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

class to produce TileCal commissioning ntuples More...

#include <TileTBAANtuple.h>

Inheritance diagram for TileTBAANtuple:
Collaboration diagram for TileTBAANtuple:

Public Member Functions

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

Protected Member Functions

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

Private Types

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

Private Member Functions

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

Private Attributes

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

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

◆ ADDER_clearBranch()

void TileTBAANtuple::ADDER_clearBranch ( void  )
private

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

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

Definition at line 2784 of file TileTBAANtuple.cxx.

2785 {
2786 
2787 
2788 }

◆ BEAM_addBranch()

void TileTBAANtuple::BEAM_addBranch ( void  )
private

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

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

Definition at line 2822 of file TileTBAANtuple.cxx.

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

◆ BEAM_clearBranch()

void TileTBAANtuple::BEAM_clearBranch ( void  )
private

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

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

Definition at line 2944 of file TileTBAANtuple.cxx.

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

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

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

◆ CISPAR_clearBranch()

void TileTBAANtuple::CISPAR_clearBranch ( void  )
private

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

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

Definition at line 2810 of file TileTBAANtuple.cxx.

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

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

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

◆ clear_init_minus1() [2/2]

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

Definition at line 3746 of file TileTBAANtuple.cxx.

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

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

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

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

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

◆ COINCBOARD_addBranch()

void TileTBAANtuple::COINCBOARD_addBranch ( void  )
private

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

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

Definition at line 3064 of file TileTBAANtuple.cxx.

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

◆ COINCBOARD_clearBranch()

void TileTBAANtuple::COINCBOARD_clearBranch ( void  )
private

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

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

Definition at line 3112 of file TileTBAANtuple.cxx.

3113 {
3114 
3115 
3116 
3117 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ DIGI_addBranch()

void TileTBAANtuple::DIGI_addBranch ( void  )
private

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

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

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

Definition at line 3125 of file TileTBAANtuple.cxx.

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

◆ DIGI_clearBranch()

void TileTBAANtuple::DIGI_clearBranch ( void  )
private

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

Definition at line 3407 of file TileTBAANtuple.cxx.

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

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

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

◆ ECAL_clearBranch()

void TileTBAANtuple::ECAL_clearBranch ( void  )
private

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

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

Definition at line 2605 of file TileTBAANtuple.cxx.

2606 {
2607 
2608 }

◆ ENETOTAL_addBranch()

void TileTBAANtuple::ENETOTAL_addBranch ( void  )
private

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

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

Definition at line 3036 of file TileTBAANtuple.cxx.

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

◆ ENETOTAL_clearBranch()

void TileTBAANtuple::ENETOTAL_clearBranch ( void  )
private

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

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

Definition at line 3052 of file TileTBAANtuple.cxx.

3053 {
3054 
3055 
3056 }

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

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

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

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

◆ FELIX_clearBranch()

void TileTBAANtuple::FELIX_clearBranch ( void  )
private

Definition at line 3614 of file TileTBAANtuple.cxx.

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

◆ getEta()

void TileTBAANtuple::getEta ( void  )
private

Definition at line 2396 of file TileTBAANtuple.cxx.

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

◆ HIT_addBranch()

void TileTBAANtuple::HIT_addBranch ( void  )
private

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

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

Definition at line 3651 of file TileTBAANtuple.cxx.

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

◆ HIT_clearBranch()

void TileTBAANtuple::HIT_clearBranch ( void  )
private

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

Definition at line 3737 of file TileTBAANtuple.cxx.

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

◆ 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_cellContainerKey.initialize(!m_cellContainerKey.empty() && m_completeNtuple && m_TBperiod < 2015) );
119 
120  ATH_CHECK( m_tileToolEmscale.retrieve() );
121  ATH_CHECK( m_adderFilterAlgTool.retrieve(EnableTool{m_unpackAdder}) );
122 
123  ATH_CHECK( m_dqStatusKey.initialize(SG::AllowEmpty) );
124 
125  return StatusCode::SUCCESS;
126 }

◆ initList()

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

Definition at line 2188 of file TileTBAANtuple.cxx.

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

◆ initListFlx()

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

Definition at line 2305 of file TileTBAANtuple.cxx.

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

◆ initNTuple()

StatusCode TileTBAANtuple::initNTuple ( void  )
private

Definition at line 2019 of file TileTBAANtuple.cxx.

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

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

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

◆ LASER_clearBranch()

void TileTBAANtuple::LASER_clearBranch ( void  )
private

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

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

Definition at line 2709 of file TileTBAANtuple.cxx.

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

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

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

◆ MUON_clearBranch()

void TileTBAANtuple::MUON_clearBranch ( void  )
private

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

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

Definition at line 2593 of file TileTBAANtuple.cxx.

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

◆ ntuple_clear()

StatusCode TileTBAANtuple::ntuple_clear ( )

Definition at line 1969 of file TileTBAANtuple.cxx.

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

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

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

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

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

◆ QDC_clearBranch()

void TileTBAANtuple::QDC_clearBranch ( void  )
private

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

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

Definition at line 2616 of file TileTBAANtuple.cxx.

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

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

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

◆ setupBeamChambersTB2015()

void TileTBAANtuple::setupBeamChambersTB2015 ( void  )
private

Definition at line 3792 of file TileTBAANtuple.cxx.

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

◆ setupBeamChambersTB2016_2020()

void TileTBAANtuple::setupBeamChambersTB2016_2020 ( void  )
private

Definition at line 3812 of file TileTBAANtuple.cxx.

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

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

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

◆ storeCells()

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

Definition at line 2129 of file TileTBAANtuple.cxx.

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

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

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

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

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

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

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

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

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

◆ storeHitVector()

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

Definition at line 1808 of file TileTBAANtuple.cxx.

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

◆ storeLaser()

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

Definition at line 455 of file TileTBAANtuple.cxx.

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

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

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

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

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

◆ TRIGGER_clearBranch()

void TileTBAANtuple::TRIGGER_clearBranch ( void  )
private

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

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

Definition at line 2571 of file TileTBAANtuple.cxx.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_adder

int** TileTBAANtuple::m_adder {}
private

Definition at line 444 of file TileTBAANtuple.h.

◆ m_adderFilterAlgTool

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

Definition at line 159 of file TileTBAANtuple.h.

◆ m_BarEne

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

Definition at line 580 of file TileTBAANtuple.h.

◆ m_bcidVec

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

Definition at line 514 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 606 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 472 of file TileTBAANtuple.h.

◆ m_btdc1

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

Definition at line 469 of file TileTBAANtuple.h.

◆ m_btdc2

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

Definition at line 470 of file TileTBAANtuple.h.

◆ m_btdcNchMultiHit

int TileTBAANtuple::m_btdcNchMultiHit[2] {}
private

Definition at line 476 of file TileTBAANtuple.h.

◆ m_btdcNhit

int TileTBAANtuple::m_btdcNhit[16] {}
private

Definition at line 475 of file TileTBAANtuple.h.

◆ m_cabling

const TileCablingService* TileTBAANtuple::m_cabling {nullptr}
private

Definition at line 627 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 619 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 455 of file TileTBAANtuple.h.

◆ m_cher2

uint32_t TileTBAANtuple::m_cher2 {}
private

Definition at line 456 of file TileTBAANtuple.h.

◆ m_cher3

uint32_t TileTBAANtuple::m_cher3 {}
private

Definition at line 457 of file TileTBAANtuple.h.

◆ m_chi2cVec

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

Definition at line 541 of file TileTBAANtuple.h.

◆ m_chi2DspVec

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

Definition at line 548 of file TileTBAANtuple.h.

◆ m_chi2FlatVec

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

Definition at line 533 of file TileTBAANtuple.h.

◆ m_chi2flxfitVec

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

Definition at line 552 of file TileTBAANtuple.h.

◆ m_chi2flxoptVec

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

Definition at line 556 of file TileTBAANtuple.h.

◆ m_chi2OptVec

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

Definition at line 545 of file TileTBAANtuple.h.

◆ m_chi2Vec

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

Definition at line 537 of file TileTBAANtuple.h.

◆ m_cispar

int TileTBAANtuple::m_cispar[16] {}
private

Definition at line 449 of file TileTBAANtuple.h.

◆ m_coincFlag1

int TileTBAANtuple::m_coincFlag1 {}
private

Definition at line 593 of file TileTBAANtuple.h.

◆ m_coincFlag2

int TileTBAANtuple::m_coincFlag2 {}
private

Definition at line 594 of file TileTBAANtuple.h.

◆ m_coincFlag3

int TileTBAANtuple::m_coincFlag3 {}
private

Definition at line 595 of file TileTBAANtuple.h.

◆ m_coincFlag4

int TileTBAANtuple::m_coincFlag4 {}
private

Definition at line 596 of file TileTBAANtuple.h.

◆ m_coincFlag5

int TileTBAANtuple::m_coincFlag5 {}
private

Definition at line 597 of file TileTBAANtuple.h.

◆ m_coincFlag6

int TileTBAANtuple::m_coincFlag6 {}
private

Definition at line 598 of file TileTBAANtuple.h.

◆ m_coincFlag7

int TileTBAANtuple::m_coincFlag7 {}
private

Definition at line 599 of file TileTBAANtuple.h.

◆ m_coincFlag8

int TileTBAANtuple::m_coincFlag8 {}
private

Definition at line 600 of file TileTBAANtuple.h.

◆ m_coincTrig1

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

Definition at line 584 of file TileTBAANtuple.h.

◆ m_coincTrig2

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

Definition at line 585 of file TileTBAANtuple.h.

◆ m_coincTrig3

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

Definition at line 586 of file TileTBAANtuple.h.

◆ m_coincTrig4

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

Definition at line 587 of file TileTBAANtuple.h.

◆ m_coincTrig5

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

Definition at line 588 of file TileTBAANtuple.h.

◆ m_coincTrig6

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

Definition at line 589 of file TileTBAANtuple.h.

◆ m_coincTrig7

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

Definition at line 590 of file TileTBAANtuple.h.

◆ m_coincTrig8

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

Definition at line 591 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 522 of file TileTBAANtuple.h.

◆ m_DMUDstrobeErrVec

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

Definition at line 519 of file TileTBAANtuple.h.

◆ m_DMUformatErrVec

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

Definition at line 516 of file TileTBAANtuple.h.

◆ m_DMUheaderVec

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

Definition at line 515 of file TileTBAANtuple.h.

◆ m_DMUHeadparityErrVec

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

Definition at line 521 of file TileTBAANtuple.h.

◆ m_dmuMaskVec

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

Definition at line 523 of file TileTBAANtuple.h.

◆ m_DMUmemoryErrVec

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

Definition at line 518 of file TileTBAANtuple.h.

◆ m_DMUparityErrVec

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

Definition at line 517 of file TileTBAANtuple.h.

◆ m_DMUSstrobeErrVec

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

Definition at line 520 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 603 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 602 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 622 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 546 of file TileTBAANtuple.h.

◆ m_efitcVec

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

Definition at line 538 of file TileTBAANtuple.h.

◆ m_efitVec

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

Definition at line 534 of file TileTBAANtuple.h.

◆ m_eflxfitVec

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

Definition at line 550 of file TileTBAANtuple.h.

◆ m_eflxoptVec

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

Definition at line 554 of file TileTBAANtuple.h.

◆ m_ehitCnt

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

Definition at line 616 of file TileTBAANtuple.h.

◆ m_ehitVec

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

Definition at line 614 of file TileTBAANtuple.h.

◆ m_eneAdd

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

Definition at line 445 of file TileTBAANtuple.h.

◆ m_eneVec

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

Definition at line 530 of file TileTBAANtuple.h.

◆ m_eOptVec

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

Definition at line 542 of file TileTBAANtuple.h.

◆ m_eta

float TileTBAANtuple::m_eta {}
private

Definition at line 610 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 507 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 503 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 581 of file TileTBAANtuple.h.

◆ m_feCRCVec

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

Definition at line 527 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 511 of file TileTBAANtuple.h.

◆ m_gainVec

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

Definition at line 525 of file TileTBAANtuple.h.

◆ m_GapEne

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

Definition at line 582 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 579 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 569 of file TileTBAANtuple.h.

◆ m_mdCapacitorflxVec

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

Definition at line 577 of file TileTBAANtuple.h.

◆ m_mdChargeflxVec

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

Definition at line 575 of file TileTBAANtuple.h.

◆ m_mdChargeTimeflxVec

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

Definition at line 576 of file TileTBAANtuple.h.

◆ m_mdL1idflxVec

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

Definition at line 568 of file TileTBAANtuple.h.

◆ m_mdModuleflxVec

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

Definition at line 570 of file TileTBAANtuple.h.

◆ m_mdPedHiflxVec

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

Definition at line 573 of file TileTBAANtuple.h.

◆ m_mdPedLoflxVec

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

Definition at line 572 of file TileTBAANtuple.h.

◆ m_mdRunflxVec

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

Definition at line 574 of file TileTBAANtuple.h.

◆ m_mdRunTypeflxVec

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

Definition at line 571 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 459 of file TileTBAANtuple.h.

◆ m_muTag

uint32_t TileTBAANtuple::m_muTag {}
private

Definition at line 458 of file TileTBAANtuple.h.

◆ m_muVeto

uint32_t TileTBAANtuple::m_muVeto {}
private

Definition at line 460 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 632 of file TileTBAANtuple.h.

◆ m_nSamplesFlxInDrawerMap

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

Definition at line 630 of file TileTBAANtuple.h.

◆ m_nSamplesInDrawer

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

Definition at line 631 of file TileTBAANtuple.h.

◆ m_nSamplesInDrawerMap

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

Definition at line 629 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 540 of file TileTBAANtuple.h.

◆ m_pedfitVec

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

Definition at line 536 of file TileTBAANtuple.h.

◆ m_pedFlatVec

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

Definition at line 532 of file TileTBAANtuple.h.

◆ m_pedflxfitVec

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

Definition at line 553 of file TileTBAANtuple.h.

◆ m_pedflxoptVec

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

Definition at line 557 of file TileTBAANtuple.h.

◆ m_pedOptVec

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

Definition at line 544 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 621 of file TileTBAANtuple.h.

◆ m_ROD_DMUBCIDVec

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

Definition at line 560 of file TileTBAANtuple.h.

◆ m_ROD_DMUDataformatErrVec

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

Definition at line 565 of file TileTBAANtuple.h.

◆ m_ROD_DMUDstrobeErrVec

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

Definition at line 563 of file TileTBAANtuple.h.

◆ m_ROD_DMUHeadformatErrVec

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

Definition at line 564 of file TileTBAANtuple.h.

◆ m_ROD_DMUMaskVec

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

Definition at line 566 of file TileTBAANtuple.h.

◆ m_ROD_DMUmemoryErrVec

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

Definition at line 561 of file TileTBAANtuple.h.

◆ m_ROD_DMUSstrobeErrVec

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

Definition at line 562 of file TileTBAANtuple.h.

◆ m_ROD_GlobalCRCVec

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

Definition at line 559 of file TileTBAANtuple.h.

◆ m_rodBCIDflxVec

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

Definition at line 508 of file TileTBAANtuple.h.

◆ m_rodBCIDVec

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

Definition at line 504 of file TileTBAANtuple.h.

◆ m_rodCRCVec

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

Definition at line 528 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 609 of file TileTBAANtuple.h.

◆ m_s1cou

uint32_t TileTBAANtuple::m_s1cou {}
private

Definition at line 452 of file TileTBAANtuple.h.

◆ m_s2cou

uint32_t TileTBAANtuple::m_s2cou {}
private

Definition at line 453 of file TileTBAANtuple.h.

◆ m_s2extra

int TileTBAANtuple::m_s2extra {}
private

Definition at line 462 of file TileTBAANtuple.h.

◆ m_s3cou

uint32_t TileTBAANtuple::m_s3cou {}
private

Definition at line 454 of file TileTBAANtuple.h.

◆ m_s3extra

int TileTBAANtuple::m_s3extra {}
private

Definition at line 463 of file TileTBAANtuple.h.

◆ m_sampleflxVec

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

Definition at line 512 of file TileTBAANtuple.h.

◆ m_sampleVec

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

Definition at line 526 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 633 of file TileTBAANtuple.h.

◆ m_sc1

int TileTBAANtuple::m_sc1 {}
private

Definition at line 465 of file TileTBAANtuple.h.

◆ m_sc2

int TileTBAANtuple::m_sc2 {}
private

Definition at line 466 of file TileTBAANtuple.h.

◆ m_scaler

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

Definition at line 471 of file TileTBAANtuple.h.

◆ m_sizeflxVec

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

Definition at line 509 of file TileTBAANtuple.h.

◆ m_sizeVec

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

Definition at line 505 of file TileTBAANtuple.h.

◆ m_slinkCRCVec

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

Definition at line 524 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 547 of file TileTBAANtuple.h.

◆ m_tfitcVec

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

Definition at line 539 of file TileTBAANtuple.h.

◆ m_tfitVec

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

Definition at line 535 of file TileTBAANtuple.h.

◆ m_tflxfitVec

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

Definition at line 551 of file TileTBAANtuple.h.

◆ m_tflxoptVec

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

Definition at line 555 of file TileTBAANtuple.h.

◆ m_theta

float TileTBAANtuple::m_theta {}
private

Definition at line 611 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 617 of file TileTBAANtuple.h.

◆ m_thitVec

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

Definition at line 615 of file TileTBAANtuple.h.

◆ m_tileHWID

const TileHWID* TileTBAANtuple::m_tileHWID {nullptr}
private

Definition at line 626 of file TileTBAANtuple.h.

◆ m_tileID

const TileID* TileTBAANtuple::m_tileID {nullptr}
private

Definition at line 625 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 446 of file TileTBAANtuple.h.

◆ m_timeVec

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

Definition at line 531 of file TileTBAANtuple.h.

◆ m_tjitter

int TileTBAANtuple::m_tjitter {}
private

Definition at line 473 of file TileTBAANtuple.h.

◆ m_tof

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

Definition at line 468 of file TileTBAANtuple.h.

◆ m_tOptVec

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

Definition at line 543 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 474 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 482 of file TileTBAANtuple.h.

◆ m_xCha1

float TileTBAANtuple::m_xCha1 {}
private

Definition at line 485 of file TileTBAANtuple.h.

◆ m_xCha1_0

float TileTBAANtuple::m_xCha1_0 {}
private

Definition at line 489 of file TileTBAANtuple.h.

◆ m_xCha2

float TileTBAANtuple::m_xCha2 {}
private

Definition at line 487 of file TileTBAANtuple.h.

◆ m_xCha2_0

float TileTBAANtuple::m_xCha2_0 {}
private

Definition at line 491 of file TileTBAANtuple.h.

◆ m_xChN1

float TileTBAANtuple::m_xChN1 {}
private

Definition at line 480 of file TileTBAANtuple.h.

◆ m_xChN2

float TileTBAANtuple::m_xChN2 {}
private

Definition at line 478 of file TileTBAANtuple.h.

◆ m_xImp

float TileTBAANtuple::m_xImp {}
private

Definition at line 493 of file TileTBAANtuple.h.

◆ m_xImp_0

float TileTBAANtuple::m_xImp_0 {}
private

Definition at line 496 of file TileTBAANtuple.h.

◆ m_xImp_90

float TileTBAANtuple::m_xImp_90 {}
private

Definition at line 498 of file TileTBAANtuple.h.

◆ m_xImp_min90

float TileTBAANtuple::m_xImp_min90 {}
private

Definition at line 500 of file TileTBAANtuple.h.

◆ m_yCha0

float TileTBAANtuple::m_yCha0 {}
private

Definition at line 483 of file TileTBAANtuple.h.

◆ m_yCha1

float TileTBAANtuple::m_yCha1 {}
private

Definition at line 486 of file TileTBAANtuple.h.

◆ m_yCha1_0

float TileTBAANtuple::m_yCha1_0 {}
private

Definition at line 490 of file TileTBAANtuple.h.

◆ m_yCha2

float TileTBAANtuple::m_yCha2 {}
private

Definition at line 488 of file TileTBAANtuple.h.

◆ m_yCha2_0

float TileTBAANtuple::m_yCha2_0 {}
private

Definition at line 492 of file TileTBAANtuple.h.

◆ m_yChN1

float TileTBAANtuple::m_yChN1 {}
private

Definition at line 481 of file TileTBAANtuple.h.

◆ m_yChN2

float TileTBAANtuple::m_yChN2 {}
private

Definition at line 479 of file TileTBAANtuple.h.

◆ m_yImp

float TileTBAANtuple::m_yImp {}
private

Definition at line 494 of file TileTBAANtuple.h.

◆ m_yImp_0

float TileTBAANtuple::m_yImp_0 {}
private

Definition at line 497 of file TileTBAANtuple.h.

◆ m_yImp_90

float TileTBAANtuple::m_yImp_90 {}
private

Definition at line 499 of file TileTBAANtuple.h.

◆ m_yImp_min90

float TileTBAANtuple::m_yImp_min90 {}
private

Definition at line 501 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:512
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:527
TileTBAANtuple::m_xCha1
float m_xCha1
Definition: TileTBAANtuple.h:485
TileTBAANtuple::m_pedflxoptVec
std::vector< std::array< float, MAX_CHAN > > m_pedflxoptVec
Definition: TileTBAANtuple.h:557
TileTBAANtuple::m_coincTrig4
std::array< unsigned int, 96 > m_coincTrig4
Definition: TileTBAANtuple.h:587
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:599
TileTBAANtuple::m_coincTrig3
std::array< unsigned int, 96 > m_coincTrig3
Definition: TileTBAANtuple.h:586
TileTBAANtuple::NOT_SETUP
@ NOT_SETUP
Definition: TileTBAANtuple.h:105
TileTBAANtuple::COINCBOARD_clearBranch
void COINCBOARD_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree COINCBOARD va...
Definition: TileTBAANtuple.cxx:3112
TileTBAANtuple::m_beamIdList
bool m_beamIdList[32]
Definition: TileTBAANtuple.h:606
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
TileTBAANtuple::m_beamBC0Z
Gaudi::Property< float > m_beamBC0Z
Definition: TileTBAANtuple.h:202
TileTBAANtuple::m_yChN2
float m_yChN2
Definition: TileTBAANtuple.h:479
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:576
TileTBAANtuple::m_s1cou
uint32_t m_s1cou
Definition: TileTBAANtuple.h:452
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:600
COMMON_PTN_FRAG
#define COMMON_PTN_FRAG
Definition: TileTBFrag.h:48
TileTBAANtuple::m_BarEne
std::array< float, 3 > m_BarEne
Definition: TileTBAANtuple.h:580
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:533
TileTBAANtuple::m_cellContainerKey
SG::ReadHandleKey< CaloCellContainer > m_cellContainerKey
Definition: TileTBAANtuple.h:153
hotSpotInTAG.suffix
string suffix
Definition: hotSpotInTAG.py:186
header
Definition: hcg.cxx:526
TileTBAANtuple::m_DMUSstrobeErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUSstrobeErrVec
Definition: TileTBAANtuple.h:520
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:478
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:481
TileTBAANtuple::m_gainflxVec
std::vector< std::array< int, MAX_CHAN > > m_gainflxVec
Definition: TileTBAANtuple.h:511
TileTBAANtuple::m_slinkCRCVec
std::vector< std::array< int, 2 > > m_slinkCRCVec
Definition: TileTBAANtuple.h:524
PathResolver::find_file
static std::string find_file(const std::string &logical_file_name, const std::string &search_path, SearchType search_type=LocalSearch)
Definition: PathResolver.cxx:251
TileTBAANtuple::m_muBack
std::array< float, 14 > m_muBack
Definition: TileTBAANtuple.h:368
TileTBAANtuple::m_las_ReqAmp
double m_las_ReqAmp
Definition: TileTBAANtuple.h:381
TileTBAANtuple::m_coincFlag4
int m_coincFlag4
Definition: TileTBAANtuple.h:596
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:468
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:541
TileTBAANtuple::m_mdRunTypeflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdRunTypeflxVec
Definition: TileTBAANtuple.h:571
TileTBAANtuple::m_DMUparityErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUparityErrVec
Definition: TileTBAANtuple.h:517
TileTBAANtuple::m_tscTOF
int m_tscTOF
Definition: TileTBAANtuple.h:474
TileTBAANtuple::m_beamBC2Y2
Gaudi::Property< float > m_beamBC2Y2
Definition: TileTBAANtuple.h:216
TileTBAANtuple::FELIX_addBranch
void FELIX_addBranch(void)
Definition: TileTBAANtuple.cxx:3462
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:509
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:603
TileTBAANtuple::m_las_Filt
int m_las_Filt
Definition: TileTBAANtuple.h:380
index
Definition: index.py:1
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TileTBAANtuple::m_drawerType
Gaudi::Property< std::vector< int > > m_drawerType
Definition: TileTBAANtuple.h:185
TileTBAANtuple::m_rodBCIDVec
std::vector< short > m_rodBCIDVec
Definition: TileTBAANtuple.h:504
TileTBAANtuple::storeHitVector
StatusCode storeHitVector(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:1808
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:534
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:518
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:590
TileTBAANtuple::m_mdBcidflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdBcidflxVec
Definition: TileTBAANtuple.h:569
TileTBAANtuple::m_chi2OptVec
std::vector< std::array< float, MAX_CHAN > > m_chi2OptVec
Definition: TileTBAANtuple.h:545
tree
TChain * tree
Definition: tile_monitor.h:30
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
TileTBAANtuple::m_pedFlatVec
std::vector< std::array< float, MAX_CHAN > > m_pedFlatVec
Definition: TileTBAANtuple.h:532
TileTBAANtuple::CISPAR_addBranch
void CISPAR_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree CISPAR variabl...
Definition: TileTBAANtuple.cxx:2796
AtlasHitsVector
Definition: AtlasHitsVector.h:33
TileTBAANtuple::m_calibrateEnergyThisEvent
bool m_calibrateEnergyThisEvent
Definition: TileTBAANtuple.h:619
TileTBAANtuple::m_btdcNhit
int m_btdcNhit[16]
Definition: TileTBAANtuple.h:475
skel.it
it
Definition: skel.GENtoEVGEN.py:396
TileTBAANtuple::QDC_addBranch
void QDC_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add QDC variables to th...
Definition: TileTBAANtuple.cxx:2554
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:560
TileTBAANtuple::m_muBackHit
float m_muBackHit
Definition: TileTBAANtuple.h:366
TileTBAANtuple::m_coincFlag3
int m_coincFlag3
Definition: TileTBAANtuple.h:595
TileTBAANtuple::m_samplingFractionKey
SG::ReadCondHandleKey< TileSamplingFraction > m_samplingFractionKey
Name of TileSamplingFraction in condition store.
Definition: TileTBAANtuple.h:111
WRONG_SAMPLE
#define WRONG_SAMPLE(frag, chan, size)
Definition: TileTBAANtuple.cxx:47
TileTBAANtuple::m_xImp_0
float m_xImp_0
Definition: TileTBAANtuple.h:496
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:577
TileTBAANtuple::m_pedOptVec
std::vector< std::array< float, MAX_CHAN > > m_pedOptVec
Definition: TileTBAANtuple.h:544
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:610
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:508
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:1635
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:602
COMMON_TOF_FRAG
#define COMMON_TOF_FRAG
Definition: TileTBFrag.h:45
Tile_Base_ID::HIGHGAIN
@ HIGHGAIN
Definition: Tile_Base_ID.h:57
TileTBAANtuple::m_muBackSum
float m_muBackSum
Definition: TileTBAANtuple.h:367
TileTBAANtuple::m_finalUnit
Gaudi::Property< int > m_finalUnit
Definition: TileTBAANtuple.h:167
TileTBAANtuple::m_las_D1_AlphaPed
double m_las_D1_AlphaPed
Definition: TileTBAANtuple.h:409
TileTBAANtuple::m_mdModuleflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdModuleflxVec
Definition: TileTBAANtuple.h:570
TileTBAANtuple::m_tfitcVec
std::vector< std::array< float, MAX_CHAN > > m_tfitcVec
Definition: TileTBAANtuple.h:539
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:12
TileTBAANtuple::m_yImp_90
float m_yImp_90
Definition: TileTBAANtuple.h:499
TileRawChannelUnit::OnlineADCcounts
@ OnlineADCcounts
Definition: TileRawChannelUnit.h:21
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:112
COMMON_ADC1_FRAG
#define COMMON_ADC1_FRAG
Definition: TileTBFrag.h:43
LASE_ADC_FRAG
#define LASE_ADC_FRAG
Definition: TileTBFrag.h:28
TileTBAANtuple::m_evtVec
std::vector< int > m_evtVec
Definition: TileTBAANtuple.h:503
TileTBAANtuple::HIT_addBranch
void HIT_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree HIT variables ...
Definition: TileTBAANtuple.cxx:3651
TileTBAANtuple::m_coincTrig6
std::array< unsigned int, 96 > m_coincTrig6
Definition: TileTBAANtuple.h:589
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:462
TileTBAANtuple::LASER_clearBranch
void LASER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree LASER variabl...
Definition: TileTBAANtuple.cxx:2709
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:497
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:550
checkRpcDigits.digit
digit
Definition: checkRpcDigits.py:186
TileTBAANtuple::m_xCha0
float m_xCha0
Definition: TileTBAANtuple.h:482
TileTBAANtuple::ntuple_clear
StatusCode ntuple_clear()
Definition: TileTBAANtuple.cxx:1969
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:515
TileTBAANtuple::m_commonPU
int m_commonPU
Definition: TileTBAANtuple.h:441
TileTBAANtuple::m_muHalo
uint32_t m_muHalo
Definition: TileTBAANtuple.h:459
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:3052
empty
bool empty(TH1 *h)
Definition: computils.cxx:295
TileTBAANtuple::m_yCha2_0
float m_yCha2_0
Definition: TileTBAANtuple.h:492
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:134
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:553
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:491
TileTBAANtuple::m_cher1
uint32_t m_cher1
Definition: TileTBAANtuple.h:455
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:573
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:1344
TileTBAANtuple::m_saveFelixData
bool m_saveFelixData
Definition: TileTBAANtuple.h:633
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:3764
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:551
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:3036
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:3758
TileTBAANtuple::ECAL_clearBranch
void ECAL_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree ECAL variable...
Definition: TileTBAANtuple.cxx:2605
TileTBAANtuple::m_eneVec
std::vector< std::array< float, MAX_CHAN > > m_eneVec
Definition: TileTBAANtuple.h:530
TileLaserObject::getSigmaPedAlpha
double getSigmaPedAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:180
TileTBAANtuple::m_thistSvc
ServiceHandle< ITHistSvc > m_thistSvc
Definition: TileTBAANtuple.h:342
TileTBAANtuple::m_beamBN1Y2
Gaudi::Property< float > m_beamBN1Y2
Definition: TileTBAANtuple.h:196
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
TileTBAANtuple::m_dmuMaskVec
std::vector< std::array< int, 2 > > m_dmuMaskVec
Definition: TileTBAANtuple.h:523
TileTBAANtuple::m_yImp_min90
float m_yImp_min90
Definition: TileTBAANtuple.h:501
TileTBAANtuple::m_s3extra
int m_s3extra
Definition: TileTBAANtuple.h:463
TileTBAANtuple::m_beamBN1X1
Gaudi::Property< float > m_beamBN1X1
Definition: TileTBAANtuple.h:193
TileTBAANtuple::m_dspRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_dspRawChannelContainerKey
Definition: TileTBAANtuple.h:132
TileTBAANtuple::m_cher3
uint32_t m_cher3
Definition: TileTBAANtuple.h:457
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
TileTBAANtuple::FELIX_clearBranch
void FELIX_clearBranch(void)
Definition: TileTBAANtuple.cxx:3614
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::setupBeamChambersBeforeTB2015
void setupBeamChambersBeforeTB2015(void)
Definition: TileTBAANtuple.cxx:3771
TileTBAANtuple::MAX_MINIDRAWER
@ MAX_MINIDRAWER
Definition: TileTBAANtuple.h:106
TileTBAANtuple::m_beamBN2Y1
Gaudi::Property< float > m_beamBN2Y1
Definition: TileTBAANtuple.h:190
TileTBAANtuple::m_yCha1_0
float m_yCha1_0
Definition: TileTBAANtuple.h:490
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:473
TileTBAANtuple::m_ExtEne
std::array< float, 3 > m_ExtEne
Definition: TileTBAANtuple.h:581
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
TileTBAANtuple::m_evTime
int m_evTime
Definition: TileTBAANtuple.h:352
TileTBAANtuple::m_calibrateEnergy
Gaudi::Property< bool > m_calibrateEnergy
Definition: TileTBAANtuple.h:165
FortranAlgorithmOptions.fileName
fileName
Definition: FortranAlgorithmOptions.py:13
AthCommonDataStore
Definition: AthCommonDataStore.h:52
TileTBAANtuple::m_beamBC2Z_0
Gaudi::Property< float > m_beamBC2Z_0
Definition: TileTBAANtuple.h:218
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
TileTBAANtuple::drawerMap_iterator
std::map< unsigned int, unsigned int, std::less< unsigned int > >::iterator drawerMap_iterator
Definition: TileTBAANtuple.h:604
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TileTBAANtuple::setupBeamChambersTB2015
void setupBeamChambersTB2015(void)
Definition: TileTBAANtuple.cxx:3792
TileTBAANtuple::m_btdc2
std::array< int, 16 > m_btdc2
Definition: TileTBAANtuple.h:470
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:626
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:547
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:609
TileTBAANtuple::setupPropertyDefaultValue
void setupPropertyDefaultValue(float property, float defaultValue, const std::string &name)
Definition: TileTBAANtuple.h:328
COIN_TRIG6_FRAG
#define COIN_TRIG6_FRAG
Definition: TileTBFrag.h:37
TileTBAANtuple::m_nSamplesFlx
Gaudi::Property< int > m_nSamplesFlx
Definition: TileTBAANtuple.h:174
TileTBAANtuple::m_theta
float m_theta
Definition: TileTBAANtuple.h:611
lumiFormat.i
int i
Definition: lumiFormat.py:85
TileTBAANtuple::m_chi2Vec
std::vector< std::array< float, MAX_CHAN > > m_chi2Vec
Definition: TileTBAANtuple.h:537
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:1853
TileTBAANtuple::m_flxOptRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_flxOptRawChannelContainerKey
Definition: TileTBAANtuple.h:141
TileTBAANtuple::MAX_CHAN
@ MAX_CHAN
Definition: TileTBAANtuple.h:106
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
TileTBAANtuple::m_tileID
const TileID * m_tileID
Definition: TileTBAANtuple.h:625
CaloCell_ID_FCS::TileBar0
@ TileBar0
Definition: FastCaloSim_CaloCell_ID.h:31
TileTBAANtuple::m_evtflxVec
std::vector< int > m_evtflxVec
Definition: TileTBAANtuple.h:507
TileTBAANtuple::m_sampleVec
std::vector< std::unique_ptr< int[]> > m_sampleVec
Definition: TileTBAANtuple.h:526
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:2822
WRONG_CHANNEL
#define WRONG_CHANNEL(frag, chan)
Definition: TileTBAANtuple.cxx:53
TileRawChannelUnit::OnlineOffset
@ OnlineOffset
Definition: TileRawChannelUnit.h:25
TileTBAANtuple::m_btdcNchMultiHit
int m_btdcNchMultiHit[2]
Definition: TileTBAANtuple.h:476
TileTBAANtuple::digiChannel2PMT
int digiChannel2PMT(int fragType, int chan)
Definition: TileTBAANtuple.h:296
TileTBAANtuple::m_muTag
uint32_t m_muTag
Definition: TileTBAANtuple.h:458
TileTBAANtuple::m_btdc
std::vector< std::vector< int > > * m_btdc
Definition: TileTBAANtuple.h:472
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:566
TileTBAANtuple::m_mdPedLoflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdPedLoflxVec
Definition: TileTBAANtuple.h:572
TileTBAANtuple::initListFlx
StatusCode initListFlx(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:2305
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:3737
TileTBAANtuple::setupBeamChambersTB2016_2020
void setupBeamChambersTB2016_2020(void)
Definition: TileTBAANtuple.cxx:3812
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:494
TileTBAANtuple::MAX_DMU
@ MAX_DMU
Definition: TileTBAANtuple.h:106
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:614
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:585
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:2129
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:454
TileTBAANtuple::m_cabling
const TileCablingService * m_cabling
Definition: TileTBAANtuple.h:627
TrigInDetValidation_Base.malloc
malloc
Definition: TrigInDetValidation_Base.py:132
TileTBAANtuple::m_completeNtuple
Gaudi::Property< bool > m_completeNtuple
Definition: TileTBAANtuple.h:170
TileTBAANtuple::initNTuple
StatusCode initNTuple(void)
Definition: TileTBAANtuple.cxx:2019
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:629
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
TileTBAANtuple::m_sizeVec
std::vector< short > m_sizeVec
Definition: TileTBAANtuple.h:505
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:598
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:2593
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:588
TileTBAANtuple::m_digitsContainerFlxKey
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerFlxKey
Definition: TileTBAANtuple.h:117
TileTBAANtuple::m_nSamplesInDrawer
std::vector< int > m_nSamplesInDrawer
Definition: TileTBAANtuple.h:631
maskDeadModules.ros
ros
Definition: maskDeadModules.py:35
TileTBAANtuple::m_DMUformatErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUformatErrVec
Definition: TileTBAANtuple.h:516
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:3125
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:498
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:2761
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:1182
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
fill
void fill(H5::Group &out_file, size_t iterations)
Definition: test-hdf5-writer.cxx:95
TileTBAANtuple::m_thitCnt
std::vector< std::array< float, MAX_CHAN > > m_thitCnt
Definition: TileTBAANtuple.h:617
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:2616
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:3064
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:535
TileTBAANtuple::m_fitcRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_fitcRawChannelContainerKey
Definition: TileTBAANtuple.h:135
TileTBAANtuple::m_s2cou
uint32_t m_s2cou
Definition: TileTBAANtuple.h:453
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:528
TileTBAANtuple::m_ROD_GlobalCRCVec
std::vector< short > m_ROD_GlobalCRCVec
Definition: TileTBAANtuple.h:559
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:449
TileTBAANtuple::m_xImp
float m_xImp
Definition: TileTBAANtuple.h:493
TileTBAANtuple::ECAL_addBranch
void ECAL_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add ECAL variables to t...
Definition: TileTBAANtuple.cxx:2539
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:228
TileDigits
Definition: TileDigits.h:30
TileTBAANtuple::m_ROD_DMUHeadformatErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUHeadformatErrVec
Definition: TileTBAANtuple.h:564
CaloCell_ID_FCS::TileExt1
@ TileExt1
Definition: FastCaloSim_CaloCell_ID.h:38
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
TileLaserObject::getBCID
int getBCID() const
Definition: TileLaserObject.h:335
TileTBAANtuple::m_las2
float m_las2
Definition: TileTBAANtuple.h:436
MAX_DRAWERS
#define MAX_DRAWERS
Definition: TileTBAANtuple.cxx:73
TileLaserObject::getDiodeADC
int getDiodeADC(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:95
TileTBAANtuple::m_adder
int ** m_adder
Definition: TileTBAANtuple.h:444
TileTBAANtuple::m_coincFlag2
int m_coincFlag2
Definition: TileTBAANtuple.h:594
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:487
TileTBAANtuple::m_coincTrig1
std::array< unsigned int, 96 > m_coincTrig1
Definition: TileTBAANtuple.h:584
TileTBAANtuple::m_las_D2_ADC
int m_las_D2_ADC
Definition: TileTBAANtuple.h:385
TileTBAANtuple::TRIGGER_addBranch
void TRIGGER_addBranch(void)
///////////////////////////////////////////////////////////////////////////
Definition: TileTBAANtuple.cxx:2472
TileTBAANtuple::clear_init_minus1
void clear_init_minus1(std::vector< T > &vec)
Definition: TileTBAANtuple.cxx:3746
TileTBAANtuple::m_btdc1
std::array< int, 16 > m_btdc1
Definition: TileTBAANtuple.h:469
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
TileTBAANtuple::LASER_addBranch
void LASER_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree LASER variable...
Definition: TileTBAANtuple.cxx:2628
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:568
TileTBAANtuple::m_coincFlag1
int m_coincFlag1
Definition: TileTBAANtuple.h:593
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:2511
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:2944
TileTBAANtuple::m_yCha1
float m_yCha1
Definition: TileTBAANtuple.h:486
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:546
TileTBAANtuple::m_tOptVec
std::vector< std::array< float, MAX_CHAN > > m_tOptVec
Definition: TileTBAANtuple.h:543
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:582
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:540
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:632
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::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:555
TileTBAANtuple::m_timeAdd
std::array< float, 16 > m_timeAdd
Definition: TileTBAANtuple.h:446
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:364
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:514
TileTBAANtuple::m_sc1
int m_sc1
Definition: TileTBAANtuple.h:465
TileTBAANtuple::m_las_D4_Alpha_RMS
double m_las_D4_Alpha_RMS
Definition: TileTBAANtuple.h:407
a
TList * a
Definition: liststreamerinfos.cxx:10
TileTBAANtuple::m_DMUHeadparityErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUHeadparityErrVec
Definition: TileTBAANtuple.h:521
TileTBAANtuple::m_dspUnit
TileRawChannelUnit::UNIT m_dspUnit
Unit for TileRawChannels in DSP.
Definition: TileTBAANtuple.h:622
TileTBAANtuple::TRIGGER_clearBranch
void TRIGGER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree TRIGGER varia...
Definition: TileTBAANtuple.cxx:2571
h
TileTBAANtuple::m_rchUnit
TileRawChannelUnit::UNIT m_rchUnit
Unit for TileRawChannels (ADC, pCb, MeV)
Definition: TileTBAANtuple.h:621
TileTBAANtuple::m_muCalib
std::array< float, 2 > m_muCalib
Definition: TileTBAANtuple.h:369
TileTBAANtuple::storeLaser
StatusCode storeLaser(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:455
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:562
TileTBAANtuple::getEta
void getEta(void)
Definition: TileTBAANtuple.cxx:2396
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TileTBAANtuple::m_las_PMT2_ADC
int m_las_PMT2_ADC
Definition: TileTBAANtuple.h:420
TileTBAANtuple::m_cher2
uint32_t m_cher2
Definition: TileTBAANtuple.h:456
CaloCell_ID_FCS::PreSamplerB
@ PreSamplerB
Definition: FastCaloSim_CaloCell_ID.h:19
TileTBAANtuple::m_unpackAdder
Gaudi::Property< bool > m_unpackAdder
Definition: TileTBAANtuple.h:169
TileTBAANtuple::m_mdRunflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdRunflxVec
Definition: TileTBAANtuple.h:574
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:483
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:556
TileTBAANtuple::m_coincFlag5
int m_coincFlag5
Definition: TileTBAANtuple.h:597
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
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:561
TileTBAANtuple::m_chi2DspVec
std::vector< std::array< float, MAX_CHAN > > m_chi2DspVec
Definition: TileTBAANtuple.h:548
TileTBAANtuple::m_DMUDstrobeErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUDstrobeErrVec
Definition: TileTBAANtuple.h:519
TileTBAANtuple::m_thitVec
std::vector< std::array< float, MAX_CHAN > > m_thitVec
Definition: TileTBAANtuple.h:615
TileTBAANtuple::m_evt
int m_evt
Definition: TileTBAANtuple.h:354
TileTBAANtuple::m_xChN1
float m_xChN1
Definition: TileTBAANtuple.h:480
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:466
TileTBAANtuple::m_DMUDataparityErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUDataparityErrVec
Definition: TileTBAANtuple.h:522
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:471
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:2784
TileTBAANtuple::m_las_D2_Ped_RMS
double m_las_D2_Ped_RMS
Definition: TileTBAANtuple.h:395
TileTBAANtuple::m_las_PMT2_Ped_RMS
double m_las_PMT2_Ped_RMS
Definition: TileTBAANtuple.h:429
TileTBAANtuple::m_beamBC1Z_90
Gaudi::Property< float > m_beamBC1Z_90
Definition: TileTBAANtuple.h:210
LArDigits2NtupleDumper.nSamples
nSamples
Definition: LArDigits2NtupleDumper.py:70
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
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:1900
TileTBAANtuple::m_ROD_DMUDataformatErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUDataformatErrVec
Definition: TileTBAANtuple.h:565
TileTBAANtuple::m_ROD_DMUDstrobeErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUDstrobeErrVec
Definition: TileTBAANtuple.h:563
TileTBAANtuple::m_adderFilterAlgTool
ToolHandle< TileRawChannelBuilderFlatFilter > m_adderFilterAlgTool
Definition: TileTBAANtuple.h:159
TileTBAANtuple::m_las_D1_Alpha
double m_las_D1_Alpha
Definition: TileTBAANtuple.h:399
calibdata.copy
bool copy
Definition: calibdata.py:27
TileTBAANtuple::CISPAR_clearBranch
void CISPAR_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree CISPAR variab...
Definition: TileTBAANtuple.cxx:2810
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
TileTBAANtuple::m_flxFitRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_flxFitRawChannelContainerKey
Definition: TileTBAANtuple.h:138
TileTBAANtuple::m_las_PMT1_Ped_RMS
double m_las_PMT1_Ped_RMS
Definition: TileTBAANtuple.h:428
TileTBAANtuple::m_las_D4_Alpha
double m_las_D4_Alpha
Definition: TileTBAANtuple.h:402
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
TileHWID::to_string
std::string to_string(const HWIdentifier &id, int level=0) const
extract all fields from HW identifier HWIdentifier get_all_fields ( const HWIdentifier & id,...
Definition: TileHWID.cxx:50
TileTBAANtuple::m_xCha1_0
float m_xCha1_0
Definition: TileTBAANtuple.h:489
TileTBAANtuple::m_timeVec
std::vector< std::array< float, MAX_CHAN > > m_timeVec
Definition: TileTBAANtuple.h:531
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:554
TileTBAANtuple::m_LarEne
std::array< float, 4 > m_LarEne
Definition: TileTBAANtuple.h:579
TileTBAANtuple::m_gainVec
std::vector< std::array< int, MAX_CHAN > > m_gainVec
Definition: TileTBAANtuple.h:525
TileTBAANtuple::m_nSamplesFlxInDrawerMap
std::map< int, int > m_nSamplesFlxInDrawerMap
Definition: TileTBAANtuple.h:630
TileTBAANtuple::m_eneAdd
std::array< float, 16 > m_eneAdd
Definition: TileTBAANtuple.h:445
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:552
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:2188
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
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
TileTBAANtuple::storeBeamElements
StatusCode storeBeamElements(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:525
TileTBAANtuple::DIGI_clearBranch
void DIGI_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// /Clear Tree DIGI variabl...
Definition: TileTBAANtuple.cxx:3407
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:616
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:542
TileTBAANtuple::m_coincTrig8
std::array< unsigned int, 96 > m_coincTrig8
Definition: TileTBAANtuple.h:591
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:536
TileTBAANtuple::m_muVeto
uint32_t m_muVeto
Definition: TileTBAANtuple.h:460
TileTBAANtuple::m_yCha2
float m_yCha2
Definition: TileTBAANtuple.h:488
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:538
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:500
TileTBAANtuple::m_mdChargeflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdChargeflxVec
Definition: TileTBAANtuple.h:575
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 Sun Dec 22 2024 21:48:56 for ATLAS Offline Software by   doxygen 1.8.18