DetailsFromRecordSvc.cc

Go to the documentation of this file.

#include "DetailsFromRecordSvc.h"

#include "FileReadoutFormat/CalibrationParametersRecord.h"
#include "FileReadoutFormat/FileNameStrings.h"
#include "FileReadoutFormat/FileStartRecord.h"
#include "FileReadoutFormat/FileTraits.h"
#include "FileReadoutFormat/RunParametersRecord.h"

using DybDaq::CalibrationParametersRecord;
using DybDaq::FileNameStrings;
using DybDaq::FileStartRecord;
using DybDaq::FileTraits;
using DybDaq::RunParametersRecord;
using std::vector;

RunDetailsFromRecord::RunDetailsFromRecord(const RunParametersRecord& record) :
  m_record(record) {
}

RunDetailsFromRecord::~RunDetailsFromRecord() {
}

unsigned int RunDetailsFromRecord::runNumber() const {
  return m_record.runNumber();
}

const RunParametersRecord& RunDetailsFromRecord::record() const {
  return m_record;
}

const DaqRunDetails::DetectorList& RunDetailsFromRecord::detectors() const {
  return *((DetectorList*)0);
}

FileDetailsFromRecord::FileDetailsFromRecord(const FileStartRecord& record,
                                             const FileNameStrings& names) :
  m_record(record),
  m_names(names) {
}

FileDetailsFromRecord::~FileDetailsFromRecord() {
}

unsigned int FileDetailsFromRecord::fileNumber() const {
  return m_record.fileNumber();
}

std::string FileDetailsFromRecord::fileName() const {
  return m_names.fileBase() + ".data";
}

TimeStamp& FileDetailsFromRecord::whenStarted() const {
  return *((TimeStamp*)0);
}

using DayaBay::Detector;

CalibDetailsFromRecord::CalibDetailsFromRecord(const DybDaq::CalibrationParametersRecord& record) :
  m_record(record) {
}

CalibDetailsFromRecord::~CalibDetailsFromRecord() {
}

Site::Site_t CalibDetailsFromRecord::convertSite(unsigned int site) const {
  if (site == FileTraits::kCalibratingEh1) {
    return Site::kDayaBay;
  }
  if (site == FileTraits::kCalibratingEh2) {
    return Site::kLingAo;
  }
  if (site == FileTraits::kCalibratingEh3) {
    return Site::kFar;
  }
  if (site == FileTraits::kCalibratingSab) {
    return Site::kSAB;
  }
  return Site::kUnknown;
}

DetectorId::DetectorId_t CalibDetailsFromRecord::convertDetectorId(unsigned int detector) const {
  if (detector == FileTraits::kCalibratingAd1) {
    return DetectorId::kAD1;
  }
  if (detector == FileTraits::kCalibratingAd2) {
    return DetectorId::kAD2;
  }
  if (detector == FileTraits::kCalibratingAd3) {
    return DetectorId::kAD3;
  }
  if (detector == FileTraits::kCalibratingAd4) {
    return DetectorId::kAD4;
  }
  return DetectorId::kUnknown;
}

DayaBay::Calibration::SourceType::SourceType_t CalibDetailsFromRecord::convertSource(unsigned int source) const {
  if (source == FileTraits::kLedSource) {
    return DayaBay::Calibration::SourceType::kLED;
  }
  if (source == FileTraits::kAmC_Co60Source) {
    return DayaBay::Calibration::SourceType::kAmC_Co60;;
  }
  if (source == FileTraits::kGe68Source) {
    return DayaBay::Calibration::SourceType::kGe68;
  }
  return DayaBay::Calibration::SourceType::kUnknown;
}

DetectorId::DetectorId_t CalibDetailsFromRecord::detectorId() const {
  return convertDetectorId(m_record.detector());
}

Detector CalibDetailsFromRecord::adNumber() const {
  const unsigned int number = m_record.adNumber();
  return Detector(convertSite(number & 0xf0),
                  convertDetectorId(number &0x0f));
}

DayaBay::Calibration::SourceType::SourceType_t CalibDetailsFromRecord::sourceIdA() const {
  return convertSource(m_record.sourceA());
}

int CalibDetailsFromRecord::zPositionA() const {
  return m_record.zPositionA();
}

DayaBay::Calibration::SourceType::SourceType_t CalibDetailsFromRecord::sourceIdB() const {
  return convertSource(m_record.sourceB());
}

int CalibDetailsFromRecord::zPositionB() const {
  return m_record.zPositionB();
}

DayaBay::Calibration::SourceType::SourceType_t CalibDetailsFromRecord::sourceIdC() const {
  return convertSource(m_record.sourceC());
}


int CalibDetailsFromRecord::zPositionC() const {
  return m_record.zPositionC();
}

int CalibDetailsFromRecord::duration() const {
  return m_record.duration();
}

int CalibDetailsFromRecord::led1() const {
  return m_record.led1();
}

int CalibDetailsFromRecord::led2() const {
  return m_record.led2();
}

int CalibDetailsFromRecord::led1Voltage() const {
  return m_record.led1Voltage();
}

int CalibDetailsFromRecord::led2Voltage() const {
  return m_record.led2Voltage();
}

int CalibDetailsFromRecord::ledFrequency() const {
  return m_record.ledFrequency();
}

int CalibDetailsFromRecord::ledPulseSeparation() const {
  return m_record.ledPulseSeparation();
}

int CalibDetailsFromRecord::ltbMode() const {
  return m_record.ltbMode();
}

int CalibDetailsFromRecord::motorPower() const {
  return m_record.motorPower();
}

int CalibDetailsFromRecord::cameraPower() const {
  return m_record.cameraPower();
}

bool CalibDetailsFromRecord::ledFlashing() const {
    return false;
}

bool CalibDetailsFromRecord::homeA() const {
    return false;
}

bool CalibDetailsFromRecord::homeB() const {
    return false;
}

bool CalibDetailsFromRecord::homeC() const {
    return false;
}

#include "DaqReadoutSvc/IDaqReadoutSvc.h"

#include "GaudiKernel/GaudiException.h"

DetailsFromRecordSvc::DetailsFromRecordSvc(const std::string& name,
                                         ISvcLocator* svc) :
  Service(name,
          svc),
  m_daqReadoutSvc(0),
  m_lastTime(0),
  m_lastDate(0),
  m_lastFile(0),
  m_runDetails(0),
  m_fileDetails(0),
  m_calibDetails(new vector<CalibDetailsFromRecord*>())
{
}

DetailsFromRecordSvc::~DetailsFromRecordSvc() {
}

StatusCode DetailsFromRecordSvc::queryInterface(const InterfaceID& id, 
                                               void** interface) {
  if (IDaqDetailsSvc::interfaceID().versionMatch(id)) {
    // Good enough. Return this object
    *interface = dynamic_cast<IDaqDetailsSvc*>(this);
    addRef();
    return StatusCode::SUCCESS;
  }
  // Try base class
  return Service::queryInterface(id,
                                 interface);
}

StatusCode DetailsFromRecordSvc::initialize() {
  StatusCode status = Service::initialize();
  if (status.isFailure()) {
    throw GaudiException("Could not initialize super class",
                         name(),
                         status);
  }
  status = service("DaqReadoutSvc",
                   m_daqReadoutSvc);
  if (status.isFailure() ) {
    return status;
  }
  return StatusCode::SUCCESS;
}

StatusCode DetailsFromRecordSvc::finalize() {
  const vector<CalibDetailsFromRecord*>::const_iterator finished = m_calibDetails->end();
  for (vector<CalibDetailsFromRecord*>::const_iterator calib = m_calibDetails->begin();
       finished != calib;
       ++calib) {
       delete *calib;
  }
  if (0 != m_fileDetails) {
    delete m_fileDetails;
  }
  if (0 != m_runDetails) {
    delete m_runDetails;
  }
  if( 0 != m_daqReadoutSvc ) {
    m_daqReadoutSvc->release();
  }
  return Service::finalize();
}

void DetailsFromRecordSvc::flushExpiredDetails() const {
  bool recordValid = m_daqReadoutSvc->hasFileStartRecord();
  const DybDaq::FileStartRecord& record = m_daqReadoutSvc->fileStartRecord();
  if (recordValid && m_lastTime == record.time() && m_lastDate == record.date() && m_lastFile == record.fileNumber()) {
      return;
  }
  const vector<CalibDetailsFromRecord*>::const_iterator finished = m_calibDetails->end();
  for (vector<CalibDetailsFromRecord*>::const_iterator calib;
       finished != calib;
       ++calib) {
       delete *calib;
  }
  m_calibDetails->clear();
  if (0 != m_fileDetails) {
    delete m_fileDetails;
    m_fileDetails = 0;
  }
  if (0 != m_runDetails) {
    delete m_runDetails;
    m_runDetails = 0;
  }
  if (!recordValid) {
    return;
  }
  m_lastTime = record.time();
  m_lastDate = record.date();
  m_lastFile = record.fileNumber();
  if (m_daqReadoutSvc->hasRunParametersRecord()) {
    m_runDetails = new RunDetailsFromRecord(m_daqReadoutSvc->runParametersRecord());
  }
  m_fileDetails = new FileDetailsFromRecord(record,
                                            m_daqReadoutSvc->fileNameStrings());
  const int finished2 = m_daqReadoutSvc->calibrationParametersRecordCount();
  for (int calib = 0;
       finished2 != calib;
       ++calib) {
      m_calibDetails->push_back(new CalibDetailsFromRecord(m_daqReadoutSvc->calibrationParametersRecord(calib)));
  }
}

bool DetailsFromRecordSvc::hasRunDetails(const ServiceMode& /* svcMode */) const {
  flushExpiredDetails();
  return 0 != m_runDetails;
}

const DaqRunDetails& DetailsFromRecordSvc::runDetails(const ServiceMode& /* svcMode */) const {
  flushExpiredDetails();
  return *m_runDetails;
}

bool DetailsFromRecordSvc::hasFileDetails(const ServiceMode& /* svcMode */) const {
  flushExpiredDetails();
  return 0 != m_fileDetails;
}

const DaqFileDetails& DetailsFromRecordSvc::fileDetails(const ServiceMode& /* svcMode */) const {
  flushExpiredDetails();
  return *m_fileDetails;
}

int DetailsFromRecordSvc::calibDetailsCount(const ServiceMode& /* svcMode */) const {
  flushExpiredDetails();
  return m_calibDetails->size();
}

const DaqCalibDetails& DetailsFromRecordSvc::calibDetails(const int index,
                                                          const ServiceMode& /* svcMode */ ) const {
  flushExpiredDetails();
  return *(m_calibDetails->at(index));
}