isisdae.cpp

Go to the documentation of this file.

/*
 *  This file contains the RIO interface that is callable from FORTRAN
 *
 *  Author:   Freddie Akeroyd
 */
#include "stdafx.h"

#include "DAEstatus.h"
#include "isisdae.h"
#include "detector_card.h"
#include "MuonDetectorCard.h"
#include "environment_card.h"
//#include "period_card.h"
#include "env_period_card.h"
#include "nivisa.h"
#include "vme_simulation.h"
#include "icputils.h"
#include "QxtrmInterface.h"


#define END_IMMEDIATELY_FILE "c:\\data\\end_now.dae"

#define ENV_FUNCTION(__func) \
        ( (m_envCards.size() > 0) ? (m_envCards[0]->__func) : \
      ((m_envPeriodCards.size() > 0) ? (m_envPeriodCards[0]->__func) : 0) )

#define PERIOD_FUNCTION(__func) \
      ((m_envPeriodCards.size() > 0) ? (m_envPeriodCards[0]->__func) : 0)         


class ClearHistogramMemoryTask : public Poco::Task
{
        DAEstatus& m_status;
        std::vector<DetectorCardIntf*>& m_detCards;
public:
        ClearHistogramMemoryTask(const std::string& name, std::vector<DetectorCardIntf*>& det_cards, DAEstatus& status) : Poco::Task(name), m_detCards(det_cards), m_status(status) { }

        void runTask()
        {
                m_status.addInfoVa(FAC_DAE, "Starting clear of DAE memory, thread ID %u", Poco::Thread::currentTid());
                int ncards = m_detCards.size();
                for(int i=0; i<ncards; ++i)
                {
                        m_detCards[i]->clearHistogramMemoryStart(m_status);
                }
                int ncomplete = 0;
                while(ncomplete < ncards)
                {
                        ncomplete = 0;
                        for(int i=0; i<ncards; ++i)
                        {
                                if (m_detCards[i]->isClearHistogramMemoryComplete(m_status))
                                {
                                        ++ncomplete;
                                }
                        }
                        setProgress((float)ncomplete / (float)ncards);
                        if (isCancelled())
                        {
                                m_status.addInfo(FAC_DAE, "Cancelled clear of DAE memory");
                                return;
                        }
                        if (ncomplete < ncards)
                        {
                                if (sleep(200)) // sleep returns true if we are cancelled
                                {
                                        m_status.addInfo(FAC_DAE, "Cancelled clear of DAE memory");
                                        return;
                                }
                        }
                }
                m_status.addInfo(FAC_DAE, "Finished clear of DAE memory");
        }

        void cancel()
        {
                Poco::Task::cancel();
        }
};

class ReadAllDAE1SpectraTask : public Poco::Task
{
        DAEstatus& m_status;
        DetectorCardIntf* m_dc;
        isisU32_t* m_buffer; 
        int m_nbuffer; 
        const int* m_spec_to_crpt_offset;
        int m_persize;

public:
        ReadAllDAE1SpectraTask(const std::string& name, DetectorCardIntf* dc, isisU32_t* buffer, int nbuffer, 
                const int* spec_to_crpt_offset, int persize, DAEstatus& status) : Poco::Task(name), m_dc(dc), m_buffer(buffer), m_nbuffer(nbuffer), 
                        m_spec_to_crpt_offset(spec_to_crpt_offset), m_persize(persize), m_status(status) { }

        void runTask()
        {
//              m_status.addInfoVa(FAC_DAE, "Starting ReadAllDAE1SpectraTask, thread id %u", Poco::Thread::currentTid());
//              setProgress(0.0);
                m_dc->readAllDAE1Spectra(m_buffer, m_nbuffer, m_spec_to_crpt_offset, m_persize, m_status);  // doesn't read spectrum 0
//              setProgress(100.0);
//              cannot use isCancelled() at moment
//              m_status.addInfo(FAC_DAE, "Finished ReadAllDAE1SpectraTask");
        }

        void cancel()
        {
                Poco::Task::cancel();
        }
};


ISISDAE::ISISDAE(DAEType type, DAEstatus& status, bool endian_workaround, bool simulate) : 
  m_lenAddmap(0), m_dae_type(type), m_period_mode(ISISDAE::PeriodTypeSoftware), m_simulate(simulate),
          m_num_async_requests(0),m_async_complete_event(NULL), m_uamp_scale(1.0),m_event_mode(false)
{
//      m_dae_type = UnknownDAE;
        setLoggerName("ISISDAE");
        LOGSTR_INFORMATION("Creating DAE");
        static SECURITY_ATTRIBUTES sec_attr = { sizeof(SECURITY_ATTRIBUTES), NULL, FALSE };
        InitializeCriticalSection(&m_dae_cs);
        switch(m_dae_type)
        {
                case MuonDAE2:
                case MuonDAE3:
                        m_clock_frequency = 2;  // 2GHz
                        break;
                case NeutronDAE2:
                case NeutronDAE3:
                        m_clock_frequency = 32; // 32 Mhz
                        break;
                default:
                        m_clock_frequency = 32;
                        break;
        }
        NIVisa::setEndianWorkaround(endian_workaround);
        m_addmap = new Addmap[DAE2DetCardPolicy::DAESPECMAX];
        m_async_complete_event = CreateEvent(&sec_attr, FALSE, FALSE, NULL);
        const Poco::AbstractObserver& on_progress = Poco::Observer<DAEProgressHandler, Poco::TaskProgressNotification>(m_task_ph, &DAEProgressHandler::onProgress);
        const Poco::AbstractObserver& on_finished = Poco::Observer<DAEProgressHandler, Poco::TaskFinishedNotification>(m_task_ph, &DAEProgressHandler::onFinished);
        m_taskmgr.addObserver(on_progress);
        m_taskmgr.addObserver(on_finished);
}

template <typename T>
static void deletePtr(T* pCard)
{
        delete pCard;
}

ISISDAE::~ISISDAE()
{
        DAEstatus status;
        const Poco::AbstractObserver& on_progress = Poco::Observer<DAEProgressHandler, Poco::TaskProgressNotification>(m_task_ph, &DAEProgressHandler::onProgress);
        const Poco::AbstractObserver& on_finished = Poco::Observer<DAEProgressHandler, Poco::TaskFinishedNotification>(m_task_ph, &DAEProgressHandler::onFinished);
        m_taskmgr.removeObserver(on_progress);
        m_taskmgr.removeObserver(on_finished);
        close(status);
        std::for_each(m_detCards.begin(), m_detCards.end(), deletePtr<DetectorCardIntf>);
        std::for_each(m_envCards.begin(), m_envCards.end(), deletePtr<EnvironmentCardIntf>);
        std::for_each(m_envPeriodCards.begin(), m_envPeriodCards.end(), deletePtr<EnvPeriodCardIntf>);
        std::for_each(m_vme.begin(), m_vme.end(), deletePtr<ISISVME>);
        delete []m_addmap;
        m_addmap = 0;
        DeleteCriticalSection(&m_dae_cs);
        CloseHandle(m_async_complete_event);
}

int ISISDAE::waitForAsync()
{
        bool done = false;
        while(!done)
        {
                // use an explicit timeout - might be you get two SetEvents at same time and miss something?
                DWORD ret = WaitForSingleObject(m_async_complete_event, 10000 /*INFINITE*/ );
                if ((ret == WAIT_OBJECT_0) && (m_num_async_requests == 0))
                {
                        done = true;
                }
                if ((ret == WAIT_TIMEOUT) && (m_num_async_requests == 0))
                {
                        done = true;
                }
        }
        return 0;
}

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


DWORD __stdcall ISISDAE::readDCHistogramThread(void* arg)
{
        histogram_async_t* his = (histogram_async_t*)arg;
        his->dc->readHistogramMemory(his->start, his->buffer, his->len, his->status);
        his->dae->doneAsync();
        delete his;
        return 0;
}

int ISISDAE::readDCHistogramAsync(DetectorCardIntf* dc, unsigned long start, isisU32_t* buffer, int len,  DAEstatus& dstatus)
{
        histogram_async_t* arg = new histogram_async_t(this, dc, start, buffer, len, dstatus);
        InterlockedIncrement(&m_num_async_requests);
        if (QueueUserWorkItem(readDCHistogramThread, arg, WT_EXECUTEDEFAULT) != 0)
        {
                return DAEstatus::Success;
        }
        else
        {
                InterlockedDecrement(&m_num_async_requests);
                return DAEstatus::Failure;
        }
}


int ISISDAE::changePeriod(int period, int daq_period, DAEstatus& status)
{
        ICPCritical cs(&m_dae_cs);
        for(det_list_t::iterator it = m_detCards.begin(); it != m_detCards.end(); ++it)
        {
                (*it)->changePeriod(daq_period, status);
        }
        return 0;
}

int ISISDAE::changeNumberOfPeriods(int nperiod, DAEstatus& status)
{
        ICPCritical cs(&m_dae_cs);
        for(det_list_t::iterator it = m_detCards.begin(); it != m_detCards.end(); ++it)
        {
                (*it)->changeNumberOfPeriods(nperiod, status);
        }
        return 0;
}

void ISISDAE::printStatus(std::ostream& os, DAEstatus& status)
{
        int i;
    os << "VME DAE with " << m_envCards.size() << " ENVIRONMENT card(s), "
           << m_envPeriodCards.size() << " ENVPERIOD card(s) and "
           << m_detCards.size() << " DETECTOR card(s)\n";
        os << "Number of DAE crates = " << m_vme.size() << "\n";
        os << "DAE Type = " << DAEType_desc[m_dae_type] << std::endl;
        os << "Period mode = " << PeriodType_desc[m_period_mode] << std::endl;
    os << "Number of DAE1 spectra = " << m_lenAddmap << "\n";
        os << "UAmp scale = " << m_uamp_scale << "\n";
        for(i=0; i<m_envCards.size(); i++)
        {
                m_envCards[i]->printStatus(os, status);
        }
        for(i=0; i<m_envPeriodCards.size(); i++)
        {
                m_envPeriodCards[i]->printStatus(os, status);
        }
        for(i=0; i<m_detCards.size(); i++)
        {
                m_detCards[i]->printStatus(os, status);
//              m_detCards[i]->printPOSLUT(os, status);
        }
//      printAddmap(os, status);
}

void ISISDAE::printAddmap(std::ostream& os, DAEstatus& )
{
        int i;
        os << "DAE Address map" << std::endl;
        os << "dae1_spec dae1_add dae2_card dae2_spec dae2_add dae2_len" << std::endl;
        for(i=0; i<m_lenAddmap; i++)
        {
                os << i << " " << m_addmap[i].dae1add << " " << m_addmap[i].card 
                        << " " << m_addmap[i].spec << " " << m_addmap[i].dae2add << " " << m_addmap[i].len << "\n";
        }
}

void ISISDAE::printSpectrum(int spec, std::ostream& os, DAEstatus& status)
{
        isisU32_t i, nchan;
        getSpectrumSize(spec, &nchan, status);
        isisU32_t* buffer = new isisU32_t[nchan];
        isisU32_t* tcb = new isisU32_t[nchan];
        readDAE1Spectrum(spec, buffer, nchan, status);
// readHistogramMemory(4*spec*nchan, buffer, nchan)
        getTimeChannels(spec, tcb, nchan-1, status);
        os << "Spectrum " << spec << "\n";
        os << "Channel 0 contains " << buffer[0] << " counts" << "\n";
        for(i=0; i < nchan-1; i++)
        {
                os << (double)tcb[i] / (double)m_clock_frequency << " - " << (double)tcb[i+1] / m_clock_frequency << " = " << buffer[i+1] << "\n";
        }
        delete []buffer;
        delete []tcb;
}

int ISISDAE::getSpectrumSize(int spec, isisU32_t* nchan, DAEstatus& status)
{
        DetectorCardIntf* dc = getDCForSpectrum(spec);
        return (dc != NULL ? dc->getSpectrumSize(nchan, status) : 0); 
}

int ISISDAE::getNTimeChannels(int spec, isisU32_t* ntc, DAEstatus& status)
{
        DetectorCardIntf* dc = getDCForSpectrum(spec);
        return (dc != NULL ? dc->getNTimeChannels(ntc, status) : 0); 
}

int ISISDAE::getTimeChannels(int spec, isisU32_t* tcb, int ntc, DAEstatus& status)
{
        DetectorCardIntf* dc = getDCForSpectrum(spec);
        return (dc != NULL ? dc->getTimeChannels(tcb, ntc, status) : 0); 
}

int ISISDAE::setTimeChannels(int crat, int start[], int nbound[], 
                                                                  int step[], int nblocks, DAEstatus& status)
{
        int ntcb, i, j, k;
        ntcb = 0;
        for(i=0; i<nblocks; i++)
        {
                ntcb += nbound[i];
        }
        isisU32_t* tcb = new isisU32_t[ntcb];
        k = 0;
        for(i=0; i<nblocks; i++)
        {
                for(j=0; j<nbound[i]; j++)
                {
                        tcb[k++] = start[i] + j * step[i];
                }
        }
        setTimeChannels(crat, tcb, ntcb-1, status);
        delete[] tcb;
        return 0;
}

// tcb array is size ntc+1 i.e. array of boundaries
int ISISDAE::setTimeChannels(int crat, isisU32_t* tcb, int ntc, DAEstatus& status)
{
        DetectorCardIntf* dc = findDetectorCard(crat, status);
        if (dc != NULL)
        {
                dc->setTimeChannels(tcb, ntc, status);
        }
        else
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Cannot find card for crate %d", crat);
        }
        return 0;
}

int ISISDAE::clearPOSLUTMemory(DAEstatus& status)
{
        int i;
        for(i=0; i<m_detCards.size(); i++)
        {
                m_detCards[i]->clearPOSLUTMemory(status);
        }
        return 0;
}

int ISISDAE::programDAE1POSLUT(int crat[], int maxcrate, int modn[], 
                                                                int mpos[], int spec[], int ndet, 
                                                                int nper_daq, DAEstatus& status)
{
        int i, specmax, dae1persize;
        DetectorCardIntf* dc;
        specmax = 0;
        for(i=0; i<ndet; i++)
        {
                if (specmax < spec[i])
                {
                        specmax = spec[i];
                }
        }
        if (m_dae_type == ISISDAE::MuonDAE2 || m_dae_type == ISISDAE::MuonDAE3)
        {
                dae1persize = specmax + 1;      // spectrum 0 is at end
        }
        else
        {
                dae1persize = specmax + 1;
        }
        int* crate_used = new int[maxcrate+1];
        for(i=0; i<=maxcrate; i++)
        {
                crate_used[i] = 0;
        }
        for(i=0; i<ndet; i++)
        {
                crate_used[crat[i]] = 1;
        }
        for(i=0; i<=maxcrate; i++)
        {
                dc = findDetectorCard(i,status);
                if ( (dc == 0) && (crate_used[i] == 1) )
                {
                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_INVCARD,"Attempt to use missing detector card/crate %d", i);
                }
        }
        delete []crate_used;
        for(i=0; i<m_detCards.size(); i++)
        {
                m_detCards[i]->programDAE1POSLUT(crat, modn, mpos, spec, ndet, nper_daq, dae1persize, status);
        }
        updateAddmap(status);
        return 0;
}

int ISISDAE::programPOSLUT(int cards[], int dims[], int pos_start[], 
                                                   int npos[], int spec[], int spec_step[], 
                                                   int nblocks, DAEstatus& status)
{
        int i;
        for(i=0; i<m_detCards.size(); i++)
        {
                m_detCards[i]->programPOSLUT(cards, dims, pos_start, npos, spec, spec_step, nblocks, 1, 0, status);
        }
        updateAddmap(status);
        return 0;
}

int ISISDAE::updateAddmap(DAEstatus& status)
{
        int i, j, len_used;
        isisU32_t nchan;
//      int len_specmap;
        m_lenAddmap = 0;
        memset(m_addmap, 0, DAE2DetCardPolicy::DAESPECMAX*sizeof(MyAddmap));
        for(i=0; i<m_detCards.size(); i++)
        {
                len_used = m_detCards[i]->fillAddmap(m_addmap, DAE2DetCardPolicy::DAESPECMAX, status);
                if (len_used > m_lenAddmap)
                {
                        m_lenAddmap = len_used;
                }
        }
        // muons have no real spectrum 0 so we might need to invent one
        if ( (m_addmap[0].dc == NULL) && (m_detCards.size() > 0) )
        {
                status.addInfo(FAC_DAE, "adding spec 0");
                m_detCards[0]->getSpectrumSize(&nchan, status);
                m_addmap[0].card = m_detCards[0]->position();
                m_addmap[0].dae1add = 0;
                m_addmap[0].dae2add = 0;
                m_addmap[0].dc = m_detCards[0];
                m_addmap[0].len = nchan;
                m_addmap[0].spec = 0;
        }
        m_dae1_spec_map.clear();
        m_dae2_spec_map.clear();
        for(i=0; i<m_detCards.size(); i++)
        {
                DetectorCardIntf* dc = m_detCards[i];
                int pos = dc->position();
                const int* spec_map = dc->getDAE2SpecMap();
                m_dae2_spec_map[pos].resize(dc->highspec() + 1);
                std::vector<int>& vec = m_dae2_spec_map[pos];
                for(j=0; j <= dc->highspec(); ++j)
                {
                        vec[j] = spec_map[j];
                        if ( spec_map[j] != DetectorCardIntf::NOSPECTRUM )
                        {
                                m_dae1_spec_map[ spec_map[j] ] = spec_map_info(dc, dc->position(), j);
                        }
                }
        }
#if 0
        len_specmap = m_nDetCards * (3+DAESPECMAX);
        int *specmap_array = new int[len_specmap];
        int offset = 0;
        for(i=0; i<m_nDetCards; i++)
        {
                offset = m_detCards[i]->saveDAE2SpecmapToArray(specmap_array, offset, len_specmap);
        }
        FILE* f = fopen("c:\\daevme_specmap.dat", "wb");
        if (f != NULL)
        {
                if (fwrite(specmap_array, sizeof(int), offset, f) != offset)
                {
                        *m_pErr << "Error updating addmap" << std::endl;
                };
                fclose(f);
        }
        else
        {
                *m_pErr << "error updating addmap" << std::endl;
        }
        delete []specmap_array;
#endif /* 0 */
        return 0;
}

int ISISDAE::readDAE1Spectrum(int dae1_spectrum, isisU32_t* buffer, int nbuffer, DAEstatus& status)
{
        int i, j;
        isisU32_t* tmp_buffer;
// spectrum 0 is special in that it is a junk spectrum which exists on all cards
        if (dae1_spectrum == 0)
        {
                memset(buffer, 0, nbuffer * sizeof(isisU32_t));
                tmp_buffer = new isisU32_t[nbuffer];
                for(i=0; i<m_detCards.size(); i++)
                {
                        if (m_detCards[i]->readDAE1Spectrum(0, tmp_buffer, nbuffer, status) != -1)
                        {
                                for(j=0; j<nbuffer; j++)
                                {
                                        buffer[j] += tmp_buffer[j];
                                }
                        }
                }
                delete[] tmp_buffer;
                return 0;
        }
// standard spectrum, number unique across all cards
        for(i=0; i<m_detCards.size(); i++)
        {
                if (m_detCards[i]->readDAE1Spectrum(dae1_spectrum, buffer, nbuffer, status) != -1)
                {
                        return 0;
                }
        }
//      std::cerr << "Spectra not found " << dae1_spectrum << std::endl;
        return -1;
}


int ISISDAE::readDAE1Spectra(isisU32_t* buffer, int nbuffer, int spec_to_crpt_offset[], int spec_start, int nspec, int period, int persize, DAEstatus& status)
{
        isisU32_t nchan, spec0 = 0;
        if (spec_start == 0)
        {
                spec0 = 1;
        }
        for(int i=0; i<m_detCards.size(); i++)
        {
                m_detCards[i]->readDAE1Spectra(buffer, nbuffer, spec_to_crpt_offset, spec_start + spec0, nspec - spec0, period, persize, status); 
        }
// re-read and correct spectrum 0
        if (spec_start == 0)
        {
                getSpectrumSize(0, &nchan, status);
                if ( nchan != spec_to_crpt_offset[1] )
                {
                        status.addInfoVa(FAC_DAE, "Correcting spectrum 0 size from %d to %d", nchan, spec_to_crpt_offset[1]);
                        nchan = spec_to_crpt_offset[1];
                }
                readDAE1Spectrum(0, buffer, nchan, status);
        }
        return 0;
}

int ISISDAE::readAllDAE1Spectra(isisU32_t* buffer, int nbuffer, int spec_to_crpt_offset[], int persize, DAEstatus& status)
{
        int i;
        isisU32_t nchan;
        for(i=0; i<m_detCards.size(); i++)
        {
                m_taskmgr.start(new ReadAllDAE1SpectraTask(Poco::format("ReadAllDAE1Spectra %d", i), m_detCards[i], 
                                                        buffer, nbuffer, spec_to_crpt_offset, persize, status)); // doesn't read spectrum 0
        }
        pollUntilTasksComplete(m_taskmgr, 200);
// re-read and correct spectrum 0
        getSpectrumSize(0, &nchan, status);
        if ( nchan != spec_to_crpt_offset[1] )
        {
                status.addInfoVa(FAC_DAE, "Correcting spectrum 0 size from %d to %d", nchan, spec_to_crpt_offset[1]);
                nchan = spec_to_crpt_offset[1];
        }
        readDAE1Spectrum(0, buffer, nchan, status);
        // check
        if (Poco::Util::Application::instance().config().getBool("isisicp.testHistogramCheck", false))
        {
                DAEstatus stat;
                isisU32_t* dat1 = new isisU32_t[nbuffer];
                memset(dat1, 4, nbuffer*sizeof(isisU32_t));
                readHistogramMemory(0, dat1, nbuffer, stat);
                compareBuffers("readHistogramMemory", dat1, buffer, nbuffer, status);
                memset(dat1, 4, nbuffer*sizeof(isisU32_t));
                int nperiod = nbuffer / persize;
                int perspec = (1 + m_dae1_spec_map.rbegin()->first) / nperiod;   // dae1specmap contains spectra for higher periods
                for(i=0; i < nperiod; ++i)
                {
                        readDAE1Spectra(dat1, nbuffer, spec_to_crpt_offset, 0, perspec, i, persize, status);
                }
                compareBuffers("readDAE1Spectra", dat1, buffer, nbuffer, status);
                memset(dat1, 4, nbuffer*sizeof(isisU32_t));
                readDAE1Spectra(dat1, nbuffer, spec_to_crpt_offset, 0, perspec*nperiod, 0, persize, status);
                compareBuffers("readDAE1Spectra2", dat1, buffer, nbuffer, status);
                delete[] dat1;
        }
        return 0;
}


isis32_t ISISDAE::openBackplane(const char* dae_name_bp, DAEstatus& status)
{
        status.addInfoVa(FAC_DAE, "Opening connection to VISA resource %s\n", dae_name_bp);
        ISISVME* vme = m_vme.front();
        vme->openBackplane(dae_name_bp, status);
        vme->setTriggerFunc(&ISISDAE::daeTriggerFunc, this);
        return ISISVME::Success;
}

isis32_t ISISDAE::open(const char* dae_name, DAEstatus& status)
{
        bool dae3 = (m_dae_type == NeutronDAE3 || m_dae_type == MuonDAE3);
        LOGSTR_INFORMATION("Opening connection to VISA resource " << dae_name);
        status.addInfoVa(FAC_DAE, "Opening connection to VISA resource %s\n", dae_name);
        if (m_simulate)
        {
                status.addInfo(FAC_DAE, "Created VME simulation DAE");
                if (dae3)
                {
                        m_vme.push_back(new VMESimulation<DAE3Policy>(status));
                }
                else
                {
                        m_vme.push_back(new VMESimulation<DAE2Policy>(status));
                }
        }
        else
        {
                if (dae3)
                {
                        m_vme.push_back(new QxtrmInterface(status));
                }
                else
                {
                        m_vme.push_back(new NIVisa(status));
                }
        }
        ISISVME* vme = m_vme.back();
        int dae_number = static_cast<int>(m_vme.size() - 1);   // first dae is 0
        if (vme->initOK())
        {
//              vme->resetBus();
                if (getenv("ISISVME_SCANBUS") != NULL)
                {
                        int i = vme->scanBus(status);
                        if (i < 3)
                        {
                                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_NODAE, 
                                        "SCAN ERROR - there should be 3 VXI?::*::INSTR devices on the VME bus\n"
                                        "You must add a dummy device covering the whole A32 address range\n"
                                        "Using the T&M explorer National Instruments program");
                        }
                }
                else
                {
                                status.addInfo(FAC_DAE, "ScanBus skipped - set ISISVME_SCANBUS environment variable to enable");
                }
        }
    vme->open(dae_name, status);
        if (dae3)
        {
                locateCards<DAE3Policy>(vme, dae_number, status);
        }
        else
        {
                locateCards<DAE2Policy>(vme, dae_number, status);
        }
        return vme->lockDevice(5, status);
}

// trig_id   8 is frame sync, 9 is run
int ISISDAE::daeTriggerFunc(void* arg, time_t the_secs, unsigned short the_ms, int trig_id)
{
        static long frame_count = 0;
        static long run_count = 0;
        ISISDAE* the_dae = (ISISDAE*)arg;
        if (trig_id == 8) // frame sync
        {
                ++frame_count;
        }
        if (trig_id == 9) // run bit
        {
                ++run_count;
        }
        return DAEstatus::Success;
}

isis32_t ISISDAE::check(DAEstatus& status)
{
        size_t i;
        if ( (i = m_envCards.size() + m_envPeriodCards.size()) != 1 )
        {
                status.addVa(FAC_DAE, SEV_FATAL, ERRTYPE_INVCARD, 
                        "Error - Found %u environment cards (must have 1) and %u detector cards", i, m_detCards.size());
                return DAEstatus::Failure;
        }
        if ( (i = m_envPeriodCards.size()) > 1 )
        {
                status.addVa(FAC_DAE, SEV_FATAL, ERRTYPE_INVCARD, 
                        "Error - Found %u period cards (only 0 or 1 allowed) and %u detector cards", i,  m_detCards.size());
                return DAEstatus::Failure;
        }
        return DAEstatus::Success;
}


isis32_t ISISDAE::close(DAEstatus& status)
{
//      std::for_each(m_vme.begin(), m_vme.end(), std::bind2nd(std::mem_fun(&ISISVME::unLock),status));
        for(vme_list_t::iterator it = m_vme.begin(); it != m_vme.end(); ++it)
        {
                (*it)->unlockDevice(status);
                (*it)->close(status);
        }
        //      m_vme->unLock(status);
        return status.result();
}

template <class DAEPolicy>
int ISISDAE::locateCards(ISISVME* vme, int dae_number, DAEstatus& status)
{
        typedef DAE2Card<DAEPolicy::card_t> MyDAE2Card;
        DAE2CardIntf::CardType card_type;
        int i, j, len_specmap = 0, num_neutron_dc = 0, num_muon_dc = 0;

//      struct stat st;
        int *specmap_array = 0;
        std::ostringstream message;
#if 0
        FILE* f = fopen("c:\\daevme_specmap.dat", "rb");
        if (f != NULL)
        {
                if (fstat(fileno(f), &st) == 0)
                {
                    len_specmap = st.st_size / sizeof(int);
                    specmap_array = new int[len_specmap];
                    std::cerr << "Reading saved specmap length " << len_specmap << std::endl; 
                    fread(specmap_array, sizeof(int), len_specmap, f);
                }
                fclose(f);
        }
        else
        {
                std::cerr << "No previous daevme_specmap.dat found" << std::endl;
        }
#endif /* 0 */
         // 4 bits are allocated for card ID -> 16 cards max
        
        for(j=0; j<16; j++)
        {
                i = j + MyDAE2Card::CRATE_MOD * dae_number;
                if (MyDAE2Card::isCardPresent(i, vme, status))
                {
                        message << "Card " << j << " is present on dae " << dae_number << " (" << vme->device() << ")";
                        card_type = MyDAE2Card::getCardType(i, vme, status);
                        switch(card_type)
                        {
                                message << "(" << MyDAE2Card::card_type; 
                                case MyDAE2Card::EnvCard:
                                        message << " Environment card)\n";
                                        m_envCards.push_back(new EnvironmentCard<DAEPolicy::env_t>(i, vme, status));
                                        break;

                                case MyDAE2Card::NeutronDetectorCard:
                                        message << " Neutron Detector card)\n";
                                        m_detCards.push_back(new DetectorCard<DAEPolicy::det_t>(i, vme, specmap_array, len_specmap, status));
                                        m_es.addCard(m_detCards.back());
                                        ++num_neutron_dc;
                                        break;

                                case MyDAE2Card::MuonDetectorCard:
                                        message << " Muon Detector card)\n";
                                        m_detCards.push_back(new MuonDetectorCard(i, vme, specmap_array, len_specmap, status));
                                        ++num_muon_dc;
                                        break;

                                case MyDAE2Card::EnvPeriodCard:
                                        message << " Combined Environment and Period card)\n";
                                        m_envPeriodCards.push_back(new EnvPeriodCard<DAEPolicy::env_t>(i, vme, status));
                                        break;

                                default:
                                        message << " *UNKNOWN*)\n";
                                        break;
                        }
                }
        }
        status.addInfo(FAC_DAE, message.str());
        if (specmap_array != 0)
        {
                delete []specmap_array;
        }
        if ( (num_muon_dc > 0) && (num_neutron_dc > 0) )  // mixing neutron and muon detector cards is not allowed
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ERROR: Found both muon and neutron detector cards in DAE");
        }
//      if (m_envCards[0]->isRunning())
//      {
//              m_envCards[0]->stopRun();
//              recreatemap();          /* create DAE-I to DAE-II map from POSLUTs */
//              m_envCards[0]->startRun();
//
//  }
//    else
//    {
//              m_envCards[0]->resetRunController();
//        defaultmap();           /* create default DAE-I to DAE-II map */
//    }
        return 0;
}

int ISISDAE::clearHistogramMemory(DAEstatus& status)
{
        m_taskmgr.start(new ClearHistogramMemoryTask("clear", m_detCards, status));
        pollUntilTasksComplete(m_taskmgr, 200);
        return 0;
}

int ISISDAE::clearCounters(int run_number, DAEstatus& status)
{
        clearCounters(status);
        if (m_event_mode)
        {
                m_es.setOutputFileName(run_number, true, status);
        }
        else
        {
                m_es.closeAndDeleteOutputFile(run_number, status);   // clear out any old event files
        }
        return 0;
}

int ISISDAE::clearCounters(DAEstatus& status)
{
        clearFramesVetosAndPPP(status);
        clearTotalCountsRegisters(status);
        return 0;
}

int ISISDAE::startRun(bool clear_counters, int run_number, time_t& start_time, DAEstatus& status)
{
        remove(END_IMMEDIATELY_FILE);
        if (clear_counters)
        {
                clearCounters(run_number, status);
        }
        if (m_event_mode)
        {
                PERIOD_FUNCTION(enableEventMode(status));
        }
        else
        {
                PERIOD_FUNCTION(disableEventMode(status));
        }
        if (m_event_mode)
        {
                m_es.setOutputFileName(run_number, clear_counters, status);
                m_es.start();
        }
        else
        {
                 m_es.closeAndDeleteOutputFile(run_number, status);   // clear out any old event files
        }
        time(&start_time);
        ENV_FUNCTION(startRun(status));
        return 0;
}

void ISISDAE::closeEventFiles(DAEstatus& status)
{
        m_es.closeOutputFile(status);
}

int ISISDAE::stopRun(StopRunMode mode, DAEstatus& status)
{
        std::ostringstream message;
        unsigned per_seq_check_counter = 0;
    int i;
        uint64_t nremain = 0;
        FILE* f;
        isisU32_t value, total_veto;
        bool early_exit = false;
        if ( (m_period_mode == ISISDAE::PeriodTypeHardwareInternal) || (m_period_mode == ISISDAE::PeriodTypeHardwareExternal) )
        {
                if ( (mode == StopRunClean) && (m_envPeriodCards.size() > 0) )
                {
                        PERIOD_FUNCTION(endRunAfterSequenceCompletes(status));
                        while(!early_exit && !(PERIOD_FUNCTION(isRunEndedAndSequenceComplete(status))))
                        {
                                Sleep(500);
                                ++per_seq_check_counter;
                                if ( per_seq_check_counter % 120 == 0 )
                                {
                                        LOGSTR_WARNING("Still waiting for period card to complete hardware period sequence - restart and use  END/IMMEDIATE  to finish early");
                                }
                                f = _fsopen(END_IMMEDIATELY_FILE, "rN", _SH_DENYNO);
                                if (f != NULL)
                                {
                                        fclose(f);
                                        early_exit = true;
                                }
                        }
                }
                PERIOD_FUNCTION(abortSequenceCompleteWait(status));
        }
        remove(END_IMMEDIATELY_FILE);
        ENV_FUNCTION(stopRun(status));
        if (m_event_mode)
        {
                nremain = m_es.nNewEventWords(status);
                if ( mode == StopRunClean || mode == StopRunFast )
                {
                        for(i = 0; (i < 250) && ( (nremain = m_es.nNewEventWords(status)) > 0 ); ++i)
                        {
//                      LOGSTR_INFORMATION("... still reading DAE, remaining unread events = " << nremain);
                                Poco::Thread::sleep(200);
                        }
//      wait long enough to clear a whole DAE of event data (worse possible case) 
//                      for(i = 0; (i < 3000) && (m_es.nNewEventWords(status) > 0); ++i)
//                      {
//                              Poco::Thread::sleep(200);
//                      }
                        if (nremain > 0)
                        {
                                LOGSTR_WARNING("Unread events in DAE " << nremain);
                        }
                }
                else
                {
                        LOGSTR_INFORMATION("StopRunDiscard mode - ignoring unread dae data events " << nremain);
                }
                // need to wait long enough for last block of events from above to get processes
                if ( mode == StopRunClean )
                {
                        for(i = 0; (i < 100) && !m_es.endHeaderSeen(); ++i)
                        {
                                Poco::Thread::sleep(200);
                        }
                        if (!m_es.endHeaderSeen())
                        {
                                LOGSTR_WARNING("No end header seen");
                        }
                }
                else
                {
                        Poco::Thread::sleep(1000); // but give chance for end header to appear
                        LOGSTR_INFORMATION("Not StopRunClean mode - not waiting for event mode end run header, present=" << (m_es.endHeaderSeen() ? "YES" : "NO") );
                }
                m_es.stop( false  );    
        }
        total_veto = value = 0;
        std::string veto_text;
        getVetoStatus(veto_text, status);
        message << veto_text << "\n";
        ENV_FUNCTION(getSMPVetoedFrames(&value, status));
        total_veto += value;
        ENV_FUNCTION(getExternalVetoedFrames(0, &value, status));
        total_veto += value;
        ENV_FUNCTION(getFIFOVetoedFrames(&value, status));
        total_veto += value;
        ENV_FUNCTION(getTS2PulseVetoedFrames(&value, status));
        total_veto += value;
        ENV_FUNCTION(getISIS50HzVetoedFrames(&value, status));
        total_veto += value;
        ENV_FUNCTION(getFChopperVetoedFrames(0, &value, status));
        total_veto += value;
        for(i=0; i<m_detCards.size(); i++)
        {
                m_detCards[i]->printVetoStatus(message, true, status);
        }
        if (m_envPeriodCards.size() > 0)
        {
                m_envPeriodCards[0]->getInternalVetoedFrames(&value, status);
//              message << "Internal vetoed frames = " << value << "\n";
                total_veto += value;
        }
//      message << "TOTAL of VETO counters from all sources = " << total_veto << "\n";
        status.addInfo(FAC_DAE, message.str());
        return 0;
}

int ISISDAE::resetRunController(DAEstatus& status)
{
        return ENV_FUNCTION(resetRunController(status));
}

//int ISISDAE::clearPPP(DAEstatus& status)
//{
//      return m_envCards[0]->clearPPP(status);
//}

int ISISDAE::getRawFrames(isisU32_t* value, DAEstatus& status)
{
    return ENV_FUNCTION(getRawFrames(value, status));
}

int ISISDAE::getRawFramesPeriod(isisU32_t* value, int period, DAEstatus& status)
{
        if ((m_period_mode != ISISDAE::PeriodTypeSoftware) /* && (m_periodCards.size() > 0) */)
        {
                return PERIOD_FUNCTION(getPeriodRawFrames(period, value, status));
        }
        else
        {
                *value = 0;
                return ISISVME::Success;
        }
}

int ISISDAE::getGoodFramesPeriod(isisU32_t* value, int period, DAEstatus& status)
{
        if ((m_period_mode != ISISDAE::PeriodTypeSoftware) /* && (m_periodCards.size() > 0)*/ )
        {
                return PERIOD_FUNCTION(getPeriodGoodFrames(period, value, status));
        }
        else
        {
                *value = 0;
                return ISISVME::Success;
        }
}

int ISISDAE::getGoodFrames(isisU32_t* value, DAEstatus& status)
{
    return ENV_FUNCTION(getGoodFrames(value, status));
}

int ISISDAE::getRawPPPLower(isisU32_t* value, DAEstatus& status)
{
        return ENV_FUNCTION(getRawPPPLower(value, status));
}

int ISISDAE::getRawPPPUpper(isisU32_t* value, DAEstatus& status)
{
        return ENV_FUNCTION(getRawPPPUpper(value, status));
}

int ISISDAE::getGoodPPPLower(isisU32_t* value, DAEstatus& status)
{
        return ENV_FUNCTION(getGoodPPPLower(value, status));
}

int ISISDAE::getGoodPPPUpper(isisU32_t* value, DAEstatus& status)
{
        return ENV_FUNCTION(getGoodPPPUpper(value, status));
}

float ISISDAE::getRawUAmpHoursPeriod(int period, DAEstatus& status)
{
        if (m_envPeriodCards.size() > 0)
        {
                return m_envPeriodCards[0]->getRawUAmpHoursPeriod(period, status) * m_uamp_scale;
        }
        else
        {
                return 0.0;
        }
}

float ISISDAE::getGoodUAmpHoursPeriod(int period, DAEstatus& status)
{
        if (m_envPeriodCards.size() > 0)
        {
                return m_envPeriodCards[0]->getGoodUAmpHoursPeriod(period, status) * m_uamp_scale;
        }
        else
        {
                return 0.0;
        }
}

int ISISDAE::getRawPPPLowerPeriod(int period, isisU32_t* value, DAEstatus& status)
{
        if (m_envPeriodCards.size() > 0)
        {
                return m_envPeriodCards[0]->getRawPPPLowerPeriod(period, value, status);
        }
        else
        {
                *value = 0;
                return DAEstatus::Failure;
        }
}

int ISISDAE::getRawPPPUpperPeriod(int period, isisU32_t* value, DAEstatus& status)
{
        if (m_envPeriodCards.size() > 0)
        {
                return m_envPeriodCards[0]->getRawPPPUpperPeriod(period, value, status);
        }
        else
        {
                *value = 0;
                return DAEstatus::Failure;
        }
}

int ISISDAE::getGoodPPPLowerPeriod(int period, isisU32_t* value, DAEstatus& status)
{
        if (m_envPeriodCards.size() > 0)
        {
                return m_envPeriodCards[0]->getGoodPPPLowerPeriod(period, value, status);
        }
        else
        {
                *value = 0;
                return DAEstatus::Failure;
        }
}

int ISISDAE::getGoodPPPUpperPeriod(int period, isisU32_t* value, DAEstatus& status)
{
        if (m_envPeriodCards.size() > 0)
        {
                return m_envPeriodCards[0]->getGoodPPPUpperPeriod(period, value, status);
        }
        else
        {
                *value = 0;
                return DAEstatus::Failure;
        }
}

bool ISISDAE::isRunning(DAEstatus& status)
{
        return ENV_FUNCTION(isRunning(status));   // test m_run?
}

// find card given crate card number
DetectorCardIntf* ISISDAE::findDetectorCard(int position, DAEstatus& )
{
        int i;
        for(i=0; i<m_detCards.size(); i++)
        {
                if (m_detCards[i]->position() == position)
                {
                        return m_detCards[i];
                }
        }
        return 0;
}

#if 0
// read len 32bit words
// DAE1 spectra are contiguous in memory
// DAE2 spectra are contiguous on a card
int ISISDAE::readHistogramMemory(unsigned long address, 
                                        isisU32_t* buffer, int len)
{
        int i, offset, n, start = -1, end = -1;
        int keep_len = len;
        for(i=0; (i<m_lenAddmap) && (start == -1 || end == -1); i++)
        {
                if (start == -1)
                {
                        if (address == m_addmap[i].dae1add)
                        {
                                start = i;
                        }
                        else if (address < m_addmap[i].dae1add)
                        {
                                start = i - 1;
                        }
                }
                if ((end == -1) && ((address + 4*len) <= 
                                (m_addmap[i].dae1add + 4*m_addmap[i].len)))
                {
                        end = i;
                }
        }
        if (start == -1)
        {
                OUTPUT_MESSAGE(*m_pErr , "readHistogramMemory error - cannot find start address " << address << " in map" << std::endl);
                return -1;
        }
        if (end == -1)
        {
                OUTPUT_MESSAGE(*m_pErr , "readHistogramMemory error - cannot find end address in map" << std::endl);
                end = m_lenAddmap - 1;
        }
        for(i=start; i<=end; i++)
        {
                offset = address - m_addmap[i].dae1add;
                if (offset/4 + len > m_addmap[i].len)
                {
                        n = m_addmap[i].len - offset/4;
                }
                else
                {
                        n = len;
                }
                if (offset < 0)
                {
                        OUTPUT_MESSAGE(*m_pErr , "readHistogramMemory error - offset < 0" << std::endl);
                        return -1;
                }
                m_addmap[i].dc->readHistogramMemory(m_addmap[i].dae2add + offset, buffer, n);
                buffer += n;
                address += n*4;
                len -= n;
        }
        if (len != 0)
        {
                OUTPUT_MESSAGE(*m_pErr , "readHistogramMemory error: only read " << keep_len - len << 
                        "/" << keep_len << " words" << std::endl);
                return -1;
        }
        return 0;
}
#endif /* 0 */

// read len 32bit words
// DAE1 spectra are contiguous in memory
// DAE2 spectra are contiguous on a card
int ISISDAE::readHistogramMemory(unsigned long address, 
                                        isisU32_t* buffer, int len, DAEstatus& status)
{
        int i = 0, j = 0, offset_i, offset_j, n, nj, len_j;
        int keep_len = len;
        isisU32_t nchan;
        isisU32_t* buffer_start = buffer;
        unsigned long address_j;
        bool do_spec0 = (address == 0);
        while( (i < m_lenAddmap) && (len > 0) )
        {
                offset_i = address - m_addmap[i].dae1add;
        //      std::cerr << "offset i" << offset_i << std::endl;
                if (offset_i < 0)
                {
        //              std::cerr << "offset i < 0" << std::endl;
                        i++;
                        continue;
                }
                if (offset_i/4 + len > m_addmap[i].len)
                {
                        n = m_addmap[i].len - offset_i/4;
                }
                else
                {
                        n = len;
                }
                if (n <= 0)
                {
        //              std::cerr << "n < 0" << std::endl;
                        i++;
                        continue;
                }
// look for a continuous region
                j = i;
                address_j = address;
                len_j = len;
                nj = 0;
                while(  (j < m_lenAddmap) && (len_j > 0) && 
                                (m_addmap[j].card == m_addmap[i].card) &&
                                (m_addmap[i].spec + (j - i) == m_addmap[j].spec) &&
                                (address + 4*len > m_addmap[j].dae1add) )
                {
                        offset_j = address_j - m_addmap[j].dae1add;
                        if (offset_j < 0)
                        {
                                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_SPECREAD, "readHistogramMemory error");
                                j++;
                                continue;
                        }
                        if (offset_j/4 + len_j > m_addmap[j].len)
                        {
                                n = m_addmap[j].len - offset_j/4;
                        }
                        else
                        {
                                n = len_j;
                        }
                        if (n <= 0)
                        {
                                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_SPECREAD, "readHistogramMemory error");
                                j++;
                                continue;
                        }
                        nj += n;
                        address_j += n*4;
                        len_j -= n;
                        j++;
//                      std::cerr << " j read of " << n << std::endl;
                }
//              std::cerr << "Reading " << nj << " words from card " << m_addmap[i].card << std::endl;
                if (true)
                {
                        readDCHistogramAsync(m_addmap[i].dc, m_addmap[i].dae2add + offset_i, buffer, nj, status);
                }
                else
                {
                        m_addmap[i].dc->readHistogramMemory(m_addmap[i].dae2add + offset_i, buffer, nj, status);
                        SetEvent(m_async_complete_event);  // needed so waitForAsync does not hang
                }
                buffer += nj;
                address += nj*4;
                len -= nj;
                i = j;
        }
        waitForAsync();
        if (len != 0)
        {
                std::ostringstream message;
                message << "readHistogramMemory error: only read " << keep_len - len << 
                        "/" << keep_len << " words";
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_SPECREAD, message.str());
                return -1;
        }
        // correct for spectrum 0
        if (do_spec0)
        {
                getSpectrumSize(0, &nchan, status);
                readDAE1Spectrum(0, buffer_start, nchan, status);
        }
        return 0;
}

isisU32_t ISISDAE::sumAllHistogramMemory(DAEstatus& status)
{
        int i;
        isisU32_t sum = 0;
        for(i=0; i<m_detCards.size(); i++)
        {
                sum += m_detCards[i]->sumHistogramMemory(status);
        }
        return sum;
}

int ISISDAE::readDescriptorTimeBinLimitRegister(int det_card, isisU32_t* value, DAEstatus& status)
{
        return m_detCards[det_card]->readDescriptorTimeBinLimitRegister(value, status);
}

int ISISDAE::writeDescriptorTimeBinLimitRegister(int det_card, isisU32_t value, DAEstatus& status)
{
        return m_detCards[det_card]->writeDescriptorTimeBinLimitRegister(value, status);
}

int ISISDAE::readTCGTimeBinLimitRegister(int det_card, isisU32_t* value, DAEstatus& status)
{
        return m_detCards[det_card]->readTCGTimeBinLimitRegister(value, status);
}

int ISISDAE::writeTCGTimeBinLimitRegister(int det_card, isisU32_t value, DAEstatus& status)
{
        return m_detCards[det_card]->writeTCGTimeBinLimitRegister(value, status);
}

//int ISISDAE::writeHistogramMemory(unsigned long start, isisU32_t* buffer, int len)
//{
//      return 0;
//}


// vetos: SMP, EXTERNAL1
// FIFO always enabled
int ISISDAE::setDAE1Vetos(int vetos[], int n, DAEstatus& status)
{
        int i;
// FIFO
        status.addInfo(FAC_DAE, "Enabling FIFO veto");
        ENV_FUNCTION(enableFIFOVeto(status));
// SMP
        if ( (n > 0) && (vetos[0] == 1) )
        {
                status.addInfo(FAC_DAE, "Enabling SMP veto");
                ENV_FUNCTION(enableSMPVeto(status));
        }
        else
        {
                status.addInfo(FAC_DAE, "Disabling SMP veto");
                ENV_FUNCTION(disableSMPVeto(status));
        }
// 4 possible External vetos
        for(i=1; i <= 4; i++)
        {
                if ( (n > i) && (vetos[i] == 1) )
                {
                        status.addInfoVa(FAC_DAE, "Enabling EXTERNAL veto %d", i-1);
                        ENV_FUNCTION(enableExternalVeto(i-1, status));
                }
                else
                {
                        status.addInfoVa(FAC_DAE, "Disabling EXTERNAL veto %d", i-1);
                        ENV_FUNCTION(disableExternalVeto(i-1, status));
                }
        }
// Fermi (Fast) Chopper
        if ( (n > 7) && (vetos[5] == 1) )
        {
                status.addInfo(FAC_DAE, "Enabling Fermi Chopper veto 0"); // delay + width printed by called function
                ENV_FUNCTION(enableFChopperVeto(0, vetos[6], vetos[7], status));
        }
        else
        {
                status.addInfo(FAC_DAE, "Disabling Fermi Chopper veto 0");
                ENV_FUNCTION(disableFChopperVeto(0, status));
        }       
// TS2 Pulse
        if ( (n > 8) && (vetos[8] == 1) )
        {
                status.addInfo(FAC_DAE, "Enabling TS2 Pulse veto");
                ENV_FUNCTION(enableTS2PulseVeto(status));
        }
        else
        {
                status.addInfo(FAC_DAE, "Disabling TS2 Pulse veto");
                ENV_FUNCTION(disableTS2PulseVeto(status));
        }       
// 50 Hz
        if ( (n > 9) && (vetos[9] == 1) )
        {
                status.addInfo(FAC_DAE, "Enabling ISIS 50Hz veto");
                ENV_FUNCTION(enableISIS50HzVeto(status));
        }
        else
        {
                status.addInfo(FAC_DAE, "Disabling ISIS 50Hz veto");
                ENV_FUNCTION(disableISIS50HzVeto(status));
        }       
// Detector Card
        for(i=0; i<m_detCards.size(); i++)
        {
                m_detCards[i]->clearVetoOccurredFlag(status);
                m_detCards[i]->enableDIMVetos(0xffff, status); // on all 16 dims
                m_detCards[i]->enableVeto(DetectorCardIntf::FrameOverflowVeto, status);
                m_detCards[i]->enableVeto(DetectorCardIntf::MemoryFullVeto, status); 
                m_detCards[i]->enableVeto(DetectorCardIntf::FIFOLateVeto, status); 
        }
//  if (m_envPeriodCards.size() > 0)
//      {
//              m_envPeriodCards[0]->disableFermiChopperVeto(status);
//      }
        return 0;
}


ISISDAE::veto_desc ISISDAE::veto_setters[] = {
        { "FIFO", &EnvironmentCardIntf::enableFIFOVeto, &EnvPeriodCardIntf::enableFIFOVeto, &EnvironmentCardIntf::disableFIFOVeto, &EnvPeriodCardIntf::disableFIFOVeto }
};

int ISISDAE::setVeto(const std::string& name, bool enable, DAEstatus& status)
{
        bool done = false;
        for(int i=0; i < sizeof(veto_setters) / sizeof(veto_desc); i++)
        {
                if (name == veto_setters[i].name)
                {
                        if (m_envCards.size() > 0)
                        {
                                if (enable)
                                {
                                        (m_envCards[0]->*(veto_setters[i].ec_enable))(status);
                                }
                                else
                                {
                                        (m_envCards[0]->*(veto_setters[i].ec_disable))(status);
                                }
                                done = true;
                        }
                        else if (m_envPeriodCards.size() > 0)
                        {
                                if (enable)
                                {
                                        (m_envPeriodCards[0]->*(veto_setters[i].pc_enable))(status);
                                }
                                else
                                {
                                        (m_envPeriodCards[0]->*(veto_setters[i].pc_disable))(status);
                                }
                                done = true;
                        }
                        else
                        {
                                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "No env or period cards");
                        }
                }
        }
        if (!done)
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Unknown veto %s", name.c_str());
        }
        return 0;
}

int ISISDAE::setFrameSync(FrameSync fs, int muon_pulse, DAEstatus& status)
{
        ENV_FUNCTION(setFrameSync(fs, status));
    if (m_envPeriodCards.size() > 0)
        {
                m_envPeriodCards[0]->setMuonPulse(muon_pulse, status);
        }
        return DAEstatus::Success;
}

int ISISDAE::setFrameSyncDelay(isisU32_t delay, DAEstatus& status)              // in us
{
        return ENV_FUNCTION(setFrameSyncDelay(delay, status));
}

double ISISDAE::frameTimerDrift(DAEstatus& status) // icp - dae
{
    if (m_envPeriodCards.size() > 0)
        {
                return m_envPeriodCards[0]->frameTimerDrift(status);
        }
        else
        {
                return 1.0e38;
        }
}

int ISISDAE::getFrameSyncDelay(isisU32_t* delay, DAEstatus& status)     // in us
{
        return ENV_FUNCTION(getFrameSyncDelay(delay, status));
}

int ISISDAE::setDCFrameSyncDelay(int crat, isisU32_t delay, DAEstatus& status)  // in us
{
        DetectorCardIntf* dc = findDetectorCard(crat, status);
        if (dc != NULL)
        {
                dc->setFrameSyncDelay(delay, status);
        }
        else
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_SPECREAD, "Unknown detector card %d", crat);
        }
        return status.result();
}

int ISISDAE::getDCFrameSyncDelay(int crat, isisU32_t* delay, DAEstatus& status) // in us
{
        DetectorCardIntf* dc = findDetectorCard(crat, status);
        if (dc != NULL)
        {
                dc->getFrameSyncDelay(delay, status);
        }
        else
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_SPECREAD, "Unknown detector card %d", crat);
        }
        return status.result();
}

float ISISDAE::getGoodUAmpHours(DAEstatus& status)
{
    return ENV_FUNCTION(getGoodUAmpHours(status)) * m_uamp_scale;
}

float ISISDAE::getRawUAmpHours(DAEstatus& status)
{
    return ENV_FUNCTION(getRawUAmpHours(status)) * m_uamp_scale;
}

int ISISDAE::clearFramesVetosAndPPP(DAEstatus& status)
{
        int i;
        for(i=0; i<m_envPeriodCards.size(); i++)
        {
                m_envPeriodCards[i]->zeroPeriodFrameCounters(status);
        }
//              for(i=0; i<m_detCards.size(); i++)
//              {
//                      m_detCards[i]->clearVetoOccurredFlag(status);
//              }
        return ENV_FUNCTION(ClearFramesAndPPP(status)); 
} 

int ISISDAE::setPeriodType(ISISDAE::PeriodType type, bool single_daq_period, DAEstatus& status)
{ 
        m_period_mode = type;
        bool hardware_periods = (type != ISISDAE::PeriodTypeSoftware);  
        int i; 
        if (type == ISISDAE::PeriodTypeHardwareExternal)
        {
        ENV_FUNCTION(enableHardwarePeriods(status));
                status.addInfo(FAC_DAE, "Enabling EC delayed start");
        }
        else
        {
                ENV_FUNCTION(disableHardwarePeriods(status)); 
        }
    for(i=0; i<m_detCards.size(); i++) 
        { 
        m_detCards[i]->setPeriodType(hardware_periods, single_daq_period, status);; 
    } 
    return 0; 
} 
    
int ISISDAE::getCurrentHardwarePeriod(isisU32_t *period, DAEstatus& status) 
{
           if ( (m_period_mode == ISISDAE::PeriodTypeHardwareExternal) && 
                    (m_detCards.size() > 0) )
           {
                   *period = PERIOD_FUNCTION(getCurrentPeriodNumber(status));  
                   return status.result();
//                      return m_detCards[0]->getCurrentHardwarePeriod(period, status); // would be same if no dwells
           }
           else if ( (m_period_mode == ISISDAE::PeriodTypeHardwareInternal) /* && (m_periodCards.size() > 0) */)
           {
                   *period = PERIOD_FUNCTION(getCurrentPeriodNumber(status));
                   return status.result();
           }
           else
           {
                        *period = 0;
//                      status.addWarning(FAC_DAE, "getCurrentHardwarePeriod error - not using hardware periods");
                        return ISISVME::Error;
           }
} 

int ISISDAE::getCurrentDAQHardwarePeriod(isisU32_t *period, DAEstatus& status)
{
        if ((m_period_mode != ISISDAE::PeriodTypeSoftware) && (m_detCards.size() > 0))
        {
                return m_detCards[0]->getCurrentHardwarePeriod(period, status);
        }
        else
        {
                *period = 0;
//              status.addWarning(FAC_DAE, "getCurrentDAQHardwarePeriod error - not using hardware periods");
                return ISISVME::Error;
        }
}
 
int ISISDAE::getTimeChannels(int spec, double* tcb, int ntc, DAEstatus& status)
{
                isisU32_t i, nchan;
                getSpectrumSize(spec, &nchan, status);
                isisU32_t* itcb = new isisU32_t[nchan];
                getTimeChannels(spec, itcb, nchan-1, status);
                for(i=0; i < ntc+1; i++)
                {
                        tcb[i] = itcb[i] / (double)m_clock_frequency;  // need to add FS delay
                }
                delete []itcb;
                return 0;
}

int ISISDAE::getSMPVetoedFrames(isisU32_t* value, DAEstatus& status)
{
        return ENV_FUNCTION(getSMPVetoedFrames(value, status));
}

int ISISDAE::getTS2PulseVetoedFrames(isisU32_t* value, DAEstatus& status)
{
        return ENV_FUNCTION(getTS2PulseVetoedFrames(value, status));
}

int ISISDAE::getISIS50HzVetoedFrames(isisU32_t* value, DAEstatus& status)
{
        return ENV_FUNCTION(getISIS50HzVetoedFrames(value, status));
}

int ISISDAE::getExternalVetoedFrames(int veto_number, isisU32_t* value, DAEstatus& status)
{
        return ENV_FUNCTION(getExternalVetoedFrames(veto_number, value, status));
}

int ISISDAE::getFIFOVetoedFrames(isisU32_t* value, DAEstatus& status)
{
        return ENV_FUNCTION(getFIFOVetoedFrames(value, status));
}

int ISISDAE::getMSModeVetoedFrames(isisU32_t* value, DAEstatus& status)
{
        if (m_envPeriodCards.size() > 0)
        {
                return m_envPeriodCards[0]->getMSModeVetoedFrames(value, status);
        }
        else
        {
                return 0;
        }
}


int ISISDAE::getTotalCounts(int64_t* value, DAEstatus& status)
{
        int i;
        isisU32_t counts;
        *value = 0;
        for(i=0; i<m_detCards.size(); i++)
        {
                m_detCards[i]->getTotalCounts(&counts, status);
                *value = *value + counts;
        }
        return 0;
}

int ISISDAE::clearTotalCountsRegisters(DAEstatus& status)
{
        int i;
        for(i=0; i<m_detCards.size(); i++)
        {
                m_detCards[i]->clearTotalCountsRegister(status);
        }
        return 0;
}

// need to call setPeriodType(HardwareInternal) after this - you need to call setPeriodType() after
// the detector card is programmed so that it knows the period size
int ISISDAE::programPeriodCard(PeriodType period_type, int nper, int nperseq_request, isisU32_t* outputs, isisU16_t *dwell_flags, isisU16_t *frames,
                                                         int period_output_delay, DAEstatus& status)
{
        if (m_envPeriodCards.size() != 1)
        {
//              status.add(FAC_DAE, SEV_ERROR, ERRTYPE_SPECREAD, "No period card present");
                status.addInfo(FAC_DAE, "No period card present");
//              return DAEstatus::Failure;
                return status.result();
        }
        if (m_envPeriodCards.size() == 1)
        {
                EnvPeriodCardIntf* epc = m_envPeriodCards[0];
                epc->resetPeriodCard(status);
                epc->clearPeriodCounters(status);
                epc->setPeriodControlBits(0, false, status); // zero register
                if (epc->getFrameSync(status) == FrameSyncMuonMS)
                {
                        epc->enableMSMode(status);
                }
                else
                {
                        epc->disableMSMode(status);
                }
                epc->setNumberOfPeriods(0, status);
                epc->zeroPeriodFrameCounters(status);
                epc->zeroPeriodProtonCounters(status);
//              epc->zeroPeriodExtraCounters(status);
                epc->setNumberOfPeriods(nper, status);
                epc->programOUTLUT(outputs, nper, status);
                epc->programPERLUT(dwell_flags, frames, nper, status);
                if (nperseq_request > 0)
                {
                    epc->setMultiplePeriodSequenceMode(nperseq_request, status);
                }
                else
                {
                        epc->setSinglePeriodSequenceMode(status);
                }
                epc->enablePeriodMode((period_type == ISISDAE::PeriodTypeHardwareExternal ? true : false), status);
                epc->setPeriodOutputDelay(period_output_delay, status);
        }
        return status.result();
}

int ISISDAE::disablePeriodCard(DAEstatus& status)
{
        if (m_envPeriodCards.size() > 0)
        {
                PERIOD_FUNCTION(disablePeriodMode(status));
        }
        return status.result();
}

int ISISDAE::getCurrentPeriodSequence(isisU32_t *period_sequence, DAEstatus& status)
{
        if (m_envPeriodCards.size() > 0)
        {
                *period_sequence = PERIOD_FUNCTION(getCurrentPeriodSequence(status));
        }
        else
        {
                *period_sequence = 0;
        }
        return status.result();
}

bool ISISDAE::isMultiplePeriodSequenceComplete(DAEstatus& status)
{
        if (m_envPeriodCards.size() > 0)
        {
                return m_envPeriodCards[0]->isMultipleSequenceComplete(status);
        }
        else
        {
                return false;
        }
}

template <class DAECardPolicy>
int ISISDAE::VMEWriteValue(unsigned long card_id, unsigned long card_address, bool sixteen_bit, unsigned long value, unsigned long mode, DAEstatus& status)
{
        unsigned long add = DAE2Card<DAECardPolicy>::makeAddress(card_id, card_address);
        unsigned long old_value;
        isisU16_t old16;
    isisU32_t old32;
        ISISVME* vme = m_vme[card_id / DAECardPolicy::CRATE_MOD];
        if (sixteen_bit)
        {
                vme->readU16(add, &old16, ISISVME::TransferNoOptions, status);
                old_value = old16;
        }
        else
        {
                vme->readU32(add, &old32, ISISVME::TransferNoOptions, status);
                old_value = old32;
        }
        switch(mode)
        {
                case 0: // SET
                        break;

                case 1: // AND
                        old_value &= value;
                        value = old_value;
                        break;

                case 2: // OR
                        old_value |= value;
                        value = old_value;
                        break;

                case 3: // XOR
                        old_value ^= value;
                        value = old_value;
                        break;

                default:
                        break;
        }
        status.addInfoVa(FAC_DAE, "Setting 0x%x = 0x%x (%s bit)", add, value, (sixteen_bit ? "16" : "32"));
        if (sixteen_bit)
        {
                vme->writeU16(add, static_cast<isisU16_t>(value), ISISVME::TransferNoOptions, status);
        }
        else
        {
                vme->writeU32(add, value, ISISVME::TransferNoOptions, status);
        }
        return 0;
}

template <class DAECardPolicy>
int ISISDAE::VMEReadValue(unsigned long card_id, unsigned long card_address, bool sixteen_bit, unsigned long* value, DAEstatus& status)
{
        int stat;
        unsigned long add = DAE2Card<DAECardPolicy>::makeAddress(card_id, card_address);
        ISISVME* vme = m_vme[card_id / DAECardPolicy::CRATE_MOD];
        isisU16_t old16;
    isisU32_t old32;
        if (sixteen_bit)
        {
                stat = vme->readU16(add, &old16, ISISVME::TransferNoOptions, status);
                *value = old16;
        }
        else
        {
                stat = vme->readU32(add, &old32, ISISVME::TransferNoOptions, status);
                *value = old32;
        }
        return stat;
}


template <class DAECardPolicy>
int ISISDAE::VMEWriteArray(unsigned long card_id, unsigned long card_address, isisU32_t* values, unsigned long num_values, DAEstatus& status)
{
        unsigned long add = DAE2Card<DAECardPolicy>::makeAddress(card_id, card_address);
        ISISVME* vme = m_vme[card_id / DAECardPolicy::CRATE_MOD];
        return vme->writeBlockU32(add, values, num_values, ISISVME::TransferBlock | ISISVME::TransferLittleEndian, status);
}

template <class DAECardPolicy>
int ISISDAE::VMEReadArray(unsigned long card_id, unsigned long card_address, isisU32_t* values, unsigned long num_values, DAEstatus& status)
{
        unsigned long add = DAE2Card<DAECardPolicy>::makeAddress(card_id, card_address);
        ISISVME* vme = m_vme[card_id / DAECardPolicy::CRATE_MOD];
        return vme->readBlockU32(add, values, num_values, ISISVME::TransferBlock | ISISVME::TransferLittleEndian, status);
}

const char* ISISDAE::PeriodType_desc[] = { 
        "Software", 
        "HardwareInternal (period card)", 
        "HardwareExternal (period card)" 
};

const char* ISISDAE::DAEType_desc[] = { 
        "Unknown", 
        "Neutron DAE2", 
        "Muon DAE2",
        "Neutron DAE3",
        "Muon DAE3"
};


DWORD __stdcall ISISDAE::checkTestPatternThread(void* arg)
{
        test_async_t* his = (test_async_t*)arg;
        his->dc->checkTestPattern(his->pattern, his->status);
        his->dae->doneAsync();
        delete his;
        return 0;
}

int ISISDAE::checkTestPatternAsync(unsigned long pattern, DAEstatus& status)
{
        ICPTimer icptimer;
        for(int i=0; i<m_detCards.size(); i++)
        {
                test_async_t* arg = new test_async_t(this, m_detCards[i], pattern, status);
                InterlockedIncrement(&m_num_async_requests);
                if (QueueUserWorkItem(checkTestPatternThread, arg, WT_EXECUTEDEFAULT) != 0)
                {
                        ;
                }
                else
                {
                        InterlockedDecrement(&m_num_async_requests);
                        status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "error queueing work item");
                }
        }
        icptimer.info("Async checks queued...", status);
        waitForAsync();
        icptimer.info("checkTestPatternAsync", status);
        return ISISVME::Success;
}

int ISISDAE::fillWithTestPattern(unsigned long pattern, DAEstatus& status)
{
        ICPTimer icptimer("fillWithTestPattern", status);
        for(int i=0; i<m_detCards.size(); i++)
        {
                m_detCards[i]->fillWithTestPattern(pattern, status);
        }
        status.addInfoVa(FAC_DAE, "Memory filled with test pattern %lu ready for checking", pattern);
        return ISISVME::Success;
}

int ISISDAE::checkTestPattern(unsigned long pattern, DAEstatus& status)
{
        ICPTimer icptimer("checkTestPattern", status);
        std::ostringstream oss;
        for(int i=0; i<m_detCards.size(); i++)
        {
                m_detCards[i]->checkTestPattern(pattern, status);
        }
        return ISISVME::Success;
}


int ISISDAE::getVetoStatus(std::string& veto_text, DAEstatus& status)
{
        std::ostringstream oss;
        ENV_FUNCTION(printVetoDetails(oss, status));
        veto_text = oss.str();
        return ISISVME::Success;
}

int ISISDAE::whichVeto(std::string& veto_text, DAEstatus& status)
{
        std::ostringstream oss;
        ENV_FUNCTION(whichVeto(oss, status));
        for(int i=0; i<m_detCards.size(); i++)
        {
                m_detCards[i]->whichVeto(oss, status);
        }
        veto_text = oss.str();
        return ISISVME::Success;
}

int ISISDAE::writePOSLUTMemory(int card_id, isisU32_t* buffer, int len, DAEstatus& status)
{
        DetectorCardIntf* dc = findDetectorCard(card_id, status);
        if (dc != NULL)
        {
                dc->writePOSLUTMemory(0, buffer, len, status);
                return ISISVME::Success;
        }
        else
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_SPECREAD, "writePOSLUTMemory: Unknown detector card %d", card_id);
                return DAEstatus::Failure;
        }
}

int ISISDAE::writeHistogramMemory(int card_id, isisU32_t* buffer, int start, int len, DAEstatus& status)
{
        DetectorCardIntf* dc = findDetectorCard(card_id, status);
        if (dc != NULL)
        {
                dc->writeHistogramMemory(start, buffer, len, status);
                return ISISVME::Success;
        }
        else
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_SPECREAD, "writeHistogramMemory: Unknown detector card %d", card_id);
                return DAEstatus::Failure;
        }
        return ISISVME::Success;
}

int ISISDAE::enableDelayedStart(DAEstatus& status)
{
        if (m_envCards.size() > 0)
        {
                status.addInfo(FAC_DAE, "Enabling EC delayed start");
                m_envCards[0]->enableHardwarePeriods(status);
        }
        if (m_envPeriodCards.size() > 0)
        {
                status.addInfo(FAC_DAE, "Enabling PC delayed start");
                m_envPeriodCards[0]->enableDelayedStart(status);
        }
        return ISISVME::Success;
}

int ISISDAE::disableDelayedStart(DAEstatus& status)
{
        if (m_envCards.size() > 0)
        {
                m_envCards[0]->disableHardwarePeriods(status);
        }
        if (m_envPeriodCards.size() > 0)
        {
                m_envPeriodCards[0]->disableDelayedStart(status);
        }
        return ISISVME::Success;
}

void ISISDAE::setDCEventMode(unsigned long card_id, bool value, DAEstatus& status)
{
        DetectorCardIntf* dc = findDetectorCard(card_id, status);
        if (dc != NULL)
        {
                dc->setEventCollectionMode(value, status);
                m_es.setCardStatus(card_id, value);
        }
        else
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_SPECREAD, "setDCEventMode: Unknown detector card %d", card_id);
        }
}

void ISISDAE::setDCCardMode(unsigned long card_id, bool neutron_data, DAEstatus& status)
{
        DetectorCardIntf* dc = findDetectorCard(card_id, status);
        if (dc != NULL)
        {
                dc->setCardMode(neutron_data ? DetectorCardIntf::ModeNeutronData : DetectorCardIntf::ModeSEData);
        }
        else
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_SPECREAD, "setDCCardMode: Unknown detector card %d", card_id);
        }
}

void ISISDAE::clearDCEventMode(DAEstatus& status)
{
        std::for_each(m_detCards.begin(), m_detCards.end(), boost::bind(&DetectorCardIntf::setEventCollectionMode, _1, false, boost::ref(status)));
        m_es.setCardStatus(false);
}

int ISISDAE::requestEndRunAfterNextSequenceCompletes(DAEstatus& status)
{
        if ( (m_period_mode == ISISDAE::PeriodTypeHardwareInternal) || (m_period_mode == ISISDAE::PeriodTypeHardwareExternal) )
        {
                if (m_envPeriodCards.size() > 0)
                {
                        PERIOD_FUNCTION(endRunAfterSequenceCompletes(status));
                }
        }
        return DAEstatus::Success;
}

bool ISISDAE::isFinalSequenceComplete(DAEstatus& status)
{
        if ( (m_envPeriodCards.size() > 0) && 
                 ((m_period_mode == ISISDAE::PeriodTypeHardwareInternal) || (m_period_mode == ISISDAE::PeriodTypeHardwareExternal)) 
                ) 
        {
                return !PERIOD_FUNCTION(isEndRunAfterSequenceCompletesInProgress(status));
        }
        return true;
}

int ISISDAE::getExternalResetCommands(std::list< std::pair<std::string,std::string> >& commands, DAEstatus& status)
{
        static std::string detectorcmd = Poco::Util::Application::instance().config().getString("isisicp.daereset.detectorcmd");
        static std::string environmentcmd = Poco::Util::Application::instance().config().getString("isisicp.daereset.environmentcmd");
        static std::string envperiodcmd = Poco::Util::Application::instance().config().getString("isisicp.daereset.envperiodcmd");
        commands.clear();
        // seems to cause problems in CreateProcess() if we put "" around the daeDevice name string, looks like 
        // it then get interpreted as a path. As daeDevice should not contain spaces, we are OK
        BOOST_FOREACH(const env_list_t::value_type& c, m_envCards)
        {
                commands.push_back(std::pair<std::string,std::string>(environmentcmd, Poco::format("%s %d", c->daeDevice(), c->position())));
        }
        BOOST_FOREACH(const env_period_list_t::value_type& c, m_envPeriodCards)
        {
                commands.push_back(std::pair<std::string,std::string>(envperiodcmd, Poco::format("%s %d", c->daeDevice(), c->position())));
        }
        BOOST_FOREACH(const det_list_t::value_type& c, m_detCards)
        {
                commands.push_back(std::pair<std::string,std::string>(detectorcmd, Poco::format("%s %d", c->daeDevice(), c->position())));
        }
        return DAEstatus::Success;
}

template int ISISDAE::VMEWriteValue<DAE3CardPolicy>(unsigned long card_id, unsigned long card_address, bool sixteen_bit, unsigned long value, unsigned long mode, DAEstatus& status);
template int ISISDAE::VMEReadValue<DAE3CardPolicy>(unsigned long card_id, unsigned long card_address, bool sixteen_bit, unsigned long *value, DAEstatus& status);
template int ISISDAE::VMEWriteArray<DAE3CardPolicy>(unsigned long card_id, unsigned long card_address, isisU32_t* values, unsigned long num_values, DAEstatus& status);
template int ISISDAE::VMEReadArray<DAE3CardPolicy>(unsigned long card_id, unsigned long card_address, isisU32_t* values, unsigned long num_values, DAEstatus& status);

template int ISISDAE::VMEWriteValue<DAE2CardPolicy>(unsigned long card_id, unsigned long card_address, bool sixteen_bit, unsigned long value, unsigned long mode, DAEstatus& status);
template int ISISDAE::VMEReadValue<DAE2CardPolicy>(unsigned long card_id, unsigned long card_address, bool sixteen_bit, unsigned long *value, DAEstatus& status);
template int ISISDAE::VMEWriteArray<DAE2CardPolicy>(unsigned long card_id, unsigned long card_address, isisU32_t* values, unsigned long num_values, DAEstatus& status);
template int ISISDAE::VMEReadArray<DAE2CardPolicy>(unsigned long card_id, unsigned long card_address, isisU32_t* values, unsigned long num_values, DAEstatus& status);