sim_env_period_card.cpp

Go to the documentation of this file.

#include "stdafx.h"

#include "vme_simulation.h"
#include "sim_env_period_card.h"
#include "isisvme.h"

template <class EnvPeriodPolicy>
SIMEnvPeriodCard<EnvPeriodPolicy>::SIMEnvPeriodCard(int position, VMESimulationIface* vme, FaultMode fault_mode, DAEstatus& status) : 
     SIMDAE2Card(position, vme, ((1 << 30) | (1 << 25)), true, Working, status)
{
        setLoggerName("SIMEnvPeriodCard");
        m_type = EnvPeriodCard;

        m_perlut = new isisU32_t[PERLUTSIZE];
        m_outlut = new isisU32_t[OUTLUTSIZE];
        m_rawframes = new isisU32_t[RFCNT0SIZE];
        m_goodframes = new isisU32_t[GFCNT0SIZE];
        m_rawproton0 = new EnvPeriodPolicy::ppp_memory_t[RPCNT0SIZE];
        m_goodproton0 = new EnvPeriodPolicy::ppp_memory_t[GPCNT0SIZE];
        m_rawproton1 = new isisU32_t[RPCNT1SIZE];
        m_goodproton1 = new isisU32_t[GPCNT1SIZE];
        m_spare0 = new isisU32_t[SPARE0SIZE];
        m_spare1 = new isisU32_t[SPARE1SIZE];

        isisU32_t* lookup_reg = NULL;
        if (isRegisterUsed(LOOKTAR))
        {
                lookup_reg = &m_lookup;
                addMapping(ISISVME::TransferIORegisterSpace, LOOKTAR, 1, &m_lookup, "", true, true, NULL, 0, false, false, fault_mode);
        }
        addMapping(ISISVME::TransferIORegisterSpace, MPCNT, 1, &m_main_period_counter, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, MPLIM, 1, &m_main_period_limit, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, PSCNT, 1, &m_period_sequence_counter, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, PSLR, 1, &m_period_sequence_limit, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, EXTPEROVFVC, 1, &m_ext_period_overflow_veto_counter, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, PERINCTOT, 1, &m_period_increment_total, "", true, true, NULL, 0, false, false, fault_mode);

        addMapping(ISISVME::TransferIORegisterSpace, PEROUTDEL, 1, &m_period_output_delay, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, PCREG, 1, &m_period_control, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, ALT1SFV, 1, &m_alt1_fw, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferLUTSpace, PERLUTSTART, PERLUTSIZE, m_perlut, "perlut", true, true, lookup_reg, TARPERLUT, false, false, fault_mode);
        addMapping(ISISVME::TransferLUTSpace, OUTLUTSTART, OUTLUTSIZE, m_outlut, "outlut", true, true, lookup_reg, TAROUTLUT, false, false, fault_mode);
        addMapping(ISISVME::TransferLUTSpace, RFCNT0START, RFCNT0SIZE, m_rawframes, "raw frames", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferLUTSpace, GFCNT0START, GFCNT0SIZE, m_goodframes, "good frames", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferLUTSpace, RPCNT0START, RPCNT0SIZE, m_rawproton0, "raw proton0", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferLUTSpace, GPCNT0START, GPCNT0SIZE, m_goodproton0, "good proton0", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferLUTSpace, RPCNT1START, RPCNT1SIZE, m_rawproton1, "raw proton1", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferLUTSpace, GPCNT1START, GPCNT1SIZE, m_goodproton1, "good proton1", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferLUTSpace, SPARE0START, SPARE0SIZE, m_spare0, "spare0", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferLUTSpace, SPARE1START, SPARE1SIZE, m_spare1, "spare1", true, true, NULL, 0, false, false, fault_mode);

// env card
        addMapping(ISISVME::TransferIORegisterSpace, FCOUNTR, 1, &m_raw_frames, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, FCOUNTG, 1, &m_good_frames, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, PCOUNTR0, 1, &m_raw_proton_low, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, PCOUNTR1, 1, &m_raw_proton_high, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, PCOUNTG0, 1, &m_good_proton_low, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, PCOUNTG1, 1, &m_good_proton_high, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, FIFOVETFRM, 1, &m_fifo_veto_frames, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, SMPVETFRM, 1, &m_smp_veto_frames, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, INTVETFRM, 1, &m_internal_veto_frames, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, EXT0VETFRM, 1, &m_external_veto0_frames, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, EXT1VETFRM, 1, &m_external_veto1_frames, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, EXT2VETFRM, 1, &m_external_veto2_frames, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, EXT3VETFRM, 1, &m_external_veto3_frames, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, FSDELAY, 1, &m_fs_delay, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, FC0WINDLY, 1, &m_chopper_window_delay, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, FC0WINWTH, 1, &m_chopper_window_width, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, FC0VETFRM, 1, &m_chopper_veto_frames, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, MSMVETFRM, 1, &m_ms_veto_frames, "", true, false, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, RCONTROL, 1, &m_run_control, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, RVETO, 1, &m_veto, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, TS2PVETFRM, 1, &m_ts2_pulse_veto_frames, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, HZ50VETFRM, 1, &m_50hz_veto_frames, "", true, true, NULL, 0, false, false, fault_mode);

        addMapping(ISISVME::TransferIORegisterSpace, FRAMETIME0, 1, &m_frame_time_low, "", true, true, NULL, 0, false, false, fault_mode);
        addMapping(ISISVME::TransferIORegisterSpace, FRAMETIME1, 1, &m_frame_time_high, "", true, true, NULL, 0, false, false, fault_mode);

        m_veto_raised = false;
        m_lookup = 0;
        m_period_sequence_counter = 0;
        m_run_control = m_period_control = 0;
        m_main_period_counter = m_main_period_limit = m_period_sequence_counter = m_period_sequence_limit = 0;
        m_raw_frames = m_good_frames = 0;

        m_is_running = (m_run_control & RCSTART ? true : false);
        LOGSTR_INFORMATION("SIMEnvPeriod card at position " << m_position);  
}

template <class EnvPeriodPolicy>
void SIMEnvPeriodCard<EnvPeriodPolicy>::printStatus(std::ostream& os)
{
        os << "SIMEnvPeriod card at position " << m_position << " using policy " << EnvPeriodPolicy::env_period_policy_name;
}

template <class EnvPeriodPolicy>
void SIMEnvPeriodCard<EnvPeriodPolicy>::updateCardAfterWrite(DAEstatus& status)
{
        if (m_period_control & PCRESET)
        {
                m_main_period_counter = 0;
                m_period_control = PCRESET; // clears all bits except reset bit
                m_lookup = 0;
                m_period_sequence_counter = 0;
        }
        if (m_period_control & PCCLRPC)
        {
                m_main_period_counter = 0;
                m_period_sequence_counter = 0;
        }
        if (m_run_control & RCFCLEAR)
        {
                m_raw_frames = 0;
                m_good_frames = 0;
                m_fifo_veto_frames = 0;
                m_smp_veto_frames = 0;
                m_internal_veto_frames = 0;
                m_external_veto0_frames = 0;
                m_external_veto1_frames = 0;
                m_external_veto2_frames = 0;
                m_external_veto3_frames = 0;
                m_chopper_veto_frames = 0;
                m_ms_veto_frames = 0;
        }
        if (m_run_control & RCPCLEAR)
        {
                m_raw_proton_low = m_raw_proton_high = 0;
                m_good_proton_low = m_good_proton_high = 0;
        }
        if (m_run_control & RCSTART)
        {
                m_is_running = true;
        }
        else
        {
                m_is_running = false;
        }
}

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

template <class EnvPeriodPolicy>
void SIMEnvPeriodCard<EnvPeriodPolicy>::simulate(int delay)
{
// pcount * 1.738e-6 = uahours
        delay = 20;   // we don't want to add more than 1 frame at a time now, so no scaling to 50Hz
        int frame_incr = delay / 20; // an isis frame is 20 milliseconds
        int proton_incr = (int)( 180.0 * (double)delay / (1000.0 * 3600.0 * 1.738e-6) ) ; // 180uA current if 50Hz
//      if ( (m_run_control & RCFSSEL) == RCFSTOF1P ) // running at 10Hz?
//      {
//              frame_incr /= 5;
//              proton_incr /= 5;
//      }

    if (!(m_run_control & RCPERSZEQZERO)) // delayed start enabled
        {
                return;
        }
        if (m_vme->isRunning())
        {
                        m_raw_frames += frame_incr;
                        increment32(proton_incr, m_raw_proton_low, m_raw_proton_high);
                        if ( !m_vme->isVetoing() )
                        {
                                m_good_frames += frame_incr;
                                increment32(proton_incr, m_good_proton_low, m_good_proton_high);
                        }       
        }
        if (!(m_period_control & PCENAB))
        {
                return; // not using periods
        }
        bool is_dwell;
        int current_period, max_period, max_frames;
    current_period = m_main_period_counter & 0x3fff; // lower 14 bits
        is_dwell = ((m_main_period_counter & (1 << 14)) != 0);
        max_period = m_main_period_limit & 0x3fff;
    max_frames = 1 + (m_perlut[current_period] & 0xffff); 
                if ( m_vme->isRunning() )
                {
                        if ((m_period_control & PCENDSEQCOMP) || (m_period_control & PCMULCOMP)) // pcard has finished sequence
                        {
                                m_veto_raised = true;
                                increment(frame_incr, m_internal_veto_frames);
                                increment(frame_incr, m_rawframes[current_period]);
                                increment32(proton_incr, m_rawproton0[current_period], m_rawproton1[current_period]);
                        }
                        else if (is_dwell)
                        {
                                m_veto_raised = true;
                                increment(frame_incr, m_internal_veto_frames);
                                increment(frame_incr, m_rawframes[current_period]);
                                increment(frame_incr, m_goodframes[current_period]);
                                increment32(proton_incr, m_rawproton0[current_period], m_rawproton1[current_period]);
                        }
                        else
                        {
                                m_veto_raised = false;
                                increment(frame_incr, m_rawframes[current_period]);
                                increment(frame_incr, m_goodframes[current_period]);
                                increment32(proton_incr, m_rawproton0[current_period], m_rawproton1[current_period]);
                                increment32(proton_incr, m_goodproton0[current_period], m_goodproton1[current_period]);
                        }
                        if (m_goodframes[current_period] >= max_frames*(1+m_period_sequence_counter) )
                        {
                                if (++current_period < max_period)
                                {
                                        m_main_period_counter = (current_period & 0x3fff) |
                                                           ((m_perlut[current_period] & 0x80000000) >> 17);
                                        if (!(m_perlut[current_period] & 0x80000000)) // not dwell 
                                        {
                                                m_vme->incrementDetectorCardPeriod();
                                        }
//                                      m_rawframes[current_period] = m_goodframes[current_period] = 0;
                                }
                                else if (m_period_control & PCENDAFTER)
                                {
                                        m_period_control |= PCENDSEQCOMP;
                                }
                                else if ((m_period_control & PCMULENAB) && 
                                             (m_period_sequence_counter > m_period_sequence_limit))
                                {
                                        m_period_control |= PCMULCOMP;
                                }
                                else
                                {
                                        current_period = 0;
                                        m_period_sequence_counter++;
                                        m_main_period_counter = (current_period & 0x3fff) |
                                                           ((m_perlut[current_period] & 0x80000000) >> 17);
                                        m_vme->resetDetectorCardPeriod();
//                                      m_rawframes[current_period] = m_goodframes[current_period] = 0;
                                }
                        }
                }
}

template <class EnvPeriodPolicy>
SIMEnvPeriodCard<EnvPeriodPolicy>::~SIMEnvPeriodCard()
{
        delete[] m_perlut;
        delete[] m_outlut;
        delete[] m_rawframes;
        delete[] m_goodframes;
}

template class SIMEnvPeriodCard<DAE2EnvPeriodPolicy>;
template class SIMEnvPeriodCard<DAE3EnvPeriodPolicy>;