CRPTProxy.h

Go to the documentation of this file.

#ifndef CRPT_PROXY
#define CRPT_PROXY

#include "isiscrpt.h"

class ISISCRPT_DATA : public ISIS::Base
{
private:
        isisU32_t* m_crpt_data;  
        isisU32_t m_crpt_data_size;   
        isisU32_t* m_spec_integrals;
        isisU32_t m_spec_integrals_size;   
        HANDLE m_crpt_data_fh;
        HANDLE m_crpt_data_fm;
        std::string m_crpt_data_file;
        std::string m_crpt_data_name;           

public:
        ISISCRPT_DATA() : Base("ISISCRPT_DATA"), m_crpt_data(NULL), m_crpt_data_size(0), m_spec_integrals(NULL), 
                m_spec_integrals_size(0), m_crpt_data_fh(INVALID_HANDLE_VALUE), m_crpt_data_fm(NULL) { }
        void init()
        {
                m_crpt_data = m_spec_integrals = NULL;
                m_crpt_data_size = m_spec_integrals_size = 0;
                m_crpt_data_fm = NULL;
                m_crpt_data_fh = INVALID_HANDLE_VALUE;
        }
        inline void zeroSpectrum(int spec, int /*daq_period*/)
        {
                if (spec >= 0 && spec < m_spec_integrals_size)
                {
                        m_spec_integrals[spec] = 0;
                }
        }
        inline void incrementSpectrum(int spec, int /*daq_period*/)
        {
                if (spec >= 0 && spec < m_spec_integrals_size)
                {
                        InterlockedIncrement(reinterpret_cast<LONG*>(&(m_spec_integrals[spec])));
                }
        }

        void copy(const ISISCRPT_DATA& clone)
        {
                if (this != &clone)
                {
                        memcpy(m_crpt_data, clone.m_crpt_data, m_crpt_data_size * sizeof(isisU32_t));
                        memcpy(m_spec_integrals, clone.m_spec_integrals, m_spec_integrals_size * sizeof(isisU32_t));
                }
        }
        isisU32_t rawDataSizeMax() const { return m_crpt_data_size; }
        isisU32_t fileSizeMax() const { return m_crpt_data_size + m_spec_integrals_size; }
        std::string fileName() const { return m_crpt_data_file; }
        std::string sectionName() const { return m_crpt_data_name; }
        isisU32_t* rawData() { return m_crpt_data; }
        const isisU32_t* rawData() const { return m_crpt_data; }
        isisU32_t* spectrumIntegrals() { return m_spec_integrals; }
        const isisU32_t* spectrumIntegrals() const { return m_spec_integrals; }
        void zeroRawData(isisU32_t data_size = 0) 
        { 
                if (data_size == 0)
                {
                        data_size = m_crpt_data_size;
                }
                ZeroMemory(m_crpt_data, data_size * sizeof(isisU32_t)); 
                ZeroMemory(m_spec_integrals, m_spec_integrals_size * sizeof(isisU32_t)); 
        }
        bool valid() const { return m_crpt_data != NULL; }
        int flush()
        {
                FlushViewOfFile(m_crpt_data, 0);   // only need to do this as all sections together
                FlushFileBuffers(m_crpt_data_fh);
                return DAEstatus::Success;
        }
        void unload(bool delete_file)
        {
                if (valid() && UnmapViewOfFile(rawData()) == 0)
                {
                        LOGSTR_INFORMATION("Error unmapping data file on exit");
                }
                if (m_crpt_data_fm != NULL && CloseHandle(m_crpt_data_fm) == 0)
                {
                        LOGSTR_INFORMATION("Error closing crpt data mapping file handle on exit");
                }
                if (m_crpt_data_fh != INVALID_HANDLE_VALUE && CloseHandle(m_crpt_data_fh) == 0)
                {
                        LOGSTR_INFORMATION("Error closing crpt data file handle on exit");
                }
                if (delete_file)
                {
                        LOGSTR_INFORMATION("Deleting CRPT data " << m_crpt_data_file.c_str());
                        remove(m_crpt_data_file.c_str());
                }
                init();
        }

        int loadOrCreate(const char* crpt_data_file, const char* crpt_data_name, int crpt_data_size, DAEstatus& status)
        {
                LARGE_INTEGER size;
                init();
                m_spec_integrals_size = ISISCRPT_MAX_DETECTOR;
                m_crpt_data_size = crpt_data_size;
                m_crpt_data_fh = CreateFile(crpt_data_file, GENERIC_READ | GENERIC_WRITE, 0, defaultNoInheritHandles(), OPEN_ALWAYS, 
                                                FILE_ATTRIBUTE_NORMAL /* | FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING */, NULL);
                if (m_crpt_data_fh == INVALID_HANDLE_VALUE)
                {
                        status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "CreateFile failed for \"%s\" - WIN32 error code = %d", crpt_data_file, GetLastError());
                        unload(false);
                        return DAEstatus::Failure;
                }
                if (GetFileSizeEx(m_crpt_data_fh, &size) == 0)
                {
                        status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "GetFileSize failed");
                        unload(false);
                        return DAEstatus::Failure;
                }
                if ( size.QuadPart != (fileSizeMax() * sizeof(isisU32_t)) )
                {
                        status.addVa(FAC_CRPT, SEV_WARNING, ERRTYPE_OUTOFMEM, "crpt data size error: %I64d != %Id delete file %s and try again", size.QuadPart, fileSizeMax() * sizeof(isisU32_t), crpt_data_file);
                        CloseHandle(m_crpt_data_fh);
                        remove(crpt_data_file);
                        m_crpt_data_fh = CreateFile(crpt_data_file, GENERIC_READ | GENERIC_WRITE, 0, defaultNoInheritHandles(), CREATE_ALWAYS, 
                                                FILE_ATTRIBUTE_NORMAL /* | FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING */, NULL);
                        size.QuadPart = fileSizeMax() * sizeof(isisU32_t);
                }
                status.addInfoVa(FAC_CRPT, "CRPT data \"%s\" size %Id KB", crpt_data_file,  size.QuadPart / 1024);
                m_crpt_data_fm = CreateFileMapping(m_crpt_data_fh, defaultNoInheritHandles(), PAGE_READWRITE, size.HighPart, size.LowPart, crpt_data_name);
                if (m_crpt_data_fm == NULL || GetLastError() == ERROR_ALREADY_EXISTS)
                {
                        status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "CreateFileMapping failed for \"%s\" - WIN32 error code = %d", crpt_data_file, GetLastError());
                        unload(false);
                        return DAEstatus::Failure;
                }
                m_crpt_data = (isisU32_t*)MapViewOfFile(m_crpt_data_fm, FILE_MAP_WRITE, 0, 0, 0);
                if (m_crpt_data == NULL)
                {
                        unload(false);
                        status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "MapViewOfFile failed for \"%s\" - WIN32 error code = %d", crpt_data_file, GetLastError());
                        return DAEstatus::Failure;
                }
                m_crpt_data_file = crpt_data_file;
                m_crpt_data_name = crpt_data_name;
                m_spec_integrals = m_crpt_data + m_crpt_data_size;
                return DAEstatus::Success;
        }

        int load(const char* crpt_data_file, HANDLE crpt_data_fh, const char* crpt_data_name, int crpt_data_size, bool read_only, DAEstatus& status)
        {
                LARGE_INTEGER size;
                int file_map_mode = (read_only ? PAGE_READONLY : PAGE_READWRITE);
                int view_map_mode = (read_only ? FILE_MAP_READ : FILE_MAP_WRITE);
                init();
                m_spec_integrals_size = ISISCRPT_MAX_DETECTOR;
                m_crpt_data_size = crpt_data_size;
                if (GetFileSizeEx(crpt_data_fh, &size) == 0)
                {
                        status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "GetFileSize failed");
                        unload(false);
                        return DAEstatus::Failure;
                }
                if ( size.QuadPart != (fileSizeMax() * sizeof(isisU32_t)) )
                {
                        status.addVa(FAC_CRPT, SEV_WARNING, ERRTYPE_OUTOFMEM, "crpt data size error: %I64d != %Id", size.QuadPart, fileSizeMax() * sizeof(isisU32_t));
                        unload(false);
                        return DAEstatus::Failure;
                }
                m_crpt_data_fm = CreateFileMapping(crpt_data_fh, defaultNoInheritHandles(), file_map_mode, size.HighPart, size.LowPart, crpt_data_name);
                if (m_crpt_data_fm == NULL || GetLastError() == ERROR_ALREADY_EXISTS)
                {
                        status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "CreateFileMapping failed - WIN32 error code = %d", GetLastError());
                        unload(false);
                        return DAEstatus::Failure;
                }
                m_crpt_data = (isisU32_t*)MapViewOfFile(m_crpt_data_fm, view_map_mode, 0, 0, 0);
                if (m_crpt_data == NULL)
                {
                        status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "MapViewOfFile failed - WIN32 error code = %d", GetLastError());
                        unload(false);
                        return DAEstatus::Failure;
                }
                m_crpt_data_file = crpt_data_file;
                m_crpt_data_name = crpt_data_name;
                m_crpt_data_fh = crpt_data_fh; 
                m_spec_integrals = m_crpt_data + m_crpt_data_size;
                return DAEstatus::Success;
        }

        int map(const std::string& crpt_data_name, bool read_only, bool /*existing*/)
        {
                int map_opt = (read_only ? FILE_MAP_READ : FILE_MAP_WRITE);
                        while( (m_crpt_data_fm = OpenFileMapping(map_opt, FALSE, crpt_data_name.c_str())) == NULL )
                {
                        Sleep(2000);
                }
                m_spec_integrals = NULL;
                m_crpt_data = (isisU32_t*)MapViewOfFile(m_crpt_data_fm, map_opt, 0, 0, 0);
                if (m_crpt_data == NULL)
                {
                        LOGSTR_ERROR("error in MapViewOfFile");
                        CloseHandle(m_crpt_data_fm);
                        m_crpt_data_fm = NULL;
                        return DAEstatus::Failure;
                }
                std::string fname = fileNameFromMappedView(m_crpt_data);
                if (fname.size() > 0)
                {
                        int64_t fsize = fileSizeBytes(fname); 
                        if (fsize == 0)
                        {
                                LOGSTR_ERROR(fname << " has zero size - assuming c:\\data\\data.run and trying again");
                                fsize = fileSizeBytes("c:\\data\\data.run");
                        }
                        if (fsize == 0)
                        {
                                LOGSTR_ERROR(fname << "c:\\data\\data.run has zero size - exiting");
                                UnmapViewOfFile(m_crpt_data);
                                m_crpt_data = NULL;
                                CloseHandle(m_crpt_data_fm);
                                m_crpt_data_fm = NULL;
                                return DAEstatus::Failure;
                        }
                        m_crpt_data_size = static_cast<isisU32_t>(fsize / sizeof(isisU32_t));
                        //              m_spec_integrals = m_crpt_data + m_crpt_data_size;
                }
                else
                {
                        LOGSTR_ERROR("error in fileNameFromMappedView");
                        UnmapViewOfFile(m_crpt_data);
                        m_crpt_data = NULL;
                        CloseHandle(m_crpt_data_fm);
                        m_crpt_data_fm = NULL;
                        return DAEstatus::Failure;
                }
                return DAEstatus::Success;
        }
};

class CRPTProxy : public ISIS::Base
{
public:
        struct parameter_t 
        { 
                std::string type; 
                std::string value;
                std::string units;
                parameter_t(const std::string& t, const std::string& u, const std::string& v) : type(t), units(u), value(v) {}
        }; 
        typedef std::map<std::string, parameter_t> parameter_map_t;
private:
        Poco::Mutex m_crpt_lock;
        Poco::Mutex m_data_lock;
    ISISCRPT_STRUCT* m_crpt;
        ISISCRPT_DATA m_crpt_data;

        HANDLE m_crpt_fh;
        HANDLE m_crpt_fm;
        ISISDAE::DAEType m_dae_type;
        std::string m_comp_name;
        std::string m_crpt_file;
        std::string m_crpt_name;                
        time_t m_raw_data_update_time;  

        std::string m_status_log;
        std::string m_event_log;
        std::string m_debug_log;
        std::string m_monitoring_log;
        std::string m_timediff_log;

        // used for beamline and sample parameters
        parameter_map_t m_sample_parameters;
        parameter_map_t m_beamline_parameters;

        CRPTProxy(const CRPTProxy&) { }
        void invalidateHandles()
        {
                m_crpt = NULL;
                m_crpt_fm = NULL;
                m_crpt_fh = INVALID_HANDLE_VALUE;
                m_crpt_data.init();
        }
        int flushSection(void* address, HANDLE file_handle, DAEstatus& status);

public:
        ISISCRPT_DATA* crptData() { return &m_crpt_data; }
        Poco::Mutex& getLockRef() { return m_crpt_lock; }
        Poco::Mutex& getDataLockRef() { return m_data_lock; }
        const std::string& statusLog() const { return m_status_log; }
        const std::string& eventLog() const { return m_event_log; }
        const std::string& debugLog() const { return m_debug_log; }
        const std::string& monitoringLog() const { return m_monitoring_log; }
        const std::string& timeDiffLog() const { return m_timediff_log; }
        parameter_map_t& sampleParameters() { return m_sample_parameters; }
        parameter_map_t& beamlineParameters() { return m_beamline_parameters; }
        int assignLogFiles(const std::string& prefix);
        int assignLogFiles(bool use_full_inst_name_for_files, const std::string& data_dir, int run_number_digits);
        void rawDataUpdated() { time(&m_raw_data_update_time); }
    time_t rawDataUpdateTime() const { return m_raw_data_update_time; }
        isisU32_t rawDataSizeMax() const { return m_crpt_data.rawDataSizeMax(); }
        isisU32_t rawDataSizeUsed() const { return m_crpt->getPeriodSize() * m_crpt->nper_daq; }
        std::string dataFileName() const { return m_crpt_data.fileName(); }
        std::string dataSectionName() const { return m_crpt_data.sectionName(); }
        isisU32_t* rawData()
        { 
                Poco::Mutex::ScopedLock _lock(m_data_lock);
                return m_crpt_data.rawData(); 
        }
        const isisU32_t* rawData() const
        { 
                return m_crpt_data.rawData(); 
        }
        isisU32_t* spectrumIntegrals()
        { 
                Poco::Mutex::ScopedLock _lock(m_data_lock);
                return m_crpt_data.spectrumIntegrals(); 
        }
        const isisU32_t* spectrumIntegrals() const
        { 
                return m_crpt_data.spectrumIntegrals(); 
        }
        isisU32_t dataFileSize() const
        {
                return m_crpt_data.fileSizeMax();
        }
        void setICPStartTime(time_t t)
        {
                m_crpt->icp_start_time = t;
        }
        void zeroAllRawData(DAEstatus& status) 
        { 
                Poco::Mutex::ScopedLock _lock(m_data_lock);
                ICPTimer timer("CRPTProxy::zeroAllRawData", status);
                m_crpt_data.zeroRawData();
                rawDataUpdated();
        }
        void zeroUsedRawData(DAEstatus& status) 
        { 
                Poco::Mutex::ScopedLock _lock(m_data_lock);
                ICPTimer timer("CRPTProxy::zeroUsedRawData", status);
                isisU32_t data_size = rawDataSizeUsed();
                if (data_size > rawDataSizeMax())
                {
                        data_size = rawDataSizeMax();
                }
                m_crpt_data.zeroRawData(data_size);
                rawDataUpdated();
        }
        void zeroEventRawData(DAEstatus& status); 
        ISISCRPT_STRUCT* CRPT() { return m_crpt; }
        const ISISCRPT_STRUCT* CRPT() const { return m_crpt; }
        CRPTProxy();
        bool isValid() const { return m_crpt != NULL; }
        ISISCRPT_STRUCT* operator->() { return m_crpt; }
        const ISISCRPT_STRUCT* operator->() const { return m_crpt; }
        int flushCRPT(DAEstatus& status, bool flush_raw_data = false);
        int mapCRPT(const std::string& crpt_name, const std::string& crpt_data_name, bool read_only, bool existing);
        int loadOrCreateCRPT(const std::string& crpt_file, const std::string& crpt_name, 
                        const std::string& crpt_data_file, const std::string& crpt_data_name, int crpt_data_size,
                        ISISDAE::DAEType dae_type, const std::string& comp_name, boost::function<int (DAEstatus&)> readRecoveryFile, DAEstatus& status);
        int loadOrCreateCRPT(const char* crpt_file, const char* crpt_name, 
                        const char* crpt_data_file, const char* crpt_data_name, int crpt_data_size,
                        ISISDAE::DAEType dae_type, const char* comp_name, boost::function<int (DAEstatus&)> readRecoveryFile, DAEstatus& status);
        int loadCRPT(const char* crpt_file, const char* crpt_name, 
                        const char* crpt_data_file, const char* crpt_data_name, int crpt_data_size, bool read_only, DAEstatus& status);
        int loadCRPT(const char* crpt_file, HANDLE crpt_fh, const char* crpt_name, const char* crpt_data_file, 
                        HANDLE crpt_data_fh, const char* crpt_data_name, int crpt_data_size, bool read_only, DAEstatus& status);
        int unloadCRPT(bool delete_crpt_file, bool delete_crpt_data_file, DAEstatus& status);
        int unloadCRPT(DAEstatus& status) { return unloadCRPT(false, false, status); }
        ~CRPTProxy() { DAEstatus status; unloadCRPT(status); }
//      int clone(const std::string& crpt_file, const std::string& crpt_data_file, bool blank_raw_data, DAEstatus& status);
        int createFrom(CRPTProxy& proxy_clone, int id, bool blank_raw_data, DAEstatus& status);
        int updateFrom(CRPTProxy& proxy_clone, bool copy_raw_data, DAEstatus& status);
//      int copyDataTo(const std::string& filename, DAEstatus& status) const;

        int getIntArrayItem(const char* item_name, const long* spec_array, int nspec, long* larray, DAEstatus& status) const
        {
                return m_crpt->getIntArrayItem(rawData(), rawDataSizeMax(), item_name, spec_array, nspec, larray, status);
        }
        int getIntArrayItem(const char* item_name, long* larray, DAEstatus& status) const
        {
                return m_crpt->getIntArrayItem(rawData(), rawDataSizeMax(), item_name, larray, status);
        }
        int getRealArrayItem(const char* item_name, const long* spec_array, int nspec, double* darray, DAEstatus& status) const
        {
                return m_crpt->getRealArrayItem(rawData(), rawDataSizeMax(), item_name, spec_array, nspec, darray, status);
        }
        int getRealArrayItem(const char* item_name, const long* spec_array, int nspec, float* farray, DAEstatus& status) const
        {
                return m_crpt->getRealArrayItem(rawData(), rawDataSizeMax(), item_name, spec_array, nspec, farray, status);
        }
        int getRealArrayItem(const char* item_name, double* darray, DAEstatus& status) const
        {
                return m_crpt->getRealArrayItem(rawData(), rawDataSizeMax(), item_name, darray, status);
        }
        int getRealArrayItem(const char* item_name, float* farray, DAEstatus& status) const
        {
                return m_crpt->getRealArrayItem(rawData(), rawDataSizeMax(), item_name, farray, status);
        }
        bool isRawDataCacheValid() const { return (m_raw_data_update_time >= m_crpt->start_time); }
    uint32_t spectrumCRPTOffset(int spec, int daq_period) const;
//      static void histogramEventsToCRPT(const ISISCRPT_STRUCT* crpt, ISISCRPT_DATA* crpt_data, const DAEEventHeader* head, const DetectorEvent32* ev, int n, int event_source_id);
        static void histogramEventsToCRPT(const ISISCRPT_STRUCT* crpt1, const ISISCRPT_STRUCT* crpt2, ISISCRPT_DATA* crpt_data1, ISISCRPT_DATA* crpt_data2, const DAEEventHeader* head, const DetectorEvent32* ev, int n, int event_source_id);
        static void histogramEventsToCRPT(CRPTProxy& crpt, const DAEEventHeader* head, const DetectorEvent32* ev, int n, int event_source_id);
        static void histogramEventsToCRPT(CRPTProxy& crpt1, CRPTProxy& crpt2, const DAEEventHeader* head, const DetectorEvent32* ev, int n, int event_source_id);
};

inline uint32_t CRPTProxy::spectrumCRPTOffset(int spec, int daq_period) const
{
        return m_crpt->spectrumCRPTOffsetImpl(spec, daq_period, rawDataSizeMax());
}

#endif /* CRPT_PROXY */