LockinAmplifier.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 LockinAmplifier;
 
    namespace LockinAmplifierDefs
    {
        enum TriggerModeType {
            UnknownMode,    
            Continuous,     
            ExternSingle    
        };
 
        enum TriggerEdgeType {
            UnknownEdge,    
            Rise,           
            Fall            
        };
 
        enum SignalType {
            X,              
            Y,              
            R,              
            Theta           
        };
 
        struct LockinResultCartesian
        {
            using DataType = double;    
 
            constexpr LockinResultCartesian() noexcept = default;
 
            constexpr LockinResultCartesian(DataType X, DataType Y) noexcept : X(X), Y(Y) {}
 
            DataType X{};               
            DataType Y{};               
        };
 
        struct LockinResultPolar
        {
            using DataType = double;    
 
            constexpr LockinResultPolar() noexcept = default;
 
            constexpr LockinResultPolar(DataType R, DataType Theta) noexcept : R(R), Theta(Theta) {}
 
            DataType R{};               
            DataType Theta{};           
        };
 
        struct LockinSample
        {
            using DataType = double;    
 
            constexpr LockinSample() noexcept = default;
 
            LockinSample(uint8_t Channel, DataType Time, LockinResultCartesian CartesianResult) noexcept;
 
            LockinSample(uint8_t Channel, DataType Time, LockinResultPolar PolarResult) noexcept;
 
            constexpr LockinSample(uint8_t Channel, DataType Time, LockinResultCartesian CartesianResult, LockinResultPolar PolarResult) noexcept;
 
            void UpdatePolar() noexcept;
 
            void UpdateCartesian() noexcept;
 
            DataType GetDisambiguatedValue(SignalType Signal) const noexcept;
 
            uint8_t Channel{};          
 
            LockinResultCartesian CartesianResult{};    
            LockinResultPolar PolarResult{};            
 
            DataType Time{};            
        };
    }
 
    namespace LockinAmplifierTasks
    {
        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) {}
        };
 
        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 LockinAmplifierData : public DataStreamInstrumentData
    {
    public:
        using SampleStreamType = BasicSampleStream;     
 
        LockinAmplifierData(size_t BufferSizeInSamples) : DataStreamInstrumentData(std::make_unique<SampleStreamType>(BufferSizeInSamples)) {}
 
        virtual ~LockinAmplifierData() = default;
 
        virtual double GetSensitivity() const noexcept = 0;             
        virtual void SetSensitivity(double Sensitivity) noexcept = 0;   
        virtual double GetPhase() const noexcept = 0;                   
        virtual void SetPhase(double Phase) noexcept = 0;               
        virtual double GetTimeConstant() const noexcept = 0;            
        virtual void SetTimeConstant(double TimeConstant) noexcept = 0; 
        virtual uint8_t GetFilterOrder() const noexcept { return 0; }   
        virtual void SetFilterOrder(uint8_t FilterOrder) noexcept {}    
 
        virtual LockinAmplifierDefs::TriggerModeType GetTriggerMode() const noexcept { return LockinAmplifierDefs::TriggerModeType::UnknownMode; }
 
        virtual void SetTriggerMode(LockinAmplifierDefs::TriggerModeType TriggerMode) noexcept {}
 
        virtual LockinAmplifierDefs::TriggerEdgeType GetTriggerEdge() const noexcept { return LockinAmplifierDefs::TriggerEdgeType::UnknownEdge; }
 
        virtual void SetTriggerEdge(LockinAmplifierDefs::TriggerEdgeType TriggerEdge) noexcept {}
 
        virtual LockinAmplifierDefs::SignalType GetSignalType() const noexcept = 0;
 
        virtual void SetSignalType(LockinAmplifierDefs::SignalType SignalType) noexcept = 0;
 
        virtual double GetSamplingRate() const noexcept { return 0; }   
        virtual void SetSamplingRate(double SamplingRate) noexcept {}   
        virtual bool IsEnabled() const noexcept { return true; }        
        virtual void SetEnable(uint8_t Enable) noexcept {}              
 
        virtual bool IsOverloaded() const noexcept { return false; }
 
        virtual std::pair<double, double> GetInputLoad() const noexcept { return std::make_pair(-1, -1); }
        
        virtual double GetOscillatorFrequency() const noexcept { return 0; }
 
        virtual double GetAcquisitionProgress() const noexcept { return -1; }
 
        double GetAcquisitionTime() const;
 
    private:
        void ResetImpl(dispatch_tag<DataStreamInstrumentData>) override final;
        virtual void ResetImpl(dispatch_tag<LockinAmplifierData>) {};           
    };
 
    class LockinAmplifierParams : public DataStreamInstrumentParams
    {
    public:
        enum AutoApplyParamsType {
            DoNotApply,     
            AutoApply       
        };
 
        static Util::TextValueListType<AutoApplyParamsType> AutoApplyParamsTypeStrList();
 
        LockinAmplifierParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core) : DataStreamInstrumentParams(ID, Core) {}
 
        virtual ~LockinAmplifierParams() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "LockinAmplifierParams"; }
 
        Param<AutoApplyParamsType> AutoApplyParams = { *this, AutoApplyParamsTypeStrList(), "AutoApplyParams", "Auto apply parameters",
            "Determines whether the parameters saved to the instrument are applied automatically on instrument initialization", false, AutoApplyParamsType::DoNotApply };
 
        Param<double> Sensitivity{ *this, "Sensitivity", 1, 0 };
 
        Param<double> Phase{ *this, "Phase", 0, 0, 2.0 * std::numbers::pi };
 
        Param<double> TimeConstant{ *this, "TimeConstant", 1e-3, 0 };
 
        Param<unsigned int> FilterOrder{ *this, "FilterOrder", 1, 1, 10 };
 
        Param<LockinAmplifierDefs::TriggerModeType> TriggerMode{ *this, "TriggerMode", LockinAmplifierDefs::TriggerModeType::ExternSingle };
 
        Param<LockinAmplifierDefs::TriggerEdgeType> TriggerEdge{ *this, "TriggerEdge", LockinAmplifierDefs::TriggerEdgeType::Fall };
 
        Param<LockinAmplifierDefs::SignalType> Signal{ *this, "Signal", LockinAmplifierDefs::SignalType::R };
 
        Param<double> SamplingRate{ *this, "SamplingRate", 1000, 1 };
 
        Param<bool> Enable{ *this, "Enable", false };
 
    private:
        void ConfigureParamsImpl(dispatch_tag<DataStreamInstrumentParams>) override final { ConfigureParamsImpl(dispatch_tag<LockinAmplifierParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<LockinAmplifierParams>) {}    
    };
 
    class LockinAmplifierConfigurator : public DataStreamInstrumentConfigurator
    {
    public:
        using ObjectType = LockinAmplifier;
        using ParamsType = LockinAmplifierParams;
 
        LockinAmplifierConfigurator() = default;
        virtual ~LockinAmplifierConfigurator() = 0;
    };
 
    class LockinAmplifier : public DataStreamInstrument
    {
    public:
        using ParamsType = LockinAmplifierParams;                               
        using ConfigType = LockinAmplifierConfigurator;                         
        using InstrumentDataType = LockinAmplifierData;                         
 
        using InitTaskType = LockinAmplifierTasks::InitTask;                    
        using ExitTaskType = LockinAmplifierTasks::ExitTask;                    
        using UpdateTaskType = LockinAmplifierTasks::UpdateTask;                
 
        constexpr static auto Name() noexcept { return "Lock-in Amplifier"; }   
        constexpr static auto Category() noexcept { return "I/O"; }             
 
        LockinAmplifier(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params)
            : DataStreamInstrument(OwnerThreadID, std::move(Params)) {}
 
        virtual ~LockinAmplifier() = 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(100); }
 
 
        virtual const char* GetSensitivityUnitString() const noexcept = 0;
 
        void PersistDataToParams() const;
 
        void ApplyFromParams() const;
 
 
        virtual void SetSensitivity(double Sensitivity, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void AutoAdjustSensitivity(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetPhase(double Phase, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void AutoAdjustPhase(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetTimeConstant(double TimeConstant, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void SetFilterOrder(uint8_t FilterOrder, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetTriggerMode(LockinAmplifierDefs::TriggerModeType TriggerMode, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetTriggerEdge(LockinAmplifierDefs::TriggerEdgeType TriggerEdge, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetSignalType(LockinAmplifierDefs::SignalType SignalType, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void SetSamplingRate(double SamplingRate, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetEnable(bool Enable, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void ForceTrigger(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
    private:
        void ResetImpl(dispatch_tag<DataStreamInstrument>) override final;
        virtual void ResetImpl(dispatch_tag<LockinAmplifier>) = 0;              
 
 
        virtual void PersistDataToParamsImpl(dispatch_tag<LockinAmplifier>) const {};
 
        virtual void ApplyFromParamsImpl(dispatch_tag<LockinAmplifier>) const = 0;
 
        virtual std::unique_ptr<DynExp::InitTaskBase> MakeInitTask() const override { return DynExp::MakeTask<LockinAmplifierTasks::InitTask>(); }
        virtual std::unique_ptr<DynExp::ExitTaskBase> MakeExitTask() const override { return DynExp::MakeTask<LockinAmplifierTasks::ExitTask>(); }
        virtual std::unique_ptr<DynExp::UpdateTaskBase> MakeUpdateTask() const override { return DynExp::MakeTask<LockinAmplifierTasks::UpdateTask>(); }
    };
}