TBPhaseRec Class Reference

reconstruction of a suitable event phase More...

#include <TBPhaseRec.h>

Inheritance diagram for TBPhaseRec:

Collaboration diagram for TBPhaseRec:

Public Member Functions
	TBPhaseRec (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~TBPhaseRec ()
virtual StatusCode	initialize () override
virtual StatusCode	execute () override
virtual StatusCode	finalize () override
StatusCode	getnewcalib ()
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

Static Public Attributes
static const int	unknown = -99999

Protected Member Functions
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
float	computePhase (int tdcIndex)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
std::vector< std::string >	m_tdcNames
std::vector< float >	m_tdcToTime
std::vector< float >	m_tdcwac
std::vector< float >	m_tdcMin
float	m_delta
int	m_timeBins
std::string	m_TBPhaseKey
bool	m_neverReturnFailure
std::string	m_calib_filename
unsigned int	m_runnumber
float	m_guardValue
int	m_nTDC
std::vector< int >	m_tdcRaw
std::vector< float >	m_phaseReco
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

reconstruction of a suitable event phase

Author

Michel Lefebvre lefeb.nosp@m.vre@.nosp@m.uvic..nosp@m.ca

Date

August 13, 2004

June 30, 2004 - implementation based on a first draft from Marco Delmastro

Definition at line 21 of file TBPhaseRec.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

TBPhaseRec()

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

Definition at line 24 of file TBPhaseRec.cxx.

                                           :
  AthAlgorithm(name,pSvcLocator)
  , m_delta(25.0*ns)
  , m_timeBins(25)
  , m_TBPhaseKey("TBPhase")
  , m_neverReturnFailure(false)
  , m_guardValue(-1.) // in TDC counts
  , m_nTDC(0)
 {
  // job options
   declareProperty("CalibFileName",m_calib_filename="");
   m_tdcNames.resize(0);
   m_tdcToTime.resize(0);
   m_tdcwac.resize(0);
   m_tdcMin.resize(0);
   declareProperty("TDCNames",           m_tdcNames);
   declareProperty("TDCToTime",          m_tdcToTime);
   declareProperty("TDCwac",             m_tdcwac);
   declareProperty("TDCMin",             m_tdcMin);
   declareProperty("TTCClockPeriod",     m_delta);
   declareProperty("TimeBins",           m_timeBins);
   declareProperty("TBPhaseKey",         m_TBPhaseKey);
   declareProperty("NeverReturnFailure", m_neverReturnFailure);  
   declareProperty("GuardCutValue",      m_guardValue);
   m_runnumber = 0;
}

~TBPhaseRec()

TBPhaseRec::~TBPhaseRec ( )

virtual

Definition at line 52 of file TBPhaseRec.cxx.

{ }

Member Function Documentation

computePhase()

float TBPhaseRec::computePhase ( int tdcIndex )

private

Definition at line 349 of file TBPhaseRec.cxx.

                                           {
 
   float phaseReco = m_tdcToTime[tdcIndex] * ((float)m_tdcRaw[tdcIndex] - m_tdcwac[tdcIndex]);
   if (m_tdcToTime[tdcIndex] > 0.) {
     if ((float)m_tdcRaw[tdcIndex] < m_tdcwac[tdcIndex]) phaseReco += m_delta;
   } else {
     if ((float)m_tdcRaw[tdcIndex] > m_tdcwac[tdcIndex]) phaseReco += m_delta;
   }
 
   return phaseReco ;
}

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 TBPhaseRec::execute ( )

overridevirtual

Definition at line 130 of file TBPhaseRec.cxx.

{
  ATH_MSG_VERBOSE ( "In execute()" );
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  // Get run number...
  unsigned int thisrun=ctx.eventID().run_number();
  
  // ... and get new calib constants (only if calibration constant file has been specified!)
  if( thisrun != m_runnumber && m_calib_filename != "" ) {
     m_runnumber= thisrun;
     if ( getnewcalib() == StatusCode::FAILURE ) {
        setFilterPassed(false);
        return StatusCode::SUCCESS;
     }
  }
  
  TBTDCRawCont * tdcRawCont = nullptr;
  StatusCode sc = evtStore()->retrieve(tdcRawCont, "TDCRawCont");
  if (sc.isFailure()) {
    ATH_MSG_ERROR ( "TBObjectReco: Retrieval of TDCRawCont failed" );
    if (!m_neverReturnFailure) {
       setFilterPassed(false);
    }
    return StatusCode::SUCCESS;
  }
 
  std::vector<float> tdcQuality;
  std::vector<float> tdcdTtoWAC;
  tdcQuality.resize(m_nTDC);
  tdcdTtoWAC.resize(m_nTDC);
  for (int k = 0; k < m_nTDC; k++) {
    m_phaseReco[k] = unknown;
    m_tdcRaw[k]    = 0;
    tdcQuality[k]  = 0.;
    tdcdTtoWAC[k]  = 0.;
  }
  
  // Loop over TDC's
  int tdcFound = 0;
  int tdcFoundAndOK = 0;
  for (const TBTDCRaw* tdcRaw : *tdcRawCont) {
    std::string tdcName = tdcRaw->getDetectorName();
    int tdcIndex = 0;
    for (; tdcIndex < m_nTDC; tdcIndex++) {
      if (tdcName == m_tdcNames[tdcIndex]) break;
    }
    if (tdcIndex < m_nTDC) {  // found the sought tdc
      tdcFound++;
 
      // get the raw tdc value
      m_tdcRaw[tdcIndex] = tdcRaw->getTDC();
      
      if (m_tdcRaw[tdcIndex] <= 0 || tdcRaw->isOverflow() || tdcRaw->isUnderThreshold()) {
        // bad tdc
        if (m_tdcRaw[tdcIndex] <= 0) 
          ATH_MSG_DEBUG ( "Bad TDC" << tdcIndex << "; value = " << m_tdcRaw[tdcIndex] );
        if (tdcRaw->isOverflow()) 
          ATH_MSG_DEBUG ( "Bad TDC" << tdcIndex << " is overflow" );
        if (tdcRaw->isUnderThreshold()) 
          ATH_MSG_DEBUG ( "Bad TDC" << tdcIndex << " is underthreshold" );
      } else {  
        // found andvalid tdc 
        tdcFoundAndOK++;
 
        // compute a quality factor used to decide which tdc to  use for the phase
        // lowest distance (tdc units) to tdcMin or tdcMax or tdcwac
        
        float dTotdcMin = fabs(m_tdcRaw[tdcIndex] - m_tdcMin[tdcIndex]);
        float tdcMax = m_tdcMin[tdcIndex] + m_delta/fabs(m_tdcToTime[tdcIndex]);
        float dTotdcMax = fabs(m_tdcRaw[tdcIndex] - tdcMax);
        float dTotdcwac = fabs(m_tdcRaw[tdcIndex] - m_tdcwac[tdcIndex]);
        float dtemp = (dTotdcMin < dTotdcMax) ? dTotdcMin : dTotdcMax;
        tdcQuality[tdcIndex] = (dtemp < dTotdcwac) ? dtemp : dTotdcwac;
        tdcdTtoWAC[tdcIndex] = m_tdcRaw[tdcIndex] - m_tdcwac[tdcIndex];
        
        ATH_MSG_DEBUG
          ( "TDC" << tdcIndex << " value = " << m_tdcRaw[tdcIndex]
            << "; tdc quality"
            << ": to tdcMin = " << dTotdcMin
            << "; to tdcMax = " << dTotdcMax
            << "; to tdcwac = " << dTotdcwac
            << "; final = " << tdcQuality[tdcIndex] );
        
        // compute the phase
        m_phaseReco[tdcIndex] = computePhase(tdcIndex);
 
        ATH_MSG_DEBUG
          ( "TDC" << tdcIndex << " value = " << m_tdcRaw[tdcIndex]
            << "; reconstructed phase = " << m_phaseReco[tdcIndex]/ns << " ns"
            );
      }
 
      if (tdcFound == m_nTDC) break ; // exit container loop if all TDCs found
    }
  }
  
  if (tdcFound == 0 || tdcFoundAndOK == 0) {
    // Check if this is a random trigger and set tdc=12.5 ns
    // retrieve Event Info
    const TBEventInfo* theEventInfo;
    StatusCode checkOut = evtStore()->retrieve(theEventInfo,"TBEventInfo");
    if ( checkOut.isFailure() )
      {
    ATH_MSG_ERROR ( "cannot retrieve TBEventInfo from StoreGate" );
        setFilterPassed(false);
    return StatusCode::SUCCESS;
      }
    else
      {
    ATH_MSG_DEBUG ( "TBEventInfo object found in TDS" );
      }
    int evtType = theEventInfo->getEventType();
    ATH_MSG_DEBUG ( "Event Type found " << evtType );
    if (evtType != 1) {    // Not a physics trigger found
      float phase = 12.5;
      short phaseInd = (short)floor(phase/m_delta * (float)m_timeBins);
      float tdc_to_wac = 100.;
      TBPhase* theTBPhase = new TBPhase(phase, phaseInd, tdc_to_wac);
      sc = evtStore()->record(theTBPhase, m_TBPhaseKey);
      if (sc.isFailure( )) {
    ATH_MSG_FATAL ( "Cannot record TBPhase" );
        setFilterPassed(false); // always return failure for this one!
        return StatusCode::SUCCESS;
      }
      return StatusCode::SUCCESS;
    }
    if (tdcFound == 0) {
      ATH_MSG_ERROR ( "no TDCs found in StoreGate" );
    } else {
      ATH_MSG_ERROR ( "no valid TDC data found" );
    }
    if (!m_neverReturnFailure) {
       setFilterPassed(false);
    }
    return StatusCode::SUCCESS;
  }
  if (tdcFound < m_nTDC || tdcFoundAndOK < m_nTDC) {
    if (tdcFound < m_nTDC) {
      ATH_MSG_WARNING ( "not all the requested TDCs were found in StoreGate" );
    } else {
      ATH_MSG_WARNING ( "not all the requested TDCs contained valid data" );
    }
  }
  
  // choose/compute best phase, compute corresponding best phaseind, create TBPhase instance
  int tdcBestIndex = 0;
  float QMax = 0.;
  for (int k = 0; k < m_nTDC; k++) {
    if (tdcQuality[k] > QMax) {
      QMax = tdcQuality[k];
      tdcBestIndex = k;
    }
  }
  float bestPhase = m_phaseReco[tdcBestIndex];
 
  ATH_MSG_DEBUG
    ( "best quality for TDC" << tdcBestIndex
      << ", with reconstructed phase = " << bestPhase/ns << " ns" );
 
  // If the tdc is working properly and if the TBPhaseRec jobOptions correctly calibrate the tdc,
  // then this timeSampleShift should be zero always.
  int timeSampleShift = (int)floor(bestPhase/m_delta);
  if (timeSampleShift != 0) {
    ATH_MSG_WARNING
      ( "TBPhaseRec time sample shift non zero: " << timeSampleShift );
  }
  
  // the phase is between 0 and the ttcClockPeriod
  float phase = bestPhase - timeSampleShift*m_delta;  // "wrapped around" phase in case of shift
 
  // the phase index must be between 0 and m_timeBins-1
  short phaseInd = (short)floor(phase/m_delta * (float)m_timeBins);
  if (phaseInd < 0 || phaseInd > m_timeBins - 1) {
    ATH_MSG_ERROR
      ( "Phase " << phase/ns << " ns "
        << "has phase index " << phaseInd 
        << " outside of the bounds [0," << m_timeBins-1 << "]" );
    if (!m_neverReturnFailure) {
       setFilterPassed(false);
    }
    return StatusCode::SUCCESS;
  }
 
  // guard region cut
  if ( m_guardValue > 0. && fabs(tdcdTtoWAC[tdcBestIndex]) < m_guardValue ) {
    ATH_MSG_ERROR
      ( "Phase " << phase/ns << " ns "
        << "has TDC-WAC " << tdcdTtoWAC[tdcBestIndex]
        << " inside the guard region [0," << m_guardValue  << "]" );
    if (!m_neverReturnFailure) {
       setFilterPassed(false);
    }
    return StatusCode::SUCCESS;
  } 
 
  ATH_MSG_DEBUG
    ( "Phase = " << phase/ns << " ns; "
      << "phase index = " << phaseInd );
 
  // create and store the TBPhase
  // TBPhase* theTBPhase = new TBPhase(phase, phaseInd);
  TBPhase* theTBPhase = new TBPhase(phase, phaseInd, tdcdTtoWAC[tdcBestIndex] );
  
  sc = evtStore()->record(theTBPhase, m_TBPhaseKey);
  if (sc.isFailure( )) {
    ATH_MSG_FATAL ( "Cannot record TBPhase" );
    setFilterPassed(false);  // always return failure for this one!
    return StatusCode::SUCCESS;
  }
  
  return StatusCode::SUCCESS;
  
}

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 TBPhaseRec::finalize ( )

overridevirtual

Definition at line 345 of file TBPhaseRec.cxx.

                                {
  return StatusCode::SUCCESS;
}

getnewcalib()

StatusCode TBPhaseRec::getnewcalib

(

)

Definition at line 363 of file TBPhaseRec.cxx.

                                   {
  //
  // Get calib constant from an ASCII file with the following structure :
  // 
  // runnumber
  // tdcnumber TDCToTime TDCwac TDCMin
  // ...
 
  ATH_MSG_INFO ( "Get TDC calibration constants for run " << m_runnumber);
  
  int tdcnumber= m_tdcNames.size();
 
  m_tdcToTime.clear(); m_tdcToTime.resize(tdcnumber);
  m_tdcwac.clear();    m_tdcwac.resize(tdcnumber);
  m_tdcMin.clear();    m_tdcMin.resize(tdcnumber);
 
  // find file in share directory
  m_calib_filename = PathResolver::find_file (m_calib_filename, "DATAPATH");
 
  std::ifstream calibfile;
  calibfile.open(m_calib_filename.c_str());
  if (!calibfile.good()) {
    ATH_MSG_INFO ( "Problem with calibration file "<< m_calib_filename );
    return StatusCode::FAILURE;
  }
 
  int pos = -1 ;  
  int runnumber = 0, prevrunnumber = 0;
 
  /* 
  
    Parsing of TDC calibration constants file
    
    Loop is exited when a run number bigger then the current is found: calibration constants of
    previous available run will be used, last step is used  only to define interval of validity
    (TDC calibration constant obtained from a run are considered valid _from_ that run (included)
    since the next one used for TDC calibration)
 
    If the calibration constants file has only one line, or provide calibration constants for run
    numbers smaller than the current one, or a empty line is found, the last read TDC calibration
    constants are used but a warning message is issued.
 
  */
 
  while ( !calibfile.eof() ) {
     prevrunnumber = runnumber ;
     runnumber = -1 ;     
     calibfile >> runnumber;
     if ( runnumber==-1 ) { // reached an empty line
       ATH_MSG_WARNING ( "Empty line found in " << m_calib_filename );
       calibfile.clear();
       runnumber = prevrunnumber ;
       break ;
     }
     if ( runnumber > int(m_runnumber) ) break ;
     pos = calibfile.tellg();
     for(int j=0; j<tdcnumber+1; j++) calibfile.ignore(5000,'\n'); // discard next lines
  } 
    
  // this take care of the case in which only one line is present in the file,
  // and the corresponding run number is greater than the current one
  if ( pos == -1 ) { 
     pos = calibfile.tellg(); 
     prevrunnumber = runnumber ;
  }
  // Now we should have found a good set of constant (the ones following pos)
  ATH_MSG_DEBUG ( "Position in file stream = "<< pos );
  calibfile.seekg(pos);
  
  ATH_MSG_INFO ( "TDC calibration constants obtained from run " << prevrunnumber );
  if ( prevrunnumber != runnumber ) {
    ATH_MSG_INFO ( "valid for run interval " << prevrunnumber << " - "  << runnumber );
  } else {
    ATH_MSG_WARNING ( "TDC calibration constants could not be optimal... ");
  }
  
  for(int j=0;j<tdcnumber;j++) {
      int tdcn;
      calibfile >> tdcn; 
      calibfile >> m_tdcToTime[j];
      calibfile >> m_tdcwac[j];  
      calibfile >> m_tdcMin[j];  
      ATH_MSG_INFO ( " * TDC n. " << tdcn );
      ATH_MSG_INFO ( "   - TDCToTime = " << m_tdcToTime[j] );
      ATH_MSG_INFO ( "   - TDCwac    = " << m_tdcwac[j] );
      ATH_MSG_INFO ( "   - TDCMin    = " << m_tdcMin[j] );
  }
  
  calibfile.close();
  
  return StatusCode::SUCCESS;
  
}

initialize()

StatusCode TBPhaseRec::initialize ( )

overridevirtual

Definition at line 56 of file TBPhaseRec.cxx.

{
  // check consistency of jobOptions, set defaults if required
  float default_tdc2time = 0.050*ns;
  float default_tdcwac   = 0.;
  float default_tdcMin   = 0.;
 
  m_nTDC = m_tdcNames.size() ;
  if ( m_nTDC == 0 ) {
    ATH_MSG_ERROR ( "Empty list of TDC names" );
    return StatusCode::FAILURE ;
  }
 
  if (m_nTDC != (int)m_tdcToTime.size()) {  // check consistency of joboption vectors
    if (m_tdcToTime.size() == 0) {
      m_tdcToTime.resize(m_nTDC) ;
      for (int k = 0; k < m_nTDC; k++) m_tdcToTime[k] = default_tdc2time;
    } else if (m_tdcToTime.size() == 1) {
      m_tdcToTime.resize(m_nTDC);
      float tdc2time = m_tdcToTime[0];
      for (int k = 0; k < m_nTDC; k++) m_tdcToTime[k] = tdc2time;
    } else {
      ATH_MSG_FATAL ( "Nunber of TDCs not equal to nunber of tdc2time constants" );
      return StatusCode::FAILURE ;
    }
  }
 
  if (m_nTDC != (int)m_tdcwac.size()) {  // check consistency of joboption vectors
    if (m_tdcwac.size() == 0) {
      m_tdcwac.resize(m_nTDC) ;
      for (int k = 0; k < m_nTDC; k++) m_tdcwac[k] = default_tdcwac;
    } else if (m_tdcwac.size() == 1) {
      m_tdcwac.resize(m_nTDC);
      float tdcwac = m_tdcwac[0];
      for (int k = 0; k < m_nTDC; k++) m_tdcwac[k] = tdcwac;
    } else {
      ATH_MSG_FATAL ( "Nunber of TDCs not equal to nuunber of wac constants" );
      return StatusCode::FAILURE ;
    }
  }
 
  if (m_nTDC != (int)m_tdcMin.size()) {  // check consistency of joboption vectors
    if (m_tdcMin.size() == 0) {
      m_tdcMin.resize(m_nTDC) ;
      for (int k = 0; k < m_nTDC; k++) m_tdcMin[k] = default_tdcMin;
    } else if (m_tdcMin.size() == 1) {
      m_tdcMin.resize(m_nTDC);
      float tdcMin = m_tdcMin[0];
      for (int k = 0; k < m_nTDC; k++) m_tdcMin[k] = tdcMin;
    } else {
      ATH_MSG_FATAL ( "Nunber of TDCs not equal to nuunber of tdcMin constants" );
      return StatusCode::FAILURE ;
    }
  }
 
  ATH_MSG_INFO
    ( "TTCClockPeriod = " << m_delta/ns << " ns" );
  for (int k = 0; k < m_nTDC; k++) {
    ATH_MSG_INFO
      ( "\042" + m_tdcNames[k] + "\042"
        << "  PhaseTDCToTime = " << m_tdcToTime[k]/ns << " ns/TDC"
        << "  PhaseTDCwac    = " << m_tdcwac[k]
        << "  PhaseTDCMin    = " << m_tdcMin[k] );
  }
 
  m_phaseReco.resize(m_nTDC);
  m_tdcRaw.resize(m_nTDC);
  
  if ( m_guardValue > 0. )
    ATH_MSG_INFO (  " Cut events using guard value: " << m_guardValue );
  
  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.

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_calib_filename

std::string TBPhaseRec::m_calib_filename

private

Definition at line 48 of file TBPhaseRec.h.

m_delta

float TBPhaseRec::m_delta

private

Definition at line 43 of file TBPhaseRec.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_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_guardValue

float TBPhaseRec::m_guardValue

private

Definition at line 51 of file TBPhaseRec.h.

m_neverReturnFailure

bool TBPhaseRec::m_neverReturnFailure

private

Definition at line 46 of file TBPhaseRec.h.

m_nTDC

int TBPhaseRec::m_nTDC

private

Definition at line 57 of file TBPhaseRec.h.

m_phaseReco

std::vector<float> TBPhaseRec::m_phaseReco

private

Definition at line 59 of file TBPhaseRec.h.

m_runnumber

unsigned int TBPhaseRec::m_runnumber

private

Definition at line 49 of file TBPhaseRec.h.

m_TBPhaseKey

std::string TBPhaseRec::m_TBPhaseKey

private

Definition at line 45 of file TBPhaseRec.h.

m_tdcMin

std::vector<float> TBPhaseRec::m_tdcMin

private

Definition at line 42 of file TBPhaseRec.h.

m_tdcNames

std::vector<std::string> TBPhaseRec::m_tdcNames

private

Definition at line 39 of file TBPhaseRec.h.

m_tdcRaw

std::vector<int> TBPhaseRec::m_tdcRaw

private

Definition at line 58 of file TBPhaseRec.h.

m_tdcToTime

std::vector<float> TBPhaseRec::m_tdcToTime

private

Definition at line 40 of file TBPhaseRec.h.

m_tdcwac

std::vector<float> TBPhaseRec::m_tdcwac

private

Definition at line 41 of file TBPhaseRec.h.

m_timeBins

int TBPhaseRec::m_timeBins

private

Definition at line 44 of file TBPhaseRec.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.

unknown

const int TBPhaseRec::unknown = -99999

static

Definition at line 33 of file TBPhaseRec.h.

---

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

• TBPhaseRec.h
• TBPhaseRec.cxx