CRPTProxy.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "CRPTProxy.h"

CRPTProxy::CRPTProxy() : Base("CRPTProxy"), m_crpt(NULL), m_crpt_fh(INVALID_HANDLE_VALUE), m_crpt_fm(NULL)
{
        invalidateHandles();
}


int CRPTProxy::flushSection(void* address, HANDLE file_handle, DAEstatus& status)
{
        int i;
//      ICPTimer timer("CRPTProxy::flushSection", status);
    i = FlushViewOfFile(address, 0);
        if (i == 0)
        {
                status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "FlushViewOfFile failed %d", GetLastError());
                return DAEstatus::Failure;
        }
        i = FlushFileBuffers(file_handle);
        if (i == 0)
        {
                status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "FlushFileBuffers failed %d", GetLastError());
                return DAEstatus::Failure;
        }
        return DAEstatus::Success;
}


int CRPTProxy::flushCRPT(DAEstatus& status, bool flush_raw_data)
{
//      ICPTimer timer("CRPTProxy::flushCRPT", status);
        if (flushSection(m_crpt, m_crpt_fh, status) == DAEstatus::Failure)
        {
                        return DAEstatus::Failure;
        }
        if (flush_raw_data)
        {
                return m_crpt_data.flush();
        }
        else
        {
                return DAEstatus::Success;
        }
}

int CRPTProxy::unloadCRPT(bool delete_crpt_file, bool delete_crpt_data_file, DAEstatus& status)
{
        ICPTimer timer("CRPTProxy::unloadCRPT", status);
        if (m_crpt != NULL)
        {
                time(&(m_crpt->crpt_unload_time));
        }
        if (m_crpt != NULL && UnmapViewOfFile(m_crpt) == 0)
        {
                status.addInfo(FAC_CRPT, "Error unmapping file on exit");
        }
        if (m_crpt_fm != NULL && CloseHandle(m_crpt_fm) == 0)
        {
                status.addInfo(FAC_CRPT, "Error closing crpt mapping file handle on exit");
        }
        if (m_crpt_fh != INVALID_HANDLE_VALUE && CloseHandle(m_crpt_fh) == 0)
        {
                status.addInfo(FAC_CRPT, "Error closing crpt file handle on exit");
        }
        m_crpt_data.unload(delete_crpt_data_file);
        invalidateHandles();
        if (delete_crpt_file)
        {
                status.addInfoVa(FAC_CRPT, "Deleting CRPT %s", m_crpt_file.c_str());
                remove(m_crpt_file.c_str());
        }
        return 0;
}

int CRPTProxy::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)
{
        return loadOrCreateCRPT(crpt_file.c_str(), crpt_name.c_str(), crpt_data_file.c_str(), crpt_data_name.c_str(), crpt_data_size, dae_type, 
                                comp_name.c_str(), readRecoveryFile, status);
}

int CRPTProxy::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)
{
        LARGE_INTEGER size;
        ICPTimer timer("CRPTProxy::loadOrCreateCRPT", status);
        unloadCRPT(status);
        bool rebuild_crpt = false;
        m_crpt_fh = CreateFile(crpt_file, GENERIC_READ | GENERIC_WRITE, 0, defaultNoInheritHandles(), OPEN_ALWAYS, 
                                                FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH /*| FILE_FLAG_NO_BUFFERING*/, NULL);
    if (m_crpt_fh == INVALID_HANDLE_VALUE)
        {
                status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "CreateFile failed for \"%s\" - WIN32 error code = %d", crpt_file, GetLastError());
                unloadCRPT(status);
                return DAEstatus::Failure;
        }
        if (GetFileSizeEx(m_crpt_fh, &size) == 0)
        {
                status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "GetFileSize failed");
                unloadCRPT(status);
                return DAEstatus::Failure;
        }
        if ( size.QuadPart != sizeof(ISISCRPT_STRUCT) )
        {
                status.addVa(FAC_CRPT, SEV_WARNING, ERRTYPE_OUTOFMEM, "crpt size error: %I64d != %Id delete file %s and try again", size.QuadPart, sizeof(ISISCRPT_STRUCT), crpt_file);
                CloseHandle(m_crpt_fh);
                remove(crpt_file);
                m_crpt_fh = CreateFile(crpt_file, GENERIC_READ | GENERIC_WRITE, 0, defaultNoInheritHandles(), CREATE_ALWAYS, 
                                                FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH /*| FILE_FLAG_NO_BUFFERING*/, NULL);
                rebuild_crpt = true;
                size.QuadPart = sizeof(ISISCRPT_STRUCT);
        }
        status.addInfoVa(FAC_CRPT, "CRPT \"%s\" size %Id KB", crpt_file, sizeof(ISISCRPT_STRUCT) / 1024);
        m_crpt_fm = CreateFileMapping(m_crpt_fh, defaultNoInheritHandles(), PAGE_READWRITE, size.HighPart, size.LowPart, crpt_name);
        if (m_crpt_fm == NULL || GetLastError() == ERROR_ALREADY_EXISTS)
        {
                status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "CreateFileMapping failed for \"%s\" - WIN32 error code = %d", crpt_file, GetLastError());
                unloadCRPT(status);
                return DAEstatus::Failure;
        }
    m_crpt = (ISISCRPT_STRUCT*)MapViewOfFile(m_crpt_fm, FILE_MAP_WRITE, 0, 0, 0);
        if (m_crpt == NULL)
        {
                unloadCRPT(status);
                status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "MapViewOfFile failed for \"%s\" - WIN32 error code = %d", crpt_file, GetLastError());
                return DAEstatus::Failure;
        }
        m_crpt_file = crpt_file;
        m_crpt_name = crpt_name;
        m_dae_type = dae_type;
        m_comp_name = comp_name;
        m_crpt->dae_type = dae_type;
        bool crpt_error = false;
        if (rebuild_crpt)
        {
                ISISCRPT_STRUCT* junk = new (m_crpt) ISISCRPT_STRUCT(dae_type, comp_name);
                if (readRecoveryFile != NULL)
                {
                        readRecoveryFile(status);
                }
                else
                {
                        status.addVa(FAC_CRPT, SEV_WARNING, ERRTYPE_OUTOFMEM, "unable to read recovery file");
                        crpt_error = true;
                }
        }
        if ( m_crpt->version != ISISCRPT_VERSION )
        {
                status.addVa(FAC_CRPT, SEV_WARNING, ERRTYPE_OUTOFMEM, "CRPT version mismatch for \"%s\" - %d != %d", crpt_file, m_crpt->version, ISISCRPT_VERSION);
                crpt_error = true;
        }
        if (!m_crpt->checkCRPT())
        {
                status.addVa(FAC_CRPT, SEV_WARNING, ERRTYPE_OUTOFMEM, "CRPT corrupt");
                crpt_error = true;
        }
        // crpt_rcsid is NULL terminated but m_crpt->rscid is not
        if (strlen(crpt_rcsid) >= sizeof(m_crpt->rcsid))
        {
                status.addWarningVa(FAC_CRPT, "CRPT RCS version too long for \"%s\"", crpt_file);       
        }
        else
        {
                if (strncmp(m_crpt->rcsid, crpt_rcsid, strlen(crpt_rcsid)) != 0)
                {
                        status.addWarningVa(FAC_CRPT, "CRPT RCS version mismatch for \"%s\": \"%s\" != \"%s\"", crpt_file, m_crpt->rcsid, crpt_rcsid);
                        crpt_error = true;
                }
        }
        if (crpt_error)
        {
                status.addWarningVa(FAC_CRPT, "CRPT had error so rebuilding from recovery file");
                ISISCRPT_STRUCT* junk2 = new (m_crpt) ISISCRPT_STRUCT(dae_type, comp_name);
                if (readRecoveryFile != NULL)
                {
                        readRecoveryFile(status);
                }
                else
                {
                        status.addVa(FAC_CRPT, SEV_WARNING, ERRTYPE_OUTOFMEM, "unable to read recovery file");
                        crpt_error = true;
                }
        }
        m_crpt_data.init();
        m_raw_data_update_time = 0;
        time(&(m_crpt->crpt_load_time));
        flushCRPT(status); // flush everything to make sure new file is full size on disk
        status.addInfoVa(FAC_CRPT, "CRPT version %d (%s)", ISISCRPT_VERSION, crpt_rcsid);
        // now load data file
        if (m_crpt_data.loadOrCreate(crpt_data_file, crpt_data_name, crpt_data_size, status) == DAEstatus::Failure)
        {
                unloadCRPT(status);
                return DAEstatus::Failure;
        }
        time(&(m_crpt->crpt_load_time));
        flushCRPT(status, true); // flush everything to make sure new file is full size on disk
        return DAEstatus::Success;
}


int CRPTProxy::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)
{
        ICPTimer timer("CRPTProxy::loadCRPT", status);
        int open_mode = ( read_only ? (GENERIC_READ) : (GENERIC_READ | GENERIC_WRITE) );
        int file_attributes = ( read_only ? (FILE_ATTRIBUTE_NORMAL) : (FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH) );
        HANDLE crpt_fh = CreateFile(crpt_file, open_mode, 0, defaultNoInheritHandles(), OPEN_EXISTING, file_attributes, NULL);
    if (crpt_fh == INVALID_HANDLE_VALUE)
        {
                status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "CreateFile failed for \"%s\" - WIN32 error code = %d", crpt_file, GetLastError());
                return DAEstatus::Failure;
        }
        HANDLE crpt_data_fh = CreateFile(crpt_data_file, open_mode, 0, defaultNoInheritHandles(), OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL /* file_attributes */, NULL);  
    if (crpt_data_fh == INVALID_HANDLE_VALUE)
        {
                CloseHandle(crpt_fh);
                status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "CreateFile failed for \"%s\" - WIN32 error code = %d", crpt_data_file, GetLastError());
                return DAEstatus::Failure;
        }
        return loadCRPT(crpt_file, crpt_fh, crpt_name, crpt_data_file, crpt_data_fh, crpt_data_name, crpt_data_size, read_only, status);
}

int CRPTProxy::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)
{
        ICPTimer timer("CRPTProxy::loadCRPT", status);
        LARGE_INTEGER size;
        unloadCRPT(status);
        m_crpt_fh = crpt_fh;
        int file_map_mode = (read_only ? PAGE_READONLY : PAGE_READWRITE);
        int view_map_mode = (read_only ? FILE_MAP_READ : FILE_MAP_WRITE);
    if (m_crpt_fh == INVALID_HANDLE_VALUE)
        {
                status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "CreateFile failed - WIN32 error code = %d", GetLastError());
                unloadCRPT(status);
                return DAEstatus::Failure;
        }
        if (GetFileSizeEx(m_crpt_fh, &size) == 0)
        {
                status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "GetFileSize failed");
                unloadCRPT(status);
                return DAEstatus::Failure;
        }
        if ( size.QuadPart != sizeof(ISISCRPT_STRUCT) )
        {
                status.addVa(FAC_CRPT, SEV_WARNING, ERRTYPE_OUTOFMEM, "crpt size error: %I64d != %Id", size.QuadPart, sizeof(ISISCRPT_STRUCT));
                unloadCRPT(status);
                return DAEstatus::Failure;
        }
        m_crpt_fm = CreateFileMapping(m_crpt_fh, defaultNoInheritHandles(), file_map_mode, size.HighPart, size.LowPart, crpt_name);
        if (m_crpt_fm == NULL || GetLastError() == ERROR_ALREADY_EXISTS)
        {
                status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "CreateFileMapping failed - WIN32 error code = %d", GetLastError());
                unloadCRPT(status);
                return DAEstatus::Failure;
        }
    m_crpt = (ISISCRPT_STRUCT*)MapViewOfFile(m_crpt_fm, view_map_mode, 0, 0, 0);
        if (m_crpt == NULL)
        {
                status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "MapViewOfFile failed - WIN32 error code = %d", GetLastError());
                unloadCRPT(status);
                return DAEstatus::Failure;
        }
// can't do this yet as also called with a blank crpt
//      if (strncmp(m_crpt->rcsid, crpt_rcsid, strlen(crpt_rcsid)) != 0)
//      {
//              status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "CRPT RCS version mismatch for \"%s\": \"%s\" != \"%s\"", crpt_file, m_crpt->rcsid, crpt_rcsid);
//              unloadCRPT(status);
//              return DAEstatus::Failure;
//      }
        m_crpt_name = crpt_name;
        m_crpt_file = crpt_file;
//      m_dae_type = dae_type;
//      m_comp_name = comp_name;
        m_raw_data_update_time = 0;
        // now load data file
        if (m_crpt_data.load(crpt_data_file, crpt_data_fh, crpt_data_name, crpt_data_size, read_only, status) == DAEstatus::Failure)
        {
                unloadCRPT(status);
                return DAEstatus::Failure;
        }
        time(&(m_crpt->crpt_load_time));
        return DAEstatus::Success;
}

int CRPTProxy::mapCRPT(const std::string& crpt_name, const std::string& crpt_data_name, bool read_only, bool existing)
{
        int map_opt = (read_only ? FILE_MAP_READ : FILE_MAP_WRITE);
        invalidateHandles();
        while( (m_crpt_fm = OpenFileMapping(map_opt, FALSE, crpt_name.c_str())) == NULL )
        {
                Sleep(2000);
        }
        m_crpt = (ISISCRPT_STRUCT*)MapViewOfFile(m_crpt_fm, map_opt, 0, 0, 0);
    if (m_crpt == NULL)
        {
                LOGSTR_ERROR("MapViewOfFile");
                CloseHandle(m_crpt_fm);
                m_crpt_fm = NULL;
                return DAEstatus::Failure;
        }
        if (m_crpt_data.map(crpt_data_name, read_only, existing) == DAEstatus::Failure)
        {
                LOGSTR_ERROR("m_crpt_data.map");
                UnmapViewOfFile(m_crpt);
                CloseHandle(m_crpt_fm);
                m_crpt = NULL;
                m_crpt_fm = NULL;
                return DAEstatus::Failure;
        }
        if (!read_only)
        {
                time(&(m_crpt->crpt_load_time));
        }
        return DAEstatus::Success;
}

#if 0
int CRPTProxy::clone(const std::string& crpt_file, const std::string& crpt_data_file, bool blank_raw_data, DAEstatus& status)
{
        ICPTimer icptimer("CRPTProxy::clone", status);
        unsigned len_used = m_crpt_data_size; 
//      unsigned len_used = m_crpt->getPeriodSize() * m_crpt->nper_daq;   // max is m_crpt_data_size
        LOGSTR_INFORMATION("Copying CRPT to " << crpt_file);
        ActiveObject<int> ob;
        Poco::ActiveResult<int> res1 = ob.run(boost::bind(flushed_write, crpt_file, m_crpt, sizeof(ISISCRPT_STRUCT)));
        Poco::SharedPtr<Poco::ActiveResult<int>> res2;  
        if (blank_raw_data)
        {
                LOGSTR_INFORMATION("Creating " << len_used << " words of blank histogram data in " << crpt_data_file);
                res2 = new Poco::ActiveResult<int>(ob.run(boost::bind(createEmptyFileAndClose, crpt_data_file, len_used*sizeof(isisU32_t))));
        }
        else
        {
                LOGSTR_INFORMATION("Copying " << len_used << " words of CRPT histogram data to " << crpt_data_file);
                res2 = new Poco::ActiveResult<int>(ob.run(boost::bind(flushed_write, crpt_data_file, m_crpt_data, len_used*sizeof(isisU32_t))));
        }
        res1.wait();
        res2->wait();
        if (res1.failed() || res1.data() != 0)
        {
                throw std::runtime_error("CRPTProxy::clone");
        }
        if (res2->failed() || res2->data() != 0)
        {
                throw std::runtime_error("CRPTProxy::clone");
        }
        return 0;
}
#endif

int CRPTProxy::createFrom(CRPTProxy& proxy_clone, int id, bool blank_raw_data, DAEstatus& status)
{
        ICPTimer timer("CRPTProxy::createFrom", status);
        std::string crpt_file = Poco::format("%s%d", proxy_clone.m_crpt_file, id);
        std::string crpt_data_file = Poco::format("%s%d", proxy_clone.dataFileName(), id);
        std::string crpt_name = Poco::format("%s%d", proxy_clone.m_crpt_name, id);
        std::string crpt_data_name = Poco::format("%s%d", proxy_clone.dataSectionName(), id);
        HANDLE crpt_fh = createEmptyFile(crpt_file, sizeof(ISISCRPT_STRUCT));
        HANDLE crpt_data_fh = createEmptyFile(crpt_data_file, proxy_clone.dataFileSize() * sizeof(isisU32_t));
        loadCRPT(crpt_file.c_str(), crpt_fh, crpt_name.c_str(), crpt_data_file.c_str(), crpt_data_fh, crpt_data_name.c_str(), proxy_clone.rawDataSizeMax(), false, status);
        updateFrom(proxy_clone, !blank_raw_data, status);
        return 0;
}

int CRPTProxy::updateFrom(CRPTProxy& proxy_clone, bool copy_raw_data, DAEstatus& status)
{
        ICPTimer timer("CRPTProxy::updateFrom", status);
        memcpy(m_crpt, proxy_clone.m_crpt, sizeof(ISISCRPT_STRUCT));
        if (copy_raw_data)
        {
                m_crpt_data.copy(proxy_clone.m_crpt_data);
        }
        flushCRPT(status, copy_raw_data);
        m_sample_parameters = proxy_clone.m_sample_parameters;
        m_beamline_parameters = proxy_clone.m_beamline_parameters;
        m_status_log = proxy_clone.m_status_log;
        m_event_log = proxy_clone.m_event_log;
        m_debug_log = proxy_clone.m_debug_log;
        m_monitoring_log = proxy_clone.m_monitoring_log;
        m_timediff_log = proxy_clone.m_timediff_log;
        return 0;
}

int CRPTProxy::assignLogFiles(const std::string& prefix)
{
        m_status_log = prefix + "_ICPstatus.txt";
        m_event_log = prefix + "_ICPevent.txt";
        m_debug_log = prefix + "_ICPdebug.txt";
        m_monitoring_log = prefix + "_ICPmonitoring.txt";
        m_timediff_log = prefix + "_ICPtimediff.txt";
        return DAEstatus::Success;
}

// also called in endRun() to update log file names for a new run number
int CRPTProxy::assignLogFiles(bool use_full_inst_name_for_files, const std::string& data_dir, int run_number_digits)
{
        char buffer[256];
        char log_name[80];
        if (use_full_inst_name_for_files)
        {
                strncpy(log_name, m_crpt->inst_name, sizeof(log_name));
        }
        else
        {
                strncpy(log_name, m_crpt->inst_abrv, sizeof(log_name));
        }
        NULL_TERMINATE(log_name);
        _snprintf(buffer, sizeof(buffer), "%s\\%s%0*d", data_dir.c_str(), log_name, run_number_digits, m_crpt->run_number);
        NULL_TERMINATE(buffer);
        return assignLogFiles(buffer);
}


static Poco::Mutex histo_mutex;

void CRPTProxy::histogramEventsToCRPT(CRPTProxy& crpt, const DAEEventHeader* head, const DetectorEvent32* ev, int n, int event_source_id)
{
        histogramEventsToCRPT(crpt.CRPT(), NULL, &(crpt.m_crpt_data), NULL, head, ev, n, event_source_id);
}

void CRPTProxy::histogramEventsToCRPT(CRPTProxy& crpt1, CRPTProxy& crpt2, const DAEEventHeader* head, const DetectorEvent32* ev, int n, int event_source_id)
{
        histogramEventsToCRPT(crpt1.CRPT(), crpt2.CRPT(), &(crpt1.m_crpt_data), &(crpt2.m_crpt_data), head, ev, n, event_source_id);
}

//void CRPTProxy::histogramEventsToCRPT(const ISISCRPT_STRUCT* crpt, ISISCRPT_DATA* crpt_data, const DAEEventHeader* head, const DetectorEvent32* ev, int n, int event_source_id)
//{
//      histogramEventsToCRPT(crpt, NULL, crpt_data, NULL, head, ev, n, event_source_id);
//}

void CRPTProxy::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 bool random_shift = Poco::Util::Application::instance().config().getBool("isisicp.randomeventbinshift", true);
//      unsigned permax = crpt->getPeriodSize();
        int spec;
        uint32_t base_offset, time_chan_offset; 
        isisU32_t* raw_data1 = crpt_data1->rawData();
        isisU32_t* raw_data2 = (crpt_data2 != NULL ? crpt_data2->rawData() : NULL);
        int card_index = crpt1->cardIndexFromPos(event_source_id);
        for(int i=0; i<n; ++i)
        {
                spec = crpt1->dae1SpecForCardIndex(card_index, ev[i].spectrum);
                if (spec >= 0 && head->period < crpt1->nper_daq)
                {
                        base_offset = crpt1->spectrumCRPTOffsetImpl(spec, head->period, crpt_data1->rawDataSizeMax());
                        if (random_shift)
                        {
                                time_chan_offset = crpt1->randomisedChannelRebin(ev[i].time_channel, crpt1->spectrumDAETR(spec), crpt1->spectrumCRPTTR(spec));
                        }
                        else
                        {
                                time_chan_offset = crpt1->tcb_map[crpt1->spectrumCRPTTR(spec)-1][crpt1->spectrumDAETR(spec)-1][ev[i].time_channel];  // equivalent to using simpleChannelRebin()
                        }
                        if (sizeof(LONG) == sizeof(raw_data1[0]))
                        {
                                InterlockedIncrement(reinterpret_cast<LONG*>(&(raw_data1[base_offset + time_chan_offset])));
                                crpt_data1->incrementSpectrum(spec, head->period);
                                if (raw_data2 != NULL)
                                {
                                        InterlockedIncrement(reinterpret_cast<LONG*>(&(raw_data2[base_offset + time_chan_offset])));
                                        crpt_data2->incrementSpectrum(spec, head->period);
                                }
                        }
                        else
                        {
                                histo_mutex.lock();
                                ++(raw_data1[base_offset + time_chan_offset]);
                                crpt_data1->incrementSpectrum(spec, head->period);
                                if (raw_data2 != NULL)
                                {
                                        ++(raw_data2[base_offset + time_chan_offset]);
                                        crpt_data2->incrementSpectrum(spec, head->period);
                                }
                                histo_mutex.unlock();
                        }
                }
        }
}


        void CRPTProxy::zeroEventRawData(DAEstatus& status)
        {
                Poco::Mutex::ScopedLock _lock(m_data_lock);
                ICPTimer timer("CRPTProxy::zeroEventRawData", status);
                isisU32_t* crpt_data = m_crpt_data.rawData();
                for(int i=0; i < m_crpt->getNumSpectra(true); ++i)
                {
                        if ( m_crpt->isEventSpectrum(i) )
                        {
                                int ntc = m_crpt->spectrumNTC(i);
                                for(int j=0; j < m_crpt->nper_daq; ++j)
                                {
                                        memset(&(crpt_data[ spectrumCRPTOffset(i, j) ]), 0, (ntc+1)*sizeof(uint32_t));
                                        m_crpt_data.zeroSpectrum(i, j);
                                }
                        }
                }
        }


#if 0
int CRPTProxy::copyDataTo(const std::string& filename, DAEstatus& status) const
{
        ICPTimer timer("CRPTProxy::copyDataTo", status);
        FILE* f;
        size_t n;
        f = fopen(filename.c_str(), "wbcN");
        if (f == NULL)
        {
                status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "cannot create new crpt disk file");
                return DAEstatus::Failure;
        }
        n = fwrite(m_crpt_data, sizeof(isisU32_t), m_crpt_data_size, f);
        fflush(f);
        fclose(f);
        if (n != m_crpt_data_size)
        {
                status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "cannot write new crpt disk file");
                return DAEstatus::Failure;
        }
        return DAEstatus::Success;
}
// create a new blank on-disk image and maps to it
int ISISCRPT_STRUCT::createNew(const std::string& crpt_filename, const std::string& crpt_section_name, 
        const std::string& crpt_data_filename, const std::string& crpt_data_section_name,
        ISISDAE::DAEType dae_type, const std::string& comp_name, DAEstatus& status)
{
        FILE* f;
        size_t n;
        ISISCRPT_STRUCT* tmp_crpt;
        f = fopen(crpt_filename.c_str(), "wbcN");
        if (f == NULL)
        {
                status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "cannot create new crpt disk file");
                return DAEstatus::Failure;
        }
        tmp_crpt = new ISISCRPT_STRUCT(dae_type, comp_name);
        n = fwrite(tmp_crpt, sizeof(ISISCRPT_STRUCT), 1, f);
        fflush(f);
        fclose(f);
        delete tmp_crpt;
        if (n != 1)
        {
                status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "cannot write new crpt disk file");
                return DAEstatus::Failure;
        }
        return DAEstatus::Success;
}

        if ( (loadCRPT() == DAEstatus::Failure) || (m_crpt == NULL) )
        {
                m_status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "cannot load new crpt");
                return DAEstatus::Failure;
        }
        readRecoveryFile(m_status);
        flushCRPT(m_status, true); // flush everything to make sure new file is full size on disk
        return DAEstatus::Success;
#endif