MuonDetectorCard.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "MuonDetectorCard.h"
#include "isisvme.h"

void MuonDetectorCard::printStatus(std::ostream& os, DAEstatus& status)
{
        os << "This is a MUON DECTECTOR card" << std::endl; 
        os << "The card has " << m_detector_inputs_per_card << " inputs (" << 
                m_num_dims << " dims, " << m_positions_per_dim << " positions," << " highest dim number = " << (m_num_dims - 1) * m_dim_step  << ")\n";
        DetectorCard::printStatus(os, status);
}


int MuonDetectorCard::getNTimeChannels(isisU32_t* ntc, DAEstatus& status)       // ntc
{
        getSpectrumSize(ntc, status);
        --(*ntc);
        return 0;
}

//clock pulses (one pulse = 0.5ns)
int MuonDetectorCard::setTimeChannels32(isisU32_t* tcb, int ntc, DAEstatus& status)
{
        isisU32_t value;
        if (ntc >= DCPOSLUTSIZE)
        {
                status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                                "too many time channels %d", ntc);
                return ISISVME::Error;
        }
        if (tcb[0] != 0)
        {
                status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                                "invalid tcb start - must be 0 not %f ns", tcb[0] / 2.0);
                return ISISVME::Error;
        }
        int clock_pulses = tcb[1] - tcb[0];  // in 0.5ns steps
        if ( (tcb[ntc] - tcb[ntc-1]) != clock_pulses )
        {
                status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                                "The final time bin boundary %f ns must be a multiple of the step size %f ns", tcb[ntc]/2.0, clock_pulses/2.0);
                return ISISVME::Error;
        }
        for(int i=0; i<ntc; ++i)
        {
                if ((tcb[i+1] - tcb[i]) != clock_pulses)
                {
                        status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                                "invalid tcb step for bin %d - must be equally spaced and found %f ns(!= %f)", i, (tcb[i+1] - tcb[i])/2.0, clock_pulses/2.0);
                        return ISISVME::Error;
                }
        }
        if (ntc * clock_pulses != 65536) // must be a 32768ns window
        {
                status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                                "The time window must be 32768 ns - %f ns is not allowed", ntc * clock_pulses / 2.0);
                return ISISVME::Error;
        }
        value = clockPulsesToMuonStepSize(clock_pulses, status);
        writeRegister(DCMUONSTEP, value, status);
        for(int i=0; i < DCPOSLUTSIZE; ++i)
        {
                m_poslut[i] = i;
        }
        return writePOSLUTMemory(0, m_poslut, DCPOSLUTSIZE, status);
}

bool MuonDetectorCard::isPowerOf2(int value)
{
        int n = 0;
        if (value < 1)
        {
                return false;
        }
        while(value > 1)
        {
                if ( (value % 2) != 0 )
                {
                        return false;
                }
                value /= 2;
                ++n;
        }
        return true;
}

int MuonDetectorCard::clockPulsesToMuonStepSize(int clock_pulses, DAEstatus& status)
{
        if (!isPowerOf2(clock_pulses))
        {
                status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                                "invalid tcb step - %d clock pulses is not a power of 2", clock_pulses);
                return 0;
        }
        if (clock_pulses > 32)
        {
                status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                                "invalid tcb step %f - max tcb step is 16ns", clock_pulses / 2.0);
                return 0;
        }
        return (clock_pulses == 1 ? 0 : clock_pulses / 2);
}

int MuonDetectorCard::muonStepSizeToClockPulses(int step_size, DAEstatus& status)
{
        return (step_size == 0 ? 1 : 2 * step_size);
}

int MuonDetectorCard::setTimeChannels(isisU32_t* tcb, int ntc, DAEstatus& status)
{
        int i, j;
        bool done;
        isisU32_t time_to;
        setNTimeChannels(ntc, status);
        if ( (m_options & DetectorCard::Muon32Channel) != 0 )
        {
                return setTimeChannels32(tcb, ntc, status);
        }
        // chan_count store how many clock pulses per tcb channel
        // we store "tcb 0" contribution from start and end separately
        // hence ntc+2
        int* chan_count = new int[ntc+2];
        memset(chan_count, 0, (ntc+2)*sizeof(int));
        i = 0;
        // poslut location is "time to" i.e. upper bin boundary 
        done = false;
        while( (i < DCPOSLUTSIZE) && !done )
        {
                time_to = i + 1;
                if (time_to <= tcb[0])
                {
                        m_poslut[i] = 0;
                        ++(chan_count[0]);
                        i++;
                }
                else
                {
                        done = true;
                }
        }
        // we are now inside the first bin tcb[0] to tcb[1]
        j = 0;
        while( (i < DCPOSLUTSIZE) && (j < ntc) )
        {
                time_to = i + 1;
                if (time_to <= tcb[j+1])
                {
                        m_poslut[i] = j + 1;
                        ++(chan_count[j+1]);
                        ++i;
                }
                else
                {
                        ++j;
                }
        }
        if (i == DCPOSLUTSIZE)
        {
         status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                         "Final TCB too big: ntc = %d (> %d), final tcb = %d", ntc, DCPOSLUTSIZE, tcb[ntc]);

        }
        while(i < DCPOSLUTSIZE)
        {
                m_poslut[i] = 0;
                ++(chan_count[ntc+1]);
                ++i;
        }
        status.addDebugVa(FAC_DETCARD, "TCB0 contribution: first %d and last %d pulses",
                                                chan_count[0], chan_count[ntc+1]);
        delete[] chan_count;
        return writePOSLUTMemory(0, m_poslut, DCPOSLUTSIZE, status);
}


int MuonDetectorCard::getTimeChannels32(isisU32_t* tcb, int ntc, DAEstatus& status)
{
        isisU32_t value;
        readRegister(DCMUONSTEP, &value, status);
        int clock_pulses = muonStepSizeToClockPulses(value, status);
        for(int i=0; i<ntc+1; ++i)
        {
                tcb[i] = i * clock_pulses;
        }
        return ISISVME::Success;
}


// in clock pulses
int MuonDetectorCard::getTimeChannels(isisU32_t* tcb, int ntc, DAEstatus& status)
{
        if ( (m_options & DetectorCard::Muon32Channel) != 0 )
        {
                return getTimeChannels32(tcb, ntc, status);
        }
        readPOSLUTMemory(0, m_poslut, DCPOSLUTSIZE, status);
        memset(tcb, 0, (ntc+1)*sizeof(isisU32_t));
        int time_from, time_to;
        int i, j = 0, max_ntc = 0;
        int* chan_count = new int[ntc]; // how many clock pulses per tcb channel
        memset(chan_count, 0, ntc*sizeof(int));
        i = 0;
        while(i < DCPOSLUTSIZE)
        {
                time_from = i;
                time_to = i + 1;
                j = m_poslut[i]; // boundaries are (low <= t < high)
                if ((j < 0) || (j > ntc ))
                {
                        status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                                "Invalid TCB bin %d", j);
                        return ISISVME::Error;
                }
                max_ntc = (j > max_ntc ? j : max_ntc);
                if (j == 1)
                {
                        tcb[0] = time_from;
                }
                if (j > 0)
                {
                        ++chan_count[j-1];
                        tcb[j] = time_to;
                }
                i++;
        }
        delete[] chan_count;
        if (max_ntc != ntc)
        {
                status.addVa(FAC_DETCARD, SEV_INFO, ERRTYPE_INVCARD, "Invalid ntc %d", ntc);
                return ISISVME::Error;
        }
        return 0;
}

// In muons there is no posult and detctor inputs are hard coded
// to go to DAE2 spectrum 0 -> 31; thus we nede to map so we map DAE1 spectrum 0 
// to the area after all the data we have collected
// there are 32 real spectra per card (DAE 0 -> 31) so we map DAE1 spectrum 0 -> DAE spec 32
int MuonDetectorCard::readPOSLUT(DAEstatus& status)
{
        int i, j, n;
        std::ostringstream message;
        m_highspec = m_detector_inputs_per_card;
        m_dae1persize = 0;
        m_dae2persize = 0;
        m_nperiods = 1;
        for(i=0; i<DAESPECMAX; i++)
        {
                m_dae1specmap[i] = NOSPECTRUM;
                m_dae2specmap[i] = NOSPECTRUM;
        }
// we may have junk in the POSLUT, so check value found
        if (m_highspec >= DAESPECMAX)
        {
                m_highspec = DAESPECMAX - 1;
        }
        m_dae1specmap[0] = m_highspec;  // map spectrum 0 to after data collected 
        m_dae2specmap[m_highspec] = 0;  // map spectrum 0
        // 32 inputs = 8 channels(position), 4 connectors (dims), dims going 0,1,2,3
        // 128 inputs = 16 channels(position), 8 connectors (dims), BUT dims laballed 0,2,4,...,14
        n = 0;
        memset(m_poslut, 0, DCPOSLUTSIZE * sizeof(isisU32_t));
        for(i=0; i < m_num_dims; i++)
        {
                for(j=0; j < m_positions_per_dim; j++)
                {
                        m_poslut[DCPOSMAX * i * m_dim_step + j] = n++;
                }
        }
//      m_dae2persize = m_highspec + 1;
        message << "Highest DAE2 spectrum: " << m_highspec << "\n";
        status.addInfo(FAC_DETCARD, message.str());
        return 0;
}


// 8 channels on 4 connectors, arranged in four blocks of 8 = 32 spectra overall
// (call 8 positions on 4 dims)
int MuonDetectorCard::programPOSLUT(int cards[], int dims[], int pos_start[],
                                                                int npos[], int spec[], int spec_step[], 
                                                                int nblocks, int nperiods, int dae1persize, DAEstatus& status)
{
                        status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                                "Invalid poslut bin %d", 1);
                        return ISISVME::Error;
}


// In muons there is no posult and detctor inputs are hard coded
// to go to DAE2 spectrum 0 -> 31; thus we nede to map so we map DAE1 spectrum 0 
// to the area after all the data we have collected
// there are 32 real spectra per card (DAE 0 -> 31) so we map DAE1 spectrum 0 -> DAE spec 32
// so there are really 33 spectra per card
// 8 channels(positions) on 4 connectors(dims), arranged in four blocks of 8 = 32 spectra overall
int MuonDetectorCard::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;
        m_dae1persize = dae1persize;
        m_nperiods = nperiods;
        for(i=0; i<DAESPECMAX; i++)
        {
                m_dae1specmap[i] = NOSPECTRUM;
                m_dae2specmap[i] = NOSPECTRUM;
        }
        m_dae1specmap[0] = m_detector_inputs_per_card;  // map spectrum 0 to unused spectrum on end
        m_dae2specmap[m_detector_inputs_per_card] = 0;
// 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;
                        m_dae1specmap[spec[i]] = SPECTRUM_PLACEHOLDER;
                        if (spec[i] > dae1max)
                        {
                                dae1max = spec[i];
                        }
                        if (spec[i] < dae1min)
                        {
                                dae1min = spec[i];
                        }
                }
        }
        ngap = 0;
        for(i=dae1min; i<=dae1max; i++)
        {
                if (m_dae1specmap[i] != SPECTRUM_PLACEHOLDER)
                {
                        ngap++;
                }
        }
        if (ngap > 0)
        {
                message_i << "There is a gap of total size " << ngap << " in the DAE1 spectra on the card" << std::endl;
        }
        m_highspec = m_detector_inputs_per_card;
        m_dae2persize = m_highspec + 1;
        m_highspec = m_nperiods * m_dae2persize - 1;

// now assign them sequential DAE2 spectrum numbers
// 8 channels(positions) on 4 connectors(dims), arranged in four blocks of 8 = 32 spectra overall numbered 0 -> 31
//      d2spec = 8 * dim + pos;
        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 == SPECTRUM_PLACEHOLDER)
                        {
                                if (calculateSpectrum(j, modn[i], mpos[i], status) == ISISVME::Success)
                                {
                                        m_dae1specmap[spec[i]] = j;
                                        m_dae2specmap[j] = spec[i];
                                }
                                else
                                {
                                        message_e << "Error in calculateSpectrum" << std::endl;
                                }
                        }
                        else
                        {
                                message_e << "Error in spectrum mapping" << std::endl;
                        }
                }
        }
// now assign spectra for periods
// "spectrum 0" is at end of each spectrum block, so different from neutron card
        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;
                        }
                }
        }
        if (card_used)
        {
            message_i << "Card: " << m_position << " DAE2 Highest: " << m_highspec 
                    << " DAE1 low: " << dae1min << " DAE1 high: " << dae1max
                    << " NPOS: " << npos << "\n";
                message_i << "MPOS: " << mpos_min << " to " << mpos_max << "\n";
                message_i << "MODN: " << modn_min << " to " << modn_max << "\n";
        }
        else
        {
                message_w << "*** Detector Card " << m_position << " not used" << std::endl;
        }
        status.addInfo(FAC_DETCARD, message_i.str());
        status.add(FAC_DETCARD, SEV_WARNING, ERRTYPE_INVCARD, message_w.str());
        status.add(FAC_DETCARD, SEV_WARNING, 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 (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); 
     } 
        return ISISVME::Success;
}

                
MuonDetectorCard::MuonDetectorCard(int position, ISISVME* vme, int* specmap_array, 
                                                           int specmap_len, DAEstatus& status) 
                                : DetectorCard(position, vme, specmap_array, specmap_len, status)
{
        std::ostringstream message;
        setLoggerName("MuonDetectorCard");
        isisU32_t value; 
        DAEstatus temp_status;
        message << "Creating Muon Detector Card" << "\n";
        // 32 inputs = 8 channels(position), 4 connectors (dims), dims going 0,1,2,3
        // 128 inputs = 16 channels(position), 8 connectors (dims), BUT dims laballed 0,2,4,...,14
        if (readRegister(DCOPMODE, &value, temp_status) == 1)
        {
                setRegisterBits(DCOPMODE, 0x2, true, status);   // always run card in full 32 channel mode if supported
                m_options |= (int)DetectorCard::Muon32Channel; 
                m_detector_inputs_per_card = 128;
                m_num_dims = 8;
                m_dim_step = 2;
        }
        else
        {
                m_detector_inputs_per_card = 32;
                m_dim_step = 1;
                m_num_dims = 4;
        }
        m_positions_per_dim = m_detector_inputs_per_card / m_num_dims;
        message << "The card has " << m_detector_inputs_per_card << " inputs (" << 
                m_num_dims << " dims, " << m_positions_per_dim << " positions," << " highest dim number = " << (m_num_dims - 1) * m_dim_step  << ")\n";
        status.addInfo(FAC_ENVCARD, message.str());
}


// 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
// 
int MuonDetectorCard::changePeriod(int period, DAEstatus& status)
{
        if (period >= m_nperiods)
        {
                status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, "Cannot change period to %d >= %d", period, m_nperiods);
                return ISISVME::Error;
        }
        return setPeriodCounter(period, status);
}

MuonDetectorCard::~MuonDetectorCard()
{
}

int MuonDetectorCard::calculateModuleAndPosition(int dae2_spec, int& modn, int& mpos, DAEstatus& status)
{
        modn = mpos = 0;
        if (dae2_spec > m_detector_inputs_per_card)
        {
                status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                         "Detector Card %d has invalid spectrum %d", m_position, dae2_spec); 
                return ISISVME::Error;
        }
        if (dae2_spec == m_detector_inputs_per_card)   // dummy spectrum 0
        {
                modn = mpos = 0;
        }
        else
        {
                int n = dae2_spec / m_positions_per_dim; 
                modn =  n * m_dim_step;
                mpos = dae2_spec % m_positions_per_dim;
        }
        return ISISVME::Success;
}

int MuonDetectorCard::calculateSpectrum(int& dae2_spec, int modn, int mpos, DAEstatus& status)
{
        dae2_spec = 0;
        if (modn % m_dim_step != 0)
        {
                status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                         "Detector Card %d has invalid modn %d", m_position, modn); 
                return ISISVME::Error;
        }
        if ( modn > (m_dim_step * (m_num_dims - 1)) )
        {
                status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                         "Detector Card %d has invalid modn %d", m_position, modn); 
                return ISISVME::Error;
        }
        if (mpos >= m_positions_per_dim)
        {
                status.addVa(FAC_DETCARD, SEV_ERROR, ERRTYPE_INVCARD, 
                         "Detector Card %d has invalid mpos %d", m_position, mpos); 
                return ISISVME::Error;
        }
        int n = modn / m_dim_step;
        dae2_spec = n * m_positions_per_dim + mpos;
        return ISISVME::Success;
}

int MuonDetectorCard::resetCardState(DAEstatus& status)
{
        LOGSTR_INFORMATION("Nothing to do");
        return ISISVME::Success;
//      return DetectorCard::resetCardState(status);
}