TimeTagger.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "DataStreamInstrument.h"
 
namespace DynExpInstr
{
    class TimeTagger;
 
    namespace TimeTaggerTasks
    {
        class InitTask : public DataStreamInstrumentTasks::InitTask
        {
            void InitFuncImpl(dispatch_tag<DataStreamInstrumentTasks::InitTask>, DynExp::InstrumentInstance& Instance) override final;
 
            virtual void InitFuncImpl(dispatch_tag<InitTask>, DynExp::InstrumentInstance& Instance) {}
 
 
            virtual bool ApplyDataStreamSizeFromParams() const noexcept { return true; }
        };
 
        class ExitTask : public DataStreamInstrumentTasks::ExitTask
        {
            void ExitFuncImpl(dispatch_tag<DataStreamInstrumentTasks::ExitTask>, DynExp::InstrumentInstance& Instance) override final { ExitFuncImpl(dispatch_tag<ExitTask>(), Instance); }
 
            virtual void ExitFuncImpl(dispatch_tag<ExitTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class UpdateTask : public DataStreamInstrumentTasks::UpdateTask
        {
            void UpdateFuncImpl(dispatch_tag<DataStreamInstrumentTasks::UpdateTask>, DynExp::InstrumentInstance& Instance) override final { UpdateFuncImpl(dispatch_tag<UpdateTask>(), Instance); }
            
            virtual void UpdateFuncImpl(dispatch_tag<UpdateTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class ResetBufferSizeTask final : public DynExp::TaskBase
        {
        public:
            ResetBufferSizeTask(CallbackType CallbackFunc) noexcept : TaskBase(CallbackFunc) {}
 
        private:
            virtual DynExp::TaskResultType RunChild(DynExp::InstrumentInstance& Instance) override;
        };
    }
 
    class TimeTaggerData : public DataStreamInstrumentData
    {
    public:
        struct HBTResultsType
        {
            using ResultVectorType = std::vector<BasicSample>;
 
            HBTResultsType() { Reset(); }
 
            void Reset();
 
            bool Enabled;                               
            long long EventCounts;                      
            std::chrono::microseconds IntegrationTime;  
 
            ResultVectorType ResultVector;              
        };
 
        enum StreamModeType {
            Counts,     
            Events      
        };
 
        using SampleStreamType = BasicSampleStream;     
 
        TimeTaggerData(size_t BufferSizeInSamples = 1)
            : DataStreamInstrumentData(std::make_unique<SampleStreamType>(BufferSizeInSamples)),
            StreamMode(StreamModeType::Counts), StreamModeChanged(true) {}
 
        TimeTaggerData(DataStreamBasePtrType&& SampleStream)
            : DataStreamInstrumentData(std::move(SampleStream)),
            StreamMode(StreamModeType::Counts), StreamModeChanged(true) {}
 
        virtual ~TimeTaggerData() = default;
 
        auto GetStreamMode() const noexcept { return StreamMode; }                  
        void SetStreamMode(StreamModeType StreamMode) const noexcept;               
        bool GetStreamModeChanged() const noexcept { return StreamModeChanged; }    
        void ResetStreamMode() const noexcept { StreamModeChanged = true; }         
        void ClearStreamModeChanged() noexcept { StreamModeChanged = false; }       
 
        auto& GetHBTResults() const noexcept { return HBTResults; }                 
        auto& GetHBTResults() noexcept { return HBTResults; }                       
 
    private:
        void ResetImpl(dispatch_tag<DataStreamInstrumentData>) override final;
        virtual void ResetImpl(dispatch_tag<TimeTaggerData>) {};                    
    
        mutable StreamModeType StreamMode;
 
        mutable bool StreamModeChanged;
 
        HBTResultsType HBTResults;
    };
 
    class TimeTaggerParams : public DataStreamInstrumentParams
    {
    public:
        static Util::TextValueListType<TimeTaggerData::StreamModeType> StreamModeTypeStrList();
 
        TimeTaggerParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core)
            : DataStreamInstrumentParams(ID, Core), StreamSizeParams(*this) {}
 
        virtual ~TimeTaggerParams() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "TimeTaggerParams"; }
        
        StreamSizeParamsExtension StreamSizeParams;
 
        Param<TimeTaggerData::StreamModeType> StreamMode = { *this, StreamModeTypeStrList(), "StreamMode", "Stream mode",
            "Determines what to store in the sample stream of this instrument.", true, TimeTaggerData::StreamModeType::Counts };
 
    private:
        void ConfigureParamsImpl(dispatch_tag<DataStreamInstrumentParams>) override final { ConfigureParamsImpl(dispatch_tag<TimeTaggerParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<TimeTaggerParams>) {}     
    };
 
    class TimeTaggerConfigurator : public DataStreamInstrumentConfigurator
    {
    public:
        using ObjectType = TimeTagger;
        using ParamsType = TimeTaggerParams;
 
        TimeTaggerConfigurator() = default;
        virtual ~TimeTaggerConfigurator() = 0;
    };
 
    class TimeTagger : public DataStreamInstrument
    {
    public:
        using ParamsType = TimeTaggerParams;                                
        using ConfigType = TimeTaggerConfigurator;                          
        using InstrumentDataType = TimeTaggerData;                          
 
        using InitTaskType = TimeTaggerTasks::InitTask;                     
        using ExitTaskType = TimeTaggerTasks::ExitTask;                     
        using UpdateTaskType = TimeTaggerTasks::UpdateTask;                 
 
        constexpr static auto Name() noexcept { return "Time Tagger"; }     
        constexpr static auto Category() noexcept { return "I/O"; }         
 
        TimeTagger(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params)
            : DataStreamInstrument(OwnerThreadID, std::move(Params)) {}
 
        virtual ~TimeTagger() = 0;
 
        virtual std::string GetName() const override { return Name(); }
        virtual std::string GetCategory() const override { return Category(); }
 
        virtual std::chrono::milliseconds GetTaskQueueDelay() const override { return std::chrono::milliseconds(10); }
        virtual DataStreamInstrumentData::UnitType GetValueUnit() const noexcept override { return DataStreamInstrumentData::UnitType::Counts; }
 
 
        virtual double GetMinThresholdInVolts() const noexcept = 0;
 
        virtual double GetMaxThresholdInVolts() const noexcept = 0;
 
        virtual Util::picoseconds GetResolution() const = 0;
 
        virtual size_t GetBufferSize() const = 0;
 
        virtual void ResetStreamSize(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const override { MakeAndEnqueueTask<TimeTaggerTasks::ResetBufferSizeTask>(CallbackFunc); }
 
        virtual void Clear(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void ConfigureInput(bool UseRisingEdge, double ThresholdInVolts, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetExposureTime(Util::picoseconds ExposureTime, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetCoincidenceWindow(Util::picoseconds CoincidenceWindow, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetDelay(Util::picoseconds Delay, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetHBTActive(bool Enable, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void ConfigureHBT(Util::picoseconds BinWidth, size_t BinCount, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void ResetHBT(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
    private:
        void ResetImpl(dispatch_tag<DataStreamInstrument>) override final;
        virtual void ResetImpl(dispatch_tag<TimeTagger>) = 0;               
 
        virtual std::unique_ptr<DynExp::InitTaskBase> MakeInitTask() const override { return DynExp::MakeTask<TimeTaggerTasks::InitTask>(); }
        virtual std::unique_ptr<DynExp::ExitTaskBase> MakeExitTask() const override { return DynExp::MakeTask<TimeTaggerTasks::ExitTask>(); }
        virtual std::unique_ptr<DynExp::UpdateTaskBase> MakeUpdateTask() const override { return DynExp::MakeTask<TimeTaggerTasks::UpdateTask>(); }
    };
}