DetectorClocksStandard.h

Go to the documentation of this file.

//
// DetectorClocks.h
//
//     This class provides electronics various electronics clocks. Currently supports
//     three types of clocks: TPC, Optical, and Trigger in order to support the
//     MicroBooNE experiment.
//
//     Formally known as TimeService.
//

#ifndef LARDATAALG_DETECTORINFO_DETECTORCLOCKSSTANDARD_H
#define LARDATAALG_DETECTORINFO_DETECTORCLOCKSSTANDARD_H

#include <stddef.h>
#include <string>
#include <vector>

#include "fhiclcpp/fwd.h"
#include "lardataalg/DetectorInfo/DetectorClocks.h"
#include "lardataalg/DetectorInfo/DetectorClocksStandardTriggerLoader.h"
#include "lardataalg/DetectorInfo/ElecClock.h"

namespace detinfo {

  class DetectorClocksStandard final : public DetectorClocks {
  public:
    DetectorClocksStandard(fhicl::ParameterSet const& pset);
    DetectorClocksStandard(DetectorClocksStandard const&) = delete;

    void SetConfigValue(size_t i, double val) { fConfigValue[i] = val; }

    std::string const& TrigModuleName() const { return fTrigModuleName; }

    std::string G4RefCorrTrigModuleName() const { return fG4RefCorrTrigModuleName; }

    std::vector<std::string> const& ConfigNames() const override { return fConfigName; }
    std::vector<double> const& ConfigValues() const override { return fConfigValue; }

    DetectorClocksData DataForJob() const override
    {
      return DetectorClocksData{
        fConfigValue[kG4RefTime], // FIXME: Should be run-dependent?
        fTriggerOffsetTPC,
        fTriggerTime,
        fBeamGateTime,
        ElecClock{fTriggerTime, fConfigValue[kFramePeriod], fConfigValue[kClockSpeedTPC]},
        ElecClock{fTriggerTime, fConfigValue[kFramePeriod], fConfigValue[kClockSpeedOptical]},
        ElecClock{fTriggerTime, fConfigValue[kFramePeriod], fConfigValue[kClockSpeedTrigger]},
        ElecClock{0, kDEFAULT_FRAME_PERIOD, kDEFAULT_FREQUENCY_EXTERNAL}};
    }

    DetectorClocksData DataFor(double const g4_ref_time,
                               double const trigger_time,
                               double const beam_time) const override
    {
      return DetectorClocksData{
        g4_ref_time,
        fTriggerOffsetTPC,
        trigger_time,
        beam_time,
        ElecClock{trigger_time, fConfigValue[kFramePeriod], fConfigValue[kClockSpeedTPC]},
        ElecClock{trigger_time, fConfigValue[kFramePeriod], fConfigValue[kClockSpeedOptical]},
        ElecClock{trigger_time, fConfigValue[kFramePeriod], fConfigValue[kClockSpeedTrigger]},
        ElecClock{0, kDEFAULT_FRAME_PERIOD, kDEFAULT_FREQUENCY_EXTERNAL}};
    }

    void ApplyParams();

    bool IsRightConfig(const fhicl::ParameterSet& ps) const;

    void debugReport() const;

  private:
    void SetTriggerTime(double const trig_time, double const beam_time)
    {
      fTriggerTime = trig_time;
      fBeamGateTime = beam_time;
      fTPCClock = ElecClock{fTriggerTime, fFramePeriod, fConfigValue[kClockSpeedTPC]};
    }

    double TriggerOffsetTPC() const
    {
      if (fTriggerOffsetTPC < 0)
        return fTriggerOffsetTPC;
      else
        return -fTriggerOffsetTPC / fTPCClock.Frequency(); // convert ticks to
                                                           // us
    }

    std::vector<std::string> fConfigName;
    std::vector<double> fConfigValue;

    std::string fTrigModuleName;
    std::string fG4RefCorrTrigModuleName;

    double fTriggerOffsetTPC;

    double fTriggerTime;

    double fBeamGateTime;

    double fFramePeriod;

    ElecClock fTPCClock;
  }; // class DetectorClocksStandard

} // namespace detinfo

#endif // LARDATAALG_DETECTORINFO_DETECTORCLOCKSSTANDARD_H