RawDataEvtHeaderCnv.cxx

Go to the documentation of this file.

#include "GaudiKernel/MsgStream.h"
// for Mutil-thread by tianhl
#include "GaudiKernel/ThreadGaudi.h"
// for Mutil-thread by tianhl
 
#include "RawDataCnv/RawDataAddress.h"
#include "RawDataCnv/RawDataInputSvc.h"
#include "RawDataCnv/PackedRawDataCnvSvc.h"
#include "RawDataCnv/EventManagement/RAWEVENT.h" 
#include "EventModel/EventHeader.h"
#include "RawDataCnv/RawDataEvtHeaderCnv.h"
#include "RawDataCnv/OfflineRevise.h"
 
extern const CLID& CLID_EventHeader;
 
static OfflineRevise* _localRevisor = NULL;
static int            _localTimeRound = 0;
 
RawDataEvtHeaderCnv::RawDataEvtHeaderCnv(ISvcLocator* svc) :
  RawDataBaseCnv(PACKEDRAWEVENT_StorageType, classID(), svc)
{
  // for Mutil-thread by tianhl
  //init();
  // for Mutil-thread by tianhl
}
 
StatusCode RawDataEvtHeaderCnv::initialize()
{
  StatusCode sc = RawDataBaseCnv::initialize();
  if ( sc.isFailure() ) return sc;
 
  std::string PackedRawDataCnvSvc_Name("PackedRawDataCnvSvc");
  std::string RawDataInputSvc_Name("RawDataInputSvc");
  std::string RawDataEvtHeaderCnv_Name("RawDataEvtHeaderCnv");
  
  // for Mutil-thread by tianhl
  //ConversionSvc*  pCnvSvc = 0;
  //if (pCnvSvc = dynamic_cast<ConversionSvc*>(conversionSvc())){
  SmartIF<IService> pCnvSvc(conversionSvc());  
  if  (isGaudiThreaded(pCnvSvc->name())){
      PackedRawDataCnvSvc_Name += getGaudiThreadIDfromName(pCnvSvc->name());
      RawDataInputSvc_Name += getGaudiThreadIDfromName(pCnvSvc->name());
      RawDataEvtHeaderCnv_Name += getGaudiThreadIDfromName(pCnvSvc->name());
    }
  //}
  // for Mutil-thread by tianhl
  MsgStream log(messageService(), RawDataEvtHeaderCnv_Name.c_str());
 
  IService* svc = 0;
  sc = serviceLocator()->service(PackedRawDataCnvSvc_Name.c_str(), svc);
  if ( sc.isFailure() ) {
    log << MSG::ERROR << "Can't get RawDataAccess interface" << endreq;
    return StatusCode::FAILURE;
  }
 
  m_RawDataAccess = dynamic_cast<PackedRawDataCnvSvc*> (svc);
  if (m_RawDataAccess  == 0 ) {
    log << MSG::ERROR << "RawDataEvtHeaderCnv: Cant cast to RawDataCnvSvc" << endreq;
    return StatusCode::FAILURE;
  }
 
  sc = serviceLocator()->getService(RawDataInputSvc_Name.c_str(), svc);
  if ( sc.isFailure() ) {
    log << MSG::WARNING << "Cant get RawDataInputSvc " << endreq;
    return sc ;
  }
 
  m_inputSvc = dynamic_cast<RawDataInputSvc*> (svc);
  if ( m_inputSvc == 0 ) {
    log << MSG::ERROR << "Cant cast to RawDataInputSvc" << endreq;
    return StatusCode::FAILURE ;
  }
 
  _localRevisor = dynamic_cast<RawDataInputSvc*>(m_inputSvc)->offlineRevisor();
 
  return StatusCode::SUCCESS;
}
 
const CLID& RawDataEvtHeaderCnv::classID()
{
  return CLID_EventHeader;
}
 
StatusCode RawDataEvtHeaderCnv::updateObj(IOpaqueAddress* pAddr, DataObject* pObj) {
  //MsgStream log(msgSvc(), "RawDataEvtHeaderCnv");
  //log << MSG::DEBUG << "RawDataEvtHeaderCnv::updateObj" << endreq;
  return Converter::updateObj(pAddr, pObj);
}
 
// Create a converted object in the Transient Data Store.
StatusCode RawDataEvtHeaderCnv::createObj(IOpaqueAddress* pAddr, DataObject*& pObj)
{
   StatusCode sc;
   RawDataAddress *pEFAddr;
   const RAWEVENT *evt;
 
   Event::EventHeader *header = new Event::EventHeader();
   pObj = header;
 
   //if ( (pEFAddr = dynamic_cast<RawDataAddress*>(pAddr)) ) {
     evt = m_inputSvc->currentEvent();
     
     if (evt == NULL) return StatusCode::FAILURE;
 
     header->setEventNumber(evt->eventHeader().event_number());
     header->setRunNumber(evt->eventHeader().run_number());
     header->setTime(evt->eventHeader().time());
     header->setFlag1( evt->eventHeader().flag1() );
     //header->setFlag2( evt->eventHeader().flag2() );
 
     const BufferHolder& rBuf = evt->getEtsBuf();
     if ( rBuf.nBuf() == 1 ) {  // this event has ETS data
         uint32_t   dataLen = rBuf.bufSize(0);
         uint32_t * dataPtr = rBuf(0);
         //{  // debug
         //    std::cout << "[ETS]:  " << std::hex;
         //    for ( uint32_t i = 0; i < dataLen; ++i ) {
         //        std::cout << " 0x" << std::setw(8) << std::setfill('0') << dataPtr[i];
         //    }
         //    std::cout << std::dec << std::endl;
         //}
         // check
         if ( dataLen > 11 && dataPtr[1] == 0xffffffff ) {
             uint32_t start = 10;
             if (  (dataPtr[start] >> 24) == 0xcf ) {
                 _localTimeRound = _localRevisor->timeRound(header->runNumber());
 
                 unsigned long t1 = calEts( dataPtr + start );
                 header->setEtsT1(t1);
 
                 static unsigned long t2 = 0;
                 if ( (start+3) < dataLen && dataPtr[start+2] != 0xf0f0f0f0 ) {
                     if ((dataPtr[start+2]>>24) == 0xd1 ) {
                         t2 = calEts( dataPtr + start + 2 );
                     }
                     else {
                         uint32_t _dataT2[2] = {dataPtr[10], dataPtr[12]};
                         unsigned long _t2 = calEts( _dataT2 );
                         if ( labs(_t2-t2) < 150/*ms*/*2000 ) {
                             t2 = _t2;
                         }
                         else if ( labs(_t2-2000000-t2) < 150*2000 ) {
                             t2 = _t2 - 2000000;
                         }
                         else if ( labs(_t2+2000000-t2) < 150*2000 ) {
                             t2 = _t2 + 2000000;
                         }
                     }
                 }
                 header->setEtsT2(t2);
 
                 //do not revise ets here, move to ResetEtsAlg
                 //_localRevisor->fixHeader(header);
 
                 //if ( header->etsT1() != t1 || header->etsT2() != t2 )
                 //{
                 //    std::cout << "event " << header->eventNumber()
                 //              << "  time " << header->time()
                 //              << "  new t1 " << header->etsT1()
                 //              << "  old t1 " << t1
                 //              << "  new t2 " << header->etsT2()
                 //              << "  old t2 " << t2
                 //              << std::endl;
                 //}
             }
         }
     }
     
   return StatusCode::SUCCESS;
   //}
   //else {
   //  return StatusCode::FAILURE;
   //}
 
}
 
unsigned long RawDataEvtHeaderCnv::calEts(uint32_t* dptr)
{
    unsigned int tmp = dptr[0] & 0xffffff;
    //std::cout << _localTimeRound << " for " << (tmp>>16) << ":" << ((tmp>>8)&0xff) << ":" << (tmp&0xff) << std::endl;
    unsigned long val = (tmp >> 16 ) * _localTimeRound * _localTimeRound;
    val += ((tmp >> 8) & 0xff) * _localTimeRound;
    val += tmp & 0xff;
    val *= 2000000;  // s -> 500ns
    val += (dptr[1] & 0x3fffff);
 
    return val;
}