NeXusEventCallback.h

Go to the documentation of this file.

#ifndef NeXusEventCallback_H
#define NeXusEventCallback_H

#include "nexuswriter.h"

typedef std::map< std::string,std::vector<int> > int_map_t;
typedef std::map< std::string,std::vector<uint32_t> > uint_map_t;
typedef std::map< std::string,std::vector<float> > float_map_t;

class NeXusEventCallback;

struct NeXusWorkerData
{
        NeXusEventCallback* object;
        Poco::Event& ev;
        const DAEEventHeader* head;
        int event_source_id;
        int nev; 
        const int_map_t& event_id; 
        const float_map_t& event_time_offset;
        NeXusWorkerData(NeXusEventCallback* object_, Poco::Event& ev_, const DAEEventHeader* head_, int event_source_id_, int nev_, const int_map_t& event_id_, const float_map_t& event_time_offset_) :
                object(object_), ev(ev_), head(head_), event_source_id(event_source_id_), nev(nev_), event_id(event_id_), event_time_offset(event_time_offset_) { }
};

class NeXusWorker : public GenericWorker<NeXusWorkerData>
{
public:
        virtual void doWork(NeXusWorkerData* data);
        NeXusWorker(Poco::NotificationQueue& queue) : GenericWorker<NeXusWorkerData>(queue) { }
};

class NeXusEventCallback : public ISIS::Base
{
        friend class NeXusWorker;
public:
        NeXusEventCallback(const ISISCRPT_STRUCT* crpt, IXNeXusFile* file, const std::vector<int>& ev_source_ids);
        void allEventCallback(const DAEEventHeader* head, const DetectorEvent32* det_ev, int n, int event_source_id, const int* mapping);
        void allFrameCallback(const DAEEventHeader* head, int event_source_id);
        void noFrameCallbackEnd(bool end_present, NoFrameCallbackMode mode, int event_source_id);
        void noFrameCallbackNull(bool end_present, NoFrameCallbackMode mode, int event_source_id);
        void finish();
        void flush();
        ~NeXusEventCallback();
        void createEmptyFileStructure();
        static float getTimeOffset(const ISISCRPT_STRUCT* crpt, const DetectorEvent32* det_ev, int event_source_id, int tr, int i);

private:
        Poco::NotificationQueue m_queue;
        NeXusWorker m_worker;
        Poco::Thread m_worker_thread;

        uint_map_t m_se_uint_values;
        float_map_t m_se_float_values;
        float_map_t m_se_times;

        uint64_t m_good_uamph_sum;
        uint64_t m_raw_uamph_sum;
        uint64_t m_good_events_sum;
        uint64_t m_raw_events_sum;

        static const int INVALID_FRAME_MARKER;

        void close();
        Poco::MemoryPool m_mempool;
        std::string m_entry_name;
        static const int m_nexus_chunk_length;  
        template<typename T>
        class myallocator
        {
                public:
                        typedef boost::pool_allocator<T,boost::default_user_allocator_new_delete,boost::details::pool::default_mutex,100000> alloc;
        };
//      typedef std::map< std::string,std::vector<int,myallocator<int>::alloc> > int_map_t;
//      typedef std::map< std::string,std::vector<float,myallocator<float>::alloc> > float_map_t;
        SimpleStore<int_map_t> m_int_map_store;
        SimpleStore<float_map_t> m_float_map_store;
        static Poco::Mutex m_frame_callback_mutex;
        static Poco::Mutex m_event_write_mutex;
        static Poco::Condition m_event_write_cond;
        const ISISCRPT_STRUCT* m_crpt;
        IXNeXusFile* m_file;
        typedef std::map< std::string, std::vector<IXNeXusFile*> > det_file_t;
        det_file_t m_det_file;

        int m_current_frame;   
        int m_current_period;       
        int m_is_vetoing;           

        int m_good_frames;
        int m_raw_frames;
        LONG m_discarded_events;    
        LONGLONG m_monitor_events_not_saved;    
        std::vector<float> m_frame_time;
        std::vector<float> m_frame_proton_charge;
        std::map<int,uint32_t> m_frame_events_raw;
        std::vector<int> m_frame_number;
        std::vector<int> m_frame_period;
        std::vector<int> m_good_frame;
//      std::map<int,int> m_first_data_frame;
        NXlogWriter<int> m_period;
        NXlogWriter<int> m_vetoing;    // 1 if vetoing (raw frame)
        int m_refeventdetcard;
        std::vector<int> m_det_id;
        typedef boost::bimap<std::string,int> det_name_t;
        det_name_t m_det_name;
        time_t m_last_frame_time;
        typedef std::map< int,std::pair<int,time_t> > card_frame_t; 
        card_frame_t m_card_frame;
        typedef std::map<std::string,std::map<int,int>> frame_events_write_t;
        frame_events_write_t m_frame_events_write;
        std::map<std::string,uint64_t> m_events_write_total;
        std::map<std::string,int> m_det_tr;
        std::set<std::string> m_event_det;   // list of names of event mode detectors
        int getSpectrum(const DetectorEvent32* det_ev, int event_source_id, int i);
        void writeEvents(const DAEEventHeader* head, int event_source_id, int nev, const int_map_t& event_id, const float_map_t& event_time_offset);
        void writeEventsImpl(const DAEEventHeader* head, int event_source_id, int nev, const int_map_t& event_id, const float_map_t& event_time_offset);
        int currentWriteFrame() const;
        void updateCurrentWriteFrame(int frame, int event_source_id);
        void makeDetName(int spec, std::string& det_name);
        void openDataGroup(IXNeXusFile* nx, const std::string& name, bool create_zero_size_if_missing = false);
        void closeDataGroup(IXNeXusFile* nx, const std::string& name);
        void openDataGroup(const std::string& name, bool create_zero_size_if_missing = false) { return openDataGroup(m_file, name, create_zero_size_if_missing); }
        void closeDataGroup(const std::string& name) { return closeDataGroup(m_file, name); }
        int getRefEventDetCard(const std::vector<int>& ev_source_ids);
        float getTimeOffset(const DetectorEvent32* det_ev, int event_source_id, int tr, int i) { return getTimeOffset(m_crpt, det_ev, event_source_id, tr, i); }
        void processDataDae(const DAEEventHeader* head, const DetectorEvent32* det_ev, int n, int event_source_id);
};

inline int NeXusEventCallback::getSpectrum(const DetectorEvent32* det_ev, int event_source_id, int i)
{
        return m_crpt->dae1SpecForCard(event_source_id, det_ev[i].spectrum);
}

inline void NeXusWorker::doWork(NeXusWorkerData* data)
{
                data->object->writeEventsImpl(data->head, data->event_source_id, data->nev, data->event_id, data->event_time_offset);
                data->ev.set();
}

#if 0
#define PHI 0x9e3779b9
 
static uint32_t Q[4096], c = 362436;
 
static void init_rand(uint32_t x)
{
        int i;
 
        Q[0] = x;
        Q[1] = x + PHI;
        Q[2] = x + PHI + PHI;
 
        for (i = 3; i < 4096; i++)
                Q[i] = Q[i - 3] ^ Q[i - 2] ^ PHI ^ i;
}
 
static uint32_t rand_cmwc(void)
{
        uint64_t t, a = 18782LL;
        static uint32_t i = 4095;
        uint32_t x, r = 0xfffffffe;
        i = (i + 1) & 4095;
        t = a * Q[i] + c;
        c = (t >> 32);
        x = t + c;
        if (x < c) {
                x++;
                c++;
        }
        return (Q[i] = r - x);
}
#endif

inline float NeXusEventCallback::getTimeOffset(const ISISCRPT_STRUCT* crpt, const DetectorEvent32* det_ev, int /*event_source_id*/, int tr, int i)
{
        static bool random_shift = Poco::Util::Application::instance().config().getBool("isisicp.randomeventbinshift", true);
        int tc_index = static_cast<int>(det_ev[i].time_channel) - 1;
        float tim = 0.0;
        if ( tc_index >= 0 && tc_index < crpt->ntc[tr-1] )
        {
                if (random_shift)
                {
                        tim = crpt->rtcb[tr-1][tc_index] + 
                                 (crpt->rtcb[tr-1][tc_index+1] - crpt->rtcb[tr-1][tc_index]) * ((float)rand() / (float)(RAND_MAX+1));
                }
                else
                {
                        tim = (crpt->rtcb[tr-1][tc_index] + crpt->rtcb[tr-1][tc_index+1]) / 2.0;  // average bin boundaries for event time
                }
        }
        return tim;
}


#endif /* NeXusEventCallback_H */