sim_detector_card.cpp

Go to the documentation of this file.

#include "stdafx.h"

#include "sim_detector_card.h"
#include "vme_simulation.h"
#include "isisvme.h"
#include "dae_events.h"

#define DET_MEM_LEN     (32*1024*1024)   // 128Mb
//#define DET_MEM_LEN   (16*1024*1024)   // 64Mb

template <class DetCardPolicy>
isisU32_t* SIMDetectorCard<DetCardPolicy>::m_shared_detMemory = NULL;

template <class DetCardPolicy>
SIMDetectorCard<DetCardPolicy>::SIMDetectorCard(int position, VMESimulationIface* vme, bool shared, FaultMode fault_mode, bool neutron_data, DAEstatus& status) :
    SIMDAE2Card(position, vme, (1 << 31), false, Working, status)
{
        setLoggerName("SIMDetectorCard");
        m_neutron_data = neutron_data;
        m_type = DetCard;
        if (shared)
        {
                if (m_shared_detMemory == NULL)
                {
                        m_shared_detMemory = new isisU32_t[DET_MEM_LEN];
                }
                m_detMemory = m_shared_detMemory;
        }
        else
        {
                m_detMemory = new isisU32_t[DET_MEM_LEN];
        }
    m_poslutMemory = new isisU32_t[DCPOSLUTSIZE];
        m_tcglutMemory = new isisU32_t[DCTCGLUTSIZE];
        isisU32_t* tcg_access = NULL;
        if (isRegisterUsed(DCTAC))
        {
                tcg_access = &m_tcgAccessRegister;
                addMapping(ISISVME::TransferIORegisterSpace, DCTAC, 1, &m_tcgAccessRegister, "", true, true, NULL, 0, false, false, fault_mode);
        }
        addMapping(ISISVME::TransferIORegisterSpace, DCTCGTBL, 1, &m_tcgTimeBinLimitRegister, "", true, true, NULL, 0, false, false, fault_mode);
//      addMapping(ISISVME::TransferIORegisterSpace, DCTCGLUT, DCTCGLUTSIZE, m_tcglutMemory, "", true, true, tcg_access, DCTTCGLUT, false, false, fault_mode);
        addMapping(ISISVME::TransferLUTSpace, DCTCGLUT, DCTCGLUTSIZE, m_tcglutMemory, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, DCDESCR, 1, &m_descriptorTimeBinLimitRegister, "", true, true, tcg_access, DCTDESCR, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, DCDESCRX, 1, &m_descriptorTimeBinLimitRegister, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferLUTSpace, DCPOSLUT, DCPOSLUTSIZE, m_poslutMemory, "", true, true, tcg_access, DCTPOSLUT, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, DCVETOENABLE, 1, &m_vetoEnableRegister, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, DCVETOFLAG, 1, &m_vetoFlagRegister, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, DCPERSIZE0, 1, &m_periodSizeLow, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, DCPERSIZE1, 1, &m_periodSizeHigh, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, DCPERCNT0, 1, &m_periodCounterLow, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, DCPERCNT1, 1, &m_periodCounterHigh, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, DCTOTCNTS, 1, &m_totalCounts, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferRunMemorySpace, DCMEMSTART, DET_MEM_LEN, m_detMemory, "", true, true, NULL, 0, true, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, DCFSDEL0, 1, &m_fsdelay0, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, DCFSDEL1, 1, &m_fsdelay1, "", true, true, NULL, 0, false, false, fault_mode);

        addMapping(ISISVME::TransferIORegisterSpace, DCEVNTMD, 1, &m_eventModeReg, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, DCNXFRMR, 1, &m_nextFrameMarker, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, DCNXMEMWR, 1, &m_nextMemoryWrite, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, DCNMEMWR, 1, &m_numMemoryWraps, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, DCADDLRR, 1, &m_lastReadAddr, "", true, true, NULL, 0, false, false, fault_mode);

        addMapping(ISISVME::TransferIORegisterSpace, DCOPMODE, 1, &m_dcopmode, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, DCMUONSTEP, 1, &m_dcmuonstep, "", true, true, NULL, 0, false, false, fault_mode);

        addMapping(ISISVME::TransferIORegisterSpace, DCRUNMEMCLEAR, 1, &m_runMemoryClear, "", true, true, NULL, 0, false, false, fault_mode);
        

        m_periodSizeLow = m_periodSizeHigh = m_periodCounterLow = m_periodCounterHigh = 0;
        m_descriptorTimeBinLimitRegister = m_tcgAccessRegister = m_tcgTimeBinLimitRegister = 0;

        m_runMemoryClear = m_dcopmode = m_dcmuonstep = 0;

        m_eventModeReg = m_nextFrameMarker = m_nextMemoryWrite = m_numMemoryWraps = m_lastReadAddr = 0;
        m_lastReadAddr -= 4;
        LOGSTR_INFORMATION("SIMDetector card at position " << m_position << " for " << (m_neutron_data ? "neutron" : "sample environment") << " data");  
}

template <class DetCardPolicy>
int SIMDetectorCard<DetCardPolicy>::incrementPeriod()
{
        increment2(1, m_periodCounterLow, m_periodCounterHigh);
        return 0;
}

template <class DetCardPolicy>
int SIMDetectorCard<DetCardPolicy>::resetPeriod()
{
        m_periodCounterLow = m_periodCounterHigh = 0;
        return 0;
}

template <class DetCardPolicy>
void SIMDetectorCard<DetCardPolicy>::printStatus(std::ostream& os)
{
        os << "SIMDetector card at position " << m_position << " for " << (m_neutron_data ? "neutron" : "sample environment") << " data using policy " << DetCardPolicy::det_card_policy_name;  
}

template <class DetCardPolicy>
SIMDetectorCard<DetCardPolicy>::~SIMDetectorCard()
{
        if (m_detMemory != m_shared_detMemory)
        {
                delete []m_detMemory;
        }
        delete []m_poslutMemory;
        delete []m_tcglutMemory;
}

template <class DetCardPolicy>
void SIMDetectorCard<DetCardPolicy>::simulate(int delay)
{
        static bool simspec0 = Poco::Util::Application::instance().config().getBool("isisicp.simulation.simulatespec0", true);  
        static bool simbin0 = Poco::Util::Application::instance().config().getBool("isisicp.simulation.simulatebin0", true);    
        static bool simulate_data = Poco::Util::Application::instance().config().getBool("isisicp.simulation.simulatedata", false);
        if (simulate_data)
        {
                if ((m_eventModeReg & EventModeRegister<DetCardPolicy>::EventMode) > 0)
                {
                        simulateEventMode(delay, simspec0, simbin0);
                }
                else
                {
                        simulateHistogramMode(delay, simspec0, simbin0);
                }
        }
}

template <class DetCardPolicy>
unsigned SIMDetectorCard<DetCardPolicy>::getTimeChannelIndex(float tof)
{
        unsigned chan = 0, ntc = m_tcgTimeBinLimitRegister;
        unsigned tof_pulses = static_cast<unsigned>(tof * 32.0);
        for(unsigned i=0; i<ntc; ++i)
        {
                if ( (tof_pulses >= m_tcglutMemory[i]) && (tof_pulses < m_tcglutMemory[i+1]) )
                {
                        chan = i + 1;
                }
        }
        return chan;
}

template <class DetCardPolicy>
void SIMDetectorCard<DetCardPolicy>::simulateHistogramMode(int /*delay*/, bool simspec0, bool simbin0)
{
        isisU32_t period_size = m_periodSizeLow + (m_periodSizeHigh << 16);
        isisU32_t period = m_periodCounterLow + (m_periodCounterHigh << 16);
// need to do period properly
        isisU32_t offset;
        float tof;
// fill DAE2 spectra 0, 2, 4 in current period
        isisU32_t start_spec = (simspec0 ? 0 : 2);
        if (!m_neutron_data)
        {
//              LOGSTR_ERROR("Invalid simulation mode - cannot histogram non neutron data");
                Poco::Thread::sleep(50);
                return;
        }
        if (m_vme->isRunning() && !m_vme->isVetoing())
        {
                for(unsigned card_spectrum=start_spec; card_spectrum <= start_spec+4; card_spectrum += 2)
                {
                        offset = card_spectrum * m_descriptorTimeBinLimitRegister + period_size * period;
                        offset %= DET_MEM_LEN;  // "% DET_MEM_LEN" to stop crash if silly values in period counters etc.
// the next line will increment bin 0 (junk bin) - this will be ignored
// when individual spectra are read, but will show up in a "sum all spectra"
                        if (simbin0)
                        {
                                ++(m_detMemory[offset]); 
                        }
                        for(unsigned j=10; j<=20; j++) // fill bins 10 to 20
                        {
// i = (unsigned)(((double)rand() / (double)(RAND_MAX+1)) * DET_MEM_LEN);
// add "% DET_MEM_LEN" to stop crash if silly values in period counters etc.
                                tof = j * 10;
                                ++(m_detMemory[(getTimeChannelIndex(tof) + offset) % (unsigned)DET_MEM_LEN ]);
                                m_totalCounts++;
                        }
                        // make bin 15 a spike
                        tof = 15 * 10;
                        ++(m_detMemory[(getTimeChannelIndex(tof) + offset) % (unsigned)DET_MEM_LEN ]);
                        m_totalCounts++;
                }
        }
}

// write a 32bit word integer data
template <class DetCardPolicy>
void SIMDetectorCard<DetCardPolicy>::simulateEventModeDataDae(DAEEventHeader& header, bool simspec0, bool simbin0)
{
        float tof;
        unsigned char device_id = 30;
        static uint32_t data_word_val = 10;
        union { uint32_t u; unsigned char b[4]; } data_word;
        data_word_val += 100;
        data_word.u = data_word_val;
                header.num_events = 5; // device id + 4 data bytes
                writeToMemoryWrapped(reinterpret_cast<isisU32_t*>(&header), DAE_EVENT_HEADER_WORDS); 
                DetectorEvent32 ev;
                tof = 15.0;
                ev.spectrum = (device_id & 0xff) | (0x0 << 8);
                ev.time_channel = getTimeChannelIndex(tof);
                writeToMemoryWrapped(reinterpret_cast<isisU32_t*>(&ev), sizeof(ev) / sizeof(isisU32_t)); 
                m_totalCounts++;
                for(int i=0; i<4; ++i)
                {
                        ev.spectrum = (data_word.b[i] & 0xff) | ((i+1) << 8);
                        ++(ev.time_channel); // these values should be ignored
                        writeToMemoryWrapped(reinterpret_cast<isisU32_t*>(&ev), sizeof(ev) / sizeof(isisU32_t)); 
                        m_totalCounts++;
                }
}

template <class DetCardPolicy>
void SIMDetectorCard<DetCardPolicy>::simulateEventModeDetector(DAEEventHeader& header, bool simspec0, bool simbin0)
{
        static bool spreadsimevents = Poco::Util::Application::instance().config().getBool("isisicp.simulation.spreadsimevents", true);
        float tof;
                writeToMemoryWrapped(reinterpret_cast<isisU32_t*>(&header), DAE_EVENT_HEADER_WORDS); 
                DetectorEvent32 ev;
                for(int i=0; i<2*header.num_events; i += 2)
                {
                        unsigned card_spectrum = (spreadsimevents ? m_poslutMemory[i % DCPOSLUTSIZE] : 2);
                        ev.spectrum = card_spectrum;
// the next line will increment bin 0 (junk bin) - this will be ignored
// when individual spectra are read, but will show up in a "sum all spectra"
//                      if (simbin0)
//                      {
//                              ev.time_channel = 0;
//                              writeToMemoryWrapped(reinterpret_cast<isisU32_t*>(&ev), sizeof(ev) / sizeof(isisU32_t)); 
//                      }
//                      for(unsigned j=10; j<=20; j++) // fill bins 10 to 20
//                      {
//                              tof = j * 10;
//                              ev.time_channel = getTimeChannelIndex(tof);
//                              writeToMemoryWrapped(reinterpret_cast<isisU32_t*>(&ev), sizeof(ev) / sizeof(isisU32_t)); 
//                              m_totalCounts++;
//                      }
                // make bin 15 a spike
                        tof = 15 * 10;
                        ev.time_channel = getTimeChannelIndex(tof);
                        writeToMemoryWrapped(reinterpret_cast<isisU32_t*>(&ev), sizeof(ev) / sizeof(isisU32_t)); 
                        m_totalCounts++;
                }
}

template <class DetCardPolicy>
void SIMDetectorCard<DetCardPolicy>::simulateEventMode(int delay, bool simspec0, bool simbin0)
{
//      isisU32_t period_size = m_periodSizeLow + (m_periodSizeHigh << 16);
        static int n_events_sim = Poco::Util::Application::instance().config().getInt("isisicp.simulation.neventssim", 5);
        isisU32_t period = m_periodCounterLow + (m_periodCounterHigh << 16);
        delay = 20; // we don't want to add more than 1 frame at a time now, so no scaling to 50Hz
        int proton_incr = (int)( 180.0 * (double)delay / (1000.0 * 3600.0 * 1.738e-6) ) ; // 180uA current if 50Hz
        SYSTEMTIME systime;
        GetSystemTime(&systime);
        DAEEventHeader::DAETime daetime;
        DAEEventList::SystemTimeToDAETime(systime, daetime);
// need to do periods properly

        if (VMESimulationIface::isRunning() && !VMESimulationIface::isVetoing())
        {
                m_end_sent = false;
                DAEEventHeader header;
                memset(&header, 0 , sizeof(header));
                header.frame_number = m_vme->frameNumber();
                header.marker0 = DAEEventHeaderFixedMarker;
                header.marker1 = AllValuesFilledInMarker;
                header.info.header_length = DAE_EVENT_HEADER_WORDS;
                header.period = period;
                header.num_events = n_events_sim;
                header.protons = proton_incr;
                header.time.low = daetime.low;
                header.time.high = daetime.high;
                header.info.header_type = ((m_eventModeReg >> 8) & 0x0f);
                if (m_neutron_data)
                {
                        simulateEventModeDetector(header, simspec0, simbin0);
                }
                else
                {
                        simulateEventModeDataDae(header, simspec0, simbin0);
                }
                m_nextFrameMarker = m_nextMemoryWrite;
            LOGSTR_DEBUG("Card " << position() << " next frame address " << m_nextFrameMarker 
                              << " next mem " << m_nextMemoryWrite << " end sent " << m_end_sent);
        }
        if (!VMESimulationIface::isRunning() && !m_end_sent)
        {
                m_end_sent = true;
                DAEEventHeader header;
                memset(&header, 0 , sizeof(header));
                header.frame_number = m_vme->frameNumber();
                header.marker0 = DAEEventHeaderFixedMarker;
                header.marker1 = EndOfRunMarker;
                header.info.header_length = DAE_EVENT_HEADER_WORDS;
                header.period = period;
                header.num_events = 0;
                header.protons = 0;
                header.time.low = daetime.low;
                header.time.high = daetime.high;
                header.info.header_type = ((m_eventModeReg >> 8) & 0x0f);
                LOGSTR_DEBUG("card " << position() << " sending end header for frame " << header.frame_number);
                writeToMemoryWrapped(reinterpret_cast<isisU32_t*>(&header), DAE_EVENT_HEADER_WORDS); 
            LOGSTR_DEBUG("Card " << position() << " next frame address " << m_nextFrameMarker 
                              << " next mem " << m_nextMemoryWrite << " end sent " << m_end_sent);
        }
}

template <class DetCardPolicy>
void SIMDetectorCard<DetCardPolicy>::writeToMemoryWrapped(isisU32_t* data, int len)
{
        int i = 0, nretry = 3;
        while(i < len)
        {
                while( (4 * DET_MEM_LEN + m_lastReadAddr - m_nextMemoryWrite) % (4 * DET_MEM_LEN) <= 1 ) 
                {
                        if ( --nretry < 0 )
                        {
                                LOGSTR_WARNING("abandoning write");
                                return;
                        }
                        LOGSTR_WARNING("memory full, waiting " << m_lastReadAddr);
                        Sleep(3000);
                }
                m_detMemory[m_nextMemoryWrite / 4] = data[i];
                m_nextMemoryWrite += 4;
                if (m_nextMemoryWrite >= 4 * DET_MEM_LEN)
                {
                        ++m_numMemoryWraps;
                        m_nextMemoryWrite = 0;
                }
                ++i;
        }
}


#if 0
static void det_junk_fill(void* arg)
{
        unsigned i, j, k;
        isisU32_t* pVal;
        VMESimulation* dae = (VMESimulation*)arg;
        for(k=1; k<=NSIMDETCARDS; k++)
        {
                for(i=0; i<(unsigned)dae->m_detMemoryLength; i += 417)
                {
                        pVal = dae->m_detMemory[k] + i % dae->m_detMemoryLength;
                        j = (unsigned)(((double)rand() / (double)(RAND_MAX+1)) * 1000.0);
                        *pVal = *pVal + j;
                }
        }
}
#endif

template <class DetCardPolicy>
void SIMDetectorCard<DetCardPolicy>::updateCardAfterWrite(DAEstatus& /*status*/)
{
        if ( (isRegisterUsed(DCRUNMEMCLEAR) && (m_runMemoryClear != 0)) || (isRegisterUsed(DCTAC) && (m_tcgAccessRegister & DCTHISCLE)) )
        {
                memset(m_detMemory, 0, DET_MEM_LEN * sizeof(isisU32_t));
                // add in a random patters for testing
                //for(int i=0; i<DET_MEM_LEN; i++)
                //{
                //      m_detMemory[i] = (i + 3 * m_position) % 17;
                //}
                m_tcgAccessRegister &= ~DCTHISCLE;
                m_nextFrameMarker = m_nextMemoryWrite = m_numMemoryWraps = m_lastReadAddr = 0;
                m_lastReadAddr -= 4;
                m_runMemoryClear = 0;
        }
        if ( isRegisterUsed(DCTAC) && (m_tcgAccessRegister & DCTTOTCNTSCLE) )
        {
                m_totalCounts = 0;
        }
}

// this is here just so we can set a breakpoint easily on a card read
template <class DetCardPolicy>
void SIMDetectorCard<DetCardPolicy>::updateCardAfterRead(DAEstatus& /*status*/)
{
}

template class SIMDetectorCard<DAE2DetCardPolicy>;
template class SIMDetectorCard<DAE3DetCardPolicy>;