ISISinstrumentControl.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "isiscrpt.h"
#include "ISISinstrumentControl.h"
#include "isisraw.h"
//#include "md5.h"
#include "labview_xml.h"
#include "icputils.h"
#include "nexuswriter.h"
#include "../svn-revision.h"
#include "ci_string.h"
#include "muParser.h"
#include "windows.h"
#include "DetectorFile.h"
#include "ICPRequestHandlerFactory.h"

#define ISISDAE_MAX_DAE2TIMECHAN        65500

#define LV_NUM_TIME_REGIMES     6   

static const char* star_line80 = "********************************************************************************\n";
static const char* hash_line80 = "################################################################################\n";

static void nxErrorFunc(void* arg, char* text)
{
    DAEstatus* pStatus = (DAEstatus*)arg;
        pStatus->addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "NEXUS ERROR: %s", text);
}

int ISISinstrumentControl::readTables(const char* wiring, const char* detector, const char* spectra, DAEstatus& status)
{
        static const std::string data_dae = m_app->config().getString("isisicp.datadae.file", "c:\\labview modules\\dae\\data_dae.xml");
        static const bool do_data_dae = m_app->config().getBool("isisicp.datadae.use", false);
        m_crpt->tables_valid = 0;
        m_crpt->n_data_dae = 0;
        if (readWiringTable(wiring, status) == DAEstatus::Failure)
        {
                return DAEstatus::Failure;
        }
        if (readDetectorTable(detector, status) == DAEstatus::Failure)
        {
                return DAEstatus::Failure;
        }
        if (readSpectraTable(spectra, status) == DAEstatus::Failure)
        {
                return DAEstatus::Failure;
        }
        if ( do_data_dae && (readDataDaeTable(data_dae.c_str(), status) == DAEstatus::Failure) )
        {
                return DAEstatus::Failure;
        }
        m_crpt->tables_valid = 1;
        return DAEstatus::Success;
}

ISISinstrumentControl::~ISISinstrumentControl()
{
        Poco::NotificationCenter& notify_centre = Poco::NotificationCenter::defaultCenter();
        notify_centre.removeObserver(Poco::Observer<ICPNotificationHandler,ICPNotification>(m_nh,&ICPNotificationHandler::handleNotification)); 
        const Poco::AbstractObserver& on_progress = Poco::Observer<ICPProgressHandler, Poco::TaskProgressNotification>(m_task_ph, &ICPProgressHandler::onProgress);
        const Poco::AbstractObserver& on_finished = Poco::Observer<ICPProgressHandler, Poco::TaskFinishedNotification>(m_task_ph, &ICPProgressHandler::onFinished);
        m_taskmgr.removeObserver(on_progress);
        m_taskmgr.removeObserver(on_finished);
//      m_beam_current_timer.stop(); // seems to deadlock

        if (m_http_server != NULL)
        {
                m_http_server->stop();
                delete m_http_server;
        }

        killDatasvr(m_status);
        m_shutdown_requested = true;
        Sleep(5000);
        if (se_close() != 0)
        {
                m_status.addInfoVa(FAC_DAE, "Error from SQLITE: %s", se_get_errmsg());
        }
        delete m_dae;
        m_dae = 0;
        flushCRPT(m_status);
        CloseHandle(m_async_complete_event);
        DeleteCriticalSection(&m_crpt_cs);
        delete m_icp_config;
}

static const char* muon_daes[] = { "NDXMUSR", "NDXEMU", "NDXHIFI", "NDXCHRONUS", "NDXARGUS" };

void ISISinstrumentControl::seTransFunction(unsigned int u, EXCEPTION_POINTERS* pExp)
{
        throw Win32StructuredException(u, pExp);
}

void ISISinstrumentControl::purecallHandler()
{
        // int *nullp = NULL; *nullp = 10;    // force an access violation - as we are in "C" maybe C++ exceptions not allowed?
        poco_bugcheck();
        // poco_bugcheck() should throw an exception if no debugger is found, but add next line just in case
        throw std::runtime_error("ISISinstrumentControl::purecallHandler()");
}

_se_translator_function ISISinstrumentControl::registerStructuredExceptionHandler()
{
        if ( m_registersetranslator )
        {
                return _set_se_translator(seTransFunction);
        }
        else
        {
                return NULL;
        }
}

void ISISinstrumentControl::unregisterStructuredExceptionHandler(_se_translator_function old_func)
{
        if ( m_registersetranslator )
        {
                _set_se_translator(old_func);
        }
}

ISISinstrumentControl::ISISinstrumentControl(Poco::Util::Application* pApp, const std::string& icp_service_dir, DAEreport_func_t* func, write_event_log_t* event_func, void* report_arg) : Base(), m_icp_service_dir(icp_service_dir), m_dae(0), 
                                m_shutdown_requested(false), m_period_error(false), m_nexus_files(false), m_vms_raw_files(true), m_use_full_inst_name_for_files(true), 
                                m_icp_options(0),m_event_log_func(event_func),m_num_async_requests(0),m_async_complete_event(NULL),m_app(pApp),
                                m_beam_current_timer(5 * 1000, 5 * 1000), m_simulation_mode(false), m_registersetranslator(false)
{
        int i;
        DWORD len_comp_name = MAX_COMPUTERNAME_LENGTH + 1;
        char comp_name[MAX_COMPUTERNAME_LENGTH + 1];
        std::string mess;
    char time_buffer[128];

        setLoggerName("InstCtrl");

        if ( m_app->config().getBool("isisicp.registerpurecallhandler", false) )
        { 
                LOGSTR_INFORMATION("Registering \"purecall\" handler");
                _set_purecall_handler(purecallHandler);
        }
        _se_translator_function old_se_trans = NULL;
        if ( m_app->config().getBool("isisicp.registersetranslator", false) )
        {
                LOGSTR_INFORMATION("Using win32 \"Structured Exception translator\" function");
                m_registersetranslator = true;
                old_se_trans = registerStructuredExceptionHandler();
        }

        srand(static_cast<unsigned>(time(NULL)));

        time(&m_icp_start_time);

        Poco::ThreadPool::defaultPool().addCapacity(50);

        const Poco::AbstractObserver& on_progress = Poco::Observer<ICPProgressHandler, Poco::TaskProgressNotification>(m_task_ph, &ICPProgressHandler::onProgress);
        const Poco::AbstractObserver& on_finished = Poco::Observer<ICPProgressHandler, Poco::TaskFinishedNotification>(m_task_ph, &ICPProgressHandler::onFinished);
        m_taskmgr.addObserver(on_progress);
        m_taskmgr.addObserver(on_finished);

        GetComputerName(comp_name, &len_comp_name);
        comp_name[len_comp_name] = '\0';

        m_comp_name = comp_name;

        m_icp_dir = m_icp_service_dir + "\\..\\..\\..";  // remove the "x64\release" bit of path (should be same as PLATFORM_SUFFIX)

        m_data_dir = "c:\\data";
        m_log_dir = m_data_dir + "\\log";

        CoInitializeEx(NULL, COINIT_MULTITHREADED);

        LOG_INFORMATION("startup");

        // emergency defaults until assignICPLogFiles() is called properly
        mkdir(m_data_dir.c_str());
        mkdir(m_log_dir.c_str());
        m_crpt.assignLogFiles(m_log_dir + "\\startup");

        // this is used in lockCRPT() and unlockCRPT()
        InitializeCriticalSection(&m_crpt_cs);

        SECURITY_ATTRIBUTES sec_attr = { sizeof(SECURITY_ATTRIBUTES), NULL, FALSE };
        m_async_complete_event = CreateEvent(&sec_attr, FALSE, FALSE, NULL);

        ISOtime(time(NULL), time_buffer, sizeof(time_buffer));

        m_status.addInfo(FAC_CRPT, hash_line80);
        m_status.addInfoVa(FAC_CRPT, "ISIS ICP Starting from %s at %s\n", m_icp_service_dir.c_str(), time_buffer);
        m_status.addInfoVa(FAC_CRPT, "SVN revision %s (%s, %s %s, %s)\n", ICPSVN_Revision.c_str(), ICPSVN_Date.c_str(), ICPSVN_Mixed.c_str(), ICPSVN_Range.c_str(), ICPSVN_Modified.c_str());
        m_status.addInfoVa(FAC_CRPT, "SVN Source repository %s\n", ICPSVN_URL.c_str());
        m_status.addInfoVa(FAC_CRPT, "SELOGGER with %s\n", se_version());

        // stop the DAE server process and start it in suspended state. We do this so that we do not inherit too many handles from ISISICP
        killDatasvr(m_status);
        HANDLE datasvr_thread = launchDatasvr(m_status);

        m_icp_config = new LabviewXML(m_status);
        Poco::Path icp_config_path(m_icp_dir, "icp_config.xml");
        std::string icp_config_file = icp_config_path.absolute().toString();
        LOGSTR_INFORMATION("Loading ICP config from \"" << icp_config_file << "\"");
        if (m_icp_config->loadFromFile(icp_config_file.c_str(), m_status) == DAEstatus::Failure)
        {
                mess = "*** ISIS ICP STARTUP FAILED (cannot load " + icp_config_file + ") ***";
                exitProgram(mess, true);
        }
        std::string tempstr;
        if (m_icp_config->getValue("InstDataDir", tempstr, m_status) == DAEstatus::Success)
        {
                m_data_dir = tempstr;
        }
        else
        {
                m_data_dir = "c:\\data";
        }
        if (m_icp_config->getValue("InstLogDir", tempstr, m_status) == DAEstatus::Success)
        {
                m_log_dir = tempstr;
        }
        else
        {
                m_log_dir = m_data_dir + "\\log";
        }
        mkdir(m_data_dir.c_str());
        mkdir(m_log_dir.c_str());

        m_recovery_file = m_data_dir + "\\recovery.run";

        m_status.setReportFunction(func, report_arg);
        m_status.reportImmediately(true);
        m_report_func = func;
        m_report_arg = report_arg;
        
        //      sendSMS("07766422175", "icp starting", m_status);

        Poco::NotificationCenter& notify_centre = Poco::NotificationCenter::defaultCenter();
        notify_centre.addObserver(Poco::Observer<ICPNotificationHandler,ICPNotification>(m_nh,&ICPNotificationHandler::handleNotification)); 

        if (ISISRAW::size_check() == -1)
        {
                mess = "*** ISIS ICP STARTUP FAILED (raw size mismatch) ***";
                exitProgram(mess, true);
        }
        printComputerMemoryStats(m_status);
    // determine DAE type
        m_dae_type = ISISDAE::NeutronDAE2;
        for(i=0; i<sizeof(muon_daes) / sizeof(const char*); i++)
        {
                if (stricmp(m_comp_name.c_str(), muon_daes[i]) == 0)
                {
                        m_dae_type = ISISDAE::MuonDAE2;
                }
        }
        if (m_icp_config->getValue("DAEType", i, m_status) == DAEstatus::Success)
        {
                m_dae_type = (ISISDAE::DAEType)i;
        }
        m_status.addInfoVa(FAC_CRPT, "Setting DAE type to %s on %s", ISISDAE::DAEType_desc[m_dae_type], m_comp_name.c_str());
        if (m_dae_type == ISISDAE::MuonDAE2 || m_dae_type == ISISDAE::MuonDAE3)
        {
                m_nexus_files = true;
                m_vms_raw_files = false;
                m_use_full_inst_name_for_files = true;          
                m_run_number_digits = 8;
        }
        else if (m_dae_type == ISISDAE::NeutronDAE2 || m_dae_type == ISISDAE::NeutronDAE3)
        {
                m_use_full_inst_name_for_files = false;  // use inst_abrv instead               
                m_nexus_files = false;
                m_vms_raw_files = true;
                m_run_number_digits = 5;
        }
        else
        {
                m_status.addInfoVa(FAC_CRPT, "Unknown DAE type %d", m_dae_type);
                mess = "*** ISIS ICP STARTUP FAILED (Cannot determine DAE Type) ***";
                exitProgram(mess, true);
        }
        if (m_icp_config->getValue("NeXusFiles", i, m_status) == DAEstatus::Success)
        {
                m_nexus_files = (i == 1 ? true : false);
        }
        if (m_icp_config->getValue("VMSRawFiles", i, m_status) == DAEstatus::Success)
        {
                m_vms_raw_files = (i == 1 ? true : false);
        }
        if (m_icp_config->getValue("InstSettingsDir", tempstr, m_status) == DAEstatus::Success)
        {
                m_inst_settings_dir = tempstr;
        }
        else
        {
                m_inst_settings_dir = "c:\\labview modules\\dae";
        }
        if (m_icp_config->getValue("RunDigits", i, m_status) == DAEstatus::Success)
        {
                m_run_number_digits = i;
        }
        if (m_run_number_digits > 5)
        {
                m_use_full_inst_name_for_files = true;  // change the default           
        }
        if (m_icp_config->getValue("UseFullInstNameForFiles", i, m_status) == DAEstatus::Success)
        {
                m_use_full_inst_name_for_files = (i == 1 ? true : false);
        }
        if (m_icp_config->getValue("AutoSave", i, m_status) == DAEstatus::Success)
        {
                if (i != 0)
                {
                        m_icp_options |= AutoSave;
                }
                else
                {
                        m_icp_options &= ~AutoSave;
                }
        }
        if (m_icp_config->getValue("PeriodSequenceAutoEnd", i, m_status) == DAEstatus::Success)
        {
                if (i != 0)
                {
                        m_icp_options |= PeriodSequenceAutoEnd;
                }
                else
                {
                        m_icp_options &= ~PeriodSequenceAutoEnd;
                }
        }
        if (m_icp_config->getValue("PerCycleJournal", i, m_status) == DAEstatus::Success)
        {
                if (i != 0)
                {
                        m_icp_options |= PerCycleJournal;
                }
                else
                {
                        m_icp_options &= ~PerCycleJournal;
                }
        }

        m_status.addInfoVa(FAC_CRPT, "Run digits = %d", m_run_number_digits);
        m_nxwriter.setRunNumberDigits(m_run_number_digits);
        m_simulation_mode = false;
        if (m_icp_config->getValue("Simulate", i, m_status) == DAEstatus::Success)
        {
                m_simulation_mode = (i == 1 ? true : false);
        }
        bool endian_workaround = true;
        if (m_icp_config->getValue("VXIType", i, m_status) == DAEstatus::Success)
        {
                if (i == 1)
                {
                        endian_workaround = false;
                }
        }
        m_dae = new ISISDAE(m_dae_type, m_status, endian_workaround, m_simulation_mode);
        // we used to have "DAEDevice" - now we have "DAEDevice0", "DAEDevice1" etc.
        // check for new names and, if none found, try old name
        char dae_tag[60];
        std::string dae_device;
        bool dae_found = false;
        for(i=0; i < 256; i++)
        {
                _snprintf(dae_tag, sizeof(dae_tag), "DAEDevice%d", i);
                if (m_icp_config->getValue(dae_tag, dae_device, m_status) == DAEstatus::Success)
                {
                        dae_found = true;
                        m_dae->open(dae_device.c_str(), m_status);
                }
                else
                {
                        break;
                }
        }
        if (!dae_found)  // look for old format string
        {
                if (m_icp_config->getValue("DAEDevice", dae_device, m_status) == DAEstatus::Failure)
                {
                        dae_device = "ISISDAE0";
                }
                m_dae->open(dae_device.c_str(), m_status);
        }
        if (m_icp_config->getValue("DAEBackplane", dae_device, m_status) == DAEstatus::Success)
        {
                m_dae->openBackplane(dae_device.c_str(), m_status);
        }
        m_dae->check(m_status);
        bool noinit = false;
        if (m_icp_config->getValue("SkipInit", i, m_status) == DAEstatus::Success)
        {
                noinit = (i == 1 ? true : false);
        }
        if (m_status >= SEV_FATAL)
        {
                mess = "*** ICP failed to start - your DAE may be switched OFF or is missing cards ***\r\n" 
                        "*** Please check " + m_log_dir + "\\icp-*.log and " + m_crpt.debugLog() + " ***";
                exitProgram(mess, true);
//              noinit = true;
        }

        // load CRPT from disk
        // we need to do this after VISA is loaded or we seem to get problems with address mapping
        ICPCritical cs(&m_crpt_cs);
        float temp_f;
        if (m_icp_config->getValue("MinTCBWidth", temp_f, m_status) == DAEstatus::Success)
        {
                std::string res = Poco::format("ISISICP_MIN_TCBWIDTH=%f", static_cast<double>(temp_f));
                putenv(res.c_str());
        }
        if ( (loadCRPT() == DAEstatus::Failure) || !m_crpt.isValid())
        {
                mess = "ICP failed to start - " + m_data_dir + "\\CURRENT.RUN is either corrupt or locked out by another process; check " + m_log_dir + "\\icp*.log and " + m_crpt.debugLog();
                exitProgram(mess, true);
        }

        m_crpt.setICPStartTime(m_icp_start_time);

        // maybe impersonate a different instrument to one based on our computer name
        if (m_icp_config->getValue("InstName", tempstr, m_status) == DAEstatus::Success)
        {
                m_crpt->setInstName(tempstr);
        }

        m_status.resetSeverityToAtMost(SEV_WARNING);
        writeRecoveryFile(m_status);

        // now we have a proper CRPT, we can get proper log filenames
        m_crpt.assignLogFiles(m_use_full_inst_name_for_files, m_data_dir, m_run_number_digits);

        // sync ICP clock to CRPT
        ICPClock* icp_clock = g_icp_clock.get();
        icp_clock->setParameters(m_crpt->icp_clock.perf_counter, m_crpt->icp_clock.proc_freq, m_crpt->icp_clock.filetime);

        FILETIME icp_ft, system_ft;
        icp_clock->getCurrentTimeAsFiletime(icp_ft);
        GetSystemTimeAsFileTime(&system_ft);
        m_status.addInfoVa(FAC_DAE, "icp - system time in millisec = %f", diffFileTimesInMilliSec(system_ft, icp_ft));

        m_crpt->setDAESpecificParameters();   // @todo this can almost be removed as done when crpt rebuilt
                                                                                  // Only issue is checking ISISICP_MIN_TCBWIDTH env variable

        strncpy(m_crpt->comp_name, m_comp_name.c_str(), sizeof(m_crpt->comp_name));
        NULL_TERMINATE(m_crpt->comp_name);

        if (m_icp_config->getValue("AlertEmail", m_crpt->alert_email, sizeof(m_crpt->alert_email), true, m_status) == DAEstatus::Failure)
        {
                m_crpt->alert_email[0] = '\0';
        }
        if (m_icp_config->getValue("UAmpScale", m_crpt->uamp_scale, m_status) == DAEstatus::Failure)
        {
                m_crpt->uamp_scale = 1.0;
        }
        m_dae->setUAmpScale(m_crpt->uamp_scale);
        if (m_icp_config->getValue("CompressionLevel", m_crpt->compression_level, m_status) == DAEstatus::Failure)
        {
                m_crpt->compression_level = 1;
        }
        if (m_icp_config->getValue("CompressionBlockSize", m_crpt->compression_block_size, m_status) == DAEstatus::Failure)
        {
                m_crpt->compression_block_size = 8;
        }
        m_crpt_run = new CRPTProxy();
        m_crpt_run->createFrom(m_crpt, m_crpt->run_number, true, m_status);
        cs.unlock();
//      se_profile("c:\\faa.log");
        if (se_set_run_number(m_crpt->run_number) != 0)
        {
                m_status.addInfoVa(FAC_DAE, "Error from SQLITE: %s", se_get_errmsg());
        }
        if (se_set_period(m_crpt->software_period) != 0)
        {
                m_status.addInfoVa(FAC_DAE, "Error from SQLITE: %s", se_get_errmsg());
        }

        logEventVa(m_crpt, m_status, "ICP_STARTUP_SUCCESS - SVN revision %s (%s, %s %s, %s)", ICPSVN_Revision.c_str(), ICPSVN_Date.c_str(), ICPSVN_Mixed.c_str(), ICPSVN_Range.c_str(), ICPSVN_Modified.c_str());
        _snprintf(m_crpt->icp_version, sizeof(m_crpt->icp_version), "SVN R%s (%s, %s %s, %s)", ICPSVN_Revision.c_str(), ICPSVN_Date.c_str(), ICPSVN_Mixed.c_str(), ICPSVN_Range.c_str(), ICPSVN_Modified.c_str());
        NULL_TERMINATE(m_crpt->icp_version);
        if (noinit)
        {
                m_status.addInfo(FAC_DAE, "Started DAE in NOINIT mode");
        }
        else
        {
                if (m_crpt->run_status == RUNSTATUS_RUNNING)
                {
                        stopDataCollection(ISISDAE::StopRunFast, m_status);
                        setupDAE(1, m_status);
                        startDataCollection(false, m_status);
                }
                else
                {
                        setupDAE(1, m_status);
                }
                _beginthread(updateThread, 0, this);
                Poco::TimerCallback<ISISinstrumentControl>* beam_current_callback = new Poco::TimerCallback<ISISinstrumentControl>(*this, &ISISinstrumentControl::beamCurrentTimerCallback);
//              m_beam_current_timer.start(*beam_current_callback);   // seems to deadlock on exit
        }
        ISOtime(time(NULL), time_buffer, sizeof(time_buffer));

        // now set data server running
        ResumeThread(datasvr_thread);
        CloseHandle(datasvr_thread);

        // need to keep a list of these connections to remove?   std::list<boost::signals2::connection>
//      m_dae->addGoodEventCallback(boost::bind(&CRPTProxy::histogramEventsToCRPT, boost::ref(m_crpt), _1, _2, _3, _4));
        m_crpt_signals = m_dae->addGoodEventCallback(boost::bind(&CRPTProxy::histogramEventsToCRPT, boost::ref(m_crpt), boost::ref(*m_crpt_run), _1, _2, _3, _4));

        startEventWriter(m_status);
        m_dae->startEventBroadcaster(m_crpt);
        m_icpwriter.setup(m_crpt.CRPT(), m_dae, m_run_number_digits, m_status);

        Poco::RunnableAdapter<ISISinstrumentControl>* ra = new Poco::RunnableAdapter<ISISinstrumentControl>(*this, &ISISinstrumentControl::readBeamloggerBroadcast); // a memory leak, but only once - avoids race condition
        m_beamlog_thread.start(*ra);
        
        bool enable_web_server = m_app->config().getBool("isisicp.services.web", true);
        if (enable_web_server)
        {
                Poco::UInt16 http_server_port = m_app->config().getInt("isisicp.services.web.port", 10999);
                Poco::Net::HTTPServerParams* http_params = new Poco::Net::HTTPServerParams;
                http_params->setMaxQueued(100);
                http_params->setMaxThreads(5);
                m_http_svs = new Poco::Net::ServerSocket(http_server_port);
                m_http_server = new Poco::Net::HTTPServer(new ICPRequestHandlerFactory(m_crpt.CRPT()), *m_http_svs, http_params);
                m_http_server->start();
        }
        else
        {
                m_http_svs = NULL;
                m_http_server = NULL;
        }

        // look for previous failed ends
        if ( m_app->config().getBool("isisicp.failedends.rerun", false) )
        {
                        rerunFailedEnds();
        }
        m_status.addInfoVa(FAC_CRPT, "***\n*** ISIS ICP STARTUP COMPLETE %s, current run number %d, status is %s\n***", 
                time_buffer, m_crpt->run_number, m_crpt->runStatusName());
        unregisterStructuredExceptionHandler(old_se_trans);
        if (strlen(m_crpt->epics_lastread_iso) == 0)
        {
                ISOtime(time(NULL), m_crpt->epics_lastread_iso, sizeof(m_crpt->epics_lastread_iso));
                m_crpt->epics_lastread_nano = 0;
        }
        m_epics_data.run_number = &(m_crpt->run_number);
        m_epics_data.inst_name = m_crpt->inst_name;
        m_epics_data.lastread_iso = m_crpt->epics_lastread_iso;
        m_epics_data.lastread_nano = m_crpt->epics_lastread_nano;
        if (m_app->config().getBool("isisicp.epicsdb.use", false))
        {
                se_start_epics_thread(&m_epics_data);
        }
}

void ISISinstrumentControl::rerunFailedEnds()
{
        // need to be able to load crpt read-only
        // also missing se blocks?
        std::set<std::string> files;
        Poco::Path search_expr("c:\\data\\current.run[0-9]?[0-9]*"); // poco glob is shell like not RE like
        Poco::Glob::glob(search_expr, files, Poco::Glob::GLOB_CASELESS);
        Poco::RegularExpression re("current.run([0-9]+)", Poco::RegularExpression::RE_CASELESS);
        Poco::RegularExpression::MatchVec matches;
        Poco::SharedPtr<Poco::Event> finish_event(new Poco::Event);
        BOOST_FOREACH(const std::string& file, files)
        {
                re.match(file, 0, matches);
                if (matches.size() == 2)
                {
                        int run_num = Poco::NumberParser::parse(file.substr(matches[1].offset, matches[1].length));
                        if ( run_num != m_crpt->run_number )
                        {
                                m_status.addInfoVa(FAC_CRPT, "Re-ending run %d", run_num); 
                                Poco::SharedPtr<CRPTProxy> prev_run(new CRPTProxy());
                                prev_run->loadCRPT(Poco::format("c:\\data\\current.run%d", run_num).c_str(), 
                                        Poco::format("c%d", run_num).c_str(), 
                                        Poco::format("c:\\data\\data.run%d", run_num).c_str(), 
                                        Poco::format("d%d", run_num).c_str(), m_crpt.rawDataSizeMax(), false, m_status);
                                if ( prev_run->CRPT() != NULL )
                                {
                                        GenericTask<int>* end_task = new GenericTask<int>(Poco::format("rerunFailedEnds %d", run_num), finish_event,
                                                boost::bind(&ISISinstrumentControl::endRunTask, this, prev_run, 
                                                boost::ref(m_nxwriter),
                                                m_app->config().getBool("isisicp.failedends.keepfiles", false),
                                                m_app->config().getBool("isisicp.failedends.keepfiles", false),
                                                "",
                                                boost::ref(m_status)));
                                        m_taskmgr.start(end_task);
                                }
                                else
                                {
                                        LOGSTR_ERROR("Unable to reload CRPT to re-end run " << run_num);
                                }
                        }
                }
        }
}

int ISISinstrumentControl::writeWinEventLog(int sev, const std::string& message)
{
        if (m_event_log_func != NULL)
        {
                return (*m_event_log_func)(sev, message.c_str(), m_report_arg);
        }
        else
        {
                return 0;
        }
}

void ISISinstrumentControl::updateThread(void* arg)
{
    int poll_time = 0;
        ISISinstrumentControl* ic = (ISISinstrumentControl*)arg;
        DAEstatus& dstatus = ic->getStatusReporter();
        _se_translator_function old_se_trans = ic->registerStructuredExceptionHandler();
        while(!ic->shutdownRequested())
        {
                poll_time = ic->getPollTime();
                if (poll_time > 0)
                {
                        Sleep(poll_time * 1000);
                        try
                        {
                                ic->updateFunc(poll_time, false);
                        }
                        catch(const std::exception& ex)
                        {
                                dstatus.addWarningVa(FAC_DAE, "Exception in updateThread: %s", ex.what());
                        }
                }
                else
                {
                        Sleep(5 * 1000);
                }
        }
        ic->unregisterStructuredExceptionHandler(old_se_trans);
}


// load existing CRPT from disk and create mapped section
int ISISinstrumentControl::loadCRPT()
{
        int crpt_data_size;
        if (m_icp_config->getValue("CRPTSize", crpt_data_size, m_status) == DAEstatus::Failure)
        {
                crpt_data_size = 200 * 1000 * 1000;  // 800Mb roughly
        }
        std::string crpt_file = m_data_dir + "\\current.run";
        std::string crpt_data_file = m_data_dir + "\\data.run";
        std::string crpt_name = "isis_current";
        std::string crpt_data_name = "isis_data";
        return m_crpt.loadOrCreateCRPT(crpt_file, crpt_name, crpt_data_file, crpt_data_name, crpt_data_size, m_dae_type, m_comp_name, 
                                                                boost::bind(&ISISinstrumentControl::readRecoveryFile, this, _1), m_status);
}

int ISISinstrumentControl::flushCRPT(DAEstatus& status, bool flush_raw_data)
{
//      status.addDebugVa(FAC_CRPT, "Flushing %d bytes of CRPT", nbytes);
//      ICPCritical cs(&m_crpt_cs);
        return m_crpt.flushCRPT(status, flush_raw_data);
}

int ISISinstrumentControl::changePeriodWhileRunning(int period, bool pause_first, DAEstatus& status)
{
        bool did_pause = false;
        ICPCritical cs(&m_crpt_cs);;
        if (pause_first && m_crpt->run_status != RUNSTATUS_PAUSED && m_crpt->run_status != RUNSTATUS_SETUP)
        {
                pauseRunMain(false, status);   // do not update cache to save time; alos we get called from updateFunc 
                did_pause = true;
        }
        changePeriod(period, status);
        if (did_pause)
        {
                resumeRun(status);
        }
        return DAEstatus::Success;
}

int ISISinstrumentControl::changePeriod(int period, DAEstatus& status)
{
        ICPCritical cs(&m_crpt_cs);
        if (m_crpt->run_status != RUNSTATUS_PAUSED && m_crpt->run_status != RUNSTATUS_SETUP)
        {
                status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Can only change period in PAUSED or SETUP state");
                return DAEstatus::Failure;
        }
        if (period < 0 || period >= m_crpt->nper)
        {
                status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "period %d is invalid\n", period+1);
                return DAEstatus::Failure;
        }
        if (m_crpt->period_type != ISISDAE::PeriodTypeSoftware)
        {
                return DAEstatus::Success;
        }
//      int per, daq_per;
//      getCurrentPeriodNumber(per, daq_per, status);
//      if (period != per)
//      {
                int daq_period = getDAQPeriod(period, status);
                m_dae->changePeriod(period, daq_period, status);
                if (m_crpt->period_type == ISISDAE::PeriodTypeSoftware)
                {
                        m_crpt->software_period = period;
                        if (period != daq_period)
                        {
                                status.addWarningVa(FAC_CRPT, "Software period mismatch %d != %d\n", period, daq_period);
                        }
                }
//      }
//      else
//      {
//              status.addInfoVa(FAC_CRPT, "Already in period %d\n", period+1);
//      }
        if (se_set_period_async(period) != 0)
        {
                status.addInfoVa(FAC_DAE, "Error from SQLITE: %s", se_get_errmsg());
        }
        logEventVa(m_crpt, status, "CHANGE_PERIOD %d", period+1);
        // what to do if we had changed period while monitoring was out of range?
        m_crpt->monitoring.return_period = -1;   // period
        refreshCachedValues(status);
        return DAEstatus::Success;
}

int ISISinstrumentControl::startDataCollection(bool clear_counters, DAEstatus& status)
{
        ICPCritical cs(&m_crpt_cs);
        LOGSTR_DEBUG("startDataCollection");
        int period, daq_period;
        getCurrentPeriodNumber(period, daq_period, status);
        PERIOD& p = m_crpt->period[period];
        int irf, igf;
        float goodua;
        if (clear_counters)
        {
                irf = igf = 0;
                goodua = 0.0;
        }
        else
        {
                irf = getRawFrames(status);
                igf = getGoodFrames(status);
                goodua = getGoodUAmpH(status);
        }
        m_dae->startRun(clear_counters, m_crpt->run_number, m_crpt->resume_time, status);
        if (p.start_time == 0)          // 0 means first time this period has started
        {
                p.start_time = m_crpt->resume_time;
        }
        logEventVa(m_crpt->resume_time, m_crpt, status, "START_COLLECTION PERIOD %d GF %d RF %d GUAH %f", 
                period + 1, igf, irf, goodua);
        return 0;
}

int ISISinstrumentControl::stopDataCollection(ISISDAE::StopRunMode mode, DAEstatus& status)
{
        LOGSTR_DEBUG("stopDataCollection");
        isisU32_t value32;
        int i;
        ICPCritical cs(&m_crpt_cs);;
        ICPTimer icptimer1;
        m_dae->stopRun(mode, status);
        m_dae->disableDelayedStart(status);

        // force an update so if people do GET("IRPB") the latest values are returned
        // we do this here rather than at the end as decisions are made based on isRunning()
        // for the interpretation of various crpt items in the updateFunc() and those decisions
        // are valid at this point
        
        // now done in relevant commands  
        // refreshCachedValues(status);

        int period, daq_period;
        getCurrentPeriodNumber(period, daq_period, status);
        m_dae->getCurrentPeriodSequence(&value32, status);
        m_crpt->nperseq = value32;
        status.addInfoVa(FAC_DAE, "Run stopped in period %d (DAQ %d), sequence %d", period+1, daq_period+1, value32);
        PERIOD* p = &(m_crpt->period[period]);
        time(&(m_crpt->stop_time));
        time_t dur = 0;
        if (m_crpt->resume_time != 0)
        {
                dur = m_crpt->stop_time - m_crpt->resume_time;
        }
        m_crpt->duration += dur;
        p->stop_time = m_crpt->stop_time;
        p->duration += dur;
        isisU32_t igf, irf;
        m_dae->getGoodFrames(&igf, status);
        m_dae->getRawFrames(&irf, status);
        p->good_frames += (igf - m_crpt->good_frames);
        p->total_frames += (irf - m_crpt->total_frames);
        m_crpt->good_frames = igf;
        m_crpt->total_frames = irf;
        float goodua = m_dae->getGoodUAmpHours(status);
        float totalua = m_dae->getRawUAmpHours(status);
        p->good_uamph += (goodua - m_crpt->good_uamph);
        p->total_uamph += (totalua - m_crpt->total_uamph);

        logEventVa(m_crpt->stop_time, m_crpt, status, "STOP_COLLECTION PERIOD %d GF %d RF %d GUAH %f DUR %d", 
                                        period + 1, igf, irf, goodua, dur);
        status.addInfoVa(FAC_DAE, "Good/Total uAH = %f / %f", goodua, totalua);
        m_crpt->good_uamph = goodua;
        m_crpt->total_uamph = totalua;
        m_dae->getGoodPPPLower(&(m_crpt->good_ppp_low), status);
        m_dae->getGoodPPPUpper(&(m_crpt->good_ppp_high), status);
        m_dae->getRawPPPLower(&(m_crpt->total_ppp_low), status);
        m_dae->getRawPPPUpper(&(m_crpt->total_ppp_high), status);
        if (m_crpt->period_type != ISISDAE::PeriodTypeSoftware)
        {
                for(i=0; i<m_crpt->nper; i++)
                {
                        p = &(m_crpt->period[i]);
                        m_dae->getRawFramesPeriod(&irf, i, status);
                        m_dae->getGoodFramesPeriod(&igf, i, status);
                        p->good_frames = igf;
                        p->total_frames = irf;
                        p->good_uamph = m_dae->getGoodUAmpHoursPeriod(i, status);
                        p->total_uamph = m_dae->getRawUAmpHoursPeriod(i, status);
                }
        }
        m_dae->getSMPVetoedFrames(&(m_crpt->vetos[SMPVeto].frames), status);
        m_dae->getMSModeVetoedFrames(&(m_crpt->vetos[MSModeVeto].frames), status);
        m_dae->getExternalVetoedFrames(0, &(m_crpt->vetos[Ext0Veto].frames), status);
        m_dae->getExternalVetoedFrames(1, &(m_crpt->vetos[Ext1Veto].frames), status);
        m_dae->getExternalVetoedFrames(2, &(m_crpt->vetos[Ext2Veto].frames), status);
        m_dae->getExternalVetoedFrames(3, &(m_crpt->vetos[Ext3Veto].frames), status);
        m_dae->getFIFOVetoedFrames(&(m_crpt->vetos[FIFOVeto].frames), status);
        m_dae->getTS2PulseVetoedFrames(&(m_crpt->vetos[TS2PulseVeto].frames), status);
        m_dae->getISIS50HzVetoedFrames(&(m_crpt->vetos[ISIS50HzVeto].frames), status);
        
        icptimer1.info("stopDataCollection()", status);

        return 0;
}

#define MAX_RC_RETRY    5


int ISISinstrumentControl::RCretry(const char* name, boost::function<int(ISISinstrumentControl*,DAEstatus&)> func, DAEstatus& status)
{
        int i, stat = DAEstatus::Failure;
        for(i=1; i <= MAX_RC_RETRY; i++)
        {
                try
                {
                        status.resetSeverityToAtMost(SEV_WARNING);
                        stat = func(this, status);
                        if (status.OK())
                        {
                                break;
                        }
                        Sleep(1000);
                }
                catch(const std::exception& ex)
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Exception in RCretry(%s, attempt %d): %s", name, i, ex.what());
                }
                catch(...)
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Exception in RCretry(%s, attempt %d): unknown", name, i);
                }
        }
        if (i > 1)
        {
                status.addWarningVa(FAC_DAE, "%s was tried %d times", name, i);
        }
        return stat;
}


int ISISinstrumentControl::beginRun(DAEstatus& status)
{
        return RCretry("BEGIN", boost::bind(&ISISinstrumentControl::beginRunMain, _1, _2), status);
}

int ISISinstrumentControl::beginRunEx(bool start_paused, bool delayed_start, long period, DAEstatus& status)
{
        return RCretry("BEGIN", boost::bind(&ISISinstrumentControl::beginRunMainEx, _1, start_paused, delayed_start, period, _2), status);
}

int ISISinstrumentControl::beginRunMain(DAEstatus& status)
{
        return beginRunMainEx(false, false, -1, status);
}

// period = -1 means do not reset period
int ISISinstrumentControl::beginRunMainEx(bool start_paused, bool delayed_start, long period, DAEstatus& status)
{
        int i;
        if (m_crpt->run_status != RUNSTATUS_SETUP)
        {
                status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Can only BEGIN in SETUP state");
                return DAEstatus::Failure;
        }
        if (!m_crpt->isInitialised())
        {
                status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "CRPT is not initialised - please set experiment parameters");
                return DAEstatus::Failure;
        }
        if ( !m_crpt->tables_valid )
        {
                status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Cannot BEGIN run - current combination of wiring, detector and spectra tables is inconsistent");
                return DAEstatus::Failure;
        }
        m_period_error = false;
        ICPTimer icptimer;
        ICPCritical cs(&m_crpt_cs);
        status.addInfoVa(FAC_DAE, "BEGIN run %d", m_crpt->run_number);
        updateCycle(status);
        g_icp_clock.get()->syncToSystemTime();
        g_icp_clock.get()->getParameters(m_crpt->icp_clock.perf_counter, m_crpt->icp_clock.proc_freq, m_crpt->icp_clock.filetime);

        // on excitations instruments tcb.dat may have got changed without a full experimental setup being done
        bool reread_tcb_file = false;
        for(i=0; i<m_crpt->ntrg; ++i)
        {
                const TCBRANGE* tcr = m_crpt->tcr[i];
                if ( (tcr[0].mode == TCBRANGE_FILE) && (tcr[0].tcb_file.hasFileChanged(status)) )
                {
                        status.addInfoVa(FAC_TCB, "Re-reading time channels from %s", tcr[0].tcb_file.fname);
                        reread_tcb_file = true;
                }
        }
        if (reread_tcb_file)
        {
                if (tcbcalc(status) == DAEstatus::Failure)
                {
                        return DAEstatus::Failure;
                }
        }
        if (m_crpt->wiring_table.hasFileChanged(status))
        {
                status.addWarningVa(FAC_DAE, "Wiring table %s has changed since last load; old values will still be used", m_crpt->wiring_table.fname);
        }
        if (m_crpt->detector_table.hasFileChanged(status))
        {
                status.addWarningVa(FAC_DAE, "Detector table %s has changed since last load; old values will still be used", m_crpt->detector_table.fname);
        }
        if (m_crpt->spectra_table.hasFileChanged(status))
        {
                status.addWarningVa(FAC_DAE, "Spectra table %s has changed since last load; old values will still be used", m_crpt->spectra_table.fname);
        }
        if (m_crpt->data_dae_table.hasFileChanged(status))
        {
                status.addWarningVa(FAC_DAE, "Data dae table %s has changed since last load; old values will still be used", m_crpt->data_dae_table.fname);
        }
        for(i=0; i<ISISCRPT_NUM_VETOS; i++)
        {
                m_crpt->vetos[i].frames = 0;
        }
        for(i=0; i<ISISCRPT_MAX_PERIOD; i++)
        {
                m_crpt->period[i].duration = 0;
                m_crpt->period[i].good_frames = 0;
                m_crpt->period[i].good_uamph = 0;
                m_crpt->period[i].start_time = 0;
                m_crpt->period[i].stop_time = 0;
                m_crpt->period[i].total_frames = 0;
                m_crpt->period[i].total_uamph = 0;
                m_crpt->period[i].total_ppp_low = 0;
                m_crpt->period[i].total_ppp_high = 0;
                m_crpt->period[i].good_ppp_low = 0;
                m_crpt->period[i].good_ppp_high = 0;
        }
        m_crpt->good_frames = 0;
        m_crpt->total_frames = 0;
        m_crpt->good_uamph = 0.0;
        m_crpt->total_uamph = 0.0;
        m_crpt->good_ppp_low = 0;
        m_crpt->good_ppp_high = 0;
        m_crpt->total_ppp_low = 0;
        m_crpt->total_ppp_high = 0;
        // shouldn't happen, but nasty if it does
        if (m_crpt->nper <= 0)
        {
                m_crpt->nper_daq = m_crpt->nper = 1;
        }
        if (m_crpt->nper > ISISCRPT_MAX_PERIOD || m_crpt->nper_daq > ISISCRPT_MAX_PERIOD)
        {
                status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Invalid number of periods %d, %d", m_crpt->nper, m_crpt->nper_daq);
                return DAEstatus::Failure;
        }
        if (m_crpt->period_type == ISISDAE::PeriodTypeSoftware)
        {
                if (period >= 0 && period < m_crpt->nper)
                {
                        m_crpt->software_period = period;
                }
                if (m_crpt->software_period < 0 || m_crpt->software_period >= m_crpt->nper)
                {
                        status.addWarningVa(FAC_DAE, "Software period %d out of range; resetting to 1", m_crpt->software_period+1);
                        m_crpt->software_period = 0;
                }
                else
                {
                        status.addInfoVa(FAC_DAE, "Run started in software period %d", m_crpt->software_period+1);
                }
        }
        else
        {
                m_crpt->software_period = 0;
        }
        m_crpt->resume_time = 0;
        m_crpt->duration = 0;
        m_crpt->stop_time = 0;
//      m_crpt->sav_file_count = 0;    // only do this on an end as we may begin, store, abort, begin
        m_crpt->auto_save_last = 0;
        m_crpt->update_num_polls = 0;
        m_crpt->update_total_counts = 0;
        m_crpt->update_good_uamph = 0.0;
        m_crpt->update_raw_uamph = 0.0;
        m_crpt->update_good_frames = 0;
        m_crpt->update_raw_frames = 0;

        m_crpt->monitoring.last_gf = 0;
        m_crpt->monitoring.last_tc = 0;
        m_crpt->monitoring.last_ua = 0.0;

        m_crpt->nperseq = 0;

        Poco::Thread zero_crpt("zero_crpt"), zero_crpt_run("zero_crpt_run");
        Poco::RunnableAdapter<ISISinstrumentControl> zc_runnable(*this, &ISISinstrumentControl::zeroCRPTRawData);
        Poco::RunnableAdapter<ISISinstrumentControl> zcr_runnable(*this, &ISISinstrumentControl::zeroCRPTRunRawData);
        zero_crpt.start(zc_runnable);
        LOGSTR_DEBUG("zero_crpt thread id " << zero_crpt.tid());
        zero_crpt_run.start(zcr_runnable);
        LOGSTR_DEBUG("zero_crpt_run thread id " << zero_crpt_run.tid());

        setupDAE(0, status);

        zero_crpt.join();
        zero_crpt_run.join();

        if (delayed_start)
        {
                m_dae->enableDelayedStart(status);
        }
        if (status.OK())
        {
                time(&(m_crpt->start_time));
                m_icpwriter.start();  // start_time is used in NXlog, we may adjust later so NeXevEventWriter will call setOffset()
                if (start_paused)
                {
                        m_crpt->stop_time = m_crpt->start_time;
                        m_dae->clearCounters(m_crpt->run_number, status);
                        setRunStatusImp(RUNSTATUS_PAUSED, true, status);
                }
                else if (m_crpt->se_status == SESTATUS_INRANGE)
                {
                        startDataCollection(true, status);
                        m_crpt->start_time = m_crpt->resume_time; // real data collection start time
                        setRunStatusImp(RUNSTATUS_RUNNING, true, status);
                }
                else
                {
                        m_crpt->stop_time = m_crpt->start_time;
                        m_dae->clearCounters(m_crpt->run_number, status);
                        setRunStatusImp(RUNSTATUS_WAITING, true, status);
                }
        }
        if (status.OK())
        {
                logEvent(m_crpt->start_time, m_crpt, "BEGIN", status);
                startEventWriter(status);   // run before postcommand so that file any old file descriptor is not inherited
                runPostCommand("isisicp.startruncmd", padWithZeros(m_crpt->run_number, m_run_number_digits), status);
        }
        else
        {
                logEvent(m_crpt, "FAILED_BEGIN", status);
                setRunStatusImp(RUNSTATUS_SETUP, true, status);
        }
        refreshCachedValues(status);
        flushCRPT(status);
//      m_dae->printStatus(oss, status);
//      m_status.addInfo(FAC_DAE, oss.str());
        icptimer.info("BEGIN", status);
        return status.result();
}

int ISISinstrumentControl::createLastrunFile(const CRPTProxy& crpt, DAEstatus& status)
{
        std::string lastrun_file = m_app->config().getString("isisicp.lastrunfile", "c:\\data\\lastrun.txt");
        std::string run_num_string = padWithZeros(crpt->run_number, m_run_number_digits);
        std::string sav_file_count = padWithZeros(crpt->sav_file_count, 2);
        std::string file_prefix = (m_use_full_inst_name_for_files ? crpt->inst_name : crpt->inst_abrv);
        try
        {
                std::fstream fs(lastrun_file, std::ios::out | std::ios::trunc);
                fs << file_prefix << " " << run_num_string << " " << sav_file_count << std::endl;
                fs.close();
                return DAEstatus::Success;
        }
        catch(const std::exception& ex)
        {
                status.addWarningVa(FAC_DAE, "createLastrunFile failed %s", ex.what());
                return DAEstatus::Failure;
        }
}

int ISISinstrumentControl::runPostCommand(const char* property_name, const std::string& arg, DAEstatus& status)
{
        std::string run_command = m_app->config().getString(property_name, "");
        if ( run_command.size() > 0 )
        {
                std::string out_file = getPostCommandLogName();
                return spawnCommand(run_command, arg, true, false, NULL, "", out_file, out_file, 0, status);
        }
        else
        {
                status.addWarningVa(FAC_DAE, "runPostCommand cannot find property %s", property_name);
                return status.result();
        }
}

int ISISinstrumentControl::startEventWriter(DAEstatus& status)
{
        return 0;

//      if (m_crpt->run_status == RUNSTATUS_SETUP)
//      {
//              return 0;
//      }
//      m_nxeventwriter.stop(true);
//      IXNeXusFile* ix = new IXNeXusFile(nxErrorFunc, &m_status);
//      ix->open(Poco::format("c:\\data\\test%d.nxs", m_crpt->run_number).c_str(), IXNeXusFile::Write);
//      m_nxeventwriter.start(m_crpt.CRPT(), ix, true);
//      return 0;
}

int ISISinstrumentControl::stopEventWriter(bool wait, DAEstatus& status)
{
        return 0;

//      if (wait)
//      {
//              m_nxeventwriter.wait();
//      }
//      m_nxeventwriter.stop(true);
//      return 0;
}

bool ISISinstrumentControl::isRunning()
{
        return m_crpt->isRunning();
}

int ISISinstrumentControl::getRunState()
{
        return m_crpt->run_status;
}

int ISISinstrumentControl::getRunNumber()
{
        return m_crpt->run_number;
}

int ISISinstrumentControl::RIO(isis32_t bus_addr, isisU16_t& word, DAEstatus& status)
{
        isisU32_t value;
        switch(bus_addr)
        {
                case 1544:
                        m_dae->getGoodFrames(&value, status);
                        word = (value & 0xffff);
                        break;
                case 1548:
                        m_dae->getGoodFrames(&value, status);
                        word = (value >> 16) & 0xffff;
                        break;
                case 1552:
                        m_dae->getRawFrames(&value, status);
                        word = (value & 0xffff);
                        break;
                case 1556:
                        m_dae->getRawFrames(&value, status);
                        word = (value >> 16) & 0xffff;
                        break;
                case 2208:
                        m_dae->getRawPPPLower(&value, status);
                        word = (value & 0xffff);
                        break;
                case 2210:
                        m_dae->getRawPPPLower(&value, status);
                        word = (value >> 16) & 0xffff;
                        break;
                case 2212:
                        m_dae->getRawPPPUpper(&value, status);
                        word = (value & 0xffff);
                        break;
                case 2224:
                        m_dae->getGoodPPPLower(&value, status);
                        word = (value & 0xffff);
                        break;
                case 2226:
                        m_dae->getGoodPPPLower(&value, status);
                        word = (value >> 16) & 0xffff;
                        break;
                case 2228:
                        m_dae->getGoodPPPUpper(&value, status);
                        word = (value & 0xffff);
                        break;
                default:
                        status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "RIO: unknown address %d\n",  bus_addr);
                        return DAEstatus::Failure;                      
                        break;
        }
        return DAEstatus::Success;
}

// only call when already have CRPT lock 
int ISISinstrumentControl::setupDAE(int tables_only, DAEstatus& dstatus)
{
        static bool run_external_reset_cmds = Poco::Util::Application::instance().config().getBool("isisicp.daereset.run");
        std::map<int,int> trcn;
        int i, j, dae1_vetos[30];
        unsigned len;
        dstatus.addInfo(FAC_CRPT, "Setting up DAE");
        int ic, maxcrate = -1, maxcard = -1, maxdae = -1;
        for(i=0; i<m_crpt->ndet; i++)
        {
                if ( (j = (m_crpt->crat[i])) > maxcrate )
                {
                        maxcrate = j;
                }
                if ( (j = (m_crpt->crat[i] % DAE2CardPolicy::CRATE_MOD)) > maxcard )
                {
                        maxcard = j;
                }
                if ( (j = (m_crpt->crat[i] / DAE2CardPolicy::CRATE_MOD)) > maxdae )
                {
                        maxdae = j;
                }
        }
        dstatus.addInfoVa(FAC_CRPT, "Highest dae, detector card, crate number used = %d, %d, %d", maxdae, maxcard, maxcrate);           
        // all detectors on a given card must be in the same time regime
        std::map<int,int>::iterator tr_it;
        bool dae_event_mode = false;
        for(j=0; j<m_crpt->ndet; j++)
        {
                ic = m_crpt->crat[j];
                if ( (tr_it = trcn.find(ic)) != trcn.end() )
                {
                        if ( m_crpt->daeTR(tr_it->second) != m_crpt->timr_dae[j] )
                        {
                                dstatus.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Detectors with different DAE time regimes not allowed on same card: %d != %d", m_crpt->daeTR(tr_it->second) , m_crpt->timr_dae[j]);
                                return DAEstatus::Failure;
                        }
                }
                else
                {
                        trcn.insert(std::map<int,int>::value_type(ic, m_crpt->fullTR(j)));
                }
                if (m_crpt->timr_dae[j] > m_crpt->ntrg || m_crpt->timr_crpt[j] > m_crpt->ntrg || m_crpt->timr_file[j] > m_crpt->ntrg)
                {
                        dstatus.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "DAE or CRPT time regime > %d for detector %d", m_crpt->ntrg, m_crpt->udet[j]);
                        return DAEstatus::Failure;
                }
                if ( (m_crpt->det_mode[j] & 0x1) != 0 )
                {
                        dae_event_mode = true;
                }
        }
        for(tr_it = trcn.begin(); tr_it != trcn.end(); ++tr_it)
        {
                if (tr_it->second < 1)
                {
                        dstatus.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Invalid time regime %d for crate %d", tr_it->second, tr_it->first);
                        return DAEstatus::Failure;
                }
        }
        if (m_crpt->ntrg > ISISCRPT_MAX_NTRG)
        {
                dstatus.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Up to %d time regimes allowed", ISISCRPT_MAX_NTRG);
                return DAEstatus::Failure;
        }
        dstatus.addInfoVa(FAC_CRPT, "Number of time regimes = %d", m_crpt->ntrg);
        // size of a period
        unsigned permax = m_crpt->getPeriodSize();
        len = permax * m_crpt->nper_daq;
// neeed to check if enough DAE memory in detector cards
        if ( len > m_crpt.rawDataSizeMax() )
        {
                dstatus.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Not enough CRPT memory for requested (spectra * time channels * periods)");
                return DAEstatus::Failure;
        }
        if ( m_crpt->nper > ISISCRPT_MAX_PERIOD )
        {
                dstatus.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Too many periods %d (>%d) specified", m_crpt->nper, ISISCRPT_MAX_PERIOD);
                return DAEstatus::Failure;
        }
        if ( m_crpt->nper_daq > ISISCRPT_MAX_PERIOD )
        {
                dstatus.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Too many daq periods %d (>%d) specified", m_crpt->nper_daq, ISISCRPT_MAX_PERIOD);
                return DAEstatus::Failure;
        }
        dstatus.addInfoVa(FAC_CRPT, "CRPT memory used for histograms = %u Mb", (len * 4) / (1024 * 1024));
    dstatus.addInfoVa(FAC_CRPT, "Number of periods (daq, total) = (%d, %d)",  m_crpt->nper_daq, m_crpt->nper);
        dstatus.addInfo(FAC_CRPT, "Resetting DAE - ignore veto counter values as not yet cleared");
        if ( run_external_reset_cmds && (tables_only == 0) )
        {
                dstatus.addInfo(FAC_CRPT, "Running external DAE reset commands");
                typedef std::pair<std::string,std::string> string_pair_t;
                std::list< string_pair_t > commands;
                m_dae->getExternalResetCommands(commands, dstatus);
                std::string out_file = getPostCommandLogName();
                BOOST_FOREACH(const string_pair_t& comm, commands)
                {
                        dstatus.addInfoVa(FAC_CRPT, "Running: %s %s", comm.first.c_str(), comm.second.c_str());
                        spawnCommand(comm.first, comm.second, true, false, NULL, "", out_file, out_file, 30, dstatus);                  
                }
        }
        // need to set event mode flag in dae/dc card before programming poslut - this is so when updateAddmap
        // and fillAddmap are called they know event mode will be used
        m_dae->setEventMode(dae_event_mode);
        m_dae->clearDCEventMode(dstatus);
        for(tr_it = trcn.begin(); tr_it != trcn.end(); ++tr_it)
        {
                m_dae->setDCEventMode(tr_it->first, m_crpt->isEventTR(tr_it->second), dstatus);
                m_dae->setDCCardMode(tr_it->first, true, dstatus);
        }
        // set event mode on any data into dae cards
        for(i=0; i<m_crpt->n_data_dae; ++i)
        {
                m_dae->setDCEventMode(m_crpt->data_dae[i].crate, true, dstatus);
                m_dae->setDCCardMode(m_crpt->data_dae[i].crate, false, dstatus);
        }
    if (tables_only == 0)
        {
                m_dae->stopRun(ISISDAE::StopRunFast/*ISISDAE::StopRunDiscard*/, dstatus);
                m_dae->resetRunController(dstatus);
                m_dae->clearHistogramMemory(dstatus);
        }
        else
        {
                m_dae->stopRun(ISISDAE::StopRunFast, dstatus);
                m_dae->resetRunController(dstatus);
                dstatus.addInfo(FAC_CRPT, "RELOAD TABLES ONLY requested - DAE memory not zeroed");
        }
        // TCG
        // prescale
        dstatus.addInfo(FAC_CRPT, "Programming Time channels");
        // need to allow for the prescale and delay 
        //std::vector<unsigned long*> new_tcb;
        //for(i=0; i<m_crpt->ntrg; ++i)
        //{
        //      new_tcb.push_back(new unsigned long[1+m_crpt->ntc[i]]);
        //}
        m_dae->setFrameSyncDelay(m_crpt->tcb_delay, dstatus);
        unsigned long* new_tcb = 0;
        float frame_delay;
        for(int k=0; k<m_crpt->ntrg; ++k)
        {
                new_tcb = new unsigned long[1+m_crpt->ntc[k]];
// if we have a pulse generator, we want the first channel at 0
// as we use this to signal the first bin
                if (m_crpt->tcb_pulse_generator != 0)
                {
                        frame_delay = (float)m_crpt->tcb[k][0] / m_crpt->clock_frequency;
                        dstatus.addInfoVa(FAC_CRPT, "PULSE_GENERATOR: frame delay %f us",  m_crpt->tcb_delay + frame_delay);
                        for(i=0; i <= m_crpt->ntc[k]; i++)
                        {
// tcb are in clock pulses, delay is in us hence * 32
                                new_tcb[i] = m_crpt->tcb[k][i] - m_crpt->tcb[k][0];
                                if ( (new_tcb[i] & 0xff000000) != 0 )
                                {
                                        dstatus.addWarningVa(FAC_CRPT, "TCG value larger than 24 bits %lu", new_tcb[i]);
                                        new_tcb[i] = 0xffffff;
                                }
                        }
                }
                else
                {
                        dstatus.addInfoVa(FAC_CRPT, "Global Frame sync delay = %d us", m_crpt->tcb_delay);
                        dstatus.addInfoVa(FAC_CRPT, "Electronics delay = %d clock pulses", m_crpt->electronics_delay);
                        for(i=0; i <= m_crpt->ntc[k]; i++)
                        {
// tcb are in clock pulses, delay is in us hence * 32
//                      new_tcb1[i] = tcb1[i] * pre1  + (4 * delay) * 32;
// get 0.21us for free (7 clock pulses)
                                new_tcb[i] = m_crpt->tcb[k][i] - m_crpt->electronics_delay;
                                if ( (new_tcb[i] & 0xff000000) != 0 )
                                {
                                        dstatus.addWarningVa(FAC_CRPT, "TCG value larger than 24 bits %lu", new_tcb[i]);
                                        new_tcb[i] = 0xffffff;
                                }
                        }
                }
                for(tr_it = trcn.begin(); tr_it != trcn.end(); ++tr_it)
                {
                        int dae_tr = m_crpt->daeTR(tr_it->second);
                        if ( dae_tr == k+1 )
                        {
                                if ( m_crpt->ntc[k] > ISISDAE_MAX_DAE2TIMECHAN )
                                {
                                        dstatus.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Too many time channels %d (> %d) for time regime %d (card %d)", 
                                                m_crpt->ntc[k], ISISDAE_MAX_DAE2TIMECHAN, dae_tr, tr_it->first);
                                        return DAEstatus::Failure;
                                }
                                dstatus.addInfoVa(FAC_CRPT, "Setting %d time channels from %f to %f us on card %d", m_crpt->ntc[k], (double)new_tcb[0] / m_crpt->clock_frequency, 
                                        (double)new_tcb[m_crpt->ntc[k]] / m_crpt->clock_frequency, tr_it->first);
                                m_dae->setTimeChannels(tr_it->first, new_tcb, m_crpt->ntc[k], dstatus);
                                int det_fs_delay = m_crpt->tcb_trdelay[dae_tr - 1];
                                dstatus.addInfoVa(FAC_CRPT, "Setting FS delay on DC %d to %d us", tr_it->first, det_fs_delay);
                                m_dae->setDCFrameSyncDelay(tr_it->first, det_fs_delay, dstatus);
                        }
                }
                // set tcb on any data into dae cards
                for(i=0; i<m_crpt->n_data_dae; ++i)
                {
                        int dae_tr = m_crpt->daeTR(m_crpt->data_dae[i].tr);
                        int crate = m_crpt->data_dae[i].crate;
                        if ( dae_tr == k+1 )
                        {
                                if ( m_crpt->ntc[k] > ISISDAE_MAX_DAE2TIMECHAN )
                                {
                                        dstatus.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Too many time channels %d (> %d) for time regime %d (card %d)", 
                                                m_crpt->ntc[k], ISISDAE_MAX_DAE2TIMECHAN, dae_tr, crate);
                                        return DAEstatus::Failure;
                                }
                                dstatus.addInfoVa(FAC_CRPT, "Setting %d time channels from %f to %f us on data dae DC %d", m_crpt->ntc[k], (double)new_tcb[0] / m_crpt->clock_frequency, 
                                        (double)new_tcb[m_crpt->ntc[k]] / m_crpt->clock_frequency, crate);
                                m_dae->setTimeChannels(crate, new_tcb, m_crpt->ntc[k], dstatus);
                                int det_fs_delay = m_crpt->tcb_trdelay[dae_tr - 1];
                                dstatus.addInfoVa(FAC_CRPT, "Setting FS delay on data dae DC %d to %d us", crate, det_fs_delay);
                                m_dae->setDCFrameSyncDelay(crate, det_fs_delay, dstatus);
                        }
                }
                delete []new_tcb;
        }
        dstatus.addInfo(FAC_DAE, "Programming POSLUT");
        m_dae->programDAE1POSLUT(m_crpt->crat, maxcrate, m_crpt->modn, 
                m_crpt->mpos, m_crpt->spec, m_crpt->ndet, m_crpt->nper_daq, dstatus);

        updateSpecmapsFromDAE(trcn, dstatus);
        
        m_dae->setFrameSync(m_crpt->tcb_sync, m_crpt->muon_cerenkov_pulse, dstatus);
        //
        if (m_crpt->period_type != ISISDAE::PeriodTypeSoftware)
        {
                dstatus.addInfo(FAC_CRPT, "Hardware periods enabled");
        }
        else
        {
                dstatus.addInfo(FAC_CRPT, "Software periods enabled");
        }
        // period card
        isisU32_t val32;
        isisU16_t val16_0, val16_1;
        if (m_crpt->period_type == ISISDAE::PeriodTypeSoftware)
        {
                // for safety, tell it to use one long period...
                val32 = 0;
                val16_0 = 0;
                val16_1 = 15000;
                dstatus.addInfo(FAC_CRPT, "(setting period card, if present, to 1 hardware period of 15000 frames)");   
                m_dae->programPeriodCard((ISISDAE::PeriodType)m_crpt->period_type, 1, 0, &val32, 
                        &val16_0, &val16_1, m_crpt->period_output_delay, dstatus);
                m_dae->disablePeriodCard(dstatus);
        }
        else
        {
                dstatus.addInfo(FAC_CRPT, "Programming PERIOD card for hardware period control");       
                isisU32_t* outputs = new isisU32_t[m_crpt->nper];
                isisU16_t* dwell_flags = new isisU16_t[m_crpt->nper];
                isisU16_t* frames = new isisU16_t[m_crpt->nper];
                for(i=0; i<m_crpt->nper; i++)
                {
                        outputs[i] = m_crpt->period[i].output;
                        dwell_flags[i] = (m_crpt->period[i].type == 2 ? 1 : 0);
                        frames[i] = static_cast<isisU16_t>(m_crpt->period[i].requested_frames);
                }
                m_dae->programPeriodCard((ISISDAE::PeriodType)m_crpt->period_type, m_crpt->nper, m_crpt->nperseq_request, 
                        outputs, dwell_flags, frames, m_crpt->period_output_delay, dstatus);
        // The period card currently uses a cable plugged into the enviroment card
        // external veto port to do dwell periods; thus we always need to enable
        // external vetos on the environment card
        // howevere the new env period card does not ...
        //      m_crpt->ext_vetos[0] = 1;
                delete[] outputs; delete[] dwell_flags; delete[] frames;
        }
        bool single_daq_period = (1 == m_crpt->nper_daq);
        m_dae->setPeriodType((ISISDAE::PeriodType)m_crpt->period_type, single_daq_period, dstatus);
        if (m_crpt->period_type == ISISDAE::PeriodTypeSoftware)
        {
                changePeriod(m_crpt->software_period, dstatus);
//              m_dae->changePeriod(m_crpt->software_period, m_crpt->software_period, dstatus); // adjust for current period
        }
        dstatus.addInfo(FAC_CRPT, "Setting vetos");
        dae1_vetos[0] = m_crpt->vetos[SMPVeto].enabled;
        dae1_vetos[1] = m_crpt->vetos[Ext0Veto].enabled;
        dae1_vetos[2] = m_crpt->vetos[Ext1Veto].enabled;
        dae1_vetos[3] = m_crpt->vetos[Ext2Veto].enabled;
        dae1_vetos[4] = m_crpt->vetos[Ext3Veto].enabled;
        dae1_vetos[5] = m_crpt->vetos[FermiChopperVeto0].enabled;
        dae1_vetos[6] = m_crpt->fermi_chopper_delay[0];
        dae1_vetos[7] = m_crpt->fermi_chopper_width[0];
        dae1_vetos[8] = m_crpt->vetos[TS2PulseVeto].enabled;
        dae1_vetos[9] = m_crpt->vetos[ISIS50HzVeto].enabled;
        m_dae->setDAE1Vetos(dae1_vetos, 10, dstatus);
// we do not start a run, just setup the DAE
    if (tables_only == 0)
        {
                dstatus.addInfo(FAC_CRPT, "Clearing frames, vetos and PPP counters");
                m_dae->clearCounters(dstatus);
        }
//      dstatus.addDebug(FAC_CRPT, "Leaving VME DAEBEG");       
        return DAEstatus::Success;
}

int ISISinstrumentControl::pauseRun(DAEstatus& dstatus)
{
        return pauseRunMain(true, dstatus);
}

int ISISinstrumentControl::pauseRunMain(bool refresh_cache, DAEstatus& dstatus)
{
        if (m_crpt->run_status == RUNSTATUS_SETUP)
        {
                dstatus.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Cannot PAUSE in SETUP");
                return DAEstatus::Failure;
        }
        if (m_crpt->run_status == RUNSTATUS_PAUSED)
        {
                dstatus.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Run already paused");
                return DAEstatus::Failure;
        }
        ICPCritical cs(&m_crpt_cs);
        dstatus.addInfoVa(FAC_CRPT, "Pausing run %d", m_crpt->run_number);
//      dstatus.addDebug(FAC_CRPT, "Entering VME DAEPAUSE");
        if (isRunning())
        {
                stopDataCollection(ISISDAE::StopRunClean, dstatus);
        }
        setRunStatusImp(RUNSTATUS_PAUSED, false, dstatus);
        logEvent(m_crpt, "PAUSE", dstatus);
//      isisU32_t igfc, irfc;
//      m_dae->stopRun(dstatus);
//      m_dae->getRawFrames(&irfc, dstatus);
//      m_dae->getGoodFrames(&igfc, dstatus);
//      m_crpt->period[m_crpt->c_period].good_frames += igfc;
//      m_crpt->period[m_crpt->c_period].raw_frames += irfc;
// return 0 as the frame count to avoid overcounting. DAE1 zerod these
// counters on stop/start data collection, but DAE-II doesn't

//      dstatus.addDebug(FAC_DAE, "Leaving VME DAEPAUSE");
        if (refresh_cache)
        {
                refreshCachedValues(dstatus);
        }
        flushCRPT(dstatus);
        return DAEstatus::Success;
}


int ISISinstrumentControl::abortRun(DAEstatus& dstatus)
{
        if (m_crpt->run_status == RUNSTATUS_SETUP)
        {
                dstatus.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Cannot ABORT in SETUP");
                return DAEstatus::Failure;
        }
        ICPCritical cs(&m_crpt_cs);
        dstatus.addInfoVa(FAC_CRPT, "Aborting run %d", m_crpt->run_number);
        if (isRunning())
        {
                stopDataCollection(ISISDAE::StopRunFast/*ISISDAE::StopRunDiscard*/, dstatus);
        }
        setRunStatusImp(RUNSTATUS_SETUP, false, dstatus);
        logEvent(m_crpt, "ABORT", dstatus);
        m_crpt->software_period = 0;
        refreshCachedValues(dstatus);
        flushCRPT(dstatus);
        return DAEstatus::Success;
}

int ISISinstrumentControl::startSEWait(DAEstatus& dstatus)
{
        ICPCritical cs(&m_crpt_cs);
        m_crpt->se_status = SESTATUS_OUTOFRANGE;
        if (isRunning())
        {
                LOGSTR_INFORMATION("Start SE wait");
                stopDataCollection(ISISDAE::StopRunFast, dstatus);
                setRunStatusImp(RUNSTATUS_WAITING, false, dstatus);
                logEvent(m_crpt, "WAIT_START", dstatus);
        }
        return DAEstatus::Success;
}

int ISISinstrumentControl::endSEWait(DAEstatus& dstatus)
{
        ICPCritical cs(&m_crpt_cs);
        m_crpt->se_status = SESTATUS_INRANGE;
        if (isWaiting())
        {
                LOGSTR_INFORMATION("End SE wait");
                logEvent(m_crpt, "WAIT_FINISH", dstatus);
                startDataCollection(false, dstatus);
                setRunStatusImp(RUNSTATUS_RUNNING, false, dstatus);
        }
        return DAEstatus::Success;
}

bool ISISinstrumentControl::isWaiting()
{
        return m_crpt->run_status == RUNSTATUS_WAITING;
}

int ISISinstrumentControl::resumeRun(DAEstatus& dstatus)
{
        if (m_crpt->run_status != RUNSTATUS_PAUSED)
        {
                dstatus.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Can only RESUME from PAUSED");
                return DAEstatus::Failure;
        }
        ICPCritical cs(&m_crpt_cs);
        dstatus.addInfoVa(FAC_CRPT, "Resuming run %d", m_crpt->run_number);
//      dstatus.addDebug(FAC_CRPT, "Entering VME DAERESUME");
        logEvent(m_crpt, "RESUME", dstatus);
        if (m_crpt->se_status == SESTATUS_INRANGE)
        {
                startDataCollection(false, dstatus);
                setRunStatusImp(RUNSTATUS_RUNNING, false, dstatus);
        }
        else
        {
                logEvent(m_crpt, "WAIT_START", dstatus);
                setRunStatusImp(RUNSTATUS_WAITING, false, dstatus);
        }
//      dstatus.addDebug(FAC_CRPT, "Leaving VME DAERESUME");
        return dstatus.result();
}

int ISISinstrumentControl::saveRun(DAEstatus& dstatus)
{
        ICPCritical cs(&m_crpt_cs);
        dstatus.addInfo(FAC_CRPT, "Saving run");
//      dstatus.addDebug(FAC_CRPT, "Entering VME DAESAVE");
        logEvent(m_crpt, "SAVE", dstatus);
        updateCRPTWithDAE(true, dstatus);
        if (dstatus.OK())
        {
                storeCRPT(dstatus);
        }
        return dstatus.result();
}


int ISISinstrumentControl::updateCRPTWithDAE(bool pause_collection, DAEstatus& dstatus)
{
        ICPCritical cs(&m_crpt_cs);
        logEvent(m_crpt, "UPDATE", dstatus);
        return updateCRPTWithDAE(m_crpt, pause_collection, dstatus);
}

int ISISinstrumentControl::updateCRPTwithSE(CRPTProxy& crpt, const seblock_map_t& blocks, DAEstatus& dstatus)
{
        ICPTimer icptimer("updateCRPTwithSE", dstatus);
        updateSampleParameters(crpt.sampleParameters(), crpt, &blocks, dstatus);
        updateBeamlineParameters(crpt.beamlineParameters(), crpt, &blocks, dstatus);
        return DAEstatus::Success;
}

int ISISinstrumentControl::updateCRPTWithDAE(CRPTProxy& crpt, bool pause_collection, DAEstatus& dstatus)
{
        ICPTimer icptimer("updateCRPTWithDAE", dstatus);
        int permax = crpt->getPeriodSize();
        int len = permax * crpt->nper_daq;
        dstatus.addInfoVa(FAC_CRPT, "%d DAQ periods of size %d words", crpt->nper_daq, permax);
        if ( len > crpt.rawDataSizeMax() )
        {
                dstatus.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Not enough CRPT memory for requested (spectra * time channels * periods)");
                return DAEstatus::Failure;
        }
        ICPTimer icptimer1;
        if (crpt->isRunning() && pause_collection && (crpt->period_type == ISISDAE::PeriodTypeSoftware) )
        {
                stopDataCollection(ISISDAE::StopRunClean, dstatus);
                Poco::Mutex::ScopedLock _lock(crpt.getDataLockRef());   // necessary? this will freeze out other trheads from reading/writing
                icptimer1.start();   // restart timer in case stopDataCollection() takes a bit of time
                m_dae->readAllDAE1Spectra(crpt.rawData(), len, crpt->spec_to_crpt_offset.data(), permax, dstatus);
                // m_dae->readHistogramMemory(0, m_crpt->raw_data, len, dstatus);
                startDataCollection(false, dstatus);
        }
        else
        {
//              dstatus.addInfo(FAC_CRPT, "Performed live CRPT snapshot\n");
                Poco::Mutex::ScopedLock _lock(crpt.getDataLockRef());    // necessary? this will freeze out other trheads from reading/writing
                m_dae->readAllDAE1Spectra(crpt.rawData(), len, crpt->spec_to_crpt_offset.data(), permax, dstatus);
                // m_dae->readHistogramMemory(0, m_crpt->raw_data, len, dstatus);
        }
        crpt.rawDataUpdated();
    double up_time = icptimer1.info("UPDATE", dstatus);
        if (up_time > 0.0)
        {
                dstatus.addInfoVa(FAC_DAE, "Average DAE transfer rate = %d KByte / s", (int)((len * 4.0) / (1000.0 * up_time)) );
        }
        crpt.flushCRPT(dstatus);
        return dstatus.result();
}

int ISISinstrumentControl::importCRPT(const char* filename, DAEstatus& dstatus)
{
        ICPCritical cs(&m_crpt_cs);
        ICPTimer icptimer;
        readISISRAW(filename, dstatus);
        flushCRPT(dstatus);
        logEvent(m_crpt, "IMPORT", dstatus);
    icptimer.info("IMPORT timing", dstatus);
        return dstatus.result();
}

int ISISinstrumentControl::getSE(const CRPTProxy& crpt, seblock_map_t& blocks, DAEstatus& dstatus)
{
        ICPTimer icptimer("getSE", dstatus);
        if (se_get_blocks(crpt->run_number, crpt->start_time, blocks) != 0)
        {
                dstatus.addInfoVa(FAC_DAE, "SQLITE error %s", se_get_errmsg());
        }
        return DAEstatus::Success;
}

int ISISinstrumentControl::checkForNoncountingDetectors(const CRPTProxy& crpt, DAEstatus& dstatus)
{
        static const int CARD_MOD = 100; // module numbers are 0->15 so this shift the card/crate number away from this
        static const bool check_noncount = m_app->config().getBool("isisicp.noncountingdetectors.check", false);
        static const bool email_noncount = m_app->config().getBool("isisicp.noncountingdetectors.email", false);
        struct crat_id_t
        { 
                uint64_t c; 
                int s; 
                int u;
                crat_id_t() : c(0), s(0), u(0) { }
        };
        typedef std::map<int,crat_id_t> crat_map_t;
        if ( !check_noncount )
        {
                return DAEstatus::Success;
        }
        crat_map_t crat_map;
        std::ostringstream oss;
        int id;
        long integral;
        for(int i=0; i<crpt->ndet; ++i)
        {
                id = CARD_MOD * crpt->crat[i] + crpt->modn[i];
                getCRPTSpectrumIntegral(crpt->spec[i], 1, 0, &integral, dstatus);
                crat_id_t& ci = crat_map[id]; 
                ci.c += integral;
                ci.s = crpt->spec[i];
                ci.u = crpt->udet[i];
        }
        for(crat_map_t::const_iterator it = crat_map.begin(); it != crat_map.end(); ++it)
        {
                if (it->second.c == 0)
                {
                        oss << "Run: " << crpt->run_number << " uAh: " << crpt->good_uamph << " Title: \"" << crpt->long_title << "\"\n";
                        oss << "DAE Crate " << (it->first / DAE2CardPolicy::CRATE_MOD) / DAE2CardPolicy::CRATE_MOD << " detector card id " << (it->first / DAE2CardPolicy::CRATE_MOD) % DAE2CardPolicy::CRATE_MOD << " DIM/module " << it->first % DAE2CardPolicy::CRATE_MOD << " has no counts (e.g. spectrum=" << it->second.s << ",UDET=" << it->second.u << ")\n"; 
                }
        }
        if (oss.str().size() > 0)
        {
                LOGSTR_WARNING(oss.str());
                if ( email_noncount )
                {
                        sendEmail("isisicp@shadow.nd.rl.ac.uk", crpt->alert_email, std::string(crpt->comp_name)+" zero counts in detector DIM", oss.str(), m_status);
                }
        }
        return DAEstatus::Success;
}

int ISISinstrumentControl::saveCRPTToFile(const CRPTProxy& crpt, const std::string& raw_filename, const std::string& nexus_filename, const seblock_map_t& blocks, const std::string& events_nxfile, DAEstatus& dstatus)
{
        ICPTimer icptimer("saveCRPTToFile", dstatus);
        if (raw_filename.size() > 0)
        {
                remove(raw_filename.c_str());
        }
        if (nexus_filename.size() > 0)
        {
                remove(nexus_filename.c_str());
        }
        bool do_nexus = ( m_nexus_files && (nexus_filename.size() > 0) );
        if (m_dae_type == ISISDAE::MuonDAE2 || m_dae_type == ISISDAE::MuonDAE3)
        {
                dstatus.addInfoVa(FAC_DAE, "Writing muon data file %s", nexus_filename.c_str());
                m_nxwriter.writeMuonFile(nexus_filename.c_str(), crpt.CRPT(), crpt.rawData(), crpt.rawDataSizeMax(), blocks, m_inst_settings_dir, m_instrument_xml_file, m_instrument_parameter_map_file, dstatus);
                createLastrunFile(crpt, dstatus);
                runPostCommand("isisicp.exportfilecmd", nexus_filename.c_str(), dstatus);
        }
        else
        {
                Poco::SharedPtr<Poco::Event> finish_event(new Poco::Event);
                if ( do_nexus )
                {
                        dstatus.addInfoVa(FAC_DAE, "Writing nexus data file %s", nexus_filename.c_str());
                        GenericTask<int>* nexus_task = new GenericTask<int>(Poco::format("saveCRPTToFile %d", crpt->run_number), finish_event, 
                                boost::bind(&ISISinstrumentControl::writeISISNeXus, 
                                boost::ref(m_nxwriter), boost::cref(crpt), nexus_filename.c_str(), false, boost::cref(blocks), 
                                boost::cref(events_nxfile), boost::ref(dstatus)));              
                        m_taskmgr.start(nexus_task);
                }
                if ( m_vms_raw_files && (raw_filename.size() > 0) )
                {
                        dstatus.addInfoVa(FAC_DAE, "Writing raw data file %s", raw_filename.c_str());
                        writeISISRAW(crpt, raw_filename.c_str(), dstatus);
                        createLastrunFile(crpt, dstatus);
                        runPostCommand("isisicp.exportfilecmd", raw_filename.c_str(), dstatus);
                }
                if ( do_nexus )
                {
                        finish_event->wait(); // wait for nexus file
                        createLastrunFile(crpt, dstatus);
                        runPostCommand("isisicp.exportfilecmd", nexus_filename.c_str(), dstatus);
                }
        }
        return dstatus.result();
}

int ISISinstrumentControl::updateCRPTWithSEandSaveToFile(CRPTProxy& crpt, const std::string& raw_filename, const std::string& nexus_filename, DAEstatus& dstatus)
{
        static bool use_shadow = Poco::Util::Application::instance().config().getBool("isisicp.shadow.use", false);
        ICPTimer icptimer("updateCRPTWithSEandSaveToFile", dstatus);
        seblock_map_t blocks;
        std::string events_nxfile = "";
        getSE(crpt, blocks, dstatus);
        updateCRPTwithSE(crpt, blocks, dstatus);
        if (use_shadow)
        {
                events_nxfile = "c:\\data\\snap.tmp";
                m_icpwriter.snapshot(events_nxfile);
        }
        saveCRPTToFile(crpt, raw_filename, nexus_filename, blocks, events_nxfile, dstatus);
        return DAEstatus::Success;
}


int ISISinstrumentControl::snapshotCRPT(const char* filename, bool do_update, bool do_pause, DAEstatus& dstatus)
{
        static bool nexus_snapshot = Poco::Util::Application::instance().config().getBool("isisicp.writenexuscrptsnapshot", true);
        ICPCritical cs(&m_crpt_cs);
        if (do_update)
        {
                updateCRPTWithDAE(m_crpt, do_pause, dstatus);
        }
        ICPTimer icptimer;
        Poco::Path file_path(filename);
        file_path.setExtension("");
        updateCRPTWithSEandSaveToFile(m_crpt, file_path.toString()+".raw", (nexus_snapshot ? file_path.toString()+".nxs" : ""), dstatus);

        runPostCommand("isisicp.endcrptsnapshotcmd", filename, dstatus);
        logEventVa(m_crpt, dstatus, "CRPT_SNAPSHOT %s", filename);
    icptimer.info("CRPT_SNAPSHOT", dstatus);
        return dstatus.result();
}

int ISISinstrumentControl::storeCRPT(DAEstatus& status)
{
        ICPCritical cs(&m_crpt_cs);
        return storeCRPT(m_crpt, status);
}

int ISISinstrumentControl::storeCRPT(CRPTProxy& crpt, DAEstatus& dstatus)
{
//      char buffer[256];
        ICPTimer icptimer;
        seblock_map_t blocks;

        if (crpt->sav_file_count < 99)
        {
                ++(crpt->sav_file_count);
        }
        std::string run_num_string = padWithZeros(crpt->run_number, m_run_number_digits);
        std::string file_prefix = (m_use_full_inst_name_for_files ? crpt->inst_name : crpt->inst_abrv);
        std::string sav_file = Poco::format(m_data_dir + "\\%s%s.s%02d", file_prefix, run_num_string, crpt->sav_file_count);
        std::string nx_sav_file = Poco::format(m_data_dir + "\\%s%s.n%03d", file_prefix, run_num_string, crpt->sav_file_count); 
        updateCRPTWithSEandSaveToFile(crpt, sav_file, nx_sav_file, dstatus);
        runPostCommand("isisicp.endstorecmd", Poco::format("%s %02d", run_num_string, crpt->sav_file_count), dstatus);
        flushCRPT(dstatus);
        writeRecoveryFile(dstatus);
        logEvent(crpt, "STORE", dstatus);
    icptimer.info("STORE", dstatus);
        return dstatus.result();
}

int ISISinstrumentControl::writeAutosaveFile(DAEstatus& dstatus)
{
//      char buffer[256];
        ICPCritical cs(&m_crpt_cs);
        ++(m_crpt->auto_save_count);
        if (m_crpt->auto_save_count > 5)
        {
                m_crpt->auto_save_count = 1;
        }
        updateCRPTWithDAE(m_crpt, true, dstatus);
        char letter = static_cast<char>(m_crpt->auto_save_count - 1 + 'A');
        std::string file_prefix = (m_use_full_inst_name_for_files ? m_crpt->inst_name : m_crpt->inst_abrv);
        std::string auto_filename = Poco::format(m_data_dir + "\\%sauto_%c.tmp", file_prefix, letter);
        updateCRPTWithSEandSaveToFile(m_crpt, auto_filename, auto_filename, dstatus);
        runPostCommand("isisicp.endautosavecmd", Poco::format("%sauto_%c.tmp", file_prefix, letter), dstatus);
        flushCRPT(dstatus);
        logEvent(m_crpt, "AUTOSAVE", dstatus);
        return dstatus.result();
}

int ISISinstrumentControl::endRun(DAEstatus& dstatus)
{
        return RCretry("END", boost::bind(&ISISinstrumentControl::endRunMain, _1, _2), dstatus);
}


int ISISinstrumentControl::updateCycle(DAEstatus& dstatus)
{
        // format of file is  "set cycle=cycle_09_1"
        try {
                const char* userprofile = getenv("USERPROFILE");
                std::string commfile = std::string(userprofile != NULL ? userprofile : "") + 
                                                                "\\My Documents\\configurations\\common\\setcycle.cmd";
                std::fstream fs(commfile.c_str(), std::ios::in);
                char buffer[256];
                std::string line;
                if (fs.good())
                {
                        fs.getline(buffer, sizeof(buffer));
                        buffer[sizeof(buffer)-1] = '\0';
                        line = buffer;
                }
                else
                {
                        line = "cycle_??_?";
                }
                strncpy(m_crpt->isis_cycle, line.substr(line.find("_")+1).c_str(), sizeof(m_crpt->isis_cycle)-1);
                return DAEstatus::Success;
        }
        catch(const std::exception& ex) {
                strncpy(m_crpt->isis_cycle, "??_?", sizeof(m_crpt->isis_cycle)-1);
                dstatus.addWarning(FAC_CRPT, ex.what());
                return DAEstatus::Failure;
        }
}


int ISISinstrumentControl::loadCRPTWithHistogrammedEvents(CRPTProxy& crpt, DAEstatus& dstatus)
{
        ICPTimer icptimer("loadCRPTWithHistogrammedEvents", dstatus);
        crpt.zeroEventRawData(dstatus);  // on a normal end this will be zero, but on a re-end may have stuff left in from the failed end
        EventStore es;
        EventStore::FileEventSourceInfo info;
        es.addFileInputSource(crpt->run_number, info);
        es.addGoodEventCallback(boost::bind(&CRPTProxy::histogramEventsToCRPT, crpt.CRPT(), static_cast<ISISCRPT_STRUCT*>(0), crpt.crptData(), static_cast<ISISCRPT_DATA*>(0), _1, _2, _3, _4));
        es.start();
        while (!es.endHeaderSeen())
        {
                Poco::Thread::sleep(500);
        }
        es.stop(false);
        return 0;
}

// need events_nxfile as copy rather than reference as may go out of scope in caller
int ISISinstrumentControl::endRunTask(Poco::SharedPtr<CRPTProxy> crpt, NeXusWriter& nxwriter, bool keep_raw_events, bool keep_crpt, std::string events_nxfile, DAEstatus& status)
{
        bool savehistogramsineventsfile = Poco::Util::Application::instance().config().getBool("isisicp.savehistogramsineventsfile", true);
        static Poco::Semaphore end_semaphore(1);
        DAEstatus dstatus;
        CRPTProxy& crpt_end = *crpt;
        ICPTimer icptimer1, icptimer2;
        if ( crpt_end.CRPT() == NULL )
        {
                LOGSTR_ERROR("CRPT_END is NULL - cannot END");
//              we do not need to crpt_end.uloadCRPT() as it was not loaded  
                return DAEstatus::Failure;
        }
        dstatus.addInfoVa(FAC_CRPT, "ENDing run %d task, thread id %u", crpt_end->run_number, Poco::Thread::currentTid());
        int permax = crpt_end->getPeriodSize();
//      int len = permax * crpt_end->nper_daq;
        dstatus.addInfoVa(FAC_CRPT, "%d DAQ periods of size %d words", crpt_end->nper_daq, permax);

        icptimer2.start();
        std::string file_prefix = (m_use_full_inst_name_for_files ? crpt_end->inst_name : crpt_end->inst_abrv);

        seblock_map_t blocks;
        getSE(crpt_end, blocks, dstatus);
        updateCRPTwithSE(crpt_end, blocks, dstatus);

        // make sure we only do the next bit one at a time - this is purely to avoid excessive CPU as it is
        // actually safe to do all these in parallel
        ScopedSemaphore _sem(end_semaphore);

        if ( savehistogramsineventsfile && (crpt_end->start_time < crpt_end->icp_start_time) )
        {
                LOGSTR_INFORMATION("ICP has been restarted - rehistogramming events");
                loadCRPTWithHistogrammedEvents(crpt_end, dstatus);
        }
        std::string run_num_string = padWithZeros(crpt_end->run_number, m_run_number_digits);
        saveCRPTToFile(crpt_end, Poco::format(m_data_dir + "\\%s%s.raw", file_prefix, run_num_string),
                                                Poco::format(m_data_dir + "\\%s%s.nxs", file_prefix, run_num_string), blocks, 
                                                events_nxfile, dstatus);

    icptimer2.info("File Write", dstatus);
        if (dstatus.OK())
        {
                ICPTimer journal_timer;
                writeJournal(crpt_end, blocks, dstatus);
                journal_timer.info("write journal", dstatus);
                ICPTimer se_clear_timer;
                // clear only this run as others may be pending now we are doing asyn ends 
                if ( !keep_crpt && (se_clear_values(crpt_end->run_number, crpt_end->run_number) != 0) )
                {
                        dstatus.addInfoVa(FAC_DAE, "Error from SQLITE(se_clear_values): %s", se_get_errmsg());
                }
                se_clear_timer.info("se_clear_values", dstatus);
                runPostCommand("isisicp.endruncmd", padWithZeros(crpt_end->run_number, m_run_number_digits), dstatus);
                checkForNoncountingDetectors(crpt_end, dstatus);
                if ( !keep_raw_events )
                {
                        // currently if we haven't done a begin;end;begin the run_number will still be open in ISISDAE
                        // so here we will delete run and run-1 to make sure we carch it eventually

                        // EventStore::deleteOutputFile(crpt_end->run_number-1, dstatus);   // this may remove a previously failed run!
                        EventStore::deleteOutputFile(crpt_end->run_number, dstatus);
                }
                else
                {
                        dstatus.addInfoVa(FAC_DAE, "Keeping raw event files for run %d", crpt_end->run_number);
                }
                if ( keep_crpt )
                {
                        dstatus.addInfoVa(FAC_DAE, "Keeping CRPT for run %d", crpt_end->run_number);
                        crpt_end.unloadCRPT(false, false, dstatus);
                }
                else
                {
                        crpt_end.unloadCRPT(true, true, dstatus);
                }
        }
        else
        {
                dstatus.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Failed to END run %d", crpt_end->run_number);
//              assignICPLogFiles();   // this updates log files for new run number
                crpt_end.unloadCRPT(false, false, dstatus);
        }
        icptimer1.info("END " + run_num_string, dstatus);
        status.add(dstatus, true);
        return dstatus.result();
}

int ISISinstrumentControl::endRunMain(DAEstatus& dstatus)
{
        ICPTimer icptimer1, icptimer2;
        if (m_crpt->run_status == RUNSTATUS_SETUP)
        {
                dstatus.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Cannot END in SETUP");
                return DAEstatus::Failure;
        }
        ICPCritical cs(&m_crpt_cs);
        std::string run_num_string = Poco::format("%d", m_crpt->run_number);
        dstatus.addInfoVa(FAC_CRPT, "ENDing run %d", m_crpt->run_number);
    icptimer2.info("lockCRPT()", dstatus);
        icptimer2.start();
        updateCycle(dstatus);
        if (isRunning())
        {
                stopDataCollection(ISISDAE::StopRunClean, dstatus);
        }
        m_dae->closeEventFiles(dstatus);
        logEvent(m_crpt->stop_time, m_crpt, "END", dstatus);
    icptimer2.info("stopDataCollection()", dstatus);

        icptimer2.start();

        m_dae->clearCallbacks(m_crpt_signals);
        m_crpt_signals.clear();

        m_crpt_run->updateFrom(m_crpt, false, dstatus);

        if (m_crpt->start_time < m_crpt->icp_start_time) // was icp restarted during run?
        {
                LOGSTR_INFORMATION("ICP has been restarted - fast end not possible");
                m_crpt_run->zeroUsedRawData(dstatus);
        }

        updateCRPTWithDAE(*m_crpt_run, false, dstatus);

        m_icpwriter.stop();
        std::string events_nxfile = m_icpwriter.filename();
        stopEventWriter(true, dstatus);

                setRunStatusImp(RUNSTATUS_SETUP, false, dstatus);
                m_crpt->software_period = 0;
                // After we have incremented the run number, all database log calls will do to the
                // new log file. We thus need to do as many outputs as possible before then
                // data written to text files does not see the new number until assignICPLogFiles()
                // is called
                ++(m_crpt->run_number);
                // we need to tell the selogger the new number and then clear out old values
                if (se_set_run_number(m_crpt->run_number) != 0)
                {
                        dstatus.addInfoVa(FAC_DAE, "Error from SQLITE(se_set_run_number): %s", se_get_errmsg());
                }
                m_crpt->sav_file_count = 0;
                writeRecoveryFile(dstatus);
                m_crpt.assignLogFiles(m_use_full_inst_name_for_files, m_data_dir, m_run_number_digits);   // this updates log files for new run number
                flushCRPT(dstatus);
        refreshCachedValues(dstatus);
        Poco::SharedPtr<Poco::Event> finish_event(new Poco::Event);
        GenericTask<int>* end_task = new GenericTask<int>("endRunMain " + run_num_string, finish_event,
                boost::bind(&ISISinstrumentControl::endRunTask, this, m_crpt_run, boost::ref(m_nxwriter), 
                Poco::Util::Application::instance().config().getBool("isisicp.keepraweventfiles", false),
                Poco::Util::Application::instance().config().getBool("isisicp.keependcrpt", false),
                events_nxfile,
                boost::ref(m_status)));
        m_taskmgr.start(end_task);
        if ( !Poco::Util::Application::instance().config().getBool("isisicp.asyncend", false) )
        {
                finish_event->wait();
//              pollUntilTasksComplete(m_taskmgr, 200);
        }

        // create a new proxy for the next run
        m_crpt_run = new CRPTProxy();
        m_crpt_run->createFrom(m_crpt, m_crpt->run_number, true, dstatus);
        m_crpt_signals = m_dae->addGoodEventCallback(boost::bind(&CRPTProxy::histogramEventsToCRPT, boost::ref(m_crpt), boost::ref(*m_crpt_run), _1, _2, _3, _4));

        icptimer1.info("END " + run_num_string, dstatus);
        return dstatus.result();
}


// if process is true apply settings to CRPT, if false just load XML into recovery map
int ISISinstrumentControl::readRecoveryFile(DAEstatus& dstatus)
{
        IXNeXusFile nx(nxErrorFunc, (void*)&dstatus);
        std::string xml_data;
        std::list<std::string> entries;
        std::list<std::string>::const_iterator entries_iter;
        std::pair<recovery_map_t::iterator, bool> insert_ret;
        m_recovery_map.clear();
        if (nx.open(m_recovery_file.c_str(), IXNeXusFile::Read) != IXNeXusFile::OK)
        {
                dstatus.addWarningVa(FAC_DAE, "Failed to open recovery file %s\n", m_recovery_file.c_str()); 
                return DAEstatus::Failure;
        }
        if (nx.openGroup("icp_xml", "IXicp_xml") == IXNeXusFile::OK)
        {
                nx.listEntries(entries);
                for(entries_iter = entries.begin(); entries_iter != entries.end(); entries_iter++)
                {
                        if (nx.readData(entries_iter->c_str(), xml_data) == IXNeXusFile::OK)
                        {
                                insert_ret = m_recovery_map.insert(recovery_map_t::value_type(*entries_iter, xml_data));
                                if (!insert_ret.second)
                                {
                                        dstatus.addWarningVa(FAC_DAE, "Found duplicate for %s in recovery map\n", entries_iter->c_str()); 
//                                      return DAEstatus::Failure;   // duplicate
                                }
                        }
                }
                nx.closeGroup();
        }
        else
        {
                dstatus.addWarning(FAC_DAE, "Failed to recover icp_xml\n"); 
        }
        if (nx.openGroup("icp_pars", "IXicp_pars") == IXNeXusFile::OK)
        {
                nx.readData("run_number", m_crpt->run_number);
                nx.readData("sav_file_count", m_crpt->sav_file_count);
                nx.closeGroup();
        }
        else
        {
                dstatus.addWarning(FAC_DAE, "Failed to recover icp_pars\n"); 
        }
        nx.close();

        updateXML("tcb", &ISISinstrumentControl::updateTCBXML, dstatus);
        updateXML("user", &ISISinstrumentControl::updateUserXML, dstatus);
        updateXML("dae", &ISISinstrumentControl::updateDAEsettingsXML, dstatus);
        updateXML("sample", &ISISinstrumentControl::updateSampleXML, dstatus);
        updateXML("periods", &ISISinstrumentControl::updateHardwarePeriodsXML, dstatus);
        updateXML("update", &ISISinstrumentControl::changeUpdateSettingsXML, dstatus);
        updateXML("monitoring", &ISISinstrumentControl::updateMonitoringXML, dstatus);

        m_crpt->markInitialised();
        dstatus.addWarningVa(FAC_DAE, "Recovered settings from file %s\n", m_recovery_file.c_str()); 

        return DAEstatus::Success;
}

int ISISinstrumentControl::updateXML(const char* name, xml_update_func_t func, DAEstatus& dstatus)
{
        recovery_map_t::const_iterator recovery_iter;
        if ( (recovery_iter = m_recovery_map.find(name)) != m_recovery_map.end())
        {
                (this->*func)(recovery_iter->second, dstatus);
        }
        else
        {
                dstatus.addWarningVa(FAC_DAE, "Unable to find settings for %s in recovery map\n", name); 
        }
        return DAEstatus::Success;
}


int ISISinstrumentControl::writeRecoveryFile(DAEstatus& dstatus)
{

        IXNeXusFile nx(nxErrorFunc, (void*)&dstatus);
        recovery_map_t::const_iterator iter;
        remove(m_recovery_file.c_str());
        if (nx.open(m_recovery_file.c_str(), IXNeXusFile::Write, IXNeXusFile::HDF5) != IXNeXusFile::OK)
        {
                return DAEstatus::Failure;
        }
        m_recovery_map["dae"] = m_crpt->lvxml_dae;
        m_recovery_map["tcb"] = m_crpt->lvxml_tcb;
        m_recovery_map["update"] = m_crpt->lvxml_update;
        m_recovery_map["periods"] = m_crpt->lvxml_periods;
        m_recovery_map["monitoring"] = m_crpt->lvxml_monitoring;

        nx.makeNewGroup("icp_xml", "IXicp_xml");
        for(iter = m_recovery_map.begin(); iter != m_recovery_map.end(); iter++)
        {
                nx.writeData(iter->first.c_str(), iter->second.c_str());
        }
        nx.closeGroup();
        nx.makeNewGroup("icp_pars", "IXicp_pars");
        nx.writeData("run_number", m_crpt->run_number);
        nx.writeData("sav_file_count", m_crpt->sav_file_count);
        nx.closeGroup();
        nx.close();
        return DAEstatus::Success;
}

int ISISinstrumentControl::killDatasvr(DAEstatus& dstatus)
{
        killProcess("isisdatasvr.exe", dstatus);
        return dstatus.result();
}

HANDLE ISISinstrumentControl::launchDatasvr(DAEstatus& dstatus)
{
        HANDLE h;
        static std::string datasvr = m_icp_service_dir + "\\isisdatasvr.exe";
        spawnCommand(datasvr, "", false, false, &h, "", "", "", 0, dstatus); // launch suspended and return thread handle
        return h;
}

#if 0
struct SendNagiosData
{
        int status; 
        std::string service;
        std::string message; 
        DAEstatus& dstatus;
        SendNagiosData(int status_, const std::string& service_, const std::string& message_, DAEstatus& dstatus_) : 
                status(status_), service(service_), message(message_), dstatus(dstatus_) { }
};

        Poco::NotificationQueue m_queue;
        NeXusWorker m_worker;
        Poco::Thread m_worker_thread;
                        m_queue.enqueueNotification(new GenericWorkNotification<NeXusWorkerData>(&d));


class SendNagiosWorker : public GenericWorker<SendNagiosData>
{
public:
        virtual void doWork(SendNagiosData* data);
        SendNagiosWorker(Poco::NotificationQueue& queue) : GenericWorker<SendNagiosData>(queue) { }
};
#endif /* if 0 */

// HOST\tservice\treturncode\tmessage\n
// return code is 0 for OK, 1 for WARNING, 2 for CRITICAL, 3 for UNKNOWN
// message can contain performance data
// CRITICAL - cannot do
// PING OK - hello | 
int ISISinstrumentControl::sendNagios(int status, const std::string& service, const std::string& message, DAEstatus& dstatus)
{
        static const bool use_nagios = m_app->config().getBool("isisicp.nagios.use", false);
        static const int nagios_timeout = m_app->config().getInt("isisicp.nagios.timeout", 5);
        static const std::string nagios_host = m_app->config().getString("isisicp.nagios.host","130.246.39.24");
        static const std::string send_nsca = m_icp_service_dir + "\\send_nsca.exe";
        static const std::string send_nsca_cfg = m_icp_service_dir + "\\send_nsca.cfg";
        static const std::string send_nsca_args = std::string("-H ") + nagios_host + " -c \"" + send_nsca_cfg + "\"";
        char* tfile = tempnam(getenv("TEMP"), "send_nsca");
        if (tfile == NULL)
        {
                dstatus.addWarningVa(FAC_DAE, "sendNagios: cannot create temp file");
                return DAEstatus::Failure;
        }
        std::string temp_file = tfile;
        std::ostringstream nagios_mess;
        free(tfile);
        std::fstream f;
        f.open(temp_file, std::ios::out);
        if (f.good())
        {
                nagios_mess << m_comp_name << '\t' << service << '\t' << status << '\t' << message << '\n';
                f << nagios_mess.str();
                f.close();
                if (use_nagios)
                {
                        spawnCommand(send_nsca, send_nsca_args, false, false, NULL, temp_file, "", "", nagios_timeout, dstatus); 
                }
                else
                {
//                      dstatus.addInfoVa(FAC_DAE, "sendNagios: %s", nagios_mess.str().c_str());
                }
        }
        else
        {
                dstatus.addWarningVa(FAC_DAE, "sendNagios: cannot open temp file");
        }
        remove(temp_file.c_str());
        return DAEstatus::Success;
} 

static bool getBeamlogFloat(Poco::XML::Document* pDoc, const std::string& path, float& value)
{
                Poco::XML::Node* pNode = pDoc->getNodeByPath(path); 
                if (pNode != NULL)
                {
                        value = atof(pNode->innerText().c_str());
//                      pNode->release();
                        return true;
                }
                return false;
}

static bool getBeamlogInt(Poco::XML::Document* pDoc, const std::string& path, int& value)
{
                Poco::XML::Node* pNode = pDoc->getNodeByPath(path); 
                if (pNode != NULL)
                {
                        value = atoi(pNode->innerText().c_str());
//                      pNode->release();
                        return true;
                }
                return false;
}

static bool getBeamlogInt64(Poco::XML::Document* pDoc, const std::string& path, int64_t& value)
{
                Poco::XML::Node* pNode = pDoc->getNodeByPath(path); 
                if (pNode != NULL)
                {
                        value = _atoi64(pNode->innerText().c_str());
//                      pNode->release();
                        return true;
                }
                return false;
}

static bool getBeamlogString(Poco::XML::Document* pDoc, const std::string& path, std::string& value)
{
                Poco::XML::Node* pNode = pDoc->getNodeByPath(path); 
                if (pNode != NULL)
                {
                        value = pNode->innerText();
//                      pNode->release();
                        return true;
                }
                return false;
}

void ISISinstrumentControl::readBeamloggerBroadcast()
{
        static char buffer[10000];
        static const int NBEAMREAD = 3;  
        Poco::Net::DatagramSocket ds_recv;
        Poco::Net::SocketAddress sa_recv("0.0.0.0", 7004);
        Poco::Timespan recv_tmo(15,0);
        beamlogger_t& bl = m_crpt->beamlogger;
        memset(&bl, 0, sizeof(beamlogger_t));
        try
        {
                ds_recv.setReceiveTimeout(recv_tmo);
                ds_recv.bind(sa_recv);
        }
        catch(const std::exception& ex)
        {
                LOGSTR_ERROR("readBeamloggerBroadcast: " << ex.what());
                return;
        }
        int n, ts = 1;
        unsigned nbeamz = 0, nbeamnz = 0;
        std::string shutter_status("OPEN"); // muons on ts1 and have no shutter
        bl.beam_on = false;
        bl.valid = false;
        bl.time = 0;
        time(&bl.beam_off_time);
        while(true)
        {
                try
                {
                        if (difftime(time(NULL), bl.time) > 10.0)
                        {
                                bl.valid = false;
                        }
                        else
                        {
                                bl.valid = true;
                        }
                        n = ds_recv.receiveBytes(buffer, sizeof(buffer)-1);
                        if (n <= 0)
                        {
                                LOGSTR_ERROR("readBeamloggerBroadcast: received " << n);
                                Poco::Thread::sleep(10 * 1000);
                                continue;
                        }
                        buffer[n] = '\0';
                        std::stringstream inp;
                        inp << buffer;
                        Poco::XML::InputSource xml_src(inp);
                        Poco::XML::DOMParser parser;
                        Poco::AutoPtr<Poco::XML::Document> pDoc = parser.parse(&xml_src);
                        if (getBeamlogString(pDoc, std::string("TS1SHUTTERS/") + m_crpt->inst_name, shutter_status))
                        {
                                ts = 1;
                        }
                        else if (getBeamlogString(pDoc, std::string("TS2SHUTTERS/") + m_crpt->inst_name, shutter_status))
                        {
                                ts = 2;
                        }
                        bl.ts = ts;
                        if ("OPEN" == shutter_status)
                        {
                                bl.shutter = 1;
                        }
                        else if ("CLOSED" == shutter_status)
                        {
                                bl.shutter = 0;
                        }
                        getBeamlogInt64(pDoc, "TIME", bl.time);
                        getBeamlogFloat(pDoc, "BEAMS", bl.beams);
                        getBeamlogInt(pDoc, "REPR", bl.ts1_repr);
                        getBeamlogInt(pDoc, "MUONKICKER", bl.muonkicker);
                        if (1 == ts)
                        {
                                getBeamlogFloat(pDoc, "BEAMT", bl.beamt);
                                getBeamlogInt(pDoc, "REPR", bl.repr);
                                getBeamlogFloat(pDoc, "TS1_TOTAL", bl.ts_total);
                                bl.repr_normal = (bl.repr >= 40);
                        }
                        else if (2 == ts)
                        {
                                getBeamlogFloat(pDoc, "BEAMT2", bl.beamt);
                                getBeamlogInt(pDoc, "REPR2", bl.repr);
                                getBeamlogFloat(pDoc, "TS2_TOTAL", bl.ts_total);
                                bl.repr_normal = (bl.repr >= 10);
                        }
                        if (bl.beamt <= 0.0)
                        {
                                ++nbeamz;
                                nbeamnz = 0;
                        }
                        else
                        {
                                nbeamz = 0;
                                ++nbeamnz;
                        }
                        if (bl.beam_on && nbeamz > NBEAMREAD)
                        {
                                bl.beam_on = false;
                                bl.beam_off_time = bl.time;
                                LOGSTR_INFORMATION("readBeamloggerBroadcast: BEAM OFF");
                        }
                        else if (!bl.beam_on && nbeamnz > NBEAMREAD)
                        {
                                bl.beam_on = true;
                                bl.beam_on_time = bl.time;
                                LOGSTR_INFORMATION("readBeamloggerBroadcast: BEAM ON");
                        }
                }
                catch(const std::exception& ex)
                {
                        LOGSTR_ERROR("readBeamloggerBroadcast: " << ex.what());
                        Poco::Thread::sleep(10 * 1000);
                }
        }
}

bool ISISinstrumentControl::beamOn(int minutes) const
{
        const beamlogger_t& bl = m_crpt->beamlogger;
        if (bl.beam_on && bl.repr_normal && difftime(time(NULL), bl.beam_on_time) > 60 * minutes)
        {
                return true;
        }
        else
        {
                return false;
        }
}

bool ISISinstrumentControl::muonKickerOK() const
{
        const beamlogger_t& bl = m_crpt->beamlogger;
        return bl.muonkicker > 0 ? true : false;
}

// spawn a background command
int ISISinstrumentControl::spawnCommand(const std::string& program, const std::string& args, bool use_cmd_exe, bool console, HANDLE* suspended_thread_handle,
                        const std::string& std_in_file, const std::string& std_out_file, const std::string& std_error_file, int wait_time, DAEstatus& dstatus)
{
    char command_line[MAX_PATH];
        SECURITY_ATTRIBUTES proc_attr;
        DWORD proc_create_flags = 0;
        BOOL inherit_handles = FALSE;
    ZeroMemory( &proc_attr, sizeof(proc_attr) );
    PROCESS_INFORMATION pi; 
    ZeroMemory( &pi, sizeof(pi) );
        if (use_cmd_exe)
        {
                _snprintf(command_line, sizeof(command_line), "\"%s\" /c \"%s\" %s", getenv("ComSpec"), program.c_str(), args.c_str());
        }
        else
        {
                _snprintf(command_line, sizeof(command_line), "\"%s\" %s", program.c_str(), args.c_str());
        }
        NULL_TERMINATE(command_line);
    STARTUPINFO si;
    ZeroMemory( &si, sizeof(si) );
    si.cb = sizeof(si);
        HANDLE proc_stdin = INVALID_HANDLE_VALUE;
        HANDLE proc_stdout = INVALID_HANDLE_VALUE;
        HANDLE proc_stderr = INVALID_HANDLE_VALUE;
        if (suspended_thread_handle != NULL)
        {
                proc_create_flags |= CREATE_SUSPENDED;
                *suspended_thread_handle = NULL;
        }
        if (console)
        {
                si.dwFlags = STARTF_USESHOWWINDOW;
                si.wShowWindow = SW_MINIMIZE;
                proc_create_flags |= CREATE_NEW_CONSOLE;
        }
        else
        {
                si.dwFlags |= STARTF_USESTDHANDLES;
                proc_attr.bInheritHandle = TRUE;  // Process handle inheritable - needed to use STARTF_USESTDHANDLES
                inherit_handles = TRUE;
                if (std_out_file.size() > 0)
                {
                        proc_stdout = CreateFile(std_out_file.c_str(), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, &proc_attr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); 
                        SetFilePointer(proc_stdout, 0, NULL, FILE_END);
                }
                else
                {
                        DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_OUTPUT_HANDLE), GetCurrentProcess(), &proc_stdout, 0, TRUE, DUPLICATE_SAME_ACCESS);
                }
                if (std_error_file.size() > 0)
                {
                        if (std_error_file == std_out_file)
                        {
                                DuplicateHandle(GetCurrentProcess(), proc_stdout, GetCurrentProcess(), &proc_stderr, 0, TRUE, DUPLICATE_SAME_ACCESS);
                        }
                        else
                        {
                                proc_stderr = CreateFile(std_error_file.c_str(), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, &proc_attr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); 
                                SetFilePointer(proc_stderr, 0, NULL, FILE_END);
                        }
                }
                else
                {
                        DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_ERROR_HANDLE), GetCurrentProcess(), &proc_stderr, 0, TRUE, DUPLICATE_SAME_ACCESS);
                }
                if (std_in_file.size() > 0)
                {
                        proc_stdin = CreateFile(std_in_file.c_str(), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, &proc_attr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); 
                }
                else
                {
                        DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_INPUT_HANDLE), GetCurrentProcess(), &proc_stdin, 0, TRUE, DUPLICATE_SAME_ACCESS);
                }
                si.hStdInput = proc_stdin;
                si.hStdOutput = proc_stdout;
                si.hStdError = proc_stderr;
        }
        // Start the child process. 
    if(CreateProcess(NULL,  
        command_line,                       // Command line. 
        &proc_attr,        
        NULL,                               // Thread handle not inheritable. 
        inherit_handles,                    // Set handle inheritance  
                proc_create_flags, // creation flags. 
        NULL,                               // Use parent's environment block. 
        NULL,                               // Use parent's starting directory. 
        &si,                                // Pointer to STARTUPINFO structure.
        &pi )                               // Pointer to PROCESS_INFORMATION structure.
    )
        {
                if (wait_time > 0)
                {
                        DWORD ret = WaitForSingleObject(pi.hProcess, wait_time * 1000);
                        if (ret == WAIT_TIMEOUT)
                        {
                                dstatus.addInfoVa(FAC_DAE, "Timout after waiting %d seconds for %s.", wait_time, command_line);
                        }
                        else if (ret != WAIT_OBJECT_0)
                        {
                                dstatus.addInfoVa(FAC_DAE, "Error waiting for %s.", command_line);
                        }
                        else
                        {
                                DWORD exit_code;
                                if (GetExitCodeProcess(pi.hProcess, &exit_code) != 0)
                                {
                                        if (exit_code != 0)
                                        {
                                                dstatus.addInfoVa(FAC_DAE, "Process exit code %d for %s", exit_code, command_line);
                                        }
                                }
                                else
                                {
                                        dstatus.addInfoVa(FAC_DAE, "GetExitCodeProcess() failed for %s", command_line);
                                }
                        }
                }
                CloseHandle(pi.hProcess);
                if (suspended_thread_handle != NULL)
                {
                        *suspended_thread_handle = pi.hThread;
                }
                else
                {
                        CloseHandle(pi.hThread);
                }
                CloseHandle(proc_stdin);
                CloseHandle(proc_stdout);
                CloseHandle(proc_stderr);
        }
        else
    {
                dstatus.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "CreateProcess failed for %s.", command_line);
    }
        return dstatus.result();
}

int ISISinstrumentControl::killProcess(const char* process_name, DAEstatus& dstatus)
{
    DWORD aProcesses[1024], cbNeeded, cProcesses;
    unsigned int i;
        std::string name;

    if ( !EnumProcesses( aProcesses, sizeof(aProcesses), &cbNeeded ) )
        return -1;

    // Calculate how many process identifiers were returned.

    cProcesses = cbNeeded / sizeof(DWORD);

    // Print the name and process identifier for each process.

    for ( i = 0; i < cProcesses; i++ )
        {
        if( aProcesses[i] != 0 )
                {
            name = getProcessName( aProcesses[i] );
                        if (name == process_name)
                        {
                                HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, aProcesses[i]);
                                if (hProcess != NULL)
                                {
                                        TerminateProcess(hProcess, 0);
                                        CloseHandle(hProcess);
                                }
                        }
                }
        }

        return 0;

}

std::string ISISinstrumentControl::getProcessName( DWORD processID )
{
        std::string result;
    TCHAR szProcessName[MAX_PATH] = TEXT("<unknown>");

    // Get a handle to the process.

    HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION |
                                   PROCESS_VM_READ,
                                   FALSE, processID );

    // Get the process name.
    if (NULL != hProcess )
    {
        HMODULE hMod;
        DWORD cbNeeded;

        if ( EnumProcessModules( hProcess, &hMod, sizeof(hMod), &cbNeeded) )
        {
            GetModuleBaseName( hProcess, hMod, szProcessName, 
                               sizeof(szProcessName)/sizeof(TCHAR) );
        }
        CloseHandle( hProcess );
    }

        result = szProcessName;
        return result;

}


//   Number of detectors           Number of monitors :
//    165891         4
//  Index     Det. no.  time reg.  crate    module    posn.  monitor  mon.prescale
//        1     11101001        1        1        0        0        0        0
//        2     11101002        1        1        0        1        0        0


// if table is loaded, marks detector and spectra tables as bad so sould only be called from readTables()
int ISISinstrumentControl::readWiringTable(const char* filename, DAEstatus& status)
{       
        int ndet, nmon, i, j, exit_status = DAEstatus::Success; 
        md5checksum_t checksum;
        struct stat stat_struct;
        RUNTABLE& wiring_table = m_crpt->wiring_table;  
        RUNTABLE& detector_table = m_crpt->detector_table;      
        RUNTABLE& spectra_table = m_crpt->spectra_table;        
        typedef std::map<unsigned,unsigned> wiring_map_t;
        typedef std::pair<wiring_map_t::iterator,bool> wiring_insert_t;
        wiring_map_t::const_iterator wiring_iterator;
        wiring_map_t wiring_map, crate_map;
        wiring_insert_t insert_ret;

        int *index, *det_no, *time_reg, *crate, *module, *mpos, *monitor, *mon_prescale;        
        if ( stat(filename, &stat_struct) != 0 )        
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Cannot open wiring table %s", filename);
                return DAEstatus::Failure;
        }
        md5sumFile(filename, checksum, status);
        if ( (strncmp(wiring_table.fname, filename, sizeof(wiring_table.fname)) == 0) &&
             (wiring_table.mod_time == stat_struct.st_mtime) && 
                 (wiring_table.file_size == stat_struct.st_size) &&     
              compareChecksums(wiring_table.checksum, checksum) )
        {               
                status.addInfoVa(FAC_DAE, "Wiring table %s is unchanged - reload skipped", filename);   
                return DAEstatus::Success;
        }
        std::ifstream f;        
        f.open(filename, std::ios::in); 
        f.ignore(50000, '\n'); // skip line "number of detectors ..."   
        f >> ndet >> nmon;      
        if (!f.good())  
        {               
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Error reading ndet and nmon from wiring table %s", filename);
                return DAEstatus::Failure;      
        }       
        if ( (ndet <= 0) || (ndet > ISISCRPT_MAX_DETECTOR) )    
        {                       
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Invalid ndet = %d from wiring table %s (too big?)", ndet, filename);
                return DAEstatus::Failure;      
        }       
        if ( (nmon < 0) || (nmon > ISISCRPT_MAX_MONITOR) )      
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Invalid nmon = %d from wiring table %s (too big?)", nmon, filename);
                return DAEstatus::Failure;      
        }       
        index = new int[ndet];  
        det_no = new int[ndet]; 
        time_reg = new int[ndet];       
        crate = new int[ndet];  
        module = new int[ndet];
        mpos = new int[ndet];
        monitor = new int[ndet];        
        mon_prescale = new int[ndet];   
        f.ignore(50000, '\n'); // skip rest of line     
        f.ignore(50000, '\n'); // skip line "index det no ..."
        // module (dim) is 0-15, mpos is 0 - 4095 and crate is 0-15
        // so 12bits mpos, 4bit dim, 4bit crate
        unsigned crate_index;
        for(i=0; i<ndet && f.good(); i++)       
        {               
                f >> index[i] >> det_no[i] >> time_reg[i] >> crate[i]             
                  >> module[i] >> mpos[i] >> monitor[i] >> mon_prescale[i];             
                f.ignore(50000, '\n');  // skip rest of line
                if (index[i] != i+1)
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Invalid index for det number %d in wiring table %s - should be %d", det_no[i], filename, i+1);
                        return DAEstatus::Failure;      
                }
                if ( (crate[i] % DAE2CardPolicy::CRATE_MOD) > 15 || module[i] > 15 || mpos[i] > 4095 )
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Invalid crate/module/position (%d/%d/%d) for det number %d in wiring table %s ", 
                                                                        crate[i], module[i], mpos[i], det_no[i], filename);
                        return DAEstatus::Failure;      
                }
                crate_index = ( (crate[i] << 16) | (module[i] << 12) | mpos[i] );
                insert_ret = wiring_map.insert(wiring_map_t::value_type(det_no[i],crate_index));
                if (!insert_ret.second)
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Error duplicate detector number %d near line %d in wiring table %s", det_no[i], i, filename);
                        return DAEstatus::Failure;      
                }
                insert_ret = crate_map.insert(wiring_map_t::value_type(crate_index,det_no[i]));
                if (!insert_ret.second)
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Error duplicate crate/module/position for det number %d near line %d in wiring table %s", det_no[i], i, filename);
                        return DAEstatus::Failure;      
                }
                // just for debuggubng REMOVE
                // crate[i] = 1;   
        }       
        if (!f.good())
        {               
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Error near line %d from wiring table %s", i, filename);
                return DAEstatus::Failure;      
        }       
        // detectors
        ICPCritical cs(&m_crpt_cs);
        m_crpt->ndet = ndet;    
        memcpy(m_crpt->crat, crate, ndet*sizeof(int));  
        memcpy(m_crpt->modn, module, ndet*sizeof(int)); 
        memcpy(m_crpt->mpos, mpos, ndet*sizeof(int));   
        for(i=0; i<ndet; ++i)
        {
                m_crpt->timr_crpt[i] = m_crpt->crptTR(time_reg[i]);
                m_crpt->timr_dae[i] = m_crpt->daeTR(time_reg[i]);
                m_crpt->timr_file[i] = m_crpt->fileTR(time_reg[i]);
                m_crpt->det_mode[i] = m_crpt->isEventTR(time_reg[i]);
        }
        memcpy(m_crpt->udet, det_no, ndet*sizeof(int));

        // monitors     
        m_crpt->nmon = nmon;
        memset(m_crpt->mdet.c_array(), 0, ISISCRPT_MAX_MONITOR*sizeof(int));    
        memset(m_crpt->monp.c_array(), 0, ISISCRPT_MAX_MONITOR*sizeof(int));    
        memset(m_crpt->save_monitor_events.c_array(), 0, ISISCRPT_MAX_MONITOR*sizeof(int));     
        m_crpt->det_group_max = 0;
        for(i=0; i<ndet; i++)   
        {               
                j = abs(monitor[i]); // we use a negative monitor number to mean not to save events             
                if (j > 0)    // 0 means it is not a monitor
                {
                        if (j > nmon)
                        {
                                exit_status = DAEstatus::Failure;
                                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Invalid monitor number %d (>%d) in wiring table %s", j, nmon, filename);
                        }
                        else if (m_crpt->mdet[j-1] == 0)
                        {
                                m_crpt->mdet[j-1] = index[i];           // mdet starts at 1 for historical (fortran) reasons (index[i] == i+1)  
                                m_crpt->monp[j-1] = mon_prescale[i];
                        }
                        else
                        {
                                exit_status = DAEstatus::Failure;
                                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Monitor number %d defined multiple times in wiring table %s", j, filename);
                        }
                        m_crpt->save_monitor_events[j-1] = (monitor[i] > 0 ? 1 : 0);
                        m_crpt->det_group[i] = 0;
                }
                else
                {
                        m_crpt->det_group[i] = 1 /* m_crpt->timr[i] */;
                        m_crpt->det_group_max = std::max(m_crpt->det_group_max, m_crpt->det_group[i]);
                }
        }
        for(i=0; i<m_crpt->nmon; i++)
        {
                if (m_crpt->mdet[i] == 0)
                {
                        status.addWarningVa(FAC_DAE, "Monitor %d is not properly defined in wiring table %s", i+1, filename);
                }
        }
        if (exit_status == DAEstatus::Success)
        {
        // update wiring table information      
                strncpy(wiring_table.fname, filename, sizeof(wiring_table.fname));
                NULL_TERMINATE(wiring_table.fname);
                memcpy(wiring_table.checksum, checksum, sizeof(wiring_table.checksum));
                wiring_table.mod_time = stat_struct.st_mtime;   
                wiring_table.file_size = stat_struct.st_size;
                status.addInfoVa(FAC_DAE, "Loaded %d detectors (%d monitors) from wiring table %s", ndet, nmon, filename);
        }
        else
        {
                wiring_table.file_size = wiring_table.mod_time = 0;
                memset(wiring_table.checksum, 0, sizeof(wiring_table.checksum));
        }

        // force subsequent reload of detector and spectra tables by marking them bad
        detector_table.file_size = detector_table.mod_time = 0;
        memset(detector_table.checksum, 0, sizeof(detector_table.checksum));
        spectra_table.file_size = spectra_table.mod_time = 0;
        memset(spectra_table.checksum, 0, sizeof(spectra_table.checksum));

        delete []index; 
        delete []det_no;        
        delete []time_reg;      
        delete []crate; 
        delete []module;        
        delete []mpos;
        delete []monitor;       
        delete []mon_prescale;  

        return exit_status;
}


int ISISinstrumentControl::readDetectorTable(const char* filename, DAEstatus& status)
{       
        int i, j, nlines, nuse, det_no, exit_status = DAEstatus::Success;
        struct stat stat_struct;
        md5checksum_t checksum;
        typedef std::map<int,DETECTOR> detector_map_t;
        typedef std::pair<detector_map_t::iterator,bool> detector_insert_t;
        detector_map_t detector_map;
        detector_map_t::const_iterator detector_iterator;
        std::set<unsigned> udet_set;
        RUNTABLE& detector_table = m_crpt->detector_table;      
        if ( stat(filename, &stat_struct) != 0 )        
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Cannot open detector table \"%s\"", filename);
                return DAEstatus::Failure;
        }
        md5sumFile(filename, checksum, status);
        if ( (strncmp(detector_table.fname, filename, sizeof(detector_table.fname)) == 0) &&
             (detector_table.mod_time == stat_struct.st_mtime) &&
                 (detector_table.file_size == stat_struct.st_size) &&
              compareChecksums(detector_table.checksum, checksum) )
        {               
                status.addInfoVa(FAC_DAE, "Detector table \"%s\" is unchanged - reload skipped", filename);
                return DAEstatus::Success;
        }
        for(i=0; i<m_crpt->ndet; ++i)
        {
                udet_set.insert(m_crpt->udet[i]);
        }
        Poco::SharedPtr<IDetectorFile> det_file;
        std::string det_filename(filename);
        // if filename ends in .nxs assume it is a mantid calibration file
        if ( (det_filename.size() > 4) && !Poco::icompare(det_filename.substr(det_filename.size() - 4), ".nxs") )
        {
                det_file = new DetectorFileMantid(filename);
        }
        else
        {
                det_file = new DetectorFileASCII(filename);
        }
        if (!det_file->good())  
        {               
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Error reading ndet and nuse from detector table %s", filename);
                return DAEstatus::Failure;      
        }       
        nlines = det_file->numLines();
        nuse = det_file->numUserTables();       
        if ( (nuse < 0) || (nuse > ISISCRPT_MAX_USER) ) 
        {                       
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Invalid nuse = %d from detector table %s (too big?)", nuse, filename);
                return DAEstatus::Failure;      
        }       
        DETECTOR det;
        DETECTOR& det_ref = det;
        detector_insert_t insert_ret;
        int n_extra_dets = 0;
        for(i=0; i<nlines && det_file->good(); i++)
        {
                det_file->readLine(det_no, det);
                insert_ret = detector_map.insert(detector_map_t::value_type(det_no,det));
                if (!insert_ret.second)
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Error duplicate near line %d, det number %d from detector table %s", i, det_no, filename);
                        return DAEstatus::Failure;      
                }
                if (udet_set.count(det_no) == 0)
                {
                        ++n_extra_dets;
                }
        }
        if (n_extra_dets > 0)
        {
                status.addWarningVa(FAC_DAE, "%d detectors defined in detector table %s but not in wiring table", n_extra_dets, filename);
        }
        if (!det_file->good())  
        {               
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Error near line %d from detector table %s", i, filename);
                return DAEstatus::Failure;      
        }
        if (detector_map.size() != nlines)
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Detector table %s does not specify enough values", filename);
                return DAEstatus::Failure;      
        }
        ICPCritical cs(&m_crpt_cs);
        m_crpt->nuse = nuse;
        DETECTOR empty_det;
        for(i=0; i < m_crpt->ndet; i++)
        {
                detector_iterator = detector_map.find(m_crpt->udet[i]);
                if (detector_iterator != detector_map.end())
                {
                        det_ref = detector_iterator->second;
                }
                else
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Detector %d missing from detector table %s", m_crpt->udet[i], filename);
                        det_ref = empty_det;
                        exit_status = DAEstatus::Failure;
                        break; // exit early as ndet can be quite big and we may have a lot of errors
                }
                m_crpt->delt[i] = det_ref.offset;
                m_crpt->code[i] = det_ref.code;
                m_crpt->len2[i] = det_ref.l2;
                m_crpt->tthe[i] = det_ref.theta;
                for(j=0; j<nuse; j++)
                {
                        m_crpt->ut[j*m_crpt->ndet + i] = det_ref.ut[j];
                }
        }
        if (exit_status == DAEstatus::Success)
        {
        // update wiring table information      
                strncpy(detector_table.fname, filename, sizeof(detector_table.fname));  
                NULL_TERMINATE(detector_table.fname);
                memcpy(detector_table.checksum, checksum, sizeof(detector_table.checksum));
                detector_table.mod_time = stat_struct.st_mtime; 
                detector_table.file_size = stat_struct.st_size;
                status.addInfoVa(FAC_DAE, "Loaded %d detectors with %d user tables from detector table %s", m_crpt->ndet, nuse, filename);
                DetectorFileMantid* dfm = dynamic_cast<DetectorFileMantid*>(det_file.get());
                if (dfm != NULL)
                {
                        if ( !Poco::icompare(dfm->instName(), static_cast<const char*>(m_crpt->inst_name)) )
                        {
                                status.addWarningVa(FAC_DAE, "Mismatch in instrument names for detector file: \"%s\" != \"%s\"", dfm->instName().c_str(), m_crpt->inst_name);
                                LOGSTR_WARNING("Mismatch in instrument names for detector file: \"" << dfm->instName() << "\" != \"" << m_crpt->inst_name << "\"");
                        }
                        strncpy(m_crpt->instrument_xml_file, dfm->instXMLFileName().c_str(), sizeof(m_crpt->instrument_xml_file));
                        NULL_TERMINATE(m_crpt->instrument_xml_file);
                        std::fstream fs(m_instrument_xml_file, std::ios::out | std::ios::trunc);
                        fs << dfm->instXML();
                        fs.close();
                        strncpy(m_crpt->instrument_parameter_map_file, dfm->instParameterMapFileName().c_str(), sizeof(m_crpt->instrument_parameter_map_file));
                        NULL_TERMINATE(m_crpt->instrument_parameter_map_file);
                        std::fstream fs1(m_instrument_parameter_map_file, std::ios::out | std::ios::trunc);
                        fs1 << dfm->instParameterMap();
                        fs1.close();
                }
                else
                {
                        m_crpt->instrument_xml_file[0] = '\0';
                        std::remove(m_instrument_xml_file.c_str());
                        m_crpt->instrument_parameter_map_file[0] = '\0';
                        std::remove(m_instrument_parameter_map_file.c_str());
                }
        }
        else
        {
                detector_table.file_size = detector_table.mod_time = 0;
                memset(detector_table.checksum, 0, sizeof(detector_table.checksum));
        }
        return exit_status;
}

//NDET :
//     73740
//DETECTOR      SPECTRUM
//   1000001         577
//   1000002         578
//   1000003         579

int ISISinstrumentControl::readSpectraTable(const char* filename, DAEstatus& status)
{       
        int i, nlines, spec_no, det_no, max_spec_no, exit_status = DAEstatus::Success;
        md5checksum_t checksum;
        struct stat stat_struct;        
        typedef std::map<int,int> spectra_map_t;
        typedef std::pair<spectra_map_t::iterator,bool> spectra_insert_t;
        spectra_map_t spectra_map;
        std::set<unsigned> udet_set;
        spectra_map_t::const_iterator spectra_iterator;
        RUNTABLE& spectra_table = m_crpt->spectra_table;        
        if ( stat(filename, &stat_struct) != 0 )        
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Cannot open spectra table %s", filename);
                return DAEstatus::Failure;
        }       
        md5sumFile(filename, checksum, status);
        if ( (strncmp(spectra_table.fname, filename, sizeof(spectra_table.fname)) == 0) &&
             (spectra_table.mod_time == stat_struct.st_mtime) &&        
                 (spectra_table.file_size == stat_struct.st_size) &&    
              compareChecksums(spectra_table.checksum, checksum) )
        {               
                status.addInfoVa(FAC_DAE, "Spectra table %s is unchanged - reload skipped", filename);
                return DAEstatus::Success;
        }
        for(i=0; i<m_crpt->ndet; ++i)
        {
                udet_set.insert(m_crpt->udet[i]);
        }
        std::ifstream f;
        f.open(filename, std::ios::in); 
        f.ignore(50000, '\n'); // skip line "number of detectors ..."   
        f >> nlines;    
        if (!f.good())  
        {               
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Error reading nlines from spectra table %s", filename);
                return DAEstatus::Failure;      
        }       
        f.ignore(50000, '\n'); // skip rest of line     
        f.ignore(50000, '\n'); // skip next line
        spectra_insert_t insert_ret;
        for(i=0; i<nlines && f.good(); i++)
        {
                f >> det_no >> spec_no;
                f.ignore(50000, '\n'); // skip rest of line     
                if (spec_no >= ISISCRPT_MAX_DETECTOR)
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Invalid spectrum number %d >= %d from spectra table %s", spec_no, ISISCRPT_MAX_DETECTOR, filename);
                        return DAEstatus::Failure;      
                }
                if (udet_set.count(det_no) == 0)
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Invalid detector number %d from spectra table %s", det_no, filename);
                        return DAEstatus::Failure;      
                }
                insert_ret = spectra_map.insert(spectra_map_t::value_type(det_no,spec_no));
                if (!insert_ret.second)
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Error duplicate near line %d from spectra table %s", i, filename);
                        return DAEstatus::Failure;      
                }
        }
        if (!f.good())  
        {               
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Error near line %d from spectra table %s", i, filename);
                return DAEstatus::Failure;      
        }
        if (spectra_map.size() != nlines)
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Error near line %d from spectra table %s", i, filename);
                return DAEstatus::Failure;      
        }
        ICPCritical cs(&m_crpt_cs);
        max_spec_no = 0;
        boost::array<int,ISISCRPT_MAX_NTRG>& spec_min = m_crpt->spec_min;
        boost::array<int,ISISCRPT_MAX_NTRG>& spec_max = m_crpt->spec_max;
        const int SPEC_MIN_FILLER=10000000, SPEC_MAX_FILLER=-1;
        spec_min.fill(SPEC_MIN_FILLER);
        spec_max.fill(SPEC_MAX_FILLER);
        int n_unassigned_detectors = 0;
        m_crpt->spec_to_index.fill(0);
        boost::array<std::set<int>,ISISCRPT_MAX_NTRG> spec_tr;  
        for(i=0; i < m_crpt->ndet; i++)
        {
                spectra_iterator = spectra_map.find(m_crpt->udet[i]);
                int tr_index = m_crpt->timr_crpt[i] - 1;
                if (spectra_iterator != spectra_map.end())
                {
                        spec_no = spectra_iterator->second;
                }
                else
                {
                        spec_no = 0;    
                        n_unassigned_detectors++;
                }
                m_crpt->spec[i] = spec_no;
                max_spec_no = std::max(spec_no, max_spec_no);
                if (spec_no > 0)
                {
                        spec_tr[tr_index].insert(spec_no);
                        spec_min[tr_index] = std::min(spec_no, spec_min[tr_index]); 
                        spec_max[tr_index] = std::max(spec_no, spec_max[tr_index]); 
                        m_crpt->spec_to_index[spec_no] = i;
                }
        }
        // put spectrum 0 into same TR as spectrum 1
        int spec0_tr = m_crpt->spectrumCRPTTR(1);
        spec_min[spec0_tr-1] = 0; 
        spec_tr[spec0_tr-1].insert(0);
        m_crpt->spec_to_index[0] = m_crpt->spec_to_index[1];
        if (n_unassigned_detectors > 0)
        {
                status.addWarningVa(FAC_DAE, "%d detectors unassigned in spectra table and mapped to spectrum 0", n_unassigned_detectors);
        }
        // a CRPT time regime must have a contiguous set of spectra that do not overlap with anything else
        typedef std::map<int,int> minmax_map_t;
        minmax_map_t minmax_map;
        for(i=0; i < m_crpt->ntrg; ++i)
        {
                if ( (spec_min[i] != SPEC_MIN_FILLER) && (minmax_map.insert(minmax_map_t::value_type(spec_min[i],spec_max[i])).second == false) )
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "duplicate spec_min %d in tr %d", spec_min[i], i+1);
                        exit_status = DAEstatus::Failure;       
                }
        }
        std::vector< std::pair<int,int> > minmax_vec;
        for(minmax_map_t::const_iterator it = minmax_map.begin(); it != minmax_map.end(); ++it)
        {
                minmax_vec.push_back(*it);
        }
        for(i=0; i < (minmax_vec.size() - 1); ++i)
        {
                if ( (minmax_vec[i].second != SPEC_MAX_FILLER) && (minmax_vec[i+1].first != SPEC_MIN_FILLER) 
                                                                                                                && ((minmax_vec[i+1].first - minmax_vec[i].second) != 1) )
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "spectra not contiguous between time regimes");
                        exit_status = DAEstatus::Failure;       
                }
        }
        int n = 0;
        for(i=0; i<m_crpt->ntrg; ++i)
        {
                int nsp = ( (spec_max[i] != SPEC_MAX_FILLER) ? (spec_max[i] - spec_min[i] + 1) : 0 );
                if ( nsp != spec_tr[i].size() )
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Spectra missing from tr %d", i+1);
                        exit_status = DAEstatus::Failure;       
                }
                m_crpt->nsp[i] = nsp;
                n += nsp;
        }
        --(m_crpt->nsp[spec0_tr-1]);   // we do not count spectrum 0 here
        --n;
        if ( n != max_spec_no )   // numbers range from 0 to max_spec_no inclusive
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Total spec error %d != %d", n, max_spec_no);
                exit_status = DAEstatus::Failure;       
        }
        if ( n != m_crpt->getHighestSpectrumNumber() )
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "High spec error %d != %d", n, m_crpt->getHighestSpectrumNumber());
                exit_status = DAEstatus::Failure;       
        }
        // update wiring table information
        if (exit_status == DAEstatus::Success)
        {
                m_crpt->calculateCRPTOffsets();
                strncpy(spectra_table.fname, filename, sizeof(spectra_table.fname));
                NULL_TERMINATE(spectra_table.fname);
                spectra_table.mod_time = stat_struct.st_mtime;
                spectra_table.file_size = stat_struct.st_size;
                memcpy(spectra_table.checksum, checksum, sizeof(spectra_table.checksum));
                status.addInfoVa(FAC_DAE, "Assigned %d spectra from spectra table %s", max_spec_no, filename);
        }
        else
        {
                spectra_table.file_size = spectra_table.mod_time = 0;
                memset(spectra_table.checksum, 0, sizeof(spectra_table.checksum));
        }
        return exit_status;     
}

static int getAttrIntegerValue(Poco::XML::NamedNodeMap* attrs, const char* name)
{
        Poco::XML::Node* node = attrs->getNamedItem(name);
        int val = 0;
        if (node != NULL)
        {
                val = atoi(node->getNodeValue().c_str());
//      node->release();
        }
        return val;
}

static double getAttrFloatValue(Poco::XML::NamedNodeMap* attrs, const char* name)
{
        Poco::XML::Node* node = attrs->getNamedItem(name);
        double val = 0.0;
        if (node != NULL)
        {
                val = atof(node->getNodeValue().c_str());
//      node->release();
        }
        return val;
}

int ISISinstrumentControl::readDataDaeTable(const char* filename, DAEstatus& status)
{
        int i, exit_status = DAEstatus::Success;
        md5checksum_t checksum;
        struct stat stat_struct;        
        RUNTABLE& data_dae_table = m_crpt->data_dae_table;      
        if ( stat(filename, &stat_struct) != 0 )        
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Cannot open data dae table %s", filename);
                m_crpt->n_data_dae = 0;
                return DAEstatus::Failure;
        }       
        md5sumFile(filename, checksum, status);
        if ( (strncmp(data_dae_table.fname, filename, sizeof(data_dae_table.fname)) == 0) &&
             (data_dae_table.mod_time == stat_struct.st_mtime) &&       
                 (data_dae_table.file_size == stat_struct.st_size) &&   
              compareChecksums(data_dae_table.checksum, checksum) )
        {               
                status.addInfoVa(FAC_DAE, "Data DAE table %s is unchanged - reload skipped", filename);
                return DAEstatus::Success;
        }
        m_crpt->n_data_dae = 0;
        std::ifstream f;
        f.open(filename, std::ios::in); 
        if (!f.good())  
        {               
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Error reading data dae table %s", filename);
                return DAEstatus::Failure;      
        }
        try
        {
                Poco::XML::InputSource xml_src(f);
                Poco::XML::DOMParser parser;
                Poco::AutoPtr<Poco::XML::Document> pDoc = parser.parse(&xml_src);
                Poco::XML::NodeIterator it(pDoc, Poco::XML::NodeFilter::SHOW_ELEMENT);
                Poco::XML::Node* pNode = it.nextNode();
                for(i=0; i < ISISCRPT_MAX_DATADAE && pNode != NULL; )
                {
                        if (pNode->nodeName() == "device")
                        {
                                Poco::XML::NamedNodeMap* attrs = pNode->attributes();
                                m_crpt->data_dae[i].id = getAttrIntegerValue(attrs, "id");
                                m_crpt->data_dae[i].crate = getAttrIntegerValue(attrs, "crate");
                                m_crpt->data_dae[i].tr = getAttrIntegerValue(attrs, "time_regime");
                                m_crpt->data_dae[i].data_bytes = getAttrIntegerValue(attrs, "data_bytes");
                                m_crpt->data_dae[i].scale = getAttrFloatValue(attrs, "scale");
                                m_crpt->data_dae[i].offset = getAttrFloatValue(attrs, "offset");
                                Poco::XML::Node* node = attrs->getNamedItem("name");
                                if (node != NULL)
                                {
                                        std::string n = node->nodeValue();
                                        std::replace(n.begin(), n.end(), ' ', '_'); 
                                        strncpy(m_crpt->data_dae[i].name, n.c_str(), sizeof(m_crpt->data_dae[i].name));
                                }
                                NULL_TERMINATE(m_crpt->data_dae[i].name);
                                node = attrs->getNamedItem("data_type");
                                if (node != NULL)
                                {
                                        if (node->nodeValue() == "int")
                                        {
                                                m_crpt->data_dae[i].data_type = 1;
                                        }
                                        else if (node->nodeValue() == "float")
                                        {
                                                m_crpt->data_dae[i].data_type = 2;
                                        }
                                        else
                                        {
                                                m_crpt->data_dae[i].data_type = 0; // unknown
                                        }
                                }
                                node = attrs->getNamedItem("raw_units");
                                if (node != NULL)
                                {
                                        strncpy(m_crpt->data_dae[i].raw_units, node->nodeValue().c_str(), sizeof(m_crpt->data_dae[i].raw_units));
                                }
                                NULL_TERMINATE(m_crpt->data_dae[i].raw_units);
                                node = attrs->getNamedItem("scaled_units");
                                if (node != NULL)
                                {
                                        strncpy(m_crpt->data_dae[i].scaled_units, node->nodeValue().c_str(), sizeof(m_crpt->data_dae[i].scaled_units));
                                        node->release();
                                }
                                NULL_TERMINATE(m_crpt->data_dae[i].scaled_units);
                                attrs->release();
                                ++i;
                        }
                        pNode = it.nextNode();
                }
                m_crpt->n_data_dae = i;
        }
        catch (const Poco::Exception& pex)
        {
                status.addWarning(FAC_DAE, pex.displayText());
                exit_status = DAEstatus::Failure;
        }
        catch (const std::exception& ex)
        {
                status.addWarning(FAC_DAE, ex.what());
                exit_status = DAEstatus::Failure;
        }
        ICPCritical cs(&m_crpt_cs);
        if (exit_status == DAEstatus::Success)
        {
                strncpy(data_dae_table.fname, filename, sizeof(data_dae_table.fname));
                NULL_TERMINATE(data_dae_table.fname);
                data_dae_table.mod_time = stat_struct.st_mtime;
                data_dae_table.file_size = stat_struct.st_size;
                memcpy(data_dae_table.checksum, checksum, sizeof(data_dae_table.checksum));
                status.addInfoVa(FAC_DAE, "Assigned %d items from data dae table %s", m_crpt->n_data_dae, filename);
        }
        else
        {
                m_crpt->n_data_dae = 0;
                data_dae_table.file_size = data_dae_table.mod_time = 0;
                memset(data_dae_table.checksum, 0, sizeof(data_dae_table.checksum));
        }
        return exit_status;     
}


// this routine convert the required boundaries into clock pulses for the DAE
// It work in a relative way i.e. if the boundaries are givien in microseconds
// it assumes the clock frequency is in MHz; if time boundaries are nanosecond
// the clock frequency must be in GHz etc (i.e. "cock_frequency is the number of clock
// pulses in one unit of the TCB units
//
// need a CRPT lock already
int ISISinstrumentControl::tcbcalc(DAEstatus& status)
{
        struct stat stat_struct;
        int i, j, n;
        std::fstream fs;
    boost::array<double*,ISISCRPT_MAX_NTRG> rtcb_file;
        rtcb_file.fill(NULL);
        for(j=0; j<m_crpt->ntrg; j++)
        {
                TCBRANGE* tcr = m_crpt->tcr[j];
                int ntcr = m_crpt->ntcr[j];
                if (tcr[0].mode == TCBRANGE_FILE)
                {
                        if ((m_crpt->ntrg != 1) || (m_crpt->ntcr[0] != 1))
                        {
                                status.addVa(FAC_TCB, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                                                        "ntgr or ntrc error in tcb");
                                return DAEstatus::Failure;
                        }
                        fs.open(tcr[0].tcb_file.fname, std::ios::in);
                        if (fs.good())
                        {
                                n = 0;
                                fs >> n;
                                if (fs.good())
                                {
                                        rtcb_file[j] = new double[n];
                                        for (i=0; i<n; i++)
                                        {
                                                fs >> rtcb_file[j][i];
                                        }
                                        tcr[0].start = static_cast<float>(rtcb_file[j][0]);
                                        tcr[0].end = static_cast<float>(rtcb_file[j][n-1]);
                                }
                                if (!fs.good())                                 // if read error the we should execute this
                                {
                                        tcr[0].start = 0.0;   // throw proper error?
                                        tcr[0].end = 0.0;
                                }
                                md5sumFile(tcr[0].tcb_file.fname, tcr[0].tcb_file.checksum, status);
                                stat(tcr[0].tcb_file.fname, &stat_struct);
                                tcr[0].tcb_file.mod_time = stat_struct.st_mtime;        
                                tcr[0].tcb_file.file_size = stat_struct.st_size;
                                status.addInfoVa(FAC_TCB, "TCB read from %s\n", tcr[0].tcb_file.fname);
                        }
                        else
                        {
                                status.addVa(FAC_TCB, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                                                        "Unable to read TCB file %s", tcr[0].tcb_file.fname);
                                if (rtcb_file[j] != NULL)
                                {
                                        delete[] rtcb_file[j];
                                        rtcb_file[j] = NULL;
                                }
                                return DAEstatus::Failure;
                        }
                        fs.close();
                }
                if (tcr[0].start < m_crpt->tcb_mintime)
                {
                        status.addInfoVa(FAC_TCB, "Start channel %f < minimum allowed (%f); resetting to min allowed", tcr[0].start, m_crpt->tcb_mintime);
                        tcr[0].start = m_crpt->tcb_mintime;
                }
                if (tcr[ntcr-1].end < m_crpt->tcb_mintime)
                {
                        status.addVa(FAC_TCB, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                                        "End channel less than min time (%f < %f)", 
                                        tcr[ntcr-1].end, m_crpt->tcb_mintime);
                        return DAEstatus::Failure;
                }
                if (tcr[0].start > m_crpt->tcb_maxtime)
                {
                        status.addVa(FAC_TCB, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                                                "Start channel greater than max time (%f > %f)", 
                                                tcr[0].start, m_crpt->tcb_maxtime);
                        return DAEstatus::Failure;
                }
                if (tcr[ntcr-1].end > m_crpt->tcb_maxtime)
                {
                        status.addVa(FAC_TCB, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                                        "end channel greater than max time (%f > %f)", 
                                        tcr[ntcr-1].end, m_crpt->tcb_maxtime);
                        return DAEstatus::Failure;
                }
// if a start or a finish value < 1 assume it means you want to join with the previous
// range
                for(i=1; i<ntcr; i++)
                {
                        if (tcr[i-1].end < 1.0)
                        {
                                tcr[i-1].end = tcr[i].start;
                        }
                        if (tcr[i].start < 1.0)
                        {
                                tcr[i].start = tcr[i-1].end;
                        }
                }
                for(i=0; i<ntcr; i++)
                {
                        if (tcr[i].end < tcr[i].start)
                        {
                                status.addVa(FAC_TCB, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                                                "end channel less than start time (%f < %f)", 
                                                tcr[i].end, tcr[i].start);
                                return DAEstatus::Failure;
                        }
                        if (tcr[i].mode == TCBRANGE_CONST_T)
                        { 
                                if ( tcr[i].tcpar[0] > (tcr[i].end - tcr[i].start) )
                                {
                                        status.addVa(FAC_TCB, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                                                "channel width too big for section %d (%f)", i, 
                                                tcr[i].tcpar[0]);
                                        return DAEstatus::Failure;
                                }
                                if ( tcr[i].tcpar[0] < m_crpt->tcb_minwidth )
                                {
                                        status.addVa(FAC_TCB, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                                                "channel width too small for section %d (%f)", i, 
                                                tcr[i].tcpar[0]);
                                        return DAEstatus::Failure;
                                }
                        }
                }
        }
        int clock_delay = 0;
        float frame_delay = 0.0;
        float min_tcb = m_crpt->tcr[0][0].start;
        for(i=0; i<m_crpt->ntrg; i++)
        {
                min_tcb = std::min(min_tcb, m_crpt->tcr[i][0].start);
        }
        if (m_dae_type == ISISDAE::NeutronDAE2 || m_dae_type == ISISDAE::NeutronDAE3)
        {
                // clock delay in 4us units
                clock_delay = (int)(min_tcb / 4.0);
                if (clock_delay * 4.0 > m_crpt->tcb_maxdelay)
                {
                        clock_delay = (int)(m_crpt->tcb_maxdelay / 4.0);
                }
                frame_delay = 4.0f * clock_delay; 
                // not less than (1.0 + m_crpt->electronics_delay / m_crpt->clock_frequency)
                if ( (min_tcb - frame_delay) < 1.4 )  // need to allow for electronics delay here, so 1.4 not 1.0
                {
                        clock_delay--;
                        frame_delay = 4.0f * clock_delay;
                }
        }
        float first_tcb = min_tcb - frame_delay; // first time channel boundary relative to any global frame_delay 
// we currently support multiple time remines, but only with 
// a global shift; hence only start may differ
//      for(i=0; i<m_crpt->ntrg; i++)
//      {
//              for(j=0; j<ISISCRPT_MAX_TCR; j++)
//              {
//                      if (!tcbRangesPurelyShifted(m_crpt->tcr[0][j], m_crpt->tcr[i][j]))
//                      {
//                                      status.addVa(FAC_TCB, SEV_ERROR, ERRTYPE_OUTOFMEM, 
//                                              "time regimes 1 and %d are incompatible", i+1); 
//                                      return DAEstatus::Failure;
//                      }
//              }
//      }
        m_crpt->tcb_delay = static_cast<int>(frame_delay);
        for(j=0; j<m_crpt->ntrg; j++)
        {
                TCBRANGE* tcr = m_crpt->tcr[j];
// we want (tcb_trdelay == 0) for the lowest time range
// do not need to be multiple of 4us, but want this to be zero for lowest regime
// need 1us for first channel min, multiple of 4us for delay
//              int tcb_trdelay = 4 * (int)((tcr[0].start - frame_delay - 1.0) / 4.0);
                int tcb_trdelay = (int)(tcr[0].start - frame_delay - first_tcb);
                if (tcb_trdelay < 0) 
                { 
                        tcb_trdelay = 0;
                }
                m_crpt->tcb_trdelay[j] = tcb_trdelay;
                if (fabs((m_crpt->tcr[j][0].start - m_crpt->tcb_trdelay[j]) - 
                             (m_crpt->tcr[0][0].start - m_crpt->tcb_trdelay[0])) > 1e-5)
                {
                                status.addVa(FAC_TCB, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                                                "time regimes 1 and %d are incompatible", j+1); 
                                return DAEstatus::Failure;
                }
        }
        // multiple TR not allowed on muons
        if ((m_dae_type == ISISDAE::MuonDAE2) && ((m_crpt->ntrg > 1) || (m_crpt->tcb_trdelay[0] != 0)) )
        {
                status.addVa(FAC_TCB, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                                                "%d time regimes not allowed on muons", m_crpt->ntrg); 
                return DAEstatus::Failure;
        }
        // now calc tcb
        // last_time is last time channel boundary output
        // current_time is what we are thinking about for the nmext boundary
        // last_width is the width of the "last_time" channel output

        // one regime will have trdelay of zero - used for boundaries at the moment
//      bool zero_shift_regime_avaiable = false;
//      for(j=0; j < m_crpt->ntrg; j++)
//      {
//              TCBRANGE* tcr = m_crpt->tcr[j];
//              if (tcr[0].mode != TCBRANGE_SHIFTED && m_crpt->tcb_trdelay[j] == 0)
//              {
//                      zero_shift_regime_avaiable = true;
//              }
//      }
        for(j=0; j < m_crpt->ntrg; j++)  
        {
                TCBRANGE* tcr = m_crpt->tcr[j];
                if (tcr[0].mode == TCBRANGE_SHIFTED)  // shifted from another regime
                {
                        continue;
                }
//              if (zero_shift_regime_avaiable && m_crpt->tcb_trdelay[j] > 0) // set up tc for first tr until we do things properly
//              {
//                      continue;
//              }
                int* tcb = m_crpt->tcb[j];
                float* rtcb = m_crpt->rtcb[j];
                int ntcr = m_crpt->ntcr[j];
                int nchan = 0;
                frame_delay = static_cast<float>(m_crpt->tcb_delay + m_crpt->tcb_trdelay[j]);
                double last_time = tcr[0].start - frame_delay;
                tcb[nchan] = (int)(0.5 + last_time * m_crpt->clock_frequency);
                last_time = (double)tcb[0] / m_crpt->clock_frequency;
                i = 0;
                nchan++;
                double current_time = last_time;
                double last_width = 0.0;
                int num_iterations = 0;
                while(i<ntcr)
                {
                        if (++num_iterations > 20 * ISISCRPT_MAX_TIMECHANB)
                        {
                                status.addVa(FAC_TCB, SEV_ERROR, ERRTYPE_OUTOFMEM, "Infinite loop detected while calculating time channels");
                                return DAEstatus::Failure;
                        }
                        if ( last_time >= (tcr[i].end - frame_delay) )
                        {
                                i++;
                                last_width = 0.0;
                                if (i < ntcr)
                                {
                                        current_time = tcr[i].start - frame_delay;
                                }
                                else
                                {
                                        continue;       // will exit as i >= ntcr
                                }
                        }
                        else
                        {
                                switch(tcr[i].mode)
                                {
                                        case TCBRANGE_FILE:
                                                current_time = rtcb_file[j][nchan] - frame_delay;
                                                break;
                                        case TCBRANGE_CONST_T:
                                                current_time = last_time + tcr[i].tcpar[0];
                                                break;
                                        case TCBRANGE_INC_T:
                                                current_time = last_time + (last_time+frame_delay)*tcr[i].tcpar[0];
                                                break;
                                        case TCBRANGE_INC_T_2:
                                                current_time = last_time + (last_time+frame_delay)*(last_time+frame_delay)*tcr[i].tcpar[0];
                                                break;
                                        default:
                                                status.addVa(FAC_TCB, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                                                        "unknown time channel mode %d", tcr[i].mode);
                                                return DAEstatus::Failure;
                                                break;
                                }
                                if ( (current_time - last_time) < m_crpt->tcb_minwidth )
                                {
                                        current_time = last_time + m_crpt->tcb_minwidth;
                                }
                                if ( current_time > (tcr[i].end - frame_delay) )
                                {
                                        current_time = tcr[i].end - frame_delay;
                                        if ( ((current_time - last_time) < (last_width / 4.0)) ||
                                                 ((current_time - last_time) < m_crpt->tcb_minwidth) )
                                        {
                                        // combine with previous channel
                                                nchan--;
                                                last_time = last_time - last_width;
                                        }
                                }
                        }
                        if ( (current_time - last_time) >= m_crpt->tcb_minwidth )
                        {
                                tcb[nchan] = (int)(0.5 + current_time * m_crpt->clock_frequency);
                                current_time = (double)tcb[nchan] / m_crpt->clock_frequency;
                                last_width = current_time - last_time;
                                last_time = current_time;
                                nchan++;
                        }
                        if (nchan >= ISISCRPT_MAX_TIMECHANB)
                        {
                                status.addVa(FAC_TCB, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                                                "too many time channels (> %d)", ISISCRPT_MAX_TIMECHANB);
                                return DAEstatus::Failure;
                        }
                }
                for(i=0; i<nchan; i++)
                {
                        rtcb[i] = (float)tcb[i] / m_crpt->clock_frequency + frame_delay;
                }
                // nchan boundaries, hence nchan-1 channels
                m_crpt->ntc[j] = nchan - 1;
        }
        for(j=0; j<m_crpt->ntrg; j++)
        {
                frame_delay = static_cast<float>(m_crpt->tcb_delay + m_crpt->tcb_trdelay[j]);
                int nchan = m_crpt->ntc[j] + 1;
                for(i=0; i<nchan; i++)
                {
                        m_crpt->rtcb[j][i] = (float)m_crpt->tcb[j][i] / m_crpt->clock_frequency + frame_delay;
                }
                if (rtcb_file[j] != NULL)
                {
                        delete[] rtcb_file[j];
                }
        }
        m_crpt->buildTimeRegimeMap();
        m_crpt->calculateCRPTOffsets();   // these depend on tcbs so also need to be recalculated when they change 
        return DAEstatus::Success;
//              status.addVa(FAC_TCB, SEV_ERROR, ERRTYPE_OUTOFMEM, "Not done tcb");
//              return DAEstatus::Failure;
}

int ISISinstrumentControl::setLinearTimeChannelRange(int range_number, float start, float end, float step, DAEstatus& status)
{
        return setTimeChannelRange(range_number, TCBRANGE_CONST_T, start, end, step, status);
}

int ISISinstrumentControl::setLogTimeChannelRange(int range_number, float start, float end, float step, DAEstatus& status)
{
        return setTimeChannelRange(range_number, TCBRANGE_INC_T, start, end, step, status);
}

int ISISinstrumentControl::setTimeChannelRange(int range_number, int range_type, float start, float end, float step, DAEstatus& status)
{
        if (range_number < 0 || range_number >= ISISCRPT_MAX_TCR)
        {
                status.addVa(FAC_TCB, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                                        "invalid range %d", range_number);
                return DAEstatus::Failure;
        }
        ICPCritical cs(&m_crpt_cs);
        TCBRANGE& tcr = m_crpt->tcr[0][range_number];
        tcr.mode = range_type;
        tcr.start = start;
        tcr.end = end;
        tcr.tcpar[0] = step;
        tcr.npar = 1;
        m_crpt->ntcr[0] = range_number + 1;
        m_crpt->ntrg = 1;
        tcbcalc(status);
        return DAEstatus::Success;
}

// beam current is calculated by the update thread
float ISISinstrumentControl::getBeamCurrent(DAEstatus& /*status*/)
{
        return m_crpt->beam_current;
}

// This is called every "poll_time" seconds by a separate thread 
// from the updateThread() function
int ISISinstrumentControl::updateFunc(int poll_time, bool only_refresh_cache)
{
        static unsigned long ncalls = 0;
        static unsigned long update_duration_total = 0; // number of seconds running 
        static bool disable_monitoring_in_event_mode = m_app->config().getBool("isisicp.monitoring.disableineventmode", false);
        bool skip_monitoring = (disable_monitoring_in_event_mode & m_crpt->usingEventMode());
        ncalls++;
        ++(m_crpt->update_num_polls);
        update_duration_total += poll_time;
        struct timeb new_update_time;
        if (!m_crpt.isValid())
        {
                return DAEstatus::Failure;
        }
        ICPCritical cs(&m_crpt_cs);
        time_t now;
        time(&now);
        time_t this_dur = (now - m_crpt->resume_time);
        ftime(&new_update_time); 
        float tdiff = (float)(new_update_time.time - (m_crpt->update_time).time) +
                (float)(new_update_time.millitm - (m_crpt->update_time).millitm) / 1e6f;
        // beam current
        float raw_uamph = getRawUAmpH(m_status);
        float good_uamph = getGoodUAmpH(m_status);

        float good_uamp_diff = good_uamph - m_crpt->update_good_uamph;

//      m_crpt->beam_current = 3600.0 * (raw_uamph - m_crpt->update_raw_uamph) / tdiff;
        m_crpt->beam_current = 3600.0f * (good_uamph - m_crpt->update_good_uamph) / tdiff;
        m_crpt->update_raw_uamph = raw_uamph;
        m_crpt->update_good_uamph = good_uamph;

        m_dae->getGoodPPPLower(&(m_crpt->update_good_ppp_low), m_status);
        m_dae->getGoodPPPUpper(&(m_crpt->update_good_ppp_high), m_status);
        m_dae->getRawPPPLower(&(m_crpt->update_total_ppp_low), m_status);
        m_dae->getRawPPPUpper(&(m_crpt->update_total_ppp_high), m_status);

        // count rate (units of million counts per hour)
        int64_t total_counts, total_counts_diff;
        getTotalCounts(total_counts, m_status);
        if (total_counts < 0)
        {
                total_counts = 0;
        }
        total_counts_diff = total_counts - m_crpt->update_total_counts;
        m_crpt->count_rate = 3600.0f * total_counts_diff / (1.0e6f * tdiff);
        if (m_crpt->count_rate < 0.0)
        {
                m_crpt->count_rate = 0.0;
        }
        m_crpt->update_total_counts = total_counts;

        // monitor integral
        long integral, max_value;
        int period, daq_period;
        getCurrentPeriodNumber(period, daq_period, m_status);
        getSpectrumIntegral(m_crpt->monitor_spectrum, period, m_crpt->monitor_range[0][0], m_crpt->monitor_range[0][1], integral, max_value, m_status);
        long integral_diff = integral - m_crpt->monitor_sum[0];
        m_crpt->monitor_sum[0] = integral;
        
        // frames
        isisU32_t good_frames, raw_frames, good_frames_diff, raw_frames_diff;
        m_dae->getGoodFrames(&good_frames, m_status);
        m_dae->getRawFrames(&raw_frames, m_status);
        good_frames_diff = good_frames - m_crpt->update_good_frames;
        raw_frames_diff = raw_frames - m_crpt->update_raw_frames;
        m_crpt->update_good_frames = good_frames;
        m_crpt->update_raw_frames = raw_frames;

        m_crpt->update_period = period;
        PERIOD& this_period = m_crpt->period[period];
        isisU32_t value32;
        m_dae->getCurrentPeriodSequence(&value32, m_status);
        m_crpt->update_period_sequence = value32;
                if (isRunning())
                {
                        if (m_crpt->period_type == ISISDAE::PeriodTypeSoftware)
                        {
                                m_crpt->update_good_frames_period = this_period.good_frames + (m_crpt->update_good_frames - m_crpt->good_frames);
                                m_crpt->update_raw_frames_period = this_period.total_frames + (m_crpt->update_raw_frames - m_crpt->total_frames);
                        }
                        else
                        {
                                m_dae->getGoodFramesPeriod(&(m_crpt->update_good_frames_period), period, m_status);
                                m_dae->getRawFramesPeriod(&(m_crpt->update_raw_frames_period), period, m_status);
                        }                       
                        m_crpt->update_duration = m_crpt->duration + this_dur;
                        m_crpt->update_duration_period = this_period.duration + this_dur;
                }
                else
                {
                        if (m_crpt->period_type == ISISDAE::PeriodTypeSoftware)
                        {
                                m_crpt->update_good_frames_period = this_period.good_frames;
                                m_crpt->update_raw_frames_period = this_period.total_frames;
                        }
                        else
                        {
                                m_dae->getGoodFramesPeriod(&(m_crpt->update_good_frames_period), period, m_status);
                                m_dae->getRawFramesPeriod(&(m_crpt->update_raw_frames_period), period, m_status);
                        }
                        m_crpt->update_duration = m_crpt->duration;
                        m_crpt->update_duration_period = this_period.duration;
                }

        // n/p ratio
        if ( !only_refresh_cache && !skip_monitoring && (m_crpt->monitoring.enabled != 0) )
        {
                float tdiff_mon = (float)(new_update_time.time - (m_crpt->monitoring.calc_last_time).time) +
                          (float)(new_update_time.millitm - (m_crpt->monitoring.calc_last_time).millitm) / 1e6f;
                if ( (m_crpt->monitoring.calc_freq > 0) && (tdiff_mon >= m_crpt->monitoring.calc_freq) )
                {
                        char buffer[20];
                        std::map<std::string,double> values;
                        std::vector<long> spectra_used(m_crpt->monitoring.n);
                        for(int i=0; i<m_crpt->monitoring.n; i++)
                        {
                                monitoring_par& par = m_crpt->monitoring.v[i];
                                spectra_used[i] = par.spectrum;
                        }
                        std::sort(spectra_used.begin(), spectra_used.end());
                        std::vector<long>::iterator new_end = std::unique(spectra_used.begin(), spectra_used.end());
                        updateCRPTSpectra(period, &(spectra_used[0]), distance(spectra_used.begin(), new_end), m_status);
                        for(int i=0; i<m_crpt->monitoring.n; i++)
                        {
                                monitoring_par& par = m_crpt->monitoring.v[i];
                                getCRPTSpectrumIntegral(par.spectrum, period, par.t_low, par.t_high, integral, max_value, m_status);
                                par.last_change = ((double)integral - par.last_value);
                                par.last_value = integral;
                                sprintf(buffer, "V%d", i+1);
                                values[buffer] = par.last_change;
                                sprintf(buffer, "_V%d", i+1);
                                values[buffer] = par.last_value;
                        }
                        values["T"] = tdiff_mon;
                        values["_T"] = difftime(now, m_crpt->start_time);
                        values["GF"] = m_crpt->update_good_frames - m_crpt->monitoring.last_gf;
                        values["_GF"] = m_crpt->update_good_frames;
                        values["UA"] = m_crpt->update_good_uamph - m_crpt->monitoring.last_ua;
                        values["_UA"] = m_crpt->update_good_uamph;
                        values["MEV"] = (m_crpt->update_total_counts - m_crpt->monitoring.last_tc) / 1.0e6;
                        values["_MEV"] = m_crpt->update_total_counts / 1.0e6;
                        m_crpt->monitoring.last_gf = m_crpt->update_good_frames;
                        m_crpt->monitoring.last_ua = m_crpt->update_good_uamph;
                        m_crpt->monitoring.last_tc = m_crpt->update_total_counts;
                        double result = 0.0;
                        if ( !only_refresh_cache && isRunning() && (values["GF"] >= 1.0) && evaluateExpression(values, m_crpt->monitoring.expression, result, m_status) == DAEstatus::Success)
                        {
                                //std::string sender = std::string("isisicp@") + m_crpt->comp_name + ".isis.cclrc.ac.uk";
                                std::string sender = "isisicp@shadow.nd.rl.ac.uk";
                                std::string alert_sms, line;
                                std::fstream fs;
                                fs.open(m_icp_dir+"\\sms_send.txt");  // one number per line, # for comments
                                while(fs.good())
                                {
                                        line.clear();
                                        std::getline(fs, line, '\n');
                                        int i = line.find('#');
                                        if (i != std::string::npos)
                                        {
                                                line.erase(i);
                                        }
                                        alert_sms.append(",");
                                        alert_sms.append(line);
                                }
                                fs.close();
                                alert_sms.erase(std::remove(alert_sms.begin(), alert_sms.end(), ' '), alert_sms.end()); // remove spaces
                                m_crpt->update_npratio_current = result;
                                int oldper = m_crpt->software_period;
                                int newper = -1;
                                if (result < m_crpt->monitoring.valid_low || result > m_crpt->monitoring.valid_high)
                                {
                                        switch(m_crpt->monitoring.action)
                                        {
                                        case 0:
                                                break;

                                        case 1:
                                                newper = m_crpt->monitoring.action_period - 1;
                                                break;

                                        case 2:
                                                newper = m_crpt->nper - 1;
                                                break;
                                        }
                                        if (newper != -1 && newper != oldper)
                                        {
                                                logEventVa(m_crpt, m_status, "NPRATIO OUT_OF_RANGE %g", result);
                                                changePeriodWhileRunning(newper, true, m_status);   // this does not call refreshCache()
                                                m_crpt->monitoring.return_period = oldper;
                                                if (m_crpt->monitoring.alerts > 0)
                                                {
//                                                      std::string sender = std::string("isisicp@") + m_crpt->comp_name + ".isis.cclrc.ac.uk";
                                                        sendEmail(sender, m_crpt->alert_email, std::string(m_crpt->comp_name)+" overcounting problem", 
                                                                std::string(m_crpt->comp_name)+" overcounting problem", m_status);
                                                        sendSMS(alert_sms, std::string(m_crpt->comp_name)+" overcounting problem", m_status);
                                                }
                                        }
                                }
                                else
                                {
                                        switch(m_crpt->monitoring.action)
                                        {
                                        case 0:
                                                break;

                                        case 1:
                                        case 2:
                                                if (m_crpt->monitoring.return_period != -1)
                                                {
                                                        if (m_crpt->monitoring.return_period != m_crpt->software_period)
                                                        {
                                                                logEventVa(m_crpt, m_status, "NPRATIO IN_RANGE %g", result);
                                                                changePeriodWhileRunning(m_crpt->monitoring.return_period, true, m_status);
                                                                if (m_crpt->monitoring.alerts > 0)
                                                                {
                                                                        sendEmail(sender, m_crpt->alert_email, std::string(m_crpt->comp_name)+" overcounting now OK", 
                                                                                std::string(m_crpt->comp_name)+" overcounting now OK", m_status);
                                                                        sendSMS(alert_sms, std::string(m_crpt->comp_name)+" overcounting now OK", m_status);
                                                                }
                                                        }
                                                        m_crpt->monitoring.return_period = -1;
                                                }
                                                break;
                                        }
                                }
                        }
                        m_crpt->update_npratio_average = 0.0;
                        m_crpt->monitoring.calc_last_time = new_update_time;
                }
                if ( isRunning() /* && (m_crpt->beam_current > 0.0) */ && (m_crpt->monitoring.log_freq > 0) && ((now - m_crpt->monitoring.log_last_time) >= m_crpt->monitoring.log_freq) )
                {
                        updateMonitoringLog();
                        m_crpt->monitoring.log_last_time = now;
                }
        }

        if ( !only_refresh_cache && (update_duration_total % 30 == 0) )
        {
                updateStatusLog();
                updateICPTimeDiffLog();
        }
        if ( only_refresh_cache || (update_duration_total % 15 == 0) )
        {
                seblock_map_t seblocks;
                if (se_get_block_values(seblocks) == 0)
                {
                        updateSampleParameters(m_crpt.sampleParameters(), m_crpt, &seblocks, m_status);
                        updateBeamlineParameters(m_crpt.beamlineParameters(), m_crpt, &seblocks, m_status);
                }
                else
                {
                        m_status.addInfoVa(FAC_DAE, "Error from SQLITE: %s", se_get_errmsg());
                }
        }
        m_crpt->update_time = new_update_time;
        if (!only_refresh_cache)
        {
// autosaves
                bool write_autosave = false;
                switch(m_crpt->auto_save_type)
                {
                        case 0: // frames
                                if ( (m_crpt->update_good_frames - m_crpt->auto_save_last) > m_crpt->auto_save_value )
                                {
                                        m_crpt->auto_save_last = m_crpt->update_good_frames;
                                        write_autosave = true;
                                }
                                break;

                        case 1: // events
                                if ( (m_crpt->update_total_counts - m_crpt->auto_save_last) > m_crpt->auto_save_value )
                                {
                                        m_crpt->auto_save_last = m_crpt->update_total_counts;
                                        write_autosave = true;
                                }
                                break;

                        case 2: // dashboard polls
                                if ( (m_crpt->auto_save_value > 0) && (m_crpt->update_num_polls % m_crpt->auto_save_value == 0) )
                                {
                                        m_crpt->auto_save_last = m_crpt->update_num_polls;
                                        write_autosave = true;
                                }
                                break;

                        case 3: // uamph
                                if ( (m_crpt->update_good_uamph - m_crpt->auto_save_last) > m_crpt->auto_save_value )
                                {
                                        m_crpt->auto_save_last = m_crpt->update_good_uamph;
                                        write_autosave = true;
                                }
                                break;

                        default:
                                break;
                }
                // check we are not in setup before writing an autosave file, update thread may have got
                // queued after a run ended and so will write the wrong run number
                if ( write_autosave && (m_crpt->run_status != RUNSTATUS_SETUP) && (m_icp_options & AutoSave) )
                {
                        writeAutosaveFile(m_status);
                }
                if ( m_icp_options & PeriodSequenceAutoEnd )
                {
                        if ( isRunning() && m_dae->isMultiplePeriodSequenceComplete(m_status) )
                        {
                                endRun(m_status);
                        }
                }
        }
        static int nagios_poll = m_app->config().getInt("isisicp.nagios.poll", 60);
        static double veto_warn = m_app->config().getDouble("isisicp.nagios.veto.warn", 80.0);
        static double veto_critical = m_app->config().getDouble("isisicp.nagios.veto.critical", 90.0);
        static double wait_warn = m_app->config().getDouble("isisicp.nagios.wait.warn", 120.0);
        static double wait_critical = m_app->config().getDouble("isisicp.nagios.wait.critical", 180.0);
        static double shutter_warn = m_app->config().getDouble("isisicp.nagios.shutter.warn", 5.0);
        if ( !only_refresh_cache && (update_duration_total % nagios_poll == 0) )
        {
                // nagios stuff
                nagios_t& nagios = m_crpt->nagios;
                nagios.veto_percent = 0.0;
                if (raw_frames_diff > 0)
                {
                        nagios.veto_percent = 100.0 * (1.0 - (double)good_frames_diff / (double)raw_frames_diff);
                }
//              std::string veto_message = Poco::format("Vetoing %.1f%% of data;|'veto'=%f%%;%f;%f\n", veto_percent, veto_percent, veto_warn, veto_critical);
//              veto_message += Poco::format("Vetoing %.1f%%\n", veto_percent);
//              veto_message += Poco::format("Effective beam current %.1f uA\n", (double)m_crpt->beam_current);
//              veto_message += Poco::format("Good proton charge %.1f uAh\n", (double)m_crpt->update_good_uamph);
//              veto_message += Poco::format("Good frames %ld\n", m_crpt->update_good_frames);
//              veto_message += Poco::format("Raw frames %ld\n", m_crpt->update_raw_frames);
//              veto_message += Poco::format("Run duration %ld seconds|'duration'=%lds\n", m_crpt->update_duration, m_crpt->update_duration);
//              veto_message += Poco::format("'beamcurrent'=%f\n", (double)m_crpt->beam_current);                       
//              veto_message += Poco::format("'gooduah'=%f\n", (double)m_crpt->update_good_uamph);                      
//              veto_message += Poco::format("'goodframes'=%ld\n",  m_crpt->update_good_frames);                        
//              veto_message += Poco::format("'rawframes'=%ld",  m_crpt->update_raw_frames);                    
                std::string veto_message = Poco::format("Vetoing %.1f%% of data;|'veto'=%f%%;%f;%f", nagios.veto_percent, nagios.veto_percent, veto_warn, veto_critical);
                Poco::format(veto_message, " 'beamcurrent'=%f", (double)m_crpt->beam_current);                  
                Poco::format(veto_message, " 'gooduah'=%f", (double)m_crpt->update_good_uamph);                 
                Poco::format(veto_message, " 'goodframes'=%ld",  m_crpt->update_good_frames);                   
                Poco::format(veto_message, " 'rawframes'=%ld",  m_crpt->update_raw_frames);                     
                Poco::format(veto_message, " 'duration'=%lds",  m_crpt->update_duration);                       
                if (beamOn(1))
                {
                        if (nagios.veto_percent > veto_critical)
                        {
                                nagios.dae_status = 2;
                        }
                        else if (nagios.veto_percent > veto_warn)
                        {
                                nagios.dae_status = 1;
                        }
                        else
                        {
                                nagios.dae_status = 0;
                        }
                }
                sendNagios(nagios.dae_status, "DAE STATUS", veto_message, m_status);
                nagios.wait_mins = difftime(now, m_crpt->stop_time) / 60.0;
                if (!isWaiting())
                {
                        nagios.wait_mins = 0;
                }
                std::string wait_message = Poco::format("Waiting for %.1f minutes;|'data'=%fs;%f;%f", nagios.wait_mins, nagios.wait_mins * 60.0, wait_warn * 60.0, wait_critical * 60.0);
                if (isWaiting() && nagios.wait_mins > wait_warn)
                {
                        if (beamOn(1))
                        {
                                if (nagios.wait_mins > wait_critical)
                                {
                                        nagios.wait_status = 2;
                                }
                                else
                                {
                                        nagios.wait_status = 1;
                                }
                        }
                }
                else
                {
                        nagios.wait_status = 0;
                }
                sendNagios(nagios.wait_status, "DAE WAITING", wait_message, m_status);
                if ( isRunning() && m_crpt->update_duration > shutter_warn * 60 )
                {
                        if ( beamOn(1) )
                        {
                                if ( m_crpt->beamlogger.shutter == 0 || (total_counts_diff == 0 && integral_diff == 0) )
                                {
                                        nagios.shutter_status = 1;
                                }
                                else
                                {
                                        nagios.shutter_status = 0;
                                }
                        }
                }
                else
                {
                        nagios.shutter_status = 0;
                }
                if ( m_crpt->dae_type == ISISDAE::MuonDAE2 && beamOn(10) && !muonKickerOK() )
                {
                        nagios.shutter_status = 1;
                }
                if (nagios.shutter_status > 0)
                {
                        nagios.shutter_val = 0;
                }
                else
                {
                        nagios.shutter_val = 1 + m_crpt->beamlogger.shutter; // 0 for closed plus running (or muon kicker not working), 1 for closed, 2 for open
                }
                std::string shutter_message;
                if (  m_crpt->dae_type == ISISDAE::MuonDAE2 )
                {
                        shutter_message = Poco::format("KICKER %s COLLECTING %s;|'data'=%d;1:;0:", std::string(m_crpt->beamlogger.muonkicker ? "ON" : "OFF"),
                                std::string(nagios.shutter_status ? "NO" : "YES"), nagios.shutter_val);
                }
                else
                {
                        shutter_message = Poco::format("SHUTTER %s%s;|'data'=%d;1:;0:", std::string(m_crpt->beamlogger.shutter ? "OPEN" : "CLOSED"), 
                                std::string(nagios.shutter_status ? " and running" : ""), nagios.shutter_val);
                }
                sendNagios(nagios.shutter_status, "BEAMLINE", shutter_message, m_status);
        }
        flushCRPT(m_status);
        return DAEstatus::Success;
}


void ISISinstrumentControl::updateICPTimeDiffLog()
{
//              float run_dur = difftime(time(NULL), m_crpt->start_time);
//              m_status.addInfoVa(FAC_DAE, "Runtime = %.0f s, Frame timer drift (icp - dae) = %f ms", run_dur, m_dae->frameTimerDrift(m_status) / 1000.0);
//              m_status.addInfoVa(FAC_DAE, "Runtime = %.0f s, System timer drift (icp - system) = %f ms", run_dur, diffFileTimesInMilliSec(system_ft, icp_ft));
//              if (update_duration_total > 0)
//              {
//                      m_status.addInfoVa(FAC_DAE, "Frame timer drift / run time = %f", m_dae->frameTimerDrift(m_status) / update_duration_total);
//              }
        static bool write_tdiff_file = m_app->config().getBool("isisicp.logfiles.writetdiff", false);
        bool file_exists = false;
        struct stat stat_struct;
        char time_buffer[128];
        FILETIME icp_ft, system_ft;
        g_icp_clock.get()->getCurrentTimeAsFiletime(icp_ft);
        GetSystemTimeAsFileTime(&system_ft);
        ISOtime(time(NULL), time_buffer, sizeof(time_buffer));
        double icp_dae_td = m_dae->frameTimerDrift(m_status) / 1000.0;
        double icp_sys_td = diffFileTimesInMilliSec(system_ft, icp_ft);
        if (se_log_value_async(m_crpt->run_number, "ISISICP", time_buffer, "ICP_DAE_TD", Poco::format("%f", icp_dae_td).c_str()) != 0)
        {
                m_status.addInfoVa(FAC_DAE, "Error from SQLITE: %s", se_get_errmsg());
        }       
        if (se_log_value_async(m_crpt->run_number, "ISISICP", time_buffer, "ICP_SYS_TD", Poco::format("%f", icp_sys_td).c_str()) != 0)
        {
                m_status.addInfoVa(FAC_DAE, "Error from SQLITE: %s", se_get_errmsg());
        }       
        if (write_tdiff_file)
        {
                if (stat(m_crpt.timeDiffLog().c_str(), &stat_struct) == 0)
                {
                        file_exists = true;
                }
                std::stringstream f;
                if (!file_exists)
                {
                        f << "# iso time, Frame timer drift (icp - dae) ms, System timer drift (icp - system) ms\r\n";
                }
                f << time_buffer << " " << icp_dae_td << " " << icp_sys_td << "\r\n";
                appendToFileAsync(m_crpt.timeDiffLog().c_str(), f.str().c_str());
        }
}

int ISISinstrumentControl::updateMonitoringLog()
{
        bool file_exists = false;
        struct stat stat_struct;
        char time_buffer[128], buffer[128];
        if (stat(m_crpt.monitoringLog().c_str(), &stat_struct) == 0)
        {
                file_exists = true;
        }
        std::stringstream f;
        ISOtime(m_crpt->monitoring.calc_last_time.time, time_buffer, sizeof(time_buffer));
        if (!file_exists) // start of file
        {
                f << "# time expression_value";
                for(int i=1; i<=m_crpt->monitoring.n; i++)
                {
                        f << " V" << i;    //  << " dV" << i;
                }
                f << "\r\n";
        }
        f << time_buffer << " " << m_crpt->update_npratio_current;
        for(int i=0; i<m_crpt->monitoring.n; i++)
        {
                monitoring_par& par = m_crpt->monitoring.v[i];
                f << " " << par.last_value;   //  << " " << par.last_change;
        }
        f << "\r\n";
        appendToFileAsync(m_crpt.monitoringLog().c_str(), f.str().c_str());
        std::vector<std::string> iso_times;
        std::vector<std::string> block_names;
        std::vector<std::string> block_values;
        for(int i=0; i<m_crpt->monitoring.n; i++)
        {
                monitoring_par& par = m_crpt->monitoring.v[i];
                sprintf(buffer, "monitoring_v%d", i+1);
                block_names.push_back(buffer);
                sprintf(buffer, "%g", par.last_value);
                block_values.push_back(buffer);
        }
        block_names.push_back("monitoring_expression");
        sprintf(buffer, "%g", m_crpt->update_npratio_current);
        block_values.push_back(buffer);
        iso_times.resize(block_names.size());
        std::fill(iso_times.begin(), iso_times.end(), time_buffer);
        if (se_log_values_async(m_crpt->run_number, "ISISICP", iso_times, block_names, block_values) != 0)
        {
                m_status.addInfoVa(FAC_DAE, "Error from SQLITE: %s", se_get_errmsg());
        }       
        return DAEstatus::Success;
}

int ISISinstrumentControl::updateStatusLog()
{
        static bool write_status_file = m_app->config().getBool("isisicp.logfiles.writestatus", false);
        bool file_exists = false;
        char time_buffer[128];
        struct stat stat_struct;
        time_t unix_time = 0;
//      isisU32_t igf, irf;
//      m_dae->getGoodFrames(&igf, m_status);
//      m_dae->getRawFrames(&irf, m_status);
        time(&unix_time);
        ISOtime(unix_time, time_buffer, sizeof(time_buffer));
        if (se_log_run(m_crpt->run_number, "ISISICP", time_buffer, m_crpt->update_period + 1,
                                m_crpt->run_status, (isRunning() ? 1 : 0), (isWaiting() ? 1 : 0),
                                m_crpt->update_good_frames, m_crpt->update_raw_frames, 
                                m_crpt->update_good_uamph, m_crpt->update_raw_uamph,
                        m_crpt->monitor_sum[0], m_crpt->beam_current, m_crpt->update_total_counts,
                                m_crpt->count_rate, m_crpt->update_npratio_current) != 0)
        {
                m_status.addInfoVa(FAC_DAE, "Error from SQLITE: %s", se_get_errmsg());
        }
        if (write_status_file)
        {
                if (stat(m_crpt.statusLog().c_str(), &stat_struct) == 0)
                {
                        file_exists = true;
                }
                std::stringstream f;
                if (!file_exists) // start of file
                {
                        f << "# time period is_running is_waiting good_frames raw_frames good_uamps raw_uamph monitor1_sum dae_beam_current total_counts count_rate np_ratio\r\n";
                }
                f << time_buffer << " " <<
                                m_crpt->update_period + 1 << " " <<
                                (isRunning() ? 1 : 0) << " " <<
                                (isWaiting() ? 1 : 0) << " " <<
                                m_crpt->update_good_frames << " " << m_crpt->update_raw_frames << " " << 
                                m_crpt->update_good_uamph << " " << m_crpt->update_raw_uamph << " " <<
                        m_crpt->monitor_sum[0] << " " <<
                                m_crpt->beam_current << " " <<
                                m_crpt->update_total_counts << " " << 
                                m_crpt->count_rate << " " <<
                                m_crpt->update_npratio_current << " " <<
                                "\r\n";
                appendToFileAsync(m_crpt.statusLog().c_str(), f.str().c_str());
        }
        return DAEstatus::Success;
}       

int ISISinstrumentControl::allReportFunc(const DAEstatus_message& mess, void* arg)
{
        ISISinstrumentControl* the_icp = static_cast<ISISinstrumentControl*>(arg);
        if (the_icp != NULL)
        {
                return the_icp->allReportFuncMain(mess);
        }
        else
        {
                return 0;
        }
}

int ISISinstrumentControl::allReportFuncMain(const DAEstatus_message& mess)
{
        debug_report_arg_t params;
        params.filename = m_crpt.debugLog();
        if (m_crpt.isValid())
        {
                params.run_number = m_crpt->run_number;
        }
        else
        {
                params.run_number = 0;
        }
        if (m_report_func != NULL)
        {
                (*m_report_func)(mess, m_report_arg);
        }
        debugReportFunction(mess, &params);
// would be nice to put these in the database, but if there is a problem
// on the instrument the size gets too big
//      sqliteReportFunction(mess, &params);
        return 0;
}

//int ISISinstrumentControl::logStatus(DAEstatus& status)
//{
//      debug_report_arg_t params;
//      params.filename = m_debug_log;
//      params.run_number = m_crpt->run_number;
//      status.reportAll(m_report_func, m_report_arg, false, false);
//      status.reportAll(debugReportFunction, &params, false, false);
//      status.reportAll(sqliteReportFunction, &params, false, false);
//      return 0;
//}

int ISISinstrumentControl::logEventVa(const CRPTProxy& crpt, DAEstatus& status, const char* event, ... )
{
        va_list ap;
        va_start(ap, event);
        int ret = logEventVaImp(time(NULL), crpt, status, event, ap);
        va_end(ap);
        return ret;
}

int ISISinstrumentControl::logEventVa(time_t the_time, const CRPTProxy& crpt, DAEstatus& status, const char* event, ... )
{
        va_list ap;
        va_start(ap, event);
        int ret = logEventVaImp(the_time, crpt, status, event, ap);
        va_end(ap);
        return ret;
}

int ISISinstrumentControl::logEventVaImp(time_t the_time, const CRPTProxy& crpt, DAEstatus& status, const char* event, va_list ap)
{
        char buffer[1024];
        vsnprintf(buffer, sizeof(buffer)-1, event, ap);
        NULL_TERMINATE(buffer);
        return logEvent(the_time, crpt, buffer, status);
}

int ISISinstrumentControl::logEvent(const CRPTProxy& crpt, const std::string& event, DAEstatus& status)
{
        return logEvent(time(NULL), crpt, event, status);
}

int ISISinstrumentControl::logEvent(time_t the_time, const CRPTProxy& crpt, const std::string& event, DAEstatus& status)
{
        char time_buffer[128];
        std::stringstream s;
        ISOtime(the_time, time_buffer, sizeof(time_buffer));
        s << time_buffer << ' ' << event << "\r\n";
        appendToFileAsync(crpt.eventLog().c_str(), s.str().c_str());
#if 0
        FILE* f = fopen(m_event_log.c_str(), "a+t");
        if (f != NULL)
        {
                fputs(s.str().c_str(), f);
                fclose(f);
        }
#endif
        if (crpt.isValid())
        {
                if (se_log_value_async(crpt->run_number, "ISISICP", time_buffer, "ICPEVENT", event.c_str()) != 0)
                {
                        status.addInfoVa(FAC_DAE, "Error from SQLITE: %s", se_get_errmsg());
                }
        }
        return DAEstatus::Success;
}

int ISISinstrumentControl::ISOtime(const struct timeb& tb, char* buffer, int len)
{
        return ISOtime(tb.time, buffer, len);
}

int ISISinstrumentControl::ISOtime(time_t time, char* buffer, int len)
{
        struct tm *tm_struct;
        buffer[0] = '\0';
        tm_struct = localtime(&time);
        if (tm_struct != 0)
        {
                strftime(buffer, len, "%Y-%m-%dT%H:%M:%S", tm_struct);
        }
        else
        {
                strncpy(buffer, "<UNKNOWN>", len);
        }
        buffer[len-1] = '\0';
        return DAEstatus::Success;
}

int ISISinstrumentControl::prettyTime(const struct timeb& tb, char* buffer, int len)
{
        return prettyTime(tb.time, buffer, len);
}

int ISISinstrumentControl::prettyTime(time_t time, char* buffer, int len)
{
        struct tm *tm_struct;
        buffer[0] = '\0';
        tm_struct = localtime(&time);
        if (tm_struct != 0)
        {
                strftime(buffer, len, "%a %d-%b-%Y %H:%M:%S", tm_struct);
        }
        else
        {
                strncpy(buffer, "<UNKNOWN>", len);
        }
        buffer[len-1] = '\0';
        return DAEstatus::Success;
}

// 0 is first period
int ISISinstrumentControl::getCurrentPeriodNumber(int& period, int& daq_period, DAEstatus& status)
{
                isisU32_t value;
                if (m_crpt->period_type == ISISDAE::PeriodTypeSoftware)
                {
                        period = daq_period = m_crpt->software_period; // daq and dwell are the same
                        return DAEstatus::Success;
                }
                // hardware periods
                ICPCritical cs(&m_crpt_cs);
                m_dae->getCurrentHardwarePeriod(&value, status);
                period = value;
                m_dae->getCurrentDAQHardwarePeriod(&value, status);
                daq_period = value;
                if (period < 0 || period >= m_crpt->nper)
                {                        
                        status.addWarningVa(FAC_DAE, "Total period number out of range (1 <= %d <= %d)", period+1, m_crpt->nper);
                        period = m_crpt->nper - 1;
                }
                if (daq_period < 0 || daq_period >= m_crpt->nper_daq)
                {                        
                        status.addWarningVa(FAC_DAE, "DAQ (detector card) period number out of range (1 <= %d <= %d)", daq_period+1, m_crpt->nper_daq);
                        daq_period = m_crpt->nper_daq - 1;
                }
                if (m_crpt->period[period].daq_period >= 0) 
                {
                        if (daq_period != m_crpt->period[period].daq_period)
                        {
                                m_period_error = true;
                                status.addInfoVa(FAC_DAE, "DAQ period mismatch for period %d: actual %d != CRPT %d", period+1, 1+daq_period, 1+m_crpt->period[period].daq_period);
                        }
                        else if (m_period_error)
                        {
                                m_period_error = false;
                                status.addInfoVa(FAC_DAE, "DAQ period OK for period %d (=%d)", period+1, 1+daq_period);
                        }
                }
                return DAEstatus::Success;
        }

        float ISISinstrumentControl::getGoodUAmpH(DAEstatus& status)
        {
                ICPCritical cs(&m_crpt_cs);
                float f = m_dae->getGoodUAmpHours(status);
                return f;
        }

        float ISISinstrumentControl::getRawUAmpH(DAEstatus& status)
        {
                ICPCritical cs(&m_crpt_cs);
                float f = m_dae->getRawUAmpHours(status);
                return f;
        }

        int ISISinstrumentControl::getRawFrames(DAEstatus& status)
        {
                isisU32_t irf;
                ICPCritical cs(&m_crpt_cs);
                m_dae->getRawFrames(&irf, status);
                return irf;
        }

        int ISISinstrumentControl::getCurrentPeriodRawFrames(DAEstatus& status)
        {
                isisU32_t irf;
                int p, daq_p;
                getCurrentPeriodNumber(p, daq_p, status);
                ICPCritical cs(&m_crpt_cs);
                m_dae->getRawFramesPeriod(&irf, p, status);
                return irf;
        }

        float ISISinstrumentControl::getCurrentPeriodGoodUAmpH(DAEstatus& status)
        {
                int p, daq_p;
                getCurrentPeriodNumber(p, daq_p, status);
                ICPCritical cs(&m_crpt_cs);
                float f = m_dae->getGoodUAmpHoursPeriod(p, status);
                return f;
        }

        float ISISinstrumentControl::getCurrentPeriodRawUAmpH(DAEstatus& status)
        {
                int p, daq_p;
                getCurrentPeriodNumber(p, daq_p, status);
                ICPCritical cs(&m_crpt_cs);
                float f = m_dae->getRawUAmpHoursPeriod(p, status);
                return f;
        }

        int ISISinstrumentControl::getCurrentPeriodGoodFrames(DAEstatus& status)
        {
                isisU32_t igf;
                int p, daq_p;
                getCurrentPeriodNumber(p, daq_p, status);
                ICPCritical cs(&m_crpt_cs);
                m_dae->getGoodFramesPeriod(&igf, p, status);
                return igf;
        }

        int ISISinstrumentControl::getGoodFrames(DAEstatus& status)
        {
                isisU32_t igf;
                ICPCritical cs(&m_crpt_cs);
                m_dae->getGoodFrames(&igf, status);
                return igf;
        }

        int ISISinstrumentControl::updateStatusXML(std::string& status_xml, DAEstatus& status)
        {
                if (!m_crpt.isValid())
                {
                        status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "CRPT is NULL");
                        return status.result();
                }
                char buffer[64];
                isisU32_t value32;
                ICPCritical cs(&m_crpt_cs);
                LabviewXML lvxml(status);
                lvxml.loadFromString(status_xml.c_str(), status);

                lvxml.setValue("BeamCurrent", m_crpt->beam_current, status);
                lvxml.setValue("TotalUAmps", m_crpt->update_good_uamph, status);
                lvxml.setValue("RunStatus", m_crpt->run_status, status);
                
                sprintf(buffer, "%0*d", m_run_number_digits, m_crpt->run_number);
                lvxml.setValue("RunNumber", buffer, status);
                lvxml.setValue("GoodFramesTotal", m_crpt->update_good_frames, status);
                lvxml.setValue("RawFramesTotal", m_crpt->update_raw_frames, status);
                int period = m_crpt->update_period;
                PERIOD& this_period = m_crpt->period[period];
                lvxml.setValue("Period Type", m_crpt->period_type, status);
                lvxml.setValue("PeriodLabel", this_period.label, status);
                lvxml.setValue("PeriodSequence", m_crpt->update_period_sequence, status);

#if 0
                if (isRunning())
                {
                        if (m_crpt->period_type == ISISDAE::PeriodTypeSoftware)
                        {
                                lvxml.setValue("GoodFramesPeriod", this_period.good_frames + (igf - m_crpt->good_frames), status);
                                lvxml.setValue("RawFramesPeriod", this_period.total_frames + (irf - m_crpt->total_frames), status);
                        }
                        else
                        {
                                m_dae->getRawFramesPeriod(&irf, period, status);
                                m_dae->getGoodFramesPeriod(&igf, period, status);
                                lvxml.setValue("GoodFramesPeriod", igf, status);
                                lvxml.setValue("RawFramesPeriod", irf, status);
                        }                       
                        lvxml.setValue("RunDurationTotal", m_crpt->duration + this_dur, status);
                        lvxml.setValue("RunDurationPeriod", this_period.duration + this_dur, status);
                }
                else
                {
                        if (m_crpt->period_type == ISISDAE::PeriodTypeSoftware)
                        {
                                lvxml.setValue("GoodFramesPeriod", this_period.good_frames, status);
                                lvxml.setValue("RawFramesPeriod", this_period.total_frames, status);
                        }
                        else
                        {
                                m_dae->getRawFramesPeriod(&irf, period, status);
                                m_dae->getGoodFramesPeriod(&igf, period, status);
                                lvxml.setValue("GoodFramesPeriod", igf, status);
                                lvxml.setValue("RawFramesPeriod", irf, status);
                        }
                        lvxml.setValue("RunDurationTotal", m_crpt->duration, status);
                        lvxml.setValue("RunDurationPeriod", this_period.duration, status);
                }
#endif
                lvxml.setValue("RunDurationTotal", m_crpt->update_duration, status);
                lvxml.setValue("RunDurationPeriod", m_crpt->update_duration_period, status);
                lvxml.setValue("GoodFramesPeriod", m_crpt->update_good_frames_period, status);
                lvxml.setValue("RawFramesPeriod", m_crpt->update_raw_frames_period, status);

                lvxml.setValue("CurrentPeriod", period+1, status);
                prettyTime(m_crpt->start_time, buffer, sizeof(buffer));
                lvxml.setValue("StartTime", buffer, status);
                lvxml.setValue("DAETimingSource", m_crpt->tcb_sync, status);
                lvxml.setValue("NumberOfSpectra", m_crpt->getNumSpectra(), status);
                lvxml.setValue("NumberOfTimeChannels", m_crpt->ntc[0], status);    // time regime 1 only
                lvxml.setValue("NumberOfPeriods", m_crpt->nper, status);
                lvxml.setValue("MonitorSpectrum", m_crpt->monitor_spectrum, status);
                lvxml.setValue("MonitorFrom", m_crpt->monitor_range[0][0], status);
                lvxml.setValue("MonitorTo", m_crpt->monitor_range[0][1], status);
                lvxml.setValue("MonitorCounts", m_crpt->monitor_sum[0], status);
                lvxml.setValue("CountRate", m_crpt->count_rate, status);
                lvxml.setValue("TotalDAECounts", (float)m_crpt->update_total_counts / (float)1e6, status);
                lvxml.setValue("InstName", m_crpt->inst_name, status);
//              lvxml.setValue("InstAbrv", m_crpt->inst_abrv, status);
                std::string run_title;
                if (m_simulation_mode)
                {
                        run_title = "(DAE SIMULATION MODE) ";
                }
                run_title.append(m_crpt->long_title);
                lvxml.setValue("RunTitle", run_title.c_str(), status);
                lvxml.setValue("UserName", m_crpt->user_name, status);
                lvxml.setValue("RBNumber", m_crpt->rb_number, status);
                lvxml.setValue("UserTelephone", m_crpt->user_telephone, status);
                value32 = m_crpt->getPeriodSize() * m_crpt->nper_daq / 256; // in Kb
                lvxml.setValue("DAEMemoryUsed", value32, status);
                prettyTime(m_crpt->update_time, buffer, sizeof(buffer));
                lvxml.setValue("Last Refresh Time", buffer, status);
                lvxml.setValue("Refresh Frequency", m_crpt->update_poll_time, status);
                lvxml.setValue("N/P Ratio", m_crpt->update_npratio_current, status);
                lvxml.setValue("ISISCycle", m_crpt->isis_cycle, status);
                lvxml.setValue("LocalContact", m_crpt->local_contact, status);
                lvxml.setValue("EventModeCardFraction", m_crpt->eventModeCardFraction(), status);

                lvxml.saveToString(status_xml, status);
                return 0;
        }

// -1 on error or DWELL period, else DAQ period number
// if period < 0 return current daq period
        int ISISinstrumentControl::getDAQPeriod(int period, DAEstatus& status)
        {
                int daq_period;
                if (period < 0)
                {
                        getCurrentPeriodNumber(period, daq_period, status);
                        return daq_period;
                }
                if (period < 0 || period >= m_crpt->nper)
                {
                        return -1;
                }
                return m_crpt->period[period].daq_period;
        }

        // sum is total counts excluding channel 0
        int ISISinstrumentControl::getSpectrum(long spectrum_number, long period, double* time_array, double* signal_array, double* error_array,
                                        bool as_histogram, bool as_distribution, long& sum, DAEstatus& status)
        {
                unsigned long i;
                float tr_shift;
                ICPCritical cs(&m_crpt_cs);
//              m_dae->getNTimeChannels(&ntcdae, status);
                int ntc = m_crpt->spectrumNTC(spectrum_number);
                unsigned long* buffer = new unsigned long[ntc+1];
                int perspec = m_crpt->getNumSpectra(true); // number of spectra in a period
                sum = 0;
// allow for periods
                int daq_period = getDAQPeriod(period, status);
                if (daq_period >= 0)
                {
                        if (m_crpt->isEventSpectrum(spectrum_number))
                        {
                                memcpy(buffer, &(m_crpt.rawData()[ m_crpt.spectrumCRPTOffset(spectrum_number, daq_period) ]) ,(ntc+1)*sizeof(uint32_t));
                        }
                        else
                        {
                                m_dae->readDAE1Spectrum(spectrum_number + daq_period * perspec, buffer, ntc+1, status);
                        }
                }
                else
                {
                        memset(buffer, 0, (ntc+1) * sizeof(unsigned long)); // DWELL period; no data
                }
                int tr_index = m_crpt->spectrumCRPTTR(spectrum_number) - 1;
                tr_shift = m_crpt->tcr[tr_index][0].start - m_crpt->rtcb[tr_index][0];
                if (as_histogram)
                {
                        for(i=0; i<ntc+1; i++)
                        {
                                time_array[i] = m_crpt->rtcb[tr_index][i] + tr_shift;
                        }
                        for(i=0; i<ntc; i++)
                        {
                                if (as_distribution)
                                {
                                        signal_array[i] = (double)buffer[i+1] / (time_array[i+1] - time_array[i]);
                                        error_array[i] = sqrt((double)buffer[i+1]) / (time_array[i+1] - time_array[i]);
                                }
                                else
                                {
                                        signal_array[i] = (double)buffer[i+1];
                                        error_array[i] = sqrt((double)buffer[i+1]);
                                }
                                sum += buffer[i+1];
                        }
                }
                else
                {
                        for(i=0; i<ntc; i++)
                        {
                                time_array[i] = tr_shift + (m_crpt->rtcb[tr_index][i] + m_crpt->rtcb[tr_index][i+1]) / 2.0;
                                if (as_distribution)
                                {
                                        signal_array[i] = (double)buffer[i+1] / (m_crpt->rtcb[tr_index][i+1] - m_crpt->rtcb[tr_index][i]);
                                        error_array[i] = sqrt((double)buffer[i+1]) / (m_crpt->rtcb[tr_index][i+1] - m_crpt->rtcb[tr_index][i]);
                                }
                                else
                                {
                                        signal_array[i] = buffer[i+1];
                                        error_array[i] = sqrt((double)buffer[i+1]);
                                }
                                sum += buffer[i+1];
                        }
                }
                delete[] buffer;
                return 0;
        }

        int ISISinstrumentControl::getNumberOfTimeChannels(int spectrum, DAEstatus& status)
        {
//              isisU32_t ntc;
//              lockCRPT();
//              m_dae->getNTimeChannels(&ntc, status);
//              unlockCRPT();
//              return ntc;
                return m_crpt->spectrumNTC(spectrum);
        }

        // nsp1 i.e. excluding specytrum 0 
        int ISISinstrumentControl::getNumberOfSpectra(DAEstatus& status)
        {
                return m_crpt->getNumSpectra(false);
        }

        int ISISinstrumentControl::getNumberOfPeriods(DAEstatus& status)
        {
                return m_crpt->nper;
        }

        int ISISinstrumentControl::getSpectrumIntegral(long spec_no, long period, float t_low, float t_high, long& integral, long& max_val, DAEstatus& status)
        {
                return getSpectrumIntegral(1, &spec_no, period, &t_low, &t_high, &integral, &max_val, status);
        }

        int ISISinstrumentControl::getCRPTSpectrumIntegral(long spec_no, long period, float t_low, float t_high, long& integral, long& max_val, DAEstatus& status)
        {
                return getCRPTSpectrumIntegral(1, &spec_no, period, &t_low, &t_high, &integral, &max_val, status);
        }

        int ISISinstrumentControl::getCRPTSpectrumIntegral(long spec_start, int nspectra, long period, float t_low,
                                float t_high, long integral[], long max_val[], DAEstatus& status)
        {
                long j, k;
                for(long i=0; i < nspectra; ++i)
                {
                        j = i + spec_start;
                        getCRPTSpectrumIntegral(1, &j, period, &t_low, &t_high, integral + i, (max_val != NULL ? max_val + i : &k), status);
                }
                return status.result();
        }


        int ISISinstrumentControl::getCRPTSpectrumIntegral(long n, const long spec_no[], long period, const float t_low[],
                                const float t_high[], long integral[], long max_val[], DAEstatus& status)
        {
                bool full_range;
                int i, j, ntc, tr_index;
                ICPCritical cs(&m_crpt_cs);
// allow for periods
                int daq_period = getDAQPeriod(period, status);
                for(i=0; i<n; i++)
                {
                        tr_index = m_crpt->spectrumCRPTTR(spec_no[i]) - 1;
                        const float* rtcb = m_crpt->rtcb[tr_index];
                        ntc = m_crpt->ntc[tr_index];
                        integral[i] = 0;
                        max_val[i] = 0;
                        if (t_high[i] > t_low[i])
                        {
                                full_range = false;
                        }
                        else
                        {
                                full_range = true;
                        }
                        if (daq_period >= 0)
                        {
                                const isisU32_t* raw_base = m_crpt.rawData() + m_crpt.spectrumCRPTOffset(spec_no[i], daq_period);
                                for(j=0; j<ntc; j++)
                                {
                                        float contrib = 0.0;
                                        float width = rtcb[j+1] - rtcb[j];
                                        if (full_range)
                                        {
                                                contrib = 1.0;
                                        }
                                        else if ( (rtcb[j] >= t_low[i]) && (rtcb[j+1] <= t_high[i]) )
                                        {
                                                contrib = 1.0;
                                        }
                                        else if ( (rtcb[j] < t_low[i]) && (rtcb[j+1] >= t_low[i]) && (rtcb[j+1] <= t_high[i]) ) 
                                        {
                                                contrib = (rtcb[j+1] - t_low[i]) / width;
                                        }
                                        else if ( (rtcb[j] >= t_low[i]) && (rtcb[j] <= t_high[i]) && (rtcb[j+1] > t_high[i]) ) 
                                        {
                                                contrib = (t_high[i] - rtcb[j]) / width;
                                        }
                                        else if ( (rtcb[j] < t_low[i]) && (rtcb[j+1] > t_high[i]) )
                                        {
                                                contrib = (t_high[i] - t_low[i]) / width;
                                        }
                                        if (contrib > 0.0)
                                        {
                                                integral[i] += ( contrib == 1.0 ? raw_base[j+1] : (int)floor(0.5 + contrib * raw_base[j+1]) );
                                                if (raw_base[j+1] > max_val[i])
                                                {
                                                        max_val[i] = raw_base[j+1];
                                                }
                                        }
                                }
                        }
                }
                return status.result();
        }

        int ISISinstrumentControl::getCRPTSpectrumIntegral(long spec_start, int nspectra, long period, long integral[], DAEstatus& status)
        {
                int i, j, spec_no;
                unsigned long* buffer; 
                ICPCritical cs(&m_crpt_cs);
                int perspec = m_crpt->getNumSpectra(true);
// allow for periods
                int daq_period = getDAQPeriod(period, status);
                const isisU32_t* spec_integrals = m_crpt.spectrumIntegrals();
                for(i=0; i<nspectra; i++)
                {
                        integral[i] = 0;
                        spec_no = spec_start + i;
                        if (daq_period >= 0)
                        {
                                if (m_crpt->isEventSpectrum(spec_no))
                                {
                                        integral[i] = spec_integrals[spec_no];
                                }
                        }
                }
                return status.result();
        }

        int ISISinstrumentControl::getSpectrumIntegral(long n, const long spec_no[], long period, const float t_low[],
                                const float t_high[], long integral[], long max_val[], DAEstatus& status)
        {
                bool full_range;
                int i, j, ntc, tr_index;
                unsigned long* buffer; 
                ICPCritical cs(&m_crpt_cs);
                int perspec = m_crpt->getNumSpectra(true);
// allow for periods
                int daq_period = getDAQPeriod(period, status);
                for(i=0; i<n; i++)
                {
                        tr_index = m_crpt->spectrumCRPTTR(spec_no[i]) - 1;
                        const float* rtcb = m_crpt->rtcb[tr_index];
                        ntc = m_crpt->ntc[tr_index];
                        buffer = new unsigned long[ntc+1];
                        integral[i] = 0;
                        max_val[i] = 0;
                        if (t_high[i] > t_low[i])
                        {
                                full_range = false;
                        }
                        else
                        {
                                full_range = true;
                        }
                        if (daq_period >= 0)
                        {
                                if (m_crpt->isEventSpectrum(spec_no[i]))
                                {
                                        memcpy(buffer, &(m_crpt.rawData()[ m_crpt.spectrumCRPTOffset(spec_no[i], daq_period) ]) ,(ntc+1)*sizeof(uint32_t));
                                }
                                else
                                {
                                        m_dae->readDAE1Spectrum(spec_no[i] + daq_period * perspec, buffer, ntc+1, status);
                                }
                                for(j=0; j<ntc; j++)
                                {
                                        if ( full_range || ((rtcb[j] >= t_low[i]) && (rtcb[j+1] <= t_high[i])) )
                                        {
                                                integral[i] += buffer[j+1];
                                                if (buffer[j+1] > max_val[i])
                                                {
                                                        max_val[i] = buffer[j+1];
                                                }
                                        }
                                }
                        }
                        delete[] buffer;
                }
                return status.result();
        }

// given a monitor number rather than a spectrum
        int ISISinstrumentControl::getMonitorIntegral(long monitor, long period, float t_low, float t_high, long& integral, DAEstatus& status)
        {
                long i, max_val;
                integral = 0;
                if ((monitor > 0) && (monitor <= m_crpt->nmon))
                {
                        i = m_crpt->mdet[monitor-1] - 1; // mdet starts at 1 for historical reasons
                        if (i >=0 && i < m_crpt->ndet)
                        {
                                return getSpectrumIntegral(m_crpt->spec[i], period, t_low, t_high, integral, max_val, status);
                        }
                }
                else
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Invalid monitor number %d", monitor);
                }
                return status.result();
        }

        int ISISinstrumentControl::getMonitorIntegral(long n, const long monitor[], long period, const float t_low[], const float t_high[], long integral[], DAEstatus& status)
        {
                long i;
                for(i=0; i<n; i++)
                {
                        getMonitorIntegral(monitor[i], period, t_low[i], t_high[i], integral[i], status);
                }
                return 0;
        }


int ISISinstrumentControl::getUpdateSettingsXML(const std::string& update_xml_in, std::string& update_xml_out, DAEstatus& status)
{
                ICPCritical cs(&m_crpt_cs);
                LabviewXML lvxml(status);
                lvxml.loadFromString(update_xml_in.c_str(), status);
                if (m_crpt->lvxml_update[0] != '\0')
                {
                        lvxml.updateFromString(m_crpt->lvxml_update, status);
                }

                lvxml.setValue("Frequency", m_crpt->auto_save_value, status);
                lvxml.setValue("Units", m_crpt->auto_save_type, status);
                lvxml.setValue("Dashboard Update Interval", m_crpt->update_poll_time, status); 

                lvxml.saveToString(update_xml_out, status);
                return status.result();
}

int ISISinstrumentControl::changeUpdateSettingsXML(const std::string& update_xml, DAEstatus& status)
{
        if (!m_crpt.isValid())
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "CRPT is NULL");
                return status.result();
        }
        LabviewXML lvxml(status);
        if ((update_xml.size() == 0) || (lvxml.loadFromString(update_xml.c_str(), status) != 0))
        {
                status.addWarning(FAC_CRPT, "UPDATE XML invalid - ignored");
                return status.result();
        }
        ICPCritical cs(&m_crpt_cs);
        strncpy(m_crpt->lvxml_update, update_xml.c_str(), sizeof(m_crpt->lvxml_update));
        NULL_TERMINATE(m_crpt->lvxml_update);
        m_recovery_map["update"] = update_xml;
                
        lvxml.getValue("Frequency", m_crpt->auto_save_value, status);
        lvxml.getValue("Units", m_crpt->auto_save_type, status);
        lvxml.getValue("Dashboard Update Interval", m_crpt->update_poll_time, status); 
                
        return status.result();
}

int ISISinstrumentControl::getTCBXML(const std::string& tcb_xml_in, std::string& tcb_xml_out, DAEstatus& status)
{
                ICPCritical cs(&m_crpt_cs);
                LabviewXML lvxml(status);
                lvxml.loadFromString(tcb_xml_in.c_str(), status);
                if (m_crpt->lvxml_tcb[0] != '\0')
                {
                        lvxml.updateFromString(m_crpt->lvxml_tcb, status);
                }
                char buffer[256];
                int i, j;
                if (LV_NUM_TIME_REGIMES > ISISCRPT_MAX_NTRG)
                {
                        status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Too many time regimes");
                        return status.result();
                }
                if (m_crpt->tcr[0][0].mode == TCBRANGE_FILE)
                {
                        lvxml.setValue("Time Channel File", m_crpt->tcr[0][0].tcb_file.fname, status);
                        lvxml.setValue("Calculation Method", 1, status);
                }
                else
                {
                        lvxml.setValue("Calculation Method", 0, status);
                        for(j=0; j<LV_NUM_TIME_REGIMES; j++)
                        {
                                for(i=0; i<5; i++)
                                {
                                        TCBRANGE& tcr = m_crpt->tcr[j][i];
                                        sprintf(buffer, "TR%d From %d", j+1, i+1);
                                        lvxml.setValue(buffer, tcr.start, status);
                                        sprintf(buffer, "TR%d To %d", j+1, i+1);
                                        lvxml.setValue(buffer, tcr.end, status);
                                        sprintf(buffer, "TR%d In Mode %d", j+1, i+1);
                                        lvxml.setValue(buffer, tcr.mode, status);
                                        sprintf(buffer, "TR%d Steps %d", j+1, i+1);
                                        lvxml.setValue(buffer, tcr.tcpar[0], status);
                                }
                        }
                }

                lvxml.saveToString(tcb_xml_out, status);
                return status.result();
}


        int ISISinstrumentControl::updateTCBXML(const std::string& tcb_xml, DAEstatus& status)
        {
                int i, j;
                md5checksum_t csum;
                md5sumString((const unsigned char*)tcb_xml.c_str(), tcb_xml.length(), csum, status);
                if (m_crpt->run_status != RUNSTATUS_SETUP)
                {
                        if (compareChecksums(m_crpt->tcb_xml_checksum, csum))
                        {
                                status.addInfo(FAC_CRPT, "TCB not updated (as RUNNING)");
                        }
                        else
                        {
                                status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Can only change TCB in SETUP state");
                        }       
                        return status.result();
                }
                if (LV_NUM_TIME_REGIMES > ISISCRPT_MAX_NTRG)
                {
                        status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Too many time regimes");
                        return status.result();
                }
                char buffer[256];
                LabviewXML lvxml(status);
                if ((tcb_xml.size() == 0) || (lvxml.loadFromString(tcb_xml.c_str(), status) != 0))
                {
                        status.addWarning(FAC_CRPT, "TCB XML invalid - ignored");
                        return status.result();
                }
                ICPCritical cs(&m_crpt_cs);
                updateChecksum(m_crpt->tcb_xml_checksum, csum);
                strncpy(m_crpt->lvxml_tcb, tcb_xml.c_str(), sizeof(m_crpt->lvxml_tcb));
                NULL_TERMINATE(m_crpt->lvxml_tcb);
                lvxml.getValue("Calculation Method", i, status);
                if (i == 0)
                {
                        m_crpt->ntrg = 0;
                        for(j=0; j<LV_NUM_TIME_REGIMES; j++)
                        {
                                m_crpt->ntcr[j] = 0;
                                for(i=0; i<5; i++)
                                {
                                        TCBRANGE& tcr = m_crpt->tcr[j][i];
                                        sprintf(buffer, "TR%d From %d", j+1, i+1);
                                        lvxml.getValue(buffer, tcr.start, status);
                                        sprintf(buffer, "TR%d To %d", j+1, i+1);
                                        lvxml.getValue(buffer, tcr.end, status);
                                        sprintf(buffer, "TR%d In Mode %d", j+1, i+1);
                                        lvxml.getValue(buffer, tcr.mode, status);
                                        sprintf(buffer, "TR%d Steps %d", j+1, i+1);
                                        lvxml.getValue(buffer, tcr.tcpar[0], status);
                                        tcr.npar = 1;
                                        // is it a valid range
                                        if ( (tcr.start < tcr.end) && (tcr.tcpar[0] > 0.0) )
                                        {
                                                (m_crpt->ntcr[j])++;
                                                m_crpt->ntrg = j + 1;
                                        }
                                }
                        }
                }
                else
                {
                        m_crpt->ntrg = 1;
                        m_crpt->ntcr[0] = 1;
                        m_crpt->tcr[0][0].mode = TCBRANGE_FILE;
                        lvxml.getValue("Time Channel File", m_crpt->tcr[0][0].tcb_file.fname, sizeof(m_crpt->tcr[0][0].tcb_file.fname), true, status);
                }
                tcbcalc(status);
                return status.result();
        }

        int ISISinstrumentControl::updateUserXML(const std::string& user_xml, DAEstatus& status)
        {
                ICPCritical cs(&m_crpt_cs);
                LabviewXML lvxml(status);
                m_recovery_map["user"] = user_xml;
                lvxml.loadFromString(user_xml.c_str(), status);
                
                lvxml.getValue("ISIS User Number", m_crpt->user_id, sizeof(m_crpt->user_id), true, status); 
                lvxml.getValue("User Name", m_crpt->user_name, sizeof(m_crpt->user_name), true, status);
                lvxml.getValue("Institute", m_crpt->institute, sizeof(m_crpt->institute), true, status);
                lvxml.getValue("Telephone", m_crpt->user_telephone, sizeof(m_crpt->user_telephone), true, status);
                lvxml.getValue("Email Address", m_crpt->user_email, sizeof(m_crpt->user_email), true, status);
                lvxml.getValue("RB (proposal) Number", m_crpt->rb_number, status);

                NULL_TERMINATE(m_crpt->user_name);
                NULL_TERMINATE(m_crpt->institute);

                return status.result();
        }

int ISISinstrumentControl::getHardwarePeriodsXML(const std::string& periods_xml_in, std::string& periods_xml_out, DAEstatus& status)
{
                int i;
                char name[64];
                ICPCritical cs(&m_crpt_cs);
                LabviewXML lvxml(status);
                lvxml.loadFromString(periods_xml_in.c_str(), status);
                if (m_crpt->lvxml_periods[0] != '\0')
                {
                        lvxml.updateFromString(m_crpt->lvxml_periods, status);
                }
                lvxml.setValue("Period Setup Source", m_crpt->period_source, status);
                lvxml.setValue("Period File", m_crpt->period_file, status);
                lvxml.setValue("Period Type", m_crpt->period_type, status);
                if (m_crpt->period_type == ISISDAE::PeriodTypeSoftware)
                {
                        lvxml.setValue("Number Of Software Periods", m_crpt->nper, status);
                }
                else
                {
                        lvxml.setValue("Number Of Software Periods", 1, status);
                        if (m_crpt->period_source == PeriodSetupSource::PeriodSourceLabview)
                        {
                                for(i=0; i<8; i++)
                                {
                                        sprintf(name, "Type %d", i+1);
                                        lvxml.setValue(name, m_crpt->period[i].type, status);
                                        sprintf(name, "Frames %d", i+1);
                                        lvxml.setValue(name, m_crpt->period[i].requested_frames, status);
                                        sprintf(name, "Output %d", i+1);
                                        lvxml.setValue(name, m_crpt->period[i].output, status);
                                        sprintf(name, "Label %d", i+1);
                                        lvxml.setValue(name, m_crpt->period[i].label, status);
                                }
                        }
                }
                lvxml.setValue("Output Delay (us)", m_crpt->period_output_delay, status);
                lvxml.setValue("Hardware Period Sequences", m_crpt->nperseq_request, status);
                lvxml.saveToString(periods_xml_out, status);
                return status.result();
}

int ISISinstrumentControl::updateHardwarePeriodsXML(const std::string& periods_xml, DAEstatus& status)
        {
                char name[64];
                int i, daq_period, nperiod;
                if (m_crpt->run_status != RUNSTATUS_SETUP)
                {
                        status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Can only change Periods configuration in SETUP state");
                        return status.result();
                }
                LabviewXML lvxml(status);
                if ((periods_xml.size() == 0) || (lvxml.loadFromString(periods_xml.c_str(), status) != 0))
                {
                        status.addWarning(FAC_CRPT, "PERIODS XML invalid - ignored");
                        return status.result();
                }
                ICPCritical cs(&m_crpt_cs);
                strncpy(m_crpt->lvxml_periods, periods_xml.c_str(), sizeof(m_crpt->lvxml_periods));
                NULL_TERMINATE(m_crpt->lvxml_periods);

                lvxml.getValue("Period Setup Source", m_crpt->period_source, status);
                lvxml.getValue("Period File", m_crpt->period_file, sizeof(m_crpt->period_file), true, status);

                lvxml.getValue("Period Type", m_crpt->period_type, status);
                lvxml.getValue("Output Delay (us)", m_crpt->period_output_delay, status);
                lvxml.getValue("Hardware Period Sequences", m_crpt->nperseq_request, status);

                if (m_crpt->period_type == ISISDAE::PeriodTypeSoftware)
                {
                        lvxml.getValue("Number Of Software Periods", nperiod, status);
                        changeNumberOfSoftwarePeriods(nperiod, status);
                        status.addInfo(FAC_CRPT, "Hardware period table ignored as using software periods");
                        return status.result();
                }
                daq_period = 0;
                int ndwell = 0;
                if (m_crpt->period_source == PeriodSetupSource::PeriodSourceFile)
                {
                        FILE* periods_info = _fsopen(m_crpt->period_file, "rtN", _SH_DENYNO);
                        if (periods_info == NULL)
                        {
                                status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Unable to read periods file %s", m_crpt->period_file); 
                                return status.result();
                        }
                        for(i=0; (i < ISISCRPT_MAX_PERIOD) && 
                                                (fscanf(periods_info, "%s %d %d %s", name, &(m_crpt->period[i].requested_frames), &(m_crpt->period[i].output), m_crpt->period[i].label) == 4); i++)
                        {
                                NULL_TERMINATE(name);
                                if (!stricmp(name, "DAQ"))
                                {
                                        m_crpt->period[i].daq_period = daq_period++;
                                }
                                else if (!stricmp(name, "DWELL"))
                                {
                                        m_crpt->period[i].daq_period = -1;
                                        ndwell++;
                                }
                                else
                                {
                                        m_crpt->period[i].daq_period = -1; // unused or unknown
                                }
                        }
                        fclose(periods_info);
                }
                else
                {
                        for(i=0; i<8; i++)
                        {
                                sprintf(name, "Type %d", i+1);
                                lvxml.getValue(name, m_crpt->period[i].type, status);
                                sprintf(name, "Frames %d", i+1);
                                lvxml.getValue(name, m_crpt->period[i].requested_frames, status);
                                sprintf(name, "Output %d", i+1);
                                lvxml.getValue(name, m_crpt->period[i].output, status);
                                sprintf(name, "Label %d", i+1);
                                lvxml.getValue(name, m_crpt->period[i].label, sizeof(m_crpt->period[i].label), true, status);
                                switch(m_crpt->period[i].type)
                                {
                                        case 0:  // usused
                                                m_crpt->period[i].daq_period = -1;
                                                break;
                                        case 1:  // DAQ
                                                m_crpt->period[i].daq_period = daq_period++;
                                                break;
                                        case 2:  // DWELL
                                                m_crpt->period[i].daq_period = -1;
                                                ndwell++;
                                                break;
                                        default:
                                                status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                                                        "invalid period type");
                                                break;
                                }
                        }
                }
                if (daq_period + ndwell > ISISCRPT_MAX_PERIOD)
                {
                        status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "invalid number of hardware periods %d", daq_period + ndwell);
                        return DAEstatus::Failure;
                }
                if (daq_period <= 0)
                {
                        status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "invalid number of daq hardware periods %d", daq_period);
                        return DAEstatus::Failure;
                }
                m_crpt->nper = daq_period + ndwell;
                status.addInfoVa(FAC_CRPT, "Programmed %d periods (%d DAQ, %d DWELL) for %d sequences from %s", 
                                                        m_crpt->nper, daq_period, ndwell, m_crpt->nperseq_request,
                                                        ((m_crpt->period_source == PeriodSetupSource::PeriodSourceFile) ? m_crpt->period_file : "labview") 
                                                 );
                m_crpt->nper_daq = daq_period;
                return status.result();
        }


        int ISISinstrumentControl::updateSampleXML(const std::string& sample_xml, DAEstatus& status)
        {
//              if (m_crpt->run_status != RUNSTATUS_SETUP)
//              {
//                      status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Can only change DAE in SETUP state");
//                      return status.result();
//              }
                ICPCritical cs(&m_crpt_cs);
                LabviewXML lvxml(status);
                m_recovery_map["sample"] = sample_xml;
                lvxml.loadFromString(sample_xml.c_str(), status);

                lvxml.getValue("SampleName", m_crpt->sample_name, sizeof(m_crpt->sample_name), true, status);
                lvxml.getValue("SampleOrientation", m_crpt->sample_orientation, sizeof(m_crpt->sample_orientation), true, status);
                lvxml.getValue("FieldLabel", m_crpt->field_label, sizeof(m_crpt->field_label), true, status);
                lvxml.getValue("TemperatureLabel", m_crpt->temperature_label, sizeof(m_crpt->temperature_label), true, status);
                lvxml.getValue("Comments", m_crpt->comment, sizeof(m_crpt->comment), true, status);
                lvxml.getValue("InstrumentGeometry", m_crpt->instrument_geometry, sizeof(m_crpt->instrument_geometry), true, status);
                _snprintf(m_crpt->long_title, sizeof(m_crpt->long_title), "%s T=%s F=%s", m_crpt->sample_name, m_crpt->temperature_label, m_crpt->field_label);
                NULL_TERMINATE(m_crpt->long_title);
                return status.result();
        }

int ISISinstrumentControl::getDAEsettingsXML(const std::string& dae_xml_in, std::string& dae_xml_out, DAEstatus& status)
{
                ICPCritical cs(&m_crpt_cs);
                LabviewXML lvxml(status);
                lvxml.loadFromString(dae_xml_in.c_str(), status);
                if (m_crpt->lvxml_dae[0] != '\0')
                {
                        lvxml.updateFromString(m_crpt->lvxml_dae, status);
                }

                lvxml.setValue("DAETimingSource", m_crpt->tcb_sync, status);

                lvxml.setValue("Monitor Spectrum", m_crpt->monitor_spectrum, status);
                lvxml.setValue("from", m_crpt->monitor_range[0][0], status);
                lvxml.setValue("to", m_crpt->monitor_range[0][1], status);
                lvxml.setValue("SMP (Chopper) Veto", m_crpt->vetos[SMPVeto].enabled, status);
                lvxml.setValue("Veto 0", m_crpt->vetos[Ext0Veto].enabled, status);
                lvxml.setValue("Veto 1", m_crpt->vetos[Ext1Veto].enabled, status);
                lvxml.setValue("Veto 2", m_crpt->vetos[Ext2Veto].enabled, status);
                lvxml.setValue("Veto 3", m_crpt->vetos[Ext3Veto].enabled, status);
                lvxml.setValue("Wiring Table", m_crpt->wiring_table.fname, status);
                lvxml.setValue("Detector Table", m_crpt->detector_table.fname, status);
                lvxml.setValue("Spectra Table", m_crpt->spectra_table.fname, status);

                lvxml.setValue("Muon Cerenkov Pulse", m_crpt->muon_cerenkov_pulse, status);
                lvxml.setValue("Fermi Chopper Veto", m_crpt->vetos[FermiChopperVeto0].enabled, status);
                double fcdelay, fcwidth; // these are read in us
                fcdelay = m_crpt->fermi_chopper_delay[0] / 50.0; // convert from 20 ns bins
                fcwidth = m_crpt->fermi_chopper_width[0] / 50.0;
                lvxml.setValue("FC Delay", fcdelay, status);
                lvxml.setValue("FC Width", fcwidth, status);

                lvxml.setValue("TS2 Pulse Veto", m_crpt->vetos[TS2PulseVeto].enabled, status);
                lvxml.setValue("ISIS 50Hz Veto", m_crpt->vetos[ISIS50HzVeto].enabled, status);

                lvxml.saveToString(dae_xml_out, status);
                return status.result();
}

        int ISISinstrumentControl::updateDAEsettingsXML(const std::string& dae_xml, DAEstatus& status)
        {
                md5checksum_t csum;
                md5sumString((const unsigned char*)dae_xml.c_str(), dae_xml.length(), csum, status);
                if (m_crpt->run_status != RUNSTATUS_SETUP)
                {
                        if (compareChecksums(m_crpt->dae_xml_checksum, csum))
                        {
                                status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Can only change DAE in SETUP state");
//                              status.addInfo(FAC_CRPT, "DAE info not updated (as RUNNING)");
                        }
                        else
                        {
                                status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Can only change DAE in SETUP state");
                        }       
                        return status.result();
                }
                LabviewXML lvxml(status);
                if ((dae_xml.size() == 0) || (lvxml.loadFromString(dae_xml.c_str(), status) != 0))
                {
                        status.addWarning(FAC_CRPT, "DAE XML invalid - ignored");
                        return status.result();
                }
                std::string wiring_table, detector_table, spectra_table;  
                ICPCritical cs(&m_crpt_cs);
                strncpy(m_crpt->lvxml_dae, dae_xml.c_str(), sizeof(m_crpt->lvxml_dae));
                NULL_TERMINATE(m_crpt->lvxml_dae);
                updateChecksum(m_crpt->dae_xml_checksum, csum);

                int tcb_sync;
                lvxml.getValue("DAETimingSource", tcb_sync, status);
                m_crpt->tcb_sync = (FrameSync)tcb_sync;

                lvxml.getValue("Monitor Spectrum", m_crpt->monitor_spectrum, status);
                lvxml.getValue("from", m_crpt->monitor_range[0][0], status);
                lvxml.getValue("to", m_crpt->monitor_range[0][1], status);
                lvxml.getValue("SMP (Chopper) Veto", m_crpt->vetos[SMPVeto].enabled, status);
                lvxml.getValue("Veto 0", m_crpt->vetos[Ext0Veto].enabled, status);
                lvxml.getValue("Veto 1", m_crpt->vetos[Ext1Veto].enabled, status);
                lvxml.getValue("Veto 2", m_crpt->vetos[Ext2Veto].enabled, status);
                lvxml.getValue("Veto 3", m_crpt->vetos[Ext3Veto].enabled, status);
                lvxml.getValue("Wiring Table", wiring_table, status);
                lvxml.getValue("Detector Table", detector_table, status);
                lvxml.getValue("Spectra Table", spectra_table, status);

                lvxml.getValue("Muon Cerenkov Pulse", m_crpt->muon_cerenkov_pulse, status);
                lvxml.getValue("Fermi Chopper Veto", m_crpt->vetos[FermiChopperVeto0].enabled, status);
                double fcdelay, fcwidth; // these are read in us
                lvxml.getValue("FC Delay", fcdelay, status);
                lvxml.getValue("FC Width", fcwidth, status);
                m_crpt->fermi_chopper_delay[0] = (int)(fcdelay * 50.0 + 0.5); // convert to 20 ns bins
                m_crpt->fermi_chopper_width[0] = (int)(fcwidth * 50.0 + 0.5);

                lvxml.getValue("TS2 Pulse Veto", m_crpt->vetos[TS2PulseVeto].enabled, status);
                lvxml.getValue("ISIS 50Hz Veto", m_crpt->vetos[ISIS50HzVeto].enabled, status);

                readTables(wiring_table.c_str(), detector_table.c_str(), spectra_table.c_str(), status);

                m_crpt->markInitialised();

                return status.result();
        }

int ISISinstrumentControl::getMonitoringXML(const std::string& monitor_xml_in, std::string& monitor_xml_out, DAEstatus& status)
{
                ICPCritical cs(&m_crpt_cs);
                LabviewXML lvxml(status);
                char buffer[64];
                lvxml.loadFromString(monitor_xml_in.c_str(), status);
                if (m_crpt->lvxml_monitoring[0] != '\0')
                {
                        lvxml.updateFromString(m_crpt->lvxml_monitoring, status);
                }

                lvxml.setValue("Lower Limit", m_crpt->monitoring.valid_low, status);
                lvxml.setValue("Higher Limit", m_crpt->monitoring.valid_high, status);
                lvxml.setValue("Calculation Frequency", m_crpt->monitoring.calc_freq, status);
                lvxml.setValue("File Logging Frequency", m_crpt->monitoring.log_freq, status);
                lvxml.setValue("Enable Monitoring", m_crpt->monitoring.enabled, status);
                lvxml.setValue("Enable Alerts", m_crpt->monitoring.alerts, status);
                lvxml.setValue("Out of range action", m_crpt->monitoring.action, status);
                lvxml.setValue("Specified Period", m_crpt->monitoring.action_period, status);
                lvxml.setValue("Expression", m_crpt->monitoring.expression, status);
                lvxml.setValue("Load Table From File", m_crpt->monitoring.file, status);
                std::vector<std::string> table;
                for(int i=0; i<m_crpt->monitoring.n; i++) // table has 3 columns
                {
                        sprintf(buffer, "%d", m_crpt->monitoring.v[i].spectrum);
                        table.push_back(buffer);
                        sprintf(buffer, "%f", m_crpt->monitoring.v[i].t_low);
                        table.push_back(buffer);
                        sprintf(buffer, "%f", m_crpt->monitoring.v[i].t_high);
                        table.push_back(buffer);
                }
                lvxml.setValue("Table", table, status);

                lvxml.saveToString(monitor_xml_out, status);
                return status.result();
}

int ISISinstrumentControl::updateMonitoringXML(const std::string& monitor_xml, DAEstatus& status)
{
                int i;
                if (m_crpt->run_status != RUNSTATUS_SETUP)
                {
                        status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Can only change monitoring configuration in SETUP state");
                        return status.result();
                }
                LabviewXML lvxml(status);
                if ((monitor_xml.size() == 0) || (lvxml.loadFromString(monitor_xml.c_str(), status) != 0))
                {
                        status.addWarning(FAC_CRPT, "Monitoring XML invalid - ignored");
                        return status.result();
                }
                ICPCritical cs(&m_crpt_cs);
                strncpy(m_crpt->lvxml_monitoring, monitor_xml.c_str(), sizeof(m_crpt->lvxml_monitoring));
                NULL_TERMINATE(m_crpt->lvxml_monitoring);
                lvxml.getValue("Lower Limit", m_crpt->monitoring.valid_low, status);
                lvxml.getValue("Higher Limit", m_crpt->monitoring.valid_high, status);
                lvxml.getValue("Calculation Frequency", m_crpt->monitoring.calc_freq, status);
                lvxml.getValue("File Logging Frequency", m_crpt->monitoring.log_freq, status);
                lvxml.getValue("Enable Monitoring", m_crpt->monitoring.enabled, status);
                lvxml.getValue("Enable Alerts", m_crpt->monitoring.alerts, status);
                lvxml.getValue("Out of range action", m_crpt->monitoring.action, status);
                lvxml.getValue("Specified Period", m_crpt->monitoring.action_period, status);
                lvxml.getValue("Expression", m_crpt->monitoring.expression, sizeof(m_crpt->monitoring.expression), true, status);
                lvxml.getValue("Load Table From File", m_crpt->monitoring.file, sizeof(m_crpt->monitoring.file), true, status);
#define R_OK 4
                if (access(m_crpt->monitoring.file, R_OK) == 0)
                {
                        std::fstream fs; // file has 3 columns
                        fs.open(m_crpt->monitoring.file, std::ios::in);
                        for(i=0; fs.good() && i < MAX_MONITORING_PAR; i++)
                        {
                                ISISCRPT_STRUCT::Monitoring::par_type& v = m_crpt->monitoring.v;
                                fs >> v[i].spectrum >> v[i].t_low >> v[i].t_high;
                        }
                        m_crpt->monitoring.n = i;
                        status.addInfoVa(FAC_DAE, "Loaded %d monitoring parameters from file %s", m_crpt->monitoring.n, m_crpt->monitoring.file);
                }
                else
                {
                        std::vector<std::string> table;
                        m_crpt->monitoring.file[0] = '\0';
                        lvxml.getValue("Table", table, status);
                        m_crpt->monitoring.n = std::min<int>(MAX_MONITORING_PAR, table.size() / 3);
                        for(i=0; i<m_crpt->monitoring.n; i++)  // table has 3 columns
                        {
                                ISISCRPT_STRUCT::Monitoring::par_type& v = m_crpt->monitoring.v;
                                v[i].spectrum = atoi(table[i*3 + 0].c_str());
                                v[i].t_low = atof(table[i*3 + 1].c_str());
                                v[i].t_high = atof(table[i*3 + 2].c_str());
                        }
                        status.addInfoVa(FAC_DAE, "Loaded %d monitoring parameters from table", m_crpt->monitoring.n);
                }
        
        return status.result();
}

int ISISinstrumentControl::getTotalCounts(int64_t& counts, DAEstatus& status)
{
        int64_t value;
        ICPCritical cs(&m_crpt_cs);
        m_dae->getTotalCounts(&value, status);
        counts = value;         // in millions
        return status.result();
}

int ISISinstrumentControl::getMEvents(double& mevents, DAEstatus& status)
{
        int64_t counts;
        getTotalCounts(counts, status);
        mevents = (double)counts / 1.0e6;
        return status.result();
}

int ISISinstrumentControl::getMEventsPeriod(double& mevents, int period, DAEstatus& status)
{
        long counts = 0, integral, max_val;
        for(int i=1; i <= m_crpt->getHighestSpectrumNumber(); ++i)
        {
                getSpectrumIntegral(i, period, 0.0, -1.0, integral, max_val, status);
                counts += integral;
        }
        mevents = (double)counts / 1.0e6;
        return status.result();
}

int ISISinstrumentControl::sumAllSpectra(long& counts, long& bin0_counts, DAEstatus& status)
{
        int len = m_crpt->getPeriodSize() * m_crpt->nper_daq;
        int i;
    updateCRPTWithDAE(false, status);
        counts = 0;
        for(i=0; i<len; i++)
        {
                counts += m_crpt.rawData()[i];
        }
        bin0_counts = 0;
        for(int spec=0; spec <= m_crpt->getHighestSpectrumNumber(); ++spec)
        {
                for(int per=0; per < m_crpt->nper_daq; ++per)
                {
                        uint32_t offset = m_crpt.spectrumCRPTOffset(spec, per);
                        bin0_counts += m_crpt.rawData()[offset];
                }
        }
        return status.result();
}

int ISISinstrumentControl::sumAllHistogramMemory(long& counts, DAEstatus& status)
{
        ICPCritical cs(&m_crpt_cs);
        counts = m_dae->sumAllHistogramMemory(status);
        return status.result();
}

float ISISinstrumentControl::getCountRate(DAEstatus& status)
{
        return m_crpt->count_rate;
}

int ISISinstrumentControl::debugReportFunction(const DAEstatus_message& mess, void* arg)
{
        std::stringstream f;
        debug_report_arg_t* params = (debug_report_arg_t*)arg;
        mess.print(f, true, true); // printing mess to ostream adds time
        f << "\r\n";   
        appendToFileAsync(params->filename.c_str(), f.str().c_str());
        return DAEstatus::Success;
}

int ISISinstrumentControl::sqliteReportFunction(const DAEstatus_message& mess, void* arg)
{
        char time_buffer[128];
        debug_report_arg_t* params = (debug_report_arg_t*)arg;
        ISOtime(time(NULL), time_buffer, sizeof(time_buffer));
        se_log_value_async(params->run_number, "ISISICP", time_buffer, "ICPDEBUG", mess.str().c_str());
        return DAEstatus::Success;
}

std::ostream& ISISinstrumentControl::printStatus(std::ostream& os, DAEstatus& status)
{
        os << "ICP status\n";
        m_dae->printStatus(os, status);
        return os;
}

int ISISinstrumentControl::VMEWriteValue(unsigned long card_id, unsigned long card_address, bool sixteen_bit, unsigned long value, unsigned long mode, DAEstatus& status)
{
        int stat;
        ICPCritical cs(&m_crpt_cs);
        if (m_dae_type == ISISDAE::NeutronDAE3 || m_dae_type == ISISDAE::MuonDAE3)
        {
                stat = m_dae->VMEWriteValue<DAE3CardPolicy>(card_id, card_address, sixteen_bit, value, mode, status);
        }
        else
        {
                stat = m_dae->VMEWriteValue<DAE2CardPolicy>(card_id, card_address, sixteen_bit, value, mode, status);
        }
        return stat;
}

int ISISinstrumentControl::VMEReadValuesToString(unsigned long card_id, unsigned long card_address, bool sixteen_bit, unsigned long num_values, std::string& values, DAEstatus& status)
{
        int i, stat = DAEstatus::Failure;
        std::ostringstream oss;
        ICPCritical cs(&m_crpt_cs);
        isisU32_t* data = new isisU32_t[num_values];
        for(i=0; i<num_values; i++)
        {
                stat = VMEReadValue(card_id, card_address + 4*i, sixteen_bit, &(data[i]), status);
                oss << Poco::format("0x%08lx = 0x%08lx\n", static_cast<unsigned long>(card_address + 4*i), static_cast<unsigned long>(data[i]));
        }
        values = oss.str();
        delete[] data;
        return stat;
}

int ISISinstrumentControl::VMEReadValue(unsigned long card_id, unsigned long card_address, bool sixteen_bit, unsigned long* value, DAEstatus& status)
{
        int stat;
        ICPCritical cs(&m_crpt_cs);
        if (m_dae_type == ISISDAE::NeutronDAE3 || m_dae_type == ISISDAE::MuonDAE3)
        {
                stat = m_dae->VMEReadValue<DAE3CardPolicy>(card_id, card_address, sixteen_bit, value, status);
        }
        else
        {
                stat = m_dae->VMEReadValue<DAE2CardPolicy>(card_id, card_address, sixteen_bit, value, status);
        }
        return stat;
}

int ISISinstrumentControl::VMEWriteArray(unsigned long card_id, unsigned long card_address, isisU32_t* values, unsigned long num_values, DAEstatus& status)
{
        int stat;
        ICPCritical cs(&m_crpt_cs);
        ICPTimer icp_timer;
        if (m_dae_type == ISISDAE::NeutronDAE3 || m_dae_type == ISISDAE::MuonDAE3)
        {
                stat = m_dae->VMEWriteArray<DAE3CardPolicy>(card_id, card_address, values, num_values, status);
        }
        else
        {
                stat = m_dae->VMEWriteArray<DAE2CardPolicy>(card_id, card_address, values, num_values, status);
        }
        icp_timer.info("VMEWriteArray", status);
        return stat;
}

int ISISinstrumentControl::VMEReadArray(unsigned long card_id, unsigned long card_address, isisU32_t* values, unsigned long num_values, DAEstatus& status)
{
        int stat;
        ICPCritical cs(&m_crpt_cs);
        ICPTimer icp_timer;
        if (m_dae_type == ISISDAE::NeutronDAE3 || m_dae_type == ISISDAE::MuonDAE3)
        {
                stat = m_dae->VMEReadArray<DAE3CardPolicy>(card_id, card_address, values, num_values, status);
        }
        else
        {
                stat = m_dae->VMEReadArray<DAE2CardPolicy>(card_id, card_address, values, num_values, status);
        }
        icp_timer.info("VMEReadArray", status);
        return stat;
}

int ISISinstrumentControl::exitProgram(const std::string& message, bool prompt)
{
        logEvent(m_crpt, "ICP_EXIT", m_status);
        if (message.size() > 0)
        {
                m_status.add(FAC_CRPT, SEV_FATAL, ERRTYPE_OUTOFMEM, message);
                if (prompt)
                {
                        MessageBox(NULL,
                                message.c_str(), 
                                "ISISICP.EXE", MB_SERVICE_NOTIFICATION | MB_SYSTEMMODAL | MB_ICONERROR | MB_OK);
                }
        }
        m_status.reportAll();
        exit(EXIT_FAILURE);
        return 0; /*NOTREACHED*/
}


int ISISinstrumentControl::writeISISNeXus(NeXusWriter& nxwriter, const CRPTProxy& crpt, const char* filename, bool logs_only, const seblock_map_t& blocks, const std::string& events_nxfile, DAEstatus& dstatus)
{
//      dstatus.addInfoVa(FAC_DAE, "writeISISNeXus, thread id %u", Poco::Thread::currentTid());
        static bool incrementaleventnexus = Poco::Util::Application::instance().config().getBool("isisicp.incrementaleventnexus", false);
        static bool incrementaleventnexustest = Poco::Util::Application::instance().config().getBool("isisicp.incrementaleventnexustest", false);
        const ISISRAW* iraw = new ISISRAW(const_cast<ISISCRPT_STRUCT*>(crpt.CRPT()), const_cast<isisU32_t*>(crpt.rawData()));
        if ( incrementaleventnexus && events_nxfile.size() > 0 && Poco::File(events_nxfile).exists() )
        {
                if (incrementaleventnexustest)
                {
                        nxwriter.writeISISNeXus(filename, logs_only, crpt.CRPT(), crpt.rawData(), crpt.rawDataSizeMax(), iraw, blocks, m_instrument_xml_file, m_instrument_parameter_map_file, dstatus);
                        nxwriter.writeISISNeXus((std::string(filename)+".incr").c_str(), logs_only, crpt.CRPT(), crpt.rawData(), crpt.rawDataSizeMax(), iraw, blocks, events_nxfile, m_instrument_xml_file, m_instrument_parameter_map_file, dstatus);
                }
                else
                {
                        nxwriter.writeISISNeXus(filename, logs_only, crpt.CRPT(), crpt.rawData(), crpt.rawDataSizeMax(), iraw, blocks, events_nxfile, m_instrument_xml_file, m_instrument_parameter_map_file, dstatus);
                }
        }
        else
        {
                nxwriter.writeISISNeXus(filename, logs_only, crpt.CRPT(), crpt.rawData(), crpt.rawDataSizeMax(), iraw, blocks, m_instrument_xml_file, m_instrument_parameter_map_file, dstatus);
        }
        delete iraw;
        return 0;
}

int ISISinstrumentControl::waitForAsync()
{
        bool done = false;
        while(!done)
        {
                if ( (WaitForSingleObject(m_async_complete_event, INFINITE) == WAIT_OBJECT_0) && 
                         (m_num_async_requests == 0) )
                {
                        done = true;
                }
        }
        return 0;
}

int ISISinstrumentControl::doneAsync()
{
        InterlockedDecrement(&m_num_async_requests);
        SetEvent(m_async_complete_event);
        return 0;
}

struct isisraw_async_t
{
        std::string filename;
        ISISinstrumentControl* icp;
        const CRPTProxy& crpt;
        DAEstatus& status;
        isisraw_async_t(const CRPTProxy& crpt_, const char* filename_, ISISinstrumentControl* icp_, DAEstatus& status_) :
                crpt(crpt_), filename(filename_), icp(icp_), status(status_) {}
};

DWORD __stdcall ISISinstrumentControl::writeISISRAWthread(void* arg)
{
        isisraw_async_t* raw = (isisraw_async_t*)arg;
        raw->icp->writeISISRAW(raw->crpt, raw->filename.c_str(), raw->status);
        raw->icp->doneAsync();
        delete raw;
        return 0;
}

int ISISinstrumentControl::writeISISRAWasync(const CRPTProxy& crpt, const char* filename, DAEstatus& dstatus)
{
        isisraw_async_t* arg = new isisraw_async_t(crpt, filename, this, dstatus);
        InterlockedIncrement(&m_num_async_requests);
        if (QueueUserWorkItem(writeISISRAWthread, arg, WT_EXECUTEDEFAULT) != 0)
        {
                return DAEstatus::Success;
        }
        else
        {
                InterlockedDecrement(&m_num_async_requests);
                return DAEstatus::Failure;
        }
}

int ISISinstrumentControl::writeISISRAW(const CRPTProxy& crpt, const char* filename, DAEstatus& dstatus)
{
        ICPTimer timer1;
#if 0
        writeMuonFile(filename, crpt, dstatus);
#else
        const ISISRAW* iraw = new ISISRAW(const_cast<ISISCRPT_STRUCT*>(crpt.CRPT()), const_cast<isisU32_t*>(crpt.rawData()));
        remove(filename);
        if (const_cast<ISISRAW*>(iraw)->writeToFile(filename) < 0)
        {
                dstatus.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Unable to write raw file %s", filename);
        }
        delete iraw;
#endif
        timer1.info("Time to write ISISRAW", dstatus);
        return 0;
}

int ISISinstrumentControl::readISISRAW(const char* filename, DAEstatus& dstatus)
{
        ISISRAW* iraw = new ISISRAW(m_crpt.CRPT(), m_crpt.rawData());
        FILE* input_file = _fsopen(filename,"r+bN", _SH_DENYWR);
        if (input_file != NULL)
        {
                iraw->ioRAW(input_file, true);
                fclose(input_file);
        }
        else
        {
                dstatus.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Unable to read raw file %s", filename);
        }
        delete iraw;
        return 0;
}


int ISISinstrumentControl::getOptions(std::string& options_xml, DAEstatus& status)
{
        if (!m_crpt.isValid())
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "CRPT is NULL");
                return status.result();
        }
        ICPCritical cs(&m_crpt_cs);
        LabviewXML lvxml(status);
        lvxml.loadFromString(options_xml.c_str(), status);

//      lvxml.setValue("Dashboard Update Interval", m_crpt->update_poll_time, status);

//      lvxml.saveToString(options_xml, status);
        return status.result();
}

int ISISinstrumentControl::setOptions(const std::string& options_xml, DAEstatus& status)
{
        if (!m_crpt.isValid())
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "CRPT is NULL");
                return status.result();
        }
        ICPCritical cs(&m_crpt_cs);
//      m_recovery_map["options"] = options_xml;
        LabviewXML lvxml(status);
        lvxml.loadFromString(options_xml.c_str(), status);
                
//      lvxml.getValue("Dashboard Update Interval", m_crpt->update_poll_time, status); 

        return status.result();
}

int ISISinstrumentControl::refreshCachedValues(DAEstatus& status)
{
        if (!m_crpt.isValid())
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "CRPT is NULL");
                return status.result();
        }
        ICPCritical cs(&m_crpt_cs);
        ICPTimer icp_timer;
        updateFunc(0, true);
        icp_timer.info("refreshCachedValues", status);
        return status.result();
}

int ISISinstrumentControl::getCharItem(const char* item_name, std::string& cvalue, DAEstatus& status)
{
        return m_crpt->getCharItem(item_name, cvalue, status);
}

int ISISinstrumentControl::getIntItem(const char* item_name, long& lVal, DAEstatus& status)
{
        return m_crpt->getIntItem(item_name, lVal, status);
}

int ISISinstrumentControl::getIntItem(const char* item_name, long* spec_array, int nspec, long* lVal, DAEstatus& status)
{
        return m_crpt->getIntItem(item_name, spec_array, nspec, lVal, status);
}

int ISISinstrumentControl::getRealItem(const char* item_name, double& dblVal, DAEstatus& status)
{
        return m_crpt->getRealItem(item_name, dblVal, status);
}

int ISISinstrumentControl::getRealItem(const char* item_name, long* spec_array, int nspec, double* dblVal, DAEstatus& status)
{
        return m_crpt->getRealItem(item_name, spec_array, nspec, dblVal, status);
}

int ISISinstrumentControl::getIntArrayItemSize(const char* item_name, int* dims_array, int& ndims, DAEstatus& status)
{
        return m_crpt->getIntArrayItemSize(item_name, dims_array, ndims, status);
}

int ISISinstrumentControl::getIntArrayItem(const char* item_name, long* larray, DAEstatus& status)
{
        std::string sitem_name = item_name;
        int spec_from, spec_to;
        if (!strncmp(item_name, "SPECTRUM_", 9))
        {
                long spectrum_number = atol(sitem_name.substr(9, 1000).c_str());
                updateCRPTSpectra(-1, &spectrum_number, 1, status);
        }
        else if ( !strncmp(item_name, "CNT", 3) && (strlen(item_name) >= 5) && (item_name[4] == '[') )   // e.g. CNT1[53:789]
        {
                long tr = atol(item_name + 3);
                if (parseSpectraRange(sitem_name, spec_from, spec_to) == DAEstatus::Success)
                {
                        updateCRPTSpectra(-1, spec_from, spec_to - spec_from + 1, status);
                }
        }
        else if ( !strncmp(item_name, "CNT", 3) )  // e.g. CNT1
        {
                long tr = atol(item_name + 3);
                long spec_min, spec_max;
                getSpectrumNumbersForTimeRegime(tr, spec_min, spec_max, status);
                updateCRPTSpectraAllPeriods(spec_min, spec_max - spec_min + 1, status);
//              updateCRPTWithDAE(false, status);
        }
        return m_crpt.getIntArrayItem(item_name, larray, status);
}

int ISISinstrumentControl::getIntArrayItem(const char* item_name, long* spec_array, int nspec, long* larray, DAEstatus& status)
{
        if (!strcmp(item_name, "SPECTRUM"))
        {
                updateCRPTSpectra(-1, spec_array, nspec, status);
        }
        else if ( !strncmp(item_name, "CNT", 3) )  // e.g. CNT1
        {
                long tr = atol(item_name + 3);
                long spec_min, spec_max;
                getSpectrumNumbersForTimeRegime(tr, spec_min, spec_max, status);
                updateCRPTSpectraAllPeriods(spec_min, spec_max - spec_min + 1, status);
//              updateCRPTWithDAE(false, status);
        }
        return m_crpt.getIntArrayItem(item_name, spec_array, nspec, larray, status);
}

int ISISinstrumentControl::getRealArrayItemSize(const char* item_name, int* dims_array, int& ndims, DAEstatus& status)
{
        return m_crpt->getRealArrayItemSize(item_name, dims_array, ndims, status);
}

int ISISinstrumentControl::getRealArrayItem(const char* item_name, long* spec_array, int nspec, double* darray, DAEstatus& status)
{
        if (!strcmp(item_name, "RSPECTRUM") || !strcmp(item_name, "RSPECERR"))
        {
                updateCRPTSpectra(-1, spec_array, nspec, status);
        }
        return m_crpt.getRealArrayItem(item_name, spec_array, nspec, darray, status);
}

int ISISinstrumentControl::getRealArrayItem(const char* item_name, double* darray, DAEstatus& status)
{
        std::string sitem_name = item_name;
        long spectrum_number, sum;
        if (!strncmp(item_name, "RSPECTRUM_", 10))
        {
                spectrum_number = atol(sitem_name.substr(10, 1000).c_str());
                int ntc = m_crpt->spectrumNTC(spectrum_number);
                double* time_array = new double[ntc+1];
                double* error_array = new double[ntc];
                // this is in counts per unit time
                getSpectrum(spectrum_number, 0, time_array, darray, error_array, 
                                        true, true, sum, status);
                delete[] time_array;
                delete[] error_array;
                return DAEstatus::Success;
        }
        if (!strncmp(item_name, "RSPECERR_", 9))
        {
                spectrum_number = atol(sitem_name.substr(9, 1000).c_str());
                int ntc = m_crpt->spectrumNTC(spectrum_number);
                double* time_array = new double[ntc+1];
                double* signal_array = new double[ntc];
                // this is in counts per unit time
                getSpectrum(spectrum_number, 0, time_array, signal_array, darray, 
                                        true, true, sum, status);
                delete[] time_array;
                delete[] signal_array;
                return DAEstatus::Success;
        }
        return m_crpt.getRealArrayItem(item_name, darray, status);
}

// if period < 0, assume spectra are absolute
int ISISinstrumentControl::updateCRPTSpectra(int period, long* spectra_list, int nspectra, DAEstatus& status)
{
        unsigned long i;
        long offset;
        ICPCritical cs(&m_crpt_cs);
        int len, spec, daq_period;
        int perspec = m_crpt->getNumSpectra(true); // number of spectra in a period
        if (period < 0)
        {
                daq_period = 0;
        }
        else
        {
                daq_period = getDAQPeriod(period, status);
        }
        if (daq_period < 0)
        {
                return DAEstatus::Success;   // dwell period - nothing to do
        }
        for(i=0; i<nspectra; i++)
        {
                spec = spectra_list[i];
                offset = m_crpt.spectrumCRPTOffset(spec, daq_period);
                len = m_crpt->spectrumNTC(spec) + 1;
                if ( !m_crpt->isEventSpectrum(spec) )
                {
                        m_dae->readDAE1Spectrum(spec + daq_period * perspec, &(m_crpt.rawData()[offset]), len, status);
                }
        }
        return DAEstatus::Success;
}

// if period < 0, assume spectra are absolute
int ISISinstrumentControl::updateCRPTSpectra(int period, long spec_start, int nspectra, DAEstatus& status)
{
        ICPCritical cs(&m_crpt_cs);
        int persize = m_crpt->getPeriodSize();
        int daq_period;
        if (period < 0)
        {
                daq_period = 0;
        }
        else
        {
                daq_period = getDAQPeriod(period, status);
        }
        if (daq_period < 0)
        {
                return DAEstatus::Success;   // dwell period - nothing to do
        }
        m_dae->readDAE1Spectra(m_crpt.rawData(), m_crpt.rawDataSizeMax(), m_crpt->spec_to_crpt_offset.data(), spec_start, nspectra, daq_period, persize, status);
        return DAEstatus::Success;
}

int ISISinstrumentControl::updateCRPTSpectraAllPeriods(long spec_start, int nspectra, DAEstatus& status)
{
        ICPCritical cs(&m_crpt_cs);
        int persize = m_crpt->getPeriodSize();
        for(int daq_period=0; daq_period < m_crpt->nper_daq; ++daq_period)
        {
                m_dae->readDAE1Spectra(m_crpt.rawData(), m_crpt.rawDataSizeMax(), m_crpt->spec_to_crpt_offset.data(), spec_start, nspectra, daq_period, persize, status);
        }
        return DAEstatus::Success;
}

int ISISinstrumentControl::notifyICP(long event_id, const char* param, DAEstatus& status)
{
        switch(event_id)
        {
                case UserDetailsChanged:
                        return updateUserDetailsFromFile(param, status);
                        break;

                case SampleParametersChanged:
                        return updateSampleParametersFromFile(param, status);
                        break;

                case BeamlineParamerersChanged:
                        return updateBeamlineParametersFromFile(param, status);
                        break;

                default:
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Unknown event %d", event_id);
                        return DAEstatus::Failure;
                        break;
        }
}

int ISISinstrumentControl::updateUserDetailsFromFile(const char* filename, DAEstatus& status)
{
        char sep = '\t';
        std::string s1, s2;
        std::fstream fs;
        fs.open(filename, std::ios::in);
        getline(fs, s1); // first line is RB
        if (fs.good())
        { 
                m_crpt->rb_number = atol(s1.c_str());
        }
        else
        {
                m_crpt->rb_number = 0;
        }
        for(int i=0; i<1; i++)
        {
                std::fstream::pos_type pt = fs.tellg();
                getline(fs, s1, sep);
                getline(fs, s2); // read to end of line
                if (fs.fail()) // maybe short line with no tab
                {
                        fs.clear();
                        fs.seekg(pt);
                        getline(fs, s1);
                        s2 = "";
                }
                if (fs.good())
                {
                        strncpy(m_crpt->user_name, s1.c_str(), sizeof(m_crpt->user_name));
                        strncpy(m_crpt->institute, s2.c_str(), sizeof(m_crpt->institute));
                }
                else
                {
                        m_crpt->user_name[0] = '\0';
                        m_crpt->institute[0] = '\0';
                }
        }
        fs.close();
        return DAEstatus::Success;
}

int ISISinstrumentControl::updateSampleParametersFromFile(const char* filename, DAEstatus& status)
{
        CRPTProxy::parameter_map_t sample_params;
        updateParametersFromFile(sample_params, filename, status);
        return DAEstatus::Failure;
}

int ISISinstrumentControl::stringTableToParameterMap(const string_table_t& string_table, 
                                                                                                         CRPTProxy::parameter_map_t& param_map, DAEstatus& status)
{
        std::pair<CRPTProxy::parameter_map_t::iterator, bool> insert_ret;
        param_map.clear();
        for(int i=0; i<string_table.size(); i++)
        {
                if (string_table[i].size() > 3)
                {
                        insert_ret = param_map.insert(CRPTProxy::parameter_map_t::value_type(string_table[i][0], 
                                        CRPTProxy::parameter_t(string_table[i][1], string_table[i][2], string_table[i][3])));
                }
                else
                {
                        status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Short string table");
                        return DAEstatus::Failure;
                }
        }
        return DAEstatus::Success;
}

int ISISinstrumentControl::updateParametersFromFile(CRPTProxy::parameter_map_t& param_map, const char* filename, DAEstatus& status)
{
        char sep = '\t';
        param_map.clear();
        std::string s1, s2, s3, s4;
        std::fstream fs;
        std::pair<CRPTProxy::parameter_map_t::iterator, bool> insert_ret;
        fs.open(filename, std::ios::in);
        while(fs.good())
        {
                std::fstream::pos_type pt;
                pt = fs.tellg();
                getline(fs, s1, sep);
                getline(fs, s2, sep);
                getline(fs, s3, sep);
                getline(fs, s4);
                if (fs.fail()) // maybe a short line missing a sep?
                {
                        fs.clear();
                        fs.seekg(pt);
                        getline(fs, s1, sep);
                        getline(fs, s2, sep);
                        getline(fs, s3);
                        s4 = "";
                }
                if (fs.fail()) // maybe a short line missing a sep?
                {
                        fs.clear();
                        fs.seekg(pt);
                        getline(fs, s1, sep);
                        getline(fs, s2);
                        s3 = s4 = "";
                }
                if (fs.fail()) // maybe a short line missing a sep?
                {
                        fs.clear();
                        fs.seekg(pt);
                        getline(fs, s1);
                        s2 = s3 = s4 = "";
                }
                if (fs.good())
                {
                        insert_ret = param_map.insert(CRPTProxy::parameter_map_t::value_type(s1, CRPTProxy::parameter_t(s2, s3, s4)));
                }
        }
        fs.close();
        return DAEstatus::Success;
}

int ISISinstrumentControl::updateBeamlineParametersFromFile(const char* filename, DAEstatus& status)
{
        CRPTProxy::parameter_map_t beamline_params;
        updateParametersFromFile(beamline_params, filename, status);
        return DAEstatus::Failure;
}

// replace @block@ in string with block actual value from se_blocks
// replace @!block@ in string with block setpoint value from se_blocks
int ISISinstrumentControl::replaceSEparameters(std::string& s, const seblock_map_t* se_blocks, DAEstatus& status)
{
        int offset, count = 0;
        size_t p1, p2, start;
        bool setpoint;
        seblock_map_t::const_iterator se_iter;
        if (se_blocks == NULL)
        {
                return DAEstatus::Success;
        }
        start = 0;
        while(count < 20)  // this is to stop an infinite loop
        {
                p1 = s.find("@", start);
                if (p1 == std::string::npos)
                {
                        break;
                }
                if (p1 < s.size() && s[p1+1] == '!')
                {
                        setpoint = true;
                        offset = 2;
                }
                else
                {
                        setpoint = false;
                        offset = 1;
                }
                p2 = s.find("@", p1 + 1);
                if (p2 == std::string::npos)
                {
                        break;
                }
                std::string block = s.substr(p1 + offset, p2 - p1 - offset);
                if ( (se_iter = se_blocks->find(block)) != se_blocks->end() )
                {
                        std::string repstr = "NaN";
                        if (se_iter->second.is_real)
                        {
                                std::stringstream sstr;
                                if (setpoint && se_iter->second.fsetpoint_value.size() > 0)
                                {
                                        sstr << se_iter->second.fsetpoint_value[0];
                                        repstr = sstr.str();
                                }
                                else if (!setpoint && se_iter->second.fcurrent_value.size() > 0)
                                {
                                        sstr << se_iter->second.fcurrent_value[0];
                                        repstr = sstr.str();
                                }
                        }
                        else 
                        {
                                if (setpoint && se_iter->second.setpoint_value.size() > 0)
                                {
                                        repstr = se_iter->second.setpoint_value[0];
                                }
                                else if (!setpoint && se_iter->second.current_value.size() > 0) 
                                {
                                        repstr = se_iter->second.current_value[0];
                                }
                        }
                        s.replace(p1, p2 - p1 + 1, repstr);
                        start = p1 + repstr.size();
                }
                else
                {
//                      status.addWarningVa(FAC_DAE, "Unable to find block \"%s\" during @@ beamline/sample parameter substitution", block.c_str());
                        start = p2 + 1;
                }
                ++count;
        }
        return DAEstatus::Success;
}

int ISISinstrumentControl::setRealParameter(const CRPTProxy::parameter_map_t& params, const seblock_map_t* se_blocks, const char* name, 
                                                                                        float& crpt_target, DAEstatus& status)
{
        CRPTProxy::parameter_map_t::const_iterator iter;
        if ( (iter = params.find(name)) != params.end() )
        {
                std::string s = iter->second.value;
                replaceSEparameters(s, se_blocks, status);
                crpt_target = atof(s.c_str());
        }
        else
        {
                ; // crpt_target = value_if_not_found;
        }
        return 0;
}

int ISISinstrumentControl::setStringParameter(const CRPTProxy::parameter_map_t& params, const seblock_map_t* se_blocks, const char* name, char* crpt_target, 
                                                                                          int size_crpt_target, bool null_terminate, DAEstatus& status)
{
        CRPTProxy::parameter_map_t::const_iterator iter;
        if ( (iter = params.find(name)) != params.end() )
        {
                std::string s = iter->second.value;
                replaceSEparameters(s, se_blocks, status);
                strncpy(crpt_target, s.c_str(), size_crpt_target);
        }
        else
        {
                ; // strncpy(crpt_target, value_if_not_found, size_crpt_target);
        }
        if (null_terminate)
        {
                crpt_target[size_crpt_target-1] = '\0';
        }
        return 0;
}

int ISISinstrumentControl::setSampleParameters(const string_table_t& table, DAEstatus& status)
{
        stringTableToParameterMap(table, m_crpt.sampleParameters(), status);
        CRPTProxy::parameter_map_t::const_iterator it;
        seblock_map_t seblocks;
        for(it=m_crpt.sampleParameters().begin(); it != m_crpt.sampleParameters().end(); ++it)
        {
                if (it->second.value.find("@") != std::string::npos)
                {
                        se_get_block_values(seblocks);
                        break;
                }
        }
        updateSampleParameters(m_crpt.sampleParameters(), m_crpt, &seblocks, status);
        return DAEstatus::Success;
}

int ISISinstrumentControl::updateSampleParameters(const CRPTProxy::parameter_map_t& sample_parameters, CRPTProxy& crpt, const seblock_map_t* se_blocks, DAEstatus& status)
{
        setStringParameter(sample_parameters, se_blocks, "Run Title", crpt->long_title, sizeof(crpt->long_title), true, status);
        setRealParameter(sample_parameters, se_blocks, "Sample Thickness", crpt->sample_thickness, status);
        setRealParameter(sample_parameters, se_blocks, "Sample Height", crpt->sample_height, status);
        setRealParameter(sample_parameters, se_blocks, "Sample Width", crpt->sample_width, status);
        setStringParameter(sample_parameters, se_blocks, "Sample Type", crpt->sample_type, sizeof(crpt->sample_type), true, status);
        setStringParameter(sample_parameters, se_blocks, "Sample Geometry", crpt->sample_geometry, sizeof(crpt->sample_geometry), true, status);
        setStringParameter(sample_parameters, se_blocks, "Sample Geometry", crpt->sample_orientation, sizeof(crpt->sample_orientation), true, status);
        setRealParameter(sample_parameters, se_blocks, "Angle of Incidence", crpt->angle_of_incidence, status);
        setRealParameter(sample_parameters, se_blocks, "Sample Phi Angle", crpt->sample_phi_angle, status);

        setStringParameter(sample_parameters, se_blocks, "Sample Name", crpt->sample_name, sizeof(crpt->sample_name), true, status);
        setStringParameter(sample_parameters, se_blocks, "Magnetic Field Label", crpt->field_label, sizeof(crpt->field_label), true, status);
        setStringParameter(sample_parameters, se_blocks, "Temperature Label", crpt->temperature_label, sizeof(crpt->temperature_label), true, status);
        setStringParameter(sample_parameters, se_blocks, "Comments", crpt->comment, sizeof(crpt->comment), true, status);
        setStringParameter(sample_parameters, se_blocks, "Script Name", crpt->script_name, sizeof(crpt->script_name), true, status);

        setStringParameter(sample_parameters, se_blocks, "Measurement ID", crpt->measurement_id, sizeof(crpt->measurement_id), true, status);
        setStringParameter(sample_parameters, se_blocks, "Measurement SubID", crpt->measurement_subid, sizeof(crpt->measurement_subid), true, status);
        setStringParameter(sample_parameters, se_blocks, "Measurement Type", crpt->measurement_type, sizeof(crpt->measurement_type), true, status);
        setStringParameter(sample_parameters, se_blocks, "Sample ID", crpt->sample_id, sizeof(crpt->sample_id), true, status);

        // we do not get "Measurement Label" as it is a derived quantity from Measuremtnt ID

        return DAEstatus::Success;
}


int ISISinstrumentControl::setBeamlineParameters(const string_table_t& table, DAEstatus& status)
{
        stringTableToParameterMap(table, m_crpt.beamlineParameters(), status);
        CRPTProxy::parameter_map_t::const_iterator it;
        seblock_map_t seblocks;
        for(it=m_crpt.beamlineParameters().begin(); it != m_crpt.beamlineParameters().end(); ++it)
        {
                if (it->second.value.find("@") != std::string::npos)
                {
                        se_get_block_values(seblocks);
                        break;
                }
        }
        updateBeamlineParameters(m_crpt.beamlineParameters(), m_crpt, &seblocks, status);
        return DAEstatus::Success;
}

int ISISinstrumentControl::updateBeamlineParameters(const CRPTProxy::parameter_map_t& beamline_parameters, CRPTProxy& crpt, const seblock_map_t* se_blocks, DAEstatus& status)
{
        setRealParameter(beamline_parameters, se_blocks, "FOE Mirror Angle", crpt->foe_mirror_angle, status);
        setRealParameter(beamline_parameters, se_blocks, "Beam Centre X", crpt->beam_centre_x, status);
        setRealParameter(beamline_parameters, se_blocks, "Beam Centre Y", crpt->beam_centre_y, status);
        setRealParameter(beamline_parameters, se_blocks, "Chopper Opening Angle", crpt->chopper_opening_angle, status);
        setRealParameter(beamline_parameters, se_blocks, "Aperture 1 Diameter", crpt->aperture1, status);
        setRealParameter(beamline_parameters, se_blocks, "Aperture 2 Diameter", crpt->aperture2, status);
//      setRealParameter(beamline_parameters, se_blocks, "Aperture 3 Diameter", crpt->aperture2, status);
        setStringParameter(beamline_parameters, se_blocks, "Beamstop Position", crpt->beamstop_position, sizeof(crpt->beamstop_position), true, status);
        setRealParameter(beamline_parameters, se_blocks, "Primary Flight Path (L1)", crpt->i_l1, status);
        setRealParameter(beamline_parameters, se_blocks, "Sample Detector Distance", crpt->sdd, status);
        setStringParameter(beamline_parameters, se_blocks, "Instrument Geometry", crpt->instrument_geometry, sizeof(crpt->instrument_geometry), true, status);
        setStringParameter(beamline_parameters, se_blocks, "Journal Blocks", crpt->journal_blocks, sizeof(crpt->journal_blocks), true, status);
        return DAEstatus::Success;
}

int ISISinstrumentControl::setBlockTable(const string_table_t& table, DAEstatus& status)
{
        return DAEstatus::Success;
}

int ISISinstrumentControl::setUserParameters(long rbno, const string_table_t& table, DAEstatus& status)
{
        int nuser = 0, k;
        std::string user_names, last_user, user_tmp;
        m_crpt->rb_number = rbno;
        m_crpt->user_name[0] = '\0';
        m_crpt->institute[0] = '\0';
        m_crpt->local_contact[0] = '\0';
        for(int i=0; i<table.size(); i++)
        {
                if (table[i].size() > 0)
                {
                        last_user = table[i][0];
                        k = last_user.find(' ');
                        if (k != last_user.npos)
                        {
                                user_tmp = last_user.substr(0, k);
                        }
                        else
                        {
                                user_tmp = last_user;
                        }
                        if (nuser == 0)
                        {
                                user_names = user_tmp;
                        }
                        else
                        {
                                user_names = user_names + "," + user_tmp;
                        }
                        strncpy(m_crpt->user_name, user_names.c_str(), sizeof(m_crpt->user_name));
                        m_crpt->institute[0] = '\0';
                        nuser++;
                }
                if (table[i].size() > 1)
                {
                        strncpy(m_crpt->institute, table[i][1].c_str(), sizeof(m_crpt->institute));
                }
                if ( table[i].size() > 2 )   // Role is blank, "PI" or "Contact" 
                {
                        std::string role = table[i][2];
                        std::transform(role.begin(), role.end(), role.begin(), tolower);
                        if (role.find("contact") != role.npos)
                        {
                                strncpy(m_crpt->local_contact, last_user.c_str(), sizeof(m_crpt->local_contact));
                        }
                }
        }
        if (nuser == 1) // for one user name, do not strip off initials
        {
                strncpy(m_crpt->user_name, last_user.c_str(), sizeof(m_crpt->user_name));
        }
        if (nuser > 1)
        {
                m_crpt->institute[0] = '\0';
        }
        NULL_TERMINATE(m_crpt->user_name);
        NULL_TERMINATE(m_crpt->institute);
        NULL_TERMINATE(m_crpt->local_contact);
        return DAEstatus::Success;
}

// VMS compatible journal entry
struct vms_journal_line
{
        char inst_abrv[3];
        char run_number[5];
        char user_name[20];
        char title[24];
        char date[20];
        char uamps[8];
};

// VMS compatible summary entry
struct vms_summary_line
{
    vms_journal_line jl;
        char rb[8];
};

static const char* STR0(const char* str, const char* value = "UNSPECIFIED")
{
        if (str == NULL || str[0] == '\0')
        {
                return value;
        }
        else
        {
                return str;
        }
}

class XMLJournalHandler : public Poco::XML::ContentHandler
{
        int& m_first_run;
        int& m_last_run;
        bool in_run_number;
public:
        XMLJournalHandler(int& first_run, int& last_run) : Poco::XML::ContentHandler(), m_first_run(first_run), m_last_run(last_run) { }
        void setDocumentLocator(const Poco::XML::Locator* loc) { }
         void startDocument() 
         { 
                 m_first_run = m_last_run = 0; 
                 in_run_number = false;
         }

         void endDocument() { }

         void startElement(const Poco::XML::XMLString& uri, const Poco::XML::XMLString& localName, const Poco::XML::XMLString& qname, 
                 const Poco::XML::Attributes& attrList) 
         {
                if (localName == "run_number")
                {
                        in_run_number = true;
                }
         }

         void endElement(const Poco::XML::XMLString& uri, const Poco::XML::XMLString& localName, const Poco::XML::XMLString& qname)
         {
                if (localName == "run_number")
                {
                        in_run_number = false;
                }
         }

         void characters(const Poco::XML::XMLChar ch[], int start, int length)
         {
                 int run_number;
                 if (in_run_number)
                 {
                         // we seem to get called multiple times, sometimes for bits of whitespace,
                         // but just checking for number > 0 seems to work OK as space -> 0
                         run_number = atoi(std::string(ch+start, length).c_str());
                         if (run_number > 0)
                         {
                                m_last_run = run_number;
                                if (m_first_run == 0)
                                {
                                         m_first_run = m_last_run;
                                }
                         }
                 }
         }

         void ignorableWhitespace(const Poco::XML::XMLChar ch[], int start, int length) { }

         void processingInstruction(const Poco::XML::XMLString& target, const Poco::XML::XMLString& data) { }

         void startPrefixMapping(const Poco::XML::XMLString& prefix, const Poco::XML::XMLString& uri) { }

         void endPrefixMapping(const Poco::XML::XMLString& prefix) { }

         void skippedEntity(const Poco::XML::XMLString& name) { }

};

int ISISinstrumentControl::writeJournal(const CRPTProxy& crpt, seblock_map_t& blocks, DAEstatus& status)
{
        char c, buffer[80];
        int i;
    vms_journal_line jl;
        vms_summary_line sl;
        // journal line
        memset(&jl, ' ', sizeof(jl));
        spacePadCopy(jl.inst_abrv, crpt->inst_abrv, sizeof(jl.inst_abrv));
        // for VMS compatibility wrap run number at 99999
        spacePadCopyVa(jl.run_number, sizeof(jl.run_number), "%0*d", sizeof(jl.run_number), crpt->run_number % VMS_RUN_MASK);
        spacePadCopy(jl.user_name, crpt->user_name, sizeof(jl.user_name));
        spacePadCopy(jl.title, crpt->long_title, sizeof(jl.title));
        ISISRAW::vmstime(buffer, sizeof(buffer), crpt->start_time);
        spacePadCopy(jl.date, buffer, sizeof(jl.date));
        spacePadCopyVa(jl.uamps, sizeof(jl.uamps), "%*.1f", sizeof(jl.uamps), crpt->good_uamph);
        // summary line
        memset(&sl, ' ', sizeof(sl));
        memcpy(&(sl.jl), &jl, sizeof(sl.jl));
        spacePadCopyVa(sl.rb, sizeof(sl.rb), "%*d", sizeof(sl.rb), crpt->rb_number);

        std::fstream fsj;
        fsj.open(m_data_dir+"\\journal.txt", std::ios::app);
        if (fsj.good())
        {
                for(i=0; i<sizeof(jl); i++)
                {
                        c = ((const char*)&jl)[i];
                        if (isspace(c))   // change tabs, newlines etc to a single space
                        {
                                c = ' ';
                        }
                        fsj << c;
                }
                fsj << std::endl;
                fsj.close();
        }
        else
        {
                status.addWarning(FAC_CRPT, "Error appending to journal file");
        }
        std::fstream fss;
        fss.open(m_data_dir+"\\summary.txt", std::ios::app);
        if (fss.good())
        {
                for(i=0; i<sizeof(sl); i++)
                {
                        c = ((const char*)&sl)[i];
                        if (isspace(c)) // change tabs, newlines etc to a single space
                        {
                                c = ' ';
                        }
                        fss << c;
                }
                fss << std::endl;
                fss.close();
        }
        else
        {
                status.addWarning(FAC_CRPT, "Error appending to summary file");
        }
        // new XML version
        int nx_mode;
        std::stringstream file_buffer;
        file_buffer << m_data_dir << "\\journal";
        if (m_icp_options & PerCycleJournal)
        {
                file_buffer << "_" << crpt->isis_cycle;
        }
        file_buffer << ".xml";
        std::string file = file_buffer.str();
        if (access(file.c_str(), 0) == 0)
        {
                nx_mode = NXACC_RDWR;
        }
        else
        {
                nx_mode = NXACC_CREATEXML;
        }
        long first_run_number;
        if (se_get_measurement_first_run(crpt->measurement_id, first_run_number) != 0)
        {
                first_run_number = 0;
        }
        std::string measurement_label;
        if (se_get_measurement_label(crpt->measurement_id, measurement_label) != 0)
        {
                measurement_label = "";
        }
        std::vector<std::string> jblock_list;
        char* tmp_blocks = strdup(crpt->journal_blocks);
        const char* block = strtok(tmp_blocks, " \t,:;");
        while(block != NULL)
        {
                jblock_list.push_back(block);
                block = strtok(NULL, " \t,:;");
        }
        free(tmp_blocks);
        using namespace NeXus;
        using namespace NeXus::Stream;
        std::string seci_config;
        std::stringstream entry_name;
        se_get_seci_config(seci_config);
        sprintf(buffer, "%08d", crpt->run_number);
        entry_name << crpt->inst_name << buffer;
        std::string temp_file = m_data_dir + "\\journal_tmp.xml";
        try 
        {
                if (nx_mode == NXACC_RDWR) // existing file
                {
                        file = temp_file;
                        nx_mode = NXACC_CREATEXML;
                }               
                File journal(file, nx_mode);
                // fix schema version number to 3.0
                journal.putAttr("xmlns", "http://definition.nexusformat.org/schema/3.0");
                journal.putAttr("xsi:schemaLocation", "http://definition.nexusformat.org/schema/3.0");
                journal.makeGroup(entry_name.str(), "NXentry", true);
                // think it is more accurate to use convertWindows1252ToUTF8() rather than convertLatin1ToUTF8()
                journal.writeData("title", convertWindows1252ToUTF8(STR0(crpt->long_title)));
                journal.writeData("user_name", convertWindows1252ToUTF8(STR0(crpt->user_name)));
                journal.writeData("local_contact", convertWindows1252ToUTF8(STR0(crpt->local_contact)));
                journal.writeData("user_institute", convertWindows1252ToUTF8(STR0(crpt->institute)));
                sprintf(buffer, "%d", crpt->rb_number);
                journal.writeData("experiment_identifier", STR0(buffer));
                journal.writeData("instrument_name", STR0(crpt->inst_name));
                journal.writeData("run_number", crpt->run_number);
                journal.writeData("sample_id", STR0(crpt->sample_id));
                journal.writeData("measurement_first_run", (int)first_run_number);
                journal.writeData("measurement_id", STR0(crpt->measurement_id));
                journal.writeData("measurement_label", STR0(measurement_label.c_str()));
                journal.writeData("measurement_type", STR0(crpt->measurement_type));
                journal.writeData("measurement_subid", STR0(crpt->measurement_subid));
                ISOtime(crpt->start_time, buffer, sizeof(buffer));
                journal.writeData("start_time", buffer);
                ISOtime(crpt->stop_time, buffer, sizeof(buffer));
                journal.writeData("end_time", buffer);
                journal.writeData("duration", crpt->duration);
                journal.writeData("proton_charge", crpt->good_uamph);
                journal.writeData("raw_frames", crpt->total_frames);
                journal.writeData("good_frames", crpt->good_frames);
                journal.writeData("number_periods", crpt->nper);
                journal.writeData("number_spectra", crpt->getNumSpectra());
                journal.writeData("number_detectors", crpt->ndet);
                journal.writeData("number_time_regimes", crpt->ntrg);
                journal.writeData("frame_sync", FrameSyncNames[crpt->tcb_sync]);
                for(i=0; i<crpt->ntrg; i++)
                {
                        const TCBRANGE* tcr = crpt->tcr[i];
                        int ntcr = crpt->ntcr[i];
                        sprintf(buffer, "time_regime_%d", i+1);
                        journal.makeGroup(buffer, "IXtime_regime", true);
                        journal.writeData("number_time_channels", crpt->ntc[i]); // all same at moment
//                      if (tcr[0].mode == TCBRANGE_FILE)
                        journal.writeData("time_channel_min", tcr[0].start); 
                        journal.writeData("time_channel_max", tcr[ntcr-1].end); 
                        journal.closeGroup();
                }
                journal.writeData("icp_version", STR0(crpt->icp_version));
                journal.writeData("detector_table_file", STR0(crpt->detector_table.fname));
                journal.writeData("spectra_table_file", STR0(crpt->spectra_table.fname));
                journal.writeData("wiring_table_file", STR0(crpt->wiring_table.fname));
                journal.writeData("monitor_spectrum", crpt->monitor_spectrum);
                journal.writeData("monitor_sum", crpt->monitor_sum[0]);
                journal.writeData("total_mevents", (float)crpt->update_total_counts / (float)1e6);
                journal.writeData("comment", STR0(crpt->comment));
                journal.writeData("field_label", STR0(crpt->field_label));
                journal.writeData("instrument_geometry", STR0(crpt->instrument_geometry));
                journal.writeData("script_name", STR0(crpt->script_name));
                journal.writeData("sample_name", STR0(crpt->sample_name));
                journal.writeData("sample_orientation", STR0(crpt->sample_orientation));
                journal.writeData("temperature_label", STR0(crpt->temperature_label));
                journal.writeData("npratio_average", crpt->update_npratio_average);
                journal.writeData("isis_cycle", STR0(crpt->isis_cycle));
                journal.writeData("seci_config", STR0(seci_config.c_str()));
                journal.writeData("event_mode", crpt->eventModeCardFraction());
                journal.makeGroup("selog", "IXselog", true);
                for(std::vector<std::string>::const_iterator it = jblock_list.begin(); it != jblock_list.end(); ++it)
                {
                        seblock_map_t::const_iterator itb;
                        if ( (Poco::trim(*it)).size() == 0 )
                        {
                                continue;
                        }
                        journal.makeGroup(*it, "IXseblock", true);
                        if ( (itb = blocks.find(*it)) != blocks.end() )
                        {
                                const SEBLOCK& block = itb->second;
                                if (block.is_real)
                                {
                                        if (block.fcurrent_value.size() > 0)
                                        {
                                                journal.writeData("current_value", block.fcurrent_value[0]);  // for all periods?
                                                journal.writeData("current_spread", block.fcurrent_spread[0]);  // for all periods?
                                        }
                                        else
                                        {
                                                journal.writeData("current_value", "NaN");  // for all periods?
                                        }
                                        if (block.fsetpoint_value.size() > 0)
                                        {
                                                journal.writeData("setpoint_value", block.fsetpoint_value[0]);  // for all periods?
                                                journal.writeData("setpoint_spread", block.fsetpoint_spread[0]);  // for all periods?
                                        }
                                        else
                                        {
                                                journal.writeData("setpoint_value", "NaN");  // for all periods?
                                        }
//                                      journal.writeData("average_value", block.faverage_value[0]);  // for all periods?
                                        journal.writeData("average_value", "NaN");  // for all periods?
                                }
                                else
                                {
                                        if (block.current_value.size() > 0)
                                        {
                                                journal.writeData("current_value", STR0(block.current_value[0].c_str()));  // for all periods?
                                        }
                                        else
                                        {
                                                journal.writeData("current_value", "UNKNOWN");  // for all periods?
                                        }
                                        if (block.setpoint_value.size() > 0)
                                        {
                                                journal.writeData("setpoint_value", STR0(block.setpoint_value[0].c_str()));  // for all periods?
                                        }
                                        else
                                        {
                                                journal.writeData("setpoint_value", "UNKNOWN");  // for all periods?
                                        }
                                        journal.writeData("average_value", "NaN");  // for all periods?
                                }
                        }
                        else
                        {
                                journal.writeData("current_value", "NaN");  // for all periods?
                                journal.writeData("setpoint_value", "NaN");  // for all periods?
                                journal.writeData("average_value", "NaN");  // for all periods?
                        }
                        journal.closeGroup();
                }
                journal.closeGroup();
                journal.closeGroup();
                journal.close();
                if (file == temp_file)
                {
                        std::fstream journal_full;
                        journal_full.open(file.c_str(), std::ios::in);
                        char big_buffer[10000];
                        journal_full.getline(big_buffer, sizeof(big_buffer), '\0');
                        journal_full.close();
                        remove(temp_file.c_str());
                        std::string xml_entry = big_buffer;
                        HANDLE h = CreateFile(file_buffer.str().c_str(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 
                                                                        defaultNoInheritHandles(), OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
                        if (h != INVALID_HANDLE_VALUE)
                        {
                                LARGE_INTEGER li;
                                li.QuadPart = -20;
                                SetFilePointerEx(h, li, NULL, FILE_END);
                                DWORD nread;
                                ReadFile(h, buffer, 20, &nread, NULL);
                                buffer[nread] = '\0';
                                const char* pos = strstr(buffer, "</NXroot>");
                                if (pos != NULL)
                                {
                                        int offset = (nread - (pos - buffer));
                                        li.QuadPart = -offset;
                                        SetFilePointerEx(h, li, NULL, FILE_END);
                                        int spos = xml_entry.find("<NXentry");
                                        if (spos != std::string::npos)
                                        {
                                                std::string spos_str = xml_entry.substr(spos);
                                                DWORD nwrite;
                                                if ( (WriteFile(h, spos_str.c_str(), spos_str.size(), &nwrite, NULL) == 0) ||
                                                         (nwrite != spos_str.size()) )
                                                {
                                                        status.addWarning(FAC_CRPT, "WriteFile error with xml journal");
                                                }
                                        }
                                }
                                CloseHandle(h);
                        }
                }
        }
        catch(const std::exception& ex)
        {
                status.addWarningVa(FAC_CRPT, "Error appending to XML journal %s", ex.what());
        }
        std::vector<std::string> journal_list;
        std::string journal_main = m_data_dir + "\\journal_main.xml";
        SetFileAttributes(journal_main.c_str(), FILE_ATTRIBUTE_NORMAL);
        remove(journal_main.c_str());
        findFiles(m_data_dir.c_str(), "journal*.xml", journal_list, false);
        std::ofstream jmain;
        try 
        {
                jmain.open(journal_main);
                jmain << "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>" << std::endl;
                jmain << "<?xml-stylesheet type=\"text/xsl\" href=\"journal.xsl\" ?>" << std::endl;
                jmain << "<!-- DO NOT EDIT - recreated automatically by ICP at each END of run -->" << std::endl;
                jmain << "<journal>" << std::endl;
                Poco::XML::SAXParser parser;
                int first_run, last_run;
                XMLJournalHandler journal_handler(first_run, last_run);
                parser.setContentHandler(&journal_handler);
                for(std::vector<std::string>::const_iterator it = journal_list.begin(); it != journal_list.end(); ++it)
                {
                        try 
                        {
                            parser.parse(m_data_dir + "\\" + *it);
                        }
                        catch(const std::exception& ex)
                        {
                                status.addWarningVa(FAC_CRPT, "Error SAX parsing XML journal file \"%s\" : %s", it->c_str(), ex.what());
                                first_run = last_run = 0;
                        }
                        jmain << "  <file name=\"" << *it << "\" first_run=\"" << first_run << "\" last_run=\"" << last_run << "\" />" << std::endl;
                }
                jmain << "</journal>" << std::endl;
                jmain.close();
                SetFileAttributes(journal_main.c_str(), FILE_ATTRIBUTE_READONLY);
        }
        catch(const std::exception& ex)
        {
                status.addWarningVa(FAC_CRPT, "Error creating journal_main.xml %s", ex.what());
        }
        return DAEstatus::Success;
}

void ISISinstrumentControl::zeroCRPTRawData()
{
        m_crpt.zeroUsedRawData(m_status);
        m_crpt.rawDataUpdated();
}

void ISISinstrumentControl::zeroCRPTRunRawData()
{
        m_crpt_run->zeroUsedRawData(m_status);
        m_crpt_run->rawDataUpdated();
}

//void ISISinstrumentControl::zeroCRPTRawData(void* arg)
//{
//      ISISinstrumentControl* ic = (ISISinstrumentControl*)arg;
//      ic->zeroCRPTRawData();
//}


int ISISinstrumentControl::getNPRatio(float* current, float* average, DAEstatus& status)
{
        *current = m_crpt->update_npratio_current;
        *average = m_crpt->update_npratio_average;
        return 0;
}

int ISISinstrumentControl::changeNumberOfSoftwarePeriods(long nperiod, DAEstatus& status)
{
        int i;
        if (m_crpt->run_status != RUNSTATUS_SETUP)
        {
                status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Can only change DAE in SETUP state");        
                return status.result();
        }
        if (m_crpt->period_type != ISISDAE::PeriodTypeSoftware)
        {
                status.add(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Not using software periods");        
                return status.result();
        }
        ICPCritical cs(&m_crpt_cs);
        unsigned permax = m_crpt->getPeriodSize();
        unsigned len = permax * nperiod;
        if ( len > m_crpt.rawDataSizeMax() )
        {
                status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "Not enough CRPT memory for requested %d periods", nperiod);
                return DAEstatus::Failure;
        }
        if ( nperiod >= ISISCRPT_MAX_PERIOD )
        {
                status.addVa(FAC_CRPT, SEV_ERROR, ERRTYPE_OUTOFMEM, "%d periods too large - only %d allowed by ICP", nperiod, ISISCRPT_MAX_PERIOD);
                return DAEstatus::Failure;
        }
        if (nperiod > 0)
        {
                m_crpt->nper = nperiod;
        }
        else
        {
                m_crpt->nper = 1;
        }
        for(i=0; i<m_crpt->nper; i++)
        {
                m_crpt->period[i].type = 1; // all DAQ periods
                m_crpt->period[i].daq_period = i; // all DAQ periods
                sprintf(m_crpt->period[i].label, "Period %d", i+1);
        }
        m_crpt->nper_daq = m_crpt->nper;
        m_dae->changeNumberOfPeriods(m_crpt->nper_daq, status);
        return status.result();
}

int ISISinstrumentControl::fillWithTestPattern(unsigned long pattern, DAEstatus& status)
{
                ICPCritical cs(&m_crpt_cs);
                m_dae->fillWithTestPattern(pattern, status);
                return status.result();
}

int ISISinstrumentControl::checkTestPattern(unsigned long pattern, DAEstatus& status)
{
                ICPCritical cs(&m_crpt_cs);
//              m_dae->checkTestPattern(pattern, status);
                m_dae->checkTestPatternAsync(pattern, status);
                return status.result();
}


int ISISinstrumentControl::getVetoStatus(std::string& veto_text, DAEstatus& status)
{
                ICPCritical cs(&m_crpt_cs);
                m_dae->getVetoStatus(veto_text, status);
                return status.result();
}

int ISISinstrumentControl::whichVeto(std::string& veto_text, DAEstatus& status)
{
                ICPCritical cs(&m_crpt_cs);
                m_dae->whichVeto(veto_text, status);
                return status.result();
}


int ISISinstrumentControl::loadDAEWithNeXusData(const std::string& file_name, long options, DAEstatus& status)
{
        Poco::SharedPtr<NeXus::File> nx_file;
        std::vector<int32_t> int32_vec;
        float good_uah;
        int good_frames;
        NeXus::Info info;
        if ( m_crpt->run_status != RUNSTATUS_PAUSED )
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Must be in PAUSED state to load data");
                return DAEstatus::Failure;
        }
        try
        {
                nx_file = new NeXus::File(file_name, NXACC_READ);
                nx_file->openPath("/entry/data");
                info = nx_file->getInfo();
                nx_file->getData(int32_vec);
                nx_file->openPath("/entry/good_frames");
                nx_file->getData(&good_frames);
                nx_file->openPath("/entry/proton_charge");
                nx_file->getData(&good_uah);
                nx_file->close(); 
        }
        catch(const std::exception& ex)
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "loadDAEWithNeXusData: %s", ex.what());
                return DAEstatus::Failure;
        }
        int period_offset;
        if ( info.dims.size() == 2 )
        {
                period_offset = 0;
                if ( 1 != m_crpt->nper )
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Number of periods mismatch 1 != %d", m_crpt->nper);
                        return DAEstatus::Failure;
                }
        }
        else if ( info.dims.size() == 3 )
        {
                period_offset = 1;
                if ( info.dims[0] != m_crpt->nper )
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Number of periods mismatch %d != %d", info.dims[0], m_crpt->nper);
                        return DAEstatus::Failure;
                }
        }
        else
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Array dimensionality mismatch in loaded data: must be 2 or 3 dimensional, not %d", info.dims.size());
                return DAEstatus::Failure;
        }
        if ( info.dims[0+period_offset] != m_crpt->nsp[0] )
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Number of spectra mismatch in loaded data: %d != %d", info.dims[0+period_offset], m_crpt->nsp[0]);
                return DAEstatus::Failure;
        }
        if ( info.dims[1+period_offset] != m_crpt->ntc[0] )
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Number of time channels mismatch in loaded data: %d != %d", info.dims[1+period_offset], m_crpt->ntc[0]);
                return DAEstatus::Failure;
        }
        int i, j, ndet, card, modn, mpos, nper, spec, spec_len, maxspec, maxcardspec;
        std::ostringstream oss;
        int maxmod = 16, maxpos = 4096, maxcrate = 16;
        ICPCritical cs(&m_crpt_cs);
        isisU32_t* new_poslut = new isisU32_t[maxcrate * maxmod * maxpos];
        int* last_card_spectrum = new int[maxcrate];
        memset(new_poslut, 0, maxcrate * maxmod * maxpos * sizeof(isisU32_t));
        memset(last_card_spectrum, 0, maxcrate * sizeof(int));
        spec_len = m_crpt->ntc[0] + 1; // +1 for time bin 0
        ndet = m_crpt->ndet;
        nper = m_crpt->nper;
        maxspec = m_crpt->nsp[0] + 1;  // +1 for spectrum 0
        int* spec_lookup = new int[maxspec];
        memset(spec_lookup, 0, maxspec * sizeof(int));
        for(i=0; i < ndet; i++)
        {
                card = m_crpt->crat[i];
                modn = m_crpt->modn[i];
                mpos = m_crpt->mpos[i];
                spec = m_crpt->spec[i];
                if (card >= maxcrate)
                {
                        status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Too many crates");
                        return DAEstatus::Failure;
                }
                if (spec > 0)
                {
                        j = card * (maxmod * maxpos) + modn * (maxpos) + mpos;
                        if (spec_lookup[spec] != 0)
                        {
                                new_poslut[j] = spec_lookup[spec];
                        }
                        else
                        {
                                new_poslut[j] = ++(last_card_spectrum[card]);
                                spec_lookup[spec] = last_card_spectrum[card];
                        }
                }
        }
        for(i=0; i < ndet; i++)
        {
                card = m_crpt->crat[i];
                spec = m_crpt->spec[i];
                if (spec > 0)
                {
                        maxcardspec = last_card_spectrum[card] + 1;
                        for(j=0; j<nper; j++)
                        {
                                // dae spectra are ntc+1, and there is also spectrum 0, so need to allow for this (compare with raw file code below)
                                int array_offset = ((spec - 1) + (maxspec - 1) * j) * (spec_len - 1);
                                m_dae->writeHistogramMemory(card, reinterpret_cast<isisU32_t*>(&(int32_vec[array_offset])), 
                                                                                (spec_lookup[spec] + maxcardspec * j) * spec_len * 4 + 1, // + 1 to start writing after time bin 0
                                                                                spec_len - 1, status);
                        }
                }
        }
        oss << "Loaded " << m_crpt->nsp[0] << " spectra, " << m_crpt->ntc[0] << " time channels, " << m_crpt->nper << " period(s)" << std::endl;
        for(i=0; i<maxcrate; i++)
        {
                if (last_card_spectrum[i] > 0)
                {
                        oss << "Writing " << last_card_spectrum[i] << " spectra to detector card " << i << std::endl;
                        m_dae->writePOSLUTMemory(i, &(new_poslut[i * (maxmod * maxpos)]), maxmod * maxpos, status);
                }
        }
        m_crpt->good_frames = m_crpt->total_frames = good_frames;
        m_crpt->good_uamph = m_crpt->total_uamph = good_uah;
        oss << "Set good_frames=" << good_frames << " and proton_charge=" << good_uah << std::endl;
        delete []new_poslut;
        delete []last_card_spectrum;
        delete []spec_lookup;
        status.addInfo(FAC_DAE, oss.str());
        return status.result();
}

int ISISinstrumentControl::loadDAEWithData(const std::string& file_name, long options, DAEstatus& status)
{
        return loadDAEWithNeXusData(file_name, options, status);

        int i, j, ndet, card, modn, mpos, nper, spec, spec_len, maxspec, maxcardspec;
        std::ostringstream oss;
        int maxmod = 16, maxpos = 4096, maxcrate = 16;
        ISISRAW *ir = new ISISRAW;
        ir->readFromFile(file_name.c_str());
        ir->printInfo(oss);
        if (ir->t_nsp1 != m_crpt->nsp[0] ||
                ir->t_ntc1 != m_crpt->ntc[0] ||
                ir->t_nper != m_crpt->nper ||
                ir->i_det != m_crpt->ndet ||
                ir->i_use != m_crpt->nuse)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Parameter mismatch");
                status.addInfo(FAC_DAE, oss.str());
                delete ir;
                return DAEstatus::Failure;
        }
        ICPCritical cs(&m_crpt_cs);
        isisU32_t* new_poslut = new isisU32_t[maxcrate * maxmod * maxpos];
        int* last_card_spectrum = new int[maxcrate];
        memset(new_poslut, 0, maxcrate * maxmod * maxpos * sizeof(isisU32_t));
        memset(last_card_spectrum, 0, maxcrate * sizeof(int));
        spec_len = ir->t_ntc1 + 1;
        ndet = ir->i_det;
        nper = ir->t_nper;
        maxspec = (ir->t_nsp1 + 1);
        int* spec_lookup = new int[maxspec];
        memset(spec_lookup, 0, maxspec * sizeof(int));
        for(i=0; i < ndet; i++)
        {
                card = ir->crat[i];
                modn = ir->modn[i];
                mpos = ir->mpos[i];
                spec = ir->spec[i];
                if (card >= maxcrate)
                {
                        status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Too many crates");
                        return DAEstatus::Failure;
                }
                if (spec > 0)
                {
                        j = card * (maxmod * maxpos) + modn * (maxpos) + mpos;
                        if (spec_lookup[spec] != 0)
                        {
                                new_poslut[j] = spec_lookup[spec];
                        }
                        else
                        {
                                new_poslut[j] = ++(last_card_spectrum[card]);
                                spec_lookup[spec] = last_card_spectrum[card];
                        }
                }
        }
        for(i=0; i < ndet; i++)
        {
                card = ir->crat[i];
                spec = ir->spec[i];
                if (spec > 0)
                {
                        maxcardspec = last_card_spectrum[card] + 1;
                        for(j=0; j<nper; j++)
                        {
                                m_dae->writeHistogramMemory(card, &(ir->dat1[(spec + maxspec * j) * spec_len]), 
                                                                                (spec_lookup[spec] + maxcardspec * j) * spec_len * 4, 
                                                                                spec_len, status);
                        }
                }
        }
        for(i=0; i<maxcrate; i++)
        {
                if (last_card_spectrum[i] > 0)
                {
                        oss << "Writing " << last_card_spectrum[i] << " spectra to detector card " << i << std::endl;
                        m_dae->writePOSLUTMemory(i, &(new_poslut[i * (maxmod * maxpos)]), maxmod * maxpos, status);
                }
        }
        delete []new_poslut;
        delete []last_card_spectrum;
        delete[] spec_lookup;
        delete ir;
        status.addInfo(FAC_DAE, oss.str());
        return status.result();
}

int ISISinstrumentControl::setVeto(const std::string& name, long enable, DAEstatus& status)
{
        ICPCritical cs(&m_crpt_cs);
        m_dae->setVeto(name, (enable != 0 ? true : false), status);
        return status.result();
}

int ISISinstrumentControl::evaluateExpression(std::map<std::string,double>& values, const std::string& expression, double& result, DAEstatus& status)
{
  using namespace mu;
  if (expression.size() == 0)
  {
          result = 1e38;
          return DAEstatus::Failure;
  }
  try
  {
          Parser p;
          std::string sexp(expression);
//        std::transform(sexp.begin(), sexp.end(), sexp.begin(), tolower);
          for(std::map<std::string,double>::iterator it = values.begin(); it != values.end() ; ++it)
          {
                  p.DefineVar(it->first.c_str(), &(it->second));
          }
          p.SetExpr(sexp);
      result = p.Eval();
          return DAEstatus::Success;
  }
  catch (Parser::exception_type& e)
  {
          status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "mu parser error: %s",  e.GetMsg().c_str());
          result = 1e38;
          return DAEstatus::Failure;
  }
}

int ISISinstrumentControl::getFramesAllPeriods(long* good_frames, long* raw_frames, int n, DAEstatus& status)
{
        if (n != m_crpt->nper)
        {
          status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "invalid number of periods");
          return DAEstatus::Failure;
        }
        isisU32_t igf, irf;
        if (m_crpt->period_type == ISISDAE::PeriodTypeSoftware)
        {
                // totals up to last pause
                for(int i=0; i<m_crpt->nper; i++)
                {
                        PERIOD& pi = m_crpt->period[i];
                        good_frames[i] = pi.good_frames;
                        raw_frames[i] = pi.total_frames;
                }
                // adjust for currrent running in period
                int period, daq_period;
                getCurrentPeriodNumber(period, daq_period, status);
                PERIOD* pc = &(m_crpt->period[period]);
                m_dae->getGoodFrames(&igf, status);
                m_dae->getRawFrames(&irf, status);
                good_frames[period] += (igf - m_crpt->good_frames);
                raw_frames[period] += (irf - m_crpt->total_frames);
        }
        else
        {
                for(int i=0; i<m_crpt->nper; i++)
                {
                        m_dae->getRawFramesPeriod(&irf, i, status);
                        m_dae->getGoodFramesPeriod(&igf, i, status);
                        good_frames[i] = igf;
                        raw_frames[i] = irf;
                }
        }
        return 0;
}

int ISISinstrumentControl::getUAmpHAllPeriods(float* good_uamph, float* raw_uamph, int n, DAEstatus& status)
{
        if (n != m_crpt->nper)
        {
          status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "invalid number of periods");
          return DAEstatus::Failure;
        }
        if (m_crpt->period_type == ISISDAE::PeriodTypeSoftware)
        {
                // totals up to last pause
                for(int i=0; i<m_crpt->nper; i++)
                {
                        PERIOD& pi = m_crpt->period[i];
                        good_uamph[i] = pi.good_uamph;
                        raw_uamph[i] = pi.total_uamph;
                }
                // adjust for currrent running in period
                int period, daq_period;
                getCurrentPeriodNumber(period, daq_period, status);
                PERIOD* pc = &(m_crpt->period[period]);
                float goodua = m_dae->getGoodUAmpHours(status);
                float totalua = m_dae->getRawUAmpHours(status);
                good_uamph[period] += (goodua - m_crpt->good_uamph);
                raw_uamph[period] += (totalua - m_crpt->total_uamph);
        }
        else
        {
                for(int i=0; i<m_crpt->nper; i++)
                {
                        good_uamph[i] = m_dae->getGoodUAmpHoursPeriod(i, status);
                        raw_uamph[i] = m_dae->getRawUAmpHoursPeriod(i, status);
                }
        }
        return 0;
}


boost::signals2::connection ISISinstrumentControl::registerOnRunStateChange(boost::function<void(BSTR)> func)
{
        return m_state_sig.connect(func);
}

void ISISinstrumentControl::fireOnRunStateChange(const char* state)
{
        Poco::NotificationCenter& nc = Poco::NotificationCenter::defaultCenter();
        nc.postNotification(new RunStateChangeNotification(state));
        m_state_sig(CT2OLE(state));
}




// append day name e.g. Mon, Tue  to filename
// also deletes next file in sequence to stop logs growing too much
std::string ISISinstrumentControl::getPostCommandLogName()
{
        Poco::Timespan one_day(1, 0, 0, 0, 0);
        std::string form = m_log_dir+"\\post_command_%s.log";
        Poco::LocalDateTime dateTime;  // current date and time
        std::string file = Poco::format(form.c_str(), Poco::DateTimeFormatter::format(dateTime,  "%w")); 
        dateTime += one_day;
        std::string next_file = Poco::format(form.c_str(), Poco::DateTimeFormatter::format(dateTime,  "%w"));
        if (_access(next_file.c_str(), 0) == 0)
        {
                remove(next_file.c_str());
        }
        return file;
}

int ISISinstrumentControl::updateSpecmapsFromDAE(const std::map<int,int>& trcn, DAEstatus& status)
{
        const ISISDAE::dae2spec_map_t& dae2specmap = m_dae->getDAE2Specmap();
        if (dae2specmap.size() > ISISCRPT_MAX_DC)
        {
                status.addVa(FAC_DAE,SEV_ERROR,ERRTYPE_OUTOFMEM, "updateSpecmapsFromDAE: too many cards %d", dae2specmap.size());
                return DAEstatus::Failure;
        }
        m_crpt->ndetcard = dae2specmap.size();
        std::transform(dae2specmap.begin(), dae2specmap.end(), m_crpt->dae2cardpos.c_array(), boost::bind(&ISISDAE::dae2spec_map_t::value_type::first, _1));
        std::map<int,int>::const_iterator tr_it;
        std::fill(m_crpt->cardpos2index.begin(), m_crpt->cardpos2index.end(), -1); 
        for(int i=0; i<m_crpt->ndetcard; ++i)
        {
                int pos = m_crpt->dae2cardpos[i];
                if (pos < 0 || pos >= m_crpt->cardpos2index.size())
                {
                        throw std::runtime_error("cardpos2index - pos too high");
                }
                m_crpt->cardpos2index[pos] = i;
                tr_it = trcn.find(pos);
                if (tr_it != trcn.end())
                {
                        m_crpt->dae2cardtr[i] = m_crpt->daeTR(tr_it->second);
                        m_crpt->dae2cardmode[i] = (m_crpt->isEventTR(tr_it->second) ? 1 : 0);
                }
                else
                {
                        m_crpt->dae2cardtr[i] = -1;  // card not being used by current wiring tables, so no TR information available
                        m_crpt->dae2cardmode[i] = -1;
                }
        }
        for(int i=0; i<m_crpt->ndetcard; ++i)
        {
                int pos = m_crpt->dae2cardpos[i];
                const ISISDAE::dae2spec_map_t::mapped_type& val = dae2specmap.find(pos)->second;
                if (val.size() > ISISCRPT_MAX_DC_DETECTOR)
                {
                        status.addVa(FAC_DAE,SEV_ERROR,ERRTYPE_OUTOFMEM, "updateSpecmapsFromDAE: too many spectra %d", val.size());
                        return DAEstatus::Failure;
                }
                m_crpt->dae2highspec[i] = val.size() - 1;   // spectrum numbers start at 0 
                std::copy(val.begin(), val.end(), m_crpt->dae2specmap[i]);
        }
        return DAEstatus::Success;
}

int ISISinstrumentControl::requestEndRunAfterNextSequenceCompletes(DAEstatus& status)
{
        if (isRunning())
        {
                return m_dae->requestEndRunAfterNextSequenceCompletes(status);
        }
        else
        {
                return DAEstatus::Success;
        }
}

bool ISISinstrumentControl::isFinalSequenceComplete(DAEstatus& status)
{
        return m_dae->isFinalSequenceComplete(status);
}

int ISISinstrumentControl::getSpectrumNumbersForTimeRegime(long tr, long& spec_min, long& spec_max, DAEstatus& status)
{
        spec_min = 1000000;
        spec_max = 0;
        if (tr >= 1 && tr <= m_crpt->ntrg)
        {
                spec_min = m_crpt->spec_min[tr-1];
                spec_max = m_crpt->spec_max[tr-1];
        }
        return DAEstatus::Success;
}

int ISISinstrumentControl::setRunStatusImp(long number, bool is_start, DAEstatus& status)
{ 
        if (se_set_run_state(m_crpt->run_number, runstatus_names[number], (is_start ? 1 : 0)) != 0)
        {
                status.addInfoVa(FAC_DAE, "Error from SQLITE: %s", se_get_errmsg());
        }
        m_crpt->run_status = number; 
        return DAEstatus::Success; 
} 


void ISISinstrumentControl::beamCurrentTimerCallback(Poco::Timer& t)
{
        ValueWithTimestamp<float> good_uamph;
//      static Poco::Timestamp last_call;
//      float good_uamph = getGoodUAmpH(m_status);
//      Poco::Timestamp now;
//      Poco::Timestamp::TimeDiff tdiff = now - last_call;
//      float good_uamp_diff = good_uamph - m_crpt->update_good_uamph;
//      m_crpt->beam_current = 3600.0 * (good_uamph - m_crpt->update_good_uamph) / tdiff;
//      m_crpt->update_good_uamph = good_uamph;
//      last_call = now;
}


Poco::Util::Application* InstrumentControlHolder::m_pApp = NULL;
std::string InstrumentControlHolder::m_icp_service_dir = "";
DAEreport_func_t* InstrumentControlHolder::m_func = NULL;
write_event_log_t* InstrumentControlHolder::m_event_func = NULL;
void* InstrumentControlHolder::m_report_arg = NULL;

std::string ISISinstrumentControl::m_instrument_xml_file = "c:\\data\\instrument.xml";
std::string ISISinstrumentControl::m_instrument_parameter_map_file = "c:\\data\\instrument_parameter_map.txt";