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 "fhiclcpp/ParameterSet.h"

#include "lardataalg/DetectorInfo/DetectorClocks.h"

namespace detinfo{

  class DetectorClocksStandard : public DetectorClocks {

  public:
    DetectorClocksStandard();
    DetectorClocksStandard(fhicl::ParameterSet const& pset);
    DetectorClocksStandard(DetectorClocksStandard const&) = delete;
    virtual ~DetectorClocksStandard() {};
    
    bool Configure(fhicl::ParameterSet const& pset);
    bool Update(uint64_t ts=0);
    
    virtual double TriggerOffsetTPC() const override
    { 
      if (fTriggerOffsetTPC<0)
        return fTriggerOffsetTPC; 
      else
        return -fTriggerOffsetTPC/fTPCClock.Frequency(); //convert ticks to us
    }
    
    virtual double TPCTime() const override { return doTPCTime(); }
    
    void debugReport() const;
    
    std::string TrigModuleName() const { return fTrigModuleName; }
    
    void SetDefaultTriggerTime();

    virtual double G4ToElecTime(double g4_time) const override {return g4_time * 1.e-3 - fG4RefTime; }
    
    virtual double TriggerTime() const override { return fTriggerTime; }
    
    virtual double BeamGateTime() const override { return fBeamGateTime; }

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

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

    virtual void SetTriggerTime(double trig_time, double beam_time)
    { 
      fTriggerTime  = trig_time;
      fBeamGateTime = beam_time;
      fTPCClock.SetTime(trig_time);
      fOpticalClock.SetTime(trig_time);
      fTriggerClock.SetTime(trig_time);
    }

    //
    // Getters of TPC ElecClock
    //
    virtual const ::detinfo::ElecClock& TPCClock() const override
    { return fTPCClock; }

    virtual ::detinfo::ElecClock TPCClock(double time) const override
        { return ::detinfo::ElecClock(time,fTPCClock.FramePeriod(),fTPCClock.Frequency());}

    detinfo::ElecClock TPCClock(unsigned int sample,
                       unsigned int frame) const override
      { detinfo::ElecClock clock = TPCClock(); clock.SetTime(sample,frame); return clock; }
    
    //
    // Getters of Optical ElecClock
    //
    virtual const detinfo::ElecClock& OpticalClock() const override
    { return fOpticalClock; }

    virtual detinfo::ElecClock OpticalClock(double time) const override
      { return detinfo::ElecClock(time,fOpticalClock.FramePeriod(),fOpticalClock.Frequency());}

    virtual detinfo::ElecClock OpticalClock(unsigned int sample,
                           unsigned int frame) const override
    { detinfo::ElecClock clock = OpticalClock(); clock.SetTime(sample,frame); return clock; }

    //
    // Getters of Trigger ElecClock
    //
    virtual const detinfo::ElecClock& TriggerClock() const override
    { return fTriggerClock; }

    virtual detinfo::ElecClock TriggerClock(double time) const  override
    { return detinfo::ElecClock(time,fTriggerClock.FramePeriod(),fTriggerClock.Frequency());}

    virtual detinfo::ElecClock TriggerClock(unsigned int sample,
                           unsigned int frame) const override
    { detinfo::ElecClock clock = TriggerClock(); clock.SetTime(sample,frame); return clock; }

    //
    // Getters of External ElecClock
    //
    virtual const detinfo::ElecClock& ExternalClock() const override
    { return fExternalClock; }

    virtual detinfo::ElecClock ExternalClock(double time) const override
      { return detinfo::ElecClock(time,fExternalClock.FramePeriod(),fTriggerClock.Frequency());}
    
    virtual detinfo::ElecClock ExternalClock(unsigned int sample,
                                  unsigned int frame) const override
      { detinfo::ElecClock clock = ExternalClock(); clock.SetTime(sample,frame); return clock; }
    
    //
    // Getters for time [us] w.r.t. trigger given information from waveform
    //

    virtual double TPCTick2TrigTime(double tick) const override
    { return fTPCClock.TickPeriod() * tick + TriggerOffsetTPC(); }
    virtual double TPCTick2BeamTime(double tick) const override
    { return TPCTick2TrigTime(tick) + TriggerTime() - BeamGateTime(); }
    virtual double OpticalTick2TrigTime(double tick, size_t sample, size_t frame) const override
    { return fOpticalClock.TickPeriod() * tick + fOpticalClock.Time(sample,frame) - TriggerTime();  }
    virtual double OpticalTick2BeamTime(double tick, size_t sample, size_t frame) const override
    { return fOpticalClock.TickPeriod() * tick + fOpticalClock.Time(sample,frame) - BeamGateTime(); }
    virtual double ExternalTick2TrigTime(double tick, size_t sample, size_t frame) const override
    { return fExternalClock.TickPeriod() * tick + fExternalClock.Time(sample,frame) - TriggerTime(); }
    virtual double ExternalTick2BeamTime(double tick, size_t sample, size_t frame) const override
    { return fExternalClock.TickPeriod() * tick + fExternalClock.Time(sample,frame) - BeamGateTime(); }
    
    virtual double Time2Tick(double time) const override
      { return doTime2Tick(time); }
    
    //
    // Getters for time [tdc] (electronics clock counting ... in double precision) 
    //

    virtual double TPCTick2TDC(double tick) const override
    { return ( doTPCTime() / fTPCClock.TickPeriod() + tick ); }
    virtual double TPCG4Time2TDC(double g4time) const override
    { return G4ToElecTime(g4time) / fTPCClock.TickPeriod(); }
    virtual double OpticalTick2TDC(double tick, size_t sample, size_t frame) const override
    { return fOpticalClock.Ticks(sample,frame) + tick; }
    virtual double OpticalG4Time2TDC(double g4time) const override
    { return G4ToElecTime(g4time) / fOpticalClock.TickPeriod(); }
    virtual double ExternalTick2TDC(double tick, size_t sample, size_t frame) const override
    { return fExternalClock.Ticks(sample,frame) + tick; }
    virtual double ExternalG4Time2TDC(double g4time) const override
    { return G4ToElecTime(g4time) / fExternalClock.TickPeriod(); }

    //
    // Getters for time [us] (electronics clock counting ... in double precision)
    //
    virtual double TPCTick2Time(double tick) const override
    { return doTPCTime() + tick * fTPCClock.TickPeriod(); }
    virtual double OpticalTick2Time(double tick, size_t sample, size_t frame) const override
    { return fOpticalClock.Time(sample,frame) + tick * fOpticalClock.TickPeriod(); }
    virtual double ExternalTick2Time(double tick, size_t sample, size_t frame) const override
    { return fExternalClock.Time(sample,frame) + tick * fExternalClock.TickPeriod(); }

    //
    // Getters for time [ticks] (waveform index number)
    //

    virtual double TPCTDC2Tick(double tdc) const override
    { return ( tdc - doTPCTime() / fTPCClock.TickPeriod() ); }
    virtual double TPCG4Time2Tick(double g4time) const override
    { return (G4ToElecTime(g4time) - doTPCTime()) / fTPCClock.TickPeriod(); }

    bool InheritClockConfig() { return fInheritClockConfig; }
    
    void ApplyParams();

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

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

    std::vector<double>      fConfigValue;

    bool fInheritClockConfig;

    std::string fTrigModuleName;

    double fG4RefTime;

    double fFramePeriod;

    ::detinfo::ElecClock fTPCClock;

    ::detinfo::ElecClock fOpticalClock;

    ::detinfo::ElecClock fTriggerClock;

    ::detinfo::ElecClock fExternalClock;

    double fTriggerOffsetTPC;

    double fTriggerTime;

    double fBeamGateTime;
    
    double doTPCTime() const { return TriggerTime() + TriggerOffsetTPC(); }
    
    double doTime2Tick(double time) const
      { return (time - doTPCTime()) / fTPCClock.TickPeriod();  }
    
  }; // class DetectorClocksStandard

} //namespace detinfo


#endif // LARDATAALG_DETECTORINFO_DETECTORCLOCKSSTANDARD_H