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, V, H > &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, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &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 {false}
 
int m_evtNr {-1}
 
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 {}
 
std::vector< int * > m_adder
 
std::vector< int > m_adderPayload
 
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 {false}
 
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_rchUnit(TileRawChannelUnit::MegaElectronVolts)
86  , m_dspUnit(TileRawChannelUnit::ADCcounts)
87 {
88 
89  char frg[6] = "0x000";
90  m_beamFragList.clear();
91  for (unsigned int i=0; i<sizeof(m_beamIdList)/sizeof(bool); ++i) {
92  m_beamIdList[i] = false;
93  // no coins trig by default (this is the case for 2004)
94  if (i <= ECAL_ADC_FRAG || i >= COMMON_ADC1_FRAG ) {
95  sprintf(frg,"0x%3.3x",i);
96  m_beamFragList.value().push_back((std::string)frg);
97  }
98  }
99 
100 }

◆ ~TileTBAANtuple()

virtual TileTBAANtuple::~TileTBAANtuple ( )
virtualdefault

Member Function Documentation

◆ ADDER_addBranch()

void TileTBAANtuple::ADDER_addBranch ( void  )
private

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

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

Definition at line 2762 of file TileTBAANtuple.cxx.

2762  {
2763 
2764  if (m_unpackAdder) {
2765  if (m_beamIdList[ADD_FADC_FRAG]) {
2766  m_adder.resize(16);
2767  m_adderPayload.resize(16*16);
2768  for (int j = 0; j < 16; j++) {
2769  m_adder[j] = m_adderPayload.data() + j * 16;
2770  }
2771 
2772  m_ntuplePtr->Branch("Adder", *m_adder.data(), "m_adder[16][16]/I");
2773  m_ntuplePtr->Branch("EneAdd", &m_eneAdd, "m_eneAdd[16]/F");
2774  m_ntuplePtr->Branch("TimeAdd", &m_timeAdd, "m_timeAdd[16]/F");
2775  }
2776  }
2777 }

◆ ADDER_clearBranch()

void TileTBAANtuple::ADDER_clearBranch ( void  )
private

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

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

Definition at line 2785 of file TileTBAANtuple.cxx.

2786 {
2787 
2788 
2789 }

◆ BEAM_addBranch()

void TileTBAANtuple::BEAM_addBranch ( void  )
private

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

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

Definition at line 2823 of file TileTBAANtuple.cxx.

2823  {
2824 
2825  if (((m_TBperiod >= 2015 || m_unpackAdder) && m_beamIdList[BEAM_ADC_FRAG])
2826  || ((!m_unpackAdder || m_TBperiod >= 2022) && m_beamIdList[COMMON_ADC1_FRAG])) {
2827 
2828  m_ntuplePtr->Branch("S1cou", &m_s1cou, "S1cou/S");
2829  m_ntuplePtr->Branch("S2cou", &m_s2cou, "S2cou/S");
2830  if (m_TBperiod >= 2016 && m_TBperiod < 2022) {
2831  m_ntuplePtr->Branch("Cher3", &m_s3cou, "Cher3/S"); // dropped S3 in favor of Cher3 in September 2016 TB
2832  // m_ntuplePtr->Branch("SpmFinger", &m_muVeto, "SmpFinger/S"); // muVeto replaced by SPM for testing
2833  m_ntuplePtr->Branch("SiPM1", &m_muTag, "SiPM1/S"); // muTag replaced by SiPM1 for testing
2834  m_ntuplePtr->Branch("SiPM2", &m_muHalo, "SiPM2/S");// muHalo repalce by SiPM1 for testing
2835  } else {
2836  m_ntuplePtr->Branch("S3cou", &m_s3cou, "S3cou/S");
2837  }
2838 
2839  m_ntuplePtr->Branch("Cher1", &m_cher1, "Cher1/S");
2840  m_ntuplePtr->Branch("Cher2", &m_cher2, "Cher2/S");
2841  if (m_TBperiod >= 2022) {
2842  m_ntuplePtr->Branch("Cher3", &m_cher3, "Cher3/S");
2843  }
2844 
2845  if (m_TBperiod < 2015) {
2846  m_ntuplePtr->Branch("MuTag", &m_muTag, "MuTag/S");
2847  m_ntuplePtr->Branch("MuHalo", &m_muHalo, "MuHalo/S");
2848  m_ntuplePtr->Branch("MuVeto", &m_muVeto, "MuVeto/S");
2849  //} else if (m_TBperiod == 2015) {
2850  // nothing
2851  } else if (m_TBperiod >= 2016) {
2852  m_ntuplePtr->Branch("SCalo1", &m_muTag, "SCalo1/S");
2853  m_ntuplePtr->Branch("SCalo2", &m_muHalo, "SCalo2/S");
2854  //m_ntuplePtr->Branch("SCalo3", &m_muVeto, "SCalo3/S");
2855  }
2856  }
2857 
2858  if (m_TBperiod >= 2015) {
2859  if (m_beamIdList[COMMON_TDC1_FRAG] || (m_TBperiod >= 2022 && m_beamIdList[COMMON_TOF_FRAG])) {
2860  m_btdc = new std::vector<std::vector<int> >(16);
2861  m_ntuplePtr->Branch("btdc1", &m_btdc1, "m_btdc1[16]/I");
2862  m_ntuplePtr->Branch("btdc2", &m_btdc2, "m_btdc2[16]/I");
2863  m_ntuplePtr->Branch("btdc", &m_btdc);
2864  m_ntuplePtr->Branch("tjitter", &m_tjitter, "tjitter/I");
2865  m_ntuplePtr->Branch("tscTOF", &m_tscTOF, "tscTOF/I");
2866  m_ntuplePtr->Branch("btdcNhit", m_btdcNhit, "btdcNhit[16]/I");
2867  m_ntuplePtr->Branch("btdcNchMultiHit", m_btdcNchMultiHit, "btdcNchMultiHit[2]/I");
2868  }
2869  if (m_beamIdList[COMMON_TOF_FRAG]) {
2870  m_ntuplePtr->Branch("tof", &m_tof, "m_tof[16]/I");
2871  }
2872  if (m_beamIdList[COMMON_PTN_FRAG]) {
2873  m_ntuplePtr->Branch("scaler", &m_scaler, "m_scaler[16]/I");
2874  }
2875  } else if (!m_unpackAdder) {
2876  if (m_beamIdList[COMMON_ADC2_FRAG]) {
2877  m_ntuplePtr->Branch("S2extra", &m_s2extra, "S2extra/S");
2878  m_ntuplePtr->Branch("S2cou", &m_s3extra, "S3extra/S");
2879  }
2880  if (m_beamIdList[BEAM_ADC_FRAG]) {
2881  m_ntuplePtr->Branch("SC1", &m_sc1, "SC1/S");
2882  m_ntuplePtr->Branch("SC2", &m_sc2, "SC2/S");
2883  }
2884  if (m_beamIdList[COMMON_PTN_FRAG]) {
2885  m_ntuplePtr->Branch("pu", &m_commonPU, "pu/S");
2886  }
2887  if (m_beamIdList[COMMON_TOF_FRAG]) {
2888  m_ntuplePtr->Branch("tof", &m_tof, "m_tof[8]/I");
2889  }
2890  if (m_beamIdList[COMMON_TDC1_FRAG]) {
2891  m_ntuplePtr->Branch("btdc1", &m_btdc1, "m_btdc1/I");
2892  }
2893  if (m_beamIdList[COMMON_TDC2_FRAG]) {
2894  m_ntuplePtr->Branch("btdc2", &m_btdc2, "m_btdc2/I");
2895  }
2896 
2897  if (m_beamIdList[COMMON_TDC1_FRAG]) {
2898  m_ntuplePtr->Branch("XchN2", &m_xChN2, "XchN2/F");
2899  m_ntuplePtr->Branch("YchN2", &m_yChN2, "YchN2/F");
2900  m_ntuplePtr->Branch("XchN1", &m_xChN1, "XchN1/F");
2901  m_ntuplePtr->Branch("YchN1", &m_yChN1, "YchN1/F");
2902  }
2903  if (m_beamIdList[COMMON_TDC2_FRAG]) {
2904  m_ntuplePtr->Branch("Xcha0", &m_xCha0, "Xcha0/F");
2905  m_ntuplePtr->Branch("Ycha0", &m_yCha0, "Ycha0/F");
2906  }
2907  } else {
2908  if (m_beamIdList[BEAM_TDC_FRAG]) {
2909  m_ntuplePtr->Branch("btdc1", &m_btdc1, "m_btdc1[16]/I");
2910  m_ntuplePtr->Branch("btdc2", &m_btdc2, "m_btdc2[16]/I");
2911  }
2912  }
2913 
2914  if ((m_TBperiod >= 2015 && m_beamIdList[COMMON_TDC1_FRAG])
2915  || (m_unpackAdder && m_beamIdList[BEAM_TDC_FRAG])
2916  || (!m_unpackAdder && m_beamIdList[COMMON_TDC2_FRAG])
2917  || (m_TBperiod >= 2022 && m_beamIdList[COMMON_TOF_FRAG])) {
2918 
2919  m_ntuplePtr->Branch("Xcha1", &m_xCha1, "Xcha1/F");
2920  m_ntuplePtr->Branch("Ycha1", &m_yCha1, "Ycha1/F");
2921  m_ntuplePtr->Branch("Xcha2", &m_xCha2, "Xcha2/F");
2922  m_ntuplePtr->Branch("Ycha2", &m_yCha2, "Ycha2/F");
2923  m_ntuplePtr->Branch("Xcha1_0", &m_xCha1_0, "Xcha1_0/F");
2924  m_ntuplePtr->Branch("Ycha1_0", &m_yCha1_0, "Ycha1_0/F");
2925  m_ntuplePtr->Branch("Xcha2_0", &m_xCha2_0, "Xcha2_0/F");
2926  m_ntuplePtr->Branch("Ycha2_0", &m_yCha2_0, "Ycha2_0/F");
2927  m_ntuplePtr->Branch("Ximp", &m_xImp, "Ximp/F");
2928  m_ntuplePtr->Branch("Yimp", &m_yImp, "Yimp/F");
2929  m_ntuplePtr->Branch("Ximp_0", &m_xImp_0, "Ximp_0/F");
2930  m_ntuplePtr->Branch("Yimp_0", &m_yImp_0, "Yimp_0/F");
2931  m_ntuplePtr->Branch("Ximp_90", &m_xImp_90, "Ximp_90/F");
2932  m_ntuplePtr->Branch("Yimp_90", &m_yImp_90, "Yimp_90/F");
2933  m_ntuplePtr->Branch("Ximp_min90", &m_xImp_min90, "Ximp_min90/F");
2934  m_ntuplePtr->Branch("Yimp_min90", &m_yImp_min90, "Yimp_min90/F");
2935  }
2936 
2937 }

◆ BEAM_clearBranch()

void TileTBAANtuple::BEAM_clearBranch ( void  )
private

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

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

Definition at line 2945 of file TileTBAANtuple.cxx.

2945  {
2946 
2947  if ((m_unpackAdder && m_beamIdList[BEAM_ADC_FRAG])
2948  || (!m_unpackAdder && m_beamIdList[COMMON_ADC1_FRAG])) {
2949 
2950  m_s1cou = 0;
2951  m_s2cou = 0;
2952  m_s3cou = 0;
2953  m_cher1 = 0;
2954  m_cher2 = 0;
2955  m_cher3 = 0;
2956  m_muTag = 0;
2957  m_muHalo = 0;
2958  m_muVeto = 0;
2959  }
2960  if (!m_unpackAdder) {
2961  if (m_beamIdList[COMMON_ADC2_FRAG]) {
2962 
2963  m_s2extra = 0;
2964  m_s3extra = 0;
2965  }
2966  if (m_beamIdList[BEAM_ADC_FRAG]) {
2967  m_sc1 = 0;
2968  m_sc2 = 0;
2969  }
2970  if (m_beamIdList[COMMON_PTN_FRAG]) {
2971  m_commonPU = 0;
2972  }
2973  if (m_beamIdList[COMMON_TDC1_FRAG]) {
2974  m_xChN2 = 0.;
2975  m_yChN2 = 0.;
2976  m_xChN1 = 0.;
2977  m_yChN1 = 0.;
2978  }
2979  if (m_beamIdList[COMMON_TDC2_FRAG]) {
2980  m_xCha0 = 0.;
2981  m_yCha0 = 0.;
2982  }
2983  }
2984 
2985  if ((m_TBperiod >= 2015 && m_beamIdList[COMMON_TDC1_FRAG])
2986  || (m_unpackAdder && m_beamIdList[BEAM_TDC_FRAG])
2987  || (!m_unpackAdder && m_beamIdList[COMMON_TDC2_FRAG])
2988  || (m_TBperiod >= 2022 && m_beamIdList[COMMON_TOF_FRAG])) {
2989 
2990  m_xCha1 = 0.;
2991  m_yCha1 = 0.;
2992  m_xCha2 = 0.;
2993  m_yCha2 = 0.;
2994  m_xCha1_0 = 0.;
2995  m_yCha1_0 = 0.;
2996  m_xCha2_0 = 0.;
2997  m_yCha2_0 = 0.;
2998  m_xImp = 0.;
2999  m_yImp = 0.;
3000  }
3001 
3002  m_muBack.fill(0.0F);
3003 
3004  for (int i=0; i<16; i+=2) {
3005  m_tof[i] = +0xFFFF;
3006  m_tof[i+1] = -0xFFFF;
3007  }
3008 
3009  for (int i=0; i<16; i+=2) {
3010  m_btdc1[i] = +0xFFFF;
3011  m_btdc1[i+1] = -0xFFFF;
3012  }
3013 
3014  for (int i=0; i<16; i+=2) {
3015  m_btdc2[i] = +0xFFFF;
3016  m_btdc2[i+1] = -0xFFFF;
3017  }
3018 
3019  if (m_btdc) {
3020  for (std::vector<int>& btdc_amplitudes : *m_btdc) {
3021  btdc_amplitudes.clear();
3022  }
3023  }
3024 
3025  memset(&m_scaler, 0, sizeof(m_scaler));
3026 
3027  memset(m_btdcNhit,0,sizeof(m_btdcNhit));
3028  memset(m_btdcNchMultiHit,0,sizeof(m_btdcNchMultiHit));
3029 }

◆ 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 2797 of file TileTBAANtuple.cxx.

2797  {
2798 
2799  if (m_beamIdList[DIGI_PAR_FRAG & 0x1F]) {
2800 
2801  m_ntuplePtr->Branch("cispar", m_cispar, "cispar[16]/I");
2802  }
2803 }

◆ CISPAR_clearBranch()

void TileTBAANtuple::CISPAR_clearBranch ( void  )
private

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

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

Definition at line 2811 of file TileTBAANtuple.cxx.

2812 {
2813  memset(m_cispar,-1,sizeof(m_cispar));
2814 }

◆ 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 3752 of file TileTBAANtuple.cxx.

3752  {
3753  for (std::array<T,N>& arr : vec) {
3754  std::fill(arr.begin(), arr.end(), static_cast<T>(-1));
3755  }
3756 }

◆ clear_init_minus1() [2/2]

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

Definition at line 3747 of file TileTBAANtuple.cxx.

3747  {
3748  std::fill(vec.begin(), vec.end(), static_cast<T>(-1));
3749 }

◆ 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 3759 of file TileTBAANtuple.cxx.

3759  {
3760  for (std::array<T,N>& arr : vec) {
3761  std::fill(arr.begin(), arr.end(), static_cast<T>(0));
3762  }
3763 }

◆ 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 3765 of file TileTBAANtuple.cxx.

3766 {
3767  for (unsigned int i = 0; i < vec.size(); ++i) {
3768  std::fill(vec[i].get(), vec[i].get() + nsamples.at(i) * nchan, -1);
3769  }
3770 }

◆ COINCBOARD_addBranch()

void TileTBAANtuple::COINCBOARD_addBranch ( void  )
private

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

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

Definition at line 3065 of file TileTBAANtuple.cxx.

3065  {
3066  if (m_beamIdList[COIN_TRIG1_FRAG]) {
3067  m_ntuplePtr->Branch("CoincTrig1", &m_coincTrig1, "m_coincTrig1[96]/I");
3068  m_ntuplePtr->Branch("CoincFlag1", &m_coincFlag1, "CoincFlag1/I");
3069  }
3070 
3071  if (m_beamIdList[COIN_TRIG2_FRAG]) {
3072  m_ntuplePtr->Branch("CoincTrig2", &m_coincTrig2, "m_coincTrig2[96]/I");
3073  m_ntuplePtr->Branch("CoincFlag2", &m_coincFlag2, "CoincFlag2/I");
3074  }
3075 
3076  if (m_beamIdList[COIN_TRIG3_FRAG]) {
3077  m_ntuplePtr->Branch("CoincTrig3", &m_coincTrig3, "m_coincTrig3[96]/I");
3078  m_ntuplePtr->Branch("CoincFlag3", &m_coincFlag3, "CoincFlag3/I");
3079  }
3080 
3081  if (m_beamIdList[COIN_TRIG4_FRAG]) {
3082  m_ntuplePtr->Branch("CoincTrig4", &m_coincTrig4, "m_coincTrig4[96]/I");
3083  m_ntuplePtr->Branch("CoincFlag4", &m_coincFlag4, "CoincFlag4/I");
3084  }
3085  if (m_beamIdList[COIN_TRIG5_FRAG]) {
3086  m_ntuplePtr->Branch("CoincTrig5", &m_coincTrig5, "m_coincTrig5[96]/I");
3087  m_ntuplePtr->Branch("CoincFlag5", &m_coincFlag5, "CoincFlag5/I");
3088  }
3089 
3090  if (m_beamIdList[COIN_TRIG6_FRAG]) {
3091  m_ntuplePtr->Branch("CoincTrig6", &m_coincTrig6, "m_coincTrig6[96]/I");
3092  m_ntuplePtr->Branch("CoincFlag6", &m_coincFlag6, "CoincFlag6/I");
3093  }
3094 
3095  if (m_beamIdList[COIN_TRIG7_FRAG]) {
3096  m_ntuplePtr->Branch("CoincTrig7", &m_coincTrig7, "m_coincTrig7[96]/I");
3097  m_ntuplePtr->Branch("CoincFlag7", &m_coincFlag7, "CoincFlag7/I");
3098  }
3099 
3100  if (m_beamIdList[COIN_TRIG8_FRAG]) {
3101  m_ntuplePtr->Branch("CoincTrig8", &m_coincTrig8, "m_coincTrig8[96]/I");
3102  m_ntuplePtr->Branch("CoincFlag8", &m_coincFlag8, "CoincFlag8/I");
3103  }
3104 
3105 }

◆ COINCBOARD_clearBranch()

void TileTBAANtuple::COINCBOARD_clearBranch ( void  )
private

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

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

Definition at line 3113 of file TileTBAANtuple.cxx.

3114 {
3115 
3116 
3117 
3118 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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, V, H > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ 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 3126 of file TileTBAANtuple.cxx.

3127 {
3128 
3129 
3132  m_bcidVec.reserve(MAX_DRAWERS);
3133  m_DMUheaderVec.reserve(MAX_DRAWERS);
3134  m_DMUformatErrVec.reserve(MAX_DRAWERS);
3135  m_DMUparityErrVec.reserve(MAX_DRAWERS);
3136  m_DMUmemoryErrVec.reserve(MAX_DRAWERS);
3137  m_DMUDstrobeErrVec.reserve(MAX_DRAWERS);
3138  m_DMUHeadparityErrVec.reserve(MAX_DRAWERS);
3139  m_DMUDataparityErrVec.reserve(MAX_DRAWERS);
3140  m_DMUSstrobeErrVec.reserve(MAX_DRAWERS);
3141  m_dmuMaskVec.reserve(MAX_DRAWERS);
3142  m_slinkCRCVec.reserve(MAX_DRAWERS);
3143  m_gainVec.reserve(MAX_DRAWERS);
3144  m_sampleVec.reserve(MAX_DRAWERS);
3145  m_feCRCVec.reserve(MAX_DRAWERS);
3146  m_rodCRCVec.reserve(MAX_DRAWERS);
3147  m_eneVec.reserve(MAX_DRAWERS);
3148  m_timeVec.reserve(MAX_DRAWERS);
3149  m_pedFlatVec.reserve(MAX_DRAWERS);
3150  m_chi2FlatVec.reserve(MAX_DRAWERS);
3151  m_efitVec.reserve(MAX_DRAWERS);
3152  m_tfitVec.reserve(MAX_DRAWERS);
3153  m_pedfitVec.reserve(MAX_DRAWERS);
3154  m_chi2Vec.reserve(MAX_DRAWERS);
3155  m_efitcVec.reserve(MAX_DRAWERS);
3156  m_tfitcVec.reserve(MAX_DRAWERS);
3157  m_pedfitcVec.reserve(MAX_DRAWERS);
3158  m_chi2cVec.reserve(MAX_DRAWERS);
3159  m_eOptVec.reserve(MAX_DRAWERS);
3160  m_tOptVec.reserve(MAX_DRAWERS);
3161  m_pedOptVec.reserve(MAX_DRAWERS);
3162  m_chi2OptVec.reserve(MAX_DRAWERS);
3163  m_eDspVec.reserve(MAX_DRAWERS);
3164  m_tDspVec.reserve(MAX_DRAWERS);
3165  m_chi2DspVec.reserve(MAX_DRAWERS);
3166  m_ROD_GlobalCRCVec.reserve(MAX_DRAWERS);
3167  m_ROD_DMUBCIDVec.reserve(MAX_DRAWERS);
3168  m_ROD_DMUmemoryErrVec.reserve(MAX_DRAWERS);
3169  m_ROD_DMUSstrobeErrVec.reserve(MAX_DRAWERS);
3170  m_ROD_DMUDstrobeErrVec.reserve(MAX_DRAWERS);
3171  m_ROD_DMUHeadformatErrVec.reserve(MAX_DRAWERS);
3172  m_ROD_DMUDataformatErrVec.reserve(MAX_DRAWERS);
3173  m_ROD_DMUMaskVec.reserve(MAX_DRAWERS);
3174 
3175  std::ostringstream oss;
3176  oss << m_nSamples;
3177  std::string nSampStr=oss.str();
3178 
3179  unsigned int listSize = std::min(m_nDrawers.value(), static_cast<unsigned int>(m_drawerMap.size()));
3180 
3181  if (listSize > 0) {
3182 
3183  std::string digit[10] = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
3184  std::vector<std::string> suffixArr;
3185  unsigned int length;
3186  bool testbeam = TileCablingService::getInstance()->getTestBeam();
3187 
3188  if (m_calibMode) {
3189 
3190  length = 2 * m_nDrawers;
3191  suffixArr.resize(length);
3192 
3193  for (unsigned int i = 0; i < listSize; ++i) {
3194  unsigned int ros = m_drawerType[i];
3195  unsigned int drawer = strtol(m_drawerList[i].data(), NULL, 0) & 0x3F;
3196  std::string digits;
3197  if (m_TBperiod >= 2010) {
3198  ++drawer; // count modules from 1
3199  digits = digit[drawer / 10] + digit[drawer % 10];
3200  } else if (testbeam) {
3201  digits = digit[drawer & 7];
3202  } else {
3203  ++drawer; // count modules from 1
3204  digits = digit[drawer / 10] + digit[drawer % 10];
3205  }
3206 
3207  if (ros == 0) {
3208  std::string suff = m_drawerList[i];
3209  suff.replace(suff.find("0x"), 2, "");
3210  suffixArr[i] = suff + "lo";
3211  suffixArr[i + m_nDrawers] = suff + "hi";
3212  } else {
3213  suffixArr[i] = m_rosName[ros] + digits + "lo";
3214  suffixArr[i + m_nDrawers] = m_rosName[ros] + digits + "hi";
3215  }
3216  }
3217  } else {
3218 
3219  length = m_nDrawers;
3220  suffixArr.resize(length);
3221 
3222  for (unsigned int i = 0; i < listSize; ++i) {
3223  unsigned int ros = m_drawerType[i];
3224  unsigned int drawer = strtol(m_drawerList[i].data(), NULL, 0) & 0x3F;
3225  std::string digits;
3226  if (m_TBperiod >= 2010) {
3227  ++drawer; // count modules from 1
3228  digits = digit[drawer / 10] + digit[drawer % 10];
3229  } else if (testbeam) {
3230  digits = digit[drawer & 7];
3231  } else {
3232  ++drawer; // count modules from 1
3233  digits = digit[drawer / 10] + digit[drawer % 10];
3234  }
3235 
3236  if (ros == 0) {
3237  std::string suff = m_drawerList[i];
3238  suff.replace(suff.find("0x"), 2, "");
3239  suffixArr[i] = suff;
3240  } else {
3241  suffixArr[i] = m_rosName[ros] + digits;
3242  }
3243  }
3244  }
3245 
3246  m_nSamplesInDrawer.reserve(length);
3247 
3248  m_evtVec.resize(length);
3249  m_rodBCIDVec.resize(length);
3250  m_sizeVec.resize(length);
3251  m_ROD_GlobalCRCVec.resize(length);
3252 
3253  for (unsigned int i = 0; i < length; i++) {
3254 
3255  int nSamplesInDrawer(m_nSamples);
3256  int frag = std::stoi(m_drawerList[i%m_nDrawers], nullptr, 0);
3257 
3258  auto it = m_nSamplesInDrawerMap.find(frag);
3259  if (it != m_nSamplesInDrawerMap.end()) {
3260  nSamplesInDrawer = it->second;
3261  }
3262  m_nSamplesInDrawer.push_back(nSamplesInDrawer);
3263 
3264  m_bcidVec.push_back(std::array<int, MAX_DMU>()); // U
3265  m_DMUheaderVec.push_back(std::array<uint32_t, MAX_DMU>()); // U32
3266  m_DMUformatErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3267  m_DMUparityErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3268  m_DMUmemoryErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3269  m_DMUDstrobeErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3270  m_DMUSstrobeErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3271  m_DMUHeadparityErrVec.push_back(std::array<short, MAX_DMU>());
3272  m_DMUDataparityErrVec.push_back(std::array<short, MAX_DMU>());
3273 
3274  m_dmuMaskVec.push_back(std::array<int, 2>()); // U(2)
3275  m_slinkCRCVec.push_back(std::array<int, 2>()); // U(2)
3276  m_gainVec.push_back(std::array<int, MAX_CHAN>()); // U(48/96)
3277  m_sampleVec.push_back(std::make_unique<int[]>(MAX_CHAN * nSamplesInDrawer)); // U(48/96,9)
3278  m_feCRCVec.push_back(std::array<int, MAX_DMU>()); //U
3279  m_rodCRCVec.push_back(std::array<int, MAX_DMU>()); //U
3280 
3281  m_eneVec.push_back(std::array<float, MAX_CHAN>());
3282  m_timeVec.push_back(std::array<float, MAX_CHAN>());
3283  m_pedFlatVec.push_back(std::array<float, MAX_CHAN>());
3284  m_chi2FlatVec.push_back(std::array<float, MAX_CHAN>());
3285 
3286  m_efitVec.push_back(std::array<float, MAX_CHAN>());
3287  m_tfitVec.push_back(std::array<float, MAX_CHAN>());
3288  m_pedfitVec.push_back(std::array<float, MAX_CHAN>());
3289  m_chi2Vec.push_back(std::array<float, MAX_CHAN>());
3290 
3291  m_efitcVec.push_back(std::array<float, MAX_CHAN>());
3292  m_tfitcVec.push_back(std::array<float, MAX_CHAN>());
3293  m_pedfitcVec.push_back(std::array<float, MAX_CHAN>());
3294  m_chi2cVec.push_back(std::array<float, MAX_CHAN>());
3295 
3296  m_eOptVec.push_back(std::array<float, MAX_CHAN>());
3297  m_tOptVec.push_back(std::array<float, MAX_CHAN>());
3298  m_pedOptVec.push_back(std::array<float, MAX_CHAN>());
3299  m_chi2OptVec.push_back(std::array<float, MAX_CHAN>());
3300 
3301  m_eDspVec.push_back(std::array<float, MAX_CHAN>());
3302  m_tDspVec.push_back(std::array<float, MAX_CHAN>());
3303  m_chi2DspVec.push_back(std::array<float, MAX_CHAN>());
3304 
3305  m_ROD_DMUBCIDVec.push_back(std::array<short, MAX_DMU>());
3306  m_ROD_DMUmemoryErrVec.push_back(std::array<short, MAX_DMU>());
3307  m_ROD_DMUSstrobeErrVec.push_back(std::array<short, MAX_DMU>());
3308  m_ROD_DMUDstrobeErrVec.push_back(std::array<short, MAX_DMU>());
3309  m_ROD_DMUHeadformatErrVec.push_back(std::array<short, MAX_DMU>());
3310  m_ROD_DMUDataformatErrVec.push_back(std::array<short, MAX_DMU>());
3311  m_ROD_DMUMaskVec.push_back(std::array<short, 2>());
3312 
3313  if (i % m_nDrawers < listSize) {
3314 
3315  ATH_MSG_DEBUG( "Adding items for " << suffixArr[i] );
3316  // create ntuple layout
3317  if (m_bsInput) {
3318  m_ntuplePtr->Branch(("Evt"+suffixArr[i]).c_str(), &m_evtVec.data()[i], ("Evt"+suffixArr[i]+"/I").c_str()); // int
3319  m_ntuplePtr->Branch(("rodBCID"+suffixArr[i]).c_str(), &m_rodBCIDVec.data()[i], ("rodBCID"+suffixArr[i]+"/S").c_str());//int
3320  m_ntuplePtr->Branch(("Size"+suffixArr[i]).c_str(), &m_sizeVec.data()[i], ("Size"+suffixArr[i]+"/S").c_str()); // short
3321  m_ntuplePtr->Branch(("BCID"+suffixArr[i]).c_str(), &m_bcidVec.back(), ("bcid"+suffixArr[i]+"[16]/I").c_str()); // int
3322  m_ntuplePtr->Branch(("DMUheader"+suffixArr[i]).c_str(), &m_DMUheaderVec.back(), ("DMUheader"+suffixArr[i]+"[16]/i").c_str()); // uint32
3323  m_ntuplePtr->Branch(("DMUformatErr"+suffixArr[i]).c_str(), &m_DMUformatErrVec.back(), ("DMUformatErr"+suffixArr[i]+"[16]/S").c_str()); // short
3324  m_ntuplePtr->Branch(("DMUparityErr"+suffixArr[i]).c_str(), &m_DMUparityErrVec.back(), ("DMUparityErr"+suffixArr[i]+"[16]/S").c_str()); // short
3325  m_ntuplePtr->Branch(("DMUmemoryErr"+suffixArr[i]).c_str(), &m_DMUmemoryErrVec.back(), ("DMUmemoryErr"+suffixArr[i]+"[16]/S").c_str()); // short
3326  m_ntuplePtr->Branch(("DMUSstrobeErr"+suffixArr[i]).c_str(), &m_DMUSstrobeErrVec.back(), ("DMUSstrobeErr"+suffixArr[i]+"[16]/S").c_str()); // short
3327  m_ntuplePtr->Branch(("DMUDstrobeErr"+suffixArr[i]).c_str(), &m_DMUDstrobeErrVec.back(), ("DMUDstrobeErr"+suffixArr[i]+"[16]/S").c_str()); // short
3328  m_ntuplePtr->Branch(("DMUMask"+suffixArr[i]).c_str(), &m_dmuMaskVec.back(), ("dmumask"+suffixArr[i]+"[2]/I").c_str()); // int
3329  m_ntuplePtr->Branch(("SlinkCRC"+suffixArr[i]).c_str(), &m_slinkCRCVec.back(), ("crc"+suffixArr[i]+"[2]/I").c_str()); // int
3330  m_ntuplePtr->Branch(("DMUHeadparityErr"+suffixArr[i]).c_str(), &m_DMUHeadparityErrVec.back(), ("DMUHeadparityErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3331  m_ntuplePtr->Branch(("DMUDataparityErr"+suffixArr[i]).c_str(), &m_DMUDataparityErrVec.back(), ("DMUDataparityErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3332  }
3333 
3334  m_ntuplePtr->Branch(("Gain"+suffixArr[i]).c_str(),&m_gainVec.back(), ("gain"+suffixArr[i]+"[48]/I").c_str()); // int
3335 
3336  if (nSamplesInDrawer > 0) {
3337  nSampStr = std::to_string(nSamplesInDrawer);
3338  m_ntuplePtr->Branch(("Sample" + suffixArr[i]).c_str(), m_sampleVec.back().get(),
3339  ("sample" + suffixArr[i] + "[48]["+nSampStr+"]/I").c_str()); // size m_nsample and type int
3340  }
3341 
3342  if (m_bsInput) {
3343  m_ntuplePtr->Branch(("feCRC" + suffixArr[i]).c_str(), &m_feCRCVec.back(), ("fe_crc" + suffixArr[i] + "[16]/I").c_str()); // int
3344  m_ntuplePtr->Branch(("rodCRC" + suffixArr[i]).c_str(), &m_rodCRCVec.back(), ("rod_crc" + suffixArr[i] + "[16]/I").c_str()); // int
3345  }
3346 
3347  if (!m_flatRawChannelContainerKey.empty()) {
3348 
3349  m_ntuplePtr->Branch(("Ene" + suffixArr[i]).c_str(), &m_eneVec.back(), ("ene" + suffixArr[i] + "[48]/F").c_str()); // float
3350  m_ntuplePtr->Branch(("Time" + suffixArr[i]).c_str(), &m_timeVec.back(), ("time" + suffixArr[i] + "[48]/F").c_str()); // float
3351  m_ntuplePtr->Branch(("Ped" + suffixArr[i]).c_str(), &m_pedFlatVec.back(), ("pedflat" + suffixArr[i] + "[48]/F").c_str()); // float
3352  m_ntuplePtr->Branch(("Chi2ene" + suffixArr[i]).c_str(), &m_chi2FlatVec.back(), ("chiflat" + suffixArr[i] + "[48]/F").c_str()); // float
3353 
3354  }
3355 
3356  if (!m_fitRawChannelContainerKey.empty()) {
3357 
3358  m_ntuplePtr->Branch(("Efit" + suffixArr[i]).c_str(), &m_efitVec.back(), ("efit" + suffixArr[i] + "[48]/F").c_str()); // float
3359  m_ntuplePtr->Branch(("Tfit" + suffixArr[i]).c_str(), &m_tfitVec.back(), ("tfit" + suffixArr[i] + "[48]/F").c_str()); // float
3360  m_ntuplePtr->Branch(("Pedfit" + suffixArr[i]).c_str(), &m_pedfitVec.back(), ("pedfit" + suffixArr[i] + "[48]/F").c_str()); // float
3361  m_ntuplePtr->Branch(("Chi2fit" + suffixArr[i]).c_str(), &m_chi2Vec.back(), ("chifit" + suffixArr[i] + "[48]/F").c_str()); // float
3362 
3363  }
3364 
3365  if (!m_fitcRawChannelContainerKey.empty()) {
3366 
3367  m_ntuplePtr->Branch(("Efitc" + suffixArr[i]).c_str(), &m_efitcVec.back(), ("efitc" + suffixArr[i] + "[48]/F").c_str()); // float
3368  m_ntuplePtr->Branch(("Tfitc" + suffixArr[i]).c_str(), &m_tfitcVec.back(), ("tfitc" + suffixArr[i] + "[48]/F").c_str()); // float
3369  m_ntuplePtr->Branch(("Pedfitc" + suffixArr[i]).c_str(), &m_pedfitcVec.back(), ("pedfitc" + suffixArr[i] + "[48]/F").c_str()); // float
3370  m_ntuplePtr->Branch(("Chi2fitc" + suffixArr[i]).c_str(), &m_chi2cVec.back(), ("chifitc" + suffixArr[i] + "[48]/F").c_str()); // float
3371 
3372  }
3373 
3374  if (!m_optRawChannelContainerKey.empty()) {
3375 
3376  m_ntuplePtr->Branch(("Eopt"+suffixArr[i]).c_str(), &m_eOptVec.back(), ("eOpt"+suffixArr[i]+"[48]/F").c_str()); // float
3377  m_ntuplePtr->Branch(("Topt"+suffixArr[i]).c_str(), &m_tOptVec.back(), ("tOpt"+suffixArr[i]+"[48]/F").c_str()); // float
3378  m_ntuplePtr->Branch(("Pedopt"+suffixArr[i]).c_str(), &m_pedOptVec.back(), ("pedOpt"+suffixArr[i]+"[48]/F").c_str()); // float
3379  m_ntuplePtr->Branch(("Chi2opt"+suffixArr[i]).c_str(), &m_chi2OptVec.back(), ("chiOpt"+suffixArr[i]+"[48]/F").c_str()); // float
3380 
3381  }
3382 
3383  if (!m_dspRawChannelContainerKey.empty()) {
3384 
3385  m_ntuplePtr->Branch(("Edsp"+suffixArr[i]).c_str(), &m_eDspVec.back(), ("eDsp"+suffixArr[i]+"[48]/F").c_str()); // float
3386  m_ntuplePtr->Branch(("Tdsp"+suffixArr[i]).c_str(), &m_tDspVec.back(), ("tDsp"+suffixArr[i]+"[48]/F").c_str()); // float
3387  m_ntuplePtr->Branch(("Chi2dsp"+suffixArr[i]).c_str(), &m_chi2DspVec.back(), ("chiDsp"+suffixArr[i]+"[48]/F").c_str()); // float
3388  m_ntuplePtr->Branch(("ROD_GlobalCRC"+suffixArr[i]).c_str(), &m_ROD_GlobalCRCVec.data()[i], ("ROD_GlobalCRC"+suffixArr[i]+"/s").c_str()); // unsigned short
3389  m_ntuplePtr->Branch(("ROD_DMUBCID"+suffixArr[i]).c_str(), &m_ROD_DMUBCIDVec.back(), ("ROD_DMUBCID"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3390  m_ntuplePtr->Branch(("ROD_DMUmemoryErr"+suffixArr[i]).c_str(), &m_ROD_DMUmemoryErrVec.back(), ("ROD_DMUmemoryErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3391  m_ntuplePtr->Branch(("ROD_DMUSstrobeErr"+suffixArr[i]).c_str(), &m_ROD_DMUSstrobeErrVec.back(), ("ROD_DMUSstrobeErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3392  m_ntuplePtr->Branch(("ROD_DMUDstrobeErr"+suffixArr[i]).c_str(), &m_ROD_DMUDstrobeErrVec.back(), ("ROD_DMUDstrobeErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3393  m_ntuplePtr->Branch(("ROD_DMUHeadformatErr"+suffixArr[i]).c_str(), &m_ROD_DMUHeadformatErrVec.back(), ("ROD_DMUHeadformatErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3394  m_ntuplePtr->Branch(("ROD_DMUDataformatErr"+suffixArr[i]).c_str(), &m_ROD_DMUDataformatErrVec.back(), ("ROD_DMUDataformatErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3395  m_ntuplePtr->Branch(("ROD_DMUMask"+suffixArr[i]).c_str(), &m_ROD_DMUMaskVec.back(), ("ROD_DMUMask"+suffixArr[i]+"[2]/s").c_str()); // unsigned short
3396 
3397  }
3398  }
3399  }
3400  }
3401 }

◆ DIGI_clearBranch()

void TileTBAANtuple::DIGI_clearBranch ( void  )
private

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

Definition at line 3408 of file TileTBAANtuple.cxx.

3409 {
3410  clear_init_minus1(m_evtVec);
3411  clear_init_minus1(m_rodBCIDVec);
3412  clear_init_minus1(m_sizeVec);
3413 
3414  clear_init_minus1(m_bcidVec);
3415  clear_init_zero(m_DMUheaderVec);
3416  clear_init_minus1(m_DMUformatErrVec);
3417  clear_init_minus1(m_DMUparityErrVec);
3418  clear_init_minus1(m_DMUmemoryErrVec);
3419  clear_init_minus1(m_DMUDstrobeErrVec);
3420  clear_init_minus1(m_DMUSstrobeErrVec);
3421  clear_init_minus1(m_DMUDataparityErrVec);
3422  clear_init_minus1(m_DMUHeadparityErrVec);
3423 
3424  clear_init_minus1(m_ROD_GlobalCRCVec);
3425  clear_init_minus1(m_ROD_DMUBCIDVec);
3426  clear_init_minus1(m_ROD_DMUmemoryErrVec);
3427  clear_init_minus1(m_ROD_DMUSstrobeErrVec);
3428  clear_init_minus1(m_ROD_DMUDstrobeErrVec);
3429  clear_init_minus1(m_ROD_DMUHeadformatErrVec);
3430  clear_init_minus1(m_ROD_DMUDataformatErrVec);
3431  clear_init_minus1(m_ROD_DMUMaskVec);
3432 
3433  clear_init_minus1(m_dmuMaskVec);
3434  clear_init_minus1(m_slinkCRCVec);
3435  clear_init_minus1(m_gainVec);
3436  clear_samples(m_sampleVec, m_nSamplesInDrawer);
3437  clear_init_minus1(m_feCRCVec);
3438  clear_init_minus1(m_rodCRCVec);
3439 
3440  clear_init_zero(m_eneVec);
3441  clear_init_zero(m_timeVec);
3442  clear_init_zero(m_pedFlatVec);
3443  clear_init_zero(m_chi2FlatVec);
3444  clear_init_zero(m_efitVec);
3445  clear_init_zero(m_tfitVec);
3446  clear_init_zero(m_pedfitVec);
3447  clear_init_zero(m_chi2Vec);
3448  clear_init_zero(m_efitcVec);
3449  clear_init_zero(m_tfitcVec);
3450  clear_init_zero(m_pedfitcVec);
3451  clear_init_zero(m_chi2cVec);
3452  clear_init_zero(m_eOptVec);
3453  clear_init_zero(m_tOptVec);
3454  clear_init_zero(m_pedOptVec);
3455  clear_init_zero(m_chi2OptVec);
3456  clear_init_zero(m_eDspVec);
3457  clear_init_zero(m_tDspVec);
3458  clear_init_zero(m_chi2DspVec);
3459 
3460 }

◆ 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 2540 of file TileTBAANtuple.cxx.

2541 {
2542 
2543  if (m_beamIdList[ECAL_ADC_FRAG]) {
2544  m_ntuplePtr->Branch("Ecal",&m_ecal,"m_ecal[8]/F");
2545  }
2546 
2547 }

◆ ECAL_clearBranch()

void TileTBAANtuple::ECAL_clearBranch ( void  )
private

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

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

Definition at line 2606 of file TileTBAANtuple.cxx.

2607 {
2608 
2609 }

◆ ENETOTAL_addBranch()

void TileTBAANtuple::ENETOTAL_addBranch ( void  )
private

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

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

Definition at line 3037 of file TileTBAANtuple.cxx.

3038 {
3039  if (m_completeNtuple) {
3040  m_ntuplePtr->Branch("LarSmp", &m_LarEne, "m_LarEne[4]/F");
3041  m_ntuplePtr->Branch("BarSmp", &m_BarEne, "m_BarEne[3]/F");
3042  m_ntuplePtr->Branch("ExtSmp", &m_ExtEne, "m_ExtEne[3]/F");
3043  m_ntuplePtr->Branch("GapSmp", &m_GapEne, "m_GapEne[3]/F");
3044  }
3045 }

◆ ENETOTAL_clearBranch()

void TileTBAANtuple::ENETOTAL_clearBranch ( void  )
private

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

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

Definition at line 3053 of file TileTBAANtuple.cxx.

3054 {
3055 
3056 
3057 }

◆ 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 362 of file TileTBAANtuple.cxx.

362  {
363 
364  const EventContext& ctx = Gaudi::Hive::currentContext();
365  const TileDQstatus* dqStatus = (!m_dqStatusKey.empty()) ? SG::makeHandle(m_dqStatusKey, ctx).get() : nullptr;
366 
367  if (m_evtNr < 0) {
368 
369  //bool calibMode = (m_beamInfo->calibMode() == 1);
370  //if ( calibMode != m_calibMode ) {
371  // ATH_MSG_INFO( "Calib mode from data is " << calibMode );
372  // ATH_MSG_INFO( " Overwriting calib mode " );
373  // m_calibMode = calibMode;
374  //}
375 
376  if (ntuple_initialize(ctx).isFailure()) {
377  ATH_MSG_ERROR( "ntuple_initialize failed" );
378  }
379 
380  }
381 
382  m_dspFlags = 0;
383  if (ntuple_clear().isFailure()) {
384  ATH_MSG_ERROR( "ntuple_clear failed" );
385  }
386 
387  if (m_evtNr % 1000 == 0)
388  ATH_MSG_INFO( m_evtNr << " events processed so far" );
389 
390  m_run = ctx.eventID().run_number();
391  m_evt = ctx.eventID().event_number();
392 
393  //Get timestamp of the event
394  if (ctx.eventID().time_stamp() > 0) {
395  m_evTime = ctx.eventID().time_stamp();
396  }
397 
398  // store BeamElements
399  bool empty = storeBeamElements(ctx).isFailure();
400 
401  //store Laser Object
402  empty &= storeLaser(ctx).isFailure();
403 
404  if (m_drawerMap.size() > 0) {
405 
406  // store TileDigits
407  if (m_nSamples > 0) {
408  empty &= (storeDigits(ctx, m_digitsContainerKey, dqStatus).isFailure());
409  }
410  if (m_nSamplesFlx > 0) {
411  empty &= (storeDigitsFlx(ctx, m_digitsContainerFlxKey).isFailure());
412  }
413 
414  // store TileRawChannels
415  // start from DSP channels - so we can find out what is the DSP units
416  empty &= (storeRawChannels(ctx, m_dspRawChannelContainerKey, m_calibMode, &m_eDspVec, &m_tDspVec, &m_chi2DspVec, nullptr, true).isFailure());
417  empty &= (storeRawChannels(ctx, m_fitRawChannelContainerKey, m_calibMode, &m_efitVec, &m_tfitVec, &m_chi2Vec, &m_pedfitVec).isFailure());
418  empty &= (storeRawChannels(ctx, m_flxFitRawChannelContainerKey, true, &m_eflxfitVec, &m_tflxfitVec, &m_chi2flxfitVec, &m_pedflxfitVec).isFailure());
419  empty &= (storeRawChannels(ctx, m_optRawChannelContainerKey, m_calibMode, &m_eOptVec, &m_tOptVec, &m_chi2OptVec, &m_pedOptVec).isFailure());
420  empty &= (storeRawChannels(ctx, m_flxOptRawChannelContainerKey, true, &m_eflxoptVec, &m_tflxoptVec, &m_chi2flxoptVec, &m_pedflxoptVec).isFailure());
421  empty &= (storeRawChannels(ctx, m_fitcRawChannelContainerKey, m_calibMode, &m_efitcVec, &m_tfitcVec, &m_chi2cVec, &m_pedfitcVec).isFailure());
422  empty &= (storeRawChannels(ctx, m_flatRawChannelContainerKey, m_calibMode, &m_eneVec, &m_timeVec, &m_chi2FlatVec, &m_pedFlatVec).isFailure());
423 
424  empty &= (storeHitVector(ctx).isFailure());
425  empty &= (storeHitContainer(ctx).isFailure());
426  }
427 
428 
429  if (m_completeNtuple && m_TBperiod < 2015) {
430  // store energy per sampling from all calorimeters
431  empty &= (storeCells(ctx).isFailure());
432  }
433 
434  // increase event nr
435  // this number can be different from real event number if we skip events
436 
437  if (empty) {
438  ATH_MSG_WARNING( "Error in execute " );
439  }
440 
441  m_ntuplePtr->Fill();
442 
443  ++m_evtNr;
444 
445  // Execution completed.
446  ATH_MSG_DEBUG( "execute() completed successfully" );
447 
448  return StatusCode::SUCCESS;
449 }

◆ 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 3463 of file TileTBAANtuple.cxx.

3464 {
3465 
3466  m_rodBCIDflxVec.reserve(MAX_DRAWERS);
3467  m_sizeflxVec.reserve(MAX_DRAWERS);
3468  m_evtflxVec.reserve(MAX_DRAWERS);
3469 
3470  m_eflxfitVec.reserve(MAX_DRAWERS);
3471  m_tflxfitVec.reserve(MAX_DRAWERS);
3472  m_chi2flxfitVec.reserve(MAX_DRAWERS);
3473  m_pedflxfitVec.reserve(MAX_DRAWERS);
3474  m_eflxoptVec.reserve(MAX_DRAWERS);
3475  m_tflxoptVec.reserve(MAX_DRAWERS);
3476  m_chi2flxoptVec.reserve(MAX_DRAWERS);
3477  m_pedflxoptVec.reserve(MAX_DRAWERS);
3478  m_gainflxVec.reserve(MAX_DRAWERS);
3479  m_sampleflxVec.reserve(MAX_DRAWERS);
3480 
3481  m_mdL1idflxVec.reserve(MAX_DRAWERS);
3482  m_mdBcidflxVec.reserve(MAX_DRAWERS);
3483  m_mdModuleflxVec.reserve(MAX_DRAWERS);
3484  m_mdRunTypeflxVec.reserve(MAX_DRAWERS);
3485  m_mdPedLoflxVec.reserve(MAX_DRAWERS);
3486  m_mdPedHiflxVec.reserve(MAX_DRAWERS);
3487  m_mdRunflxVec.reserve(MAX_DRAWERS);
3488  m_mdChargeflxVec.reserve(MAX_DRAWERS);
3489  m_mdChargeTimeflxVec.reserve(MAX_DRAWERS);
3490  m_mdCapacitorflxVec.reserve(MAX_DRAWERS);
3491 
3492  std::string nSampStrFlx = std::to_string(m_nSamplesFlx);
3493  unsigned int listSize = std::min(m_nDrawersFlx.value(), static_cast<unsigned int>(m_drawerFlxMap.size()));
3494 
3495  bool testbeam = TileCablingService::getInstance()->getTestBeam();
3496  std::vector<std::string> moduleNames(m_nDrawersFlx, "");
3497  unsigned int length = 2 * m_nDrawersFlx;
3498  std::vector<std::string> suffixArr(length, "");
3499  m_nSamplesFlxInDrawer.resize(length);
3500 
3501  for (const std::pair<const unsigned int, unsigned int>& fragAndDrawer : m_drawerFlxMap) {
3502  unsigned int frag = fragAndDrawer.first;
3503  unsigned int ros = frag >> 8;
3504  unsigned int drawer = frag & 0x3F;
3505  unsigned int drawerIndex = fragAndDrawer.second;
3506 
3507  std::ostringstream drawerName;
3508  drawerName << m_rosName[ros];
3509  if (testbeam) {
3510  drawerName << (drawer & 7);
3511  } else {
3512  ++drawer; // count modules from 1
3513  drawerName << std::setw(2) << std::setfill('0') << drawer;
3514  }
3515 
3516  moduleNames.at(drawerIndex) = drawerName.str();
3517  suffixArr.at(drawerIndex) = drawerName.str() + "lo";
3518  suffixArr.at(drawerIndex + m_nDrawersFlx) = drawerName.str() + "hi";
3519 
3520  int nSamples(m_nSamplesFlx);
3521  auto it = m_nSamplesFlxInDrawerMap.find(frag);
3522  if (it != m_nSamplesFlxInDrawerMap.end()) {
3523  nSamples = it->second;
3524  }
3525 
3526  m_nSamplesFlxInDrawer[drawerIndex] = nSamples;
3527  m_nSamplesFlxInDrawer[drawerIndex + m_nDrawersFlx] = nSamples;
3528  }
3529 
3530  m_rodBCIDflxVec.resize(m_nDrawersFlx);
3531  m_sizeflxVec.resize(m_nDrawersFlx);
3532  m_evtflxVec.resize(m_nDrawersFlx);
3533 
3534  for (unsigned int i = 0; i < length; ++i) {
3535 
3536  int nSamplesInDrawer = m_nSamplesFlxInDrawer[i];
3537 
3538  m_eflxfitVec.push_back(std::array<float, MAX_CHAN>());
3539  m_tflxfitVec.push_back(std::array<float, MAX_CHAN>());
3540  m_pedflxfitVec.push_back(std::array<float, MAX_CHAN>());
3541  m_chi2flxfitVec.push_back(std::array<float, MAX_CHAN>());
3542 
3543  m_eflxoptVec.push_back(std::array<float, MAX_CHAN>());
3544  m_tflxoptVec.push_back(std::array<float, MAX_CHAN>());
3545  m_pedflxoptVec.push_back(std::array<float, MAX_CHAN>());
3546  m_chi2flxoptVec.push_back(std::array<float, MAX_CHAN>());
3547 
3548  if (i < m_nDrawersFlx) {
3549  m_mdL1idflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3550  m_mdBcidflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3551  m_mdModuleflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3552  m_mdRunTypeflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3553  m_mdPedLoflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3554  m_mdPedHiflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3555  m_mdRunflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3556  m_mdChargeflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3557  m_mdChargeTimeflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3558  m_mdCapacitorflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3559 
3560  std::string suffix = moduleNames[i];
3561  ATH_MSG_DEBUG( "Adding items for " << suffix );
3562 
3563  if (m_bsInput) {
3564  m_ntuplePtr->Branch(("FlxEvt"+suffix).c_str(), &m_evtflxVec.data()[i]); // int
3565  m_ntuplePtr->Branch(("FlxRodBCID"+suffix).c_str(), &m_rodBCIDflxVec.data()[i]);//int
3566  m_ntuplePtr->Branch(("FlxSize"+suffix).c_str(), &m_sizeflxVec.data()[i]); // short
3567  }
3568 
3569  m_ntuplePtr->Branch(("FlxL1ID"+suffix).c_str(), &m_mdL1idflxVec.back()); // int
3570  m_ntuplePtr->Branch(("FlxBCID"+suffix).c_str(), &m_mdBcidflxVec.back()); // int
3571  m_ntuplePtr->Branch(("FlxModule"+suffix).c_str(), &m_mdModuleflxVec.back()); // int
3572  m_ntuplePtr->Branch(("FlxRun"+suffix).c_str(), &m_mdRunflxVec.back()); // int
3573  m_ntuplePtr->Branch(("FlxRunType"+suffix).c_str(), &m_mdRunTypeflxVec.back()); // int
3574  m_ntuplePtr->Branch(("FlxPedLo"+suffix).c_str(), &m_mdPedLoflxVec.back()); // int
3575  m_ntuplePtr->Branch(("FlxPedHi"+suffix).c_str(), &m_mdPedHiflxVec.back()); // int
3576  m_ntuplePtr->Branch(("FlxCharge"+suffix).c_str(), &m_mdChargeflxVec.back()); // int
3577  m_ntuplePtr->Branch(("FlxChargeTime"+suffix).c_str(), &m_mdChargeTimeflxVec.back()); // int
3578  m_ntuplePtr->Branch(("FlxCapacitor"+suffix).c_str(), &m_mdCapacitorflxVec.back()); // int
3579 
3580  }
3581 
3582  m_gainflxVec.push_back(std::array<int, MAX_CHAN>());
3583  m_sampleflxVec.push_back(std::make_unique<int[]>(MAX_CHAN * nSamplesInDrawer)); // U(48/96,9)
3584 
3585  if (i % m_nDrawersFlx < listSize) {
3586  ATH_MSG_DEBUG( "Adding items for " << suffixArr[i] );
3587 
3588  m_ntuplePtr->Branch(("FlxGain"+suffixArr[i]).c_str(), &m_gainflxVec.back()); // int
3589 
3590  if (nSamplesInDrawer > 0) {
3591  nSampStrFlx = std::to_string(nSamplesInDrawer);
3592  m_ntuplePtr->Branch(("FlxSample" + suffixArr[i]).c_str(), m_sampleflxVec.back().get(),
3593  ("Flxsample" + suffixArr[i] + "[48]["+nSampStrFlx+"]/I").c_str()); // size m_nsample and type int
3594  }
3595 
3596  if (!m_flxFitRawChannelContainerKey.empty()) {
3597  m_ntuplePtr->Branch(("FlxEfit" + suffixArr[i]).c_str(), &m_eflxfitVec.back()); // float
3598  m_ntuplePtr->Branch(("FlxTfit" + suffixArr[i]).c_str(), &m_tflxfitVec.back()); // float
3599  m_ntuplePtr->Branch(("FlxPedfit" + suffixArr[i]).c_str(), &m_pedflxfitVec.back()); // float
3600  m_ntuplePtr->Branch(("FlxChi2fit" + suffixArr[i]).c_str(), &m_chi2flxfitVec.back()); // float
3601  }
3602 
3603  if (!m_flxOptRawChannelContainerKey.empty()) {
3604  m_ntuplePtr->Branch(("FlxEOpt" + suffixArr[i]).c_str(), &m_eflxoptVec.back()); // float
3605  m_ntuplePtr->Branch(("FlxTOpt" + suffixArr[i]).c_str(), &m_tflxoptVec.back()); // float
3606  m_ntuplePtr->Branch(("FlxPedOpt" + suffixArr[i]).c_str(), &m_pedflxoptVec.back()); // float
3607  m_ntuplePtr->Branch(("FlxChi2Opt" + suffixArr[i]).c_str(), &m_chi2flxoptVec.back()); // float
3608  }
3609  }
3610  }
3611 }

◆ FELIX_clearBranch()

void TileTBAANtuple::FELIX_clearBranch ( void  )
private

Definition at line 3615 of file TileTBAANtuple.cxx.

3616 {
3617  clear_init_minus1(m_evtflxVec);
3618  clear_init_minus1(m_rodBCIDflxVec);
3619  clear_init_minus1(m_sizeflxVec);
3620 
3621  clear_init_minus1(m_gainflxVec);
3622  clear_samples(m_sampleflxVec, m_nSamplesFlxInDrawer);
3623 
3624  clear_init_zero(m_eflxfitVec);
3625  clear_init_zero(m_tflxfitVec );
3626  clear_init_zero(m_chi2flxfitVec);
3627  clear_init_zero(m_pedflxfitVec);
3628 
3629  clear_init_zero(m_eflxoptVec);
3630  clear_init_zero(m_tflxoptVec);
3631  clear_init_zero(m_chi2flxoptVec);
3632  clear_init_zero(m_pedflxoptVec);
3633 
3634  clear_init_minus1(m_mdL1idflxVec);
3635  clear_init_minus1(m_mdBcidflxVec);
3636  clear_init_minus1(m_mdModuleflxVec);
3637  clear_init_minus1(m_mdRunTypeflxVec);
3638  clear_init_minus1(m_mdRunflxVec);
3639  clear_init_minus1(m_mdChargeflxVec);
3640  clear_init_minus1(m_mdChargeTimeflxVec);
3641  clear_init_minus1(m_mdCapacitorflxVec);
3642  clear_init_minus1(m_mdPedLoflxVec);
3643  clear_init_minus1(m_mdPedHiflxVec);
3644 }

◆ getEta()

void TileTBAANtuple::getEta ( void  )
private

Definition at line 2397 of file TileTBAANtuple.cxx.

2397  {
2398 
2399  // Get eta from an ASCII file with the following structure :
2400  // runnumber eta
2401 
2402  ATH_MSG_INFO( "Get eta for run " << m_runNumber );
2403 
2404  // Find the full path to filename:
2405  std::string fileName = PathResolver::find_file(m_etaFileName, "DATAPATH");
2406  ATH_MSG_INFO( "Reading file " << fileName );
2407 
2408  if (fileName.size() == 0) {
2409 
2410  ATH_MSG_WARNING( "Could not find input file " << m_etaFileName );
2411  ATH_MSG_WARNING( "Skip reading of eta value " );
2412 
2413  } else {
2414 
2415  std::ifstream etafile;
2416  etafile.open(fileName.c_str());
2417 
2418  if (etafile.good()) {
2419 
2420  int runNumber = 0;
2421  float eta = 0;
2422  while ((runNumber != m_runNumber) && (!etafile.eof())) {
2423  etafile >> runNumber >> eta;
2424  }
2425 
2426  if (runNumber != m_runNumber) {
2427  ATH_MSG_INFO( "Run " << m_runNumber << " has not been found, keep eta and theta at zero" );
2428 
2429  m_eta = m_theta = 0.0;
2430  } else {
2431  m_eta = eta;
2432  m_theta = (M_PI_2 - 2 * atan(exp(m_eta)));
2433  ATH_MSG_INFO( "Run " << m_runNumber << " has been found with eta=" << m_eta << ", theta =" << m_theta );
2434 
2435  }
2436 
2437  } else {
2438 
2439  ATH_MSG_WARNING( "Problem with file " << fileName );
2440  ATH_MSG_WARNING( "Skip reading of eta value " );
2441 
2442  }
2443 
2444  etafile.close();
2445  }
2446 }

◆ HIT_addBranch()

void TileTBAANtuple::HIT_addBranch ( void  )
private

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

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

Definition at line 3652 of file TileTBAANtuple.cxx.

3653 {
3654  m_ehitVec.clear();
3655  m_thitVec.clear();
3656  m_ehitCnt.clear();
3657  m_thitCnt.clear();
3658 
3659  m_ehitVec.reserve(MAX_DRAWERS);
3660  m_thitVec.reserve(MAX_DRAWERS);
3661  m_ehitCnt.reserve(MAX_DRAWERS);
3662  m_thitCnt.reserve(MAX_DRAWERS);
3663 
3664  unsigned int listSize = std::min(m_nDrawers.value(), static_cast<unsigned int>(m_drawerMap.size()));
3665 
3666  if (listSize > 0) {
3667 
3668  std::string digit[10] = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
3669  std::vector<std::string> suffixArr;
3670  unsigned int length;
3671  bool testbeam = TileCablingService::getInstance()->getTestBeam();
3672 
3673  length = m_nDrawers;
3674  suffixArr.resize(length);
3675 
3676  for (unsigned int i = 0; i < listSize; ++i) {
3677  unsigned int ros = m_drawerType[i];
3678  unsigned int drawer = strtol(m_drawerList[i].data(), NULL, 0) & 0x3F;
3679  std::string digits;
3680  if (m_TBperiod >= 2010) {
3681  ++drawer; // count modules from 1
3682  digits = digit[drawer / 10] + digit[drawer % 10];
3683  } else if (testbeam) {
3684  digits = digit[drawer & 7];
3685  } else {
3686  ++drawer; // count modules from 1
3687  digits = digit[drawer / 10] + digit[drawer % 10];
3688  }
3689 
3690  if (ros == 0) {
3691  std::string suff = m_drawerList[i];
3692  suff.replace(suff.find("0x"), 2, "");
3693  suffixArr[i] = suff;
3694  } else {
3695  suffixArr[i] = m_rosName[ros] + digits;
3696  }
3697  }
3698 
3699  for (unsigned int i = 0; i < length; i++) {
3700 
3701  if (i % m_nDrawers < listSize)
3702  ATH_MSG_DEBUG( "Adding items for " << suffixArr[i] );
3703 
3704  m_ehitVec.push_back(std::array<float, MAX_CHAN>());
3705  m_thitVec.push_back(std::array<float, MAX_CHAN>());
3706  m_ehitCnt.push_back(std::array<float, MAX_CHAN>());
3707  m_thitCnt.push_back(std::array<float, MAX_CHAN>());
3708 
3709  if (i%m_nDrawers < listSize) {
3710 
3711  if (!m_hitVectorKey.empty()) {
3712 
3713  if (i % m_nDrawers < listSize)
3714  ATH_MSG_DEBUG( "Adding G4 hit info for " << suffixArr[i] );
3715 
3716  m_ntuplePtr->Branch(("EhitG4"+suffixArr[i]).c_str(),&m_ehitVec.back(),("eHitG4"+suffixArr[i]+"[48]/F").c_str());
3717  m_ntuplePtr->Branch(("ThitG4"+suffixArr[i]).c_str(),&m_thitVec.back(),("tHitG4"+suffixArr[i]+"[48]/F").c_str());
3718  }
3719 
3720  if (!m_hitContainerKey.empty()) {
3721 
3722  if (i % m_nDrawers < listSize)
3723  ATH_MSG_DEBUG( "Adding G4 corrected hit info for " << suffixArr[i] );
3724 
3725  m_ntuplePtr->Branch(("EhitSim"+suffixArr[i]).c_str(),&m_ehitCnt.back(),("eHitSim"+suffixArr[i]+"[48]/F").c_str());
3726  m_ntuplePtr->Branch(("ThitSim"+suffixArr[i]).c_str(),&m_thitCnt.back(),("tHitSim"+suffixArr[i]+"[48]/F").c_str());
3727  }
3728  }
3729  }
3730  }
3731 }

◆ HIT_clearBranch()

void TileTBAANtuple::HIT_clearBranch ( void  )
private

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

Definition at line 3738 of file TileTBAANtuple.cxx.

3739 {
3740  clear_init_zero(m_ehitVec);
3741  clear_init_zero(m_thitVec);
3742  clear_init_zero(m_ehitCnt);
3743  clear_init_zero(m_thitCnt);
3744 }

◆ initialize()

StatusCode TileTBAANtuple::initialize ( )
overridevirtual

Definition at line 102 of file TileTBAANtuple.cxx.

102  {
103  ATH_CHECK( m_samplingFractionKey.initialize(SG::AllowEmpty) );
104  m_saveFelixData = !(m_digitsContainerFlxKey.empty() && m_flxOptRawChannelContainerKey.empty() && m_flxFitRawChannelContainerKey.empty());
105 
106  ATH_CHECK( m_digitsContainerKey.initialize(SG::AllowEmpty) );
107  ATH_CHECK( m_digitsContainerFlxKey.initialize(SG::AllowEmpty) );
108  ATH_CHECK( m_beamElemContainerKey.initialize(SG::AllowEmpty) );
109  ATH_CHECK( m_flatRawChannelContainerKey.initialize(SG::AllowEmpty) );
110  ATH_CHECK( m_fitRawChannelContainerKey.initialize(SG::AllowEmpty) );
111  ATH_CHECK( m_optRawChannelContainerKey.initialize(SG::AllowEmpty) );
112  ATH_CHECK( m_dspRawChannelContainerKey.initialize(SG::AllowEmpty) );
113  ATH_CHECK( m_fitcRawChannelContainerKey.initialize(SG::AllowEmpty) );
114  ATH_CHECK( m_flxFitRawChannelContainerKey.initialize(SG::AllowEmpty) );
115  ATH_CHECK( m_flxOptRawChannelContainerKey.initialize(SG::AllowEmpty) );
116  ATH_CHECK( m_laserObjectKey.initialize(SG::AllowEmpty) );
117  ATH_CHECK( m_hitContainerKey.initialize(SG::AllowEmpty) );
118  ATH_CHECK( m_hitVectorKey.initialize(SG::AllowEmpty) );
119  ATH_CHECK( m_cellContainerKey.initialize(!m_cellContainerKey.empty() && m_completeNtuple && m_TBperiod < 2015) );
120 
121  ATH_CHECK( m_tileToolEmscale.retrieve() );
122  ATH_CHECK( m_adderFilterAlgTool.retrieve(EnableTool{m_unpackAdder}) );
123 
124  ATH_CHECK( m_dqStatusKey.initialize(SG::AllowEmpty) );
125 
126  return StatusCode::SUCCESS;
127 }

◆ initList()

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

Definition at line 2189 of file TileTBAANtuple.cxx.

2189  {
2190 
2191  unsigned int size = m_drawerList.size();
2192 
2193  if (size > 0) {
2194 
2195  if (m_digitsContainerKey.empty()) { // empty name, nothing to do
2196 
2197  ATH_MSG_WARNING( "can't retrieve Digits from TDS" );
2198  ATH_MSG_WARNING( "can't set up fragment list for ntuple" );
2199 
2200  if (m_nSamples != 0) {
2201  ATH_MSG_WARNING( "Disable digit samples in ntuple" );
2202  m_nSamples = 0;
2203  }
2204 
2205  return StatusCode::SUCCESS;
2206  }
2207 
2208  // Read Digits from TES
2209  const TileDigitsContainer* digitsCnt = SG::makeHandle (m_digitsContainerKey, ctx).get();
2210 
2211  int frag = strtol(m_drawerList[0].data(), NULL, 0);
2212  if (frag < 0) { // setup frags IDs from the data
2213 
2214  std::vector<unsigned int> frags;
2215  // Go through all TileDigitsCollections
2216  for (const TileDigitsCollection* digitsCollection : *digitsCnt) {
2217  if (!digitsCollection->empty()) {
2218  // determine type of frag
2219  frags.push_back(digitsCollection->identify());
2220  }
2221  }
2222  size = frags.size();
2223 
2224  if (size > 0) {
2225 
2226  if (size < m_nDrawers) {
2227  ATH_MSG_INFO( "decreasing m_nDrawers from " << m_nDrawers << " to " << size );
2228  m_nDrawers = size;
2229  }
2230 
2231  unsigned int rosOrder[5] = { 2, 1, 3, 4, 0 };
2232  unsigned int dr = 0;
2233  char frg[6] = "0x000";
2234 
2235  m_drawerList.clear();
2236  // m_drawerType.clear();
2237  m_drawerMap.clear();
2238 
2239  msg(MSG::INFO) << "setting drawerList from data " << MSG::hex;
2240  for (unsigned int ir = 0; ir < 5; ++ir) {
2241  for (unsigned int i = 0; i < size; ++i) {
2242  unsigned int frag = frags[i];
2243  if (frag >> 8 == rosOrder[ir]) {
2244  sprintf(frg, "0x%3.3x", frag);
2245  m_drawerList.value().push_back((std::string) frg);
2246  if (dr == m_drawerType.size()) m_drawerType.value().push_back(frag >> 8);
2247  m_drawerMap[frag] = dr;
2248  msg(MSG::INFO) << " 0x" << frag;
2249  ++dr;
2250  }
2251  }
2252  }
2253 
2254  msg(MSG::INFO) << MSG::dec << endmsg;
2255 
2256  size = m_drawerType.size();
2257  if (size < m_nDrawers) {
2258  m_drawerType.value().resize(m_nDrawers);
2259  for (; size < m_nDrawers; ++size)
2260  m_drawerType[size] = 0;
2261  }
2262 
2263  msg(MSG::INFO) << MSG::INFO << "drawerType ";
2264  for (unsigned int dr = 0; dr < size; ++dr)
2265  msg(MSG::INFO) << " " << m_drawerType[dr];
2266  msg(MSG::INFO) << endmsg;
2267 
2268  if (size > m_nDrawers) {
2269  ATH_MSG_INFO( "increasing m_nDrawers from " << m_nDrawers << " to " << size );
2270  m_nDrawers = size;
2271  }
2272 
2273  if (size < 1) size = 1;
2274  if (m_eventsPerFile == 0) {
2275  m_eventsPerFile = static_cast<int>(200 / size) * 1000;
2276  ATH_MSG_INFO( "Number of events per file was 0, set it to 200k/" << size << " = " << m_eventsPerFile );
2277  }
2278 
2279  } else {
2280 
2281  ATH_MSG_ERROR( "can't find any TileDigits collections" );
2282  ATH_MSG_ERROR( "can't set up fragment list for ntuple" );
2283  }
2284  }
2285 
2286  // once again - check number of samples in the data
2287  // but do not print any ERRORs now
2288 
2289  // Go through all TileDigitsCollections
2290  for (const TileDigitsCollection* digitsCollection : *digitsCnt) {
2291  if (!digitsCollection->empty()) {
2292  int siz = digitsCollection->front()->samples().size();
2293  m_nSamplesInDrawerMap[digitsCollection->identify()] = siz;
2294  if (siz > m_nSamples && m_nSamples != 0) {
2295  ATH_MSG_WARNING( "Increasing number of digit samples in ntuple from " << m_nSamples << " to " << siz );
2296  m_nSamples = siz;
2297  }
2298  }
2299  }
2300  }
2301 
2302  return StatusCode::SUCCESS;
2303 }

◆ initListFlx()

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

Definition at line 2306 of file TileTBAANtuple.cxx.

2306  {
2307 
2308  unsigned int listSize = m_drawerList.size();
2309 
2310  if (listSize > 0) {
2311 
2312  if (m_digitsContainerFlxKey.empty()) { // empty name, nothing to do
2313 
2314  ATH_MSG_WARNING( "can't retrieve FELIX Digits from TDS" );
2315  ATH_MSG_WARNING( "can't set up FELIX fragment list for ntuple" );
2316 
2317  if (m_nSamples != 0) {
2318  ATH_MSG_WARNING( "Disable FELIX digit samples in ntuple" );
2319  m_nSamplesFlx = 0;
2320  }
2321 
2322  return StatusCode::SUCCESS;
2323  }
2324 
2325  // Read Digits from TES
2326  const TileDigitsContainer* digitsCntFlx = SG::makeHandle (m_digitsContainerFlxKey, ctx).get();
2327 
2328  if (listSize == m_nDrawers) {
2329  // Only legacy drawers in the list, setup FELIX frags IDs from the data
2330 
2331  std::vector<unsigned int> frags;
2332  // Go through all TileDigitsCollections
2333  for (const TileDigitsCollection* digitsCollection : *digitsCntFlx) {
2334  if (!digitsCollection->empty()) {
2335  // Determine type of frag
2336  frags.push_back(digitsCollection->identify());
2337  }
2338  }
2339 
2340  unsigned int nFrags = frags.size();
2341 
2342  if (nFrags > 0) {
2343 
2344  if (nFrags != m_nDrawersFlx) {
2345  ATH_MSG_INFO( "changing m_nDrawersFlx from " << m_nDrawersFlx.value() << " to " << nFrags );
2346  m_nDrawersFlx = nFrags;
2347  }
2348 
2349  m_drawerFlxMap.clear();
2350 
2351  std::ostringstream os;
2352  os << "setting FELIX drawers from data " << std::hex;
2353  unsigned int drawerIndex = 0;
2354  for (unsigned int frag : frags) {
2355  m_drawerFlxMap[frag] = drawerIndex;
2356  os << " 0x" << frag;
2357  ++drawerIndex;
2358  }
2359  os << std::dec;
2360 
2361  ATH_MSG_INFO(os.str());
2362 
2363  if (m_eventsPerFile == 0) {
2364  int nDrawersAll = m_nDrawers.value() + m_nDrawersFlx.value();
2365  m_eventsPerFile = static_cast<int>(200 / nDrawersAll) * 1000;
2366  ATH_MSG_INFO( "Number of events per file was 0, set it to 200k/" << nDrawersAll << " = " << m_eventsPerFile );
2367  }
2368 
2369  } else {
2370  ATH_MSG_ERROR( "can't find any FELIX TileDigits collections" );
2371  ATH_MSG_ERROR( "can't set up FELIX fragment list for ntuple" );
2372  }
2373  }
2374 
2375 
2376  // once again - check number of samples in the data
2377  // but do not print any ERRORs now
2378 
2379  for (const TileDigitsCollection* digitsCollection : *digitsCntFlx) {
2380  if (!digitsCollection->empty()) {
2381  int siz = digitsCollection->front()->samples().size();
2382  m_nSamplesFlxInDrawerMap[digitsCollection->identify()] = siz;
2383  if (siz > m_nSamplesFlx && m_nSamplesFlx != 0) {
2384  ATH_MSG_WARNING( "Increasing number of FELIX digit samples in ntuple from " << m_nSamplesFlx << " to " << siz );
2385  m_nSamplesFlx = siz;
2386  }
2387  }
2388  }
2389  }
2390 
2391  return StatusCode::SUCCESS;
2392 }

◆ initNTuple()

StatusCode TileTBAANtuple::initNTuple ( void  )
private

Definition at line 2020 of file TileTBAANtuple.cxx.

2020  {
2021  MsgStream log(msgSvc(), name());
2022 
2023  m_evtVec.clear();
2024  m_bcidVec.clear();
2025  m_DMUheaderVec.clear();
2026  m_DMUformatErrVec.clear();
2027  m_DMUparityErrVec.clear();
2028  m_DMUmemoryErrVec.clear();
2029  m_DMUDstrobeErrVec.clear();
2030  m_DMUSstrobeErrVec.clear();
2031  m_DMUHeadparityErrVec.clear();
2032  m_DMUDataparityErrVec.clear();
2033  m_rodBCIDVec.clear();
2034  m_sizeVec.clear();
2035  m_dmuMaskVec.clear();
2036  m_slinkCRCVec.clear();
2037  m_gainVec.clear();
2038  m_sampleVec.clear();
2039  m_feCRCVec.clear();
2040  m_rodCRCVec.clear();
2041 
2042  m_evtflxVec.clear();
2043  m_rodBCIDflxVec.clear();
2044  m_sizeflxVec.clear();
2045  m_gainflxVec.clear();
2046  m_sampleflxVec.clear();
2047 
2048  m_eneVec.clear();
2049  m_timeVec.clear();
2050  m_pedFlatVec.clear();
2051  m_chi2FlatVec.clear();
2052 
2053  m_efitVec.clear();
2054  m_tfitVec.clear();
2055  m_pedfitVec.clear();
2056  m_chi2Vec.clear();
2057 
2058  m_efitcVec.clear();
2059  m_tfitcVec.clear();
2060  m_pedfitcVec.clear();
2061  m_chi2cVec.clear();
2062 
2063  m_eOptVec.clear();
2064  m_tOptVec.clear();
2065  m_pedOptVec.clear();
2066  m_chi2OptVec.clear();
2067 
2068  m_eflxfitVec.clear();
2069  m_tflxfitVec.clear();
2070  m_pedflxfitVec.clear();
2071  m_chi2flxfitVec.clear();
2072 
2073  m_eflxoptVec.clear();
2074  m_tflxoptVec.clear();
2075  m_pedflxoptVec.clear();
2076  m_chi2flxoptVec.clear();
2077 
2078  m_eDspVec.clear();
2079  m_tDspVec.clear();
2080  m_chi2DspVec.clear();
2081 
2082  m_ROD_GlobalCRCVec.clear();
2083  m_ROD_DMUBCIDVec.clear();
2084  m_ROD_DMUmemoryErrVec.clear();
2085  m_ROD_DMUSstrobeErrVec.clear();
2086  m_ROD_DMUDstrobeErrVec.clear();
2087  m_ROD_DMUHeadformatErrVec.clear();
2088  m_ROD_DMUDataformatErrVec.clear();
2089  m_ROD_DMUMaskVec.clear();
2090 
2091  //Ntuple creation
2092 
2093  auto tree = std::make_unique<TTree>(m_ntupleID.value().c_str(), "TileBEAM-Ntuple");
2094  tree->SetMaxTreeSize(m_treeSize);
2095  m_ntuplePtr = tree.get();
2096  if (m_thistSvc->regTree("/" + m_streamName + "/" + m_ntupleID, std::move(tree)).isFailure()) {
2097  ATH_MSG_ERROR( "Problem registering TileRec Tree" );
2098  m_ntupleCreated = false;
2099  } else {
2100  m_ntupleCreated = true;
2101  }
2102 
2103  TRIGGER_addBranch();
2104  MUON_addBranch();
2105 
2106  if (m_TBperiod < 2015) {
2107  ECAL_addBranch();
2108  LASER_addBranch();
2109  ADDER_addBranch();
2110  ENETOTAL_addBranch();
2111  COINCBOARD_addBranch();
2112  }
2113 
2114  if (m_TBperiod > 2015) {
2115  QDC_addBranch();
2116  }
2117 
2118  CISPAR_addBranch();
2119  BEAM_addBranch();
2120  DIGI_addBranch(); //working now
2121  if (m_saveFelixData) {
2122  FELIX_addBranch();
2123  }
2124 
2125  HIT_addBranch();
2126 
2127  return StatusCode::SUCCESS;
2128 }

◆ 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 2629 of file TileTBAANtuple.cxx.

2629  {
2630 
2631  if (!m_laserObjectKey.empty() > 0) {
2632 
2633  m_ntuplePtr->Branch("LASER_BCID", &m_las_BCID, "LASER_BCID/I");
2634 
2635  m_ntuplePtr->Branch("LASER_FILTER", &m_las_Filt, "LASER_FILTER/I");
2636  m_ntuplePtr->Branch("LASER_REQAMP", &m_las_ReqAmp, "LASER_REQAMP/D");
2637  m_ntuplePtr->Branch("LASER_MEASAMP", &m_las_MeasAmp, "LASER_MEASAMP/D");
2638 
2639  m_ntuplePtr->Branch("LASER_Diode_1_ADC", &m_las_D1_ADC, "LASER_Diode_1_ADC/I");
2640  m_ntuplePtr->Branch("LASER_Diode_2_ADC", &m_las_D2_ADC, "LASER_Diode_2_ADC/I");
2641  m_ntuplePtr->Branch("LASER_Diode_3_ADC", &m_las_D3_ADC, "LASER_Diode_3_ADC/I");
2642  m_ntuplePtr->Branch("LASER_Diode_4_ADC", &m_las_D4_ADC, "LASER_Diode_4_ADC/I");
2643 
2644  m_ntuplePtr->Branch("LASER_Diode_1_Ped", &m_las_D1_Ped, "LASER_Diode_1_Ped/D");
2645  m_ntuplePtr->Branch("LASER_Diode_2_Ped", &m_las_D2_Ped, "LASER_Diode_2_Ped/D");
2646  m_ntuplePtr->Branch("LASER_Diode_3_Ped", &m_las_D3_Ped, "LASER_Diode_3_Ped/D");
2647  m_ntuplePtr->Branch("LASER_Diode_4_Ped", &m_las_D4_Ped, "LASER_Diode_4_Ped/D");
2648 
2649  m_ntuplePtr->Branch("LASER_Diode_1_Ped_RMS", &m_las_D1_Ped_RMS, "LASER_Diode_1_Ped_RMS/D");
2650  m_ntuplePtr->Branch("LASER_Diode_2_Ped_RMS", &m_las_D2_Ped_RMS, "LASER_Diode_2_Ped_RMS/D");
2651  m_ntuplePtr->Branch("LASER_Diode_3_Ped_RMS", &m_las_D1_Ped_RMS, "LASER_Diode_3_Ped_RMS/D");
2652  m_ntuplePtr->Branch("LASER_Diode_4_Ped_RMS", &m_las_D1_Ped_RMS, "LASER_Diode_4_Ped_RMS/D");
2653 
2654  m_ntuplePtr->Branch("LASER_Diode_1_Alpha", &m_las_D1_Alpha, "LASER_Diode_1_Alpha/D");
2655  m_ntuplePtr->Branch("LASER_Diode_2_Alpha", &m_las_D2_Alpha, "LASER_Diode_2_Alpha/D");
2656  m_ntuplePtr->Branch("LASER_Diode_3_Alpha", &m_las_D3_Alpha, "LASER_Diode_3_Alpha/D");
2657  m_ntuplePtr->Branch("LASER_Diode_4_Alpha", &m_las_D4_Alpha, "LASER_Diode_4_Alpha/D");
2658 
2659  m_ntuplePtr->Branch("LASER_Diode_1_Alpha_RMS", &m_las_D1_Alpha_RMS, "LASER_Diode_1_Alpha_RMS/D");
2660  m_ntuplePtr->Branch("LASER_Diode_2_Alpha_RMS", &m_las_D2_Alpha_RMS, "LASER_Diode_2_Alpha_RMS/D");
2661  m_ntuplePtr->Branch("LASER_Diode_3_Alpha_RMS", &m_las_D3_Alpha_RMS, "LASER_Diode_3_Alpha_RMS/D");
2662  m_ntuplePtr->Branch("LASER_Diode_4_Alpha_RMS", &m_las_D4_Alpha_RMS, "LASER_Diode_4_Alpha_RMS/D");
2663 
2664  m_ntuplePtr->Branch("LASER_Diode_1_AlphaPed", &m_las_D1_AlphaPed, "LASER_Diode_1_AlphaPed/D");
2665  m_ntuplePtr->Branch("LASER_Diode_2_AlphaPed", &m_las_D2_AlphaPed, "LASER_Diode_2_AlphaPed/D");
2666  m_ntuplePtr->Branch("LASER_Diode_3_AlphaPed", &m_las_D3_AlphaPed, "LASER_Diode_3_AlphaPed/D");
2667  m_ntuplePtr->Branch("LASER_Diode_4_AlphaPed", &m_las_D4_AlphaPed, "LASER_Diode_4_AlphaPed/D");
2668 
2669  m_ntuplePtr->Branch("LASER_Diode_1_AlphaPed_RMS", &m_las_D1_AlphaPed_RMS, "LASER_Diode_1_AlphaPed_RMS/D");
2670  m_ntuplePtr->Branch("LASER_Diode_2_AlphaPed_RMS", &m_las_D2_AlphaPed_RMS, "LASER_Diode_2_AlphaPed_RMS/D");
2671  m_ntuplePtr->Branch("LASER_Diode_3_AlphaPed_RMS", &m_las_D3_AlphaPed_RMS, "LASER_Diode_3_AlphaPed_RMS/D");
2672  m_ntuplePtr->Branch("LASER_Diode_4_AlphaPed_RMS", &m_las_D4_AlphaPed_RMS, "LASER_Diode_4_AlphaPed_RMS/D");
2673 
2674  m_ntuplePtr->Branch("LASER_PMT_1_ADC", &m_las_PMT1_ADC, "LASER_PMT_1_ADC/I");
2675  m_ntuplePtr->Branch("LASER_PMT_2_ADC", &m_las_PMT2_ADC, "LASER_PMT_2_ADC/I");
2676 
2677  m_ntuplePtr->Branch("LASER_PMT_1_TDC", &m_las_PMT1_TDC, "LASER_PMT_1_TDC/I");
2678  m_ntuplePtr->Branch("LASER_PMT_2_TDC", &m_las_PMT2_TDC, "LASER_PMT_2_TDC/I");
2679 
2680  m_ntuplePtr->Branch("LASER_PMT_1_Ped", &m_las_PMT1_Ped, "LASER_PMT_1_Ped/D");
2681  m_ntuplePtr->Branch("LASER_PMT_2_Ped", &m_las_PMT2_Ped, "LASER_PMT_2_Ped/D");
2682 
2683  m_ntuplePtr->Branch("LASER_PMT_1_Ped_RMS", &m_las_PMT1_Ped_RMS, "LASER_PMT_1_Ped_RMS/D");
2684  m_ntuplePtr->Branch("LASER_PMT_2_Ped_RMS", &m_las_PMT2_Ped_RMS, "LASER_PMT_2_Ped_RMS/D");
2685 
2686  m_ntuplePtr->Branch("LASER_HEAD_Temp", &m_las_Temperature, "LASER_HEAD_Temp/D");
2687  }
2688 
2689  if (m_beamIdList[LASE_PTN_FRAG]) {
2690  m_ntuplePtr->Branch("LasFlag", &m_lasFlag, "LasFlag/s");
2691  }
2692 
2693  if ((m_unpackAdder && m_beamIdList[BEAM_ADC_FRAG])
2694  || (!m_unpackAdder && m_beamIdList[LASE_ADC_FRAG])) {
2695  m_ntuplePtr->Branch("Las0", &m_las0, "Las0/F");
2696  m_ntuplePtr->Branch("Las1", &m_las1, "Las1/F");
2697  m_ntuplePtr->Branch("Las2", &m_las2, "Las2/F");
2698  m_ntuplePtr->Branch("Las3", &m_las3, "Las3/F");
2699  m_ntuplePtr->Branch("LasExtra", &m_lasExtra, "m_lasExtra[4]/F");
2700  }
2701 
2702 }

◆ LASER_clearBranch()

void TileTBAANtuple::LASER_clearBranch ( void  )
private

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

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

Definition at line 2710 of file TileTBAANtuple.cxx.

2711 {
2712 
2713  if (!m_laserObjectKey.empty()) {
2714 
2715  m_las_BCID = 0;
2716  m_las_D1_ADC = 0;
2717  m_las_D2_ADC = 0;
2718  m_las_D3_ADC = 0;
2719  m_las_D4_ADC = 0;
2720 
2721  m_las_D1_Ped = 0;
2722  m_las_D2_Ped = 0;
2723  m_las_D3_Ped = 0;
2724  m_las_D4_Ped = 0;
2725 
2726  m_las_D1_Alpha = 0;
2727  m_las_D2_Alpha = 0;
2728  m_las_D3_Alpha = 0;
2729  m_las_D4_Alpha = 0;
2730 
2731  m_las_PMT1_ADC = 0;
2732  m_las_PMT2_ADC = 0;
2733 
2734  m_las_PMT1_TDC = 0;
2735  m_las_PMT2_TDC = 0;
2736 
2737  m_las_PMT1_Ped = 0;
2738  m_las_PMT2_Ped = 0;
2739  }
2740 
2741  if (m_beamIdList[LASE_PTN_FRAG]) {
2742  m_lasFlag=0;
2743  }
2744 
2745  if ((m_unpackAdder && m_beamIdList[BEAM_ADC_FRAG])
2746  || (!m_unpackAdder && m_beamIdList[LASE_ADC_FRAG])) {
2747 
2748  m_las0 = 0.;
2749  m_las1 = 0.;
2750  m_las2 = 0.;
2751  m_las3 = 0.;
2752 
2753  }
2754 }

◆ 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 2512 of file TileTBAANtuple.cxx.

2513 {
2514 
2515  if ( m_beamIdList[MUON_ADC_FRAG] ||
2516  m_beamIdList[ADDR_ADC_FRAG] )
2517  {
2518  m_ntuplePtr->Branch("MuBackHit",&m_muBackHit,"MuBackHit/F");
2519  m_ntuplePtr->Branch("MuBackSum",&m_muBackSum,"MuBackSum/F");
2520 
2521  if (m_TBperiod < 2015) {
2522  m_ntuplePtr->Branch("MuBack",&m_muBack,"m_muBack[14]");
2523  m_ntuplePtr->Branch("MuCalib",&m_muCalib,"m_muCalib[2]");
2524  } else if (m_TBperiod == 2015) {
2525  m_ntuplePtr->Branch("MuBack",&m_muBack,"MuBack[8]/F");
2526  } else {
2527  m_ntuplePtr->Branch("MuBack",&m_muBack,"MuBack[12]/F");
2528  }
2529  }
2530 
2531 
2532 }

◆ MUON_clearBranch()

void TileTBAANtuple::MUON_clearBranch ( void  )
private

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

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

Definition at line 2594 of file TileTBAANtuple.cxx.

2594  {
2595  m_muBackHit = 0.;
2596  m_muBackSum = 0.;
2597 
2598 }

◆ ntuple_clear()

StatusCode TileTBAANtuple::ntuple_clear ( )

Definition at line 1970 of file TileTBAANtuple.cxx.

1970  {
1971 
1972  TRIGGER_clearBranch();
1973 
1974  if (m_beamIdList[MUON_ADC_FRAG] || m_beamIdList[ADDR_ADC_FRAG]) {
1975  MUON_clearBranch();
1976  }
1977 
1978  if (m_beamIdList[ECAL_ADC_FRAG]) {
1979  ECAL_clearBranch();
1980  if (m_TBperiod > 2015) QDC_clearBranch();
1981  }
1982 
1983  LASER_clearBranch();
1984 
1985  if (m_unpackAdder) {
1986  if (m_beamIdList[ADD_FADC_FRAG]) {
1987  ADDER_clearBranch();
1988  }
1989  }
1990 
1991  if (m_beamIdList[DIGI_PAR_FRAG & 0x1F]) {
1992  CISPAR_clearBranch();
1993  }
1994 
1995  if (((m_TBperiod >= 2015 || m_unpackAdder) && m_beamIdList[BEAM_ADC_FRAG])
1996  || (!m_unpackAdder && m_beamIdList[COMMON_ADC1_FRAG])
1997  || (m_TBperiod >= 2022 && m_beamIdList[COMMON_TOF_FRAG])) {
1998  BEAM_clearBranch();
1999  ATH_MSG_VERBOSE( "clear branch");
2000  }
2001 
2002  if (m_completeNtuple && m_TBperiod < 2015) {
2003  ENETOTAL_clearBranch();
2004  }
2005 
2006  COINCBOARD_clearBranch();
2007 
2008  DIGI_clearBranch(); // working now
2009  if (m_saveFelixData) {
2010  FELIX_clearBranch();
2011  }
2012 
2013  HIT_clearBranch();
2014  ATH_MSG_DEBUG( "clear() successfully" );
2015 
2016  return StatusCode::SUCCESS;
2017 }

◆ 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 135 of file TileTBAANtuple.cxx.

135  {
136 
137  CHECK( m_thistSvc.retrieve() );
138 
139  // find TileCablingService
140  m_cabling = TileCablingService::getInstance();
141 
142  // retrieve TileID helper from det store
143 
144  CHECK( detStore()->retrieve(m_tileID) );
145 
146  CHECK( detStore()->retrieve(m_tileHWID) );
147 
148  if (m_nSamples < 0) {
149  m_nSamples = 7;
150  }
151  if (m_nSamplesFlx < 0) {
152  m_nSamplesFlx = m_saveFelixData ? 32 : 0;
153  }
154 
155  if (m_TBperiod >= 2015) {
156  m_unpackAdder = false;
157 
158  if (m_TBperiod == 2015) {
159  m_nDrawers = 2;
160  m_drawerList.value().resize(m_nDrawers);
161  m_drawerType.value().resize(m_nDrawers);
162  m_drawerList[0] = "0x200"; m_drawerType[0] = 2; // barrel neg
163  m_drawerList[1] = "0x401"; m_drawerType[1] = 4; // ext.barrel neg
164  } else if (m_TBperiod == 2016 || m_TBperiod == 2018 || m_TBperiod == 2021 || m_TBperiod == 2022) {
165  m_nDrawers = 5;
166  m_drawerList.value().resize(m_nDrawers); m_drawerType.value().resize(m_nDrawers);
167  m_drawerList[0] = "0x100"; m_drawerType[0] = 1; // M0 pos
168  m_drawerList[1] = "0x101"; m_drawerType[1] = 1; // barrel pos
169  m_drawerList[2] = "0x200"; m_drawerType[2] = 2; // M0 neg
170  m_drawerList[3] = "0x201"; m_drawerType[3] = 2; // barrel neg
171  m_drawerList[4] = "0x402"; m_drawerType[4] = 4; // ext.barrel neg
172  } else if (m_TBperiod == 2017) {
173  m_nDrawers = 6;
174  m_drawerList.value().resize(m_nDrawers); m_drawerType.value().resize(m_nDrawers);
175  m_drawerList[0] = "0x100"; m_drawerType[0] = 1; // M0 pos
176  m_drawerList[1] = "0x101"; m_drawerType[1] = 1; // barrel pos
177  m_drawerList[2] = "0x200"; m_drawerType[2] = 2; // M0 neg
178  m_drawerList[3] = "0x201"; m_drawerType[3] = 2; // barrel neg
179  m_drawerList[4] = "0x203"; m_drawerType[4] = 2; // barrel neg
180  m_drawerList[5] = "0x402"; m_drawerType[5] = 4; // ext.barrel neg
181  } else if (m_TBperiod == 2019) {
182  m_nDrawers = 7;
183  m_drawerList.value().resize(m_nDrawers); m_drawerType.value().resize(m_nDrawers);
184  m_drawerList[0] = "0x100"; m_drawerType[0] = 1; // M0 pos
185  m_drawerList[1] = "0x101"; m_drawerType[1] = 1; // barrel pos
186  m_drawerList[2] = "0x200"; m_drawerType[2] = 2; // M0 neg
187  m_drawerList[3] = "0x201"; m_drawerType[3] = 2; // barrel neg
188  m_drawerList[4] = "0x203"; m_drawerType[4] = 2; // barrel neg
189  m_drawerList[5] = "0x402"; m_drawerType[5] = 4; // ext.barrel neg
190  m_drawerList[6] = "0x405"; m_drawerType[6] = 4; // ext.barrel neg
191  }
192 
193  if (m_TBperiod < 2016) {
194  setupBeamChambersTB2015();
195  } else if (m_TBperiod < 2021) {
196  setupBeamChambersTB2016_2020();
197  } else {
198  // Strating from 2021 the following properties should be setup via JO
199  checkIsPropertySetup(m_beamBC1X1, "BC1X1");
200  checkIsPropertySetup(m_beamBC1X2, "BC1X2");
201  checkIsPropertySetup(m_beamBC1Y1, "BC1Y1");
202  checkIsPropertySetup(m_beamBC1Y2, "BC1Y2");
203  checkIsPropertySetup(m_beamBC1Z, "BC1Z");
204  checkIsPropertySetup(m_beamBC1Z_0, "BC1Z_0");
205  checkIsPropertySetup(m_beamBC1Z_90, "BC1Z_90");
206  checkIsPropertySetup(m_beamBC1Z_min90, "BC1Z_min90");
207 
208  checkIsPropertySetup(m_beamBC2X1, "BC2X1");
209  checkIsPropertySetup(m_beamBC2X2, "BC2X2");
210  checkIsPropertySetup(m_beamBC2Y1, "BC2Y1");
211  checkIsPropertySetup(m_beamBC2Y2, "BC2Y2");
212  checkIsPropertySetup(m_beamBC2Z, "BC2Z");
213  checkIsPropertySetup(m_beamBC2Z_0, "BC2Z_0");
214  checkIsPropertySetup(m_beamBC2Z_90, "BC2Z_90");
215  checkIsPropertySetup(m_beamBC2Z_min90, "BC2Z_min90");
216  }
217 
218  } else {
219  setupBeamChambersBeforeTB2015();
220  }
221 
222 
223  if (m_unpackAdder) {
224  // get TileRawChannelBuilderFlatFilter for adder energy calculation
225 
226  StatusCode sc;
227  sc &= m_adderFilterAlgTool->setProperty("TileRawChannelContainer", "TileAdderFlat");
228  sc &= m_adderFilterAlgTool->setProperty("calibrateEnergy", "true");
229 
230  sc &= m_adderFilterAlgTool->setProperty("PedStart", "0");
231  sc &= m_adderFilterAlgTool->setProperty("PedLength", "1");
232  sc &= m_adderFilterAlgTool->setProperty("PedOffset", "0");
233  sc &= m_adderFilterAlgTool->setProperty("SignalStart", "1");
234  sc &= m_adderFilterAlgTool->setProperty("SignalLength", "15");
235  sc &= m_adderFilterAlgTool->setProperty("FilterLength", "5");
236  sc &= m_adderFilterAlgTool->setProperty("FrameLength", "16");
237  sc &= m_adderFilterAlgTool->setProperty("DeltaCutLo", "9.5");
238  sc &= m_adderFilterAlgTool->setProperty("DeltaCutHi", "9.5");
239  sc &= m_adderFilterAlgTool->setProperty("RMSCutLo", "1.0");
240  sc &= m_adderFilterAlgTool->setProperty("RMSCutHi", "1.0");
241  if (sc.isFailure()) {
242  ATH_MSG_ERROR("Failure setting properties of " << m_adderFilterAlgTool);
243  return StatusCode::FAILURE;
244  }
245  }
246 
247  if (m_finalUnit < TileRawChannelUnit::ADCcounts
248  || m_finalUnit > TileRawChannelUnit::OnlineMegaElectronVolts) {
249 
250  m_finalUnit = -1;
251  if (!m_useDspUnits && m_calibrateEnergy) {
252  m_useDspUnits = true;
253  ATH_MSG_INFO( "Final offline units are not set, will use DSP units" );
254  }
255  }
256 
257  if (!m_calibrateEnergy) {
258  if (m_useDspUnits) {
259  ATH_MSG_INFO( "calibrateEnergy is disabled, don't want to use DSP units" );
260  m_useDspUnits = false;
261  }
262  }
263 
264  ATH_MSG_INFO( "TestBeam period " << m_TBperiod.value() );
265  ATH_MSG_INFO( "calibMode " << m_calibMode.value() );
266  ATH_MSG_INFO( "calibrateEnergy " << m_calibrateEnergy.value() );
267  ATH_MSG_INFO( "offlineUnits " << m_finalUnit.value() );
268  ATH_MSG_INFO( "useDspUnits " << m_useDspUnits.value() );
269  ATH_MSG_INFO( "number of samples " << m_nSamples.value() );
270 
271 
272  msg(MSG::INFO) << "drawerList " << MSG::hex;
273  unsigned int size = m_drawerList.size();
274  for (unsigned int dr = 0; dr < size; ++dr) {
275  int frag = strtol(m_drawerList[dr].data(), NULL, 0);
276  if (frag >= 0) {
277  m_drawerMap[frag] = dr;
278  if (dr == m_drawerType.size()) m_drawerType.value().push_back(frag >> 8);
279  msg(MSG::INFO) << " 0x" << frag;
280  } else {
281  msg(MSG::INFO) << " " << m_drawerList[dr];
282  // put negative number in first element (flag to read frag ID from data)
283  m_drawerList[0] = m_drawerList[dr];
284  m_drawerList.value().resize(1);
285  // m_drawerType.clear();
286  m_drawerMap.clear();
287  size = 0;
288  break;
289  }
290  }
291  if (size == 0) {
292  if (m_drawerList.size() > 0)
293  msg(MSG::INFO) << " - negative number, will read frag IDs from the data" << MSG::dec << endmsg;
294  else
295  msg(MSG::INFO) << "is empty, no drawer fragments in ntuple" << MSG::dec << endmsg;
296  } else {
297  msg(MSG::INFO) << MSG::dec << endmsg;
298 
299  size = m_drawerType.size();
300  if (size < m_nDrawers) {
301  m_drawerType.value().resize(m_nDrawers);
302  for (; size < m_nDrawers; ++size)
303  m_drawerType[size] = 0;
304  }
305 
306  msg(MSG::INFO) << MSG::INFO << "drawerType ";
307  for (unsigned int dr = 0; dr < size; ++dr)
308  msg(MSG::INFO) << " " << m_drawerType[dr];
309  msg(MSG::INFO) << endmsg;
310 
311  if (size > m_nDrawers) {
312  ATH_MSG_INFO( "increasing m_nDrawers from " << m_nDrawers << " to " << size );
313  m_nDrawers = size;
314  }
315  }
316 
317  msg(MSG::INFO) << MSG::INFO << "Beam Frag List " << MSG::hex;
318  size = m_beamFragList.size();
319  for (unsigned int dr = 0; dr < size; ++dr) {
320  int frag = strtol(m_beamFragList[dr].data(), NULL, 0);
321  if (frag >= 0) {
322  m_beamIdList[frag & 0x1F] = true;
323  msg(MSG::INFO) << " 0x" << frag;
324  }
325  }
326  if (size == 0) {
327  msg(MSG::INFO) << "is empty, no beam fragments in ntuple" << MSG::dec << endmsg;
328  } else {
329  msg(MSG::INFO) << MSG::dec << endmsg;
330  }
331 
332  // set event number to 0 before first event
333  m_evtNr = 0;
334  m_calibrateEnergyThisEvent = m_calibrateEnergy;
335 
336  // find event and beam ROD header, calib mode for digitizers
337 
341  if (m_evtNr == 0) {
342  if (m_unpackAdder) // in 2003 event number starts from 1
343  ++m_evtNr;
344  }
345 
346  if (initList(ctx).isFailure()) {
347  ATH_MSG_ERROR( " Error during drawer list initialization" );
348  }
349 
350  if (m_saveFelixData && initListFlx(ctx).isFailure()) {
351  ATH_MSG_ERROR( " Error during drawer list initialization" );
352  }
353 
354  if (initNTuple().isFailure()) {
355  ATH_MSG_ERROR( " Error during ntuple initialization" );
356  }
357 
358  ATH_MSG_INFO( "initialization completed" );
359  return StatusCode::SUCCESS;
360 }

◆ 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 2555 of file TileTBAANtuple.cxx.

2556 {
2557 
2558  if (m_beamIdList[ECAL_ADC_FRAG]) {
2559  for(unsigned i=0; i<33; ++i){ m_qdc[i]=0.0; }
2560  m_ntuplePtr->Branch("qdc", &m_qdc, "qdc[33]/i");
2561  }
2562 
2563 }

◆ QDC_clearBranch()

void TileTBAANtuple::QDC_clearBranch ( void  )
private

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

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

Definition at line 2617 of file TileTBAANtuple.cxx.

2618 {
2619  for(unsigned i=0; i<33; ++i){ m_qdc[i]=0.0; }
2620 }

◆ 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 3772 of file TileTBAANtuple.cxx.

3772  {
3773  // Setup default value for the following properties, if they are not setup via JO
3774  setupPropertyDefaultValue(m_beamBC1X1, -0.938, "BC1X1");
3775  setupPropertyDefaultValue(m_beamBC1X2, 0.1747, "BC1X2");
3776  setupPropertyDefaultValue(m_beamBC1Y1, 0.125, "BC1Y1");
3777  setupPropertyDefaultValue(m_beamBC1Y2, 0.1765, "BC1Y2");
3778  setupPropertyDefaultValue(m_beamBC1Z, 13788.0, "BC1Z");
3779  setupPropertyDefaultValue(m_beamBC1Z_0, 13788.0, "BC1Z_0");
3780  setupPropertyDefaultValue(m_beamBC1Z_90, 13788.0, "BC1Z_90");
3781  setupPropertyDefaultValue(m_beamBC1Z_min90, 13788.0, "BC1Z_min90");
3782 
3783  setupPropertyDefaultValue(m_beamBC2X1, -0.9369, "BC2X1");
3784  setupPropertyDefaultValue(m_beamBC2X2, 0.191, "BC2X2");
3785  setupPropertyDefaultValue(m_beamBC2Y1, -1.29, "BC2Y1");
3786  setupPropertyDefaultValue(m_beamBC2Y2, 0.187, "BC2Y2");
3787  setupPropertyDefaultValue(m_beamBC2Z, 9411.0, "BC2Z");
3788  setupPropertyDefaultValue(m_beamBC2Z_0, 9411.0, "BC2Z_0");
3789  setupPropertyDefaultValue(m_beamBC2Z_90, 9411.0, "BC2Z_90");
3790  setupPropertyDefaultValue(m_beamBC2Z_min90, 9411.0, "BC2Z_min90");
3791 }

◆ setupBeamChambersTB2015()

void TileTBAANtuple::setupBeamChambersTB2015 ( void  )
private

Definition at line 3793 of file TileTBAANtuple.cxx.

3793  {
3794  setupPropertyDefaultValue(m_beamBC1X1, -0.0462586, "BC1X1");
3795  setupPropertyDefaultValue(m_beamBC1X2, -0.175666, "BC1X2");
3796  setupPropertyDefaultValue(m_beamBC1Y1, -0.051923, "BC1Y1");
3797  setupPropertyDefaultValue(m_beamBC1Y2, -0.176809, "BC1Y2");
3798  setupPropertyDefaultValue(m_beamBC1Z, 13000. + 2760, "BC1Z");
3799  setupPropertyDefaultValue(m_beamBC1Z_0, 13788.0, "BC1Z_0");
3800  setupPropertyDefaultValue(m_beamBC1Z_90, 13788.0, "BC1Z_90");
3801  setupPropertyDefaultValue(m_beamBC1Z_min90, 13788.0, "BC1Z_min90");
3802 
3803  setupPropertyDefaultValue(m_beamBC2X1, 0.25202, "BC2X1");
3804  setupPropertyDefaultValue(m_beamBC2X2, -0.18053, "BC2X2");
3805  setupPropertyDefaultValue(m_beamBC2Y1, 0.0431688, "BC2Y1");
3806  setupPropertyDefaultValue(m_beamBC2Y2, -0.181128, "BC2Y2");
3807  setupPropertyDefaultValue(m_beamBC2Z, 2760, "BC2Z");
3808  setupPropertyDefaultValue(m_beamBC2Z_0, 9411.0, "BC2Z_0");
3809  setupPropertyDefaultValue(m_beamBC2Z_90, 9411.0, "BC2Z_90");
3810  setupPropertyDefaultValue(m_beamBC2Z_min90, 9411.0, "BC2Z_min90");
3811 }

◆ setupBeamChambersTB2016_2020()

void TileTBAANtuple::setupBeamChambersTB2016_2020 ( void  )
private

Definition at line 3813 of file TileTBAANtuple.cxx.

3813  {
3814  // 2016 settings:
3815  //
3816  // https://pcata007.cern.ch/elog/TB2016/88
3817  //
3818  //
3819  // The calibration has been done with the following runs :
3820  // BC1:
3821  // Center : 610212
3822  // Left/up : 610210
3823  // Right/down : 610209
3824  //
3825  // BC2:
3826  // Center : 610256
3827  // Left/up : 610321
3828  // Right/down : 610320
3829  //
3830  // Here are the new constants :
3831  //
3832  // BC1
3833  // horizontal slope = -0.171928
3834  // horizontal offset = -0.047624
3835  //
3836  // vertical slope = -0.172942
3837  // vertical offset = -0.0958677
3838  //
3839  // BC2
3840  // horizontal slope = -0.175698
3841  // horizontal offset = -1.04599
3842  //
3843  // vertical slope = -0.174535
3844  // vertical offset = -3.10666
3845 
3846  // June 2016 calibration
3847  //m_beamBC1X1 = -0.047624;
3848  //m_beamBC1X2 = -0.171928;
3849  //m_beamBC1Y1 = -0.0958677;
3850  //m_beamBC1Y2 = -0.172942;
3851  //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3852 
3853  //m_beamBC2X1 = -1.04599;
3854  //m_beamBC2X2 = -0.175698;
3855  //m_beamBC2Y1 = -3.10666;
3856  //m_beamBC2Y2 = -0.174535;
3857  //m_beamBC2Z = 2760 /* 2600. */;
3858 
3859  // September 2016 calibration, https://pcata007.cern.ch/elog/TB2016/300 (joakim.olsson@cern.ch)
3860  //m_beamBC1X1 = 0.100857923042;
3861  //m_beamBC1X2 = -0.172098;
3862  //m_beamBC1Y1 = -0.133045996607;
3863  //m_beamBC1Y2 = -0.172855178323;
3864  //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3865  //
3866  //m_beamBC2X1 = 0.271555258578 ;
3867  //m_beamBC2X2 = -0.173463 ;
3868  //m_beamBC2Y1 = 0.305483228502;
3869  //m_beamBC2Y2 = -0.173805131744 ;
3870  //m_beamBC2Z = 2760 /* 2600. */;
3871 
3872  // June 2017 calibration, https://pcata007.cern.ch/elog/TB2017/550 (schae@cern.ch)
3873  //m_beamBC1X1 = 0.153584934082;
3874  //m_beamBC1X2 = -0.175220;
3875  //m_beamBC1Y1 = -0.493246053303;
3876  //m_beamBC1Y2 = -0.176567356723;
3877  //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3878  //
3879  //m_beamBC2X1 = 0.414611893278;
3880  //m_beamBC2X2 = -0.176122;
3881  //m_beamBC2Y1 = 0.150807740888;
3882  //m_beamBC2Y2 = -0.173472808704;
3883  //m_beamBC2Z = 2760 /* 2600. */;
3884 
3885  // August 2017 calibration, https://pcata007.cern.ch/elog/TB2017/550 (schae@cern.ch)
3886  //m_beamBC1X1 = 0.181797;
3887  //m_beamBC1X2 = -0.175657;
3888  //m_beamBC1Y1 = -0.128910;
3889  //m_beamBC1Y2 = -0.175965;
3890  //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3891  //
3892  //m_beamBC2X1 = 0.611502;
3893  //m_beamBC2X2 = -0.183116;
3894  //m_beamBC2Y1 = 0.541212;
3895  //m_beamBC2Y2 = -0.183115;
3896  //m_beamBC2Z = 2760 /* 2600. */;
3897 
3898  // September 2017 calibration, https://pcata007.cern.ch/elog/TB2017/550 (schae@cern.ch)
3899  //m_beamBC1X1 = 0.181797;
3900  //m_beamBC1X2 = -0.175657;
3901  //m_beamBC1Y1 = -0.128910;
3902  //m_beamBC1Y2 = -0.175965;
3903  //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3904 
3905  //m_beamBC2X1 = 0.622896039922;
3906  //m_beamBC2X2 = -0.176735;
3907  //m_beamBC2Y1 = 0.195954125116;
3908  //m_beamBC2Y2 = -0.176182117624;
3909  //m_beamBC2Z = 2760 /* 2600. */;
3910 
3911  // September 2017 calibration with additional precision from Survey
3912  setupPropertyDefaultValue(m_beamBC1X1, 0.681797, "BC1X1");
3913  setupPropertyDefaultValue(m_beamBC1X2, -0.175657, "BC1X2");
3914  setupPropertyDefaultValue(m_beamBC1Y1, -2.02891, "BC1Y1");
3915  setupPropertyDefaultValue(m_beamBC1Y2, -0.175965, "BC1Y2");
3916  setupPropertyDefaultValue(m_beamBC1Z, 17348.8, "BC1Z");
3917  setupPropertyDefaultValue(m_beamBC1Z_0, 17348.8, "BC1Z_0");
3918  setupPropertyDefaultValue(m_beamBC1Z_90, 15594.05, "BC1Z_90");
3919  setupPropertyDefaultValue(m_beamBC1Z_min90, 15571.8, "BC1Z_min90");
3920 
3921  setupPropertyDefaultValue(m_beamBC2X1, -24.377104, "BC2X1");
3922  setupPropertyDefaultValue(m_beamBC2X2, -0.176735, "BC2X2");
3923  setupPropertyDefaultValue(m_beamBC2Y1, 17.895954, "BC2Y1");
3924  setupPropertyDefaultValue(m_beamBC2Y2, -0.176182117624, "BC2Y2");
3925  setupPropertyDefaultValue(m_beamBC2Z, 4404.2, "BC2Z");
3926  setupPropertyDefaultValue(m_beamBC2Z_0, 4420.7, "BC2Z_0");
3927  setupPropertyDefaultValue(m_beamBC2Z_90, 2649.45, "BC2Z_90");
3928  setupPropertyDefaultValue(m_beamBC2Z_min90, 2627.2, "BC2Z_min90");
3929 
3930 }

◆ 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 526 of file TileTBAANtuple.cxx.

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

◆ storeCells()

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

Definition at line 2130 of file TileTBAANtuple.cxx.

2130  {
2131 
2132  if (m_cellContainerKey.empty()) { // empty name, nothing to do
2133  return StatusCode::FAILURE;
2134  }
2135 
2136  //Retrieve Cell collection from SG
2137  const CaloCellContainer* cellContainer = SG::makeHandle (m_cellContainerKey, ctx).get();
2138 
2139  //Loop over all cells in container. Sum up the Energy and fill 2DHistograms
2140  ATH_MSG_DEBUG( "succeeded retrieving cellContainer from SG" );
2141 
2142  ATH_MSG_DEBUG( "TileTBAANtuple : about to iterate over CaloCells" );
2143 
2144  m_LarEne[0] = m_LarEne[1] = m_LarEne[2] = m_LarEne[3] = 0.0;
2145  m_BarEne[0] = m_BarEne[1] = m_BarEne[2] = 0.0;
2146  m_ExtEne[0] = m_ExtEne[1] = m_ExtEne[2] = 0.0;
2147  m_GapEne[0] = m_GapEne[1] = m_GapEne[2] = 0.0;
2148 
2149  for (const CaloCell* cell : *cellContainer) {
2150  //Decode cell information
2151  const double energy = cell->energy();
2152  const CaloDetDescrElement* caloDDE = cell->caloDDE(); //pointer to the DetectorDescriptionElement
2153  const CaloCell_ID::CaloSample sampl = caloDDE->getSampling(); //To which sampling belongs this cell?
2154 
2155  if (sampl == CaloCell_ID::PreSamplerB) {
2156  m_LarEne[0] += energy;
2157  } else if (sampl == CaloCell_ID::EMB1) {
2158  m_LarEne[1] += energy;
2159  } else if (sampl == CaloCell_ID::EMB2) {
2160  m_LarEne[2] += energy;
2161  } else if (sampl == CaloCell_ID::EMB3) {
2162  m_LarEne[3] += energy;
2163  } else if (sampl == CaloCell_ID::TileBar0) {
2164  m_BarEne[0] += energy;
2165  } else if (sampl == CaloCell_ID::TileBar1) {
2166  m_BarEne[1] += energy;
2167  } else if (sampl == CaloCell_ID::TileBar2) {
2168  m_BarEne[2] += energy;
2169  } else if (sampl == CaloCell_ID::TileExt0) {
2170  m_ExtEne[0] += energy;
2171  } else if (sampl == CaloCell_ID::TileExt1) {
2172  m_ExtEne[1] += energy;
2173  } else if (sampl == CaloCell_ID::TileExt2) {
2174  m_ExtEne[2] += energy;
2175  } else if (sampl == CaloCell_ID::TileGap1) {
2176  m_GapEne[1] += energy;
2177  } else if (sampl == CaloCell_ID::TileGap2) {
2178  m_GapEne[2] += energy;
2179  } else if (sampl == CaloCell_ID::TileGap3) {
2180  m_GapEne[0] += energy;
2181  }
2182  }
2183 
2184  return StatusCode::SUCCESS;
2185 }

◆ 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 1345 of file TileTBAANtuple.cxx.

1345  {
1346 
1347  if (containerKey.empty()) { // empty name, nothing to do
1348  return StatusCode::FAILURE;
1349  }
1350 
1351  // Read Digits from TES
1352  const TileDigitsContainer* digitsCnt = SG::makeHandle (containerKey, ctx).get();
1353 
1354  bool emptyColl = true;
1355 
1356  // drawerIndex is 0 - m_nDrawers-1, fragType is 1-4 B+/B-/EB+/EB-
1357  int drawerIndex, fragType, channel;
1358 
1359  std::vector<float> sampleVec;
1360  std::vector<uint32_t> headerVec;
1361  std::vector<uint32_t> headerVecHi;
1362  uint32_t CRCmask;
1363  uint32_t fe_crc;
1364  uint32_t rod_crc;
1365 
1366  // Go through all TileDigitsCollections
1367  for (const TileDigitsCollection* digitsCollection : * digitsCnt) {
1368  // determine type of frag
1369  int fragId = digitsCollection->identify();
1370  int ros = (fragId >> 8);
1371  int drawer = fragId & 0x3F;
1372 
1373  drawerMap_iterator itr = m_drawerMap.find(fragId);
1374  if ( itr != m_drawerMap.end() ) {
1375  drawerIndex = (*itr).second;
1376  } else {
1377  drawerIndex= -1;
1378  }
1379 
1380  if (drawerIndex < 0) {
1381  if ( !digitsCollection->empty() )
1382  ATH_MSG_DEBUG( "frag id 0x" << MSG::hex << fragId << MSG::dec <<" was not found among valid frag IDs when storing TRC!" );
1383 
1384  } else {
1385  fragType = m_drawerType[drawerIndex];
1386 
1387  ATH_MSG_DEBUG( "Event# " << m_evtNr
1388  << " Frag id 0x" << MSG::hex << fragId << MSG::dec
1389  << " index " << drawerIndex
1390  << " Calib " << m_calibMode );
1391 
1392  ATH_MSG_DEBUG( " Size=" << digitsCollection->getFragSize()
1393  << " BCID=" << digitsCollection->getFragBCID()<<MSG::hex
1394  << " CRC=0x" << (digitsCollection->getFragCRC()&0xffff)
1395  << " DMUMask=0x" << (digitsCollection->getFragDMUMask()&0xffff)<<MSG::dec );
1396 
1397  ATH_MSG_DEBUG( " Lvl1ID=" << digitsCollection->getLvl1Id()
1398  << " Lvl1Type=" << digitsCollection->getLvl1Type()
1399  << " EvBCID=" << digitsCollection->getRODBCID()
1400  << " EvType=" << digitsCollection->getDetEvType() );
1401 
1402  ATH_MSG_DEBUG( " Header=" << digitsCollection->getFragChipHeaderWords() );
1403 
1404  if (m_completeNtuple) {
1409  m_l1ID.at(drawerIndex) = digitsCollection->getLvl1Id();
1410  m_l1Type.at(drawerIndex) = digitsCollection->getLvl1Type();
1411  m_evType.at(drawerIndex) = digitsCollection->getDetEvType();
1412  m_evBCID.at(drawerIndex) = digitsCollection->getRODBCID();
1413  // store FrBCID
1414  m_frBCID.at(drawerIndex) = digitsCollection->getFragBCID();
1415  }
1416 
1417  if(m_calibMode) {
1418  // Digits in calib mode
1419  // check gain for first digits in collection
1420 
1421  int dcnt=0;
1422  int drawerIndexHi = drawerIndex + m_nDrawers;
1423  // non empty collection
1424  if (!digitsCollection->empty()) {
1425  // store evtnr, bcid,crc, size
1426  // Same for lo and hi, because they come from the same fragment
1427  m_rodBCIDVec.at(drawerIndex) = digitsCollection->getRODBCID();
1428  m_sizeVec.at(drawerIndex) = digitsCollection->getFragSize();
1429  m_sizeVec.at(drawerIndexHi) = digitsCollection->getFragSize();
1430  m_evtVec.at(drawerIndex) = m_evtNr;
1431  m_evtVec.at(drawerIndexHi) = m_evtNr;
1432 
1433  headerVec = digitsCollection->getFragChipHeaderWords();
1434  headerVecHi = digitsCollection->getFragChipHeaderWordsHigh();
1435  CRCmask = digitsCollection->getFragDMUMask(); //mask of FE+ROD DMU crc check (16bit+16bit) 0xffffffff == All ok
1436  fe_crc = CRCmask & 0xFFFF;
1437  rod_crc = CRCmask >> 16;
1438 
1439  unsigned int headsize = std::min(16U, static_cast<unsigned int>(headerVec.size()));
1440  unsigned int headsizehi = std::min(16U, static_cast<unsigned int>(headerVecHi.size()));
1441 
1442  for (unsigned int ih = 0; ih < headsize; ++ih) {
1443 
1444  m_bcidVec.at(drawerIndex)[ih] = (headerVec[ih] & 0xFFF);
1445  m_DMUheaderVec.at(drawerIndex)[ih] = headerVec[ih];
1446  m_DMUformatErrVec.at(drawerIndex)[ih] = CheckDMUFormat(headerVec[ih]);
1447  m_DMUparityErrVec.at(drawerIndex)[ih] = CheckDMUParity(headerVec[ih]);
1448  m_DMUmemoryErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 25 & 0x1);
1449  m_DMUSstrobeErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 24 & 0x1);
1450  m_DMUDstrobeErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 23 & 0x1);
1451  m_feCRCVec.at(drawerIndex)[ih] = (fe_crc >> ih & 0x1);
1452  m_rodCRCVec.at(drawerIndex)[ih] = (rod_crc >> ih & 0x1);
1453 
1454  if (dqStatus) {
1455  m_DMUHeadparityErrVec.at(drawerIndex)[ih] = dqStatus->checkHeaderParityErr(ros, drawer, ih, 0);
1456  m_DMUDataparityErrVec.at(drawerIndex)[ih] = dqStatus->checkSampleParityErr(ros, drawer, ih, 0);
1457  }
1458  }
1459 
1460  for (unsigned int ihhi = 0; ihhi < headsizehi; ++ihhi) {
1461  m_bcidVec.at(drawerIndexHi)[ihhi] = (headerVecHi[ihhi] & 0xFFF);
1462  m_DMUheaderVec.at(drawerIndexHi)[ihhi] = headerVecHi[ihhi];
1463  m_DMUformatErrVec.at(drawerIndexHi)[ihhi] = CheckDMUFormat(headerVecHi[ihhi]);
1464  m_DMUparityErrVec.at(drawerIndexHi)[ihhi] = CheckDMUParity(headerVecHi[ihhi]);
1465  m_DMUmemoryErrVec.at(drawerIndexHi)[ihhi] = (headerVecHi[ihhi] >> 25 & 0x1);
1466  m_DMUSstrobeErrVec.at(drawerIndexHi)[ihhi] = (headerVecHi[ihhi] >> 24 & 0x1);
1467  m_DMUDstrobeErrVec.at(drawerIndexHi)[ihhi] = (headerVecHi[ihhi] >> 23 & 0x1);
1468  m_feCRCVec.at(drawerIndex)[ihhi] = -1; //Variables must be filled anyway, empty variables are not allowed
1469  m_rodCRCVec.at(drawerIndex)[ihhi] = -1; //Variables must be filled anyway, empty variables are not allowed
1470 
1471  if (dqStatus) {
1472  m_DMUHeadparityErrVec.at(drawerIndex)[ihhi] = dqStatus->checkHeaderParityErr(ros, drawer, ihhi, 1);
1473  m_DMUDataparityErrVec.at(drawerIndex)[ihhi] = dqStatus->checkSampleParityErr(ros, drawer, ihhi, 1);
1474  }
1475  }
1476 
1477  m_slinkCRCVec.at(drawerIndex)[0] = (digitsCollection->getFragCRC() >> 16) & 0xffff;
1478  m_dmuMaskVec.at(drawerIndex)[0] = (digitsCollection->getFragDMUMask() >> 16) & 0xffff;
1479  m_slinkCRCVec.at(drawerIndex)[1] = digitsCollection->getFragCRC() & 0xffff;
1480  m_dmuMaskVec.at(drawerIndex)[1] = digitsCollection->getFragDMUMask() & 0xffff;
1481 
1482  m_slinkCRCVec.at(drawerIndexHi)[0] = (digitsCollection->getFragCRC() >> 16) & 0xffff;
1483  m_dmuMaskVec.at(drawerIndexHi)[0] = (digitsCollection->getFragDMUMask() >> 16) & 0xffff;
1484  m_slinkCRCVec.at(drawerIndexHi)[1] = digitsCollection->getFragCRC() & 0xffff;
1485  m_dmuMaskVec.at(drawerIndexHi)[1] = digitsCollection->getFragDMUMask() & 0xffff;
1486 
1487  // go through all TileDigits in collection
1488  for (const TileDigits* tile_digits : *digitsCollection) {
1489 
1490  emptyColl = false;
1491 
1492  HWIdentifier hwid = tile_digits->adc_HWID();
1493  // determine gain
1494  int gain = m_tileHWID->adc(hwid);
1495  // add m_nDrawers to index if hi gain
1496  int index = (gain == 1) ? drawerIndexHi : drawerIndex;
1497  int nSamplesInDrawer = m_nSamplesInDrawer[index];
1498 
1499  // determine channel
1500  channel = m_tileHWID->channel(hwid);
1501  // cabling for testbeam (convert to pmt#-1)
1502 
1503  if ((m_TBperiod < 2015 ||
1504  (m_TBperiod==2015 && fragType<3) ||
1505  ((m_TBperiod==2016 || m_TBperiod==2021) && ((fragId&0xFF)<4 && fragId != 0x201)) ||
1506  (m_TBperiod==2017 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x203))) ||
1507  (m_TBperiod==2018 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x402))) ||
1508  (m_TBperiod==2019 && ((fragId&0xFF)<5 && !(fragId == 0x201 || fragId == 0x203 || fragId >= 0x402))) ||
1509  (m_TBperiod==2022 && ((fragId&0xFF)<4 && !(fragId == 0x201 || (m_run >= 2210456 && fragId == 0x402)))))
1510  && fragType > 0 && m_pmtOrder)
1511 
1512  channel = digiChannel2PMT(fragType, channel);
1513 
1514 
1515  // gain determined for all digits in collection
1516  m_gainVec.at(index)[channel] = gain;
1517  ATH_MSG_DEBUG( "Storing TD for channel: " << channel
1518  << " with gain " << m_tileHWID->adc(hwid)
1519  << " index " << index );
1520 
1521  // get digits
1522  sampleVec = tile_digits->samples();
1523  int siz = sampleVec.size();
1524 
1525  if (msgLvl(MSG::DEBUG)) {
1526  msg(MSG::DEBUG) << "Digits(" << siz << ")." << (dcnt++) << " {";
1527  for (int i = 0; i < siz; i++) {
1528  msg(MSG::DEBUG) << static_cast<int>(sampleVec[i]) << " ";
1529  }
1530 
1531  if (siz > nSamplesInDrawer) {
1532  msg(MSG::DEBUG) << "} ONLY " << nSamplesInDrawer << " digits saved to ntuple" << endmsg;
1533  } else {
1534  msg(MSG::DEBUG) << "}" << endmsg;
1535  }
1536  }
1537 
1538  if (siz > nSamplesInDrawer) siz = nSamplesInDrawer;
1539  std::transform(sampleVec.begin(), sampleVec.begin() + siz, &m_sampleVec.at(index).get()[0] + nSamplesInDrawer * channel, [] (float v) {return static_cast<int>(v);});
1540  }
1541  }
1542  } else {
1543  // Digits in normal mode
1544  // store evtnr, bcid,crc, size
1545  m_rodBCIDVec.at(drawerIndex) = digitsCollection->getRODBCID();
1546  m_sizeVec.at(drawerIndex) = digitsCollection->getFragSize();
1547  m_evtVec.at(drawerIndex) = m_evtNr;
1548 
1549  headerVec = digitsCollection->getFragChipHeaderWords();
1550  CRCmask = digitsCollection->getFragDMUMask(); //mask of FE+ROD DMU crc check (16bit+16bit) 0xffffffff == All ok
1551  fe_crc = CRCmask & 0xFFFF;
1552  rod_crc = CRCmask >> 16;
1553 
1554  int headsize = headerVec.size();
1555 
1556  for (int ih = 0; ih < headsize; ++ih) {
1557  m_bcidVec.at(drawerIndex)[ih] = (headerVec[ih] & 0xFFF);
1558  m_DMUheaderVec.at(drawerIndex)[ih] = headerVec[ih];
1559  m_DMUformatErrVec.at(drawerIndex)[ih] = CheckDMUFormat(headerVec[ih]);
1560  m_DMUparityErrVec.at(drawerIndex)[ih] = CheckDMUParity(headerVec[ih]);
1561  m_DMUmemoryErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 25 & 0x1);
1562  m_DMUSstrobeErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 24 & 0x1);
1563  m_DMUDstrobeErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 23 & 0x1);
1564  m_feCRCVec.at(drawerIndex)[ih] = (fe_crc >> ih & 0x1);
1565  m_rodCRCVec.at(drawerIndex)[ih] = (rod_crc >> ih & 0x1);
1566 
1567  if (dqStatus) {
1568  m_DMUHeadparityErrVec.at(drawerIndex)[ih] = dqStatus->checkHeaderParityErr(ros, drawer, ih, 0);
1569  m_DMUDataparityErrVec.at(drawerIndex)[ih] = dqStatus->checkSampleParityErr(ros, drawer, ih, 0);
1570  }
1571  }
1572 
1573  m_slinkCRCVec.at(drawerIndex)[0] = (digitsCollection->getFragCRC() >> 16) & 0xffff;
1574  m_dmuMaskVec.at(drawerIndex)[0] = (digitsCollection->getFragDMUMask() >> 16) & 0xffff;
1575  m_slinkCRCVec.at(drawerIndex)[1] = digitsCollection->getFragCRC() & 0xffff;
1576  m_dmuMaskVec.at(drawerIndex)[1] = digitsCollection->getFragDMUMask() & 0xffff;
1577 
1578  int nSamplesInDrawer = m_nSamplesInDrawer[drawerIndex];
1579 
1580  int dcnt = 0;
1581  // go through all TileDigits in collection
1582  for (const TileDigits* tile_digits : *digitsCollection) {
1583  emptyColl = false;
1584 
1585  HWIdentifier hwid = tile_digits->adc_HWID();
1586  // determine channel
1587  channel = m_tileHWID->channel(hwid);
1588  // cabling for testbeam
1589  if ((m_TBperiod < 2015 ||
1590  (m_TBperiod==2015 && fragType<3) ||
1591  ((m_TBperiod==2016 || m_TBperiod==2021) && ((fragId&0xFF)<4 && fragId != 0x201)) ||
1592  (m_TBperiod==2017 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x203))) ||
1593  (m_TBperiod==2018 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x402))) ||
1594  (m_TBperiod==2019 && ((fragId&0xFF)<5 && !(fragId == 0x201 || fragId == 0x203 || fragId >= 0x402))) ||
1595  (m_TBperiod==2022 && ((fragId&0xFF)<4 && !(fragId == 0x201 || (m_run >= 2210456 && fragId == 0x402)))))
1596  && fragType > 0 && m_pmtOrder)
1597  channel = digiChannel2PMT(fragType, channel);
1598 
1599  // gain
1600  m_gainVec.at(drawerIndex)[channel] = m_tileHWID->adc(hwid);
1601  ATH_MSG_DEBUG( "Storing TD for channel: " << channel
1602  << " with gain " << m_tileHWID->adc(hwid) );
1603 
1604  // get digits
1605  sampleVec = tile_digits->samples();
1606  int siz = sampleVec.size();
1607  if (msgLvl(MSG::DEBUG)) {
1608  msg(MSG::DEBUG) << "Digits(" << siz << ")." << (dcnt++) << " {";
1609 
1610  for (int i = 0; i < siz; i++) {
1611  msg(MSG::DEBUG) << static_cast<int>(sampleVec[i]) << " ";
1612  }
1613 
1614  if (siz > nSamplesInDrawer) {
1615  msg(MSG::DEBUG) << "} ONLY " << nSamplesInDrawer << " digits saved to ntuple" << endmsg;
1616  } else {
1617  msg(MSG::DEBUG) << "}" << endmsg;
1618  }
1619  }
1620 
1621  if (siz > nSamplesInDrawer) siz = nSamplesInDrawer;
1622  std::transform(sampleVec.begin(), sampleVec.begin() + siz, &m_sampleVec.at(drawerIndex).get()[0] + nSamplesInDrawer * channel, [] (float v) {return static_cast<int>(v);});
1623  }
1624  }
1625  }
1626  // next container
1627  }
1628 
1629  if (emptyColl)
1630  return StatusCode::FAILURE;
1631  else
1632  return StatusCode::SUCCESS;
1633 }

◆ 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 1636 of file TileTBAANtuple.cxx.

1636  {
1637 
1638  if (containerKey.empty()) { // empty name, nothing to do
1639  return StatusCode::FAILURE;
1640  }
1641 
1642  // Read Digits from TES
1643  const TileDigitsContainer* digitsCntFlx = SG::makeHandle (containerKey, ctx).get();
1644 
1645  bool emptyColl = true;
1646 
1647  // drawerIndex is 0 - m_nDrawersFlx-1, fragType is 1-4 B+/B-/EB+/EB-
1648  int drawerIndex, channel;
1649 
1650  std::vector<float> sampleVecLo;
1651  std::vector<float> sampleVecHi;
1652  // Go through all TileDigitsCollections
1653  for (const TileDigitsCollection* digitsCollection : *digitsCntFlx) {
1654  // determine type of frag
1655  int fragId = digitsCollection->identify();
1656  drawerMap_iterator itr = m_drawerFlxMap.find(fragId);
1657  if ( itr != m_drawerFlxMap.end() ) {
1658  drawerIndex = (*itr).second;
1659  } else {
1660  drawerIndex = -1;
1661  }
1662 
1663  if (drawerIndex < 0) {
1664  if ( !digitsCollection->empty() )
1665  ATH_MSG_DEBUG( "FELIX frag id 0x" << MSG::hex << fragId << MSG::dec <<" was not found among valid frag IDs when storing TRC!" );
1666 
1667  } else {
1668 
1669  ATH_MSG_DEBUG( "Event# " << m_evtNr
1670  << " FELIX Frag id 0x" << MSG::hex << fragId << MSG::dec
1671  << " index " << drawerIndex);
1672 
1673  ATH_MSG_DEBUG( " Size=" << digitsCollection->getFragSize());
1674 
1675  ATH_MSG_DEBUG( " Lvl1ID=" << digitsCollection->getLvl1Id()
1676  << " EvBCID=" << digitsCollection->getRODBCID()
1677  << " EvType=" << digitsCollection->getDetEvType() );
1678  ATH_MSG_DEBUG( " Headers = "<< digitsCollection->getFragExtraWords() );
1679 
1680  if (m_completeNtuple) {
1685  int index = drawerIndex + m_nDrawers;
1686  m_l1ID.at(index) = digitsCollection->getLvl1Id();
1687  m_l1Type.at(index) = digitsCollection->getLvl1Type();
1688  m_evType.at(index) = digitsCollection->getDetEvType();
1689  m_evBCID.at(index) = digitsCollection->getRODBCID();
1690  // store FrBCID
1691  m_frBCID.at(index) = digitsCollection->getFragBCID();
1692  }
1693 
1694  // Digits in calib mode
1695  // check gain for first digits in collection
1696 
1697 
1698  std::vector<uint32_t> extraWords = digitsCollection->getFragExtraWords();
1699  if (extraWords.size() >= 10 * MAX_MINIDRAWER) {
1700 
1701  std::reference_wrapper<std::array<int,MAX_MINIDRAWER>>
1702  md[] = {m_mdL1idflxVec.at(drawerIndex), m_mdBcidflxVec.at(drawerIndex),
1703  m_mdModuleflxVec.at(drawerIndex), m_mdRunTypeflxVec.at(drawerIndex),
1704  m_mdRunflxVec.at(drawerIndex), m_mdPedLoflxVec.at(drawerIndex),
1705  m_mdPedHiflxVec.at(drawerIndex), m_mdChargeflxVec.at(drawerIndex),
1706  m_mdChargeTimeflxVec.at(drawerIndex), m_mdCapacitorflxVec.at(drawerIndex)};
1707 
1708  auto it = extraWords.begin();
1709  for (int i = 0; i < 10; ++i) {
1710  std::copy(it + i * MAX_MINIDRAWER, it + (i + 1) * MAX_MINIDRAWER, &md[i].get()[0]);
1711  }
1712 
1713  }
1714 
1715  int dcnt=0;
1716  // non empty collection
1717  if(!digitsCollection->empty()) {
1718  int drawerIndexHi = drawerIndex + m_nDrawersFlx;
1719  // store evtnr, bcid,crc, size
1720  if (m_bsInput) {
1721  m_rodBCIDflxVec.at(drawerIndex) = digitsCollection->getRODBCID();
1722  m_sizeflxVec.at(drawerIndex) = digitsCollection->getFragSize();
1723  m_evtflxVec.at(drawerIndex) = m_evtNr;
1724  }
1725 
1726  // go through all TileDigits in collection
1727  for (const TileDigits* tile_digits : *digitsCollection) {
1728  emptyColl = false;
1729  HWIdentifier hwid = tile_digits->adc_HWID();
1730  // determine gain
1731  int gain = m_tileHWID->adc(hwid);
1732  // add m_nDrawersFlx to index if hi gain
1733  int index = (gain == 1) ? drawerIndexHi : drawerIndex;
1734 
1735  // determine channel
1736  channel = m_tileHWID->channel(hwid);
1737  // cabling for testbeam (convert to pmt#-1)
1738 
1739  // gain determined for all digits in collection
1740  m_gainflxVec.at(index)[channel] = gain;
1741  ATH_MSG_DEBUG( "Storing TD for channel: " << channel
1742  << " with gain " << m_tileHWID->adc(hwid)
1743  << " index " << index );
1744 
1745  // get digits
1746  if (gain == 0) {
1747  sampleVecLo = tile_digits->samples();
1748  } else if (gain == 1) {
1749  sampleVecHi = tile_digits->samples();
1750  }
1751 
1752  int sizLo = sampleVecLo.size();
1753  int sizHi = sampleVecHi.size();
1754 
1755  int nSamplesInDrawer = m_nSamplesFlxInDrawer[index];
1756 
1757  if (msgLvl(MSG::DEBUG)) {
1758  if (sizLo > 0 ){
1759  msg(MSG::DEBUG) << "Low gain Digits(" << sizLo << ")." << (dcnt++) << " {";
1760  for (int i = 0; i < sizLo; i++) {
1761  msg(MSG::DEBUG) << static_cast<int>(sampleVecLo[i]) << " ";
1762  }
1763 
1764  if (sizLo > nSamplesInDrawer) {
1765  msg(MSG::DEBUG) << "} ONLY " << nSamplesInDrawer << " digits saved to ntuple" << endmsg;
1766  } else {
1767  msg(MSG::DEBUG) << "}" << endmsg;
1768  }
1769  }
1770 
1771  if (sizHi > 0 ){
1772  msg(MSG::DEBUG) << "High gain Digits(" << sizHi << ")." << (dcnt++) << " {";
1773  for (int i = 0; i < sizHi; i++) {
1774  msg(MSG::DEBUG) << static_cast<int>(sampleVecHi[i]) << " ";
1775  }
1776 
1777  if (sizHi > nSamplesInDrawer) {
1778  msg(MSG::DEBUG) << "} ONLY " << nSamplesInDrawer << " digits saved to ntuple" << endmsg;
1779  } else {
1780  msg(MSG::DEBUG) << "}" << endmsg;
1781  }
1782  }
1783 
1784 
1785  }
1786  if (sizLo > nSamplesInDrawer) sizLo = nSamplesInDrawer;
1787  if (sizHi > nSamplesInDrawer) sizHi = nSamplesInDrawer;
1788  std::transform(sampleVecLo.begin(), sampleVecLo.begin() + sizLo, &m_sampleflxVec.at(index).get()[0] + nSamplesInDrawer * channel, [] (float v) {return static_cast<int>(v);});
1789  std::transform(sampleVecHi.begin(), sampleVecHi.begin() + sizHi, &m_sampleflxVec.at(index).get()[0] + nSamplesInDrawer * channel, [] (float v) {return static_cast<int>(v);});
1790  sampleVecLo.clear();
1791  sampleVecHi.clear();
1792  }
1793  }
1794  }
1795  // next container
1796  }
1797 
1798  if (emptyColl)
1799  return StatusCode::FAILURE;
1800  else
1801  return StatusCode::SUCCESS;
1802 }

◆ 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 1901 of file TileTBAANtuple.cxx.

1904  {
1905 
1906  // determine channel
1907  HWIdentifier hwid = cinp->pmt_HWID();
1908  int channel = m_tileHWID->channel(hwid);
1909 
1910  int size = cinp->size();
1911  if (msgLvl(MSG::VERBOSE)) {
1912  msg(MSG::VERBOSE) << "hit hwid="
1913  << m_tileHWID->to_string(hwid, -1) << " ener=";
1914 
1915  for (int i = 0; i < size; ++i)
1916  msg(MSG::VERBOSE) << cinp->energy(i) << " ";
1917 
1918  msg(MSG::VERBOSE) << "time=";
1919  for (int i = 0; i < size; ++i)
1920  msg(MSG::VERBOSE) << cinp->time(i) << " ";
1921 
1922  msg(MSG::VERBOSE) << endmsg;
1923  }
1924 
1925  double ehit=0.0, thit=0.0;
1926  for(int i=0;i<size;++i) {
1927 
1928  double e = cinp->energy(i);
1929  double t = cinp->time(i);
1930 
1931  if (-75.<t && t<75.) {
1932  ehit += e;
1933  thit += e*t;
1934  }
1935  }
1936 
1937  if (ehit!=0) {
1938  thit /= ehit;
1939  // conversion factor from hit energy to final energy units
1940  int drawerIdx = TileCalibUtils::getDrawerIdxFromFragId(fragId);
1941  ehit *= samplingFraction->getSamplingFraction(drawerIdx, channel);
1942  if (m_rchUnit != TileRawChannelUnit::MegaElectronVolts) {
1943  ehit /= m_tileToolEmscale->channelCalib(drawerIdx, channel, TileID::HIGHGAIN, 1.,
1944  m_rchUnit, TileRawChannelUnit::MegaElectronVolts);
1945  }
1946  } else {
1947  thit=0.0;
1948  }
1949 
1950  // cabling for testbeam
1951  if ((m_TBperiod < 2015 ||
1952  (m_TBperiod==2015 && fragType<3) ||
1953  ((m_TBperiod==2016 || m_TBperiod==2021) && ((fragId&0xFF)<4 && fragId != 0x201)) ||
1954  (m_TBperiod==2017 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x203))) ||
1955  (m_TBperiod==2018 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x402))) ||
1956  (m_TBperiod==2019 && ((fragId&0xFF)<5 && !(fragId == 0x201 || fragId == 0x203 || fragId >= 0x402))) ||
1957  (m_TBperiod==2022 && ((fragId&0xFF)<4 && !(fragId == 0x201 || (m_run >= 2210456 && fragId == 0x402)))))
1958  && fragType > 0 && m_pmtOrder)
1959  channel = digiChannel2PMT(fragType, channel);
1960 
1961  ehitVec[channel] = ehit;
1962  thitVec[channel] = thit;
1963 
1964  ATH_MSG_DEBUG( "HIT ene=" << ehit
1965  << " time=" << thit
1966  << " pmt-1=" << channel
1967  << " index " << m_drawerMap.find(fragId)->second );
1968 
1969 }

◆ 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 1854 of file TileTBAANtuple.cxx.

1854  {
1855 
1856  if (m_hitContainerKey.empty()) { // empty name, nothing to do
1857  return StatusCode::FAILURE;
1858  }
1859 
1860  // Read Hit Vector from TDS
1861  const TileHitContainer* hitCnt = SG::makeHandle (m_hitContainerKey, ctx).get();
1862 
1863  SG::ReadCondHandle<TileSamplingFraction> samplingFraction(m_samplingFractionKey, ctx);
1864  ATH_CHECK( samplingFraction.isValid() );
1865 
1866  bool emptyColl = true;
1867 
1868  // Go through all TileHitCollections
1869  for (const TileHitCollection* hitCollection : *hitCnt) {
1870 
1871  // determine type of frag
1872  int fragId = hitCollection->identify();
1873  drawerMap_iterator itr = m_drawerMap.find(fragId);
1874  int drawerIndex = ( itr != m_drawerMap.end() ) ? (*itr).second : -1;
1875 
1876  if (drawerIndex < 0) {
1877  if ( !hitCollection->empty() )
1878  ATH_MSG_WARNING( "frag id 0x" << MSG::hex << fragId << MSG::dec <<" was not found among valid frag IDs when storing HITS!" );
1879 
1880  } else {
1881  int fragType = m_drawerType[drawerIndex];
1882 
1883  ATH_MSG_DEBUG( "Event# " << m_evtNr
1884  << " Frag id 0x" << MSG::hex << fragId << MSG::dec
1885  << " index " << drawerIndex );
1886 
1887  if (emptyColl) emptyColl = hitCollection->empty();
1888  // go through all TileHit in collection
1889  for (const TileHit* cinp : *hitCollection) {
1890  storeHit(cinp,fragType,fragId,m_ehitCnt.at(drawerIndex),m_thitCnt.at(drawerIndex),*samplingFraction);
1891  }
1892  }
1893  }
1894 
1895  if (emptyColl)
1896  return StatusCode::FAILURE;
1897  else
1898  return StatusCode::SUCCESS;
1899 }

◆ storeHitVector()

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

Definition at line 1809 of file TileTBAANtuple.cxx.

1809  {
1810 
1811  if (m_hitVectorKey.empty()) { // empty name, nothing to do
1812  return StatusCode::FAILURE;
1813  }
1814 
1815  // Read Hit Vector from TDS
1816  const TileHitVector* hitVec = SG::makeHandle (m_hitVectorKey, ctx).get();
1817 
1818  ATH_MSG_DEBUG( "Event# " << m_evtNr << " reading Hit Vector");
1819 
1820  SG::ReadCondHandle<TileSamplingFraction> samplingFraction(m_samplingFractionKey, ctx);
1821  ATH_CHECK( samplingFraction.isValid() );
1822 
1823  // Go through all TileHit
1824  for (const TileHit& cinp : *hitVec) {
1825 
1826  // get hits
1827  HWIdentifier hwid = cinp.pmt_HWID();
1828 
1829  // determine type of frag
1830  int fragId = m_tileHWID->frag(hwid);
1831  drawerMap_iterator itr = m_drawerMap.find(fragId);
1832  int drawerIndex = ( itr != m_drawerMap.end() ) ? (*itr).second : -1;
1833 
1834  if (drawerIndex < 0) {
1835  ATH_MSG_WARNING( "frag id 0x" << MSG::hex << fragId << MSG::dec <<" was not found among valid frag IDs when storing HITS!" );
1836 
1837  } else {
1838  int fragType = m_drawerType[drawerIndex];
1839  storeHit(&cinp,fragType,fragId,m_ehitVec.at(drawerIndex),m_thitVec.at(drawerIndex), *samplingFraction);
1840  }
1841  }
1842 
1843  if (hitVec->empty())
1844  return StatusCode::FAILURE;
1845  else
1846  return StatusCode::SUCCESS;
1847 }

◆ storeLaser()

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

Definition at line 456 of file TileTBAANtuple.cxx.

456  {
457 
458  if (m_laserObjectKey.empty()) { // empty name, nothing to do
459  return StatusCode::FAILURE;
460  }
461 
462  // Read Hit Vector from TDS
463  const TileLaserObject* laserObj = SG::makeHandle (m_laserObjectKey, ctx).get();
464 
465  m_las_BCID = laserObj->getBCID();
466 
467  m_las_Filt = laserObj->getFiltNumber();
468  m_las_ReqAmp = laserObj->getDiodeCurrOrd();
469  m_las_MeasAmp = laserObj->getDiodeCurrMeas();
470 
471 
472  m_las_D1_ADC = laserObj->getDiodeADC(0);
473  m_las_D2_ADC = laserObj->getDiodeADC(1);
474  m_las_D3_ADC = laserObj->getDiodeADC(2);
475  m_las_D4_ADC = laserObj->getDiodeADC(3);
476 
477  m_las_D1_Ped = laserObj->getDiodePedestal(0);
478  m_las_D2_Ped = laserObj->getDiodePedestal(1);
479  m_las_D3_Ped = laserObj->getDiodePedestal(2);
480  m_las_D4_Ped = laserObj->getDiodePedestal(3);
481 
482  m_las_D1_Ped_RMS = laserObj->getDiodeSigmaPedestal(0);
483  m_las_D2_Ped_RMS = laserObj->getDiodeSigmaPedestal(1);
484  m_las_D3_Ped_RMS = laserObj->getDiodeSigmaPedestal(2);
485  m_las_D4_Ped_RMS = laserObj->getDiodeSigmaPedestal(3);
486 
487  m_las_D1_Alpha = laserObj->getAlpha(0);
488  m_las_D2_Alpha = laserObj->getAlpha(1);
489  m_las_D3_Alpha = laserObj->getAlpha(2);
490  m_las_D4_Alpha = laserObj->getAlpha(3);
491 
492  m_las_D1_Alpha_RMS = laserObj->getSigmaAlpha(0);
493  m_las_D2_Alpha_RMS = laserObj->getSigmaAlpha(1);
494  m_las_D3_Alpha_RMS = laserObj->getSigmaAlpha(2);
495  m_las_D4_Alpha_RMS = laserObj->getSigmaAlpha(3);
496 
497  m_las_D1_AlphaPed = laserObj->getPedestalAlpha(0);
498  m_las_D2_AlphaPed = laserObj->getPedestalAlpha(1);
499  m_las_D3_AlphaPed = laserObj->getPedestalAlpha(2);
500  m_las_D4_AlphaPed = laserObj->getPedestalAlpha(3);
501 
502  m_las_D1_AlphaPed_RMS = laserObj->getSigmaPedAlpha(0);
503  m_las_D2_AlphaPed_RMS = laserObj->getSigmaPedAlpha(1);
504  m_las_D3_AlphaPed_RMS = laserObj->getSigmaPedAlpha(2);
505  m_las_D4_AlphaPed_RMS = laserObj->getSigmaPedAlpha(3);
506 
507  m_las_PMT1_ADC = laserObj->getPMADC(0);
508  m_las_PMT2_ADC = laserObj->getPMADC(1);
509 
510  m_las_PMT1_TDC = laserObj->getTDC(0);
511  m_las_PMT2_TDC = laserObj->getTDC(1);
512 
513  m_las_PMT1_Ped = laserObj->getPMPedestal(0);
514  m_las_PMT2_Ped = laserObj->getPMPedestal(1);
515 
516  m_las_PMT1_Ped_RMS = laserObj->getPMSigmaPedestal(0);
517  m_las_PMT2_Ped_RMS = laserObj->getPMSigmaPedestal(1);
518 
519  m_las_Temperature = laserObj->getPumpDiodeTemp();
520 
521  ATH_MSG_DEBUG( "storeLaser() completed" );
522 
523  return StatusCode::SUCCESS;
524 }

◆ 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 1183 of file TileTBAANtuple.cxx.

1191 {
1192 
1193 
1194  if (containerKey.empty()) {// empty name, nothing to do
1195  return StatusCode::FAILURE;
1196  }
1197 
1198  bool isFELIX = containerKey.key().find("Flx") != std::string::npos;
1199  int nDrawers = isFELIX ? m_nDrawersFlx : m_nDrawers;
1200  std::map<unsigned int, unsigned int, std::less<unsigned int>>& drawerMap = (isFELIX) ? m_drawerFlxMap : m_drawerMap;
1201 
1202  // get named container
1203  const TileRawChannelContainer* rcCnt = SG::makeHandle (containerKey, ctx).get();
1204 
1205  TileRawChannelUnit::UNIT rChUnit = rcCnt->get_unit();
1206  ATH_MSG_DEBUG( "RawChannel unit is " << rChUnit );
1207 
1208 
1209  if (rChUnit >= TileRawChannelUnit::OnlineADCcounts) { // this is container with DSP results
1210  m_dspUnit = rChUnit;
1211  m_dspFlags = rcCnt->get_bsflags() >> 16;
1212  ATH_MSG_DEBUG( "DSP flag is 0x" << MSG::hex << m_dspFlags << MSG::dec << " DSP unit is " << m_dspUnit );
1213 
1214  } else if ((m_useDspUnits || m_finalUnit >= TileRawChannelUnit::OnlineADCcounts)
1215  && rChUnit != TileRawChannelUnit::ADCcounts) {
1216 
1217  ATH_MSG_ERROR( "RawChannel units are not ADC counts, can't apply DSP-like calibration" );
1218  return StatusCode::FAILURE;
1219  }
1220 
1221  if (m_calibrateEnergyThisEvent) {
1222  if (m_useDspUnits) { // calibrate a-la online
1223  m_rchUnit = m_dspUnit;
1224  } else { // convert to final units
1225  m_rchUnit = (TileRawChannelUnit::UNIT)m_finalUnit.value();
1226  }
1227  } else {
1228  m_rchUnit = rChUnit;
1229  }
1230 
1231  ATH_MSG_DEBUG( "Final RawChannel unit is " << m_rchUnit );
1232 
1233  // drawerIndex is 0 - m_nDrawers-1, fragType is 1-4 B+/B-/EB+/EB-
1234  int drawerIndex, fragType;
1235 
1236  // Go through all TileRawChannelCollections
1237  for (const TileRawChannelCollection* rawChannelCollection : *rcCnt) {
1238  // determine type
1239  int fragId = rawChannelCollection->identify();
1240  int drawerIdx = TileCalibUtils::getDrawerIdxFromFragId(fragId);
1241 
1242  drawerMap_iterator itr = drawerMap.find(fragId);
1243  if ( itr != drawerMap.end() ) {
1244  drawerIndex = (*itr).second;
1245  } else {
1246  drawerIndex= -1;
1247  }
1248 
1249  if (drawerIndex < 0) {
1250  if ( !rawChannelCollection->empty() )
1251  ATH_MSG_DEBUG( "frag id 0x" << MSG::hex << fragId << MSG::dec << " was not found among valid frag IDs when storing TRC!" );
1252  } else {
1253  fragType = isFELIX ? fragId >> 8 : m_drawerType[drawerIndex];
1254  ATH_MSG_DEBUG( "TRC (" << containerKey.key()
1255  << ") Event# " << m_evtNr
1256  << " Frag id 0x" << MSG::hex << fragId << MSG::dec
1257  << " index "<< drawerIndex );
1258 
1259  // go through all TileRawChannels in collection
1260  for (const TileRawChannel* rch : *rawChannelCollection) {
1261  int index = drawerIndex;
1262  HWIdentifier hwid = rch->adc_HWID();
1263 
1264  // determine channel and gain
1265  int channel = m_tileHWID->channel(hwid);
1266  int gain = m_tileHWID->adc(hwid);
1267 
1268  if (calib_mode) {
1269  // gain, if hi add m_nDrawers to index
1270  if (gain == 1) index += nDrawers;
1271  }
1272 
1274  double energy = rch->amplitude();
1275  if (m_rchUnit != rChUnit) {
1276  if (m_rchUnit < TileRawChannelUnit::OnlineOffset)
1277  energy = m_tileToolEmscale->channelCalib(drawerIdx, channel, gain, energy, rChUnit, m_rchUnit);
1278  else
1279  energy = m_tileToolEmscale->channelCalibOnl(drawerIdx, channel, gain, energy, m_rchUnit);
1280  }
1281 
1282  // cabling for testbeam (convert to pmt#-1)
1283  if ((m_TBperiod < 2015 ||
1284  (m_TBperiod==2015 && fragType<3) ||
1285  ((m_TBperiod==2016 || m_TBperiod==2021) && ((fragId&0xFF)<4 && fragId != 0x201)) ||
1286  (m_TBperiod==2017 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x203))) ||
1287  (m_TBperiod==2018 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x402))) ||
1288  (m_TBperiod==2019 && ((fragId&0xFF)<5 && !(fragId == 0x201 || fragId == 0x203 || fragId >= 0x402))) ||
1289  (m_TBperiod==2022 && ((fragId&0xFF)<4 && !(fragId == 0x201 || (m_run >= 2210456 && fragId == 0x402)))))
1290  && fragType > 0 && m_pmtOrder)
1291  channel = digiChannel2PMT(fragType, channel);
1292 
1293  eneVec->at(index)[channel] = energy;
1294  timeVec->at(index)[channel] = rch->time();
1295  if (chi2Vec) {
1296  chi2Vec->at(index)[channel] = rch->quality();
1297  }
1298  if (pedVec) {
1299  pedVec->at(index)[channel] = rch->pedestal();
1300  }
1301 
1302  ATH_MSG_DEBUG( "TRC ene=" << energy
1303  << " time=" << rch->time()
1304  << " chi2=" << rch->quality()
1305  << " ped=" << rch->pedestal()
1306  << " pmt-1=" << channel
1307  << " index " << index );
1308 
1309  }
1310 
1311  if (saveDQstatus && !isFELIX) {
1312 
1313  int index1 = drawerIndex, index2 = drawerIndex + 1;
1314  if (calib_mode) index2 += m_nDrawers;
1315 
1316  for (int index = index1; index < index2; index += m_nDrawers) {
1317 
1318  m_ROD_GlobalCRCVec.at(index) = rawChannelCollection->getFragGlobalCRC() & 1;
1319  m_ROD_DMUMaskVec.at(index)[0] = rawChannelCollection->getFragRODChipMask();
1320  m_ROD_DMUMaskVec.at(index)[1] = rawChannelCollection->getFragFEChipMask();
1321 
1322  for (unsigned int dmu = 0; dmu < MAX_DMU; ++dmu) {
1323 
1324  m_ROD_DMUBCIDVec.at(index)[dmu] = (rawChannelCollection->getFragBCID() >> dmu) & 1;
1325  m_ROD_DMUmemoryErrVec.at(index)[dmu] = (rawChannelCollection->getFragMemoryPar() >> dmu) & 1;
1326  m_ROD_DMUSstrobeErrVec.at(index)[dmu] = (rawChannelCollection->getFragSstrobe() >> dmu) & 1;
1327  m_ROD_DMUDstrobeErrVec.at(index)[dmu] = (rawChannelCollection->getFragDstrobe() >> dmu) & 1;
1328  m_ROD_DMUHeadformatErrVec.at(index)[dmu] = (rawChannelCollection->getFragHeaderBit() >> dmu) & 1;
1329  m_ROD_DMUDataformatErrVec.at(index)[dmu] = (rawChannelCollection->getFragSampleBit() >> dmu) & 1;
1330  }
1331  }
1332  }
1333  }
1334  }
1335 
1336  return StatusCode::SUCCESS;
1337 }

◆ 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 2473 of file TileTBAANtuple.cxx.

2474 {
2475 
2476  m_ntuplePtr->Branch("EvTime",&m_evTime,"EvTime/I");
2477  m_ntuplePtr->Branch("Run",&m_run,"Run/I");
2478  m_ntuplePtr->Branch("Evt",&m_evt,"Evt/I");
2479  m_ntuplePtr->Branch("Trig",&m_trigType,"Trig/S");
2480  m_ntuplePtr->Branch("DSPflags",&m_dspFlags,"DSPflags/I");
2481  m_ntuplePtr->Branch("DSPunits",&m_dspUnit,"DSPunits/S");
2482  m_ntuplePtr->Branch("OFLunits",&m_rchUnit,"OFLunits/S");
2483 
2484  if ( m_completeNtuple ) {
2485  int nDrawersAll = m_nDrawers.value() + m_nDrawersFlx.value();
2486  if (nDrawersAll > 0) {
2487  m_l1ID.resize(nDrawersAll + 1);
2488  m_l1Type.resize(nDrawersAll + 1);
2489  m_evType.resize(nDrawersAll + 1);
2490  m_evBCID.resize(nDrawersAll + 1);
2491  m_frBCID.resize(nDrawersAll);
2492  }
2493 
2494  // Info from ROD headers
2495  // m_nDrawers drawers separately (i.e. with duplications) + Beam ROD
2496  m_ntuplePtr->Branch("L1ID",&m_l1ID);
2497  m_ntuplePtr->Branch("L1Type",&m_l1Type);
2498  m_ntuplePtr->Branch("EvType",&m_evType);
2499  m_ntuplePtr->Branch("EvBCID",&m_evBCID);
2500  m_ntuplePtr->Branch("FrBCID",&m_frBCID);
2501  }
2502 
2503 
2504 }

◆ TRIGGER_clearBranch()

void TileTBAANtuple::TRIGGER_clearBranch ( void  )
private

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

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

Definition at line 2572 of file TileTBAANtuple.cxx.

2572  {
2573 
2574  m_evTime = 0;
2575  m_run = 0;
2576  m_evt = 0;
2577  m_trigType = 0;
2578 
2579  if (m_completeNtuple) {
2580  std::fill(m_l1ID.begin(), m_l1ID.end(), 0);
2581  std::fill(m_l1Type.begin(), m_l1Type.end(), 0);
2582  std::fill(m_evType.begin(), m_evType.end(), 0);
2583  std::fill(m_evBCID.begin(), m_evBCID.end(), 0);
2584  std::fill(m_frBCID.begin(), m_frBCID.end(), 0);
2585  }
2586 }

◆ 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

std::vector<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_adderPayload

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

Definition at line 445 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 {false}
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 {-1}
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 {false}
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
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
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:3113
TileTBAANtuple::m_beamIdList
bool m_beamIdList[32]
Definition: TileTBAANtuple.h:607
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:215
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:185
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
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:24
ADD_FADC_FRAG
#define ADD_FADC_FRAG
Definition: TileTBFrag.h:29
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
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:3463
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:83
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
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:1809
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
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
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:109
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:2797
AtlasHitsVector
Definition: AtlasHitsVector.h:32
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:407
TileTBAANtuple::QDC_addBranch
void QDC_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add QDC variables to th...
Definition: TileTBAANtuple.cxx:2555
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_adderPayload
std::vector< int > m_adderPayload
Definition: TileTBAANtuple.h:445
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:1636
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:56
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:9
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:111
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:3652
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:2710
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:1970
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::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:3053
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:135
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:1345
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:3765
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:3037
TileLaserObject::getFiltNumber
int getFiltNumber() const
Definition: TileLaserObject.h:229
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
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:3759
TileTBAANtuple::ECAL_clearBranch
void ECAL_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree ECAL variable...
Definition: TileTBAANtuple.cxx:2606
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:274
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_adder
std::vector< int * > m_adder
Definition: TileTBAANtuple.h:444
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:3615
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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
TileHWID::adc
int adc(const HWIdentifier &id) const
extract adc field from HW identifier
Definition: TileHWID.h:193
TileTBAANtuple::MAX_DMU
@ MAX_DMU
Definition: TileTBAANtuple.h:106
TileTBAANtuple::setupBeamChambersBeforeTB2015
void setupBeamChambersBeforeTB2015(void)
Definition: TileTBAANtuple.cxx:3772
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
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
TileTBAANtuple::m_evTime
int m_evTime
Definition: TileTBAANtuple.h:352
TileTBAANtuple::m_calibrateEnergy
Gaudi::Property< bool > m_calibrateEnergy
Definition: TileTBAANtuple.h:165
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:3793
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::MAX_MINIDRAWER
@ MAX_MINIDRAWER
Definition: TileTBAANtuple.h:106
TileTBAANtuple::m_theta
float m_theta
Definition: TileTBAANtuple.h:612
lumiFormat.i
int i
Definition: lumiFormat.py:85
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:1854
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:2823
WRONG_CHANNEL
#define WRONG_CHANNEL(frag, chan)
Definition: TileTBAANtuple.cxx:53
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
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:2306
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:3738
CopyBlobFromCool.suff
suff
Definition: CopyBlobFromCool.py:121
TileTBAANtuple::setupBeamChambersTB2016_2020
void setupBeamChambersTB2016_2020(void)
Definition: TileTBAANtuple.cxx:3813
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::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:239
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:2130
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
TileTBAANtuple::m_completeNtuple
Gaudi::Property< bool > m_completeNtuple
Definition: TileTBAANtuple.h:170
TileTBAANtuple::initNTuple
StatusCode initNTuple(void)
Definition: TileTBAANtuple.cxx:2020
TileTBAANtuple::m_beamBC0Y1
Gaudi::Property< float > m_beamBC0Y1
Definition: TileTBAANtuple.h:200
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:79
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:233
TileTBAANtuple::MUON_clearBranch
void MUON_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree MUON variable...
Definition: TileTBAANtuple.cxx:2594
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:3126
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:2762
TileTBAANtuple::m_hitVectorKey
SG::ReadHandleKey< TileHitVector > m_hitVectorKey
Definition: TileTBAANtuple.h:150
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:1183
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:2617
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:3065
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:2540
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:240
TileTBAANtuple::NOT_SETUP
@ NOT_SETUP
Definition: TileTBAANtuple.h:105
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_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:2473
TileTBAANtuple::clear_init_minus1
void clear_init_minus1(std::vector< T > &vec)
Definition: TileTBAANtuple.cxx:3747
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:2629
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:2512
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:2945
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:154
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::MAX_CHAN
@ MAX_CHAN
Definition: TileTBAANtuple.h:106
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
TileTBAANtuple::m_las_D4_Alpha_RMS
double m_las_D4_Alpha_RMS
Definition: TileTBAANtuple.h:407
a
TList * a
Definition: liststreamerinfos.cxx:10
columnar::empty
bool empty() const noexcept
Definition: ObjectRange.h:163
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:2572
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:456
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:104
TileTBAANtuple::getEta
void getEta(void)
Definition: TileTBAANtuple.cxx:2397
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
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
PathResolver::find_file
static std::string find_file(const std::string &logical_file_name, const std::string &search_path)
Definition: PathResolver.cxx:183
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:567
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:629
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
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:2785
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:85
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
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:1901
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:26
TileTBAANtuple::CISPAR_clearBranch
void CISPAR_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree CISPAR variab...
Definition: TileTBAANtuple.cxx:2811
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
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
jobOptions.fileName
fileName
Definition: jobOptions.SuperChic_ALP2.py:39
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:2189
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
TileTBAANtuple::m_ntupleCreated
bool m_ntupleCreated
Definition: TileTBAANtuple.h:346
TileTBAANtuple::storeBeamElements
StatusCode storeBeamElements(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:526
TileTBAANtuple::DIGI_clearBranch
void DIGI_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// /Clear Tree DIGI variabl...
Definition: TileTBAANtuple.cxx:3408
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 Mon Sep 29 2025 21:51:26 for ATLAS Offline Software by   doxygen 1.8.18