isisdae.h

Go to the documentation of this file.

/*
 *  This file contains the RIO interface that is callable from FORTRAN
 *
 *  Author:   Freddie Akeroyd
 */

#ifndef ISISDAE_H
#define ISISDAE_H

#include "isisvme_types.h"
#include "isiscrpt_types.h"
#include "event_store.h"
#include "TCPEventStreamer.h"

#include "dae2_card.h"

class ISISVME;
struct Addmap;
class DAE2EnvPeriodPolicy;
class DAE2DetCardPolicy;
class DAE3EnvPeriodPolicy;
class DAE3DetCardPolicy;
class DetectorCardIntf;
class DAE2CardIntf;
class EnvPeriodCardIntf;
class EnvironmentCardIntf;
template <class DetCardPolicy> class DetectorCard;
template <class EnvPeriodPolicy> class EnvironmentCard;
template <class EnvPeriodPolicy> class EnvPeriodCard;

class DAEProgressHandler
{
        LONG m_nfinished;
        LONG m_ntasks;

public:
        DAEProgressHandler() : m_nfinished(0), m_ntasks(0) { }

        
        void onProgress(Poco::TaskProgressNotification* pNf)
        {
                pNf->release();
        }

        void onFinished(Poco::TaskFinishedNotification* pNf)
        {
                InterlockedIncrement(&m_nfinished);
                pNf->task()->name();
                pNf->release();
        }

        void setNumTasks(long ntasks) { m_nfinished = 0; m_ntasks = ntasks; }
        long nFinished() { return m_nfinished; }
};


class ISISDAE : public ISIS::Base
{
private:
        ISISDAE() {}

public:
        enum DAEType { UnknownDAE=0, NeutronDAE2=1, MuonDAE2=2, NeutronDAE3=3, MuonDAE3=4 };
        typedef Addmap MyAddmap;

        static const char* DAEType_desc[]; // list must agree with DAEType enum
        enum PeriodType { PeriodTypeSoftware=0, PeriodTypeHardwareInternal=1, PeriodTypeHardwareExternal=2 };
        static const char* PeriodType_desc[]; // list must agree with PeriodType enum
        struct spec_map_info
        {
                DetectorCardIntf* card;
                int card_id;   
                int spec;  
                spec_map_info(DetectorCardIntf* _card, int _card_id, int _spec) : card(_card), card_id(_card_id), spec(_spec) { }
                spec_map_info() : card(NULL), card_id(-1), spec(-1) { }
        };
        typedef std::map< int, spec_map_info > dae1spec_map_t;
        typedef std::map< int, std::vector<int> > dae2spec_map_t;
        const dae1spec_map_t& getDAE1Specmap() const { return m_dae1_spec_map; } 
        const dae2spec_map_t& getDAE2Specmap() const { return m_dae2_spec_map; } 

protected:
        typedef int (EnvironmentCardIntf::*env_veto_set_func_t)(DAEstatus& status);
        typedef int (EnvPeriodCardIntf::*env_pc_veto_set_func_t)(DAEstatus& status);
        struct histogram_async_t
        {
                ISISDAE* dae;
                DetectorCardIntf* dc;
                unsigned long start;
                isisU32_t* buffer;
                int len;
                DAEstatus& status;
                histogram_async_t(ISISDAE* dae_, DetectorCardIntf* dc_, unsigned long start_, isisU32_t*buffer_,
                        int len_, DAEstatus& status_) : dae(dae_), dc(dc_), start(start_), buffer(buffer_), len(len_), status(status_) {}
        };
        struct test_async_t
        {
                ISISDAE* dae;
                DetectorCardIntf* dc;
                unsigned long pattern;
                DAEstatus& status;
                test_async_t(ISISDAE* dae_, DetectorCardIntf* dc_, unsigned long pattern_, DAEstatus& status_) : 
                        dae(dae_), dc(dc_), pattern(pattern_), status(status_) {}
        };

        struct veto_desc
        {
                const char* name;
                env_veto_set_func_t ec_enable;
                env_pc_veto_set_func_t pc_enable;
                env_veto_set_func_t ec_disable;
                env_pc_veto_set_func_t pc_disable;
        };
        static veto_desc veto_setters[];
        typedef std::vector<ISISVME*> vme_list_t;
        typedef std::vector<DetectorCardIntf*> det_list_t;
        typedef std::vector<EnvironmentCardIntf*> env_list_t;
        typedef std::vector<EnvPeriodCardIntf*> env_period_list_t;
        vme_list_t m_vme;
        det_list_t m_detCards;
        env_list_t m_envCards;
        env_period_list_t m_envPeriodCards;
        MyAddmap* m_addmap;
        dae1spec_map_t m_dae1_spec_map;
        dae2spec_map_t m_dae2_spec_map;
        EventStore m_es;
        int m_lenAddmap;
//      int m_nspectra;
//      int m_nperiod;          // number of periods
//      int m_period;           // current period number
        int m_clock_frequency;
        float m_uamp_scale;
        Poco::TaskManager m_taskmgr;
        DAEProgressHandler m_task_ph;
        int updateAddmap(DAEstatus& status);
        template <class DAEPolicy> int locateCards(ISISVME* vme, int dae_number, DAEstatus& status);
        DAEType m_dae_type;
        PeriodType m_period_mode;
        CRITICAL_SECTION m_dae_cs;
        bool m_simulate;
        bool m_event_mode;
        int waitForAsync();
        int doneAsync();
        HANDLE m_async_complete_event;
        volatile LONG m_num_async_requests;
        static DWORD __stdcall readDCHistogramThread(void* arg);
        int readDCHistogramAsync(DetectorCardIntf* dc, unsigned long start, isisU32_t* buffer, int len,  DAEstatus& dstatus);
        static DWORD __stdcall checkTestPatternThread(void* arg);
        static int daeTriggerFunc(void* arg, time_t the_secs, unsigned short the_ms, int trig_id);

public:
        ISISDAE(DAEType type, DAEstatus& status, bool endian_workaround, bool simulate);
        virtual ~ISISDAE();
        enum StopRunMode { StopRunClean, StopRunFast, StopRunDiscard };
    isis32_t open(const char* dae_name, DAEstatus& status);
    isis32_t openBackplane(const char* dae_name_bp, DAEstatus& status);
        isis32_t close(DAEstatus& status);
//      int clearPPP(DAEstatus& status);
        bool isRunning(DAEstatus& status);
        void printStatus(std::ostream& os, DAEstatus& status);
        void printAddmap(std::ostream& os, DAEstatus& status);
        void printSpectrum(int spec, std::ostream& os, DAEstatus& status);

        DetectorCardIntf* findDetectorCard(int position, DAEstatus& status);

        int readHistogramMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status);
        isisU32_t sumAllHistogramMemory(DAEstatus& status);

//      int writeHistogramMemory(unsigned long start, isisU32_t* buffer, int len);
        int clearHistogramMemory(DAEstatus& status);
//      int readPOSLUTMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status);
        int writePOSLUTMemory(int card_id, isisU32_t* buffer, int len, DAEstatus& status);
        int clearPOSLUTMemory(DAEstatus& status);
//      int readTCGLUTMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status);
//      int writeTCGLUTMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status);
        int writeHistogramMemory(int card_id, isisU32_t* buffer, int start, int len, DAEstatus& status);

        int getRawFrames(isisU32_t* value, DAEstatus& status);
        int getGoodFrames(isisU32_t* value, DAEstatus& status);

        int getRawPPPLower(isisU32_t* value, DAEstatus& status);
        int getRawPPPUpper(isisU32_t* value, DAEstatus& status);

        int getGoodPPPLower(isisU32_t* value, DAEstatus& status);
        int getGoodPPPUpper(isisU32_t* value, DAEstatus& status);

        int getRawFramesPeriod(isisU32_t* value, int period, DAEstatus& status);
        int getGoodFramesPeriod(isisU32_t* value, int period, DAEstatus& status);

        float getRawUAmpHours(DAEstatus& status);
        float getGoodUAmpHours(DAEstatus& status);

        float getRawUAmpHoursPeriod(int period, DAEstatus& status);
        float getGoodUAmpHoursPeriod(int period, DAEstatus& status);
        int getRawPPPLowerPeriod(int period, isisU32_t* value, DAEstatus& status);
        int getRawPPPUpperPeriod(int period, isisU32_t* value, DAEstatus& status);
        int getGoodPPPLowerPeriod(int period, isisU32_t* value, DAEstatus& status);
        int getGoodPPPUpperPeriod(int period, isisU32_t* value, DAEstatus& status);

        int setTimeChannels(int crat, isisU32_t* tcb, int ntc, DAEstatus& status);
        int setTimeChannels(int crat, int start[], int nbound[], int step[], int nblocks, DAEstatus& status);
        int readDAE1Spectrum(int dae1_spectrum, isisU32_t* buffer, int nbuffer, DAEstatus& status);
        int readDAE1Spectra(isisU32_t* buffer, int nbuffer, int spec_to_crpt_offset[], int spec_start, int nspec, int period, int persize, DAEstatus& status);
        int readAllDAE1Spectra(isisU32_t* buffer, int nbuffer, int spec_to_crpt_offset[], int persize, DAEstatus& status);
        int programDAE1POSLUT(int crat[], int maxcrate, int modn[], 
                                                                int mpos[], int spec[], int ndet, 
                                                                int nper_daq, DAEstatus& status);
        int programPOSLUT(int cards[], int dims[], int pos_start[], 
                        int npos[], int spec[], int spec_step[], 
                        int nblocks, DAEstatus& status);
        int startRun(bool clear_counters, int run_number, time_t& start_time, DAEstatus& status);
        int stopRun(StopRunMode mode, DAEstatus& status);
        int changePeriod(int period, int daq_period, DAEstatus& status);
        int changeNumberOfPeriods(int nperiod, DAEstatus& status);
        int resetRunController(DAEstatus& status);
        int setDAE1Vetos(int vetos[], int n, DAEstatus& status);
//      int addTimeChannels(int offset_chan, int start, int nchan, int step, DAEstatus& status);
        int setFrameSync(FrameSync fs, int muon_pulse, DAEstatus& status);
        int setFrameSyncDelay(isisU32_t delay, DAEstatus& status);      // in us
        int getFrameSyncDelay(isisU32_t* delay, DAEstatus& status);     // in us
        int setDCFrameSyncDelay(int crat, isisU32_t delay, DAEstatus& status);  // in us
        int getDCFrameSyncDelay(int crat, isisU32_t* delay, DAEstatus& status); // in us
        int setPeriodType(ISISDAE::PeriodType type, bool single_daq_period, DAEstatus& status); 
    int getCurrentHardwarePeriod(isisU32_t *period, DAEstatus& status);
        int getCurrentDAQHardwarePeriod(isisU32_t *period, DAEstatus& status);
        int getCurrentPeriodSequence(isisU32_t *period_sequence, DAEstatus& status);
        int getSMPVetoedFrames(isisU32_t* value, DAEstatus& status);
        int getExternalVetoedFrames(int veto_number, isisU32_t* value, DAEstatus& status);
        int getFIFOVetoedFrames(isisU32_t* value, DAEstatus& status);
        int getTS2PulseVetoedFrames(isisU32_t* value, DAEstatus& status);
        int getISIS50HzVetoedFrames(isisU32_t* value, DAEstatus& status);
        int getMSModeVetoedFrames(isisU32_t* value, DAEstatus& status);
        int getTotalCounts(int64_t* value, DAEstatus& status);
        int programPeriodCard(PeriodType period_type, int nper, int nperseq_request, isisU32_t* outputs, isisU16_t *dwell_flags, isisU16_t *frames,
                                                         int period_output_delay, DAEstatus& status);
        int disablePeriodCard(DAEstatus& status);
        bool isMultiplePeriodSequenceComplete(DAEstatus& status);
        template <class DAECardPolicy> int VMEWriteValue(unsigned long card_id, unsigned long card_address, bool sixteen_bit, unsigned long value, unsigned long mode, DAEstatus& status);
        template <class DAECardPolicy> int VMEReadValue(unsigned long card_id, unsigned long card_address, bool sixteen_bit, unsigned long *value, DAEstatus& status);
        template <class DAECardPolicy> int VMEWriteArray(unsigned long card_id, unsigned long card_address, isisU32_t* values, unsigned long num_values, DAEstatus& status);
        template <class DAECardPolicy> int VMEReadArray(unsigned long card_id, unsigned long card_address, isisU32_t* values, unsigned long num_values, DAEstatus& status);
        int clearCounters(DAEstatus& status);
        int clearCounters(int run_number, DAEstatus& status);
        int fillWithTestPattern(unsigned long pattern, DAEstatus& status);
        int checkTestPattern(unsigned long pattern, DAEstatus& status);
        int checkTestPatternAsync(unsigned long pattern, DAEstatus& status);
        int getVetoStatus(std::string& veto_text, DAEstatus& status);
        int whichVeto(std::string& veto_text, DAEstatus& status);
        int setVeto(const std::string& name, bool enable, DAEstatus& status);
        void setUAmpScale(float scale) { m_uamp_scale = scale; }
        int enableDelayedStart(DAEstatus& status);
        int disableDelayedStart(DAEstatus& status);

        void setEventMode(bool value) { m_event_mode = value; }
//      bool isEventMode() const { return m_event_mode; }
        void clearDCEventMode(DAEstatus& status);
        void setDCEventMode(unsigned long card_id, bool value, DAEstatus& status);
        void setDCCardMode(unsigned long card_id, bool neutron_data, DAEstatus& status);

        isis32_t check(DAEstatus& status);

        int requestEndRunAfterNextSequenceCompletes(DAEstatus& status);
        bool isFinalSequenceComplete(DAEstatus& status);

        std::list<boost::signals2::connection> addGoodEventCallback(const EventCallbackSlotType& slot)
        {
                return m_es.addGoodEventCallback(slot);
        }
        std::list<boost::signals2::connection> addAllEventCallback(const EventCallbackSlotType& slot) 
        {
                return m_es.addAllEventCallback(slot);
        }
        std::list<boost::signals2::connection> addGoodFrameCallback(const FrameCallbackSlotType& slot)
        {
                return m_es.addGoodFrameCallback(slot);
        }
        std::list<boost::signals2::connection> addAllFrameCallback(const FrameCallbackSlotType& slot) 
        {
                return m_es.addAllFrameCallback(slot);
        }
        std::list<boost::signals2::connection> addNoFrameCallback(const NoFrameCallbackSlotType& slot) 
        {
                return m_es.addNoFrameCallback(slot);
        }
        void clearCallbacks(const std::list<boost::signals2::connection>& callback_list) 
        {
                m_es.clearCallbacks(callback_list);
        }
        void getEventSourceIDs(std::vector<int>& ids)
        {
                m_es.getEventSourceIDs(ids);
        }
        void getEnabledEventSourceIDs(std::vector<int>& ids)
        {
                m_es.getEnabledEventSourceIDs(ids);
        }

        double frameTimerDrift(DAEstatus& status); // icp - dae
        void closeEventFiles(DAEstatus& status);
        int getExternalResetCommands(std::list< std::pair<std::string,std::string> >& commands, DAEstatus& status);

        void startEventBroadcaster(const CRPTProxy& crpt) { new TCPEventStreamer(m_es, crpt); }

protected:
        int clearFramesVetosAndPPP(DAEstatus& status);
        int clearTotalCountsRegisters(DAEstatus& status);
        int readDescriptorTimeBinLimitRegister(int det_card, isisU32_t* value, DAEstatus& status);
        int writeDescriptorTimeBinLimitRegister(int det_card, isisU32_t value, DAEstatus& status);
        int readTCGTimeBinLimitRegister(int det_card, isisU32_t* value, DAEstatus& status);
        int writeTCGTimeBinLimitRegister(int det_card, isisU32_t value, DAEstatus& status);
        DetectorCardIntf* getDCForSpectrum(int spec) const;
        int getDCSpecForSpectrum(int spec) const;
        void getDCSpecInfoForSpectrum(int spec, spec_map_info& info) const;
        int getNTimeChannels(int spectrum, isisU32_t* ntc, DAEstatus& status);
        int getSpectrumSize(int spectrum, isisU32_t* nchan, DAEstatus& status);
        int getTimeChannels(int spec, isisU32_t* tcb, int ntc, DAEstatus& status);
        int getTimeChannels(int spec, double* tcb, int ntc, DAEstatus& status);
};

inline DetectorCardIntf* ISISDAE::getDCForSpectrum(int spec) const
{
        dae1spec_map_t::const_iterator it = m_dae1_spec_map.find(spec);
        return (it != m_dae1_spec_map.end() ? it->second.card : NULL);
}

inline int ISISDAE::getDCSpecForSpectrum(int spec) const
{
        dae1spec_map_t::const_iterator it = m_dae1_spec_map.find(spec);
        return (it != m_dae1_spec_map.end() ? it->second.spec : -1);
}

inline void ISISDAE::getDCSpecInfoForSpectrum(int spec, spec_map_info& info) const
{
        dae1spec_map_t::const_iterator it = m_dae1_spec_map.find(spec);
        if (it != m_dae1_spec_map.end())
        {
                info = it->second;
        }
        else
        {
                info.card = NULL;
                info.spec = -1;
        }
}

#endif /* ISISDAE_H */