TileTBStat Class Reference

Class to produce run statistics. More...

#include <TileTBStat.h>

Inheritance diagram for TileTBStat:

Collaboration diagram for TileTBStat:

Classes
struct	T_RobRodFragMap
struct	T_RodDataFrag

Public Member Functions
	TileTBStat (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~TileTBStat ()
virtual StatusCode	initialize () override
virtual StatusCode	execute () override
virtual StatusCode	finalize () override
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 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 struct TileTBStat::T_RobRodFragMap	T_RobRodFragMap
typedef struct TileTBStat::T_RodDataFrag	T_RodDataFrag
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	find_frag (const uint32_t *data, unsigned int size, T_RobRodFragMap &ROBfrag)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
Gaudi::Property< bool >	m_printAllEvents
Gaudi::Property< bool >	m_detectDummyFragments
SG::ReadCondHandleKey< TileHid2RESrcID >	m_hid2RESrcIDKey
SG::ReadHandleKey< TileDQstatus >	m_dqStatusKey
SG::ReadHandleKey< TileLaserObject >	m_laserObjectKey
ServiceHandle< IROBDataProviderSvc >	m_robSvc
	Name of ROB data provider service.
int	m_evtNr
StatDouble	m_laserBoxTemp
StatDouble	m_laserDiodeTemp
StatDouble	m_laserBoxHum
StatDouble	m_gasFlow
StatInt	m_cisMode
StatInt	m_cisSamples
StatInt	m_cisPipeline
StatInt	m_cisI3Delay
StatInt	m_cisDAC
StatInt	m_cisCap
StatInt	m_cisEvent
StatInt	m_cisPhase
StatInt	m_cisCard
StatInt	m_lasFiltNum
StatInt	m_lasAmp
StatInt	m_lasAlphaPos
int	m_lasStatus
int	m_checkOn
int	m_checkOff
int	m_check0
int	m_check1
int	m_check2
int	m_Alarm
int	m_Error
int	m_ShOpen
int	m_ShClose
uint32_t	m_runNo
uint64_t	m_evTime
uint32_t	m_evtNo
int	m_trigType
uint32_t	m_prevTrig
uint32_t	m_evtBegin
uint64_t	m_timeBegin
uint64_t	m_timeStart
uint64_t	m_timeLast
uint32_t	m_evtMin
uint32_t	m_evtMax
uint32_t	m_calibMode
uint32_t	m_spillPattern
uint32_t	m_nSpill
uint32_t	m_nEvt [5]
uint32_t	m_cisPar [16]
uint32_t	m_cis1st [16]
uint32_t	m_cisBeg [19]
uint32_t	m_cisEnd [19]
std::vector< T_RobRodFragMap >	m_fragMap
std::vector< T_RobRodFragMap >	m_beamFragMap
uint32_t	m_nEventsPerTrigger [257]
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

Class to produce run statistics.

Used to fill commissioning database.

Definition at line 76 of file TileTBStat.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

T_RobRodFragMap

typedef struct TileTBStat::T_RobRodFragMap TileTBStat::T_RobRodFragMap

private

T_RodDataFrag

typedef struct TileTBStat::T_RodDataFrag TileTBStat::T_RodDataFrag

private

Constructor & Destructor Documentation

TileTBStat()

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

Definition at line 125 of file TileTBStat.cxx.

  : AthAlgorithm(name, pSvcLocator)
  , m_evtNr(0)
  , m_lasStatus(0)
  , m_checkOn(0)
  , m_checkOff(0)
  , m_check0(0)
  , m_check1(0)
  , m_check2(0)
  , m_Alarm(0)
  , m_Error(0)
  , m_ShOpen(0)
  , m_ShClose(0)
  , m_evTime(0)
  , m_trigType(0)
  , m_prevTrig(0)
  , m_timeBegin(0)
  , m_timeStart(0)
  , m_timeLast(0)
  , m_calibMode(0)
  , m_spillPattern(0)
  , m_nSpill(0)
  , m_nEvt()
  , m_cisPar()
  , m_cis1st()
  , m_cisBeg()
  , m_cisEnd()
  , m_nEventsPerTrigger()
{
  m_runNo = m_evtMin =  m_evtMax = m_evtBegin = m_evtNo = 0;
}

~TileTBStat()

TileTBStat::~TileTBStat ( )

virtual

Definition at line 158 of file TileTBStat.cxx.

                        {
}

Member Function Documentation

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

overridevirtual

Definition at line 196 of file TileTBStat.cxx.

                               {
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  const TileDQstatus* dqStatus = SG::makeHandle (m_dqStatusKey, ctx).get();
 
  static std::atomic<bool> first=true;
  static std::atomic<bool> firstORsecond=true;
  
  if ( firstORsecond ) {
    const eformat::FullEventFragment<const uint32_t*> * event = m_robSvc->getEvent(ctx);
    if( true /* event->check_tree() */) { // valid event
      if ( ! first ) firstORsecond = m_printAllEvents;
      first=false;
      m_fragMap.clear();
 
      uint32_t nrob = event->nchildren();
      uint32_t L1type = event->lvl1_trigger_type();
 
      for (size_t irob=0; irob<nrob; ++irob) {
        const uint32_t* fprob;
        event->child(fprob, irob);
        const eformat::ROBFragment<const uint32_t*> robf(fprob);
 
        T_RobRodFragMap ROBfrag;
        ROBfrag.L1type = L1type;
        ROBfrag.ROBid = robf.source_id();
        ROBfrag.RODid = robf.rod_source_id();
 
        //unsigned int version     = robf.rod_version();
        unsigned int source_id   = robf.rod_source_id();
        eformat::helper::SourceIdentifier id = eformat::helper::SourceIdentifier(source_id);
        unsigned int subdet_id   = id.subdetector_id();
        //unsigned int module_id   = id.module_id();
 
        unsigned int max_allowed_size = robf.rod_fragment_size_word();
        unsigned int delta = robf.rod_header_size_word() + robf.rod_trailer_size_word();
        if (max_allowed_size > delta) {
          max_allowed_size -= delta;
        } else {
          max_allowed_size = 0;
        }
            
        unsigned int size = robf.rod_ndata();
        if (size > max_allowed_size) {
 
          if (size - robf.rod_trailer_size_word() < max_allowed_size) {
            ATH_MSG_ERROR( "Problem with data size - assuming that trailer size is " << robf.rod_trailer_size_word()-(size-max_allowed_size)
                           <<" words instead of " << robf.rod_trailer_size_word() << " and data size is " << size << " words " );
            max_allowed_size = size;
          } else if (size - robf.rod_trailer_size_word() == max_allowed_size) {
            ATH_MSG_ERROR( "Problem with data size - assuming that trailer is absent "
                           << " ROD size " << robf.rod_fragment_size_word()
                           << " header size " << robf.rod_header_size_word()
                           << " data size " << size );
            max_allowed_size = size;
          } else {
            max_allowed_size += robf.rod_trailer_size_word();
            size = max_allowed_size;
            ATH_MSG_ERROR( "Problem with data size - assuming " << size << " words and no trailer at all" );
          }
        }
 
        if ( size > 0 ) {
 
          const uint32_t * data;
          robf.rod_data(data);
 
          switch ( subdet_id ) {
          case TILE_BEAM_ID:   // TILE BEAM ROD
          case COMMON_BEAM_ID: // COMMON BEAM ROD
          case 0x63: // wrong id in first test runs
          case TILE_POS_ID: // POSITIVE ROD
          case TILE_NEG_ID: // NEGATIVE ROD
          case TILE_EBPOS_ID: // POSITIVE EB ROD
          case TILE_EBNEG_ID: // NEGATIVE EB ROD
            find_frag(data, size, ROBfrag);
            break;
          default:
            break;
          }
        }
        m_fragMap.push_back(ROBfrag);
        if ((ROBfrag.RODid & 0xFF0000) == 0x500000) {
          size_t i=0;
          for ( ; i<m_beamFragMap.size(); ++i) {
            if (m_beamFragMap[i].ROBid == ROBfrag.ROBid && m_beamFragMap[i].L1type == ROBfrag.L1type) break;
          }
          if (i==m_beamFragMap.size()) {
            m_beamFragMap.push_back(std::move(ROBfrag));
          }
        }
      }
 
      if (m_printAllEvents)
        std::cout << "Fragments found in event " << event->global_id();
      else if (firstORsecond)
        std::cout << "Fragments found in first event";
      else
        std::cout << "Fragments found in second event";
      std::cout << "  L1 trigger type " << L1type << " (0x"<< std::hex << L1type << std::dec << ")"
                << "  calib mode=" << dqStatus->calibMode() << std::endl
                << "  ROB ID   ROD ID   Frag IDs" << std::endl;
      for (unsigned int i = 0; i < nrob; ++i) {
        std::cout << std::hex << " 0x" << m_fragMap[i].ROBid << " 0x" << m_fragMap[i].RODid;
        for (unsigned int j = 0; j < m_fragMap[i].fragID.size(); ++j)
          std::cout << std::hex << " 0x" << m_fragMap[i].fragID[j];
        std::cout << std::dec << std::endl;
      }
    }
  }
  
  // take values from event header
 
  memcpy(m_cisPar,dqStatus->cispar(), sizeof (m_cisPar));
  
  unsigned int testsum=0;
  for (int k = 4; k < 16; ++k) testsum += m_cisPar[k];
  if ( testsum == 0 && m_cisPar[3] == 8 ) { // broken CIS par
    m_cisSamples.addValue(m_cisPar[1]);
    m_cisI3Delay.addValue(m_cisPar[2]);
  } else {
    m_cisMode.addValue(m_cisPar[0]);
    m_cisSamples.addValue(m_cisPar[1]);
    m_cisPipeline.addValue(m_cisPar[2]);
    m_cisI3Delay.addValue(m_cisPar[3]);
    m_cisEvent.addValue(m_cisPar[4]);
    m_cisPhase.addValue(m_cisPar[5]);
    m_cisDAC.addValue(m_cisPar[6]);
    m_cisCap.addValue(m_cisPar[7]);
    m_cisCard.addValue(m_cisPar[8]);
  }
  
  const eformat::FullEventFragment<const uint32_t*> * event = m_robSvc->getEvent(ctx);
 
  if (testsum!=0) {
    memcpy(m_cisEnd,m_cisPar,sizeof(m_cisPar));
    m_cisEnd[16] = event->global_id();
    m_cisEnd[17] = m_evtNr;
    m_cisEnd[18] = 1;
    if (m_cisBeg[18] == 0) {
      memcpy(m_cisBeg,m_cisEnd,sizeof(m_cisEnd));
    }
  }
 
  m_evTime = event->bc_time_seconds();
  if (m_evTime >= m_timeStart || m_evTime < 1054321000 ) {
    if (m_evtNr == 0)
      ATH_MSG_WARNING( "bad time in event header (" << m_evTime << "), taking time from cispar (" << m_cisPar[10] << ")" );
 
    m_evTime = m_cisPar[10];
  }
  
  m_trigType = dqStatus->trigType();
  if (m_trigType < 1 || m_trigType > 0x80 ) {
    if (m_evtNr == 0)
      ATH_MSG_WARNING( "no event trig type available (" << m_trigType << ") , taking trig from cispar (" << m_cisPar[12] << ")" );
 
    m_trigType = m_cisPar[12];
  }
  
  m_evtNo = event->global_id();
  if (m_evtNo < m_evtMin) m_evtMin = m_evtNo;
  if (m_evtNo > m_evtMax) m_evtMax = m_evtNo;
  
  if (m_evtNr == 0) {
    SG::ReadCondHandle<TileHid2RESrcID> hid2re(m_hid2RESrcIDKey, ctx);
    ATH_CHECK(hid2re.isValid());
    std::vector<uint32_t> robid;
    robid.push_back( hid2re->getRobFromFragID(DIGI_PAR_FRAG) );
    robid.push_back( hid2re->getRobFromFragID(LASER_OBJ_FRAG) );
    std::vector<const ROBDataProviderSvc::ROBF*> robf;
    m_robSvc->getROBData(ctx, robid, robf);
    const ROBDataProviderSvc::ROBF* robFrag = (robf.size() > 0 ) ? robf[0] : 0;
    if (robFrag) {
      m_runNo = robFrag->rod_run_no();   // take it from beam ROD header
    } else {
      m_runNo = event->run_no();  // run_no sometimes is not filled here
    }
    m_timeBegin = m_evTime;
    m_evtBegin  = m_evtNo;
    m_calibMode = dqStatus->calibMode();
    memcpy(m_cis1st,m_cisPar,sizeof(m_cisPar));
  } else if (m_evtNr == 1) {
    // once again, first event can be junk
    m_calibMode = dqStatus->calibMode();
  }
 
  if (! m_printAllEvents) {
    // check if new Laser or CIS fragments appear in events with different L1 trigger types
    bool first_header=true;
    for (size_t irob=0; irob<event->nchildren(); ++irob) {
      const uint32_t* fprob;
      event->child(fprob, irob);
      const eformat::ROBFragment<const uint32_t*> robf(fprob);
 
      T_RobRodFragMap ROBfrag;
      ROBfrag.L1type = event->lvl1_trigger_type();
      ROBfrag.ROBid = robf.source_id();
      ROBfrag.RODid = robf.rod_source_id();
 
      if ((ROBfrag.RODid & 0xFF0000) == 0x500000) {
        size_t i=0;
        for ( ; i<m_beamFragMap.size(); ++i) {
          if (m_beamFragMap[i].ROBid == ROBfrag.ROBid && m_beamFragMap[i].L1type == ROBfrag.L1type) break;
        }
        if (i==m_beamFragMap.size()) {
          unsigned int size = robf.rod_ndata();
          if ( size > 0 ) {
            const uint32_t * data;
            robf.rod_data(data);
            find_frag(data, size, ROBfrag);
            m_beamFragMap.push_back(ROBfrag);
            if (first_header) {
              first_header=false;
              std::cout << "Beam Fragments found in event " << m_evtNo << " ( " << m_evtNr << " )  L1 trigger type "
                        << ROBfrag.L1type << " (0x"<< std::hex << ROBfrag.L1type << std::dec << ")" << std::endl
                        << "  ROB ID   ROD ID   Frag IDs" << std::endl;
            }
            std::cout << std::hex << " 0x" << ROBfrag.ROBid << " 0x" << ROBfrag.RODid;
            for (unsigned int j = 0; j < ROBfrag.fragID.size(); ++j)
              std::cout << std::hex << " 0x" << ROBfrag.fragID[j];
            std::cout << std::dec << std::endl;
          }
        }
      }
    }
  }
 
  if ( ( m_evTime < m_timeBegin && (m_timeBegin - m_evTime) < 10*24*3600 ) ||  // less then 10 days shift in neg direction
       ( m_evTime > m_timeBegin && (m_evTime - m_timeBegin) > 10*24*3600 ) ) { // more than 10 days shift in pos direction
 
    ATH_MSG_WARNING( " in evt " << m_evtNo << " ( " << m_evtNr << " ) "
                     << " event header time " << event->bc_time_seconds()
                     << " CISpar time " << m_cisPar[10]
                     << " old begin time " <<  m_timeBegin );
 
    if ( m_cisPar[10] > 0 && m_cisPar[10] - m_evTime > 600 ) { // more than 10 min difference !
      ATH_MSG_WARNING( "Strange time in event header, ignore it! " );
 
      m_evTime = m_cisPar[10];
    } else {
      ATH_MSG_WARNING( "Strange begin time, change it from " << m_timeBegin << " to " << m_evTime );
 
      m_timeBegin = m_evTime;
    }    
  }
  
  if ((m_evTime >= m_timeBegin) && ((m_evTime - m_timeBegin) < 10 * 24 * 3600)
      && (m_evTime > m_timeLast)) {
    m_timeLast = m_evTime;
  }
  
  int ind = 4;
  switch ( m_trigType ) {
  case  1: ind = 0; break;
  case  2: ind = 1; break;
  case  4: ind = 2; break;
  case  8: ind = 3; break;
  case 16: ind = 3; break;
  default: ind = 4; break;
  }
  ++(m_nEvt[ind]);
 
  unsigned int lvl1_trigger_type = event->lvl1_trigger_type();
  if (lvl1_trigger_type < 256U) ++m_nEventsPerTrigger[lvl1_trigger_type];
  else ++m_nEventsPerTrigger[256];
 
  m_spillPattern <<= 4;
  m_spillPattern |= (m_trigType & 0xF);
 
  if (m_spillPattern != m_prevTrig && m_spillPattern == 0x11111111) 
    ++m_nSpill;
  
  m_prevTrig = m_spillPattern;
 
  ++m_evtNr;
 
  SG::ReadHandle<TileLaserObject> pTileLasObj(m_laserObjectKey, ctx);
  if(!pTileLasObj.isValid()) {
    ATH_MSG_ERROR( "There is a problem opening the LASER object" );
 
    //return sc;
  } else {
    m_lasFiltNum.addValue(pTileLasObj->getFiltNumber());
    m_lasAmp.addValue((int)pTileLasObj->getDiodeCurrOrd());
    m_laserBoxTemp.addValue(pTileLasObj->getDiodeBoxTemp());
    m_laserDiodeTemp.addValue(pTileLasObj->getPumpDiodeTemp());
    m_laserBoxHum.addValue(pTileLasObj->getHumidity());
    m_gasFlow.addValue(pTileLasObj->getGasFlux());
    m_lasStatus = (pTileLasObj->getAlarm() << 0x9) + (pTileLasObj->getInterlock() << 0x8) + (pTileLasObj->getShutter() << 0x6)
    + ((int)pTileLasObj->getHVpmts() << 0x4) + ((int)pTileLasObj->getLVdiodes() << 0x3) + (pTileLasObj->getAlphaPos());
    int lasAlpha = (int)pTileLasObj->getAlphaPos() & 0x7;
    m_lasAlphaPos.addValue(lasAlpha);
    m_checkOn = m_checkOn | m_lasStatus;
    m_checkOff = m_checkOff | (~m_lasStatus);
//    std::cout << std::endl << "Status: " << std::hex << m_lasStatus << std::dec
//              << std::endl << "Alpha: "  << lasAlpha << std::endl   << std::endl;
  }
  
  //log<<MSG::DEBUG<<"execute() completed successfully"<<endmsg;
  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 TileTBStat::finalize ( )

overridevirtual

Definition at line 499 of file TileTBStat.cxx.

                                {
 
  ATH_MSG_INFO( "Finalization" );
 
  std::cout << std::endl << "Run number " << m_runNo  << std::endl;
  std::cout << "Min event number " << m_evtMin << std::endl;
  std::cout << "Max event number " << m_evtMax << std::endl;
  std::cout << "First event " << m_evtBegin << std::endl;
  std::cout << "Last  event " << m_evtNo << std::endl;
 
  // time stored in event header is time since 1-jan-1970 00:00:00 Geneva time
  // has to make one hour correction to convert to UNIX (UTC) time
 
  time_t tim;
  struct tm buf;
  char ctim[50];
  char format[30] = "%a, %d %b %Y %H:%M:%S %Z (%z)";
  
  if (m_evTime >= m_timeStart || m_evTime == 0 ) {
    if (m_evtNr == 0)
      ATH_MSG_WARNING( "no event header available, taking time from cispar" );
 
    m_evTime = m_cisPar[10];
  }
 
  if (m_timeBegin != 0 && m_timeBegin < 1104537600 ) { // CTB 2004 time  
    std::cout << "Begin time " << m_timeBegin;
    tim = m_timeBegin - 3600; 
    std::cout << "-3600=" << tim;
    strftime(ctim, 50, format, localtime_r(&tim, &buf) );
    std::cout << "  " << ctim;
    strftime(ctim, 50, format, gmtime_r(&tim, &buf) );
    std::cout << "  " << ctim;
    std::cout << std::endl;
 
    std::cout << "End   time " << m_evTime;
    tim = m_evTime - 3600; 
    std::cout << "-3600=" << tim;
    strftime(ctim, 50, format, localtime_r(&tim, &buf) );
    std::cout << "  " << ctim;
    strftime(ctim, 50, format, gmtime_r(&tim, &buf) );
    std::cout << "  " << ctim;
    std::cout << std::endl;
 
  } else {
 
    std::cout << "Begin time " << m_timeBegin;
    tim = m_timeBegin; 
    strftime(ctim, 50, format, localtime_r(&tim, &buf) );
    std::cout << "  " << ctim;
    strftime(ctim, 50, format, gmtime_r(&tim, &buf) );
    std::cout << "  " << ctim;
    std::cout << std::endl;
    std::cout << "End   time " << m_timeLast;
    tim = m_timeLast; 
    strftime(ctim, 50, format, localtime_r(&tim, &buf) );
    std::cout << "  " << ctim;
    strftime(ctim, 50, format, gmtime_r(&tim, &buf) );
    std::cout << "  " << ctim;
    std::cout << std::endl;
  }
  
  std::cout << std::endl << "Ngains " << ( (m_calibMode == 1) ? 2 : 1 ) << std::endl;
 
  bool cisdiff = false;
  for (int i = 0; i < 16; ++i) {
    cisdiff |= (m_cis1st[i] != m_cisBeg[i]);
    cisdiff |= (m_cisEnd[i] != m_cisPar[i]);
  }
 
  if (cisdiff) {
    std::cout << "CISpar first ";
    for (int i = 0; i < 16; ++i)
      std::cout << m_cis1st[i] << "  ";
    std::cout << std::endl << "CISpar last  ";
    for (int i = 0; i < 16; ++i)
      std::cout << m_cisPar[i] << "  ";
    std::cout << std::endl;
  }
  std::cout << "CISpar begin ";
  for (int i = 0; i < 16; ++i)
    std::cout << m_cisBeg[i] << "  ";
  if (cisdiff) {
    std::cout << " \tevent " << m_cisBeg[16] << " \teventNr " << m_cisBeg[17];
  }
  std::cout << std::endl << "CISpar end   ";
  for (int i = 0; i < 16; ++i)
    std::cout << m_cisEnd[i] << "  ";
  if (cisdiff) {
    std::cout << " \tevent " << m_cisEnd[16] << " \teventNr " << m_cisEnd[17];
  }
  std::cout << std::endl << std::endl;
 
  uint32_t nphy=0;
  uint32_t nlas=m_nEventsPerTrigger[52];
  uint32_t nped=m_nEventsPerTrigger[49];
  uint32_t ncis=m_nEventsPerTrigger[50];
  uint32_t nbad=0;
  for (int i = 0; i < 128; ++i) {
    nbad += m_nEventsPerTrigger[i];
  }
  for (int i = 128; i < 256; ++i) {
    nphy += m_nEventsPerTrigger[i];
  }
  nbad -= nlas+nped+ncis;
  nbad += m_nEventsPerTrigger[256];
 
  if (m_nEvt[1]+m_nEvt[2]+m_nEvt[3]==0 && nlas+nped+ncis>0) {
    std::cout << "Spills " << m_nSpill  << std::endl;
    std::cout << "Events " << m_evtNr   << std::endl;
    std::cout << "Phy    " << nphy << std::endl;
    std::cout << "Las    " << nlas << std::endl;
    std::cout << "Ped    " << nped << std::endl;
    std::cout << "CIS    " << ncis << std::endl;
    std::cout << "Bad    " << nbad << std::endl;
    std::cout << std::endl << std::endl;
  } else {
    std::cout << "Spills " << m_nSpill  << std::endl;
    std::cout << "Events " << m_evtNr   << std::endl;
    std::cout << "Phy    " << m_nEvt[0] << std::endl;
    std::cout << "Las    " << m_nEvt[1] << std::endl;
    std::cout << "Ped    " << m_nEvt[2] << std::endl;
    std::cout << "CIS    " << m_nEvt[3] << std::endl;
    std::cout << "Bad    " << m_nEvt[4] << std::endl;
    std::cout << std::endl << std::endl;
  }
 
  std::cout << "Number of events per trigger:" << std::endl;
  for (int i = 0; i < 256; ++i) {
    if (m_nEventsPerTrigger[i] != 0) {
      std::cout << " Level1 trigger type: " << i << " (0x"<< std::hex << i << std::dec << ") => " <<  m_nEventsPerTrigger[i] << std::endl;
    }
  }
 
  if (m_nEventsPerTrigger[256] != 0) {
    std::cout << " Level1 trigger type: > 255(0xFF) => " <<  m_nEventsPerTrigger[256] << std::endl;
  }
 
  std::cout << std::endl << std::endl;
 
  std::cout << "LasFrag begin" << std::endl;
  m_lasFiltNum.print("FilterWheel");
  m_lasAmp.print("ReqAmp");
  std::cout << "Counter " << m_laserDiodeTemp.Counter << std::endl;
  m_laserDiodeTemp.print("LaserDiodeTemp");
  m_laserBoxTemp.print  ("LaserBoxTemp  ");
  m_laserBoxHum.print   ("LaserBoxHum   ");
  m_gasFlow.print       ("GasFlow       ");
  m_check0 = ~m_checkOn;
  m_check1 = ~m_checkOff;
  m_check2 = ~(m_check0 ^ m_check1);
  m_lasAlphaPos.print("LasAlpha");
  int bit = 0x800;
//  std::cout << "StatusHEX: " << std::hex << m_lasStatus << std::endl;
  std::cout << "GlobalStatus ";
  for (int i = 0; i < 9; i++) {
    if (m_check0 & bit)      std::cout << " 0"; 
    else if (m_check1 & bit) std::cout << " 1"; 
    else                     std::cout << " 2";
    bit = bit >> 1;
  }
  m_Alarm = 0;
  m_Error = 0;
  m_ShOpen = 0;
  m_ShClose = 0;
  bit = 0x200;
  if (m_check0 & bit) m_Error = 0; else
  if (m_check1 & bit) m_Error = 1; else
    m_Error = 2;
  std::cout << std::endl << "LasError " << m_Error;
  bit = 0x800;
  if (m_check0 & bit) m_Alarm = 0; else
  if (m_check1 & bit) m_Alarm = 1; else
    m_Alarm = 2;
  std::cout  << std::endl << "LasAlarm " << m_Alarm;
  bit = bit >> 4;
  if (m_check0 & bit) m_ShOpen = 0; else
  if (m_check1 & bit) m_ShOpen = 1; else
    m_ShOpen = 2;
  std::cout  << std::endl << "LasShOpen " << m_ShOpen;
  bit = bit >> 1;
  if (m_check0 & bit) m_ShClose = 0; else
  if (m_check1 & bit) m_ShClose = 1; else
    m_ShClose = 2;
  std::cout << std::endl << "LasShClosed " << m_ShClose;
  std::cout << std::endl << "LasFrag end" << std::endl << std::endl;
  
  std::cout << "CISparFrag begin" << std::endl;
  m_cisMode.print("CISparMode");
  m_cisSamples.print("CISparSamples");
  m_cisPipeline.print("CISparPipeline");
  m_cisI3Delay.print("CISparI3Delay");
  m_cisDAC.print("CISparDAC");
  m_cisCap.print("CISparCap");
  m_cisEvent.print("CISparEvent");
  m_cisPhase.print("CISparPhase");
  m_cisCard.print("CISparCard");
  std::cout << "CISparFrag end" << std::endl << std::endl;
 
  ATH_MSG_INFO( "finalize() successfully" );
 
  return StatusCode::SUCCESS;
}

find_frag()

void TileTBStat::find_frag ( const uint32_t * data, unsigned int size, T_RobRodFragMap & ROBfrag )

private

Definition at line 703 of file TileTBStat.cxx.

                                                                                              {
 
  unsigned int offset = 0, sizeOverhead = 2;
  bool v3Format = ( *(data) == 0xff1234ff ); // additional frag marker since Sep 2005
  v3Format |= ( *(data) == 0x00123400 ); // another possible frag marker (can appear in buggy ROD frags)
  if ( v3Format ) {
    ++sizeOverhead;
    ++offset; // skip frag marker
  }
  
  while (offset < size ) {
    const T_RodDataFrag* frag = reinterpret_cast<const T_RodDataFrag *>(data + offset);
    if ( frag->size < sizeOverhead ) { // too small size, frag contains garbage
      break;
    }
    const uint32_t * fdata = frag->data;
    int n = frag->size - sizeOverhead - 1;
    for (; n > -1; --n) {
      if ( fdata[n]!=0 && fdata[n]!=0xffffffff) break;
    }
    if (n == -1 && m_detectDummyFragments) { // nothing reasonable found
      ROBfrag.fragID.push_back(frag->id + 0xff000000);
    } else {
      ROBfrag.fragID.push_back(frag->id);
    }
    offset += frag->size;
  }
 
  if ( v3Format ) --offset; // set offset back to correct value
  if ( offset > size && ROBfrag.fragID.size() > 0 ) { // wrong length in last frag, drop it
    ROBfrag.fragID.resize(ROBfrag.fragID.size()-1);
  }
}

initialize()

StatusCode TileTBStat::initialize ( )

overridevirtual

Definition at line 162 of file TileTBStat.cxx.

                                  {
 
  ATH_MSG_INFO( "Initialization" );
 
  m_checkOn = 0;
  m_checkOff = 0;
  m_check0 = 0;
  m_check1 = 0;
  m_check2 = 0;
  
  m_lasStatus = 0;
 
  // start with event 0
  m_evtNr = 0;
  m_runNo = m_evTime = m_evtNo = m_trigType = m_nSpill = m_timeBegin = m_timeLast = m_evtMax = 0;
  m_calibMode = m_prevTrig = m_spillPattern = m_evtMin = 0xFFFFFFFF;
  memset(m_nEvt, 0, sizeof(m_nEvt));
  memset(m_cisPar, 0, sizeof(m_cisPar));
  memset(m_cis1st, 0, sizeof(m_cis1st));
  memset(m_cisBeg, 0, sizeof(m_cisBeg));
  memset(m_cisEnd, 0, sizeof(m_cisEnd));
  memset(m_nEventsPerTrigger, 0, sizeof(m_nEventsPerTrigger));
 
  m_timeStart = time(0);
  ATH_MSG_INFO( "initialization completed" );
 
  ATH_CHECK( m_hid2RESrcIDKey.initialize() );
  ATH_CHECK( m_dqStatusKey.initialize() );
  ATH_CHECK( m_robSvc.retrieve() );
  ATH_CHECK( m_laserObjectKey.initialize() );
 
  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_Alarm

int TileTBStat::m_Alarm

private

Definition at line 126 of file TileTBStat.h.

m_beamFragMap

std::vector<T_RobRodFragMap> TileTBStat::m_beamFragMap

private

Definition at line 164 of file TileTBStat.h.

m_calibMode

uint32_t TileTBStat::m_calibMode

private

Definition at line 139 of file TileTBStat.h.

m_check0

int TileTBStat::m_check0

private

Definition at line 125 of file TileTBStat.h.

m_check1

int TileTBStat::m_check1

private

Definition at line 125 of file TileTBStat.h.

m_check2

int TileTBStat::m_check2

private

Definition at line 125 of file TileTBStat.h.

m_checkOff

int TileTBStat::m_checkOff

private

Definition at line 125 of file TileTBStat.h.

m_checkOn

int TileTBStat::m_checkOn

private

Definition at line 125 of file TileTBStat.h.

m_cis1st

uint32_t TileTBStat::m_cis1st[16]

private

Definition at line 144 of file TileTBStat.h.

m_cisBeg

uint32_t TileTBStat::m_cisBeg[19]

private

Definition at line 145 of file TileTBStat.h.

m_cisCap

StatInt TileTBStat::m_cisCap

private

Definition at line 118 of file TileTBStat.h.

m_cisCard

StatInt TileTBStat::m_cisCard

private

Definition at line 121 of file TileTBStat.h.

m_cisDAC

StatInt TileTBStat::m_cisDAC

private

Definition at line 117 of file TileTBStat.h.

m_cisEnd

uint32_t TileTBStat::m_cisEnd[19]

private

Definition at line 146 of file TileTBStat.h.

m_cisEvent

StatInt TileTBStat::m_cisEvent

private

Definition at line 119 of file TileTBStat.h.

m_cisI3Delay

StatInt TileTBStat::m_cisI3Delay

private

Definition at line 116 of file TileTBStat.h.

m_cisMode

StatInt TileTBStat::m_cisMode

private

Definition at line 113 of file TileTBStat.h.

m_cisPar

uint32_t TileTBStat::m_cisPar[16]

private

Definition at line 143 of file TileTBStat.h.

m_cisPhase

StatInt TileTBStat::m_cisPhase

private

Definition at line 120 of file TileTBStat.h.

m_cisPipeline

StatInt TileTBStat::m_cisPipeline

private

Definition at line 115 of file TileTBStat.h.

m_cisSamples

StatInt TileTBStat::m_cisSamples

private

Definition at line 114 of file TileTBStat.h.

m_detectDummyFragments

Gaudi::Property<bool> TileTBStat::m_detectDummyFragments

private

Initial value:

{this,
       "DetectDummyFragments", false, "Detect dummy fragments"}

Definition at line 93 of file TileTBStat.h.

                                              {this,
       "DetectDummyFragments", false, "Detect dummy fragments"};

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_dqStatusKey

SG::ReadHandleKey<TileDQstatus> TileTBStat::m_dqStatusKey

private

Initial value:

{this,
       "TileDQstatus", "TileDQstatus", "Tile DQ status key"}

Definition at line 97 of file TileTBStat.h.

                                               {this,
       "TileDQstatus", "TileDQstatus", "Tile DQ status key"};

m_Error

int TileTBStat::m_Error

private

Definition at line 126 of file TileTBStat.h.

m_evtBegin

uint32_t TileTBStat::m_evtBegin

private

Definition at line 133 of file TileTBStat.h.

m_evTime

uint64_t TileTBStat::m_evTime

private

Definition at line 129 of file TileTBStat.h.

m_evtMax

uint32_t TileTBStat::m_evtMax

private

Definition at line 138 of file TileTBStat.h.

m_evtMin

uint32_t TileTBStat::m_evtMin

private

Definition at line 137 of file TileTBStat.h.

m_evtNo

uint32_t TileTBStat::m_evtNo

private

Definition at line 130 of file TileTBStat.h.

m_evtNr

int TileTBStat::m_evtNr

private

Definition at line 108 of file TileTBStat.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_fragMap

std::vector<T_RobRodFragMap> TileTBStat::m_fragMap

private

Definition at line 163 of file TileTBStat.h.

m_gasFlow

StatDouble TileTBStat::m_gasFlow

private

Definition at line 112 of file TileTBStat.h.

m_hid2RESrcIDKey

SG::ReadCondHandleKey<TileHid2RESrcID> TileTBStat::m_hid2RESrcIDKey

private

Initial value:

{this,
       "TileHid2RESrcID", "TileHid2RESrcID", "TileHid2RESrcID key"}

Definition at line 95 of file TileTBStat.h.

                                                         {this,
       "TileHid2RESrcID", "TileHid2RESrcID", "TileHid2RESrcID key"};

m_lasAlphaPos

StatInt TileTBStat::m_lasAlphaPos

private

Definition at line 124 of file TileTBStat.h.

m_lasAmp

StatInt TileTBStat::m_lasAmp

private

Definition at line 123 of file TileTBStat.h.

m_laserBoxHum

StatDouble TileTBStat::m_laserBoxHum

private

Definition at line 111 of file TileTBStat.h.

m_laserBoxTemp

StatDouble TileTBStat::m_laserBoxTemp

private

Definition at line 109 of file TileTBStat.h.

m_laserDiodeTemp

StatDouble TileTBStat::m_laserDiodeTemp

private

Definition at line 110 of file TileTBStat.h.

m_laserObjectKey

SG::ReadHandleKey<TileLaserObject> TileTBStat::m_laserObjectKey

private

Initial value:

{this,
       "TileLaserObject", "TileLaserObj", "Tile laser object key"}

Definition at line 99 of file TileTBStat.h.

                                                     {this,
       "TileLaserObject", "TileLaserObj", "Tile laser object key"};

m_lasFiltNum

StatInt TileTBStat::m_lasFiltNum

private

Definition at line 122 of file TileTBStat.h.

m_lasStatus

int TileTBStat::m_lasStatus

private

Definition at line 125 of file TileTBStat.h.

m_nEventsPerTrigger

uint32_t TileTBStat::m_nEventsPerTrigger[257]

private

Definition at line 168 of file TileTBStat.h.

m_nEvt

uint32_t TileTBStat::m_nEvt[5]

private

Definition at line 142 of file TileTBStat.h.

m_nSpill

uint32_t TileTBStat::m_nSpill

private

Definition at line 141 of file TileTBStat.h.

m_prevTrig

uint32_t TileTBStat::m_prevTrig

private

Definition at line 132 of file TileTBStat.h.

m_printAllEvents

Gaudi::Property<bool> TileTBStat::m_printAllEvents

private

Initial value:

{this,
       "PrintAllEvents", false, "Print all events"}

Definition at line 91 of file TileTBStat.h.

                                        {this,
       "PrintAllEvents", false, "Print all events"};

m_robSvc

ServiceHandle<IROBDataProviderSvc> TileTBStat::m_robSvc

private

Initial value:

{this,
       "ROBDataProviderSvc", "ROBDataProviderSvc", "The ROB data provider service"}

Name of ROB data provider service.

Definition at line 105 of file TileTBStat.h.

                                               {this,
       "ROBDataProviderSvc", "ROBDataProviderSvc", "The ROB data provider service"};

m_runNo

uint32_t TileTBStat::m_runNo

private

Definition at line 128 of file TileTBStat.h.

m_ShClose

int TileTBStat::m_ShClose

private

Definition at line 126 of file TileTBStat.h.

m_ShOpen

int TileTBStat::m_ShOpen

private

Definition at line 126 of file TileTBStat.h.

m_spillPattern

uint32_t TileTBStat::m_spillPattern

private

Definition at line 140 of file TileTBStat.h.

m_timeBegin

uint64_t TileTBStat::m_timeBegin

private

Definition at line 134 of file TileTBStat.h.

m_timeLast

uint64_t TileTBStat::m_timeLast

private

Definition at line 136 of file TileTBStat.h.

m_timeStart

uint64_t TileTBStat::m_timeStart

private

Definition at line 135 of file TileTBStat.h.

m_trigType

int TileTBStat::m_trigType

private

Definition at line 131 of file TileTBStat.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.

---

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

• TileTBStat.h
• TileTBStat.cxx