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

#include "TBRec/CBNTAA_TBTPValidation.h"

Inheritance diagram for CBNTAA_TBTPValidation:
Collaboration diagram for CBNTAA_TBTPValidation:

Public Member Functions

 CBNTAA_TBTPValidation (const std::string &name, ISvcLocator *pSvcLocator)
 
 ~CBNTAA_TBTPValidation ()
 
virtual StatusCode CBNT_initialize ()
 
virtual StatusCode CBNT_execute ()
 
virtual StatusCode CBNT_finalize ()
 
virtual StatusCode initialize () override
 
virtual StatusCode execute () override
 
virtual StatusCode finalize () override
 
virtual StatusCode pre_execute ()
 
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 Types

enum  { NOT_VALID = -999 }
 

Protected Member Functions

template<class T >
void addBranch (const std::string &branchname, T &obj, const std::string &leaflist)
 
template<class T >
void addBranch (const std::string &branchname, T *&obj)
 
template<class T >
void addBranch (const std::string &branchname, T *&obj, int bufferSize, int splitLevel)
 
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...
 

Protected Attributes

std::string m_ntpath
 
std::string m_ntTitle
 
TTree * m_nt
 
MsgStream * m_log
 
const LArEM_ID * m_emId
 
const LArHEC_ID * m_hecId
 
const LArFCAL_ID * m_fcalId
 
const LArOnlineID * m_onlineId
 

Private Types

typedef double signal_type_TBBPCCont
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

std::string add_name (const char *base, const std::string &extension)
 
StatusCode CBNT_clear ()
 
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

bool m_neverReturnFailure
 
std::vector< unsigned int > * m_adc
 
std::vector< std::string > * m_tbDetectorName_TBADCRawCont
 
std::vector< bool > * m_overflow_TBADCRawCont
 
std::string m_containerKey1
 
std::vector< unsigned int > * m_tdc_raw
 
std::vector< bool > * m_underThreshold_raw
 
std::vector< std::string > * m_tbDetectorName_TBTDCRawCont
 
std::vector< bool > * m_overflow_TBTDCRawCont
 
std::string m_containerKey2
 
std::vector< float > * m_phase
 
std::vector< short > * m_phaseind
 
std::vector< float > * m_dTtoWAC
 
std::string m_containerKey3
 
std::vector< int > * m_ev_number
 
std::vector< int > * m_ev_clock
 
std::vector< int > * m_ev_type
 
std::vector< unsigned int > * m_run_num
 
std::vector< float > * m_beam_moment
 
std::vector< std::string > * m_beam_part
 
std::vector< float > * m_cryoX
 
std::vector< float > * m_cryoAngle
 
std::vector< float > * m_tableY
 
std::string m_containerKey4
 
std::vector< signal_type_TBBPCCont > * m_xPos
 
std::vector< signal_type_TBBPCCont > * m_yPos
 
std::vector< signal_type_TBBPCCont > * m_xErr
 
std::vector< signal_type_TBBPCCont > * m_yErr
 
std::vector< signal_type_TBBPCCont > * m_xPulse
 
std::vector< signal_type_TBBPCCont > * m_yPulse
 
std::vector< short > * m_hitnumber
 
std::vector< bool > * m_xPosOverflow
 
std::vector< bool > * m_yPosOverflow
 
std::vector< bool > * m_xPulseOverflow
 
std::vector< bool > * m_yPulseOverflow
 
std::vector< bool > * m_overflowSetFlag
 
std::vector< std::string > * m_tbDetectorName_TBBPCCont
 
std::vector< bool > * m_overflow_TBBPCCont
 
std::string m_containerKey5
 
std::vector< unsigned int > * m_channelID
 
std::vector< unsigned char > * m_gain
 
std::vector< unsigned short > * m_nSamples
 
std::vector< unsigned short > * m_samples
 
std::string m_containerKey6
 
std::vector< float > * m_signal_scint
 
std::vector< float > * m_time_signal_scint
 
std::vector< bool > * m_signal_overflow_scint
 
std::vector< bool > * m_time_overflow_scint
 
std::vector< std::string > * m_tbDetectorName_TBScintillatorCont
 
std::vector< bool > * m_overflow_TBScintillatorCont
 
std::string m_containerKey7
 
std::vector< double > * m_signals
 
std::vector< float > * m_signal_tCatch
 
std::vector< float > * m_time_signal_tCatch
 
std::vector< bool > * m_signal_overflow_tCatch
 
std::vector< bool > * m_time_overflow_tCatch
 
std::vector< std::string > * m_tbDetectorName_TBTailCatcher
 
std::vector< bool > * m_overflow_TBTailCatcher
 
std::string m_containerKey8
 
std::vector< int > * m_tdc_TBTDC
 
std::vector< int > * m_tdcmin_TBTDC
 
std::vector< float > * m_scale_TBTDC
 
std::vector< int > * m_phase_TBTDC
 
std::string m_containerKey9
 
std::vector< int > * m_hitNumberU
 
std::vector< int > * m_hitNumberV
 
std::vector< double > * m_residualu
 
std::vector< double > * m_residualv
 
std::vector< double > * m_chi2
 
std::vector< double > * m_chi2u
 
std::vector< double > * m_chi2v
 
std::vector< double > * m_angle
 
std::vector< double > * m_uslope
 
std::vector< double > * m_vslope
 
std::vector< double > * m_uintercept
 
std::vector< double > * m_vintercept
 
std::vector< double > * m_cryou
 
std::vector< double > * m_cryov
 
std::vector< double > * m_cryow
 
std::string m_containerKey10
 
std::vector< unsigned int > * m_triggerWord
 
std::vector< bool > * m_triggers
 
std::string m_containerKey11
 
std::vector< std::vector< float > > * m_cPos
 
std::vector< std::vector< float > > * m_cErr
 
std::vector< bool > * m_isX
 
std::vector< std::vector< float > > * m_clusterSize_c
 
std::vector< std::string > * m_tbDetectorName_TBMWPCCont
 
std::vector< bool > * m_overflow_TBMWPCCont
 
std::string m_containerKey12
 
std::vector< std::vector< unsigned > > * m_cPosOverflow
 
bool m_initialized
 
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

ntpl-dumper for all persistified TB classes.

Author
Iftach Sadeh

Definition at line 21 of file CBNTAA_TBTPValidation.h.

Member Typedef Documentation

◆ signal_type_TBBPCCont

typedef double CBNTAA_TBTPValidation::signal_type_TBBPCCont
private

Definition at line 65 of file CBNTAA_TBTPValidation.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
protectedinherited
Enumerator
NOT_VALID 

Definition at line 56 of file CBNT_TBRecBase.h.

56 {NOT_VALID = -999};

Constructor & Destructor Documentation

◆ CBNTAA_TBTPValidation()

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

Definition at line 21 of file CBNTAA_TBTPValidation.cxx.

21  : CBNT_TBRecBase(name, pSvcLocator)
22 {
23  declareProperty("NeverReturnFailure", m_neverReturnFailure=false);
24 
25  // TBADCRawCont
26  declareProperty("ContainerKey1",m_containerKey1="ADCRawCont");
27  m_adc=NULL;
28  m_tbDetectorName_TBADCRawCont=NULL;
29  m_overflow_TBADCRawCont=NULL;
30  // TBTDCRawCont
31  declareProperty("ContainerKey2",m_containerKey2="TDCRawCont");
32  m_tdc_raw=NULL;
33  m_underThreshold_raw=NULL;
34  m_tbDetectorName_TBTDCRawCont=NULL;
35  m_overflow_TBTDCRawCont=NULL;
36  // TBPhase
37  declareProperty("ContainerKey3",m_containerKey3="TBPhase");
38  m_phase=NULL;
39  m_phaseind=NULL;
40  m_dTtoWAC=NULL;
41  // TBEventInfo
42  declareProperty("m_containerKey4",m_containerKey4="TBEventInfo");
43  m_ev_number=NULL;
44  m_ev_clock=NULL;
45  m_ev_type=NULL;
46  m_run_num=NULL;
47  m_beam_moment=NULL;
48  m_beam_part=NULL;
49  m_cryoX=NULL;
50  m_cryoAngle=NULL;
51  m_tableY=NULL;
52  // TBBPCCont
53  declareProperty("m_containerKey5",m_containerKey5="BPCCont");
54  m_xPos=NULL;
55  m_yPos=NULL;
56  m_xErr=NULL;
57  m_yErr=NULL;
58  m_xPulse=NULL;
59  m_yPulse=NULL;
60  m_hitnumber=NULL;
61  m_xPosOverflow=NULL;
62  m_yPosOverflow=NULL;
63  m_xPulseOverflow=NULL;
64  m_yPulseOverflow=NULL;
65  m_overflowSetFlag=NULL;
66  m_tbDetectorName_TBBPCCont=NULL;
67  m_overflow_TBBPCCont=NULL;
68  // TBLArDigitContainer
69  declareProperty("m_containerKey6",m_containerKey6="FREE");
70  m_channelID=NULL;
71  m_gain=NULL;
72  m_nSamples=NULL;
73  m_samples=NULL;
74  // TBScintillatorCont
75  declareProperty("m_containerKey7",m_containerKey7="ScintillatorCont");
76  m_signal_scint=NULL;
77  m_time_signal_scint=NULL;
78  m_signal_overflow_scint=NULL;
79  m_time_overflow_scint=NULL;
80  m_tbDetectorName_TBScintillatorCont=NULL;
81  m_overflow_TBScintillatorCont=NULL;
82  // TBTailCatcher
83  declareProperty("m_containerKey8",m_containerKey8="TailCatcher");
84  m_signals=NULL;
85  m_signal_tCatch=NULL;
86  m_time_signal_tCatch=NULL;
87  m_signal_overflow_tCatch=NULL;
88  m_time_overflow_tCatch=NULL;
89  m_tbDetectorName_TBTailCatcher=NULL;
90  m_overflow_TBTailCatcher=NULL;
91  // TBTDC
92  declareProperty("m_containerKey9",m_containerKey9="TBTDC");
93  m_tdc_TBTDC=NULL;
94  m_tdcmin_TBTDC=NULL;
95  m_scale_TBTDC=NULL;
96  m_phase_TBTDC=NULL;
97  // TBTrack
98  declareProperty("m_containerKey10",m_containerKey10="Track");
99  m_hitNumberU=NULL;
100  m_hitNumberV=NULL;
101  m_residualu=NULL;
102  m_residualv=NULL;
103  m_chi2=NULL;
104  m_chi2u=NULL;
105  m_chi2v=NULL;
106  m_angle=NULL;
107  m_uslope=NULL;
108  m_vslope=NULL;
109  m_uintercept=NULL;
110  m_vintercept=NULL;
111  m_cryou=NULL;
112  m_cryov=NULL;
113  m_cryow=NULL;
114  // TBTriggerPatternUnit
115  declareProperty("m_containerKey11",m_containerKey11="TBTrigPat");
116  m_triggerWord=NULL;
117  m_triggers=NULL;
118  // TBMWPCCont
119  declareProperty("m_containerKey12",m_containerKey12="MWPCCont");
120  m_cPos=NULL;
121  m_cErr=NULL;
122  m_isX=NULL;
123  m_clusterSize_c=NULL;
124  m_cPosOverflow=NULL;
125  m_tbDetectorName_TBMWPCCont=NULL;
126  m_overflow_TBMWPCCont=NULL;
127 }

◆ ~CBNTAA_TBTPValidation()

CBNTAA_TBTPValidation::~CBNTAA_TBTPValidation ( )

Definition at line 130 of file CBNTAA_TBTPValidation.cxx.

131 {//Clean up arrays of ntuple entries (if they have been booked)
132 
133  // TBADCRawCont
134  if (m_adc) delete m_adc;
135  if (m_tbDetectorName_TBADCRawCont) delete m_tbDetectorName_TBADCRawCont;
136  if (m_overflow_TBADCRawCont) delete m_overflow_TBADCRawCont;
137  // TBTDCRawCont
138  if (m_tdc_raw) delete m_tdc_raw;
139  if (m_underThreshold_raw) delete m_underThreshold_raw;
140  if (m_tbDetectorName_TBTDCRawCont) delete m_tbDetectorName_TBTDCRawCont;
141  if (m_overflow_TBTDCRawCont) delete m_overflow_TBTDCRawCont;
142  // TBPhase
143  if (m_phase) delete m_phase;
144  if (m_phaseind) delete m_phaseind;
145  if (m_dTtoWAC) delete m_dTtoWAC;
146  // TBEventInfo
147  if (m_ev_number) delete m_ev_number;
148  if (m_ev_clock) delete m_ev_clock;
149  if (m_ev_type) delete m_ev_type;
150  if (m_run_num) delete m_run_num;
151  if (m_beam_moment) delete m_beam_moment;
152  if (m_beam_part) delete m_beam_part;
153  if (m_cryoX) delete m_cryoX;
154  if (m_cryoAngle) delete m_cryoAngle;
155  if (m_tableY) delete m_tableY;
156  // TBBPCCont
157  if (m_xPos) delete m_xPos;
158  if (m_yPos) delete m_yPos;
159  if (m_xErr) delete m_xErr;
160  if (m_yErr) delete m_yErr;
161  if (m_xPulse) delete m_xPulse;
162  if (m_yPulse) delete m_yPulse;
163  if (m_hitnumber) delete m_hitnumber;
164  if (m_xPosOverflow) delete m_xPosOverflow;
165  if (m_yPosOverflow) delete m_yPosOverflow;
166  if (m_xPulseOverflow) delete m_xPulseOverflow;
167  if (m_yPulseOverflow) delete m_yPulseOverflow;
168  if (m_overflowSetFlag) delete m_overflowSetFlag;
169  if (m_tbDetectorName_TBBPCCont) delete m_tbDetectorName_TBBPCCont;
170  if (m_overflow_TBBPCCont) delete m_overflow_TBBPCCont;
171  // TBLArDigitContainer
172  if (m_channelID) delete m_channelID;
173  if (m_gain) delete m_gain;
174  if (m_nSamples) delete m_nSamples;
175  if (m_samples) delete m_samples;
176  // TBScintillatorCont
177  if (m_signal_scint) delete m_signal_scint;
178  if (m_time_signal_scint) delete m_time_signal_scint;
179  if (m_signal_overflow_scint) delete m_signal_overflow_scint;
180  if (m_time_overflow_scint) delete m_time_overflow_scint;
181  if (m_tbDetectorName_TBScintillatorCont) delete m_tbDetectorName_TBScintillatorCont;
182  if (m_overflow_TBScintillatorCont) delete m_overflow_TBScintillatorCont;
183  // TBTailCatcher
184  if (m_signals) delete m_signals;
185  if (m_signal_tCatch) delete m_signal_tCatch;
186  if (m_time_signal_tCatch) delete m_time_signal_tCatch;
187  if (m_signal_overflow_tCatch) delete m_signal_overflow_tCatch;
188  if (m_time_overflow_tCatch) delete m_time_overflow_tCatch;
189  if (m_tbDetectorName_TBTailCatcher) delete m_tbDetectorName_TBTailCatcher;
190  if (m_overflow_TBTailCatcher) delete m_overflow_TBTailCatcher;
191  // TBTDC
192  if (m_tdc_TBTDC) delete m_tdc_TBTDC;
193  if (m_tdcmin_TBTDC) delete m_tdcmin_TBTDC;
194  if (m_scale_TBTDC) delete m_scale_TBTDC;
195  if (m_phase_TBTDC) delete m_phase_TBTDC;
196  // TBTrack
197  if (m_hitNumberU) delete m_hitNumberU;
198  if (m_hitNumberV) delete m_hitNumberV;
199  if (m_residualu) delete m_residualu;
200  if (m_residualv) delete m_residualv;
201  if (m_chi2) delete m_chi2;
202  if (m_chi2u) delete m_chi2u;
203  if (m_chi2v) delete m_chi2v;
204  if (m_angle) delete m_angle;
205  if (m_uslope) delete m_uslope;
206  if (m_vslope) delete m_vslope;
207  if (m_uintercept) delete m_uintercept;
208  if (m_vintercept) delete m_vintercept;
209  if (m_cryou) delete m_cryou;
210  if (m_cryov) delete m_cryov;
211  if (m_cryow) delete m_cryow;
212  // TBTriggerPatternUnit
213  if (m_triggerWord) delete m_triggerWord;
214  if (m_triggers) delete m_triggers;
215  // TBMWPCCont
216  if (m_cPos) delete m_cPos;
217  if (m_cErr) delete m_cErr;
218  if (m_isX) delete m_isX;
219  if (m_clusterSize_c) delete m_clusterSize_c;
220  if (m_cPosOverflow) delete m_cPosOverflow;
221  if (m_tbDetectorName_TBMWPCCont) delete m_tbDetectorName_TBMWPCCont;
222  if (m_overflow_TBMWPCCont) delete m_overflow_TBMWPCCont;
223 }

Member Function Documentation

◆ add_name()

std::string CBNTAA_TBTPValidation::add_name ( const char *  base,
const std::string &  extension 
)
private

Definition at line 825 of file CBNTAA_TBTPValidation.cxx.

825  {
826  std::string retval(base);
827  for (unsigned i=0;i<extension.size();i++) {
828  const char& ch=extension[i];
829  if (ch=='=' || ch==':' || ch=='/')
830  continue; //Inore these characters
831  else if (ch=='-')
832  retval.append("m");//replace by letter m
833  else if (ch=='+')
834  retval.append("p");//replace by letter p
835  else
836  retval.append(1,ch);
837  }
838  return retval;
839 }

◆ addBranch() [1/3]

template<class T >
void CBNT_TBRecBase::addBranch ( const std::string &  branchname,
T &  obj,
const std::string &  leaflist 
)
inlineprotectedinherited

Definition at line 44 of file CBNT_TBRecBase.h.

44  {
45  m_nt->Branch(branchname.c_str(), &obj, leaflist.c_str());
46  }

◆ addBranch() [2/3]

template<class T >
void CBNT_TBRecBase::addBranch ( const std::string &  branchname,
T *&  obj 
)
inlineprotectedinherited

Definition at line 47 of file CBNT_TBRecBase.h.

47  {
48  obj = new T();
49  m_nt->Branch(branchname.c_str(), &obj);
50  }

◆ addBranch() [3/3]

template<class T >
void CBNT_TBRecBase::addBranch ( const std::string &  branchname,
T *&  obj,
int  bufferSize,
int  splitLevel 
)
inlineprotectedinherited

Definition at line 51 of file CBNT_TBRecBase.h.

51  {
52  obj = new T();
53  m_nt->Branch(branchname.c_str(), &obj, bufferSize, splitLevel);
54  }

◆ CBNT_clear()

StatusCode CBNTAA_TBTPValidation::CBNT_clear ( )
privatevirtual

Reimplemented from CBNT_TBRecBase.

Definition at line 721 of file CBNTAA_TBTPValidation.cxx.

722 {
723 
724  // TBADCRawCont
725  if (m_adc) m_adc->clear();
726  if (m_tbDetectorName_TBADCRawCont) m_tbDetectorName_TBADCRawCont->clear();
727  if (m_overflow_TBADCRawCont) m_overflow_TBADCRawCont->clear();
728  // TBTDCRawCont
729  if (m_tdc_raw) m_tdc_raw->clear();
730  if (m_underThreshold_raw) m_underThreshold_raw->clear();
731  if (m_tbDetectorName_TBTDCRawCont) m_tbDetectorName_TBTDCRawCont->clear();
732  if (m_overflow_TBTDCRawCont) m_overflow_TBTDCRawCont->clear();
733  // TBPhase
734  if (m_phase) m_phase->clear();
735  if (m_phaseind) m_phaseind->clear();
736  if (m_dTtoWAC) m_dTtoWAC->clear();
737  // TBEventInfo
738  if (m_ev_number) m_ev_number->clear();
739  if (m_ev_clock) m_ev_clock->clear();
740  if (m_ev_type) m_ev_type->clear();
741  if (m_run_num) m_run_num->clear();
742  if (m_beam_moment) m_beam_moment->clear();
743  if (m_beam_part) m_beam_part->clear();
744  if (m_cryoX) m_cryoX->clear();
745  if (m_cryoAngle) m_cryoAngle->clear();
746  if (m_tableY) m_tableY->clear();
747  // TBBPCCont
748  if (m_xPos) m_xPos->clear();
749  if (m_yPos) m_yPos->clear();
750  if (m_xErr) m_xErr->clear();
751  if (m_yErr) m_yErr->clear();
752  if (m_xPulse) m_xPulse->clear();
753  if (m_yPulse) m_yPulse->clear();
754  if (m_hitnumber) m_hitnumber->clear();
755  if (m_xPosOverflow) m_xPosOverflow->clear();
756  if (m_yPosOverflow) m_yPosOverflow->clear();
757  if (m_xPulseOverflow) m_xPulseOverflow->clear();
758  if (m_yPulseOverflow) m_yPulseOverflow->clear();
759  if (m_overflowSetFlag) m_overflowSetFlag->clear();
760  if (m_tbDetectorName_TBBPCCont) m_tbDetectorName_TBBPCCont->clear();
761  if (m_overflow_TBBPCCont) m_overflow_TBBPCCont->clear();
762  // TBLArDigitContainer
763  if (m_channelID) m_channelID->clear();
764  if (m_gain) m_gain->clear();
765  if (m_nSamples) m_nSamples->clear();
766  if (m_samples) m_samples->clear();
767  // TBScintillatorCont
768  if (m_signal_scint) m_signal_scint->clear();
769  if (m_time_signal_scint) m_time_signal_scint->clear();
770  if (m_signal_overflow_scint) m_signal_overflow_scint->clear();
771  if (m_time_overflow_scint) m_time_overflow_scint->clear();
772  if (m_tbDetectorName_TBScintillatorCont) m_tbDetectorName_TBScintillatorCont->clear();
773  if (m_overflow_TBScintillatorCont) m_overflow_TBScintillatorCont->clear();
774  // TBTailCatcher
775  if (m_signals) m_signals->clear();
776  if (m_signal_tCatch) m_signal_tCatch->clear();
777  if (m_time_signal_tCatch) m_time_signal_tCatch->clear();
778  if (m_signal_overflow_tCatch) m_signal_overflow_tCatch->clear();
779  if (m_time_overflow_tCatch) m_time_overflow_tCatch->clear();
780  if (m_tbDetectorName_TBTailCatcher) m_tbDetectorName_TBTailCatcher->clear();
781  if (m_overflow_TBTailCatcher) m_overflow_TBTailCatcher->clear();
782  // TBTDC
783  if (m_tdc_TBTDC) m_tdc_TBTDC->clear();
784  if (m_tdcmin_TBTDC) m_tdcmin_TBTDC->clear();
785  if (m_scale_TBTDC) m_scale_TBTDC->clear();
786  if (m_phase_TBTDC) m_phase_TBTDC->clear();
787  // TBTrack
788  if (m_hitNumberU) m_hitNumberU->clear();
789  if (m_hitNumberV) m_hitNumberV->clear();
790  if (m_residualu) m_residualu->clear();
791  if (m_residualv) m_residualv->clear();
792  if (m_chi2) m_chi2->clear();
793  if (m_chi2u) m_chi2u->clear();
794  if (m_chi2v) m_chi2v->clear();
795  if (m_angle) m_angle->clear();
796  if (m_uslope) m_uslope->clear();
797  if (m_vslope) m_vslope->clear();
798  if (m_uintercept) m_uintercept->clear();
799  if (m_vintercept) m_vintercept->clear();
800  if (m_cryou) m_cryou->clear();
801  if (m_cryov) m_cryov->clear();
802  if (m_cryow) m_cryow->clear();
803  // TBTriggerPatternUnit
804  if (m_triggerWord) m_triggerWord->clear();
805  if (m_triggers) m_triggers->clear();
806  // TBMWPCCont
807  if (m_cPos) m_cPos->clear();
808  if (m_cErr) m_cErr->clear();
809  if (m_isX) m_isX->clear();
810  if (m_clusterSize_c) m_clusterSize_c->clear();
811  if (m_cPosOverflow) m_cPosOverflow->clear();
812  if (m_tbDetectorName_TBMWPCCont) m_tbDetectorName_TBMWPCCont->clear();
813  if (m_overflow_TBMWPCCont) m_overflow_TBMWPCCont->clear();
814 
815  return StatusCode::SUCCESS;
816 }

◆ CBNT_execute()

StatusCode CBNTAA_TBTPValidation::CBNT_execute ( )
virtual

Reimplemented from CBNT_TBRecBase.

Definition at line 327 of file CBNTAA_TBTPValidation.cxx.

328 {
329  // ----------------------------------------------------------------------------------------------------
330  // TBADCRawCont
331  // ----------------------------------------------------------------------------------------------------
332  const TBADCRawCont * adcCont;
333  StatusCode sc = evtStore()->retrieve(adcCont,m_containerKey1);
334  if (sc.isFailure()) {
335  ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBADCRawCont from StoreGate! key= " << m_containerKey1 << "\033[0m" );
336  } else {
337  ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBADCRawCont ( StoreGate key =" << m_containerKey1 << " ) ..."<< "\033[0m" );
338 
339  const unsigned nADC = (TBADCRawCont::size_type)adcCont->size();
340  m_adc->resize(nADC);
341  m_tbDetectorName_TBADCRawCont->resize(nADC);
342  m_overflow_TBADCRawCont->resize(nADC);
343 
344  unsigned NtupleVectorIndex = 0;
345  for (const TBADCRaw* adc : *adcCont) {
346  (*m_adc)[NtupleVectorIndex] = adc-> getADC();
347  (*m_tbDetectorName_TBADCRawCont)[NtupleVectorIndex] = adc-> getDetectorName();
348  (*m_overflow_TBADCRawCont)[NtupleVectorIndex] = adc-> isOverflow();
349  }
350  }
351 
352  // ----------------------------------------------------------------------------------------------------
353  // TBTDCRawCont
354  // ----------------------------------------------------------------------------------------------------
355  const TBTDCRawCont * tdcCont;
356  sc = evtStore()->retrieve(tdcCont,m_containerKey2);
357  if (sc.isFailure()) {
358  ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBTDCRawCont from StoreGate! key= " << m_containerKey2 << "\033[0m" );
359  } else {
360  ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBTDCRawCont ( StoreGate key =" << m_containerKey2 << " ) ..."<< "\033[0m" );
361 
362  const unsigned nTDC = (TBTDCRawCont::size_type)tdcCont->size();
363  m_tdc_raw->resize(nTDC);
364  m_underThreshold_raw->resize(nTDC);
365  m_tbDetectorName_TBTDCRawCont->resize(nTDC);
366  m_overflow_TBTDCRawCont->resize(nTDC);
367 
368  unsigned NtupleVectorIndex = 0;
369  for (const TBTDCRaw* tdc : *tdcCont) {
370  (*m_tdc_raw)[NtupleVectorIndex] = tdc-> getTDC();
371  (*m_underThreshold_raw)[NtupleVectorIndex] = tdc-> isUnderThreshold();
372  (*m_tbDetectorName_TBTDCRawCont)[NtupleVectorIndex] = tdc-> getDetectorName();
373  (*m_overflow_TBTDCRawCont)[NtupleVectorIndex] = tdc-> isOverflow();
374  }
375  }
376 
377  // ----------------------------------------------------------------------------------------------------
378  // TBPhase
379  // ----------------------------------------------------------------------------------------------------
380  const TBPhase * phase = nullptr;
381  sc = evtStore()->retrieve(phase,m_containerKey3);
382  if (sc.isFailure()) {
383  ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBPhase from StoreGate! key= " << m_containerKey3 << "\033[0m" );
384  } else {
385  ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBPhase ( StoreGate key =" << m_containerKey3 << " ) ..."<< "\033[0m" );
386 
387  m_phase ->resize(1);
388  m_phaseind ->resize(1);
389  m_dTtoWAC ->resize(1);
390 
391  (*m_phase)[0] = phase-> getPhase();
392  (*m_phaseind)[0] = phase-> getPhaseind();
393  (*m_dTtoWAC)[0] = phase-> getdTtoWACSigned();
394  }
395 
396  // ----------------------------------------------------------------------------------------------------
397  // TBEventInfo
398  // ----------------------------------------------------------------------------------------------------
399  const TBEventInfo * EventInfo = nullptr;
400  sc = evtStore()->retrieve(EventInfo,m_containerKey4);
401  if (sc.isFailure()) {
402  ATH_MSG_ERROR ( "\033[31m" << "- Can not read EventInfo from StoreGate! key= " << m_containerKey4 << "\033[0m" );
403  } else {
404  ATH_MSG_DEBUG ( "\033[34m" << "- Going over EventInfo ( StoreGate key =" << m_containerKey4 << " ) ..."<< "\033[0m" );
405 
406  m_ev_number ->resize(1);
407  m_ev_clock ->resize(1);
408  m_ev_type ->resize(1);
409  m_run_num ->resize(1);
410  m_beam_moment ->resize(1);
411  m_beam_part ->resize(1);
412  m_cryoX ->resize(1);
413  m_cryoAngle ->resize(1);
414  m_tableY ->resize(1);
415 
416  (*m_ev_number)[0] = EventInfo-> getEventNum();
417  (*m_ev_clock)[0] = EventInfo-> getEventClock();
418  (*m_ev_type)[0] = EventInfo-> getEventType();
419  (*m_run_num)[0] = EventInfo-> getRunNum();
420  (*m_beam_moment)[0] = EventInfo-> getBeamMomentum();
421  (*m_beam_part)[0] = EventInfo-> getBeamParticle();
422  (*m_cryoX)[0] = EventInfo-> getCryoX();
423  (*m_cryoAngle)[0] = EventInfo-> getCryoAngle();
424  (*m_tableY)[0] = EventInfo-> getTableY();
425  }
426 
427 
428  // ----------------------------------------------------------------------------------------------------
429  // TBBPCCont
430  // ----------------------------------------------------------------------------------------------------
431  const TBBPCCont * BPCCont = nullptr;
432  sc = evtStore()->retrieve(BPCCont,m_containerKey5);
433  if (sc.isFailure()) {
434  ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBBPCCont from StoreGate! key= " << m_containerKey5 << "\033[0m" );
435  } else {
436  ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBBPCCont ( StoreGate key =" << m_containerKey5 << " ) ..."<< "\033[0m" );
437 
438  const unsigned nBPCCont = (TBBPCCont::size_type)BPCCont->size();
439  m_xPos ->resize(nBPCCont);
440  m_yPos ->resize(nBPCCont);
441  m_xErr ->resize(nBPCCont);
442  m_yErr ->resize(nBPCCont);
443  m_xPulse ->resize(nBPCCont);
444  m_yPulse ->resize(nBPCCont);
445  m_hitnumber ->resize(nBPCCont);
446  m_xPosOverflow ->resize(nBPCCont);
447  m_yPosOverflow ->resize(nBPCCont);
448  m_xPulseOverflow ->resize(nBPCCont);
449  m_yPulseOverflow ->resize(nBPCCont);
450  m_overflowSetFlag ->resize(nBPCCont);
451  m_tbDetectorName_TBBPCCont ->resize(nBPCCont);
452  m_overflow_TBBPCCont ->resize(nBPCCont);
453 
454  unsigned NtupleVectorIndex = 0;
455  for (const TBBPC* bpc : *BPCCont) {
456  (*m_xPos)[NtupleVectorIndex] = bpc-> getXPos();
457  (*m_yPos)[NtupleVectorIndex] = bpc-> getYPos();
458  (*m_xErr)[NtupleVectorIndex] = bpc-> getXErr();
459  (*m_yErr)[NtupleVectorIndex] = bpc-> getYErr();
460  (*m_xPulse)[NtupleVectorIndex] = bpc-> getXPulse();
461  (*m_yPulse)[NtupleVectorIndex] = bpc-> getYPulse();
462  (*m_hitnumber)[NtupleVectorIndex] = bpc-> getHitNbr();
463  (*m_xPosOverflow)[NtupleVectorIndex] = bpc-> isXPosOverflow();
464  (*m_yPosOverflow)[NtupleVectorIndex] = bpc-> isYPosOverflow();
465  (*m_xPulseOverflow)[NtupleVectorIndex] = bpc-> isXPulseOverflow();
466  (*m_yPulseOverflow)[NtupleVectorIndex] = bpc-> isYPulseOverflow();
467  (*m_overflowSetFlag)[NtupleVectorIndex] = false;//bpc-> m_overflowSetFlag ;
468  (*m_tbDetectorName_TBBPCCont)[NtupleVectorIndex] = bpc-> getDetectorName();
469  (*m_overflow_TBBPCCont)[NtupleVectorIndex] = bpc-> isOverflow();
470  }
471  }
472 
473 
474  // ----------------------------------------------------------------------------------------------------
475  // TBLArDigitContainer // FIXME !!! probably does not work right.... //
476  // ----------------------------------------------------------------------------------------------------
477  const TBLArDigitContainer * LArDigitContainer = nullptr;
478  sc = evtStore()->retrieve(LArDigitContainer,m_containerKey6);
479  if (sc.isFailure()) {
480  ATH_MSG_ERROR ( "\033[31m" << "- Can not read LArDigitContainer from StoreGate! key= " << m_containerKey6 << "\033[0m" );
481  } else {
482  ATH_MSG_DEBUG ( "\033[34m" << "- Going over LArDigitContainer ( StoreGate key =" << m_containerKey6 << " ) ..."<< "\033[0m" );
483 
484  const unsigned nLArDigits = (TBLArDigitContainer::size_type)LArDigitContainer->size();
485  m_channelID->resize(nLArDigits);
486  m_gain->resize(nLArDigits);
487  m_nSamples->resize(nLArDigits);
488  if (nLArDigits)
489  m_samples->reserve( ( (*(LArDigitContainer->begin()))->nsamples() ) * nLArDigits);
490 
491  unsigned NtupleVectorIndex = 0;
492  for (const LArDigit* larDigit : *LArDigitContainer) {
493  (*m_channelID)[NtupleVectorIndex] = larDigit->hardwareID().get_identifier32().get_compact() ;
494  (*m_gain)[NtupleVectorIndex] = (unsigned char)larDigit->gain();
495 
496  unsigned nM_samples = larDigit->nsamples();
497  (*m_nSamples)[NtupleVectorIndex] = nM_samples;
498 
499  m_samples->assign (larDigit->samples().begin(),
500  larDigit->samples().end());
501  }
502  }
503 
504 
505  // ----------------------------------------------------------------------------------------------------
506  // TBScintillatorCont
507  // ----------------------------------------------------------------------------------------------------
508  const TBScintillatorCont * ScintillatorCont = nullptr;
509  sc = evtStore()->retrieve(ScintillatorCont,m_containerKey7);
510  if (sc.isFailure()) {
511  ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBScintillatorCont from StoreGate! key= " << m_containerKey7 << "\033[0m" );
512  } else {
513  ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBScintillatorCont ( StoreGate key =" << m_containerKey7 << " ) ..."<< "\033[0m" );
514 
515  const unsigned nScintillators = (TBScintillatorCont::size_type)ScintillatorCont->size();
516  m_signal_scint ->resize(nScintillators);
517  m_time_signal_scint ->resize(nScintillators);
518  m_signal_overflow_scint ->resize(nScintillators);
519  m_time_overflow_scint ->resize(nScintillators);
520  m_tbDetectorName_TBScintillatorCont ->resize(nScintillators);
521  m_overflow_TBScintillatorCont ->resize(nScintillators);
522 
523 
524  unsigned NtupleVectorIndex = 0;
525  TBScintillatorCont::const_iterator it_TBScintillatorCont = ScintillatorCont->begin();
526  TBScintillatorCont::const_iterator last_TBScintillatorCont = ScintillatorCont->end();
527  for(;it_TBScintillatorCont!=last_TBScintillatorCont;++it_TBScintillatorCont,NtupleVectorIndex++) {
528  // scint->isTimeOverflow() is not a constant method, and so we define here
529  // 'TBScintillator * scint' instead of the usual 'const TBScintillator * scint'
530  // since for a const TBScintillator all methods need to be const as well...
531  const TBScintillator * scint = (*it_TBScintillatorCont);
532 
533  (*m_signal_scint)[NtupleVectorIndex] = scint-> getSignal();
534  (*m_time_signal_scint)[NtupleVectorIndex] = scint-> getTimeSignal();
535  (*m_signal_overflow_scint)[NtupleVectorIndex] = scint-> isSignalOverflow();
536  (*m_time_overflow_scint)[NtupleVectorIndex] = scint-> isTimeOverflow();
537  (*m_tbDetectorName_TBScintillatorCont)[NtupleVectorIndex] = scint-> getDetectorName();
538  (*m_overflow_TBScintillatorCont)[NtupleVectorIndex] = scint-> isOverflow();
539  }
540  }
541 
542 
543  // ----------------------------------------------------------------------------------------------------
544  // TBTailCatcher
545  // ----------------------------------------------------------------------------------------------------
546  const TBTailCatcher * TailCatcher = nullptr;
547  sc = evtStore()->retrieve(TailCatcher,m_containerKey8);
548  if (sc.isFailure()) {
549  ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBTailCatcher from StoreGate! key= " << m_containerKey8 << "\033[0m" );
550  } else {
551  ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBTailCatcher ( StoreGate key =" << m_containerKey8 << " ) ..."<< "\033[0m" );
552 
553  const unsigned nTailCatchers = (TBTailCatcher::size_type)TailCatcher->size();
554  m_signals ->resize(nTailCatchers);
555  m_signal_tCatch ->resize(nTailCatchers);
556  m_time_signal_tCatch ->resize(nTailCatchers);
557  m_signal_overflow_tCatch ->resize(nTailCatchers);
558  m_time_overflow_tCatch ->resize(nTailCatchers);
559  m_tbDetectorName_TBTailCatcher ->resize(nTailCatchers);
560  m_overflow_TBTailCatcher ->resize(nTailCatchers);
561 
562  (*m_signals) = TailCatcher->getSignals();
563 
564  unsigned NtupleVectorIndex = 0;
565  TBTailCatcher::const_iterator it_TailCatcher = TailCatcher->begin();
566  TBTailCatcher::const_iterator last_TailCatcher = TailCatcher->end();
567  for(;it_TailCatcher!=last_TailCatcher;++it_TailCatcher,NtupleVectorIndex++) {
568  // scint->isTimeOverflow() is not a constant method, and so we define here
569  // 'TBScintillator * scint' instead of the usual 'const TBScintillator * scint'
570  // since for a const TBScintillator all methods need to be const as well...
571  const TBScintillator * scint = (*it_TailCatcher);
572 
573  (*m_signal_tCatch)[NtupleVectorIndex] = scint-> getSignal();
574  (*m_time_signal_tCatch)[NtupleVectorIndex] = scint-> getTimeSignal();
575  (*m_signal_overflow_tCatch)[NtupleVectorIndex] = scint-> isSignalOverflow();
576  (*m_time_overflow_tCatch)[NtupleVectorIndex] = scint-> isTimeOverflow();
577  (*m_tbDetectorName_TBTailCatcher)[NtupleVectorIndex] = scint-> getDetectorName();
578  (*m_overflow_TBTailCatcher)[NtupleVectorIndex] = scint-> isOverflow();
579  }
580  }
581 
582 
583  // ----------------------------------------------------------------------------------------------------
584  // TBTDC
585  // ----------------------------------------------------------------------------------------------------
586  const TBTDC * TDC = nullptr;
587  sc = evtStore()->retrieve(TDC,m_containerKey9);
588  if (sc.isFailure()) {
589  ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBTDC from StoreGate! key= " << m_containerKey9 << "\033[0m" );
590  } else {
591  ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBTDC ( StoreGate key =" << m_containerKey9 << " ) ..."<< "\033[0m" );
592 
593  m_tdc_TBTDC ->resize(1);
594  m_tdcmin_TBTDC ->resize(1);
595  m_scale_TBTDC ->resize(1);
596  m_phase_TBTDC ->resize(1);
597 
598  (*m_tdc_TBTDC)[0] = TDC-> tdc();
599  (*m_tdcmin_TBTDC)[0] = TDC-> tdcmin();
600  (*m_scale_TBTDC)[0] = TDC-> scale();
601  (*m_phase_TBTDC)[0] = TDC-> phase();
602  }
603 
604 
605  // ----------------------------------------------------------------------------------------------------
606  // TBTrack
607  // ----------------------------------------------------------------------------------------------------
608  const TBTrack * Track = nullptr;
609  sc = evtStore()->retrieve(Track,m_containerKey10);
610  if (sc.isFailure()) {
611  ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBTrack from StoreGate! key= " << m_containerKey10 << "\033[0m" );
612  } else {
613  ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBTrack ( StoreGate key =" << m_containerKey10 << " ) ..."<< "\033[0m" );
614 
615  m_hitNumberU ->resize(1);
616  m_hitNumberV ->resize(1);
617  m_chi2 ->resize(1);
618  m_chi2u ->resize(1);
619  m_chi2v ->resize(1);
620  m_angle ->resize(1);
621  m_uslope ->resize(1);
622  m_vslope ->resize(1);
623  m_uintercept ->resize(1);
624  m_vintercept ->resize(1);
625  m_cryou ->resize(1);
626  m_cryov ->resize(1);
627  m_cryow ->resize(1);
628 
629  (*m_hitNumberU)[0] = Track-> getHitNumberU();
630  (*m_hitNumberV)[0] = Track-> getHitNumberV();
631  (*m_chi2)[0] = Track-> getChi2_global();
632  (*m_chi2u)[0] = Track-> getChi2_u();
633  (*m_chi2v)[0] = Track-> getChi2_v();
634  (*m_angle)[0] = Track-> getAngle();
635  (*m_uslope)[0] = Track-> getUslope();
636  (*m_vslope)[0] = Track-> getVslope();
637  (*m_uintercept)[0] = Track-> getUintercept();
638  (*m_vintercept)[0] = Track-> getVintercept();
639  (*m_cryou)[0] = Track-> getCryoHitu();
640  (*m_cryov)[0] = Track-> getCryoHitv();
641  (*m_cryow)[0] = Track-> getCryoHitw();
642  (*m_residualu) = Track-> getResidualu();
643  (*m_residualv) = Track-> getResidualv();
644  }
645 
646 
647  // ----------------------------------------------------------------------------------------------------
648  // TBTriggerPatternUnit
649  // ----------------------------------------------------------------------------------------------------
650  const TBTriggerPatternUnit * TriggerPatternUnit = nullptr;
651  sc = evtStore()->retrieve(TriggerPatternUnit,m_containerKey11);
652  if (sc.isFailure()) {
653  ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBTriggerPatternUnit from StoreGate! key= " << m_containerKey11 << "\033[0m" );
654  } else {
655  ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBTriggerPatternUnit ( StoreGate key =" << m_containerKey11 << " ) ..."<< "\033[0m" );
656 
657  m_triggerWord->resize(1);
658  (*m_triggerWord)[0] = TriggerPatternUnit-> getTriggerWord();
659 
660  (*m_triggers) = TriggerPatternUnit-> getTriggers();
661  }
662 
663 
664  // ----------------------------------------------------------------------------------------------------
665  // TBMWPCCont
666  // ----------------------------------------------------------------------------------------------------
667  const TBMWPCCont * MWPCCont = nullptr;
668  sc = evtStore()->retrieve(MWPCCont,m_containerKey12);
669  if (sc.isFailure()) {
670  ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBMWPCCont from StoreGate! key= " << m_containerKey12 << "\033[0m" );
671  } else {
672  ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBMWPCCont ( StoreGate key =" << m_containerKey12 << " ) ..."<< "\033[0m" );
673 
674  const unsigned nMWPCCont = (TBMWPCCont::size_type)MWPCCont->size();
675  m_cPos ->resize(nMWPCCont);
676  m_cErr ->resize(nMWPCCont);
677  m_isX ->resize(nMWPCCont);
678  m_clusterSize_c ->resize(nMWPCCont);
679  m_cPosOverflow ->resize(nMWPCCont);
680  m_tbDetectorName_TBMWPCCont ->resize(nMWPCCont);
681  m_overflow_TBMWPCCont ->resize(nMWPCCont);
682 
683  unsigned NtupleVectorIndex = 0;
684  TBMWPCCont::const_iterator it_TBMWPCCont = MWPCCont->begin();
685  TBMWPCCont::const_iterator last_TBMWPCCont = MWPCCont->end();
686  for(;it_TBMWPCCont!=last_TBMWPCCont;++it_TBMWPCCont,NtupleVectorIndex++) {
687  const TBMWPC * mwpc = (*it_TBMWPCCont);
688 
689  (*m_cPos)[NtupleVectorIndex] = mwpc-> getCPos();
690  (*m_cErr)[NtupleVectorIndex] = mwpc-> getCErr();
691  (*m_isX)[NtupleVectorIndex] = mwpc-> isX();
692  (*m_clusterSize_c)[NtupleVectorIndex] = mwpc-> getClusterSizeC();
693  (*m_tbDetectorName_TBMWPCCont)[NtupleVectorIndex] = mwpc-> getDetectorName();
694  (*m_overflow_TBMWPCCont)[NtupleVectorIndex] = mwpc-> isOverflow();
695 
696  // ------------------------------------------------------------------------------------------------
697  // for some reason a stright forward definition of m_cPosOverflow as
698  // std::vector < std::vector<bool> > m_cPosOverflow;
699  // does not work. perhaps due to the fact that std::vector<bool> is nonconforming (not
700  // really a vector of bool variables, but some ). instead we defined
701  // std::vector < std::vector<unsigned> > m_cPosOverflow;
702  // and now need to convert the bool constituents of the vectors to unsigned
703  // ------------------------------------------------------------------------------------------------
704  unsigned nBools = mwpc->isCPosOverflow().size(); //lenght of the vector of bool in TBMWPC
705  std::vector<unsigned> cPosOverflowNow(nBools); //defines lenght and initializes to zero
706 
707  for (unsigned nBoolNow=0; nBoolNow<nBools; nBoolNow++)
708  if(mwpc->isCPosOverflow()[nBoolNow])
709  cPosOverflowNow[nBoolNow] = 1;
710 
711  (*m_cPosOverflow)[NtupleVectorIndex] = cPosOverflowNow;
712  cPosOverflowNow.clear();
713  // ------------------------------------------------------------------------------------------------
714  }
715  }
716 
717  return StatusCode::SUCCESS;
718 }

◆ CBNT_finalize()

StatusCode CBNTAA_TBTPValidation::CBNT_finalize ( )
virtual

Reimplemented from CBNT_TBRecBase.

Definition at line 819 of file CBNTAA_TBTPValidation.cxx.

820 {
821  ATH_MSG_DEBUG ( "in finalize()" );
822  return StatusCode::SUCCESS;
823 }

◆ CBNT_initialize()

StatusCode CBNTAA_TBTPValidation::CBNT_initialize ( )
virtual

Reimplemented from CBNT_TBRecBase.

Definition at line 227 of file CBNTAA_TBTPValidation.cxx.

228 {
229  ATH_MSG_DEBUG ( "in initialize()" );
230 
231  // TBADCRawCont
232  addBranch("TBTPValid_TBADCRaw_m_adc",m_adc);
233  addBranch("TBTPValid_TBADCRaw_tbDetectorName",m_tbDetectorName_TBADCRawCont);
234  addBranch("TBTPValid_TBADCRaw_overflow",m_overflow_TBADCRawCont);
235  // TBTDCRawCont
236  addBranch("TBTPValid_TBTDCRaw_tdc",m_tdc_raw);
237  addBranch("TBTPValid_TBTDCRaw_underThreshold",m_underThreshold_raw);
238  addBranch("TBTPValid_TBTDCRaw_tbDetectorName",m_tbDetectorName_TBTDCRawCont);
239  addBranch("TBTPValid_TBTDCRaw_overflow",m_overflow_TBTDCRawCont);
240  // TBPhase
241  addBranch("TBTPValid_TBPhase_phase",m_phase);
242  addBranch("TBTPValid_TBPhase_phaseind",m_phaseind);
243  addBranch("TBTPValid_TBPhase_dTtoWAC",m_dTtoWAC);
244  // TBEventInfo
245  addBranch("TBTPValid_TBEventInfo_ev_number", m_ev_number);
246  addBranch("TBTPValid_TBEventInfo_ev_clock", m_ev_clock);
247  addBranch("TBTPValid_TBEventInfo_ev_type", m_ev_type);
248  addBranch("TBTPValid_TBEventInfo_run_num", m_run_num);
249  addBranch("TBTPValid_TBEventInfo_beam_moment", m_beam_moment);
250  addBranch("TBTPValid_TBEventInfo_beam_part", m_beam_part);
251  addBranch("TBTPValid_TBEventInfo_cryoX", m_cryoX);
252  addBranch("TBTPValid_TBEventInfo_cryoAngle", m_cryoAngle);
253  addBranch("TBTPValid_TBEventInfo_tableY", m_tableY);
254  // TBBPCCont
255  addBranch("TBTPValid_TBBPCCont_xPos", m_xPos);
256  addBranch("TBTPValid_TBBPCCont_yPos", m_yPos);
257  addBranch("TBTPValid_TBBPCCont_xErr", m_xErr);
258  addBranch("TBTPValid_TBBPCCont_yErr", m_yErr);
259  addBranch("TBTPValid_TBBPCCont_xPulse", m_xPulse);
260  addBranch("TBTPValid_TBBPCCont_yPulse", m_yPulse);
261  addBranch("TBTPValid_TBBPCCont_hitnumber", m_hitnumber);
262  addBranch("TBTPValid_TBBPCCont_xPosOverflow", m_xPosOverflow);
263  addBranch("TBTPValid_TBBPCCont_yPosOverflow", m_yPosOverflow);
264  addBranch("TBTPValid_TBBPCCont_xPulseOverflow", m_xPulseOverflow);
265  addBranch("TBTPValid_TBBPCCont_yPulseOverflow", m_yPulseOverflow);
266  addBranch("TBTPValid_TBBPCCont_overflowSetFlag", m_overflowSetFlag);
267  addBranch("TBTPValid_TBBPCCont_tbDetectorName", m_tbDetectorName_TBBPCCont);
268  addBranch("TBTPValid_TBBPCCont_overflow", m_overflow_TBBPCCont);
269  // TBLArDigitContainer
270  addBranch("TBTPValid_TBLArDigitContainer_channelID", m_channelID);
271  addBranch("TBTPValid_TBLArDigitContainer_gain", m_gain);
272  addBranch("TBTPValid_TBLArDigitContainer_nSamples", m_nSamples);
273  addBranch("TBTPValid_TBLArDigitContainer_samples", m_samples);
274  // TBScintillatorCont
275  addBranch("TBTPValid_TBScintillatorCont_signal", m_signal_scint);
276  addBranch("TBTPValid_TBScintillatorCont_time_signal", m_time_signal_scint);
277  addBranch("TBTPValid_TBScintillatorCont_signal_overflow", m_signal_overflow_scint);
278  addBranch("TBTPValid_TBScintillatorCont_time_overflow", m_time_overflow_scint);
279  addBranch("TBTPValid_TBScintillatorCont_tbDetectorName", m_tbDetectorName_TBScintillatorCont);
280  addBranch("TBTPValid_TBScintillatorCont_overflow", m_overflow_TBScintillatorCont);
281  // TBTailCatcher
282  addBranch("TBTPValid_TBTailCatcher_signals", m_signals);
283  addBranch("TBTPValid_TBTailCatcher_signal", m_signal_tCatch);
284  addBranch("TBTPValid_TBTailCatcher_time_signal", m_time_signal_tCatch);
285  addBranch("TBTPValid_TBTailCatcher_signal_overflow", m_signal_overflow_tCatch);
286  addBranch("TBTPValid_TBTailCatcher_time_overflow", m_time_overflow_tCatch);
287  addBranch("TBTPValid_TBTailCatcher_tbDetectorName", m_tbDetectorName_TBTailCatcher);
288  addBranch("TBTPValid_TBTailCatcher_overflow", m_overflow_TBTailCatcher);
289  // TBTDC
290  addBranch("TBTPValid_TBTDC_tdc", m_tdc_TBTDC);
291  addBranch("TBTPValid_TBTDC_tdcmin", m_tdcmin_TBTDC);
292  addBranch("TBTPValid_TBTDC_scale", m_scale_TBTDC);
293  addBranch("TBTPValid_TBTDC_phase", m_phase_TBTDC);
294  // TBTrack
295  addBranch("TBTPValid_TBTrack_hitNumberU", m_hitNumberU);
296  addBranch("TBTPValid_TBTrack_hitNumberV", m_hitNumberV);
297  addBranch("TBTPValid_TBTrack_residualu", m_residualu);
298  addBranch("TBTPValid_TBTrack_residualv", m_residualv);
299  addBranch("TBTPValid_TBTrack_chi2", m_chi2);
300  addBranch("TBTPValid_TBTrack_chi2u", m_chi2u);
301  addBranch("TBTPValid_TBTrack_chi2v", m_chi2v);
302  addBranch("TBTPValid_TBTrack_angle", m_angle);
303  addBranch("TBTPValid_TBTrack_uslope", m_uslope);
304  addBranch("TBTPValid_TBTrack_vslope", m_vslope);
305  addBranch("TBTPValid_TBTrack_uintercept", m_uintercept);
306  addBranch("TBTPValid_TBTrack_vintercept", m_vintercept);
307  addBranch("TBTPValid_TBTrack_cryou", m_cryou);
308  addBranch("TBTPValid_TBTrack_cryov", m_cryov);
309  addBranch("TBTPValid_TBTrack_cryow", m_cryow);
310  // TBTriggerPatternUnit
311  addBranch("TBTPValid_TBTriggerPatternUnit_triggerWord", m_triggerWord);
312  addBranch("TBTPValid_TBTriggerPatternUnit_triggers", m_triggers);
313  // TBMWPCCont
314  addBranch("TBTPValid_TBMWPCCont_cPos", m_cPos);
315  addBranch("TBTPValid_TBMWPCCont_cErr", m_cErr);
316  addBranch("TBTPValid_TBMWPCCont_isX", m_isX);
317  addBranch("TBTPValid_TBMWPCCont_clusterSize_c", m_clusterSize_c);
318  addBranch("TBTPValid_TBMWPCCont_cPosOverflow", m_cPosOverflow);
319  addBranch("TBTPValid_TBMWPCCont_tbDetectorName", m_tbDetectorName_TBMWPCCont);
320  addBranch("TBTPValid_TBMWPCCont_overflow", m_overflow_TBMWPCCont);
321 
322  return StatusCode::SUCCESS;
323 
324 }

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

◆ 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 CBNT_TBRecBase::execute ( )
overridevirtualinherited

Definition at line 157 of file CBNT_TBRecBase.cxx.

157  {
158 
159  StatusCode sc;
160 
161  // run pre-execution
162  try {
163  sc = this->pre_execute();
164  }
165 
166  catch( const std::exception& Exception ) {
167  *m_log << MSG::ERROR << " Standard exception "
168  << Exception.what()
169  << " caught from sub-algorithm::CBNT_pre_execute (). Disable !" << endmsg ;
170  sc = this->setProperty(BooleanProperty( "Enable",false ) );
171  return StatusCode::FAILURE;
172 
173  }
174  catch (...) {
175  *m_log << MSG::ERROR << " Unknown exception "
176  << " caught from sub-algorithm::CBNT_pre_execute (). Disable !" << endmsg ;
177  sc = this->setProperty(BooleanProperty( "Enable",false ) );
178  return StatusCode::FAILURE;
179  }
180 
181  if (sc.isFailure()) {
182  *m_log << MSG::ERROR << "CBNT_pre_execute() failed. Disable !" << endmsg;
183  sc = this->setProperty(BooleanProperty( "Enable",false ) );
184  return sc;
185  }
186 
187  // now subalgorithm execution
188  try {
189  sc = this->CBNT_execute();
190  }
191 
192  catch( const std::exception& Exception ) {
193  *m_log << MSG::ERROR << " Standard exception "
194  << Exception.what()
195  << " caught from sub-algorithm::CBNT_execute () :" << endmsg ;
196  return StatusCode::FAILURE;
197  }
198  catch (...) {
199  *m_log << MSG::ERROR << " Unknown exception "
200  << " caught from sub-algorithm::CBNT_execute () :" << endmsg ;
201  return StatusCode::FAILURE;
202  }
203 
204  return sc;
205 }

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

◆ finalize()

StatusCode CBNT_TBRecBase::finalize ( )
overridevirtualinherited

Definition at line 208 of file CBNT_TBRecBase.cxx.

208  {
209 
210  StatusCode sc;
211 
212  //now subalgorithm finalisation
213  try {
214  sc = this->CBNT_finalize();
215  }
216  catch( const std::exception& Exception ) {
217  *m_log << MSG::ERROR << " Standard exception "
218  << Exception.what()
219  << " caught from sub-algorithm::CBNT_finalize () :" << endmsg ;
220  }
221  catch (...) {
222  *m_log << MSG::ERROR << " Unknown exception "
223  << " caught from sub-algorithm::CBNT_finalize () :" << endmsg ;
224  }
225 
226  return sc;
227 }

◆ initialize()

StatusCode CBNT_TBRecBase::initialize ( )
overridevirtualinherited

Definition at line 22 of file CBNT_TBRecBase.cxx.

22  {
23  m_log=new MsgStream(msgSvc(), name());
24 
25  *m_log << MSG::DEBUG << "Initializing CBNT_TBRecBase base class" << endmsg;
26 
27  const CaloCell_ID* idHelper = nullptr;
28  ATH_CHECK( detStore()->retrieve (idHelper, "CaloCell_ID") );
29  m_emId=idHelper->em_idHelper();
30  m_fcalId=idHelper->fcal_idHelper();
31  m_hecId=idHelper->hec_idHelper();
32 
33 
34  if (!m_emId) {
35  (*m_log) << MSG::ERROR << "Could not access lar EM ID helper" << endmsg;
36  return StatusCode::FAILURE;
37  }
38  if (!m_fcalId) {
39  (*m_log) << MSG::ERROR << "Could not access lar FCAL ID helper" << endmsg;
40  return StatusCode::FAILURE;
41  }
42  if (!m_hecId) {
43  (*m_log) << MSG::ERROR << "Could not access lar HEC ID helper" << endmsg;
44  return StatusCode::FAILURE;
45  }
46 
47  StatusCode sc = detStore()->retrieve(m_onlineId, "LArOnlineID");
48  if (sc.isFailure()) {
49  (*m_log) << MSG::ERROR << "Could not get LArOnlineID helper !" << endmsg;
50  return StatusCode::FAILURE;
51  }
52  else {
53  (*m_log) << MSG::DEBUG << " Found the LArOnlineID helper. " << endmsg;
54  }
55 
56 
57  m_initialized=true;
58  return StatusCode::SUCCESS;
59 }

◆ inputHandles()

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

Return this algorithm's input handles.

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

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ pre_execute()

StatusCode CBNT_TBRecBase::pre_execute ( )
virtualinherited

Definition at line 61 of file CBNT_TBRecBase.cxx.

61  {
62 
63  StatusCode sc;
64 
65  if(!m_initialized) {
66 
67  if (m_ntpath.size()==0 || m_ntTitle.size()==0) {
68  *m_log << MSG::ERROR << "Need to set variable 'm_ntpath' and 'm_ntTitle' in constructor of deriving class!" << endmsg;
69  return StatusCode::FAILURE;
70  }
71 
72  size_t i=m_ntpath.rfind('/');
73  if (i==std::string::npos) {
74  *m_log << MSG::ERROR << "Expected at least on '/' in path " << m_ntpath << endmsg;
75  return StatusCode::FAILURE;
76  }
77  std::string basepath(m_ntpath.begin(),m_ntpath.begin()+i);
78  //std::cout << "Basepath" << basepath << std::endl;
79 
80  // retrive pointer to THistSvc
81  ITHistSvc * tHistSvc = 0;
82  sc = Gaudi::svcLocator()->service("THistSvc", tHistSvc);
83  if (sc.isFailure()) {
84  *m_log << MSG::ERROR << "Unable to retrieve pointer to THistSvc" << endmsg;
85  return sc;
86  }
87  // get TTree
88  sc = tHistSvc->getTree(m_ntpath,m_nt);
89  if (sc.isFailure()) {
90  *m_log << MSG::ERROR << "Unable to retrieve TTree : " << m_ntpath << endmsg;
91  return sc;
92  }
93  /*
94  NTupleFilePtr file1(ntupleSvc(),basepath);
95  if (!file1){
96  (*m_log) << MSG::ERROR << "Could not get NTupleFilePtr with path " << basepath << " failed" << endmsg;
97  return StatusCode::FAILURE;
98  }
99  NTuplePtr nt(ntupleSvc(),m_ntpath);
100  if (!nt) {
101  nt=ntupleSvc()->book(m_ntpath,CLID_ColumnWiseTuple,m_ntTitle);
102  }
103  if (!nt){
104  (*m_log) << MSG::ERROR << "Booking of NTuple at "<< m_ntpath << " and name " << m_ntTitle << " failed" << endmsg;
105  return StatusCode::FAILURE;
106  }
107  m_nt=nt;
108  */
109  //std::cout << "Ntuple ptr:" << m_nt << std::endl;
110 
111  // subalgorithm initialisation
112  try {
113  sc = this->CBNT_initialize();
114  }
115  catch( const std::exception& Exception ) {
116  *m_log << MSG::ERROR << " Standard exception "
117  << Exception.what()
118  << " caught from sub-algorithm::CBNT_initialize () :" << endmsg ;
119  }
120  catch (...) {
121  *m_log << MSG::ERROR << " Unknown exception "
122  << " caught from sub-algorithm::CBNT_initialize () :" << endmsg ;
123  }
124 
125  if (sc.isFailure())
126  {
127  *m_log << MSG::ERROR << "CBNT_initialize() failed" << endmsg;
128  return sc;
129  }
130 
131  m_initialized=true;
132  }
133 
134  // clear data members
135  try {
136  sc = this->CBNT_clear();
137  }
138  catch( const std::exception& Exception ) {
139  *m_log << MSG::ERROR << " Standard exception "
140  << Exception.what()
141  << " caught from sub-algorithm::CBNT_clear () :" << endmsg ;
142  }
143  catch (...) {
144  *m_log << MSG::ERROR << " Unknown exception "
145  << " caught from sub-algorithm::CBNT_clear () :" << endmsg ;
146  }
147 
148  if (sc.isFailure()) {
149  *m_log << MSG::ERROR << "CBNT_clear() failed" << endmsg;
150  return sc;
151  }
152 
153  return StatusCode::SUCCESS ;
154 }

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

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

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

Definition at line 66 of file AthAlgorithm.cxx.

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

◆ sysStart()

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

Handle START transition.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_adc

std::vector<unsigned int>* CBNTAA_TBTPValidation::m_adc
private

Definition at line 38 of file CBNTAA_TBTPValidation.h.

◆ m_angle

std::vector<double >* CBNTAA_TBTPValidation::m_angle
private

Definition at line 105 of file CBNTAA_TBTPValidation.h.

◆ m_beam_moment

std::vector<float>* CBNTAA_TBTPValidation::m_beam_moment
private

Definition at line 58 of file CBNTAA_TBTPValidation.h.

◆ m_beam_part

std::vector<std::string>* CBNTAA_TBTPValidation::m_beam_part
private

Definition at line 59 of file CBNTAA_TBTPValidation.h.

◆ m_cErr

std::vector< std::vector<float> >* CBNTAA_TBTPValidation::m_cErr
private

Definition at line 116 of file CBNTAA_TBTPValidation.h.

◆ m_channelID

std::vector<unsigned int>* CBNTAA_TBTPValidation::m_channelID
private

Definition at line 77 of file CBNTAA_TBTPValidation.h.

◆ m_chi2

std::vector<double >* CBNTAA_TBTPValidation::m_chi2
private

Definition at line 104 of file CBNTAA_TBTPValidation.h.

◆ m_chi2u

std::vector<double > * CBNTAA_TBTPValidation::m_chi2u
private

Definition at line 104 of file CBNTAA_TBTPValidation.h.

◆ m_chi2v

std::vector<double > * CBNTAA_TBTPValidation::m_chi2v
private

Definition at line 104 of file CBNTAA_TBTPValidation.h.

◆ m_clusterSize_c

std::vector< std::vector<float> >* CBNTAA_TBTPValidation::m_clusterSize_c
private

Definition at line 118 of file CBNTAA_TBTPValidation.h.

◆ m_containerKey1

std::string CBNTAA_TBTPValidation::m_containerKey1
private

Definition at line 41 of file CBNTAA_TBTPValidation.h.

◆ m_containerKey10

std::string CBNTAA_TBTPValidation::m_containerKey10
private

Definition at line 109 of file CBNTAA_TBTPValidation.h.

◆ m_containerKey11

std::string CBNTAA_TBTPValidation::m_containerKey11
private

Definition at line 113 of file CBNTAA_TBTPValidation.h.

◆ m_containerKey12

std::string CBNTAA_TBTPValidation::m_containerKey12
private

Definition at line 121 of file CBNTAA_TBTPValidation.h.

◆ m_containerKey2

std::string CBNTAA_TBTPValidation::m_containerKey2
private

Definition at line 47 of file CBNTAA_TBTPValidation.h.

◆ m_containerKey3

std::string CBNTAA_TBTPValidation::m_containerKey3
private

Definition at line 52 of file CBNTAA_TBTPValidation.h.

◆ m_containerKey4

std::string CBNTAA_TBTPValidation::m_containerKey4
private

Definition at line 63 of file CBNTAA_TBTPValidation.h.

◆ m_containerKey5

std::string CBNTAA_TBTPValidation::m_containerKey5
private

Definition at line 75 of file CBNTAA_TBTPValidation.h.

◆ m_containerKey6

std::string CBNTAA_TBTPValidation::m_containerKey6
private

Definition at line 81 of file CBNTAA_TBTPValidation.h.

◆ m_containerKey7

std::string CBNTAA_TBTPValidation::m_containerKey7
private

Definition at line 87 of file CBNTAA_TBTPValidation.h.

◆ m_containerKey8

std::string CBNTAA_TBTPValidation::m_containerKey8
private

Definition at line 94 of file CBNTAA_TBTPValidation.h.

◆ m_containerKey9

std::string CBNTAA_TBTPValidation::m_containerKey9
private

Definition at line 100 of file CBNTAA_TBTPValidation.h.

◆ m_cPos

std::vector< std::vector<float> >* CBNTAA_TBTPValidation::m_cPos
private

Definition at line 115 of file CBNTAA_TBTPValidation.h.

◆ m_cPosOverflow

std::vector< std::vector<unsigned> >* CBNTAA_TBTPValidation::m_cPosOverflow
private

Definition at line 123 of file CBNTAA_TBTPValidation.h.

◆ m_cryoAngle

std::vector<float>* CBNTAA_TBTPValidation::m_cryoAngle
private

Definition at line 61 of file CBNTAA_TBTPValidation.h.

◆ m_cryou

std::vector< double >* CBNTAA_TBTPValidation::m_cryou
private

Definition at line 108 of file CBNTAA_TBTPValidation.h.

◆ m_cryov

std::vector< double > * CBNTAA_TBTPValidation::m_cryov
private

Definition at line 108 of file CBNTAA_TBTPValidation.h.

◆ m_cryow

std::vector< double > * CBNTAA_TBTPValidation::m_cryow
private

Definition at line 108 of file CBNTAA_TBTPValidation.h.

◆ m_cryoX

std::vector<float>* CBNTAA_TBTPValidation::m_cryoX
private

Definition at line 60 of file CBNTAA_TBTPValidation.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_dTtoWAC

std::vector<float>* CBNTAA_TBTPValidation::m_dTtoWAC
private

Definition at line 51 of file CBNTAA_TBTPValidation.h.

◆ m_emId

const LArEM_ID* CBNT_TBRecBase::m_emId
protectedinherited

Definition at line 65 of file CBNT_TBRecBase.h.

◆ m_ev_clock

std::vector<int>* CBNTAA_TBTPValidation::m_ev_clock
private

Definition at line 55 of file CBNTAA_TBTPValidation.h.

◆ m_ev_number

std::vector<int>* CBNTAA_TBTPValidation::m_ev_number
private

Definition at line 54 of file CBNTAA_TBTPValidation.h.

◆ m_ev_type

std::vector<int>* CBNTAA_TBTPValidation::m_ev_type
private

Definition at line 56 of file CBNTAA_TBTPValidation.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_fcalId

const LArFCAL_ID* CBNT_TBRecBase::m_fcalId
protectedinherited

Definition at line 67 of file CBNT_TBRecBase.h.

◆ m_gain

std::vector<unsigned char>* CBNTAA_TBTPValidation::m_gain
private

Definition at line 78 of file CBNTAA_TBTPValidation.h.

◆ m_hecId

const LArHEC_ID* CBNT_TBRecBase::m_hecId
protectedinherited

Definition at line 66 of file CBNT_TBRecBase.h.

◆ m_hitnumber

std::vector< short >* CBNTAA_TBTPValidation::m_hitnumber
private

Definition at line 69 of file CBNTAA_TBTPValidation.h.

◆ m_hitNumberU

std::vector< int >* CBNTAA_TBTPValidation::m_hitNumberU
private

Definition at line 102 of file CBNTAA_TBTPValidation.h.

◆ m_hitNumberV

std::vector< int > * CBNTAA_TBTPValidation::m_hitNumberV
private

Definition at line 102 of file CBNTAA_TBTPValidation.h.

◆ m_initialized

bool CBNT_TBRecBase::m_initialized
privateinherited

Definition at line 40 of file CBNT_TBRecBase.h.

◆ m_isX

std::vector< bool >* CBNTAA_TBTPValidation::m_isX
private

Definition at line 117 of file CBNTAA_TBTPValidation.h.

◆ m_log

MsgStream* CBNT_TBRecBase::m_log
protectedinherited

Definition at line 63 of file CBNT_TBRecBase.h.

◆ m_neverReturnFailure

bool CBNTAA_TBTPValidation::m_neverReturnFailure
private

Definition at line 35 of file CBNTAA_TBTPValidation.h.

◆ m_nSamples

std::vector<unsigned short>* CBNTAA_TBTPValidation::m_nSamples
private

Definition at line 79 of file CBNTAA_TBTPValidation.h.

◆ m_nt

TTree* CBNT_TBRecBase::m_nt
protectedinherited

Definition at line 61 of file CBNT_TBRecBase.h.

◆ m_ntpath

std::string CBNT_TBRecBase::m_ntpath
protectedinherited

Definition at line 58 of file CBNT_TBRecBase.h.

◆ m_ntTitle

std::string CBNT_TBRecBase::m_ntTitle
protectedinherited

Definition at line 58 of file CBNT_TBRecBase.h.

◆ m_onlineId

const LArOnlineID* CBNT_TBRecBase::m_onlineId
protectedinherited

Definition at line 68 of file CBNT_TBRecBase.h.

◆ m_overflow_TBADCRawCont

std::vector< bool >* CBNTAA_TBTPValidation::m_overflow_TBADCRawCont
private

Definition at line 40 of file CBNTAA_TBTPValidation.h.

◆ m_overflow_TBBPCCont

std::vector< bool >* CBNTAA_TBTPValidation::m_overflow_TBBPCCont
private

Definition at line 74 of file CBNTAA_TBTPValidation.h.

◆ m_overflow_TBMWPCCont

std::vector< bool >* CBNTAA_TBTPValidation::m_overflow_TBMWPCCont
private

Definition at line 120 of file CBNTAA_TBTPValidation.h.

◆ m_overflow_TBScintillatorCont

std::vector< bool >* CBNTAA_TBTPValidation::m_overflow_TBScintillatorCont
private

Definition at line 86 of file CBNTAA_TBTPValidation.h.

◆ m_overflow_TBTailCatcher

std::vector< bool >* CBNTAA_TBTPValidation::m_overflow_TBTailCatcher
private

Definition at line 93 of file CBNTAA_TBTPValidation.h.

◆ m_overflow_TBTDCRawCont

std::vector< bool >* CBNTAA_TBTPValidation::m_overflow_TBTDCRawCont
private

Definition at line 46 of file CBNTAA_TBTPValidation.h.

◆ m_overflowSetFlag

std::vector< bool >* CBNTAA_TBTPValidation::m_overflowSetFlag
private

Definition at line 72 of file CBNTAA_TBTPValidation.h.

◆ m_phase

std::vector<float>* CBNTAA_TBTPValidation::m_phase
private

Definition at line 49 of file CBNTAA_TBTPValidation.h.

◆ m_phase_TBTDC

std::vector< int >* CBNTAA_TBTPValidation::m_phase_TBTDC
private

Definition at line 99 of file CBNTAA_TBTPValidation.h.

◆ m_phaseind

std::vector<short>* CBNTAA_TBTPValidation::m_phaseind
private

Definition at line 50 of file CBNTAA_TBTPValidation.h.

◆ m_residualu

std::vector<double >* CBNTAA_TBTPValidation::m_residualu
private

Definition at line 103 of file CBNTAA_TBTPValidation.h.

◆ m_residualv

std::vector<double > * CBNTAA_TBTPValidation::m_residualv
private

Definition at line 103 of file CBNTAA_TBTPValidation.h.

◆ m_run_num

std::vector<unsigned int>* CBNTAA_TBTPValidation::m_run_num
private

Definition at line 57 of file CBNTAA_TBTPValidation.h.

◆ m_samples

std::vector<unsigned short>* CBNTAA_TBTPValidation::m_samples
private

Definition at line 80 of file CBNTAA_TBTPValidation.h.

◆ m_scale_TBTDC

std::vector< float >* CBNTAA_TBTPValidation::m_scale_TBTDC
private

Definition at line 98 of file CBNTAA_TBTPValidation.h.

◆ m_signal_overflow_scint

std::vector< bool >* CBNTAA_TBTPValidation::m_signal_overflow_scint
private

Definition at line 84 of file CBNTAA_TBTPValidation.h.

◆ m_signal_overflow_tCatch

std::vector< bool >* CBNTAA_TBTPValidation::m_signal_overflow_tCatch
private

Definition at line 91 of file CBNTAA_TBTPValidation.h.

◆ m_signal_scint

std::vector< float >* CBNTAA_TBTPValidation::m_signal_scint
private

Definition at line 83 of file CBNTAA_TBTPValidation.h.

◆ m_signal_tCatch

std::vector< float >* CBNTAA_TBTPValidation::m_signal_tCatch
private

Definition at line 90 of file CBNTAA_TBTPValidation.h.

◆ m_signals

std::vector< double >* CBNTAA_TBTPValidation::m_signals
private

Definition at line 89 of file CBNTAA_TBTPValidation.h.

◆ m_tableY

std::vector<float>* CBNTAA_TBTPValidation::m_tableY
private

Definition at line 62 of file CBNTAA_TBTPValidation.h.

◆ m_tbDetectorName_TBADCRawCont

std::vector< std::string >* CBNTAA_TBTPValidation::m_tbDetectorName_TBADCRawCont
private

Definition at line 39 of file CBNTAA_TBTPValidation.h.

◆ m_tbDetectorName_TBBPCCont

std::vector< std::string >* CBNTAA_TBTPValidation::m_tbDetectorName_TBBPCCont
private

Definition at line 73 of file CBNTAA_TBTPValidation.h.

◆ m_tbDetectorName_TBMWPCCont

std::vector< std::string >* CBNTAA_TBTPValidation::m_tbDetectorName_TBMWPCCont
private

Definition at line 119 of file CBNTAA_TBTPValidation.h.

◆ m_tbDetectorName_TBScintillatorCont

std::vector< std::string >* CBNTAA_TBTPValidation::m_tbDetectorName_TBScintillatorCont
private

Definition at line 85 of file CBNTAA_TBTPValidation.h.

◆ m_tbDetectorName_TBTailCatcher

std::vector< std::string >* CBNTAA_TBTPValidation::m_tbDetectorName_TBTailCatcher
private

Definition at line 92 of file CBNTAA_TBTPValidation.h.

◆ m_tbDetectorName_TBTDCRawCont

std::vector< std::string >* CBNTAA_TBTPValidation::m_tbDetectorName_TBTDCRawCont
private

Definition at line 45 of file CBNTAA_TBTPValidation.h.

◆ m_tdc_raw

std::vector<unsigned int>* CBNTAA_TBTPValidation::m_tdc_raw
private

Definition at line 43 of file CBNTAA_TBTPValidation.h.

◆ m_tdc_TBTDC

std::vector< int >* CBNTAA_TBTPValidation::m_tdc_TBTDC
private

Definition at line 96 of file CBNTAA_TBTPValidation.h.

◆ m_tdcmin_TBTDC

std::vector< int >* CBNTAA_TBTPValidation::m_tdcmin_TBTDC
private

Definition at line 97 of file CBNTAA_TBTPValidation.h.

◆ m_time_overflow_scint

std::vector< bool > * CBNTAA_TBTPValidation::m_time_overflow_scint
private

Definition at line 84 of file CBNTAA_TBTPValidation.h.

◆ m_time_overflow_tCatch

std::vector< bool > * CBNTAA_TBTPValidation::m_time_overflow_tCatch
private

Definition at line 91 of file CBNTAA_TBTPValidation.h.

◆ m_time_signal_scint

std::vector< float > * CBNTAA_TBTPValidation::m_time_signal_scint
private

Definition at line 83 of file CBNTAA_TBTPValidation.h.

◆ m_time_signal_tCatch

std::vector< float > * CBNTAA_TBTPValidation::m_time_signal_tCatch
private

Definition at line 90 of file CBNTAA_TBTPValidation.h.

◆ m_triggers

std::vector<bool>* CBNTAA_TBTPValidation::m_triggers
private

Definition at line 112 of file CBNTAA_TBTPValidation.h.

◆ m_triggerWord

std::vector< unsigned int >* CBNTAA_TBTPValidation::m_triggerWord
private

Definition at line 111 of file CBNTAA_TBTPValidation.h.

◆ m_uintercept

std::vector<double >* CBNTAA_TBTPValidation::m_uintercept
private

Definition at line 107 of file CBNTAA_TBTPValidation.h.

◆ m_underThreshold_raw

std::vector<bool>* CBNTAA_TBTPValidation::m_underThreshold_raw
private

Definition at line 44 of file CBNTAA_TBTPValidation.h.

◆ m_uslope

std::vector<double >* CBNTAA_TBTPValidation::m_uslope
private

Definition at line 106 of file CBNTAA_TBTPValidation.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_vintercept

std::vector<double > * CBNTAA_TBTPValidation::m_vintercept
private

Definition at line 107 of file CBNTAA_TBTPValidation.h.

◆ m_vslope

std::vector<double > * CBNTAA_TBTPValidation::m_vslope
private

Definition at line 106 of file CBNTAA_TBTPValidation.h.

◆ m_xErr

std::vector< signal_type_TBBPCCont >* CBNTAA_TBTPValidation::m_xErr
private

Definition at line 67 of file CBNTAA_TBTPValidation.h.

◆ m_xPos

std::vector< signal_type_TBBPCCont >* CBNTAA_TBTPValidation::m_xPos
private

Definition at line 66 of file CBNTAA_TBTPValidation.h.

◆ m_xPosOverflow

std::vector< bool >* CBNTAA_TBTPValidation::m_xPosOverflow
private

Definition at line 70 of file CBNTAA_TBTPValidation.h.

◆ m_xPulse

std::vector< signal_type_TBBPCCont >* CBNTAA_TBTPValidation::m_xPulse
private

Definition at line 68 of file CBNTAA_TBTPValidation.h.

◆ m_xPulseOverflow

std::vector< bool >* CBNTAA_TBTPValidation::m_xPulseOverflow
private

Definition at line 71 of file CBNTAA_TBTPValidation.h.

◆ m_yErr

std::vector< signal_type_TBBPCCont > * CBNTAA_TBTPValidation::m_yErr
private

Definition at line 67 of file CBNTAA_TBTPValidation.h.

◆ m_yPos

std::vector< signal_type_TBBPCCont > * CBNTAA_TBTPValidation::m_yPos
private

Definition at line 66 of file CBNTAA_TBTPValidation.h.

◆ m_yPosOverflow

std::vector< bool > * CBNTAA_TBTPValidation::m_yPosOverflow
private

Definition at line 70 of file CBNTAA_TBTPValidation.h.

◆ m_yPulse

std::vector< signal_type_TBBPCCont > * CBNTAA_TBTPValidation::m_yPulse
private

Definition at line 68 of file CBNTAA_TBTPValidation.h.

◆ m_yPulseOverflow

std::vector< bool > * CBNTAA_TBTPValidation::m_yPulseOverflow
private

Definition at line 71 of file CBNTAA_TBTPValidation.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
base
std::string base
Definition: hcg.cxx:78
TBTDCRaw
Definition: TBTDCRaw.h:21
CBNTAA_TBTPValidation::m_overflow_TBMWPCCont
std::vector< bool > * m_overflow_TBMWPCCont
Definition: CBNTAA_TBTPValidation.h:120
CBNTAA_TBTPValidation::m_neverReturnFailure
bool m_neverReturnFailure
Definition: CBNTAA_TBTPValidation.h:35
CBNTAA_TBTPValidation::m_beam_moment
std::vector< float > * m_beam_moment
Definition: CBNTAA_TBTPValidation.h:58
CBNTAA_TBTPValidation::m_yPosOverflow
std::vector< bool > * m_yPosOverflow
Definition: CBNTAA_TBTPValidation.h:70
ReadOfcFromCool.phase
phase
Definition: ReadOfcFromCool.py:127
CBNTAA_TBTPValidation::m_yPulse
std::vector< signal_type_TBBPCCont > * m_yPulse
Definition: CBNTAA_TBTPValidation.h:68
CBNTAA_TBTPValidation::m_samples
std::vector< unsigned short > * m_samples
Definition: CBNTAA_TBTPValidation.h:80
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
CBNTAA_TBTPValidation::m_ev_number
std::vector< int > * m_ev_number
Definition: CBNTAA_TBTPValidation.h:54
CBNTAA_TBTPValidation::m_residualv
std::vector< double > * m_residualv
Definition: CBNTAA_TBTPValidation.h:103
CBNT_TBRecBase::CBNT_finalize
virtual StatusCode CBNT_finalize()
Definition: CBNT_TBRecBase.h:36
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
CBNT_TBRecBase::m_nt
TTree * m_nt
Definition: CBNT_TBRecBase.h:61
TBTrack
Definition: TBTrack.h:20
CBNTAA_TBTPValidation::m_angle
std::vector< double > * m_angle
Definition: CBNTAA_TBTPValidation.h:105
CBNTAA_TBTPValidation::m_signals
std::vector< double > * m_signals
Definition: CBNTAA_TBTPValidation.h:89
TBADCRaw
Definition: TBADCRaw.h:21
CBNT_TBRecBase::m_initialized
bool m_initialized
Definition: CBNT_TBRecBase.h:40
CBNTAA_TBTPValidation::m_tbDetectorName_TBScintillatorCont
std::vector< std::string > * m_tbDetectorName_TBScintillatorCont
Definition: CBNTAA_TBTPValidation.h:85
CBNTAA_TBTPValidation::m_overflow_TBTailCatcher
std::vector< bool > * m_overflow_TBTailCatcher
Definition: CBNTAA_TBTPValidation.h:93
CaloCell_ID::em_idHelper
const LArEM_ID * em_idHelper() const
access to EM idHelper
Definition: CaloCell_ID.h:63
CBNTAA_TBTPValidation::m_containerKey8
std::string m_containerKey8
Definition: CBNTAA_TBTPValidation.h:94
CBNTAA_TBTPValidation::m_uslope
std::vector< double > * m_uslope
Definition: CBNTAA_TBTPValidation.h:106
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
CBNTAA_TBTPValidation::m_cryoAngle
std::vector< float > * m_cryoAngle
Definition: CBNTAA_TBTPValidation.h:61
CBNT_TBRecBase::m_onlineId
const LArOnlineID * m_onlineId
Definition: CBNT_TBRecBase.h:68
TBBPC
Definition: TBBPC.h:23
CBNT_TBRecBase::CBNT_clear
virtual StatusCode CBNT_clear()
Definition: CBNT_TBRecBase.h:37
CBNT_TBRecBase::CBNT_initialize
virtual StatusCode CBNT_initialize()
Definition: CBNT_TBRecBase.h:34
xAOD::char
char
Definition: TrigDecision_v1.cxx:38
TBH6ByteStream-Monitor-EventStorage.tdcmin
tdcmin
Definition: TBH6ByteStream-Monitor-EventStorage.py:143
CBNT_TBRecBase::CBNT_execute
virtual StatusCode CBNT_execute()
Definition: CBNT_TBRecBase.h:35
CBNTAA_TBTPValidation::m_chi2v
std::vector< double > * m_chi2v
Definition: CBNTAA_TBTPValidation.h:104
CBNTAA_TBTPValidation::m_hitNumberU
std::vector< int > * m_hitNumberU
Definition: CBNTAA_TBTPValidation.h:102
CBNTAA_TBTPValidation::m_vslope
std::vector< double > * m_vslope
Definition: CBNTAA_TBTPValidation.h:106
CBNTAA_TBTPValidation::m_yPulseOverflow
std::vector< bool > * m_yPulseOverflow
Definition: CBNTAA_TBTPValidation.h:71
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
TBScintillatorCont
Definition: TBScintillatorCont.h:19
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
CBNTAA_TBTPValidation::m_tbDetectorName_TBTDCRawCont
std::vector< std::string > * m_tbDetectorName_TBTDCRawCont
Definition: CBNTAA_TBTPValidation.h:45
CBNTAA_TBTPValidation::m_beam_part
std::vector< std::string > * m_beam_part
Definition: CBNTAA_TBTPValidation.h:59
CBNTAA_TBTPValidation::m_containerKey10
std::string m_containerKey10
Definition: CBNTAA_TBTPValidation.h:109
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
CBNTAA_TBTPValidation::m_containerKey2
std::string m_containerKey2
Definition: CBNTAA_TBTPValidation.h:47
CBNTAA_TBTPValidation::m_xPulseOverflow
std::vector< bool > * m_xPulseOverflow
Definition: CBNTAA_TBTPValidation.h:71
yodamerge_tmp.scale
scale
Definition: yodamerge_tmp.py:138
CBNTAA_TBTPValidation::m_phaseind
std::vector< short > * m_phaseind
Definition: CBNTAA_TBTPValidation.h:50
CBNT_TBRecBase::NOT_VALID
@ NOT_VALID
Definition: CBNT_TBRecBase.h:56
TBTailCatcher
Definition: TBTailCatcher.h:25
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
CaloCell_ID::hec_idHelper
const LArHEC_ID * hec_idHelper() const
access to HEC idHelper
Definition: CaloCell_ID.h:69
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
RTTAlgmain.branchname
string branchname
Definition: RTTAlgmain.py:60
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
CBNTAA_TBTPValidation::m_time_overflow_scint
std::vector< bool > * m_time_overflow_scint
Definition: CBNTAA_TBTPValidation.h:84
LArCellBinning_test.retval
def retval
Definition: LArCellBinning_test.py:112
CBNTAA_TBTPValidation::m_ev_type
std::vector< int > * m_ev_type
Definition: CBNTAA_TBTPValidation.h:56
CBNTAA_TBTPValidation::m_cryou
std::vector< double > * m_cryou
Definition: CBNTAA_TBTPValidation.h:108
CBNTAA_TBTPValidation::m_xErr
std::vector< signal_type_TBBPCCont > * m_xErr
Definition: CBNTAA_TBTPValidation.h:67
CBNTAA_TBTPValidation::m_isX
std::vector< bool > * m_isX
Definition: CBNTAA_TBTPValidation.h:117
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
CBNTAA_TBTPValidation::m_containerKey5
std::string m_containerKey5
Definition: CBNTAA_TBTPValidation.h:75
CBNTAA_TBTPValidation::m_containerKey3
std::string m_containerKey3
Definition: CBNTAA_TBTPValidation.h:52
CBNTAA_TBTPValidation::m_adc
std::vector< unsigned int > * m_adc
Definition: CBNTAA_TBTPValidation.h:38
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CBNTAA_TBTPValidation::m_signal_tCatch
std::vector< float > * m_signal_tCatch
Definition: CBNTAA_TBTPValidation.h:90
CBNTAA_TBTPValidation::m_underThreshold_raw
std::vector< bool > * m_underThreshold_raw
Definition: CBNTAA_TBTPValidation.h:44
CBNTAA_TBTPValidation::m_hitnumber
std::vector< short > * m_hitnumber
Definition: CBNTAA_TBTPValidation.h:69
CBNT_TBRecBase::m_emId
const LArEM_ID * m_emId
Definition: CBNT_TBRecBase.h:65
CBNT_TBRecBase::m_fcalId
const LArFCAL_ID * m_fcalId
Definition: CBNT_TBRecBase.h:67
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
CBNTAA_TBTPValidation::m_ev_clock
std::vector< int > * m_ev_clock
Definition: CBNTAA_TBTPValidation.h:55
CBNTAA_TBTPValidation::m_yErr
std::vector< signal_type_TBBPCCont > * m_yErr
Definition: CBNTAA_TBTPValidation.h:67
LArDigit
Liquid Argon digit base class.
Definition: LArDigit.h:25
lumiFormat.i
int i
Definition: lumiFormat.py:92
CBNTAA_TBTPValidation::m_uintercept
std::vector< double > * m_uintercept
Definition: CBNTAA_TBTPValidation.h:107
CBNT_TBRecBase::m_log
MsgStream * m_log
Definition: CBNT_TBRecBase.h:63
CBNTAA_TBTPValidation::m_xPos
std::vector< signal_type_TBBPCCont > * m_xPos
Definition: CBNTAA_TBTPValidation.h:66
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
CBNTAA_TBTPValidation::m_run_num
std::vector< unsigned int > * m_run_num
Definition: CBNTAA_TBTPValidation.h:57
CBNT_TBRecBase::addBranch
void addBranch(const std::string &branchname, T &obj, const std::string &leaflist)
Definition: CBNT_TBRecBase.h:44
calibdata.exception
exception
Definition: calibdata.py:496
CBNTAA_TBTPValidation::m_triggerWord
std::vector< unsigned int > * m_triggerWord
Definition: CBNTAA_TBTPValidation.h:111
CBNTAA_TBTPValidation::m_signal_overflow_scint
std::vector< bool > * m_signal_overflow_scint
Definition: CBNTAA_TBTPValidation.h:84
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CBNTAA_TBTPValidation::m_tbDetectorName_TBADCRawCont
std::vector< std::string > * m_tbDetectorName_TBADCRawCont
Definition: CBNTAA_TBTPValidation.h:39
CBNTAA_TBTPValidation::m_cryoX
std::vector< float > * m_cryoX
Definition: CBNTAA_TBTPValidation.h:60
CBNTAA_TBTPValidation::m_phase
std::vector< float > * m_phase
Definition: CBNTAA_TBTPValidation.h:49
CaloCell_ID
Helper class for offline cell identifiers.
Definition: CaloCell_ID.h:34
TBTDCRawCont
Definition: TBTDCRawCont.h:21
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
CBNT_TBRecBase::CBNT_TBRecBase
CBNT_TBRecBase(const std::string &name, ISvcLocator *pSvcLocator)
Definition: CBNT_TBRecBase.cxx:12
CBNTAA_TBTPValidation::m_overflow_TBTDCRawCont
std::vector< bool > * m_overflow_TBTDCRawCont
Definition: CBNTAA_TBTPValidation.h:46
CBNTAA_TBTPValidation::m_signal_scint
std::vector< float > * m_signal_scint
Definition: CBNTAA_TBTPValidation.h:83
CBNTAA_TBTPValidation::m_containerKey6
std::string m_containerKey6
Definition: CBNTAA_TBTPValidation.h:81
CBNT_TBRecBase::m_hecId
const LArHEC_ID * m_hecId
Definition: CBNT_TBRecBase.h:66
TBMWPCCont
Definition: TBMWPCCont.h:17
TBTDC
Definition: TBTDC.h:17
CBNTAA_TBTPValidation::m_hitNumberV
std::vector< int > * m_hitNumberV
Definition: CBNTAA_TBTPValidation.h:102
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
beamspotman.basepath
string basepath
Definition: beamspotman.py:1018
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
CBNTAA_TBTPValidation::m_cErr
std::vector< std::vector< float > > * m_cErr
Definition: CBNTAA_TBTPValidation.h:116
CBNTAA_TBTPValidation::m_tdc_raw
std::vector< unsigned int > * m_tdc_raw
Definition: CBNTAA_TBTPValidation.h:43
CBNTAA_TBTPValidation::m_dTtoWAC
std::vector< float > * m_dTtoWAC
Definition: CBNTAA_TBTPValidation.h:51
CBNTAA_TBTPValidation::m_chi2u
std::vector< double > * m_chi2u
Definition: CBNTAA_TBTPValidation.h:104
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
CBNTAA_TBTPValidation::m_time_signal_tCatch
std::vector< float > * m_time_signal_tCatch
Definition: CBNTAA_TBTPValidation.h:90
CBNTAA_TBTPValidation::m_cPos
std::vector< std::vector< float > > * m_cPos
Definition: CBNTAA_TBTPValidation.h:115
CBNTAA_TBTPValidation::m_tdcmin_TBTDC
std::vector< int > * m_tdcmin_TBTDC
Definition: CBNTAA_TBTPValidation.h:97
CBNTAA_TBTPValidation::m_tbDetectorName_TBMWPCCont
std::vector< std::string > * m_tbDetectorName_TBMWPCCont
Definition: CBNTAA_TBTPValidation.h:119
EventInfo
This class provides general information about an event. Event information is provided by the accessor...
Definition: EventInfo/EventInfo/EventInfo.h:42
CBNTAA_TBTPValidation::m_cryow
std::vector< double > * m_cryow
Definition: CBNTAA_TBTPValidation.h:108
CBNTAA_TBTPValidation::m_overflow_TBScintillatorCont
std::vector< bool > * m_overflow_TBScintillatorCont
Definition: CBNTAA_TBTPValidation.h:86
CBNTAA_TBTPValidation::m_containerKey7
std::string m_containerKey7
Definition: CBNTAA_TBTPValidation.h:87
CBNTAA_TBTPValidation::m_clusterSize_c
std::vector< std::vector< float > > * m_clusterSize_c
Definition: CBNTAA_TBTPValidation.h:118
CBNTAA_TBTPValidation::m_yPos
std::vector< signal_type_TBBPCCont > * m_yPos
Definition: CBNTAA_TBTPValidation.h:66
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
CBNTAA_TBTPValidation::m_cryov
std::vector< double > * m_cryov
Definition: CBNTAA_TBTPValidation.h:108
CBNTAA_TBTPValidation::m_overflow_TBBPCCont
std::vector< bool > * m_overflow_TBBPCCont
Definition: CBNTAA_TBTPValidation.h:74
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
CBNTAA_TBTPValidation::m_scale_TBTDC
std::vector< float > * m_scale_TBTDC
Definition: CBNTAA_TBTPValidation.h:98
CBNTAA_TBTPValidation::m_containerKey4
std::string m_containerKey4
Definition: CBNTAA_TBTPValidation.h:63
TBMWPC
Definition: TBMWPC.h:30
a
TList * a
Definition: liststreamerinfos.cxx:10
TBPhase
Definition: TBPhase.h:22
h
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
TBEventInfo
Definition: TBEventInfo.h:27
CBNTAA_TBTPValidation::m_xPosOverflow
std::vector< bool > * m_xPosOverflow
Definition: CBNTAA_TBTPValidation.h:70
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CBNTAA_TBTPValidation::m_containerKey12
std::string m_containerKey12
Definition: CBNTAA_TBTPValidation.h:121
CBNTAA_TBTPValidation::m_time_signal_scint
std::vector< float > * m_time_signal_scint
Definition: CBNTAA_TBTPValidation.h:83
CBNTAA_TBTPValidation::m_cPosOverflow
std::vector< std::vector< unsigned > > * m_cPosOverflow
Definition: CBNTAA_TBTPValidation.h:123
DEBUG
#define DEBUG
Definition: page_access.h:11
CBNTAA_TBTPValidation::m_chi2
std::vector< double > * m_chi2
Definition: CBNTAA_TBTPValidation.h:104
CBNTAA_TBTPValidation::m_signal_overflow_tCatch
std::vector< bool > * m_signal_overflow_tCatch
Definition: CBNTAA_TBTPValidation.h:91
CBNTAA_TBTPValidation::m_vintercept
std::vector< double > * m_vintercept
Definition: CBNTAA_TBTPValidation.h:107
CBNTAA_TBTPValidation::m_tbDetectorName_TBBPCCont
std::vector< std::string > * m_tbDetectorName_TBBPCCont
Definition: CBNTAA_TBTPValidation.h:73
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
LArDigitContainer
Container class for LArDigit.
Definition: LArDigitContainer.h:24
CBNTAA_TBTPValidation::m_overflow_TBADCRawCont
std::vector< bool > * m_overflow_TBADCRawCont
Definition: CBNTAA_TBTPValidation.h:40
CBNT_TBRecBase::pre_execute
virtual StatusCode pre_execute()
Definition: CBNT_TBRecBase.cxx:61
TBScintillator
Definition: TBScintillator.h:25
TBTailCatcher::getSignals
const std::vector< signal_type > & getSignals() const
Definition: TBTailCatcher.cxx:58
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
CBNTAA_TBTPValidation::m_tableY
std::vector< float > * m_tableY
Definition: CBNTAA_TBTPValidation.h:62
Track
Definition: TriggerChamberClusterOnTrackCreator.h:21
TBMWPC::isCPosOverflow
std::vector< bool > isCPosOverflow() const
Definition: TBMWPC.h:78
CBNTAA_TBTPValidation::m_tdc_TBTDC
std::vector< int > * m_tdc_TBTDC
Definition: CBNTAA_TBTPValidation.h:96
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
TBTriggerPatternUnit
Definition: TBTriggerPatternUnit.h:27
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
CBNTAA_TBTPValidation::m_containerKey11
std::string m_containerKey11
Definition: CBNTAA_TBTPValidation.h:113
TBLArDigitContainer
Gaudi Class ID.
Definition: TBLArDigitContainer.h:40
CBNT_TBRecBase::m_ntTitle
std::string m_ntTitle
Definition: CBNT_TBRecBase.h:58
CBNT_TBRecBase::m_ntpath
std::string m_ntpath
Definition: CBNT_TBRecBase.h:58
CBNTAA_TBTPValidation::m_nSamples
std::vector< unsigned short > * m_nSamples
Definition: CBNTAA_TBTPValidation.h:79
DataVector< TBADCRaw >::size_type
BASE::size_type size_type
Definition: DataVector.h:813
CBNTAA_TBTPValidation::m_tbDetectorName_TBTailCatcher
std::vector< std::string > * m_tbDetectorName_TBTailCatcher
Definition: CBNTAA_TBTPValidation.h:92
CBNTAA_TBTPValidation::m_time_overflow_tCatch
std::vector< bool > * m_time_overflow_tCatch
Definition: CBNTAA_TBTPValidation.h:91
CBNTAA_TBTPValidation::m_channelID
std::vector< unsigned int > * m_channelID
Definition: CBNTAA_TBTPValidation.h:77
python.PyAthena.obj
obj
Definition: PyAthena.py:135
TBADCRawCont
Definition: TBADCRawCont.h:20
CBNTAA_TBTPValidation::m_xPulse
std::vector< signal_type_TBBPCCont > * m_xPulse
Definition: CBNTAA_TBTPValidation.h:68
CBNTAA_TBTPValidation::m_overflowSetFlag
std::vector< bool > * m_overflowSetFlag
Definition: CBNTAA_TBTPValidation.h:72
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
CBNTAA_TBTPValidation::m_containerKey1
std::string m_containerKey1
Definition: CBNTAA_TBTPValidation.h:41
getADC
float getADC(const AFP_SiDigi &digi)
Definition: AFP_SiDigi.h:29
CBNTAA_TBTPValidation::m_phase_TBTDC
std::vector< int > * m_phase_TBTDC
Definition: CBNTAA_TBTPValidation.h:99
CBNTAA_TBTPValidation::m_gain
std::vector< unsigned char > * m_gain
Definition: CBNTAA_TBTPValidation.h:78
getTDC
float getTDC(const AFP_SiDigi &digi)
Definition: AFP_SiDigi.h:25
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
CaloCell_ID::fcal_idHelper
const LArFCAL_ID * fcal_idHelper() const
access to FCAL idHelper
Definition: CaloCell_ID.h:75
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
TBBPCCont
Definition: TBBPCCont.h:17
CBNTAA_TBTPValidation::m_residualu
std::vector< double > * m_residualu
Definition: CBNTAA_TBTPValidation.h:103
ServiceHandle< ICondSvc >
CBNTAA_TBTPValidation::m_triggers
std::vector< bool > * m_triggers
Definition: CBNTAA_TBTPValidation.h:112
CBNTAA_TBTPValidation::m_containerKey9
std::string m_containerKey9
Definition: CBNTAA_TBTPValidation.h:100
Generated on Mon Jul 8 2024 21:41:14 for ATLAS Offline Software by   doxygen 1.8.18