detector_card.h

Go to the documentation of this file.

#ifndef DETECTOR_CARD
#define DETECTOR_CARD

#include "dae2_card.h"

template <class DetCardPolicy> class DetectorCard;

class DetectorCardIntf;

struct Addmap {
        DetectorCardIntf* dc;
        unsigned long dae2add;
        unsigned long dae1add;
        int spec;                               
        int card;
        int len;
};

template <class DetCardPolicy>
struct EventModeRegister : public DAE2Register<DetCardPolicy>
{
    enum Mask 
    { 
            EventMode = (1 << 0),      
            EventSize64 = (1 << 1),      
                HeaderType = ((1<<8) + (1<<9) + (1<<10) + (1<<11)), 
                StoreVetoedData = (1 << 12),  
                AllVetosInHeader = (1 << 13) 
        };
        enum EventHeaderType
        {
                NormalEventHeader = 0x3   
        };
        EventModeRegister(DAE2Card<DetCardPolicy>* card) : DAE2Register(card, DetCardPolicy::DCEVNTMD) {  }
        int eventMode(DAEstatus& status) { return (read(status) & 0x1); }
        int eventMode(bool choice, DAEstatus& status) { return enable(choice, EventMode, status); }
        int enable32bitEvents(DAEstatus& status) { return clearBits(EventSize64, status); }
        int enable64bitEvents(DAEstatus& status) { return setBits(EventSize64, true, status); }
        int storeVetodData(bool choice, DAEstatus& status) { return enable(choice, StoreVetoedData, status); }
        int allVetoesInHeader(bool choice, DAEstatus& status) { return enable(choice, AllVetosInHeader, status); }
        unsigned setHeaderType(unsigned val, DAEstatus& status) { return (setBits((val & 0x0f) << 8, true, status)); }
        unsigned getHeaderType(DAEstatus& status) { return ((read(status) >> 8) & 0x0f); }
};

template <class DetCardPolicy>
struct DetectorCardRegisters
{
        EventModeRegister<DetCardPolicy> event_reg;
        DetectorCardRegisters(DAE2Card<DetCardPolicy>* dc) : event_reg(dc) {}
};

class DetectorCardIntf : public DAE2CardIntf, public DAEEventSource
{
        public: // len is the number of 32 bit words to write
        enum DetectorCardMode { ModeUnknown=0x0, ModeNeutronData=0x1, ModeSEData=0x2 };
        virtual int readHistogramMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status) = 0;
        virtual bool readHistogramMemoryWrapped(unsigned long start, isisU32_t* buffer, uint32_t len, DAEstatus& status) = 0;
        virtual int writeHistogramMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status) = 0;
        virtual isisU32_t sumHistogramMemory(DAEstatus& status) = 0;
        virtual int clearHistogramMemoryStart(DAEstatus& status) = 0;
        virtual bool isClearHistogramMemoryComplete(DAEstatus& status) = 0; 
        virtual int readPOSLUTMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status) = 0;
        virtual int writePOSLUTMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status) = 0;
        virtual int clearPOSLUTMemory(DAEstatus& status, unsigned long start = 0, int len = 65536) = 0;
        virtual int readTCGLUTMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status) = 0;
        virtual int writeTCGLUTMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status) = 0;
        virtual int readDescriptorTimeBinLimitRegister(isisU32_t* value, DAEstatus& status) = 0;
        virtual int writeDescriptorTimeBinLimitRegister(isisU32_t value, DAEstatus& status) = 0;
        virtual int readTCGTimeBinLimitRegister(isisU32_t* value, DAEstatus& status) = 0;
        virtual int writeTCGTimeBinLimitRegister(isisU32_t value, DAEstatus& status) = 0;
        DetectorCardIntf() { }
        virtual int getNTimeChannels(isisU32_t* ntc, DAEstatus& status) = 0;    // ntc
        virtual int setNTimeChannels(isisU32_t ntc, DAEstatus& status) = 0;     // ntc
        virtual int getSpectrumSize(isisU32_t* value, DAEstatus& status) = 0;   // ntc+1
        virtual int readSpectrum(int spec, isisU32_t* buffer, int nbuffer, DAEstatus& status) = 0; 
        virtual int readDAE1Spectrum(int dae1_spec, isisU32_t* buffer, int nbuffer, DAEstatus& status) = 0;
        virtual int readDAE1Spectra(isisU32_t* buffer, int nbuffer, const int spec_to_crpt_offset[], int spec_start, int nspec, int period, int persize, DAEstatus& status) = 0;
        virtual int setTimeChannels(isisU32_t* tcb, int ntc, DAEstatus& status) = 0;
        virtual int getTimeChannels(isisU32_t* tcb, int ntc, DAEstatus& status) = 0;
        virtual ~DetectorCardIntf() { }
        virtual int programDAE1POSLUT(int crat[], int modn[], int mpos[], 
                                        int spec[], int ndet, int nperiods, int dae1persize, DAEstatus& status) = 0;
        virtual int findDAE1Spectrum(int dae1_spectrum, DAEstatus& ) const  = 0; // returns DAE2 spectrum number for DAE1 number or NOSPECTRUM
        virtual int findDAE2Spectrum(int dae2_spectrum, DAEstatus& ) const  = 0;
        virtual const int* getDAE2SpecMap() = 0;
        virtual int readAllDAE1Spectra(isisU32_t* buffer, int nbuffer, const int spec_to_crpt_offset[], int persize, DAEstatus& status) = 0;
        virtual int programPOSLUT(int cards[], int dims[], int pos_start[], 
                int npos[], int spec[], int spec_step[], int nblocks,
                int nperiods, int dae1persize, DAEstatus& status) = 0;
        virtual int fillAddmap(Addmap* addmap, int len, DAEstatus& status) = 0;
        virtual void printStatus(std::ostream& os, DAEstatus& status) = 0;
        virtual void printSpecmap(std::ostream& os) = 0;
        virtual void printTimeChannels(std::ostream& os, int start = 0, int end = -1) = 0;
        virtual void printPOSLUT(std::ostream& os, DAEstatus& status) = 0;
        virtual int readPOSLUT(DAEstatus& status) = 0;
        virtual unsigned long memorySize()  = 0;
        virtual int loadDAE2SpecmapFromArray(int* array, int len, DAEstatus& status) = 0;
        virtual int saveDAE2SpecmapToArray(int* array, int offset, int len, DAEstatus& status) = 0;
        virtual int changePeriod(int period, DAEstatus& status) = 0;
        virtual int changeNumberOfPeriods(int nperiod, DAEstatus& status) = 0;
    virtual int setPeriodType(bool hardware_periods, bool single_daq_period, DAEstatus& status) = 0;
        virtual int enableDIMVetos(isisU16_t dim_mask, DAEstatus& status) = 0;    // set bit 0 for dim0 etc
        virtual int getDIMVetos(isisU16_t* dim_mask, DAEstatus& status) = 0;    // set bit 0 for dim0 etc
        virtual int disableDIMVetos(DAEstatus& status) = 0;
        virtual int clearVetoOccurredFlag(DAEstatus& status) = 0;
        virtual int readDIMVetoOccurredFlag(isisU16_t* dim_mask, DAEstatus& status) = 0;  // bit 0 set for dim 0 etc
    virtual int getCurrentHardwarePeriod(isisU32_t* period, DAEstatus& status) = 0;
        virtual int getTotalCounts(isisU32_t* counts, DAEstatus& status) = 0;
        virtual int clearTotalCountsRegister(DAEstatus& status) = 0;
        virtual int getFrameSyncDelay(isisU32_t* value, DAEstatus& status) = 0;
        virtual int setFrameSyncDelay(isisU32_t value, DAEstatus& status) = 0;
        virtual int fillWithTestPattern(unsigned long pattern, DAEstatus& status) = 0;
        virtual int checkTestPattern(unsigned long pattern, DAEstatus& status) = 0;
        virtual int whichVeto(std::ostream& os, DAEstatus& status) = 0;

        virtual int setEventCollectionMode(bool enable, DAEstatus& status) = 0;
//      int setEventModeOptions(bool event_size32, bool store_vetoed_events, all_vetos_in_headers, DAEstatus& status)

        virtual uint32_t getNewEvents(isisU32_t* buffer, uint32_t maxlen, uint64_t& num_unread, 
                                                        bool& run_ended, DAEstatus& status) = 0;
        virtual uint64_t nNewEventWords(DAEstatus& status) = 0;
        virtual void updateDAEEventLastRead(DAEstatus& status) = 0;
        virtual isisU32_t getLastAddressRead() = 0;
        virtual void setLastAddressRead(isisU32_t addr) = 0;
        virtual int eventSourceID() const  = 0;
        virtual int highspec() const  = 0;
        static const int NOSPECTRUM;
        static const int SPECTRUM_PLACEHOLDER;

        enum DetectorCardVeto { FrameOverflowVeto=0x1, MemoryFullVeto=0x2, FIFOLateVeto=0x4 }; // see #DAEEventHeaderInfo
        virtual int enableVeto(DetectorCardVeto veto, DAEstatus& status) = 0;
        virtual int disableVeto(DetectorCardVeto veto, DAEstatus& status) = 0;
        virtual bool isVetoEnabled(DetectorCardVeto veto, DAEstatus& status) = 0;   
        virtual bool hasVetoOccurred(DetectorCardVeto veto, DAEstatus& status) = 0; 
        virtual int printVetoStatus(std::ostream& os, bool triggered_only, DAEstatus& status) = 0;
        virtual int resetCardState(DAEstatus& status) = 0;
        virtual void setCardMode(DetectorCardMode mode) = 0;
};

template <class DetCardPolicy>
class DetectorCard : public DAE2Card<DetCardPolicy>, public DetectorCardIntf
{
public:
protected:
        unsigned long m_memsize;        
        int m_highspec;                         
        std::vector<int> m_dae1specmap;   
        std::vector<int> m_dae2specmap;   
//      int* m_dae1specmap;                     ///< dae2spec = m_dae1specmap[dae1spec]
//      int* m_dae2specmap;                     ///< dae1spec = m_dae2specmap[dae2spec]
        isisU32_t* m_poslut;            
        int m_nperiods;                         
        int m_dae1persize;                      
        int m_dae2persize;                      
        int m_hardware_periods;         
    enum DetectorCardOptions { None=0x0, HardwarePeriods=0x1, VetoLogging=0x2, TotalCounts=0x4, 
                DelayedFrameSync=0x8, EventMode=0x10, Muon32Channel=0x20 }; 
        DetectorCardMode m_mode;
    CardOptions m_options;
        CRITICAL_SECTION m_critical;
        DetectorCardRegisters<DetCardPolicy> m_reg;
        isisU16_t m_wrap_counter;   
        isisU32_t m_last_address_read;  
        typedef DetectorCard<DetCardPolicy> MyDetectorCard;

public: // len is the number of 32 bit words to write
        int readHistogramMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status);
        bool readHistogramMemoryWrapped(unsigned long start, isisU32_t* buffer, uint32_t len, DAEstatus& status);
        int writeHistogramMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status);
        isisU32_t sumHistogramMemory(DAEstatus& status);
        int clearHistogramMemoryStart(DAEstatus& status);
        bool isClearHistogramMemoryComplete(DAEstatus& status); 
        int readPOSLUTMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status);
        int writePOSLUTMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status);
        int clearPOSLUTMemory(DAEstatus& status, unsigned long start = 0, int len = 65536);
        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 readDescriptorTimeBinLimitRegister(isisU32_t* value, DAEstatus& status);
        int writeDescriptorTimeBinLimitRegister(isisU32_t value, DAEstatus& status);
        int readTCGTimeBinLimitRegister(isisU32_t* value, DAEstatus& status);
        int writeTCGTimeBinLimitRegister(isisU32_t value, DAEstatus& status);
        DetectorCard(int position, ISISVME* vme, int* specmap_array, int specmap_len, DAEstatus& status);
        virtual int getNTimeChannels(isisU32_t* ntc, DAEstatus& status);        // ntc
        virtual int setNTimeChannels(isisU32_t ntc, DAEstatus& status); // ntc
        int getSpectrumSize(isisU32_t* value, DAEstatus& status);       // ntc+1
        int readSpectrum(int spec, isisU32_t* buffer, int nbuffer, DAEstatus& status); 
        int readDAE1Spectrum(int dae1_spec, isisU32_t* buffer, int nbuffer, DAEstatus& status);
        int readDAE1Spectra(isisU32_t* buffer, int nbuffer, const int spec_to_crpt_offset[], int spec_start, int nspec, int period, int persize, DAEstatus& status);
        virtual int setTimeChannels(isisU32_t* tcb, int ntc, DAEstatus& status);
        virtual int getTimeChannels(isisU32_t* tcb, int ntc, DAEstatus& status);
        virtual ~DetectorCard();
        virtual int programDAE1POSLUT(int crat[], int modn[], int mpos[], 
                                        int spec[], int ndet, int nperiods, int dae1persize, DAEstatus& status);
        int findDAE1Spectrum(int dae1_spectrum, DAEstatus& ) const { return m_dae1specmap[dae1_spectrum]; } // returns DAE2 spectrum number for DAE1 number or NOSPECTRUM
        int findDAE2Spectrum(int dae2_spectrum, DAEstatus& ) const { return m_dae2specmap[dae2_spectrum]; }
        const int* getDAE2SpecMap() { return &(m_dae2specmap.front()); }
        int readAllDAE1Spectra(isisU32_t* buffer, int nbuffer, const int spec_to_crpt_offset[], int persize, DAEstatus& status);
        virtual int programPOSLUT(int cards[], int dims[], int pos_start[], 
                int npos[], int spec[], int spec_step[], int nblocks,
                int nperiods, int dae1persize, DAEstatus& status);
        int fillAddmap(Addmap* addmap, int len, DAEstatus& status);
        virtual void printStatus(std::ostream& os, DAEstatus& status);
        void printSpecmap(std::ostream& os);
        void printTimeChannels(std::ostream& os, int start = 0, int end = -1);
        void printPOSLUT(std::ostream& os, DAEstatus& status);
        virtual int readPOSLUT(DAEstatus& status);
        unsigned long memorySize() { return m_memsize; }
        int loadDAE2SpecmapFromArray(int* array, int len, DAEstatus& status);
        int saveDAE2SpecmapToArray(int* array, int offset, int len, DAEstatus& status);
        virtual int changePeriod(int period, DAEstatus& status);
        virtual int changeNumberOfPeriods(int nperiod, DAEstatus& status);
    virtual int setPeriodType(bool hardware_periods, bool single_daq_period, DAEstatus& status);
        int enableDIMVetos(isisU16_t dim_mask, DAEstatus& status);    // set bit 0 for dim0 etc
        int getDIMVetos(isisU16_t* dim_mask, DAEstatus& status);    // set bit 0 for dim0 etc
        int disableDIMVetos(DAEstatus& status);
        int clearVetoOccurredFlag(DAEstatus& status);
        int readDIMVetoOccurredFlag(isisU16_t* dim_mask, DAEstatus& status);  // bit 0 set for dim 0 etc
    int getCurrentHardwarePeriod(isisU32_t* period, DAEstatus& status);
        int getTotalCounts(isisU32_t* counts, DAEstatus& status);
        int clearTotalCountsRegister(DAEstatus& status);
        int getFrameSyncDelay(isisU32_t* value, DAEstatus& status);
        int setFrameSyncDelay(isisU32_t value, DAEstatus& status);
        int fillWithTestPattern(unsigned long pattern, DAEstatus& status);
        int checkTestPattern(unsigned long pattern, DAEstatus& status);
        int whichVeto(std::ostream& os, DAEstatus& status);

        int setEventCollectionMode(bool enable, DAEstatus& status);
//      int setEventModeOptions(bool event_size32, bool store_vetoed_events, all_vetos_in_headers, DAEstatus& status)

        uint32_t getNewEvents(isisU32_t* buffer, uint32_t maxlen, uint64_t& num_unread, 
                                                        bool& run_ended, DAEstatus& status);
        uint64_t nNewEventWords(DAEstatus& status);
        void updateDAEEventLastRead(DAEstatus& status);
        isisU32_t getLastAddressRead() { return m_last_address_read; }
        void setLastAddressRead(isisU32_t addr) { m_last_address_read = addr; }
        int eventSourceID() const { return position(); }
        int highspec() const { return m_highspec; }
//      static const int NOSPECTRUM;
//      static const int SPECTRUM_PLACEHOLDER;

        int enableVeto(DetectorCardVeto veto, DAEstatus& status);
        int disableVeto(DetectorCardVeto veto, DAEstatus& status);
        bool isVetoEnabled(DetectorCardVeto veto, DAEstatus& status);   
        bool hasVetoOccurred(DetectorCardVeto veto, DAEstatus& status); 
        int printVetoStatus(std::ostream& os, bool triggered_only, DAEstatus& status);
        virtual int resetCardState(DAEstatus& status);
        void setCardMode(DetectorCardMode mode);

        int position() const { return DAE2Card<DetCardPolicy>::position(); }
        std::string daeDevice() const { return DAE2Card<DetCardPolicy>::daeDevice(); }

protected:
        int printVetoStatus(DetectorCardVeto veto, std::ostream& os, bool triggered_only, DAEstatus& status);
        uint32_t getVetoMask(DetectorCardVeto veto);
        const char* getVetoName(DetectorCardVeto veto);
        int setTCGAccessRegister(isisU32_t mask, DAEstatus& status);
        int readTCGAccessRegister(isisU32_t *value, DAEstatus& status);
        int setAndClearTCGAccessRegister(isisU32_t mask, DAEstatus& status);
        int recreateDAE1Specmap(DAEstatus& status);
        int setPeriodSize(int per_size, DAEstatus& status);        // in 32 bit words 
    int setPeriodCounter(int period, DAEstatus& status); 
//      Poco::ActiveMethod<int, uint32_t, DetectorCard> flushEvents;
//      int flushEventsImpl(const uint32_t last_address_read);
//      int readEventWords(isisU32_t* buffer, uint32_t maxlen, uint32_t& num_unread, uint32_t start, uint32_t end, DAEstatus& status);
        bool isEventMode(DAEstatus& status);
        virtual int programDAE1POSLUTDataDae(DAEstatus& status);
};

#endif /* DETECTOR_CARD */