detector_card.cpp

Go to the documentation of this file.

#include "stdafx.h"

#include "detector_card.h"
#include "isisvme.h"
#include "icputils.h"
#include "dae_events.h"

static bool memory_check = false; 

// there are ntc user time channels and hence ntc+1 
// user supplied boundaries. ntc+1 values are written to
// the TCGLUT memory, but the size of a spectrum, is (ntc+1)
// rather than (ntc) as there is a special "channel 0" where counts
// that occur before the first time channel go

template <class DetCardPolicy>
bool DetectorCard<DetCardPolicy>::isEventMode(DAEstatus& status)
{
        if (m_options & DetectorCard::EventMode)
        {
                return (m_reg.event_reg.eventMode(status) != 0) ? true : false;
        }
        else
        {
                return false;
        }
}

template <class DetCardPolicy>
void DetectorCard<DetCardPolicy>::printStatus(std::ostream& os, DAEstatus& status)
{
        isisU32_t value;
        DAE2Card::printStatus(os, status);
        os << "This is a " << DetCardPolicy::card_type <<  " DETECTOR card with " << m_memsize / (1024*1024) 
                << " MB memory" << std::endl;
        os << "Mode is " << (m_mode & ModeNeutronData ? "neutron" : "sample environment") << std::endl;
        os << "Highest DAE2 spectrum used = " << m_highspec << std::endl;
        getNTimeChannels(&value, status);
        os << value << " time channels" << std::endl;
        if (m_hardware_periods)
        {
                os << "HARDWARE periods: number of DAQ periods = " << m_nperiods << std::endl;
                getCurrentHardwarePeriod(&value, status);
                os << "Current DAQ period number = " << value << std::endl;
                readRegister16As32(DCPERSIZE0, DCPERSIZE1, &value, status);
                os << "Current DAQ period size (words) = " << value << std::endl;
        }
        else
        {
                os << "SOFTWARE periods: number of periods = " << m_nperiods << std::endl;
        }
        getTotalCounts(&value, status);
        os << "Total counts register = " << value << std::endl;
        if (m_options & DetectorCard::VetoLogging)
        {
                printVetoStatus(os, false, status);
        }
        else
        {
                os << "Veto logging not supported" << std::endl;
        }
        if (m_options & DetectorCard::DelayedFrameSync)
        {
                getFrameSyncDelay(&value, status);
                os << "Delayed Frame synch  = " << value << std::endl;
        }
        md5checksum_t checksum;
        md5sumString(m_poslut, DCPOSLUTSIZE * sizeof(isisU32_t), checksum, status);
        os << "POSLUT checksum = "  << checksumAsString(checksum) << std::endl;
        if (m_options & DetectorCard::EventMode)
        {
                printRegister("Next Frame Marker Register", DCNXFRMR, os);
                printRegister("Next Memory Write Register", DCNXMEMWR, os);
                printRegister("Number of Memory Wraps Register", DCNMEMWR, os);
                printRegister("Last Read Register", DCADDLRR, os);
                printRegister("Event Mode Register", DCEVNTMD, os, true);
        }
//      printSpecmap(os);
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::printVetoStatus(std::ostream& os, bool triggered_only, DAEstatus& status)
{
                isisU16_t temp16, value16;
                getDIMVetos(&temp16, status);
                readDIMVetoOccurredFlag(&value16, status);
                for(int i=0; i<16; i++)
                {
                        bool enabled = ((temp16 & (1 << i)) != 0);
                        bool triggered = ((value16 & (1 << i)) != 0);
                        if (!triggered_only || (enabled && triggered))
                        {
                                os << "Detector card " << m_position << " Veto for Dim" << i << 
                                        " is " << (enabled ? "ENABLED" : "DISABLED") << 
                                        (triggered ? " OCCURRED" : " CLEAR") << std::endl;
                        }
                }
                printVetoStatus(FrameOverflowVeto, os,  triggered_only, status);
                printVetoStatus(MemoryFullVeto, os, triggered_only, status);
                printVetoStatus(FIFOLateVeto, os, triggered_only, status);
                return 0;
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::printVetoStatus(DetectorCardVeto veto, std::ostream& os, bool triggered_only, DAEstatus& status)
{
        bool enabled = isVetoEnabled(veto, status);
        bool triggered = hasVetoOccurred(veto, status);
        if (!triggered_only || (enabled && triggered))
        {
                os << "Detector card " << m_position << " " << getVetoName(veto) << (enabled ? " ENABLED, " : " DISABLED ") << (triggered ? "OCCURRED" : "CLEAR") << std::endl;
        }
        return 0;
}

template <class DetCardPolicy>
void DetectorCard<DetCardPolicy>::printSpecmap(std::ostream& os)
{
        int i;
        os << "DAE2 -> DAE1 spec map" << std::endl;
    for(i=0; i<= m_highspec; i++)
        {
                if (m_dae2specmap[i] != NOSPECTRUM)
                {
                    os << i << " -> " << m_dae2specmap[i] << std::endl;
                }
        }
        os << "DAE1 -> DAE2 spec map" << std::endl;
        for(i=0; i<DAESPECMAX; i++)
        {
                if (m_dae1specmap[i] != NOSPECTRUM)
                {
                        os << i << " -> " << m_dae1specmap[i] << std::endl;
                }
        }
}

template <class DetCardPolicy>
void DetectorCard<DetCardPolicy>::printPOSLUT(std::ostream& os, DAEstatus& status)
{
        isisU32_t val;
        int i;
        readPOSLUTMemory(0, m_poslut, DCPOSLUTSIZE, status);
        os << "*** DUMP OF POSLUT ***\n"; 
        for(i=0; i<DCPOSLUTSIZE; i++)
        {
                val = m_poslut[i];
                os << val << ((i+1) % 20 == 0 ? '\n' : ' ');
        }
        os << "*** DUMP DONE ***\n"; 
}


template <class DetCardPolicy>
void DetectorCard<DetCardPolicy>::printTimeChannels(std::ostream& os, int start, int end)
{
        isisU32_t ntc, value;
        DAEstatus status;
        int i;
        if (m_options & DetectorCard::DelayedFrameSync)
        {
                getFrameSyncDelay(&value, status);
                os << "Delayed frame sync = " << value << std::endl;
        }
        getNTimeChannels(&ntc, status);
        os << ntc << " time channels - first few boundaries in clock pulses\n";
        if (end == -1)
        {
                end = ntc+1;
        }
        isisU32_t* tcb = new isisU32_t[ntc+1];
        getTimeChannels(tcb, ntc, status);
        for(i=start; i<end; i++)
        {
//for real time need to divide by m_clock_frequency
                os << tcb[i] << ( ((i+1) % 10) ? " " : "\n");
        }
        os << "\n";
        delete []tcb;
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::getSpectrumSize(isisU32_t* value, DAEstatus& status)   // ntc+1
{
        *value = 0;
        return readDescriptorTimeBinLimitRegister(value, status);
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::getNTimeChannels(isisU32_t* ntc, DAEstatus& status)    // ntc
{
        *ntc = 0;
        return readTCGTimeBinLimitRegister(ntc, status);
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::setNTimeChannels(isisU32_t ntc, DAEstatus& status)     // ntc
{
        writeDescriptorTimeBinLimitRegister(ntc+1, status);
        return writeTCGTimeBinLimitRegister(ntc, status);
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::readDAE1Spectrum(int dae1_spec, isisU32_t* buffer, int nbuffer, DAEstatus& status)
{
        isisU32_t nchan;
        int spec = findDAE1Spectrum(dae1_spec, status);
        if (spec != NOSPECTRUM)
        {
                if (isEventMode(status))
                {
                        memset(buffer, 0, nbuffer * sizeof(isisU32_t));  // no data to read
//                      status.addInfoVa(FAC_DETCARD, "Card %d using event mode - readDAE1Spectrum not done", position());
                        return 0;
                }
                getSpectrumSize(&nchan, status);
                if (nchan > nbuffer)
                {
                        status.addInfoVa(FAC_DETCARD, "Card %d reading DAE1 spectrum %d truncated (%d > %d)", position(), dae1_spec, nchan, nbuffer);
                }
            return readHistogramMemory(4*spec*nchan, buffer, nbuffer /* nchan */, status);
        }
        else
        {
                memset(buffer, 0, sizeof(isisU32_t) * nbuffer);
                return -1;
        }
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::readDAE1Spectra(isisU32_t* buffer, int nbuffer, const int spec_to_crpt_offset[], int spec_start, int nspec, int period, int persize, DAEstatus& status)
{
        std::ostringstream message;
        isisU32_t nchan;
        int dae1_spec, i, j, n;
        if (isEventMode(status))
        {
//              memset(buffer, 0, nbuffer * sizeof(isisU32_t));   // we get passed the CRPT with histogrammed events so do not want to do this! 
//              status.addInfoVa(FAC_DETCARD, "Card %d using event mode - readDAE1Spectra not done", position());
                return 0;
        }
        if (spec_start + nspec >= DAESPECMAX)
        {
                        status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, "Too many spectra * periods in readDAE1Spectra");
                        return 0;
        }
        std::vector<int> dae2_spec;
        dae2_spec.reserve(nspec);
        for(i = 0; i < nspec; ++i)
        {
                dae1_spec = i + spec_start;
                if (m_dae1specmap[dae1_spec] != NOSPECTRUM)
                {
                        dae2_spec.push_back(m_dae1specmap[dae1_spec]);
                }
                else
                {
                        dae2_spec.push_back(NOSPECTRUM);  // need to make sure we had contiguous dae2 spec -> contiguous dae1 spec
                }
        }
        std::vector<int> consec_points, consec_sizes;
        findConsecutive(dae2_spec, NOSPECTRUM, consec_points, consec_sizes);
        getSpectrumSize(&nchan, status);
        for(i=0; i<consec_points.size(); ++i)
        {
                j = consec_points[i];
                n = consec_sizes[i];
                int d2spec = dae2_spec[j];
                dae1_spec = m_dae2specmap[d2spec];
                int effective_period = dae1_spec / m_dae1persize;   // this is to allow for higher spectrum numbers beiging used to indicate periods
                int offset = spec_to_crpt_offset[dae1_spec % m_dae1persize] + (period + effective_period) * persize;
                if ( (offset + n * nchan) > nbuffer )
                {
                        message << "DetectorCard: too small buffer " << nbuffer << " for reading DAE1 spectrum " << dae1_spec << " period " << period << " from card " << position() << "\n";           
                }
                else if (readHistogramMemory(4*nchan*(d2spec + period*m_dae2persize), buffer + offset, n*nchan, status) != ISISVME::Success)
                {
                        message << "DetectorCard: error reading DAE1 spectrum " << dae1_spec << " from card " << position() << "\n";            
                }
        }
        if (message.str().size() > 0)
        {
                status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, message.str());
        }
        return 0;
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::readAllDAE1Spectra(isisU32_t* buffer, int nbuffer, const int spec_to_crpt_offset[], int persize, DAEstatus& status)
{
        std::ostringstream message;
//      int nper_daq = nbuffer / persize;
        isisU32_t nchan;
        int dae1_spec, i, j, n;
        if (isEventMode(status))
        {
//              status.addInfoVa(FAC_DETCARD, "Card %d using event mode - readAllDAE1Spectra not done", position());
                return 0;
        }
        std::vector<int> consec_points, consec_sizes;
        findConsecutive(m_dae2specmap, NOSPECTRUM, consec_points, consec_sizes);
        getSpectrumSize(&nchan, status);
        for(i=0; i<consec_points.size(); ++i)
        {
                j = consec_points[i];
                n = consec_sizes[i];
                dae1_spec = m_dae2specmap[j];
                if (dae1_spec == 0) // skip spectrum 0 for now - see comments above
                {
                        if (n == 1)
                        {
                                continue; 
                        }
                        else
                        {
                                ++j;
                                --n;
                                ++dae1_spec;
                        }
                }
                int period = j / m_dae2persize;
                int offset = spec_to_crpt_offset[dae1_spec % m_dae1persize] + period * persize;
//              if (period >= nper_daq)
//              {
//                      status.addWarningVa(FAC_DETCARD, "DetectorCard: reading period %d on card %d when nper_daq=%d - this can be ignored if you are using hardware periods with DEWLL periods\n", period + 1, position(), nper_daq);
//              }
//              else if ( (offset + n * nchan) > nbuffer )
                if ( (offset + n * nchan) > nbuffer )
                {
                        message << "DetectorCard: too small buffer " << nbuffer << " for reading " << n << " DAE1 spectra starting at " << dae1_spec << " period " << period << " on card " << position() << "\n";
                }
                else if (readHistogramMemory(4*j*nchan, buffer + offset, n*nchan, status) != ISISVME::Success)
                {
                        message << "DetectorCard: error reading " << n << " DAE1 spectra starting at " << dae1_spec << " on card " << position() << "\n";               
                }
        }
#if 0
        bool done;
        for(i=0; i<=m_highspec; i++)
        {
                dae1_spec = m_dae2specmap[i];
                if (dae1_spec != NOSPECTRUM)
                {
                        if ( (dae1_spec+1)*nchan > nbuffer )
                        {
                                done = true;
                        }
                        else
                        {
                                done = false;
                        }
                        while(!done)
                        {
                            if (readHistogramMemory(4*i*nchan, buffer + dae1_spec*nchan, nchan, status) != ISISVME::Success)
                                {
                                    message << "DetectorCard: error reading DAE1 spectrum " << dae1_spec << " from card " << position() << "; retrying\n";              
                                }
                                else
                                {
                                        done = true;
                                }
                        }
                }
        }
#endif /* 0 */
        if (message.str().size() > 0)
        {
                status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, message.str());
        }
        return 0;
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::readSpectrum(int spec, isisU32_t* buffer, int nbuffer, DAEstatus& status)
{
        isisU32_t nchan;
        if (isEventMode(status))
        {
                memset(buffer, 0, nbuffer * sizeof(isisU32_t));  // no data to read
//              status.addInfoVa(FAC_DETCARD, "Card %d using event mode - readSpectrum not done", position());
                return 0;
        }
    getSpectrumSize(&nchan, status);
        if (nchan > nbuffer)
        {
                status.addInfoVa(FAC_DETCARD, "Card %d reading DAE2 spectrum %d truncated (%d > %d)", position(), spec, nchan, nbuffer);
        }
        return readHistogramMemory(4*spec*nchan, buffer, nbuffer /* nchan */, status);
}
 
template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::setTimeChannels(isisU32_t* tcb, int ntc, DAEstatus& status)
{
        setNTimeChannels(ntc, status);
        return writeTCGLUTMemory(0, tcb, ntc+1, status);
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::getTimeChannels(isisU32_t* tcb, int ntc, DAEstatus& status)
{
        return readTCGLUTMemory(0, tcb, ntc+1, status);
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::fillAddmap(Addmap* addmap, int len, DAEstatus& status)
{
        int i, j, dae1_highest = -1;
        isisU32_t nchan;
        if (isEventMode(status))
        {
                status.addInfoVa(FAC_DETCARD, "Card %d using event mode - addmap not updated", position());
                return 0;
        }
    getSpectrumSize(&nchan, status);
        for(i=0; i<=m_highspec; i++)
        {
                j = m_dae2specmap[i];
                if (j >= len)
                {
                        status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, "fillAddmap: too many spectra %d >= %d", j, len);
                        continue;
                }
                if (j != NOSPECTRUM)
                {
                        // don't update spectrum zero unless we do spectrum 1 too
                        // used during testing of multiple time regimes - may want to do it permanently after more thought?
                        //
                        // if (j == 0 && m_dae1specmap[1] == NOSPECTRUM)
                        // {
                        //          continue;
                        // }
                        if (j > dae1_highest)
                        {
                                dae1_highest = j;
                        }
                        addmap[j].spec = i;
                        addmap[j].card = m_position;
                        addmap[j].dc = this;
                        addmap[j].dae1add = 4*j*nchan;
                        addmap[j].dae2add = 4*i*nchan;
                        addmap[j].len = nchan;
                }
        }
        return dae1_highest + 1; // number of elements used
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::readPOSLUT(DAEstatus& status)
{
        std::ostringstream message;
        int modn_min=1000000, modn_max=-1, mpos_min=1000000, mpos_max=-1;
        int i, j, s, np;
        readPOSLUTMemory(0, m_poslut, DCPOSLUTSIZE, status);
        m_highspec = 0;
        np = 0;
        m_dae1persize = 0;
        m_dae2persize = 0;
        m_nperiods = 1;
        for(i=0; i<DAESPECMAX; i++)
        {
                m_dae1specmap[i] = NOSPECTRUM;
                m_dae2specmap[i] = NOSPECTRUM;
        }
        m_dae1specmap[0] = 0;   // map spectrum 0 
        m_dae2specmap[0] = 0;   // map spectrum 0
        for(i=0; i<DCDIMMAX; i++)
        {
                for(j=0; j<DCPOSMAX; j++)
                {
                        s = m_poslut[DCPOSMAX*i + j];
                        if (s > m_highspec)
                        {
                                m_highspec = s;
                        }
                        if (s != 0)
                        {
                                np++;
                                if (i > modn_max)
                                {
                                        modn_max = i;
                                }
                                if (j > mpos_max)
                                {
                                        mpos_max = j;
                                }
                                if (i < modn_min)
                                {
                                        modn_min = i;
                                }
                                if (j < mpos_min)
                                {
                                        mpos_min = j;
                                }
//                              std::cerr << "Data from (dim,position) = (" << i << "," 
//                                      << j << ") going to spectrum " << s << std::endl;
                        }
                }
        }
// we may have junk in the POSLUT, so check value found
        if (m_highspec >= DAESPECMAX)
        {
                m_highspec = DAESPECMAX;
        }
//      m_dae2persize = m_highspec + 1;
        message << "Highest DAE2 spectrum: " << m_highspec << "\n";
        message << "Number of position: " << np << "\n";
        message << "MPOS: " << mpos_min << " to " << mpos_max << "\n";
        message << "MODN: " << modn_min << " to " << modn_max << "\n";
        status.addInfo(FAC_DETCARD, message.str());
        return 0;
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::programPOSLUT(int cards[], int dims[], int pos_start[],
                                                                int npos[], int spec[], int spec_step[], 
                                                                int nblocks, int nperiods, int dae1persize, DAEstatus& status)
{
        std::ostringstream message;
        int i, j, s, np;
        m_highspec = 0;
        np = 0;
        m_dae1persize = dae1persize;
        m_nperiods = nperiods;
        memset(m_poslut, 0, DCPOSLUTSIZE * sizeof(isisU32_t));
        for(i=0; i<DAESPECMAX; i++)
        {
                m_dae1specmap[i] = NOSPECTRUM;
                m_dae2specmap[i] = NOSPECTRUM;
        }
        m_dae1specmap[0] = 0;   // map spectrum 0 
        m_dae2specmap[0] = 0;   // map spectrum 0
        for(i=0; i<nblocks; i++)
        {
                if (cards[i] != m_position)
                {
                        continue;
                }
                s = spec[i];
                for(j=0; j<npos[i]; j++)
                {
                        m_poslut[DCPOSMAX * dims[i] + pos_start[i] + j] = s;
                        m_dae1specmap[s] = s;
                        m_dae2specmap[s] = s;
                        if (s > m_highspec)
                        {
                                m_highspec = s;
                        }
                        s += spec_step[i];
                        np++;
                }
        }
        m_dae2persize = m_highspec + 1;
        message << "Card: " << m_position << " DAE2 Highest: " << m_highspec << "NPOS:  " << np << std::endl;
        if (m_highspec > DAESPECMAX)
        {
         status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                         "Detector Card %d has too many spectra: %d",
                         m_position, m_highspec); 
        }
        status.addInfo(FAC_DETCARD, message.str());
        return writePOSLUTMemory(0, m_poslut, DCPOSLUTSIZE, status);
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::programDAE1POSLUT(int crat[], int modn[], 
                                                                int mpos[], int spec[], int ndet,
                                                                int nperiods, int dae1persize, DAEstatus& status)
{
        std::ostringstream message_i, message_e, message_w;
        int i, j, s, dae1min, dae1max, npos, ngap;
        bool card_used;
        int modn_min=1000000, modn_max=-1, mpos_min=1000000, mpos_max=-1;
        npos = 0;
        memset(m_poslut, 0, DCPOSLUTSIZE * sizeof(isisU32_t));
        m_dae1persize = dae1persize;
        m_nperiods = nperiods;
        if (ndet > DAESPECMAX)
        {
                status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, "Too may spectra - DAESPECMAX needs increasing to more than %d", ndet);
                return ISISVME::Error;
        }
        if (m_mode & ModeSEData)
        {
                return programDAE1POSLUTDataDae(status);
        }
        for(i=0; i<DAESPECMAX; i++)
        {
                m_dae1specmap[i] = NOSPECTRUM;
                m_dae2specmap[i] = NOSPECTRUM;
        }
        m_dae1specmap[0] = 0;   // map spectrum 0 - will remove later if card not used
        m_dae2specmap[0] = 0;   // map spectrum 0 - will remove later if card not used
// find all DAE1 spectra on this card and 
// assign dummy DAE2 spectrum number of 1
        dae1max = -1;
        dae1min=1000000;
        card_used = false;
        for(i=0; i<ndet; i++)
        {
                if (crat[i] == m_position)
                {
                        card_used = true;
                        if (spec[i] != 0) // do not remap spectrum 0
                        {
                                m_dae1specmap[spec[i]] = SPECTRUM_PLACEHOLDER;
                        }
                        if (spec[i] > dae1max)
                        {
                                dae1max = spec[i];
                        }
                        if (spec[i] < dae1min)
                        {
                                dae1min = spec[i];
                        }
                }
        }
// now assign them sequential DAE2 spectrum numbers
        ngap = 0;
        m_highspec = 0;
        for(i=dae1min; i<=dae1max; i++)
        {
                if (m_dae1specmap[i] == SPECTRUM_PLACEHOLDER)
                {
                        m_dae1specmap[i] = ++m_highspec;
                        m_dae2specmap[m_highspec] = i;
                }
                else
                {
                        ngap++;
                }
        }
        if (m_highspec > DCMAXSPECPOSLUT)
        {
                status.addVa(FAC_DETCARD, SEV_WARNING, ERRTYPE_INVCARD, "Too many spectra for poslut %d > %d", m_highspec, DCMAXSPECPOSLUT);
                return ISISVME::Error;
        }
        m_dae2persize = m_highspec + 1;
        if (ngap > 0)
        {
                message_i << "There is a gap of total size " << ngap << " in the DAE1 spectra on the card" << std::endl;
        }
// now assign spectra for periods
        if (m_dae2persize * m_nperiods >= DAESPECMAX)
        {
        status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                         "Detector Card %d has too many spectra * periods: %d > %d",
                         m_position, m_dae2persize * m_nperiods, DAESPECMAX); 
                return ISISVME::Error;
        }
        if (m_nperiods * m_dae1persize + m_highspec >= DAESPECMAX)
        {
        status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                         "Detector Card %d has too many spectra * periods: %d > %d",
                         m_position, m_dae1persize * m_nperiods + m_highspec, DAESPECMAX); 
                return ISISVME::Error;
        }
        for(i=0; i<m_dae2persize; i++)
        {
                s = m_dae2specmap[i];
                if (s != NOSPECTRUM)   // not sure if this really occurs for neutrons, but needed in MuonDetetcorCard so do here for symmetry
                {
                        for(j=1; j<m_nperiods; j++)
                        {
                                m_dae2specmap[i + j * m_dae2persize] = s + j * m_dae1persize;
                                m_dae1specmap[s + j * m_dae1persize] = i + j * m_dae2persize;
                        }
                }
        }
        m_highspec = m_nperiods * m_dae2persize - 1;
        // now calculate the POSLUT
        for(i=0; i<ndet; i++)
        {
                if (crat[i] == m_position)
                {
                        npos++;
                        if (mpos[i] < mpos_min)
                        {
                                mpos_min = mpos[i];
                        }
                        if (modn[i] < modn_min)
                        {
                                modn_min = modn[i];
                        }
                        if (mpos[i] > mpos_max)
                        {
                                mpos_max = mpos[i];
                        }
                        if (modn[i] > modn_max)
                        {
                                modn_max = modn[i];
                        }
                        j = m_dae1specmap[spec[i]];
                        if (j >= 0)
                        {
                                m_poslut[DCPOSMAX * modn[i] + mpos[i]] = j;
                        }
                        else
                        {
                                message_e << "DetectorCard: Error in mapping for dae1 spectrum " << spec[i] << " -> dae2 spectrum " << j << std::endl;
                        }
                }
        }
        if (card_used)
        {
            message_i << "Card: " << m_position << " DAE2 Highest: " << m_highspec 
                    << " DAE1 low: " << dae1min << " DAE1 high: " << dae1max
                    << " NPOS: " << npos << std::endl;
                message_i << "MPOS: " << mpos_min << " to " << mpos_max << std::endl;
                message_i << "MODN: " << modn_min << " to " << modn_max << std::endl;
        }
        else
        {
                message_w << "*** Detector Card " << m_position << " not used" << std::endl;
                m_dae1specmap[0] = NOSPECTRUM;  // unmap spectrum 0 - this is so we don't pick it up by accident on a scan of Addmaps on cards 
                m_dae2specmap[0] = NOSPECTRUM;  // unmap spectrum 0
        }
        if (message_i.str().size() > 0)
        {
                status.addInfo(FAC_DETCARD, message_i.str());
        }
        if (message_w.str().size() > 0)
        {
                status.add(FAC_DETCARD, SEV_WARNING, ERRTYPE_INVCARD, message_w.str());
        }
        if (message_e.str().length() > 0)
        {
                status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, message_e.str());
        }
        // check enough memory on card 
    isisU32_t nchan, mem_needed; 
    getSpectrumSize(&nchan, status); 
    mem_needed = 4 * m_nperiods * m_dae2persize * nchan; // bytes 
        if (isEventMode(status))
        {
                status.addInfoVa(FAC_DETCARD, "Card %d using event mode - equivalent card histogram memory needed would be %d MBytes", 
                                                        position(), mem_needed / (1024 * 1024));
        }
        else if (mem_needed > m_memsize) 
    { 
         status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                         "Detector Card %d has too little memory: %d < %d bytes",
                         m_position, m_memsize, mem_needed); 
    } 
        else
        {
                status.addInfoVa(FAC_DETCARD, "Card %d using %d of %d bytes of available histogram memory", 
                                                        position(), mem_needed, m_memsize);
        }
        return writePOSLUTMemory(0, m_poslut, DCPOSLUTSIZE, status);
}


// read len 4 byte words
template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::readHistogramMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status)
{
        ICPCritical cs(&m_critical);
        ISISVME::TransferProps props = ISISVME::TransferBlock | ISISVME::TransferLittleEndian | ISISVME::TransferRunMemorySpace;
        int /*i,*/ stat;
//      std::cerr << "Reading dc histogram memory start,len = " << start << "," << len << " to address " << buffer << " from card " << m_position << std::endl;
        if ( (m_memsize == 0) || ((start + 4 * len) <= m_memsize) )
        {
            stat = readMemory(start + DCMEMSTART, buffer, len, props, status);
//              for(i=0; i<len; i++)
//              {
//                      reverseEndian(&buffer[i]);
//              }
                return stat;
        }
        else
        {
                std::ostringstream message;
                message << "readHistogramMemory: not enough memory on card for address range 0x" << std::hex << start << " to 0x" << start + 4*len << std::dec << std::endl;
                status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, message.str());
                return ISISVME::Error;
        }
}

template <class DetCardPolicy>
isisU32_t DetectorCard<DetCardPolicy>::sumHistogramMemory(DAEstatus& status)
{
        ISISVME::TransferProps props = ISISVME::TransferBlock | ISISVME::TransferLittleEndian | ISISVME::TransferRunMemorySpace;
        int stat = ISISVME::Error;
        int i, len, max_i;
//      int chunk_len = 1024 * 1024;
        std::ostringstream message;
        isisU32_t sum = 0;
        isisU32_t* buffer = 0;
        len = m_memsize / 4;
        if (len > 0)
        {
                buffer = new isisU32_t[len];
//          stat = readMemoryChunked(DCMEMSTART, buffer, len, chunk_len, true, true, status);
            stat = readMemory(DCMEMSTART, buffer, len, props, status);
        }
        max_i = -1;
        if (stat == ISISVME::Error)
        {
                message << "sumHistogramMemory: ERROR" << std::endl;
                status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, message.str());
        }
        else
        {
                for(i=0; i<len; i++)
                {
                        sum += buffer[i];
                        if (buffer[i] > 0)
                        {
                                max_i = i;
                        }
                }
        }
        if (buffer != 0)
        {
                delete []buffer;
        }
        status.addInfoVa(FAC_DAE, "Detector card at position %d has memory sum %u, last non zero location after %d words\n", m_position, sum, max_i);
        return sum;
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::writeHistogramMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status)
{
        ISISVME::TransferProps props = ISISVME::TransferBlock | ISISVME::TransferLittleEndian | ISISVME::TransferRunMemorySpace;
        if ( (m_memsize == 0) || ((start + 4 * len) <= m_memsize) )
        {
            return writeMemory(start + DCMEMSTART, buffer, len, 0, props, status);
        }
        else
        {
                std::ostringstream message;
                message << "writeHistogramMemory: not enough memory on card" << std::endl;
                status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, message.str());
                return ISISVME::Error;
        }
}
        
template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::readPOSLUTMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status)
{
        int i;
        setTCGAccessRegister(DCTPOSLUT, status);
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        readMemory(start + DCPOSLUT, buffer, len, props, status);
        for(i=0; i<len; i++)
        {
                buffer[i] &= DetCardPolicy::DCPOSLUTMASK;
        }
        return 0;
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::writePOSLUTMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status)
{
        setTCGAccessRegister(DCTPOSLUT, status);
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        return writeMemory(start + DCPOSLUT, buffer, len, (memory_check ? DCPOSLUTMASK : 0x0), props, status);
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::clearPOSLUTMemory(DAEstatus& status, unsigned long start, int len)
{
        setTCGAccessRegister(DCTPOSLUT, status);
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        return zeroMemory<isisU32_t>(start + DCPOSLUT, len, (memory_check ? DCPOSLUTMASK : 0x0), props, status);
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::readTCGLUTMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status)
{
//      setTCGAccessRegister(DCTTCGLUT);
// TCGLUT memory is 24 bit registers, but should read as 32 bit OK
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        return readMemory(start + DCTCGLUT, buffer, len, props, status);
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::writeTCGLUTMemory(unsigned long start, isisU32_t* buffer, int len, DAEstatus& status)
{
//      setTCGAccessRegister(DCTTCGLUT);
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        return writeMemory(start + DCTCGLUT, buffer, len, (memory_check ? 0xffffffff : 0x0), props, status);
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::setTCGAccessRegister(isisU32_t mask, DAEstatus& status)
{
        return writeRegister(DCTAC, mask, status);
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::setAndClearTCGAccessRegister(isisU32_t mask, DAEstatus& status)
{
        return setAndClearRegisterBits(DCTAC, mask, true, status);
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::readTCGAccessRegister(isisU32_t *value, DAEstatus& status)
{
        return readRegister(DCTAC, value, status);
}

// use isClearHistogramMemoryComplete() to check later
template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::clearHistogramMemoryStart(DAEstatus& status)
{
        m_last_address_read = m_memsize - 4;  // dae set this to 0 on a clear, so we cannot read it from dae here
        m_wrap_counter = 0;
        if (isRegisterUsed(DCTAC))
        {
                return setTCGAccessRegister(DCTHISCLE, status);
        }
        else
        {
                return writeRegister(DCRUNMEMCLEAR, 0x1, status);
        }
}

// the TCG clears the bit once the clar is completed
template <class DetCardPolicy>
bool DetectorCard<DetCardPolicy>::isClearHistogramMemoryComplete(DAEstatus& status)
{
    isisU32_t value;
        if (isRegisterUsed(DCTAC))
        {
                readTCGAccessRegister(&value, status);
                value &= DCTHISCLE;
        }
        else
        {
                readRegister(DCRUNMEMCLEAR, &value, status);
        }
        if (value)
        {
                return false;   // bit still set, clear still in progress
        }
        else
        {
                if (m_options & DetectorCard::EventMode)
                {
                        readRegister(DCADDLRR, &value, status);
                        // the DAE sets this to zero at begin, but should be "end of memory", so hack to allow for this
                        if (value != m_last_address_read)
                        {
                                LOGSTR_WARNING("zero last address workaround");
                                status.addWarning(FAC_DAE, "zero last address workaround");
                                writeRegister(DCADDLRR, m_last_address_read, status);
                        }
                }
                return true;    // bit reset, clear now finished
        }
}

// contains ntc+1
template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::readDescriptorTimeBinLimitRegister(isisU32_t* value, DAEstatus& status)
{
        if (m_options & DetectorCard::DelayedFrameSync)
        {
                readRegister(DCDESCRX, value, status);
        }
        else
        {
                setTCGAccessRegister(DCTDESCR, status);
                readRegister(DCDESCR, value, status);
        }
        *value &= 0xffff;
        return 1;
}

// contains ntc+1
template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::writeDescriptorTimeBinLimitRegister(isisU32_t value, DAEstatus& status)
{
        if (m_options & DetectorCard::DelayedFrameSync)
        {
                return writeRegister(DCDESCRX, value, status);
        }
        else
        {
                setTCGAccessRegister(DCTDESCR, status);
                return writeRegister(DCDESCR, value, status);
        }
}

// contains ntc
template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::readTCGTimeBinLimitRegister(isisU32_t* value, DAEstatus& status)
{
        readRegister(DCTCGTBL, value, status);
        *value &= 0xffff;
        return 1;
}

// contains ntc
template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::writeTCGTimeBinLimitRegister(isisU32_t value, DAEstatus& status)
{
        return writeRegister(DCTCGTBL, value, status);
}
                
template <class DetCardPolicy>
DetectorCard<DetCardPolicy>::DetectorCard(int position, ISISVME* vme, int* specmap_array, int specmap_len, DAEstatus& status) : DAE2Card(position, vme, status), m_highspec(0), m_memsize(0), 
        m_nperiods(1), m_dae1persize(0), m_dae2persize(0), m_options(0), m_reg(this), m_last_address_read(0),m_wrap_counter(0),
        m_dae1specmap(DAESPECMAX),m_dae2specmap(DAESPECMAX),m_mode(ModeNeutronData)
{
        int i;
        setLoggerName("DetectorCard");
        std::ostringstream message;
        isisU32_t value;
        DAEstatus temp_status;
        InitializeCriticalSection(&m_critical);

   // check for card features 
    if (readRegister(DCPERCNT0, &value, temp_status, false, false) == 1) 
    { 
          message << "This Card Supports HARDWARE periods" << "\n"; 
          m_options |= (int)DetectorCard::HardwarePeriods; 
    } 
        temp_status.clear(SEV_ERROR, SEV_GE);
    if (readRegister(DCVETOFLAG /* DCVETOENABLE */, &value, temp_status, false, false) == 1) 
    { 
          message << "This Card Supports VETO logging" << "\n"; 
          m_options |= (int)DetectorCard::VetoLogging; 
    } 
        temp_status.clear(SEV_ERROR, SEV_GE);
        if (readRegister(DCFSDEL0, &value, temp_status, false, false) == 1)
        {
          message << "This Card supports delayed frame sync" << "\n"; 
                  m_options |= (int)DetectorCard::DelayedFrameSync; 
        }
        temp_status.clear(SEV_ERROR, SEV_GE);
        if (readRegister(DCNXFRMR, &value, temp_status, false, false) == 1)
        {
          message << "This Card supports Event Mode data collection" << "\n"; 
                  m_options |= (int)DetectorCard::EventMode; 
        }
        temp_status.clear(SEV_ERROR, SEV_GE);
        if (readRegister(DCTOTCNTS, &value, temp_status, false, false) == 1) 
    { 
          message << "This Card has a total counts register" << "\n"; 
                  m_options |= (int)DetectorCard::TotalCounts; 
    }
        temp_status.clear(SEV_ERROR, SEV_GE);

        m_poslut = new isisU32_t[DCPOSLUTSIZE];
        m_dae1specmap.resize(DAESPECMAX, NOSPECTRUM);
        m_dae2specmap.resize(DAESPECMAX, NOSPECTRUM);
        m_dae1specmap[0] = 0;
        m_dae2specmap[0] = 0;
        readPOSLUT(status);
//      printTimeChannels(cout, 0, 100);

        if (specmap_array != NULL)
        {
                loadDAE2SpecmapFromArray(specmap_array, specmap_len, status);
        }
        else
        {   
                // just map 1 to 1 with DAE1 spectra; we have no better info
                for(i=1; i<=m_highspec; i++)
                {
                        m_dae2specmap[i] = i;
                }
        }
        recreateDAE1Specmap(status);
        
// determine memory size
        int j;
                bool done = false;
                isisU32_t pattern = 0x01010101, zero = 0x0;
                isisU32_t save_start, temp1, temp2;
                readHistogramMemory(0, &save_start, 1, status);
                writeHistogramMemory(0, &zero, 1, status);
//              for(j=1; j<70 && !done; j++)
                for(j=64; j<65 && !done; j++)    // cards are either 64 or 128
                {
                        readHistogramMemory(j*1024*1024, &temp1, 1, status);
                        writeHistogramMemory(j*1024*1024, &pattern, 1, status);
                        readHistogramMemory(0, &temp2, 1, status);
                        writeHistogramMemory(j*1024*1024, &temp1, 1, status);
//                      message << "Wrote " << pattern << " read " << temp2 << " for MB = " << j << std::endl;
                        if (temp2 == pattern)
                        {
                                m_memsize = j * 1024 * 1024;
                                message << "The card has " << j << "Mb of memory" << std::endl;
                                status.addInfo(FAC_DETCARD, message.str());
                                done = true;
                        }
                        pattern++;
                }
                writeHistogramMemory(0, &save_start, 1, status);
                // fix for 128 Mb cards - they do not wrap as the address would be a valid one for the
                // next card in the crate. We should only have either 64 or 128 so have to assume 128
                // if unable to determine memory
                if (!done)
                {
                        m_memsize = 128 * 1024 * 1024;
                        done = true;
                        status.addInfo(FAC_DETCARD, "Unable to determine card memory size; assuming 128Mb");
                }
                if (!done)
                {
                        status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, "Cannot determine card memory");
                }
                if (m_options & DetectorCard::EventMode)
                {
                        readRegister(DCADDLRR, &m_last_address_read, status);
                        readRegister(DCNMEMWR, &m_wrap_counter, status);
                }
    printStatus(message, status);
        status.addInfo(FAC_ENVCARD, message.str());
}

// format is m_position m_highspec m_dae2specmap[0->m_highspec]
template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::loadDAE2SpecmapFromArray(int* array, int len, DAEstatus& status)
{
        bool found = false;
        int i, highspec = 0, offset = 0;
        while(!found && (offset < len))
        {
                highspec = array[offset+1];
                if (array[offset] == m_position)
                {
                        found = true;
                }
                else
                {
                        offset += (highspec + 3);
                }
        }
        if (!found)
        {
                status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, "Error loading detector card");
                return 0;
        }
        if (highspec != m_highspec)
        {
                status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, "Detector card spectrum problem");
                return 0;
        }
        for(i=0; i<=m_highspec; i++)
        {
                m_dae2specmap[i] = array[i+offset+2];
        }
//      m_dae2persize = m_highspec + 1;
        return 0;
}

// format is m_position m_highspec m_dae2specmap[0->m_highspec]
template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::saveDAE2SpecmapToArray(int* array, int offset, int len, DAEstatus& status)
{
        int i, new_offset = offset + m_highspec + 3;
        if (new_offset <= len)
        {
        array[offset] = m_position;
            array[offset+1] = m_highspec;
                for(i=0; i<=m_highspec; i++)
                {
                        array[i+offset+2] = m_dae2specmap[i];
                }
                return new_offset;
        }
        else
        {
                status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, "Not enough room for specmap");
                return 0;
        }
}

// recreate m_dae1specmap from m_dae2specmap
template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::recreateDAE1Specmap(DAEstatus& status)
{
        std::ostringstream message;
        int i, j, dae1_high = 0, dae1_low = 999999;
        bool gap = false;
        for(i=0; i<DAESPECMAX; i++)
        {
                m_dae1specmap[i] = NOSPECTRUM;
        }
        m_dae1specmap[0] = 0;    // dae1 0 -> dae2 0
        for(i=1; i<=m_highspec; i++)
        {
                j = m_dae2specmap[i];
                if (j != NOSPECTRUM)
                {
                        if (j > dae1_high)
                        {
                                dae1_high = j;
                        }
                        if (j < dae1_low)
                        {
                                dae1_low = j;
                        }
                        m_dae1specmap[j] = i;
                }
                else
                {
                        gap = true;
                }
        }
        if (gap)
        {
                status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, "ERROR: Gap detected in DAE2 specmap");
        }
    message << "Recreated DAE1 specmap with DAE1 spec range " << dae1_low << " to " << dae1_high << std::endl;
        if ( (dae1_high - dae1_low + 1) != m_highspec )
        {
                message << "DAE1 and DAE2 spectra not contiguous" << std::endl;
        }
        status.addInfo(FAC_DETCARD, message.str());
        return 0;
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::changeNumberOfPeriods(int nperiod, DAEstatus& status)
{
        if (nperiod <= 0)
        {
                status.addWarning(FAC_DETCARD, "Cannot change number of periods; nperiod <= 0");
                return ISISVME::Error;
        }
        if (m_dae2persize <= 0 || m_dae1persize <= 0)
        {
                status.addWarning(FAC_DETCARD, "Cannot change number of periods; do not know DAE2 period size");
                return ISISVME::Error;
        }
        if (m_dae2persize * nperiod >= DAESPECMAX)
        {
        status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD,  
                         "Detector Card %d has too many spectra * periods: %d > %d",
                         m_position, m_dae2persize * nperiod, DAESPECMAX); 
                return ISISVME::Error;
        }
        if (nperiod * m_dae1persize + m_dae2persize >= DAESPECMAX)
        {
        status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD,   
                         "Detector Card %d has too many spectra * periods: %d > %d",
                         m_position, m_dae1persize * nperiod + m_dae2persize, DAESPECMAX); 
                return ISISVME::Error;
        }
        // check enough memory on card 
    isisU32_t nchan, mem_needed; 
    getSpectrumSize(&nchan, status); 
        if (nchan > 0)
        {
        mem_needed = 4 * nperiod * m_dae2persize * nchan; // bytes 
            if ( !isEventMode(status) && (mem_needed > m_memsize) )
            {
             status.addWarningVa(FAC_DETCARD, 
                             "Detector Card %d has too little memory for %d periods: %d < %d bytes",
                             m_position, nperiod, m_memsize, mem_needed); 
                    return ISISVME::Error;
                }
    } 
        m_nperiods = nperiod;
        int i, j, s;
        for(i=m_dae2persize; i<m_dae2specmap.size(); ++i)
        {
                m_dae2specmap[i] = NOSPECTRUM;
        }
        for(i=m_dae1persize; i<m_dae1specmap.size(); ++i)
        {
                m_dae1specmap[i] = NOSPECTRUM;
        }
        for(i=0; i<m_dae2persize; ++i)
        {
                s = m_dae2specmap[i];
                if (s != NOSPECTRUM)    // we need this test for muons as may be unassigned DAE2 spectra due to no POSLUT
                {
                        for(j=1; j<m_nperiods; ++j)
                        {
                                m_dae2specmap[i + j * m_dae2persize] = s + j * m_dae1persize;
                                m_dae1specmap[s + j * m_dae1persize] = i + j * m_dae2persize;
                        }
                }
        }
        m_highspec = m_nperiods * m_dae2persize - 1;
        return ISISVME::Success;
}

// period 0 is the first period with detectors going into
// DAE2 spectra 0, 1, 2, 3 ... N (=m_highspec) etc
// period 1 will have it going into N+1, N+2, ..., 2*(N+1)-1
// period 2 will be      2*(N+1) ... 3*(N+1)-1
// 
template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::changePeriod(int period, DAEstatus& status)
{
        int i, j, s, period_incr;
        if (period >= m_nperiods)
        {
                status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, "Cannot change period to %d >= %d", period, m_nperiods);
                return ISISVME::Error;
        }
        if (m_dae2persize == 0)
        {
                status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, "Cannot change period; do not know DAE2 period size");
                return ISISVME::Error;
        }
        if (m_options & DetectorCard::HardwarePeriods)
        {
                return setPeriodCounter(period, status);
        }
        else
        {
                period_incr = period * m_dae2persize;
                for(i=0; i<DCDIMMAX; i++)
                {
                        for(j=0; j<DCPOSMAX; j++)
                        {
                                s = m_poslut[DCPOSMAX*i + j] % m_dae2persize; // make spectrum relative to first period
                                m_poslut[DCPOSMAX*i + j] = s + period_incr;
                                if (s + period_incr > DCMAXSPECPOSLUT)
                                {
                                        status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, "spectrum * period number too big for POSLUT");
                                        return ISISVME::Error;
                                }
                        }
                }
                return writePOSLUTMemory(0, m_poslut, DCPOSLUTSIZE, status);
        }
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::getDIMVetos(isisU16_t* dim_mask, DAEstatus& status)
{
         isisU32_t value;
         if (m_options & DetectorCard::VetoLogging) 
     {
                readRegister(DCVETOENABLE, &value, status);
                *dim_mask = (isisU16_t)(value >> 16);
         }
         else
         {
                 *dim_mask = 0;
         }
         return 0;
}

// set bit 0 for dim 0 etc
template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::enableDIMVetos(isisU16_t dim_mask, DAEstatus& status)
{
         if (m_options & DetectorCard::VetoLogging) 
     { 
                return setRegisterBits(DCVETOENABLE, (isisU32_t)dim_mask << 16, true, status);
         }
         else
         {
                 return 0;
         }
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::disableDIMVetos(DAEstatus& status)
{
         if (m_options & DetectorCard::VetoLogging) 
     { 
                return clearRegisterBits(DCVETOENABLE, 0xffff0000, status);
         }
         else
         {
                 return 0;
         }
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::clearVetoOccurredFlag(DAEstatus& status)
{
         if (m_options & DetectorCard::VetoLogging) 
     { 
                return writeRegister(DCVETOFLAG, 0, status);
         }
         else
         {
                 return 0;
         }
}

// set bit 0 for dim 0 etc
template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::readDIMVetoOccurredFlag(isisU16_t* dim_mask, DAEstatus& status)
{
    isisU32_t v;
         if (m_options & DetectorCard::VetoLogging) 
     { 
                readRegister(DCVETOFLAG, &v, status);
                *dim_mask = (isisU16_t)(v >> 16);
         }
         else
         {
                 *dim_mask = 0;
         }
        return 0;
}

template <class DetCardPolicy>
uint32_t DetectorCard<DetCardPolicy>::getVetoMask(DetectorCardVeto veto)
{
        switch(veto)
        {
                case FrameOverflowVeto:
                        return (1 << 15);
                case MemoryFullVeto:
                        return (1 << 14);
                case FIFOLateVeto:
                        return (1 << 13);
                default:
                        return 0;
        }
}

template <class DetCardPolicy>
const char* DetectorCard<DetCardPolicy>::getVetoName(DetectorCardVeto veto)
{
        switch(veto)
        {
                case FrameOverflowVeto:
                        return "FrameOverflowVeto";
                case MemoryFullVeto:
                        return "MemoryFullVeto";
                case FIFOLateVeto:
                        return "FIFOLateVeto";
                default:
                        return "UNKNOWN";
        }
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::enableVeto(DetectorCardVeto veto, DAEstatus& status)
{
        return setRegisterBits(DCVETOENABLE, getVetoMask(veto), true, status);
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::disableVeto(DetectorCardVeto veto, DAEstatus& status)
{
        return clearRegisterBits(DCVETOENABLE, getVetoMask(veto), status);
}

template <class DetCardPolicy>
bool DetectorCard<DetCardPolicy>::isVetoEnabled(DetectorCardVeto veto, DAEstatus& status)   
{
        return registerBitsSet(DCVETOENABLE, getVetoMask(veto), status);
}

template <class DetCardPolicy>
bool DetectorCard<DetCardPolicy>::hasVetoOccurred(DetectorCardVeto veto, DAEstatus& status) 
{
        return registerBitsSet(DCVETOFLAG, getVetoMask(veto), status);
}

template <class DetCardPolicy>
DetectorCard<DetCardPolicy>::~DetectorCard()
{
        delete []m_poslut;
        DeleteCriticalSection(&m_critical);
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::setPeriodCounter(int period, DAEstatus& status) 
   { 
       if (m_options & DetectorCard::HardwarePeriods) 
       { 
           return writeRegister32As16(DCPERCNT0, DCPERCNT1, period, status); 
       } 
       else 
       { 
                        status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, "HardwarePeriods not available");
            return 1; 
       } 
   } 
    
template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::setPeriodSize(int per_size, DAEstatus& status)   // in 32 bit words 
   { 
       if (m_options & DetectorCard::HardwarePeriods) 
           { 
               return writeRegister32As16(DCPERSIZE0, DCPERSIZE1, per_size, status); 
           } 
           else 
           { 
                        status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, "HardwarePeriods not available");
                   return 1; 
           } 
   } 
    
 template <class DetCardPolicy>
  int DetectorCard<DetCardPolicy>::getCurrentHardwarePeriod(isisU32_t* value, DAEstatus& status) 
   { 
       if (m_options & DetectorCard::HardwarePeriods) 
           { 
               readRegister16As32(DCPERCNT0, DCPERCNT1, value, status);
                           if (*value < 0 || *value >= m_nperiods)
                           {
                                   status.addWarningVa(FAC_DETCARD, "Detcard: DAQ Period %d invalid (>%d)", *value+1, m_nperiods);
                           }
                           return ISISVME::Success;
           } 
           else 
           {
                           *value = 0;
                                status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, "HardwarePeriods not available");
                return ISISVME::Error; 
           } 
   } 
    
template <class DetCardPolicy>
   int DetectorCard<DetCardPolicy>::setPeriodType(bool hardware_periods, bool single_daq_period, DAEstatus& status) 
   { 
           isisU32_t value; 
           if (m_options & DetectorCard::HardwarePeriods) 
           { 
               m_hardware_periods = hardware_periods; 
               getSpectrumSize(&value, status);
                           // this is a workaround for noise on the backplane that can cause a period jump
                           if (single_daq_period)   
                           {
                                    setPeriodSize(0, status);
                           }
                           else
                           {
                                    setPeriodSize(m_dae2persize * value, status);
                           }
               setPeriodCounter(0, status); 
           } 
           else 
           {
                                m_hardware_periods = false;
                if (hardware_periods) 
                { 
                                    status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, "HardwarePeriods not available");
                } 
           } 
           return 0; 
   } 
        
template <class DetCardPolicy>
   int DetectorCard<DetCardPolicy>::getTotalCounts(isisU32_t* counts, DAEstatus& status)
   {
           if (m_options & DetectorCard::TotalCounts)
           {
                        return readRegister(DCTOTCNTS, counts, status);
           }
           else
           {
                   *counts = 0;
                   return ISISVME::Success;
           }
   }
   
template <class DetCardPolicy>
   int DetectorCard<DetCardPolicy>::clearTotalCountsRegister(DAEstatus& status)
   {
           if (m_options & DetectorCard::TotalCounts)
           {
                        return setAndClearTCGAccessRegister(DCTTOTCNTSCLE, status);
           }
           else
           {
                        return ISISVME::Success;
           }
   }

 template <class DetCardPolicy>
        int DetectorCard<DetCardPolicy>::getFrameSyncDelay(isisU32_t* value, DAEstatus& status)
        {
                if (m_options & DetectorCard::DelayedFrameSync)
                {
                        return readRegister16As32(DCFSDEL0, DCFSDEL1, value, status);
                }
                else
                {
                        *value = 0;
                        return ISISVME::Success;
                }
        }

template <class DetCardPolicy>
        int DetectorCard<DetCardPolicy>::setFrameSyncDelay(isisU32_t value, DAEstatus& status)
        {
                if (m_options & DetectorCard::DelayedFrameSync)
                {
                        return writeRegister32As16(DCFSDEL0, DCFSDEL1, value , status);
                }
                else if (value == 0)
                {
                        return ISISVME::Success;
                }
                else
                {
                        status.add(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                                "Attempt to set a non-zero frame sync delay on a card without such support");
                        return ISISVME::Error;
                }
        }


// if (pattern == 0) fill with test pattern where upper bits are card address 
// and lower bits are memory location offset
// otherwise fill all of memory with pattern

#define MAKE_TEST_PATTERN(addr) ( ((addr) << 4) + m_position )    // write card ID as botton 4 bits

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::fillWithTestPattern(unsigned long pattern, DAEstatus& status)
{
        int n;
        bool done = false;
        unsigned long i, j, start;
        const int bufsize = 100000;
        isisU32_t* buffer = new isisU32_t[bufsize];
        start = 0;
        while(!done)
        {
                if (start + 4*bufsize < m_memsize)
                {
                        n = bufsize;
                }
                else
                {
                        n = (m_memsize - start) / 4;
                        done = true;
                }
                for(i=0; i<n; i++)
                {
                        j = i + start / 4;
                        if (0 == pattern)
                        {
                                buffer[i] = MAKE_TEST_PATTERN(j);  
                        }
                        else if (1 == pattern)
                        {
                                buffer[i] = rand();
                        }
                        else
                        {
                                buffer[i] = pattern;
                        }
                }
                writeHistogramMemory(start, buffer, n, status);
                start += 4*n;
        }
        delete[] buffer;
        return ISISVME::Success;
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::checkTestPattern(unsigned long pattern, DAEstatus& status)
{
        int n;
        bool done = false;
        unsigned long i, start, j;
        int nerror = 0;
        const int bufsize = 100000, max_error = 20;
        isisU32_t* buffer = new isisU32_t[bufsize];
        start = 0;
        unsigned long tpattern;
        ICPTimer icptimer("checkTestPattern(DC)", status);
        while(!done)
        {
                if (start + 4*bufsize < m_memsize)
                {
                        n = bufsize;
                }
                else
                {
                        n = (m_memsize - start) / 4;
                        done = true;
                }
                readHistogramMemory(start, buffer, n, status);
                for(i=0; i<n; i++)
                {
                        j = i + start / 4;
                        if (0 == pattern)
                        {
                                tpattern = MAKE_TEST_PATTERN(j);
                        }
                        else
                        {
                                tpattern = pattern;
                        }
                        if (buffer[i] != tpattern)
                        {
                                if (nerror < max_error)
                                {
                                        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Error at offset %d on card %d", j, m_position);
                                }
                                ++nerror;
                        }
                }
                start += 4*n;
        }
        if (nerror > 0)
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, 
                        "There were %d error(s) on card %d (only first %d printed)", nerror, m_position, max_error);
        }
        else
        {
                status.addInfoVa(FAC_DAE, "There were no errors on card %d (%d MB checked)", m_position, m_memsize / (1024 * 1024));
        }
        delete[] buffer;
        return status.result();
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::whichVeto(std::ostream& os, DAEstatus& status)
{
        if (m_options & DetectorCard::VetoLogging)
        {
                printVetoStatus(os, true, status);
        }
        return ISISVME::Success;
}

template <class DetCardPolicy>
   int DetectorCard<DetCardPolicy>::setEventCollectionMode(bool enable, DAEstatus& status)
   {
           LOGSTR_DEBUG("Setting event collection mode to " << enable);
           if (enable)
           {
                   if (m_options & DetectorCard::EventMode)
                   {
                           m_reg.event_reg.eventMode(true, status);
                           m_reg.event_reg.enable32bitEvents(status);
                           m_reg.event_reg.allVetoesInHeader(false, status);
                           m_reg.event_reg.storeVetodData(false, status);
                           m_reg.event_reg.setHeaderType(EventModeRegister<DetCardPolicy>::NormalEventHeader, status); 
                           return ISISVME::Success;
                   }
                   else
                   {
                           return ISISVME::Error;
                   }
           }
           else
           {
                        if (m_options & DetectorCard::EventMode)
                        {
                                m_reg.event_reg.eventMode(false, status);
                        }
                        return ISISVME::Success;
           }
   }


template <class DetCardPolicy>
void DetectorCard<DetCardPolicy>::updateDAEEventLastRead(DAEstatus& status)
{
        if ( !isEventMode(status) )
        {
                return;
        }
        isisU32_t last_mem_write;
        LOGSTR_DEBUG("Updating dae address to " << m_last_address_read);
        readRegister(DCNXMEMWR, &last_mem_write, status);
        writeRegister(DCADDLRR, m_last_address_read, status);
        unsigned bytes_diff = (m_memsize + m_last_address_read - last_mem_write) % m_memsize;
        if (bytes_diff < 4096)
        {
                LOGSTR_WARNING("memory nearly full only " << bytes_diff << " free");
        }
}

template <class DetCardPolicy>
uint32_t DetectorCard<DetCardPolicy>::getNewEvents(isisU32_t* buffer, uint32_t maxlen, uint64_t& num_unread, 
                                                                bool& run_ended, DAEstatus& status)
{
        if ( !isEventMode(status) )
        {
                num_unread = 0;
                run_ended = true;
                return 0;
        }
        isisU32_t value32;
        isisU16_t value16;
        std::string error_message;
        uint32_t len;
        num_unread = 0;
        run_ended = false;
        readRegister(DCADDLRR, &value32, status);
        if (value32 != m_last_address_read)
        {
                LOGSTR_WARNING("DAE and ICP disagree on last value read - dae " << value32 << " icp " << m_last_address_read);
                m_last_address_read = value32;
                //throw std::runtime_error("DAE and ICP disagree on last value read");
        }
        poco_assert(m_last_address_read % 4 == 0);
        int start_address = (m_last_address_read + 4) % m_memsize;
        uint32_t new_words = static_cast<uint32_t>(nNewEventWords(status));    // we cannot evenr have uint64 words on this card
        LOGSTR_DEBUG("new words in dae " << new_words << " starting from address " << start_address);
        if (new_words == 0)
        {
                // we may have ended the run - see if there is an end run header present
                readRegister(DCNXMEMWR, &value32, status);
                if ( (m_memsize + value32 - start_address) % m_memsize >= sizeof(DAEEventHeader) )
                {
                        DAEEventHeader temp_head;
                        readHistogramMemoryWrapped(start_address, reinterpret_cast<isisU32_t*>(&temp_head), DAE_EVENT_HEADER_WORDS, status);
                        int iret = DAEEventList::checkEventHeader(&temp_head, error_message);
                        if (iret == 0)
                        {
                                run_ended = DAEEventList::isEndRunHeader(&temp_head, status);
                        }
                        else if (iret != 0x20)  // 0x20 means dummy pre-frame header is present 
                        {
                                LOGSTR_WARNING("No new events, but invalid header present " << error_message)
                        }
                }
                if (run_ended)
                {
                        LOGSTR_INFORMATION("End header present");
                }
                return 0; // no new data
        }
        if (new_words > maxlen)
        {
                num_unread = new_words - maxlen;
                len = maxlen;
        }
        else
        {
                len = new_words;
        }
        if (readHistogramMemoryWrapped(start_address, buffer, len, status))
        {
                ++m_wrap_counter;
                readRegister(DCNMEMWR, &value16, status);
                LOGSTR_NOTICE("Detector card memory wrapped, count = " << value16);
                if (value16 != m_wrap_counter)
                {
                        LOGSTR_WARNING("mismatch in event memory wrap count: dae = " << value16 << ", icp = " << m_wrap_counter);
//                      throw std::runtime_error("mismatch in event memory wrap count");
                }
        }
        m_last_address_read = (m_last_address_read + 4 * len) % m_memsize;
        return len;
}

template <class DetCardPolicy>
bool DetectorCard<DetCardPolicy>::readHistogramMemoryWrapped(unsigned long start, isisU32_t* buffer, uint32_t len, DAEstatus& status)
{
        poco_assert( start % 4 == 0 );
        poco_assert( start < m_memsize );
        poco_assert( 4 * len <= m_memsize );
    uint32_t end_limit = (start + 4 * len) % m_memsize;
        if (end_limit > start)
        {
                readHistogramMemory(start, buffer, len, status);
                return false;
        }
        else  // memory wrapped
        {
                unsigned  len1 = (m_memsize - start) / 4;
                unsigned  len2 = end_limit / 4;
                poco_assert(len == len1 + len2);
                readHistogramMemory(start, buffer, len1, status);
                readHistogramMemory(0, buffer + len1, len2, status);
                return true;
        }
}


template <class DetCardPolicy>
uint64_t DetectorCard<DetCardPolicy>::nNewEventWords(DAEstatus& status)
{
        if ( !isEventMode(status) )
        {
                return 0;
        }
        isisU32_t next_dae_frame_address;
        readRegister(DCNXFRMR, &next_dae_frame_address, status);
        poco_assert(next_dae_frame_address % 4 == 0);
        uint32_t num_bytes = (m_memsize + next_dae_frame_address - m_last_address_read - 4) % m_memsize;
        poco_assert(num_bytes % 4 == 0);
//      int fake_max = 1024;
//      if (num_bytes > fake_max)
//      {
//              num_bytes = fake_max;
//      }
        return num_bytes / 4;
}


template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::resetCardState(DAEstatus& status)
{
        LOGSTR_INFORMATION("Resetting card state");
        ISISVME::TransferProps props = ISISVME::TransferLUTSpace;
        uint32_t check_mask = 0x0;
// mantalk 0 %1 40000 C0000000
        writeRegister(DCTAC, 0xC0000000, status);
// mantalk 0 %1 80000 0 20000
        zeroMemory<isisU32_t>(DCTCGLUT, DCTCGLUTSIZE, check_mask, props, status);  // 0x20000 = 131072
// mantalk 0 %1 0 0 E
        zeroMemory<isisU32_t>(0, 0xE, check_mask, ISISVME::TransferIORegisterSpace, status);
// mantalk 0 %1 40010 0
        writeRegister(DCEVNTMD, 0x0, status);
// mantalk 0 %1 40080 0 2
        writeRegister(DCDESCRX, 0x0, status);
        writeRegister(DCTCGTBL, 0x0, status);
        return ISISVME::Success;
}

template <class DetCardPolicy>
void DetectorCard<DetCardPolicy>::setCardMode(DetectorCardMode mode)
{
        if (m_mode == mode)
        {
                return;
        }
        if (mode != ModeSEData)
        {
                LOGSTR_ERROR("Cannot change mode from SE");
                return;
        }
        m_mode = mode; 
}

template <class DetCardPolicy>
int DetectorCard<DetCardPolicy>::programDAE1POSLUTDataDae(DAEstatus& status)
{
        int i;
        for(i=0; i<DAESPECMAX; i++)
        {
                m_dae1specmap[i] = NOSPECTRUM;
                m_dae2specmap[i] = NOSPECTRUM;
        }
//      m_dae1specmap[0] = 0;   // do not map spectrum 0 as card is unused
//      m_dae2specmap[0] = 0;   // do not map spectrum 0 as card is unused
        m_highspec = 0;
        m_dae2persize = m_highspec + 1;
        m_highspec = m_nperiods * m_dae2persize - 1;
        status.addInfoVa(FAC_DETCARD, "Programming Card %d for sample environment data", position());
        // poslut needs to be consqcquitive integeers
        for(i=0; i < DCPOSLUTSIZE; ++i)
        {
                m_poslut[i] = i;
        }
        return writePOSLUTMemory(0, m_poslut, DCPOSLUTSIZE, status);
}

const int DetectorCardIntf::NOSPECTRUM = -1;
const int DetectorCardIntf::SPECTRUM_PLACEHOLDER = -2;

template class DetectorCard<DAE2DetCardPolicy>;
template class DetectorCard<DAE3DetCardPolicy>;