CBNT_Timing Class Reference

#include <CBNT_Timing.h>

Inheritance diagram for CBNT_Timing:

Public Member Functions
	CBNT_Timing (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~CBNT_Timing ()
virtual StatusCode	CBNT_initialize () override
virtual StatusCode	CBNT_execute () override
virtual StatusCode	CBNT_finalize () override
virtual StatusCode	CBNT_clear () override
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 ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	setupLookupTables ()
	internal helpers
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
const LArOnlineID *	m_onlineHelper
double	m_energy_cut
bool	m_first_event
std::string	m_tbphase
std::vector< std::string >	m_sampling_names
std::string	m_caloCellName
std::vector< CaloSampling::CaloSample >	m_samplingIndices
	stores
std::map< CaloCell_ID::SUBCALO, std::vector< CaloSampling::CaloSample > >	m_calosAndSamplings
std::vector< HWIdentifier >	m_febIDs
std::map< int, std::string >	m_slotToFebNameLookup
std::map< CaloCell_ID::SUBCALO, std::string >	m_caloToNameLookup
std::map< std::string, CaloCell_ID::SUBCALO >	m_caloFromNameLookup
std::map< CaloSampling::CaloSample, std::string >	m_samplingToNameLookup
std::map< std::string, CaloSampling::CaloSample >	m_samplingFromNameLookup
std::map< CaloSampling::CaloSample, CaloCell_ID::SUBCALO >	m_caloLookup
std::vector< long > *	m_layer_cell
std::vector< long > *	m_eta_cell
std::vector< long > *	m_phi_cell
std::vector< long > *	m_febId_cell
std::vector< float > *	m_energy_cell
std::vector< float > *	m_time_cell
std::vector< float > *	m_time_layer
std::vector< long > *	m_layer_layer
std::vector< long > *	m_febId_feb
std::vector< float > *	m_time_feb
std::vector< long > *	m_slot_feb
std::vector< long > *	m_feedthrough_feb
float	m_energy
float	m_time
float	m_tdc_phase
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

Static Private Attributes
static const int	NOTIME = -999
static const int	NOENERGY = -999

Detailed Description

Definition at line 22 of file CBNT_Timing.h.

Member Typedef Documentation

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.

{NOT_VALID = -999};

Constructor & Destructor Documentation

CBNT_Timing()

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

Definition at line 26 of file CBNT_Timing.cxx.

  :CBNT_TBRecBase(name, pSvcLocator)
   , m_onlineHelper(0)
   , m_energy_cut(2.*GeV)
   , m_first_event(true)
   , m_caloCellName("AllCalo")
{
  m_sampling_names.resize(0);
 
  declareProperty("TBPhase",m_tbphase="TBPhase");
  declareProperty("CellContainerName",     m_caloCellName);
  declareProperty("EnergyCut", m_energy_cut);
  declareProperty("IncludedSamplings", m_sampling_names);
 
  m_energy = 0;
  m_tdc_phase = 0;
  m_time = 0;
 
  m_energy_cell = 0;
  m_eta_cell = 0;
  m_febId_cell = 0;
  m_febId_feb = 0;
  m_feedthrough_feb = 0;
  m_layer_cell = 0;
  m_layer_layer = 0;
  m_phi_cell = 0;
  m_slot_feb = 0;
  m_time_cell = 0;
  m_time_feb = 0;
  m_time_layer = 0;
}

~CBNT_Timing()

CBNT_Timing::~CBNT_Timing ( )

virtual

Definition at line 58 of file CBNT_Timing.cxx.

{//empty
}

Member Function Documentation

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 CBNT_Timing::CBNT_clear ( )

overridevirtual

Reimplemented from CBNT_TBRecBase.

Definition at line 467 of file CBNT_Timing.cxx.

                                   {
   
   if(m_layer_cell) m_layer_cell->clear();
   if(m_eta_cell) m_eta_cell->clear();
   if(m_phi_cell) m_phi_cell->clear();
   if(m_febId_cell) m_febId_cell->clear();
   if(m_energy_cell) m_energy_cell->clear();
   if(m_time_cell) m_time_cell->clear();
   if(m_time_layer) m_time_layer->clear();
   if(m_layer_layer) m_layer_layer->clear();
   if(m_febId_feb) m_febId_feb->clear();
   if(m_time_feb) m_time_feb->clear();
   if(m_slot_feb) m_slot_feb->clear();
   if(m_feedthrough_feb) m_feedthrough_feb->clear();   
   return StatusCode::SUCCESS;
}

CBNT_execute()

StatusCode CBNT_Timing::CBNT_execute ( )

overridevirtual

Reimplemented from CBNT_TBRecBase.

Definition at line 134 of file CBNT_Timing.cxx.

{
  ATH_MSG_DEBUG ( "in execute()" );
  
  // Data Access //
  
  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey};
  const LArOnOffIdMapping* cabling{*cablingHdl};
  if(!cabling) {
     ATH_MSG_ERROR( "Do not have cabling mapping from key " << m_cablingKey.key() );
     return StatusCode::FAILURE;
  }
 
  // CaloCells
  const CaloCellContainer* cellContainer = nullptr;
  ATH_CHECK( evtStore()->retrieve(cellContainer, m_caloCellName ) );
 
  // TBPhase 
  TBPhase * phase = nullptr;
  ATH_CHECK( evtStore()->retrieve(phase,m_tbphase) );
  
  m_tdc_phase = phase->getPhase();

  // First Event Action //
 
  if (m_first_event) {
 
    // find all febID's related to the requested samplings
    // loop over desired calorimeter modules first, more efficient this way
    for (const auto& p : m_calosAndSamplings) {
      CaloCell_ID::SUBCALO idCalo = p.first;
      std::vector<CaloSampling::CaloSample> samplingV = p.second;
 
      // loop over the corresponding CaloCell's
      for (CaloCellContainer::const_iterator cell = cellContainer->beginConstCalo(idCalo);
           cell != cellContainer->endConstCalo(idCalo); ++cell) {
 
        // get the corresponding sample
        CaloSampling::CaloSample idSample;
        const CaloDetDescrElement * theCaloDDE= (*cell)->caloDDE();
        if (theCaloDDE) {
              idSample = (CaloSampling::CaloSample) theCaloDDE->getSampling();
        }else{
              idSample =  CaloSampling::Unknown;
        } 
 
        // only consider CaloCell's in the requested sampling
        if (find(samplingV.begin(), samplingV.end(), idSample) != samplingV.end()) {
          
          // here you have the CaloCell with idCalo, idSample, **cell
          // find the hardware ID and the corresponding febID
 
          HWIdentifier id = cabling->createSignalChannelID((*cell)->ID());
          HWIdentifier febID = m_onlineHelper->feb_Id(id);
 
          // store it if you don't have it already
          if (find(m_febIDs.begin(), m_febIDs.end(), febID) == m_febIDs.end()) m_febIDs.push_back(febID);
 
        }
      }
    }
    // print out
    msg() << MSG::INFO << "FEB IDs: ";
    for (HWIdentifier febID : m_febIDs) {
      std::ostringstream os; 
      os << std::hex << febID;
      msg() << MSG::INFO << " \042" << os.str() << "\042";
    }
    msg() << MSG::INFO << endmsg;
 
    m_first_event = false;
  }
 

  // sampling timing distributions //
 
  // energy weighted time stores
  std::map<CaloSampling::CaloSample, double> sumEPerSampling, sumETimePerSampling;  // sampling id keyed
  std::map<HWIdentifier, double>             sumEPerFeb,      sumETimePerFeb;       // febID keyed
  double sumETotal = 0, sumETimeTotal = 0;
  bool eSet = false;
 
  // fill energy weighted time stores
  // loop over desired calorimeter modules first, more efficient this way
  m_energy = 0;
 
  for (const auto& p : m_calosAndSamplings) {
    CaloCell_ID::SUBCALO idCalo = p.first;
    ATH_MSG_DEBUG
      ( "Looping over CaloCells of calorimeter : \042"
        << m_caloToNameLookup[idCalo]
        << "\042" );
    std::vector<CaloSampling::CaloSample> samplingV = p.second;
 
    // loop over the corresponding CaloCell's
    for (CaloCellContainer::const_iterator cell = cellContainer->beginConstCalo(idCalo);
         cell != cellContainer->endConstCalo(idCalo); ++cell) {
 
      // get the corresponding sample
      //CaloSampling::CaloSample idSample = CaloSampling::getSampling(**cell);
      CaloSampling::CaloSample idSample;
      const CaloDetDescrElement * theCaloDDE= (*cell)->caloDDE();
      if (theCaloDDE) {
            idSample = (CaloSampling::CaloSample) theCaloDDE->getSampling();
      }else{
            idSample =  CaloSampling::Unknown;
      } 
 
      // only consider CaloCell's in the requested sampling
      if (find(samplingV.begin(), samplingV.end(), idSample) != samplingV.end()) {
 
        // here you have the CaloCell with idCalo, idSample, **cell
        // find the hardware ID and the corresponding febID
 
        HWIdentifier id = cabling->createSignalChannelID((*cell)->ID());
        HWIdentifier febID = m_onlineHelper->feb_Id(id);
       
        // gather sums for energy weighted cubic peaking time
        // select cells for which the cubic interpolation was successfully applied
        // *** for now, this is done by requiring that time(ns) is not too close to 25ns * n
        // *** but it should be done using the CaloCell quality, when available...
        // select cells above an energy threshold
 
        double energy = (*cell)->e();
        double time = (*cell)->time();
        if (fabs(time/ns - float(int(time/(25*ns))*25.)) > 0.001 && energy > m_energy_cut) {
      
      m_time_cell->push_back(time/ns);
      m_energy_cell->push_back(energy/GeV);   
      m_energy += energy/GeV;
 
          sumEPerSampling[idSample] += energy;
          sumETimePerSampling[idSample] += energy * time;
 
          sumEPerFeb[febID] += energy; 
          sumETimePerFeb[febID] += energy * time;
 
      sumETotal += energy;
      sumETimeTotal += energy * time;
      eSet = true;
 
      ATH_MSG_DEBUG
            ( "cell time = " << time/ns << " ns"
              << "; energy = " << energy/GeV << " GeV" );
 
    } else {
      // below energy cut
      m_time_cell->push_back(NOTIME);
      m_energy_cell->push_back(NOENERGY);
    }
    
    m_febId_cell->push_back(febID.get_identifier32().get_compact());
    //try {
    //const Identifier ident = cabling->cnvToIdentifier(id);
    if ( m_emId->is_lar_em((*cell)->ID()) ) { 
      m_eta_cell->push_back(m_emId->eta((*cell)->ID()));
      m_phi_cell->push_back(m_emId->phi((*cell)->ID()));
      m_layer_cell->push_back(m_emId->sampling((*cell)->ID()));
    } else {
      m_eta_cell->push_back(0);
      m_phi_cell->push_back(0);
      m_layer_cell->push_back(0);
    }
    //}
    /*catch (LArID_Exception & except) {
      m_eta_cell->push_back(-999);
      m_phi_cell->push_back(-999);
      m_layer_cell->push_back(-999);
      }*/
 
      }
    }
  }
 
  // fill energy weighted cubic peaking time for each requested sampling
  for (CaloSampling::CaloSample idSample : m_samplingIndices) {
    // go on only if there is data stored for this sample:
    //if (sumEPerSampling.find(idSample) != sumEPerSampling.end()) {
      double peakTime = (sumEPerSampling[idSample] > 0.) ? sumETimePerSampling[idSample]/sumEPerSampling[idSample] : NOTIME;
      m_time_layer->push_back(peakTime/ns);
      m_layer_layer->push_back(idSample);
      //}
  }
 
  // fill energy weighted cubic peaking time for each requested FEB
  for (HWIdentifier febID : m_febIDs) {
    // go on only if there is data stored for this febID
    //if (sumEPerFeb.find(febID) != sumEPerFeb.end()) {
      double peakTime = (sumEPerFeb[febID] > 0.) ? sumETimePerFeb[febID]/sumEPerFeb[febID] : NOTIME;
      m_time_feb->push_back(peakTime/ns);
      m_febId_feb->push_back(febID.get_identifier32().get_compact());
      m_slot_feb->push_back(m_onlineHelper->slot(febID));
      m_feedthrough_feb->push_back(m_onlineHelper->feedthrough(febID));
      //}
  }
 
  // fill energy weighted cubic peaking time for everything
  if (eSet) {
    m_time = (sumETotal > 0.) ? sumETimeTotal/sumETotal : 0.;
  }
 
  //if (m_Ncells > 0) std::cout << "#cells: " << m_Ncells << std::endl;
  return StatusCode::SUCCESS;
}

CBNT_finalize()

StatusCode CBNT_Timing::CBNT_finalize ( )

overridevirtual

Reimplemented from CBNT_TBRecBase.

Definition at line 349 of file CBNT_Timing.cxx.

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

CBNT_initialize()

StatusCode CBNT_Timing::CBNT_initialize ( )

overridevirtual

Reimplemented from CBNT_TBRecBase.

Definition at line 62 of file CBNT_Timing.cxx.

                                        {
 
  ATH_MSG_DEBUG  ( "CBNT_Timing in initialize()" );
 
  ATH_CHECK( m_cablingKey.initialize() );
  ATH_CHECK( detStore()->retrieve(m_onlineHelper, "LArOnlineID") );
 
    addBranch ("TDC_TimeCell",m_time_cell);
    addBranch ("TDC_EnergyCell",m_energy_cell);
    addBranch ("TDC_LayerCell",m_layer_cell);
    addBranch ("TDC_EtaCell", m_eta_cell);
    addBranch ("TDC_PhiCell", m_phi_cell);
    addBranch ("TDC_FebIDCell", m_febId_cell);
    addBranch ("TDC_TimeLayer",m_time_layer);
    addBranch ("TDC_LayerIDLayer",m_layer_layer);
    addBranch ("TDC_TimeFeb",m_time_feb);
    addBranch ("TDC_FebIdFeb",m_febId_feb);
    addBranch ("TDC_SlotFeb", m_slot_feb);
    addBranch ("TDC_FeedthroughFeb", m_feedthrough_feb);
    addBranch ("TDC_Phase",m_tdc_phase, "Phase/F");
    addBranch ("TDC_TimeTotal",m_time, "TimeTotal/F");
    addBranch ("TDC_EnergyTotal",m_energy, "EnergyTotal/F");
 
 
 
  
  // setup calorimeter module and sampling lookup tables
  ATH_CHECK( this->setupLookupTables() );
 
  // get calorimeter samplings ids for the requested samplings
  msg() << MSG::INFO << "Included calorimeter samplings: ";
  for (const std::string& sampling : m_sampling_names) {
    CaloSampling::CaloSample idSamp = m_samplingFromNameLookup[sampling];
    if (idSamp != CaloSampling::Unknown) {
      m_samplingIndices.push_back(idSamp);
      msg() << MSG::INFO << "\042" << sampling
             << "\042 ";
    }
  }
  msg() << MSG::INFO << endmsg;
 
  // get an idCalo keyed map of vectors of idSample for the requested samplings
  for (CaloSampling::CaloSample idSample : m_samplingIndices) {
    // find the idCalo 
    CaloCell_ID::SUBCALO idCalo = m_caloLookup[idSample];
    // build the vector of idSample
    std::vector<CaloSampling::CaloSample> samplingV = m_calosAndSamplings[idCalo];
    samplingV.push_back(idSample);
    m_calosAndSamplings[idCalo] = std::move(samplingV);
  }
  // printout
  for (const auto& p : m_calosAndSamplings) {
    CaloCell_ID::SUBCALO idCalo = p.first;
    msg() << MSG::INFO
           << "Included calorimeter : \042"
           << m_caloToNameLookup[idCalo]
           << "\042 samplings:";
    const std::vector<CaloSampling::CaloSample>& samplingV = p.second;
    for (CaloSampling::CaloSample sample : samplingV) {
      msg() << MSG::INFO
             << " \042"
             << m_samplingToNameLookup[sample]
             << "\042";
    }
    msg()  << MSG::INFO << endmsg;
  }
 
  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.

{ return m_detStore; }

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.

{ return m_evtStore; }

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();
  }

setupLookupTables()

StatusCode CBNT_Timing::setupLookupTables ( )

private

internal helpers

Definition at line 356 of file CBNT_Timing.cxx.

                                          {
 
  // fill slot and febName lookup table for EM barrel online
  m_slotToFebNameLookup[1]="Presampler";
  m_slotToFebNameLookup[2]="Front 0";
  m_slotToFebNameLookup[3]="Front 1";
  m_slotToFebNameLookup[4]="Front 2";
  m_slotToFebNameLookup[5]="Front 3";
  m_slotToFebNameLookup[6]="Front 4";
  m_slotToFebNameLookup[7]="Front 5";
  m_slotToFebNameLookup[8]="Front 6";
  m_slotToFebNameLookup[9]="Back 0";
  m_slotToFebNameLookup[10]="Back 1";
  m_slotToFebNameLookup[11]="Middle 0";
  m_slotToFebNameLookup[12]="Middle 1";
  m_slotToFebNameLookup[13]="Middle 2";
  m_slotToFebNameLookup[14]="Middle 3";
 
  // fill calo names lookup tables
  m_caloToNameLookup[CaloCell_ID::LAREM]   = "LAREM";
  m_caloToNameLookup[CaloCell_ID::LARHEC]  = "LARHEC";
  m_caloToNameLookup[CaloCell_ID::LARFCAL] = "LARFCAL";
  m_caloToNameLookup[CaloCell_ID::TILE]    = "TILE";
 
  m_caloFromNameLookup["LAREM"]   = CaloCell_ID::LAREM;
  m_caloFromNameLookup["LARHEC"]  = CaloCell_ID::LARHEC;
  m_caloFromNameLookup["LARFCAL"] = CaloCell_ID::LARFCAL;
  m_caloFromNameLookup["TILE"]    = CaloCell_ID::TILE;
 
  // fill sampling names lookup table
  m_samplingToNameLookup[CaloSampling::PreSamplerB] = "PreSamplerB";  // electromagnetic barrel
  m_samplingToNameLookup[CaloSampling::EMB1]        = "EMB1";        
  m_samplingToNameLookup[CaloSampling::EMB2]        = "EMB2";        
  m_samplingToNameLookup[CaloSampling::EMB3]        = "EMB3";        
  m_samplingToNameLookup[CaloSampling::PreSamplerE] = "PreSamplerE";  // electromagnetic endcap
  m_samplingToNameLookup[CaloSampling::EME1]        = "EME1";        
  m_samplingToNameLookup[CaloSampling::EME2]        = "EME2";        
  m_samplingToNameLookup[CaloSampling::EME3]        = "EME3";        
  m_samplingToNameLookup[CaloSampling::HEC0]        = "HEC0";         // hadronic endcap
  m_samplingToNameLookup[CaloSampling::HEC1]        = "HEC1";        
  m_samplingToNameLookup[CaloSampling::HEC2]        = "HEC2";        
  m_samplingToNameLookup[CaloSampling::HEC3]        = "HEC3";        
  m_samplingToNameLookup[CaloSampling::TileBar0]    = "TileBar0";     // tile barrel
  m_samplingToNameLookup[CaloSampling::TileBar1]    = "TileBar1";    
  m_samplingToNameLookup[CaloSampling::TileBar2]    = "TileBar2";    
  m_samplingToNameLookup[CaloSampling::TileGap1]    = "TileGap1";     // tile gap scintillators
  m_samplingToNameLookup[CaloSampling::TileGap2]    = "TileGap2";    
  m_samplingToNameLookup[CaloSampling::TileGap3]    = "TileGap3";    
  m_samplingToNameLookup[CaloSampling::TileExt0]    = "TileExt0";     // tile extended barrel
  m_samplingToNameLookup[CaloSampling::TileExt1]    = "TileExt1";    
  m_samplingToNameLookup[CaloSampling::TileExt2]    = "TileExt2";    
  m_samplingToNameLookup[CaloSampling::FCAL0]       = "FCal1";        // fcal
  m_samplingToNameLookup[CaloSampling::FCAL1]       = "FCal2";       
  m_samplingToNameLookup[CaloSampling::FCAL2]       = "FCal3";       
  m_samplingToNameLookup[CaloSampling::Unknown]     = "unknown";
 
  m_samplingFromNameLookup["PreSamplerB"] = CaloSampling::PreSamplerB; // electromagnetic barrel
  m_samplingFromNameLookup["EMB1"]        = CaloSampling::EMB1;       
  m_samplingFromNameLookup["EMB2"]        = CaloSampling::EMB2;       
  m_samplingFromNameLookup["EMB3"]        = CaloSampling::EMB3;       
  m_samplingFromNameLookup["PreSamplerE"] = CaloSampling::PreSamplerE; // electromagnetic endcap
  m_samplingFromNameLookup["EME1"]        = CaloSampling::EME1;       
  m_samplingFromNameLookup["EME2"]        = CaloSampling::EME2;       
  m_samplingFromNameLookup["EME3"]        = CaloSampling::EME3;       
  m_samplingFromNameLookup["HEC0"]        = CaloSampling::HEC0;        // hadronic endcap
  m_samplingFromNameLookup["HEC1"]        = CaloSampling::HEC1;       
  m_samplingFromNameLookup["HEC2"]        = CaloSampling::HEC2;       
  m_samplingFromNameLookup["HEC3"]        = CaloSampling::HEC3;       
  m_samplingFromNameLookup["TileBar0"]    = CaloSampling::TileBar0;    // tile barrel
  m_samplingFromNameLookup["TileBar1"]    = CaloSampling::TileBar1;   
  m_samplingFromNameLookup["TileBar2"]    = CaloSampling::TileBar2;   
  m_samplingFromNameLookup["TileGap1"]    = CaloSampling::TileGap1;    // tile gap scintillators
  m_samplingFromNameLookup["TileGap2"]    = CaloSampling::TileGap2;   
  m_samplingFromNameLookup["TileGap3"]    = CaloSampling::TileGap3;   
  m_samplingFromNameLookup["TileExt0"]    = CaloSampling::TileExt0;    // tile extended barrel
  m_samplingFromNameLookup["TileExt1"]    = CaloSampling::TileExt1;   
  m_samplingFromNameLookup["TileExt2"]    = CaloSampling::TileExt2;   
  m_samplingFromNameLookup["FCal1"]       = CaloSampling::FCAL0;       // fcal
  m_samplingFromNameLookup["FCal2"]       = CaloSampling::FCAL1;      
  m_samplingFromNameLookup["FCal3"]       = CaloSampling::FCAL2;      
  m_samplingFromNameLookup["unknown"]     = CaloSampling::Unknown;     
 
  // fill calo lookup table
  m_caloLookup[CaloSampling::PreSamplerB] = CaloCell_ID::LAREM;
  m_caloLookup[CaloSampling::EMB1]        = CaloCell_ID::LAREM;
  m_caloLookup[CaloSampling::EMB2]        = CaloCell_ID::LAREM; 
  m_caloLookup[CaloSampling::EMB3]        = CaloCell_ID::LAREM; 
  m_caloLookup[CaloSampling::PreSamplerE] = CaloCell_ID::LAREM; 
  m_caloLookup[CaloSampling::EME1]        = CaloCell_ID::LAREM; 
  m_caloLookup[CaloSampling::EME2]        = CaloCell_ID::LAREM; 
  m_caloLookup[CaloSampling::EME3]        = CaloCell_ID::LAREM; 
  m_caloLookup[CaloSampling::HEC0]        = CaloCell_ID::LARHEC; 
  m_caloLookup[CaloSampling::HEC1]        = CaloCell_ID::LARHEC;  
  m_caloLookup[CaloSampling::HEC2]        = CaloCell_ID::LARHEC;  
  m_caloLookup[CaloSampling::HEC3]        = CaloCell_ID::LARHEC;  
  m_caloLookup[CaloSampling::TileBar0]    = CaloCell_ID::TILE;  
  m_caloLookup[CaloSampling::TileBar1]    = CaloCell_ID::TILE;   
  m_caloLookup[CaloSampling::TileBar2]    = CaloCell_ID::TILE;   
  m_caloLookup[CaloSampling::TileGap1]    = CaloCell_ID::TILE;   
  m_caloLookup[CaloSampling::TileGap2]    = CaloCell_ID::TILE;   
  m_caloLookup[CaloSampling::TileGap3]    = CaloCell_ID::TILE;    
  m_caloLookup[CaloSampling::TileExt0]    = CaloCell_ID::TILE;   
  m_caloLookup[CaloSampling::TileExt1]    = CaloCell_ID::TILE;    
  m_caloLookup[CaloSampling::TileExt2]    = CaloCell_ID::TILE;    
  m_caloLookup[CaloSampling::FCAL0]       = CaloCell_ID::LARFCAL; 
  m_caloLookup[CaloSampling::FCAL1]       = CaloCell_ID::LARFCAL;  
  m_caloLookup[CaloSampling::FCAL2]       = CaloCell_ID::LARFCAL;  
 
  return StatusCode::SUCCESS;
}

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_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> CBNT_Timing::m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}

private

Definition at line 39 of file CBNT_Timing.h.

{this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"};

m_caloCellName

std::string CBNT_Timing::m_caloCellName

private

Definition at line 47 of file CBNT_Timing.h.

m_caloFromNameLookup

std::map<std::string, CaloCell_ID::SUBCALO> CBNT_Timing::m_caloFromNameLookup

private

Definition at line 59 of file CBNT_Timing.h.

m_caloLookup

std::map<CaloSampling::CaloSample, CaloCell_ID::SUBCALO> CBNT_Timing::m_caloLookup

private

Definition at line 62 of file CBNT_Timing.h.

m_calosAndSamplings

std::map< CaloCell_ID::SUBCALO, std::vector<CaloSampling::CaloSample> > CBNT_Timing::m_calosAndSamplings

private

Definition at line 52 of file CBNT_Timing.h.

m_caloToNameLookup

std::map<CaloCell_ID::SUBCALO, std::string> CBNT_Timing::m_caloToNameLookup

private

Definition at line 58 of file CBNT_Timing.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_emId

const LArEM_ID* CBNT_TBRecBase::m_emId

protectedinherited

Definition at line 65 of file CBNT_TBRecBase.h.

m_energy

float CBNT_Timing::m_energy

private

Definition at line 79 of file CBNT_Timing.h.

m_energy_cell

std::vector<float>* CBNT_Timing::m_energy_cell

private

Definition at line 67 of file CBNT_Timing.h.

m_energy_cut

double CBNT_Timing::m_energy_cut

private

Definition at line 42 of file CBNT_Timing.h.

m_eta_cell

std::vector<long> * CBNT_Timing::m_eta_cell

private

Definition at line 66 of file CBNT_Timing.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_febId_cell

std::vector<long> * CBNT_Timing::m_febId_cell

private

Definition at line 66 of file CBNT_Timing.h.

m_febId_feb

std::vector<long>* CBNT_Timing::m_febId_feb

private

Definition at line 73 of file CBNT_Timing.h.

m_febIDs

std::vector<HWIdentifier> CBNT_Timing::m_febIDs

private

Definition at line 53 of file CBNT_Timing.h.

m_feedthrough_feb

std::vector<long>* CBNT_Timing::m_feedthrough_feb

private

Definition at line 76 of file CBNT_Timing.h.

m_first_event

bool CBNT_Timing::m_first_event

private

Definition at line 43 of file CBNT_Timing.h.

m_hecId

const LArHEC_ID* CBNT_TBRecBase::m_hecId

protectedinherited

Definition at line 66 of file CBNT_TBRecBase.h.

m_initialized

bool CBNT_TBRecBase::m_initialized

privateinherited

Definition at line 40 of file CBNT_TBRecBase.h.

m_layer_cell

std::vector<long>* CBNT_Timing::m_layer_cell

private

Definition at line 66 of file CBNT_Timing.h.

m_layer_layer

std::vector<long>* CBNT_Timing::m_layer_layer

private

Definition at line 70 of file CBNT_Timing.h.

m_log

MsgStream* CBNT_TBRecBase::m_log

protectedinherited

Definition at line 63 of file CBNT_TBRecBase.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_onlineHelper

const LArOnlineID* CBNT_Timing::m_onlineHelper

private

Definition at line 40 of file CBNT_Timing.h.

m_onlineId

const LArOnlineID* CBNT_TBRecBase::m_onlineId

protectedinherited

Definition at line 68 of file CBNT_TBRecBase.h.

m_phi_cell

std::vector<long> * CBNT_Timing::m_phi_cell

private

Definition at line 66 of file CBNT_Timing.h.

m_sampling_names

std::vector<std::string> CBNT_Timing::m_sampling_names

private

Definition at line 46 of file CBNT_Timing.h.

m_samplingFromNameLookup

std::map<std::string, CaloSampling::CaloSample> CBNT_Timing::m_samplingFromNameLookup

private

Definition at line 61 of file CBNT_Timing.h.

m_samplingIndices

std::vector<CaloSampling::CaloSample> CBNT_Timing::m_samplingIndices

private

stores

Definition at line 51 of file CBNT_Timing.h.

m_samplingToNameLookup

std::map<CaloSampling::CaloSample, std::string> CBNT_Timing::m_samplingToNameLookup

private

Definition at line 60 of file CBNT_Timing.h.

m_slot_feb

std::vector<long>* CBNT_Timing::m_slot_feb

private

Definition at line 75 of file CBNT_Timing.h.

m_slotToFebNameLookup

std::map<int, std::string> CBNT_Timing::m_slotToFebNameLookup

private

Definition at line 57 of file CBNT_Timing.h.

m_tbphase

std::string CBNT_Timing::m_tbphase

private

Definition at line 45 of file CBNT_Timing.h.

m_tdc_phase

float CBNT_Timing::m_tdc_phase

private

Definition at line 79 of file CBNT_Timing.h.

m_time

float CBNT_Timing::m_time

private

Definition at line 79 of file CBNT_Timing.h.

m_time_cell

std::vector<float> * CBNT_Timing::m_time_cell

private

Definition at line 67 of file CBNT_Timing.h.

m_time_feb

std::vector<float>* CBNT_Timing::m_time_feb

private

Definition at line 74 of file CBNT_Timing.h.

m_time_layer

std::vector<float>* CBNT_Timing::m_time_layer

private

Definition at line 69 of file CBNT_Timing.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.

NOENERGY

const int CBNT_Timing::NOENERGY = -999

staticprivate

Definition at line 37 of file CBNT_Timing.h.

NOTIME

const int CBNT_Timing::NOTIME = -999

staticprivate

Definition at line 36 of file CBNT_Timing.h.

---

The documentation for this class was generated from the following files:

• CBNT_Timing.h
• CBNT_Timing.cxx