ntpl-dumper for all persistified TB classes. More...

#include "TBRec/CBNTAA_TBTPValidation.h"

Inheritance 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.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

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

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, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
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};

CBNT_TBRecBase::NOT_VALID

@ NOT_VALID

Definition CBNT_TBRecBase.h:56

Constructor & Destructor Documentation

◆ CBNTAA_TBTPValidation()

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

Definition at line 21 of file CBNTAA_TBTPValidation.cxx.

                                                                                              : CBNT_TBRecBase(name, pSvcLocator)
{
  declareProperty("NeverReturnFailure", m_neverReturnFailure=false);
    
  // TBADCRawCont
  declareProperty("ContainerKey1",m_containerKey1="ADCRawCont");
    m_adc=NULL;
    m_tbDetectorName_TBADCRawCont=NULL;
    m_overflow_TBADCRawCont=NULL;
  // TBTDCRawCont
    declareProperty("ContainerKey2",m_containerKey2="TDCRawCont");
    m_tdc_raw=NULL;
    m_underThreshold_raw=NULL;
    m_tbDetectorName_TBTDCRawCont=NULL;
    m_overflow_TBTDCRawCont=NULL;
  // TBPhase
    declareProperty("ContainerKey3",m_containerKey3="TBPhase");
    m_phase=NULL;
    m_phaseind=NULL;
    m_dTtoWAC=NULL;
  // TBEventInfo
    declareProperty("m_containerKey4",m_containerKey4="TBEventInfo");
    m_ev_number=NULL;
    m_ev_clock=NULL;
    m_ev_type=NULL;
    m_run_num=NULL;
    m_beam_moment=NULL;
    m_beam_part=NULL;
    m_cryoX=NULL;
    m_cryoAngle=NULL;
    m_tableY=NULL;
  // TBBPCCont
    declareProperty("m_containerKey5",m_containerKey5="BPCCont");
    m_xPos=NULL;
    m_yPos=NULL;
    m_xErr=NULL;
    m_yErr=NULL;
    m_xPulse=NULL;
    m_yPulse=NULL;
    m_hitnumber=NULL;
    m_xPosOverflow=NULL;
    m_yPosOverflow=NULL;
    m_xPulseOverflow=NULL;
    m_yPulseOverflow=NULL;
    m_overflowSetFlag=NULL;
    m_tbDetectorName_TBBPCCont=NULL;
    m_overflow_TBBPCCont=NULL;
  // TBLArDigitContainer
    declareProperty("m_containerKey6",m_containerKey6="FREE");
    m_channelID=NULL;
    m_gain=NULL;
    m_nSamples=NULL;
    m_samples=NULL;
  // TBScintillatorCont
    declareProperty("m_containerKey7",m_containerKey7="ScintillatorCont");
    m_signal_scint=NULL;
    m_time_signal_scint=NULL;
    m_signal_overflow_scint=NULL;
    m_time_overflow_scint=NULL;
    m_tbDetectorName_TBScintillatorCont=NULL;
    m_overflow_TBScintillatorCont=NULL;
  // TBTailCatcher
    declareProperty("m_containerKey8",m_containerKey8="TailCatcher");
    m_signals=NULL;
    m_signal_tCatch=NULL;
    m_time_signal_tCatch=NULL;
    m_signal_overflow_tCatch=NULL;
    m_time_overflow_tCatch=NULL;
    m_tbDetectorName_TBTailCatcher=NULL;
    m_overflow_TBTailCatcher=NULL;
  // TBTDC 
    declareProperty("m_containerKey9",m_containerKey9="TBTDC");
    m_tdc_TBTDC=NULL;
    m_tdcmin_TBTDC=NULL;
    m_scale_TBTDC=NULL;
    m_phase_TBTDC=NULL;
  // TBTrack 
  declareProperty("m_containerKey10",m_containerKey10="Track");
    m_hitNumberU=NULL;
    m_hitNumberV=NULL;
    m_residualu=NULL;
    m_residualv=NULL;
    m_chi2=NULL;
    m_chi2u=NULL;
    m_chi2v=NULL;
    m_angle=NULL;
    m_uslope=NULL;
    m_vslope=NULL;
    m_uintercept=NULL;
    m_vintercept=NULL;
    m_cryou=NULL;
    m_cryov=NULL;
    m_cryow=NULL;
  // TBTriggerPatternUnit
  declareProperty("m_containerKey11",m_containerKey11="TBTrigPat");
    m_triggerWord=NULL;
    m_triggers=NULL;
  // TBMWPCCont
    declareProperty("m_containerKey12",m_containerKey12="MWPCCont");
    m_cPos=NULL;
    m_cErr=NULL;
    m_isX=NULL;
    m_clusterSize_c=NULL;
    m_cPosOverflow=NULL;
    m_tbDetectorName_TBMWPCCont=NULL;
    m_overflow_TBMWPCCont=NULL;
}

◆ ~CBNTAA_TBTPValidation()

CBNTAA_TBTPValidation::~CBNTAA_TBTPValidation ( )

Definition at line 130 of file CBNTAA_TBTPValidation.cxx.

{//Clean up arrays of ntuple entries (if they have been booked)
 
  // TBADCRawCont
  if (m_adc) delete m_adc;
  if (m_tbDetectorName_TBADCRawCont) delete m_tbDetectorName_TBADCRawCont;
  if (m_overflow_TBADCRawCont) delete m_overflow_TBADCRawCont;
  // TBTDCRawCont
  if (m_tdc_raw) delete m_tdc_raw;
    if (m_underThreshold_raw) delete m_underThreshold_raw;
    if (m_tbDetectorName_TBTDCRawCont) delete m_tbDetectorName_TBTDCRawCont;
    if (m_overflow_TBTDCRawCont) delete m_overflow_TBTDCRawCont;
  // TBPhase
    if (m_phase) delete m_phase;
    if (m_phaseind) delete m_phaseind;
    if (m_dTtoWAC) delete m_dTtoWAC;
  // TBEventInfo
    if (m_ev_number) delete  m_ev_number;
    if (m_ev_clock) delete  m_ev_clock;
    if (m_ev_type) delete  m_ev_type;
    if (m_run_num) delete  m_run_num;
    if (m_beam_moment) delete  m_beam_moment;
    if (m_beam_part) delete  m_beam_part;
    if (m_cryoX) delete  m_cryoX;
    if (m_cryoAngle) delete  m_cryoAngle;
    if (m_tableY) delete  m_tableY;
  // TBBPCCont
    if (m_xPos) delete  m_xPos;
    if (m_yPos) delete  m_yPos;
    if (m_xErr) delete  m_xErr;
    if (m_yErr) delete  m_yErr;
    if (m_xPulse) delete  m_xPulse;
    if (m_yPulse) delete  m_yPulse;
    if (m_hitnumber) delete  m_hitnumber;
    if (m_xPosOverflow) delete  m_xPosOverflow;
    if (m_yPosOverflow) delete  m_yPosOverflow;
    if (m_xPulseOverflow) delete  m_xPulseOverflow;
    if (m_yPulseOverflow) delete  m_yPulseOverflow;
    if (m_overflowSetFlag) delete  m_overflowSetFlag;
    if (m_tbDetectorName_TBBPCCont) delete  m_tbDetectorName_TBBPCCont;
    if (m_overflow_TBBPCCont) delete  m_overflow_TBBPCCont;
  // TBLArDigitContainer
    if (m_channelID) delete  m_channelID;
    if (m_gain) delete  m_gain;
    if (m_nSamples) delete  m_nSamples;
    if (m_samples) delete  m_samples;
  // TBScintillatorCont
    if (m_signal_scint) delete  m_signal_scint;
    if (m_time_signal_scint) delete  m_time_signal_scint;
    if (m_signal_overflow_scint) delete  m_signal_overflow_scint;
    if (m_time_overflow_scint) delete  m_time_overflow_scint;
    if (m_tbDetectorName_TBScintillatorCont) delete  m_tbDetectorName_TBScintillatorCont;
    if (m_overflow_TBScintillatorCont) delete  m_overflow_TBScintillatorCont;
  // TBTailCatcher
    if (m_signals) delete  m_signals;
    if (m_signal_tCatch) delete  m_signal_tCatch;
    if (m_time_signal_tCatch) delete  m_time_signal_tCatch;
    if (m_signal_overflow_tCatch) delete  m_signal_overflow_tCatch;
    if (m_time_overflow_tCatch) delete  m_time_overflow_tCatch;
    if (m_tbDetectorName_TBTailCatcher) delete  m_tbDetectorName_TBTailCatcher;
    if (m_overflow_TBTailCatcher) delete  m_overflow_TBTailCatcher;
  // TBTDC 
    if (m_tdc_TBTDC) delete  m_tdc_TBTDC;
    if (m_tdcmin_TBTDC) delete  m_tdcmin_TBTDC;
    if (m_scale_TBTDC) delete  m_scale_TBTDC;
    if (m_phase_TBTDC) delete  m_phase_TBTDC;
  // TBTrack 
    if (m_hitNumberU) delete  m_hitNumberU;
    if (m_hitNumberV) delete  m_hitNumberV;
    if (m_residualu) delete  m_residualu;
    if (m_residualv) delete  m_residualv;
    if (m_chi2) delete  m_chi2;
    if (m_chi2u) delete  m_chi2u;
    if (m_chi2v) delete  m_chi2v;
    if (m_angle) delete  m_angle;
    if (m_uslope) delete  m_uslope;
    if (m_vslope) delete  m_vslope;
    if (m_uintercept) delete  m_uintercept;
    if (m_vintercept) delete  m_vintercept;
    if (m_cryou) delete  m_cryou;
    if (m_cryov) delete  m_cryov;
    if (m_cryow) delete  m_cryow;
  // TBTriggerPatternUnit
    if (m_triggerWord) delete  m_triggerWord;
    if (m_triggers) delete  m_triggers;
  // TBMWPCCont
    if (m_cPos) delete  m_cPos;
    if (m_cErr) delete  m_cErr;
    if (m_isX) delete  m_isX;
    if (m_clusterSize_c) delete  m_clusterSize_c;
    if (m_cPosOverflow) delete  m_cPosOverflow;
    if (m_tbDetectorName_TBMWPCCont) delete  m_tbDetectorName_TBMWPCCont;
    if (m_overflow_TBMWPCCont) delete  m_overflow_TBMWPCCont;
}

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.

                                                                                      {
  std::string retval(base);
  for (unsigned i=0;i<extension.size();i++) {
    const char& ch=extension[i];
    if (ch=='=' || ch==':' || ch=='/')
      continue; //Inore these characters
    else if (ch=='-')
      retval.append("m");//replace by letter m
    else if (ch=='+')
      retval.append("p");//replace by letter p
    else
      retval.append(1,ch);
  }
  return retval;
}

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

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

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

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

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

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

◆ CBNT_clear()

StatusCode CBNTAA_TBTPValidation::CBNT_clear ( )

privatevirtual

Reimplemented from CBNT_TBRecBase.

Definition at line 721 of file CBNTAA_TBTPValidation.cxx.

{
 
  // TBADCRawCont
  if (m_adc) m_adc->clear();
  if (m_tbDetectorName_TBADCRawCont) m_tbDetectorName_TBADCRawCont->clear();
  if (m_overflow_TBADCRawCont) m_overflow_TBADCRawCont->clear();
  // TBTDCRawCont
  if (m_tdc_raw) m_tdc_raw->clear();
  if (m_underThreshold_raw) m_underThreshold_raw->clear();
  if (m_tbDetectorName_TBTDCRawCont) m_tbDetectorName_TBTDCRawCont->clear();
  if (m_overflow_TBTDCRawCont) m_overflow_TBTDCRawCont->clear();
  // TBPhase
  if (m_phase) m_phase->clear();
  if (m_phaseind) m_phaseind->clear();
  if (m_dTtoWAC) m_dTtoWAC->clear();
  // TBEventInfo
    if (m_ev_number)   m_ev_number->clear();
    if (m_ev_clock)   m_ev_clock->clear();
    if (m_ev_type)   m_ev_type->clear();
    if (m_run_num)   m_run_num->clear();
    if (m_beam_moment)   m_beam_moment->clear();
    if (m_beam_part)   m_beam_part->clear();
    if (m_cryoX)   m_cryoX->clear();
    if (m_cryoAngle)   m_cryoAngle->clear();
    if (m_tableY)   m_tableY->clear();
  // TBBPCCont
    if (m_xPos)   m_xPos->clear();
    if (m_yPos)   m_yPos->clear();
    if (m_xErr)   m_xErr->clear();
    if (m_yErr)   m_yErr->clear();
    if (m_xPulse)   m_xPulse->clear();
    if (m_yPulse)   m_yPulse->clear();
    if (m_hitnumber)   m_hitnumber->clear();
    if (m_xPosOverflow)   m_xPosOverflow->clear();
    if (m_yPosOverflow)   m_yPosOverflow->clear();
    if (m_xPulseOverflow)   m_xPulseOverflow->clear();
    if (m_yPulseOverflow)   m_yPulseOverflow->clear();
    if (m_overflowSetFlag)   m_overflowSetFlag->clear();
    if (m_tbDetectorName_TBBPCCont)   m_tbDetectorName_TBBPCCont->clear();
    if (m_overflow_TBBPCCont)   m_overflow_TBBPCCont->clear();
  // TBLArDigitContainer
    if (m_channelID)   m_channelID->clear();
    if (m_gain)   m_gain->clear();
    if (m_nSamples)   m_nSamples->clear();
    if (m_samples)   m_samples->clear();
  // TBScintillatorCont
    if (m_signal_scint)   m_signal_scint->clear();
    if (m_time_signal_scint)   m_time_signal_scint->clear();
    if (m_signal_overflow_scint)   m_signal_overflow_scint->clear();
    if (m_time_overflow_scint)   m_time_overflow_scint->clear();
    if (m_tbDetectorName_TBScintillatorCont)   m_tbDetectorName_TBScintillatorCont->clear();
    if (m_overflow_TBScintillatorCont)   m_overflow_TBScintillatorCont->clear();
  // TBTailCatcher
    if (m_signals)   m_signals->clear();
    if (m_signal_tCatch)   m_signal_tCatch->clear();
    if (m_time_signal_tCatch)   m_time_signal_tCatch->clear();
    if (m_signal_overflow_tCatch)   m_signal_overflow_tCatch->clear();
    if (m_time_overflow_tCatch)   m_time_overflow_tCatch->clear();
    if (m_tbDetectorName_TBTailCatcher)   m_tbDetectorName_TBTailCatcher->clear();
    if (m_overflow_TBTailCatcher)   m_overflow_TBTailCatcher->clear();
  // TBTDC 
    if (m_tdc_TBTDC)   m_tdc_TBTDC->clear();
    if (m_tdcmin_TBTDC)   m_tdcmin_TBTDC->clear();
    if (m_scale_TBTDC)   m_scale_TBTDC->clear();
    if (m_phase_TBTDC)   m_phase_TBTDC->clear();
  // TBTrack 
    if (m_hitNumberU)   m_hitNumberU->clear();
    if (m_hitNumberV)   m_hitNumberV->clear();
    if (m_residualu)   m_residualu->clear();
    if (m_residualv)   m_residualv->clear();
    if (m_chi2)   m_chi2->clear();
    if (m_chi2u)   m_chi2u->clear();
    if (m_chi2v)   m_chi2v->clear();
    if (m_angle)   m_angle->clear();
    if (m_uslope)   m_uslope->clear();
    if (m_vslope)   m_vslope->clear();
    if (m_uintercept)   m_uintercept->clear();
    if (m_vintercept)   m_vintercept->clear();
    if (m_cryou)   m_cryou->clear();
    if (m_cryov)   m_cryov->clear();
    if (m_cryow)   m_cryow->clear();
  // TBTriggerPatternUnit
    if (m_triggerWord)   m_triggerWord->clear();
    if (m_triggers)   m_triggers->clear();
  // TBMWPCCont
    if (m_cPos)   m_cPos->clear();
    if (m_cErr)   m_cErr->clear();
    if (m_isX)   m_isX->clear();
    if (m_clusterSize_c)   m_clusterSize_c->clear();
    if (m_cPosOverflow)   m_cPosOverflow->clear();
    if (m_tbDetectorName_TBMWPCCont)   m_tbDetectorName_TBMWPCCont->clear();
    if (m_overflow_TBMWPCCont)   m_overflow_TBMWPCCont->clear();
 
  return StatusCode::SUCCESS;
}

◆ CBNT_execute()

StatusCode CBNTAA_TBTPValidation::CBNT_execute ( )

virtual

Reimplemented from CBNT_TBRecBase.

Definition at line 327 of file CBNTAA_TBTPValidation.cxx.

{
  // ----------------------------------------------------------------------------------------------------
  // TBADCRawCont  
  // ----------------------------------------------------------------------------------------------------
  const TBADCRawCont * adcCont;
  StatusCode sc = evtStore()->retrieve(adcCont,m_containerKey1);
  if (sc.isFailure()) {
    ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBADCRawCont from StoreGate! key= " << m_containerKey1 << "\033[0m" );
  }  else  {
    ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBADCRawCont ( StoreGate key =" << m_containerKey1 << " ) ..."<< "\033[0m" );
 
    const unsigned nADC = (TBADCRawCont::size_type)adcCont->size();
    m_adc->resize(nADC);
    m_tbDetectorName_TBADCRawCont->resize(nADC);
    m_overflow_TBADCRawCont->resize(nADC);
 
    unsigned NtupleVectorIndex = 0;
    for (const TBADCRaw* adc : *adcCont) {
      (*m_adc)[NtupleVectorIndex]                          = adc-> getADC();
      (*m_tbDetectorName_TBADCRawCont)[NtupleVectorIndex]  = adc-> getDetectorName();    
      (*m_overflow_TBADCRawCont)[NtupleVectorIndex]        = adc-> isOverflow();
    }  
  }
 
  // ----------------------------------------------------------------------------------------------------
  // TBTDCRawCont  
  // ----------------------------------------------------------------------------------------------------
  const TBTDCRawCont * tdcCont;
  sc = evtStore()->retrieve(tdcCont,m_containerKey2);
  if (sc.isFailure()) {
    ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBTDCRawCont from StoreGate! key= " << m_containerKey2 << "\033[0m" );
  }  else  {
    ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBTDCRawCont ( StoreGate key =" << m_containerKey2 << " ) ..."<< "\033[0m" );
 
    const unsigned nTDC = (TBTDCRawCont::size_type)tdcCont->size();
    m_tdc_raw->resize(nTDC);
    m_underThreshold_raw->resize(nTDC);
    m_tbDetectorName_TBTDCRawCont->resize(nTDC);
    m_overflow_TBTDCRawCont->resize(nTDC);
 
    unsigned NtupleVectorIndex = 0;
    for (const TBTDCRaw* tdc : *tdcCont) {
      (*m_tdc_raw)[NtupleVectorIndex]                      = tdc-> getTDC();
      (*m_underThreshold_raw)[NtupleVectorIndex]           = tdc-> isUnderThreshold();
      (*m_tbDetectorName_TBTDCRawCont)[NtupleVectorIndex]  = tdc-> getDetectorName();
      (*m_overflow_TBTDCRawCont)[NtupleVectorIndex]        = tdc-> isOverflow();
    }
  }
 
  // ----------------------------------------------------------------------------------------------------
  // TBPhase  
  // ----------------------------------------------------------------------------------------------------
  const TBPhase * phase = nullptr;
  sc = evtStore()->retrieve(phase,m_containerKey3);
  if (sc.isFailure()) {
    ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBPhase from StoreGate! key= " << m_containerKey3 << "\033[0m" );
  }  else  {    
    ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBPhase ( StoreGate key =" << m_containerKey3 << " ) ..."<< "\033[0m" );
 
    m_phase     ->resize(1);
    m_phaseind  ->resize(1);
    m_dTtoWAC   ->resize(1);
 
    (*m_phase)[0]    = phase-> getPhase();
    (*m_phaseind)[0] = phase-> getPhaseind();
    (*m_dTtoWAC)[0]  = phase-> getdTtoWACSigned();
  }
 
  // ----------------------------------------------------------------------------------------------------
  // TBEventInfo  
  // ----------------------------------------------------------------------------------------------------
  const TBEventInfo * EventInfo = nullptr;
  sc = evtStore()->retrieve(EventInfo,m_containerKey4);
  if (sc.isFailure()) {
    ATH_MSG_ERROR ( "\033[31m" << "- Can not read EventInfo from StoreGate! key= " << m_containerKey4 << "\033[0m" );
  }  else  {
    ATH_MSG_DEBUG ( "\033[34m" << "- Going over EventInfo ( StoreGate key =" << m_containerKey4 << " ) ..."<< "\033[0m" );
 
    m_ev_number   ->resize(1);
    m_ev_clock    ->resize(1);
    m_ev_type     ->resize(1);
    m_run_num     ->resize(1);
    m_beam_moment ->resize(1);
    m_beam_part   ->resize(1);
    m_cryoX       ->resize(1);
    m_cryoAngle   ->resize(1);
    m_tableY      ->resize(1);
 
    (*m_ev_number)[0]    = EventInfo-> getEventNum();
    (*m_ev_clock)[0]     = EventInfo-> getEventClock();
    (*m_ev_type)[0]      = EventInfo-> getEventType();
    (*m_run_num)[0]      = EventInfo-> getRunNum();
    (*m_beam_moment)[0]  = EventInfo-> getBeamMomentum();
    (*m_beam_part)[0]    = EventInfo-> getBeamParticle();
    (*m_cryoX)[0]        = EventInfo-> getCryoX();
    (*m_cryoAngle)[0]    = EventInfo-> getCryoAngle();
    (*m_tableY)[0]       = EventInfo-> getTableY();
  }
 
 
  // ----------------------------------------------------------------------------------------------------
  // TBBPCCont  
  // ----------------------------------------------------------------------------------------------------
  const TBBPCCont * BPCCont = nullptr;
  sc = evtStore()->retrieve(BPCCont,m_containerKey5);
  if (sc.isFailure()) {
    ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBBPCCont from StoreGate! key= " << m_containerKey5 << "\033[0m" );
  }  else  {
    ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBBPCCont ( StoreGate key =" << m_containerKey5 << " ) ..."<< "\033[0m" );
 
    const unsigned nBPCCont = (TBBPCCont::size_type)BPCCont->size();
    m_xPos                      ->resize(nBPCCont);
    m_yPos                      ->resize(nBPCCont);
    m_xErr                      ->resize(nBPCCont);
    m_yErr                      ->resize(nBPCCont);
    m_xPulse                    ->resize(nBPCCont);
    m_yPulse                    ->resize(nBPCCont);
    m_hitnumber                 ->resize(nBPCCont);
    m_xPosOverflow              ->resize(nBPCCont);
    m_yPosOverflow              ->resize(nBPCCont);
    m_xPulseOverflow            ->resize(nBPCCont);
    m_yPulseOverflow            ->resize(nBPCCont);
    m_overflowSetFlag           ->resize(nBPCCont);
    m_tbDetectorName_TBBPCCont  ->resize(nBPCCont);
    m_overflow_TBBPCCont        ->resize(nBPCCont);
     
    unsigned NtupleVectorIndex = 0;
    for (const TBBPC* bpc : *BPCCont) {
        (*m_xPos)[NtupleVectorIndex]                      = bpc-> getXPos();
        (*m_yPos)[NtupleVectorIndex]                      = bpc-> getYPos();
        (*m_xErr)[NtupleVectorIndex]                      = bpc-> getXErr();
        (*m_yErr)[NtupleVectorIndex]                      = bpc-> getYErr();
        (*m_xPulse)[NtupleVectorIndex]                    = bpc-> getXPulse();
        (*m_yPulse)[NtupleVectorIndex]                    = bpc-> getYPulse();
        (*m_hitnumber)[NtupleVectorIndex]                 = bpc-> getHitNbr();
        (*m_xPosOverflow)[NtupleVectorIndex]              = bpc-> isXPosOverflow();
        (*m_yPosOverflow)[NtupleVectorIndex]              = bpc-> isYPosOverflow();
        (*m_xPulseOverflow)[NtupleVectorIndex]            = bpc-> isXPulseOverflow();
        (*m_yPulseOverflow)[NtupleVectorIndex]            = bpc-> isYPulseOverflow();
        (*m_overflowSetFlag)[NtupleVectorIndex]           = false;//bpc-> m_overflowSetFlag ;
        (*m_tbDetectorName_TBBPCCont)[NtupleVectorIndex]  = bpc-> getDetectorName();
        (*m_overflow_TBBPCCont)[NtupleVectorIndex]        = bpc-> isOverflow();
    }
  }
 
 
  // ----------------------------------------------------------------------------------------------------
  // TBLArDigitContainer    // FIXME !!!  probably does not work right.... //
  // ----------------------------------------------------------------------------------------------------
  const TBLArDigitContainer * LArDigitContainer = nullptr;
  sc = evtStore()->retrieve(LArDigitContainer,m_containerKey6);
  if (sc.isFailure()) {
    ATH_MSG_ERROR ( "\033[31m" << "- Can not read LArDigitContainer from StoreGate! key= " << m_containerKey6 << "\033[0m" );
    }  else  {
    ATH_MSG_DEBUG ( "\033[34m" << "- Going over LArDigitContainer ( StoreGate key =" << m_containerKey6 << " ) ..."<< "\033[0m" );
 
    const unsigned nLArDigits = (TBLArDigitContainer::size_type)LArDigitContainer->size();
    m_channelID->resize(nLArDigits);
    m_gain->resize(nLArDigits);
    m_nSamples->resize(nLArDigits);
    if (nLArDigits) 
      m_samples->reserve( ( (*(LArDigitContainer->begin()))->nsamples() ) * nLArDigits);
 
    unsigned NtupleVectorIndex = 0;
    for (const LArDigit* larDigit : *LArDigitContainer) {
      (*m_channelID)[NtupleVectorIndex] = larDigit->hardwareID().get_identifier32().get_compact() ;
      (*m_gain)[NtupleVectorIndex] = (unsigned char)larDigit->gain();
 
      unsigned nM_samples = larDigit->nsamples();
      (*m_nSamples)[NtupleVectorIndex] = nM_samples;
        
      m_samples->assign (larDigit->samples().begin(),
                         larDigit->samples().end());
    }
  }
 
 
  // ----------------------------------------------------------------------------------------------------
  // TBScintillatorCont  
  // ----------------------------------------------------------------------------------------------------
  const TBScintillatorCont * ScintillatorCont = nullptr;
  sc = evtStore()->retrieve(ScintillatorCont,m_containerKey7);
  if (sc.isFailure()) {
    ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBScintillatorCont from StoreGate! key= " << m_containerKey7 << "\033[0m" );
  }  else  {
    ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBScintillatorCont ( StoreGate key =" << m_containerKey7 << " ) ..."<< "\033[0m" );
 
    const unsigned nScintillators = (TBScintillatorCont::size_type)ScintillatorCont->size();
    m_signal_scint                        ->resize(nScintillators);
    m_time_signal_scint                   ->resize(nScintillators);
    m_signal_overflow_scint               ->resize(nScintillators);
    m_time_overflow_scint                 ->resize(nScintillators);
    m_tbDetectorName_TBScintillatorCont   ->resize(nScintillators);
    m_overflow_TBScintillatorCont         ->resize(nScintillators);
 
 
    unsigned NtupleVectorIndex = 0;
    TBScintillatorCont::const_iterator it_TBScintillatorCont   = ScintillatorCont->begin();
    TBScintillatorCont::const_iterator last_TBScintillatorCont = ScintillatorCont->end();
    for(;it_TBScintillatorCont!=last_TBScintillatorCont;++it_TBScintillatorCont,NtupleVectorIndex++) {
      // scint->isTimeOverflow() is not a constant method, and so we define here
      // 'TBScintillator * scint'  instead of the usual  'const TBScintillator * scint'
      // since for a const TBScintillator all methods need to be const as well...
      const TBScintillator * scint = (*it_TBScintillatorCont);
 
      (*m_signal_scint)[NtupleVectorIndex]                        = scint-> getSignal();
      (*m_time_signal_scint)[NtupleVectorIndex]                   = scint-> getTimeSignal();
      (*m_signal_overflow_scint)[NtupleVectorIndex]               = scint-> isSignalOverflow();
      (*m_time_overflow_scint)[NtupleVectorIndex]                 = scint-> isTimeOverflow();
      (*m_tbDetectorName_TBScintillatorCont)[NtupleVectorIndex]   = scint-> getDetectorName();
      (*m_overflow_TBScintillatorCont)[NtupleVectorIndex]         = scint-> isOverflow();
    }
  }
 
 
  // ----------------------------------------------------------------------------------------------------
  // TBTailCatcher  
  // ----------------------------------------------------------------------------------------------------
  const TBTailCatcher * TailCatcher = nullptr;
  sc = evtStore()->retrieve(TailCatcher,m_containerKey8);
  if (sc.isFailure()) {
    ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBTailCatcher from StoreGate! key= " << m_containerKey8 << "\033[0m" );
  }  else  {
    ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBTailCatcher ( StoreGate key =" << m_containerKey8 << " ) ..."<< "\033[0m" );
 
    const unsigned nTailCatchers = (TBTailCatcher::size_type)TailCatcher->size();
    m_signals                         ->resize(nTailCatchers);
    m_signal_tCatch                   ->resize(nTailCatchers);
    m_time_signal_tCatch              ->resize(nTailCatchers);
    m_signal_overflow_tCatch          ->resize(nTailCatchers);
    m_time_overflow_tCatch            ->resize(nTailCatchers);
    m_tbDetectorName_TBTailCatcher    ->resize(nTailCatchers);
    m_overflow_TBTailCatcher          ->resize(nTailCatchers);
 
    (*m_signals) = TailCatcher->getSignals();
 
    unsigned NtupleVectorIndex = 0;
    TBTailCatcher::const_iterator it_TailCatcher   = TailCatcher->begin();
    TBTailCatcher::const_iterator last_TailCatcher = TailCatcher->end();
    for(;it_TailCatcher!=last_TailCatcher;++it_TailCatcher,NtupleVectorIndex++) {
      // scint->isTimeOverflow() is not a constant method, and so we define here
      // 'TBScintillator * scint'  instead of the usual  'const TBScintillator * scint'
      // since for a const TBScintillator all methods need to be const as well...
      const TBScintillator * scint = (*it_TailCatcher);
 
      (*m_signal_tCatch)[NtupleVectorIndex]                   = scint-> getSignal();
      (*m_time_signal_tCatch)[NtupleVectorIndex]              = scint-> getTimeSignal();
      (*m_signal_overflow_tCatch)[NtupleVectorIndex]          = scint-> isSignalOverflow();
      (*m_time_overflow_tCatch)[NtupleVectorIndex]            = scint-> isTimeOverflow();
      (*m_tbDetectorName_TBTailCatcher)[NtupleVectorIndex]    = scint-> getDetectorName();
      (*m_overflow_TBTailCatcher)[NtupleVectorIndex]          = scint-> isOverflow();
    }
  }
 
 
  // ----------------------------------------------------------------------------------------------------
  // TBTDC  
  // ----------------------------------------------------------------------------------------------------
  const TBTDC * TDC = nullptr;
  sc = evtStore()->retrieve(TDC,m_containerKey9);
  if (sc.isFailure()) {
    ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBTDC from StoreGate! key= " << m_containerKey9 << "\033[0m" );
  }  else  {
    ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBTDC ( StoreGate key =" << m_containerKey9 << " ) ..."<< "\033[0m" );
 
    m_tdc_TBTDC      ->resize(1);
    m_tdcmin_TBTDC   ->resize(1);
    m_scale_TBTDC    ->resize(1);
    m_phase_TBTDC    ->resize(1);
 
    (*m_tdc_TBTDC)[0]    = TDC-> tdc();
    (*m_tdcmin_TBTDC)[0] = TDC-> tdcmin();
    (*m_scale_TBTDC)[0]  = TDC-> scale();
    (*m_phase_TBTDC)[0]  = TDC-> phase();
  }
 
 
  // ----------------------------------------------------------------------------------------------------
  // TBTrack  
  // ----------------------------------------------------------------------------------------------------
  const TBTrack * Track = nullptr;
  sc = evtStore()->retrieve(Track,m_containerKey10);
  if (sc.isFailure()) {
    ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBTrack from StoreGate! key= " << m_containerKey10 << "\033[0m" );
  }  else  {
    ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBTrack ( StoreGate key =" << m_containerKey10 << " ) ..."<< "\033[0m" );
 
    m_hitNumberU      ->resize(1);
    m_hitNumberV      ->resize(1);
    m_chi2            ->resize(1);
    m_chi2u           ->resize(1);
    m_chi2v           ->resize(1);
    m_angle           ->resize(1);
    m_uslope          ->resize(1);
    m_vslope          ->resize(1);
    m_uintercept      ->resize(1);
    m_vintercept      ->resize(1);
    m_cryou           ->resize(1);
    m_cryov           ->resize(1);
    m_cryow           ->resize(1);
 
    (*m_hitNumberU)[0]    = Track->  getHitNumberU();
    (*m_hitNumberV)[0]    = Track->  getHitNumberV();
    (*m_chi2)[0]          = Track->  getChi2_global();
    (*m_chi2u)[0]         = Track->  getChi2_u();
    (*m_chi2v)[0]         = Track->  getChi2_v();
    (*m_angle)[0]         = Track->  getAngle();
    (*m_uslope)[0]        = Track->  getUslope();
    (*m_vslope)[0]        = Track->  getVslope();
    (*m_uintercept)[0]    = Track->  getUintercept();
    (*m_vintercept)[0]    = Track->  getVintercept();
    (*m_cryou)[0]         = Track->  getCryoHitu();
    (*m_cryov)[0]         = Track->  getCryoHitv();
    (*m_cryow)[0]         = Track->  getCryoHitw();
    (*m_residualu) = Track->  getResidualu();
    (*m_residualv) = Track->  getResidualv();
  }
 
 
  // ----------------------------------------------------------------------------------------------------
  // TBTriggerPatternUnit  
  // ----------------------------------------------------------------------------------------------------
  const TBTriggerPatternUnit * TriggerPatternUnit = nullptr;
  sc = evtStore()->retrieve(TriggerPatternUnit,m_containerKey11);
  if (sc.isFailure()) {
    ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBTriggerPatternUnit from StoreGate! key= " << m_containerKey11 << "\033[0m" );
  }  else  {
    ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBTriggerPatternUnit ( StoreGate key =" << m_containerKey11 << " ) ..."<< "\033[0m" );
 
    m_triggerWord->resize(1);
    (*m_triggerWord)[0] = TriggerPatternUnit->  getTriggerWord();
 
    (*m_triggers)       = TriggerPatternUnit->  getTriggers();
  }
 
 
  // ----------------------------------------------------------------------------------------------------
  // TBMWPCCont  
  // ----------------------------------------------------------------------------------------------------
  const TBMWPCCont * MWPCCont = nullptr;
  sc = evtStore()->retrieve(MWPCCont,m_containerKey12);
  if (sc.isFailure()) {
    ATH_MSG_ERROR ( "\033[31m" << "- Can not read TBMWPCCont from StoreGate! key= " << m_containerKey12 << "\033[0m" );
  }  else  {
    ATH_MSG_DEBUG ( "\033[34m" << "- Going over TBMWPCCont ( StoreGate key =" << m_containerKey12 << " ) ..."<< "\033[0m" );
 
    const unsigned nMWPCCont = (TBMWPCCont::size_type)MWPCCont->size();
    m_cPos                        ->resize(nMWPCCont);
    m_cErr                        ->resize(nMWPCCont);
    m_isX                         ->resize(nMWPCCont);
    m_clusterSize_c               ->resize(nMWPCCont);
    m_cPosOverflow                ->resize(nMWPCCont);
    m_tbDetectorName_TBMWPCCont   ->resize(nMWPCCont);
    m_overflow_TBMWPCCont         ->resize(nMWPCCont);
 
    unsigned NtupleVectorIndex = 0;
    TBMWPCCont::const_iterator it_TBMWPCCont   = MWPCCont->begin();
    TBMWPCCont::const_iterator last_TBMWPCCont = MWPCCont->end();
    for(;it_TBMWPCCont!=last_TBMWPCCont;++it_TBMWPCCont,NtupleVectorIndex++) {
      const TBMWPC * mwpc = (*it_TBMWPCCont);
 
      (*m_cPos)[NtupleVectorIndex]                      = mwpc-> getCPos();
      (*m_cErr)[NtupleVectorIndex]                      = mwpc-> getCErr();
      (*m_isX)[NtupleVectorIndex]                       = mwpc-> isX();
      (*m_clusterSize_c)[NtupleVectorIndex]             = mwpc-> getClusterSizeC();
      (*m_tbDetectorName_TBMWPCCont)[NtupleVectorIndex] = mwpc-> getDetectorName();
      (*m_overflow_TBMWPCCont)[NtupleVectorIndex]       = mwpc-> isOverflow();
 
      // ------------------------------------------------------------------------------------------------
      // for some reason a stright forward definition of m_cPosOverflow as
      // std::vector < std::vector<bool> > m_cPosOverflow;
      // does not work. perhaps due to the fact that std::vector<bool> is nonconforming (not
      // really a vector of bool variables, but some ). instead we defined
      // std::vector < std::vector<unsigned> > m_cPosOverflow;
      // and now need to convert the bool constituents of the vectors to unsigned
      // ------------------------------------------------------------------------------------------------
      unsigned nBools = mwpc->isCPosOverflow().size();    //lenght of the vector of bool in TBMWPC
      std::vector<unsigned>  cPosOverflowNow(nBools);   //defines lenght and initializes to zero
    
      for (unsigned nBoolNow=0; nBoolNow<nBools; nBoolNow++)
        if(mwpc->isCPosOverflow()[nBoolNow])
          cPosOverflowNow[nBoolNow] = 1;
 
      (*m_cPosOverflow)[NtupleVectorIndex] =  cPosOverflowNow;
      cPosOverflowNow.clear();
      // ------------------------------------------------------------------------------------------------
    }
  }
 
  return StatusCode::SUCCESS;
}  

◆ CBNT_finalize()

StatusCode CBNTAA_TBTPValidation::CBNT_finalize ( )

virtual

Reimplemented from CBNT_TBRecBase.

Definition at line 819 of file CBNTAA_TBTPValidation.cxx.

{
  ATH_MSG_DEBUG ( "in finalize()" );
  return StatusCode::SUCCESS;
}

◆ CBNT_initialize()

StatusCode CBNTAA_TBTPValidation::CBNT_initialize ( )

virtual

Reimplemented from CBNT_TBRecBase.

Definition at line 227 of file CBNTAA_TBTPValidation.cxx.

{
  ATH_MSG_DEBUG ( "in initialize()" );
 
  // TBADCRawCont
  addBranch("TBTPValid_TBADCRaw_m_adc",m_adc);
  addBranch("TBTPValid_TBADCRaw_tbDetectorName",m_tbDetectorName_TBADCRawCont);
  addBranch("TBTPValid_TBADCRaw_overflow",m_overflow_TBADCRawCont);
  // TBTDCRawCont
  addBranch("TBTPValid_TBTDCRaw_tdc",m_tdc_raw);
  addBranch("TBTPValid_TBTDCRaw_underThreshold",m_underThreshold_raw);
  addBranch("TBTPValid_TBTDCRaw_tbDetectorName",m_tbDetectorName_TBTDCRawCont);
  addBranch("TBTPValid_TBTDCRaw_overflow",m_overflow_TBTDCRawCont);
  // TBPhase
  addBranch("TBTPValid_TBPhase_phase",m_phase);
  addBranch("TBTPValid_TBPhase_phaseind",m_phaseind);
  addBranch("TBTPValid_TBPhase_dTtoWAC",m_dTtoWAC);
  // TBEventInfo
    addBranch("TBTPValid_TBEventInfo_ev_number",  m_ev_number);
    addBranch("TBTPValid_TBEventInfo_ev_clock",  m_ev_clock);
    addBranch("TBTPValid_TBEventInfo_ev_type",  m_ev_type);
    addBranch("TBTPValid_TBEventInfo_run_num",  m_run_num);
    addBranch("TBTPValid_TBEventInfo_beam_moment",  m_beam_moment);
    addBranch("TBTPValid_TBEventInfo_beam_part",  m_beam_part);
    addBranch("TBTPValid_TBEventInfo_cryoX",  m_cryoX);
    addBranch("TBTPValid_TBEventInfo_cryoAngle",  m_cryoAngle);
    addBranch("TBTPValid_TBEventInfo_tableY",  m_tableY);
  // TBBPCCont
    addBranch("TBTPValid_TBBPCCont_xPos",  m_xPos);
    addBranch("TBTPValid_TBBPCCont_yPos",  m_yPos);
    addBranch("TBTPValid_TBBPCCont_xErr",  m_xErr);
    addBranch("TBTPValid_TBBPCCont_yErr",  m_yErr);
    addBranch("TBTPValid_TBBPCCont_xPulse",  m_xPulse);
    addBranch("TBTPValid_TBBPCCont_yPulse",  m_yPulse);
    addBranch("TBTPValid_TBBPCCont_hitnumber",  m_hitnumber);
    addBranch("TBTPValid_TBBPCCont_xPosOverflow",  m_xPosOverflow);
    addBranch("TBTPValid_TBBPCCont_yPosOverflow",  m_yPosOverflow);
    addBranch("TBTPValid_TBBPCCont_xPulseOverflow",  m_xPulseOverflow);
    addBranch("TBTPValid_TBBPCCont_yPulseOverflow",  m_yPulseOverflow);
    addBranch("TBTPValid_TBBPCCont_overflowSetFlag",  m_overflowSetFlag);
    addBranch("TBTPValid_TBBPCCont_tbDetectorName",  m_tbDetectorName_TBBPCCont);
    addBranch("TBTPValid_TBBPCCont_overflow",  m_overflow_TBBPCCont);
  // TBLArDigitContainer
    addBranch("TBTPValid_TBLArDigitContainer_channelID",  m_channelID);
    addBranch("TBTPValid_TBLArDigitContainer_gain",  m_gain);
    addBranch("TBTPValid_TBLArDigitContainer_nSamples",  m_nSamples);
    addBranch("TBTPValid_TBLArDigitContainer_samples",  m_samples);
  // TBScintillatorCont
    addBranch("TBTPValid_TBScintillatorCont_signal",  m_signal_scint);
    addBranch("TBTPValid_TBScintillatorCont_time_signal",  m_time_signal_scint);
    addBranch("TBTPValid_TBScintillatorCont_signal_overflow",  m_signal_overflow_scint);
    addBranch("TBTPValid_TBScintillatorCont_time_overflow",  m_time_overflow_scint);
    addBranch("TBTPValid_TBScintillatorCont_tbDetectorName",  m_tbDetectorName_TBScintillatorCont);
    addBranch("TBTPValid_TBScintillatorCont_overflow",  m_overflow_TBScintillatorCont);
  // TBTailCatcher
    addBranch("TBTPValid_TBTailCatcher_signals",  m_signals);
    addBranch("TBTPValid_TBTailCatcher_signal",  m_signal_tCatch);
    addBranch("TBTPValid_TBTailCatcher_time_signal",  m_time_signal_tCatch);
    addBranch("TBTPValid_TBTailCatcher_signal_overflow",  m_signal_overflow_tCatch);
    addBranch("TBTPValid_TBTailCatcher_time_overflow",  m_time_overflow_tCatch);
    addBranch("TBTPValid_TBTailCatcher_tbDetectorName",  m_tbDetectorName_TBTailCatcher);
    addBranch("TBTPValid_TBTailCatcher_overflow",  m_overflow_TBTailCatcher);
  // TBTDC 
    addBranch("TBTPValid_TBTDC_tdc",  m_tdc_TBTDC);
    addBranch("TBTPValid_TBTDC_tdcmin",  m_tdcmin_TBTDC);
    addBranch("TBTPValid_TBTDC_scale",  m_scale_TBTDC);
    addBranch("TBTPValid_TBTDC_phase",  m_phase_TBTDC);
  // TBTrack 
    addBranch("TBTPValid_TBTrack_hitNumberU",  m_hitNumberU);
    addBranch("TBTPValid_TBTrack_hitNumberV",  m_hitNumberV);
    addBranch("TBTPValid_TBTrack_residualu",  m_residualu);
    addBranch("TBTPValid_TBTrack_residualv",  m_residualv);
    addBranch("TBTPValid_TBTrack_chi2",  m_chi2);
    addBranch("TBTPValid_TBTrack_chi2u",  m_chi2u);
    addBranch("TBTPValid_TBTrack_chi2v",  m_chi2v);
    addBranch("TBTPValid_TBTrack_angle",  m_angle);
    addBranch("TBTPValid_TBTrack_uslope",  m_uslope);
    addBranch("TBTPValid_TBTrack_vslope",  m_vslope);
    addBranch("TBTPValid_TBTrack_uintercept",  m_uintercept);
    addBranch("TBTPValid_TBTrack_vintercept",  m_vintercept);
    addBranch("TBTPValid_TBTrack_cryou",  m_cryou);
    addBranch("TBTPValid_TBTrack_cryov",  m_cryov);
    addBranch("TBTPValid_TBTrack_cryow",  m_cryow);
  // TBTriggerPatternUnit
    addBranch("TBTPValid_TBTriggerPatternUnit_triggerWord",  m_triggerWord);
    addBranch("TBTPValid_TBTriggerPatternUnit_triggers",  m_triggers);
  // TBMWPCCont
    addBranch("TBTPValid_TBMWPCCont_cPos",  m_cPos);
    addBranch("TBTPValid_TBMWPCCont_cErr",  m_cErr);
    addBranch("TBTPValid_TBMWPCCont_isX",  m_isX);
    addBranch("TBTPValid_TBMWPCCont_clusterSize_c",  m_clusterSize_c);
    addBranch("TBTPValid_TBMWPCCont_cPosOverflow",  m_cPosOverflow);
    addBranch("TBTPValid_TBMWPCCont_tbDetectorName",  m_tbDetectorName_TBMWPCCont);
    addBranch("TBTPValid_TBMWPCCont_overflow",  m_overflow_TBMWPCCont);
 
  return StatusCode::SUCCESS; 
  
}

◆ declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

◆ declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

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

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

StatusCode CBNT_TBRecBase::execute ( )

overridevirtualinherited

Definition at line 154 of file CBNT_TBRecBase.cxx.

                                   {
 
  StatusCode sc;
 
   // run pre-execution
  try {
            sc = this->pre_execute();
  }
        
  catch( const std::exception& Exception ) {
   *m_log << MSG::ERROR << " Standard exception " 
               << Exception.what() 
               << " caught from sub-algorithm::CBNT_pre_execute (). Disable !" << endmsg ;
    sc = this->setProperty(BooleanProperty( "Enable",false ) );
    return StatusCode::FAILURE;
   
  }
  catch (...) {
    *m_log << MSG::ERROR << " Unknown exception " 
         << " caught from sub-algorithm::CBNT_pre_execute (). Disable !" << endmsg ;
     sc = this->setProperty(BooleanProperty( "Enable",false ) );
     return StatusCode::FAILURE;
  }
 
  if (sc.isFailure()) {
    *m_log << MSG::ERROR << "CBNT_pre_execute() failed. Disable !" << endmsg;
     sc = this->setProperty(BooleanProperty( "Enable",false ) );
     return sc;
  }
           
  // now subalgorithm execution
  try {
     sc = this->CBNT_execute();
  }
 
  catch( const std::exception& Exception ) {
    *m_log << MSG::ERROR << " Standard exception " 
         << Exception.what() 
         << " caught from sub-algorithm::CBNT_execute () :" << endmsg ;
     return StatusCode::FAILURE;
  }
  catch (...) {
    *m_log << MSG::ERROR << " Unknown exception " 
         << " caught from sub-algorithm::CBNT_execute () :" << endmsg ;
     return StatusCode::FAILURE;
  }
 
  return sc;
}

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

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

◆ finalize()

StatusCode CBNT_TBRecBase::finalize ( )

overridevirtualinherited

Definition at line 205 of file CBNT_TBRecBase.cxx.

                                    {
 
  StatusCode sc;
 
  //now subalgorithm finalisation
  try {
    sc = this->CBNT_finalize();
  }
  catch( const std::exception& Exception ) {
    *m_log << MSG::ERROR << " Standard exception " 
         << Exception.what() 
         << " caught from sub-algorithm::CBNT_finalize () :" << endmsg ;
  }
  catch (...) {
     *m_log << MSG::ERROR << " Unknown exception " 
          << " caught from sub-algorithm::CBNT_finalize () :" << endmsg ;
  }
 
  return sc;
}

◆ initialize()

StatusCode CBNT_TBRecBase::initialize ( )

overridevirtualinherited

Definition at line 22 of file CBNT_TBRecBase.cxx.

                                      {
  m_log=new MsgStream(msgSvc(), name());
  
  *m_log << MSG::DEBUG << "Initializing CBNT_TBRecBase base class" << endmsg;
  
  const CaloCell_ID* idHelper = nullptr;
  ATH_CHECK( detStore()->retrieve (idHelper, "CaloCell_ID") );
  m_emId=idHelper->em_idHelper();
  m_fcalId=idHelper->fcal_idHelper();
  m_hecId=idHelper->hec_idHelper();
 
 
  if (!m_emId) {
    (*m_log) << MSG::ERROR << "Could not access lar EM ID helper" << endmsg;
    return StatusCode::FAILURE;
  }
  if (!m_fcalId) {
    (*m_log) << MSG::ERROR << "Could not access lar FCAL ID helper" << endmsg;
    return StatusCode::FAILURE;
  }
  if (!m_hecId) {
    (*m_log) << MSG::ERROR << "Could not access lar HEC ID helper" << endmsg;
    return StatusCode::FAILURE;
  }
 
  StatusCode sc = detStore()->retrieve(m_onlineId, "LArOnlineID");
  if (sc.isFailure()) {
    (*m_log) << MSG::ERROR << "Could not get LArOnlineID helper !" << endmsg;
    return StatusCode::FAILURE;
  }
    else {
      (*m_log) << MSG::DEBUG << " Found the LArOnlineID helper. " << endmsg;
    }
 
 
  m_initialized=true;
  return StatusCode::SUCCESS;
}

◆ inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

◆ msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

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

                                       {
 
  StatusCode sc;
 
  if(!m_initialized) {
 
    if (m_ntpath.size()==0 || m_ntTitle.size()==0) {
      *m_log << MSG::ERROR << "Need to set variable 'm_ntpath' and 'm_ntTitle' in constructor of deriving class!" << endmsg;
      return StatusCode::FAILURE;
    }
 
    size_t i=m_ntpath.rfind('/');
    if (i==std::string::npos) {
      *m_log << MSG::ERROR << "Expected at least on '/' in path " << m_ntpath << endmsg;
      return StatusCode::FAILURE;
    }
    std::string basepath(m_ntpath.begin(),m_ntpath.begin()+i);
    //std::cout << "Basepath" << basepath << std::endl;
 
    // retrieve pointer to THistSvc
    ServiceHandle<ITHistSvc> tHistSvc("THistSvc", name());
    ATH_CHECK( tHistSvc.retrieve() );
 
    // get TTree
    sc = tHistSvc->getTree(m_ntpath,m_nt);
    if (sc.isFailure()) {
       *m_log << MSG::ERROR << "Unable to retrieve TTree : " << m_ntpath << endmsg;
       return sc;
    }
    /*
    NTupleFilePtr file1(ntupleSvc(),basepath);
    if (!file1){
      (*m_log)  << MSG::ERROR << "Could not get NTupleFilePtr with path " << basepath << " failed" << endmsg;
      return StatusCode::FAILURE;
    }
    NTuplePtr nt(ntupleSvc(),m_ntpath);
    if (!nt) {
      nt=ntupleSvc()->book(m_ntpath,CLID_ColumnWiseTuple,m_ntTitle);
    }
    if (!nt){
      (*m_log)  << MSG::ERROR << "Booking of NTuple at "<< m_ntpath << " and name " << m_ntTitle << " failed" << endmsg;
      return StatusCode::FAILURE; 
    }
    m_nt=nt;
    */ 
    //std::cout << "Ntuple ptr:" << m_nt << std::endl;
 
    // subalgorithm initialisation
    try {
      sc = this->CBNT_initialize();
    }
    catch( const std::exception& Exception ) {
      *m_log << MSG::ERROR << " Standard exception " 
                  << Exception.what() 
                  << " caught from sub-algorithm::CBNT_initialize () :" << endmsg ;
    }
    catch (...) {
              *m_log << MSG::ERROR << " Unknown exception " 
         << " caught from sub-algorithm::CBNT_initialize () :" << endmsg ;
   }
 
   if (sc.isFailure())
     {
              *m_log << MSG::ERROR << "CBNT_initialize() failed" << endmsg;
               return sc;
     }
 
    m_initialized=true;
  }
  
  // clear data members
  try {
            sc = this->CBNT_clear();
  }
  catch( const std::exception& Exception ) {
   *m_log << MSG::ERROR << " Standard exception " 
        << Exception.what() 
        << " caught from sub-algorithm::CBNT_clear () :" << endmsg ;
  }
  catch (...) {
   *m_log << MSG::ERROR << " Unknown exception " 
               << " caught from sub-algorithm::CBNT_clear () :" << endmsg ;
  }
 
  if (sc.isFailure()) {
      *m_log << MSG::ERROR << "CBNT_clear() failed" << endmsg;
       return sc;
  }
 
  return StatusCode::SUCCESS ;
}

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

  {
    h.renounce();
    PBASE::renounce (h);
  }

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

                                                          {
    handlesArray.renounce();
  }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

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

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

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

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

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:

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ signal_type_TBBPCCont

◆ StoreGateSvc_t

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ CBNTAA_TBTPValidation()

◆ ~CBNTAA_TBTPValidation()

Member Function Documentation

◆ add_name()

◆ addBranch() [1/3]

◆ addBranch() [2/3]

◆ addBranch() [3/3]

◆ CBNT_clear()

◆ CBNT_execute()

◆ CBNT_finalize()

◆ CBNT_initialize()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ pre_execute()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_adc

◆ m_angle

◆ m_beam_moment

◆ m_beam_part

◆ m_cErr

◆ m_channelID

◆ m_chi2

◆ m_chi2u

◆ m_chi2v

◆ m_clusterSize_c

◆ m_containerKey1

◆ m_containerKey10

◆ m_containerKey11

◆ m_containerKey12

◆ m_containerKey2

◆ m_containerKey3

◆ m_containerKey4

◆ m_containerKey5

◆ m_containerKey6

◆ m_containerKey7

◆ m_containerKey8

◆ m_containerKey9

◆ m_cPos

◆ m_cPosOverflow

◆ m_cryoAngle

◆ m_cryou

◆ m_cryov

◆ m_cryow

◆ m_cryoX

◆ m_detStore

◆ m_dTtoWAC

◆ m_emId

◆ m_ev_clock

◆ m_ev_number

◆ m_ev_type