In This Package:

DataLoaderAlg.cc

Go to the documentation of this file.

#include "DataLoaderAlg.h"

#include "RawData/RawRecord.h"
#include "RawData/RawData.h"
#include "RawData/RawDataReader.h"
#include "RawData/RawRecordFormat.h"
#include "RawData/RawDataFormat.h"
#include "Event/ReadoutPmtCrate.h"
#include "Event/ReadoutRpcCrate.h"


#include <sstream>

DataLoaderAlg::DataLoaderAlg(const std::string& name, ISvcLocator* pSvcLocator)
  : DybAlgorithm<DayaBay::ReadoutHeader>(name,pSvcLocator)
  , m_inputFiles()
  , m_usePacked(true)
  , m_useUnpacked(true)
  , m_reader(0)
  , m_fileIndex(0)
  , m_fileYear(0)
  , m_fileMonth(0)
  , m_fileDay(0)
  , m_utcDay(0)
{
  declareProperty("InputFiles",m_inputFiles,
                  "List of input data files");
  declareProperty("UsePacked",m_usePacked=true,"Load Packed Data");
  declareProperty("UseUnpacked",m_useUnpacked=true,"Load Unpacked Data");
}

DataLoaderAlg::~DataLoaderAlg()
{
}

StatusCode DataLoaderAlg::initialize()
{
  // Initialize the data loader
  m_fileIndex = 0;
  return StatusCode::SUCCESS;
}

StatusCode DataLoaderAlg::execute()
{
  // Load one readout event

  // Get next event data
  DayaBay::RawEvent* event = 0;
  StatusCode sc = this->readNextEvent(event);
  if( !sc.isSuccess() ) return sc;

  // Create output header
  DayaBay::ReadoutHeader* readoutHeader = MakeHeaderObject();

  // Load data into header
  sc = this->loadEventData(event, readoutHeader);

  delete event;
  return sc;
}

StatusCode DataLoaderAlg::finalize()
{

  // Delete old file reader
  if(m_reader){
    delete m_reader;
    m_reader=0;
  }
  m_fileIndex=0;
  return StatusCode::SUCCESS;
}


StatusCode DataLoaderAlg::openNextFile()
{
  // Open the next input data file.

  // Delete old file reader
  if(m_reader){
    delete m_reader;
    m_reader=0;
  }

  // Check if there are more files
  if(m_fileIndex >= m_inputFiles.size()){
    warning() << "No more files to read" << endreq; 
    return StatusCode::FAILURE;
  }

  // Create new file reader
  m_reader = new DayaBay::RawDataReader;
  if(!m_reader){
    error() << "Failed to create new file reader" << endreq;
    return StatusCode::FAILURE;
  }

  // Open next file
  if(!m_reader->open( m_inputFiles[m_fileIndex].c_str() )){
    error() << "Failed to open input file: " << m_inputFiles[m_fileIndex] 
            << endreq;
    delete m_reader;
    m_reader=0;
    return StatusCode::FAILURE;
  }

  return StatusCode::SUCCESS;
}

StatusCode DataLoaderAlg::readNextEvent(DayaBay::RawEvent*& nextEvent)
{
  // Read the next event record

  DayaBay::RawEvent* event = 0;
  while( !event ){

    // Check if reader is ready
    if(!m_reader){
      StatusCode sc = this->openNextFile();
      if(! sc.isSuccess() ){
        return sc;
      }
    }

    // Read the next record
    DayaBay::RawRecord* record = m_reader->nextRecord();
    if(!record){
      error() << "Failed to read next record from file: " 
              << m_inputFiles[m_fileIndex] << endreq;
      return StatusCode::FAILURE;
    }

    // Check the record type
    if( !record->isDataSeparator() ){
      // Not a data separator record.
      std::stringstream message;
      record->dump( message );
      info() << message.str() << endreq;
      if( record->isFileStart() ){
        DayaBay::RawFileStart* fileStart = dynamic_cast<DayaBay::RawFileStart*>(record);
        if(fileStart){
          this->m_fileYear = fileStart->date() % 10000;
          this->m_fileMonth = (fileStart->date() / 10000) % 100;
          this->m_fileDay = (fileStart->date() / 1000000) % 100;
          this->m_utcDay = 0;
        }
      }
      if( record->isFileEnd() ){
        // End of file.  Close and increment file index
        delete m_reader;
        m_reader = 0;
        m_fileIndex++;
      }
      delete record;
      continue;
    }

    // Process the data separator
    DayaBay::RawDataSeparator* dataSeparator = 
      dynamic_cast<DayaBay::RawDataSeparator*>(record);
    if( !dataSeparator ){
      error() << "Failed to process data separator" << endreq;
      std::stringstream message;
      record->dump( message );
      error() << message.str() << endreq;
      delete record;
      return StatusCode::FAILURE;
    }
    // Get Payload data
    DayaBay::RawData* data = dataSeparator->data();
    if( !data ){
      error() << "Failed to load payload data" << endreq;
      std::stringstream message;
      record->dump( message );
      error() << message.str() << endreq;
      delete record;
      return StatusCode::FAILURE;
    }
    // Check for event data
    if( !data->isEventType() ){
      // Not event data
      std::stringstream message;
      data->dump( message );
      info() << message.str() << endreq;
      delete data;
      delete record;
      continue;
    }

    // Found event data
    event = dynamic_cast<DayaBay::RawEvent*>(data);
    if( !event ){
      error() << "Failed to read event" << endreq;
      std::stringstream message;
      data->dump( message );
      error() << message.str() << endreq;
      delete data;
      delete record;
      return StatusCode::FAILURE;
    }
  }

  nextEvent = event;
  return StatusCode::SUCCESS;
}


StatusCode DataLoaderAlg::loadEventData(DayaBay::RawEvent* event, 
                                        DayaBay::ReadoutHeader* readoutHeader)
{
  // Fill Readout 

  // Find the trigger time
  TimeStamp triggerTime;
  StatusCode sc = this->findTriggerTime(event,triggerTime);
  if(!sc.isSuccess()){
    warning() << "Failed to find trigger time for event: " << event->eventId()
              << endreq;
  }

  // Set the context
  Site::Site_t site = this->convertSite( event->siteId() );
  Context context(site,
                  SimFlag::kData,
                  triggerTime,
                  (DetectorId::DetectorId_t)(event->detectorId()));

  readoutHeader->setContext(context);
  readoutHeader->setEarliest(triggerTime);
  readoutHeader->setLatest(triggerTime);

  // Construct the readout
  DayaBay::Detector detector(this->convertSite(event->siteId()),
                             this->convertDetector(event->detectorId()));

  DayaBay::Readout* readout = 0;
  if( detector.isAD() || detector.isWaterShield() ){
    readout = new DayaBay::ReadoutPmtCrate();
  }else if( detector.detectorId() == DetectorId::kRPC){
    readout = new DayaBay::ReadoutRpcCrate();
  }else{
    error() << "Unknown detector: \"" << detector.detName() << "\","
            << " cannot make readout." << endreq;
    return StatusCode::FAILURE;
  }

  // Need to set detector for proper persistency
  readout->setDetector(detector);
  
  // Fill readout
  if(m_usePacked){
    // Packed data
    readout->setRawEvent( event->clone() );
  }

  if(m_useUnpacked){
    // Unpacked data
    sc = this->unpackEvent(event, readout);
    if( !sc.isSuccess() ){
      delete readout;
      return sc;
    }
  }
  // Add the readout to the header
  readoutHeader->setReadout( readout );
  readout->setHeader( readoutHeader );

  return StatusCode::SUCCESS;
}


StatusCode DataLoaderAlg::findTriggerTime(DayaBay::RawEvent* event, 
                                          TimeStamp& triggerTime)
{
  // Find the trigger time for this event
  if(!event){
    error() << "Cannot find time of invalid event" << endreq;
    return StatusCode::FAILURE;
  }
  // Search raw data block for trigger time
  bool foundTriggerTime = false;
  while( DayaBay::RawModule* module = event->nextModule() ){
    if( module->isLocalTriggerModule() ){
      while( DayaBay::DataFragment* fragment = module->nextDataFragment() ){
        if( fragment->isLocalTriggerData() ){
          DayaBay::LocalTriggerData* ltbData = 
            dynamic_cast<DayaBay::LocalTriggerData*>(fragment);
          if(!ltbData){
            error() << "Failed to access local trigger data fragment" << endreq;
            return StatusCode::FAILURE;
          }
          triggerTime = this->convertTriggerTime(ltbData);
          foundTriggerTime = true;
          break;
        }
        delete fragment;
      }
      if( foundTriggerTime ) break;
    }
    delete module;
  }
  event->resetModule();
  if(!foundTriggerTime)   return StatusCode::FAILURE;
  return StatusCode::SUCCESS;
}


TimeStamp DataLoaderAlg::convertTriggerTime(DayaBay::LocalTriggerData* ltbData)
{
  //Unpack Trigger time from raw LTB data block
  TimeStamp triggerTime;
  if(ltbData->isUnixTime()){
    triggerTime = TimeStamp(ltbData->unixtime(),
                            ltbData->nanosecond()+ltbData->accumulation());
  }else if(ltbData->isUtcTime()){
    // This data format provides no 'year'
    // Estimate the year from the file start time
    if(  ltbData->days()  <  this->m_utcDay ){
      // Catch case where file spans new year
      this->m_fileYear++;
    }
    triggerTime = TimeStamp(this->m_fileYear,
                            1 /*month*/,
                            ltbData->days()+1 /*day in year*/,
                            ltbData->hour(),
                            ltbData->minute(),
                            ltbData->second(),
                            ltbData->nanosecond()+ltbData->accumulation(),
                            true /*UTC*/);
    this->m_utcDay = ltbData->days();
  }else{
    // Date format from LTB Data version 0
    // The trigger times in this format have many issues; see DocDB-4635
    // Override using the file start time
    // Fix bug caused by 61s in a minute and 61m in an hour
    unsigned int seconds = ltbData->hour()*61*61 
      + ltbData->minute()*61 
      + ltbData->second();
    unsigned int hour = seconds / 3600;
    unsigned int minute = (seconds - hour*3600) / 60;
    unsigned int second = (seconds - (hour*3600 + minute*60));
    int timezoneOffset = -8*60*60; /* 8hr offset of PRC from UTC */
    triggerTime = TimeStamp(this->m_fileYear,  //ltbData->year(),
                            this->m_fileMonth, //ltbData->month(),
                            this->m_fileDay,   //ltbData->day(),
                            hour,
                            minute,
                            second,
                            (int)(ltbData->clock()*12.5) /* 80MHz clock */,
                            true /*use UTC with timezone offset*/,
                            timezoneOffset);
  }
  return triggerTime;
}

Site::Site_t DataLoaderAlg::convertSite(unsigned int daqSiteId)
{
  // Convert site definition from DAQ to Offline convention 
  switch(daqSiteId){
  case 1:
    return Site::kDayaBay;
  case 2:
    return Site::kLingAo;
  case 3:
    return Site::kFar;
  case 4:
    return Site::kMid;
  case 6:
    return Site::kSAB;
  default:
    break;
  }
  return Site::kUnknown;
}

DetectorId::DetectorId_t DataLoaderAlg::convertDetector(
                                                  unsigned int daqDetectorId)
{
  // Convert detector definition from DAQ to Offline convention 
  switch(daqDetectorId){
  case 1:
    return DetectorId::kAD1;
  case 2:
    return DetectorId::kAD2;
  case 3:
    return DetectorId::kAD3;
  case 4:
    return DetectorId::kAD4;
  case 5:
    return DetectorId::kIWS;
  case 6:
    return DetectorId::kOWS;
  case 7:
    return DetectorId::kRPC;
  default:
    break;
  }
  return DetectorId::kUnknown;
}

int DataLoaderAlg::convertBoard(unsigned int daqSlotId)
{
  return daqSlotId;
}

int DataLoaderAlg::convertConnector(unsigned int daqChannelId)
{
  return daqChannelId+1;
}

DayaBay::Trigger::TriggerType_t DataLoaderAlg::convertTriggerType(
                                            DayaBay::LocalTriggerData* ltbData,
                                            const DayaBay::Detector* detector)
{
  // Convert Online trigger type to Offline convention
  unsigned int triggerType = DayaBay::Trigger::kUnknown;
  if(ltbData->isManualTrigger())
    triggerType |= DayaBay::Trigger::kManual;
  if(ltbData->isCrossTrigger())
    triggerType |= DayaBay::Trigger::kCross;
  if(ltbData->isPeriodicTrigger())
    triggerType |= DayaBay::Trigger::kPeriodic;
  if(ltbData->isMultiplicityTrigger())
    triggerType |= DayaBay::Trigger::kMult;
  // FIXME: Need to add all Esum trigger types to offline convention
  if(ltbData->isEsumAdcTrigger())
    triggerType |= DayaBay::Trigger::kESum;
  if(ltbData->isEsumCompHighTrigger())
    triggerType |= DayaBay::Trigger::kESum;
  if(ltbData->isEsumCompLowTrigger())
    triggerType |= DayaBay::Trigger::kESum;
  if(ltbData->isEsumCompAllTrigger())
    triggerType |= DayaBay::Trigger::kESum;

  switch(detector->detectorId()){
  case DetectorId::kAD1:
    triggerType |= DayaBay::Trigger::kAD1;
    break;
  case DetectorId::kAD2:
    triggerType |= DayaBay::Trigger::kAD2;
    break;
  case DetectorId::kAD3:
    triggerType |= DayaBay::Trigger::kAD3;
    break;
  case DetectorId::kAD4:
    triggerType |= DayaBay::Trigger::kAD4;
    break;
  case DetectorId::kIWS:
    triggerType |= DayaBay::Trigger::kIWS;
    break;
  case DetectorId::kOWS:
    triggerType |= DayaBay::Trigger::kOWS;
    break;
  default:
    break;
 }

  return static_cast<DayaBay::Trigger::TriggerType_t>(triggerType);
}

DayaBay::FeeGain::FeeGain_t DataLoaderAlg::convertAdcRange(
                                                      unsigned int daqAdcRange)
{
  // Convert ADC Range definition from DAQ to Offline convention 
  switch(daqAdcRange){
  case 0:
    return DayaBay::FeeGain::kHigh;
  case 1:
    return DayaBay::FeeGain::kLow;
  default:
    break;
  }
  return DayaBay::FeeGain::kUnknown;
}


StatusCode DataLoaderAlg::unpackEvent(DayaBay::RawEvent* event, 
                                      DayaBay::Readout* readout)
{
  // Unpack raw data into readout object

  // Loop over modules
  while( DayaBay::RawModule* module = event->nextModule() ){
    StatusCode sc;
    if( module->isLocalTriggerModule() ){
      sc = this->unpackLtbModule(module, readout);
    }else if( module->isPmtFeeModule() ){
      sc = this->unpackFeeModule(module, 
                     dynamic_cast<DayaBay::ReadoutPmtCrate*>(readout));
    }else if( module->isFlashAdcModule() ){
      //sc = this->unpackFlashAdcModule(module, readout);
    }else if( module->isRpcRomModule() ){
      //sc = this->unpackRpcRomModule(module, readout);
    }else if( module->isRpcRtmModule() ){
      //sc = this->unpackRpcRomModule(module, readout);
    }else{
      warning() << "Cannot unpack unknown module type: " 
                << module->moduleType()<< endreq;
      sc = StatusCode::FAILURE;
    }
    if( !sc.isSuccess() ){
      // Gracefully continue even if there is trouble reading a module
      continue;
    }
    delete module;
  }

  return StatusCode::SUCCESS;
}

StatusCode DataLoaderAlg::unpackLtbModule(DayaBay::RawModule* module, 
                                          DayaBay::Readout* readout)
{
  // Unpack the trigger data module
  bool firstTriggerFragment = true;
  TimeStamp triggerTime;

  while( DayaBay::DataFragment* fragment = module->nextDataFragment() ){
    if( fragment->isLocalTriggerData() ){
      // Process the trigger data fragment
      DayaBay::LocalTriggerData* ltbData = 
        dynamic_cast<DayaBay::LocalTriggerData*>(fragment);
      if(!ltbData){
        warning() << "Bad Local Trigger Data fragment" << endreq;
        continue;
      }
      triggerTime = this->convertTriggerTime(ltbData);
      if(firstTriggerFragment){
        // Set trigger time, type, number according to first trigger data block
        readout->setTriggerTime( triggerTime );
        readout->setTriggerType(this->convertTriggerType(ltbData, 
                                                      &(readout->detector())));
        // Get Trigger Number from head fragment
        DayaBay::HeadFragment* headFragment = module->headFragment();
        if( headFragment ){
          readout->setTriggerNumber( headFragment->triggerNumber() );
          delete headFragment;
        }else{
          warning() << "Missing head fragment!" << endreq;
        }
        firstTriggerFragment = false;
      }else{
        if(triggerTime != readout->triggerTime()){
          TimeStamp dtTrigger( triggerTime );
          dtTrigger.Subtract( readout->triggerTime() );
          debug() << "Additional trigger at dT = " <<  dtTrigger.GetSeconds()
                  << " [s]" << endreq;
        }
      }
    }else{
      warning() << "Unknown LTB data fragment type: " << fragment->dataType() 
                << endreq;
    }
    delete fragment;
  }
  return StatusCode::SUCCESS;
}

StatusCode DataLoaderAlg::unpackFeeModule(DayaBay::RawModule* module, 
                                          DayaBay::ReadoutPmtCrate* readout)
{
  // Unpack the front-end electronics data module
  if(!readout){
    warning() << "Trying to add FEE data to a non-PMT readout"
              << endreq;
    return StatusCode::FAILURE;
  }

  while( DayaBay::DataFragment* fragment = module->nextDataFragment() ){
    if( fragment->isFeePeakData() ){
      // Process the FEE peak-finding data fragment
      DayaBay::FeePeakData* feePeakData = 
        dynamic_cast<DayaBay::FeePeakData*>(fragment);
      if(!feePeakData){
        warning() << "Bad FEE Peak-finding Data fragment" << endreq;
        continue;
      }
      // Add channel data to readout
      DayaBay::FeeChannelId channelId(
                          this->convertBoard(module->slot()),
                          this->convertConnector(feePeakData->channel()),
                          readout->detector().site(),
                          readout->detector().detectorId()); 

      DayaBay::ReadoutPmtChannel& feeChannel = readout->channel(channelId);
      if(feeChannel.channelId() != channelId){
        // New channel, initialize
        feeChannel.setChannelId(channelId);
        feeChannel.setMode(0x1); // Peak-finding
        feeChannel.setReadout(readout);
      }
      // Add hit data
      feeChannel.tdc().push_back( feePeakData->tdc() );
      feeChannel.tdcHitCount().push_back( feePeakData->tdcHitCount() );
      feeChannel.adc().push_back( feePeakData->adc() );
      feeChannel.adcRange().push_back( 
                           this->convertAdcRange(feePeakData->adcRange()) );
      feeChannel.adcCycle().push_back( feePeakData->peakCycle() );
      if( feePeakData->hasAdcPedestal() )
        feeChannel.pedestal().push_back( feePeakData->adcPedestal() ); 
    }else{
      warning() << "Unknown FEE data fragment type: " << fragment->dataType() 
                << endreq;
    }
    delete fragment;
  }
  return StatusCode::SUCCESS;
}


// Local Variables: **
// c-basic-offset:2 **
// indent-tabs-mode:nil **
// End: **

---