Laser.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "Instrument.h"
 
namespace DynExpInstr
{
    class Laser;
 
    namespace LaserTasks
    {
        class InitTask : public DynExp::InitTaskBase
        {
            void InitFuncImpl(dispatch_tag<InitTaskBase>, DynExp::InstrumentInstance& Instance) override final { InitFuncImpl(dispatch_tag<InitTask>(), Instance); }
 
            virtual void InitFuncImpl(dispatch_tag<InitTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class ExitTask : public DynExp::ExitTaskBase
        {
            void ExitFuncImpl(dispatch_tag<ExitTaskBase>, DynExp::InstrumentInstance& Instance) override final { ExitFuncImpl(dispatch_tag<ExitTask>(), Instance); }
 
            virtual void ExitFuncImpl(dispatch_tag<ExitTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class UpdateTask : public DynExp::UpdateTaskBase
        {
            void UpdateFuncImpl(dispatch_tag<UpdateTaskBase>, DynExp::InstrumentInstance& Instance) override final { UpdateFuncImpl(dispatch_tag<UpdateTask>(), Instance); }
 
            virtual void UpdateFuncImpl(dispatch_tag<UpdateTask>, DynExp::InstrumentInstance& Instance) {}
        };
    }
 
    class LaserData : public DynExp::InstrumentDataBase
    {
    public:
        enum class FrequencyUnitType {
            Hz,         
            nm,         
        };
 
        enum class IntensityUnitType {
            Power_W     
        };
        
        static const char* FrequencyUnitTypeToStr(const FrequencyUnitType& Unit);
 
        static const char* IntensityUnitTypeToStr(const IntensityUnitType& Unit);
 
        enum class LaserStateType {
            Startup,                    
            Ready,                      
            EmissionEnabledConstant,    
            EmissionEnabledScanning,    
            Error,                      
        };
 
        LaserData() = default;
        virtual ~LaserData() = default;
 
        void SetFrequencyValue(double Frequency) noexcept { this->Frequency = Frequency; }              
        auto GetFrequencyValue() const noexcept { return Frequency; }                                   
        void SetIntensityValue(double Intensity) noexcept { this->Intensity = Intensity; }              
        auto GetIntensityValue() const noexcept { return Intensity; }                                   
        void SetScanRangeValue(double ScanRange) noexcept { this->ScanRange = ScanRange; }              
        auto GetScanRangeValue() const noexcept { return ScanRange; }                                   
        void SetScanRateValue(double ScanRate) noexcept { this->ScanRate = ScanRate; }                  
        auto GetScanRateValue() const noexcept { return ScanRate; }                                     
 
        auto GetLaserState() const noexcept { return GetLaserStateChild(); }
        
    private:
        void ResetImpl(dispatch_tag<InstrumentDataBase>) override final;
        virtual void ResetImpl(dispatch_tag<LaserData>) {};                 
 
        virtual LaserStateType GetLaserStateChild() const noexcept = 0;     
 
        double Frequency = 0.0;             
        double Intensity = 0.0;             
        double ScanRange = 0.0;             
        double ScanRate = 0.0;              
    };
 
    class LaserParams : public DynExp::InstrumentParamsBase
    {
    public:
        LaserParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core) : InstrumentParamsBase(ID, Core) {}
 
        virtual ~LaserParams() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "LaserParams"; }
 
    private:
        void ConfigureParamsImpl(dispatch_tag<InstrumentParamsBase>) override final { ConfigureParamsImpl(dispatch_tag<LaserParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<LaserParams>) {}          
 
        DummyParam Dummy = { *this };                                           
    };
 
    class LaserConfigurator : public DynExp::InstrumentConfiguratorBase
    {
    public:
        using ObjectType = Laser;
        using ParamsType = LaserParams;
 
        LaserConfigurator() = default;
        virtual ~LaserConfigurator() = 0;
    };
 
    class Laser : public DynExp::InstrumentBase
    {
    public:
        using ParamsType = LaserParams;                                     
        using ConfigType = LaserConfigurator;                               
        using InstrumentDataType = LaserData;                               
 
        using InitTaskType = LaserTasks::InitTask;                          
        using ExitTaskType = LaserTasks::ExitTask;                          
        using UpdateTaskType = LaserTasks::UpdateTask;                      
 
        constexpr static auto Name() noexcept { return "Laser"; }           
        constexpr static auto Category() noexcept { return "I/O"; }         
 
        Laser(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params)
            : InstrumentBase(OwnerThreadID, std::move(Params)) {}
 
        virtual ~Laser() = 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(50); }
 
 
        virtual LaserData::FrequencyUnitType GetFrequencyUnit() const = 0;
        
        virtual LaserData::IntensityUnitType GetIntensityUnit() const = 0;
 
        virtual double GetMinFrequency() const { return GetMaxFrequency(); }
 
        virtual double GetMaxFrequency() const = 0;
 
        virtual double GetMinIntensity() const { return GetMaxIntensity(); }
 
        virtual double GetMaxIntensity() const = 0;
 
        virtual double GetMinScanRange() const { return 0.0; }
 
        virtual double GetMaxScanRange() const { return 0.0; }
 
        virtual double GetMinScanRate() const { return 0.0; }
 
        virtual double GetMaxScanRate() const { return 0.0; }
 
        virtual double GetModeHopFreeTuningRange() const { return 0.0; }
 
 
        virtual void SetFrequency(double Frequency, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void SetIntensity(double Intensity, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void SetScanRange(double ScanRange, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void SetScanRate(double ScanRate, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void Enable(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void Disable(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void ScanContinuously(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void DisableScan(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
    private:
        void ResetImpl(dispatch_tag<InstrumentBase>) override final;
        virtual void ResetImpl(dispatch_tag<Laser>) = 0;            
    };
}