environment_card.cpp

Go to the documentation of this file.

#include "stdafx.h"

#include "isisvme.h"
#include "environment_card.h"

template <class EnvPeriodPolicy>
EnvironmentCard<EnvPeriodPolicy>::EnvironmentCard(int position, ISISVME* vme, DAEstatus& status) : DAE2Card(position, vme, status)
{
        setLoggerName("EnvironmentCard");
        std::ostringstream message;
        isisU32_t value;
    if (readRegister(FC0WINDLY, &value, status) == 1)
        {
                message << "This Card Supports Fast (Fermi) Chopper Vetos\n";
                m_options |= (int)EnvironmentCard<EnvPeriodPolicy>::FChopperVeto;
        }
    printStatus(message, status);
        status.addInfo(FAC_ENVCARD, message.str());
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::setRunControlBits(isisU32_t mask, bool preserve, DAEstatus& status)
{
    return setRegisterBits(RCONTROL, mask, preserve, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::clearRunControlBits(isisU32_t mask, DAEstatus& status)
{
        return clearRegisterBits(RCONTROL, mask, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::setAndClearRunControlBits(isisU32_t mask, bool preserve, DAEstatus& status)
{
        return setAndClearRegisterBits(RCONTROL, mask, preserve, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::startRun(DAEstatus& status)
{
        resetRunController(status);
        return setRunControlBits(RCSTART, true, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::stopRun(DAEstatus& status)
{
    clearRunControlBits(RCSTART, status);
    return resetRunController(status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::ClearFramesAndPPP(DAEstatus& status)
{
//      clearSMPVetoedFrames(status);
//      clearExternalVetoedFrames(status);
//      clearFIFOVetoedFrames(status);
    return setAndClearRegisterBits(RCONTROL, RCFCLEAR | RCPCLEAR, true, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::clearPPP(DAEstatus& status)
{
    return setAndClearRegisterBits(RCONTROL, RCPCLEAR, true, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::setFrameSync(FrameSync fs, DAEstatus& status)
{
        int stat = clearRunControlBits(RCFSSEL, status); // clear all FS bits first (sets to test clock)
        switch(fs)
        {
                case FrameSyncInternalTest:
                        return stat;
                        break;

                case FrameSyncISIS:
                        return setRunControlBits(RCFSTOF, true, status);
                        break;

                case FrameSyncISISFirstTS1Pulse:
                        return setRunControlBits(RCFSTOF1P, true, status);
                        break;

                case FrameSyncSMP:
                        return setRunControlBits(RCFSSMP, true, status);
                        break;

                default:
                        break;
        }
        status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Invalid frame sync type %d\n", fs);
        return DAEstatus::Failure;
}

template <class EnvPeriodPolicy>
bool EnvironmentCard<EnvPeriodPolicy>::isRunning(DAEstatus& status)
{
        isisU32_t value;
    readRegister(RCONTROL, &value, status);
        if (value & RCSTART)
        {
                return true;
        }
        else
        {
                return false;
        }
}

template <class EnvPeriodPolicy>
void EnvironmentCard<EnvPeriodPolicy>::printStatus(std::ostream& os, DAEstatus& status)
{
        isisU32_t value, value1, veto_reg;
        DAE2Card::printStatus(os, status);
        os << "This is an ENVIRONMENT card" << std::endl;
        readRegister(RCONTROL, &value, status);
        os << "RC register value = " << std::hex << "0x" << value << std::dec << std::endl;
    os << "Status: " << (value &  RCSTART ? "Running" : "Stopped") << std::endl;
        os << "Frame Sync: " << ( value & RCFSSEL ? "External" : "Internal" ) << std::endl;
        os << "Delayed start: " << (value & RCPERSZEQZERO ? "disabled" : "enabled") << std::endl;
        getFrameSyncDelay(&value1, status);
        os << "Frame sync delay: " << value1 << "\n";
        readRegister(RVETO, &veto_reg, status);
        printVetoDetails(os, status);
        getGoodFrames(&value1, status);
        getRawFrames(&value, status);
        os << "GOOD/RAW frames: " << value1 << "/" << value << "\n";
        os << "GOOD/RAW uamph: " << getGoodUAmpHours(status) << "/" << getRawUAmpHours(status) << "\n";
        os << "Period Type: " << (usingHardwarePeriods(status) ? "Hardware" : "Software") << std::endl;
// print period type
}

//int EnvironmentCard<EnvPeriodPolicy>::getRawFramesLower(isisU16_t* value, DAEstatus& status)
//{
//    readRegister(FCOUNTR0, value, status);
//      return 0;
//}

//int EnvironmentCard<EnvPeriodPolicy>::getRawFramesUpper(isisU16_t* value, DAEstatus& status)
//{
//    readRegister(FCOUNTR1, value, status);
//      return 0;
//}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::getRawFrames(isisU32_t* value, DAEstatus& status)
{
    return readRegister(FCOUNTR, value, status);
}

//int EnvironmentCard<EnvPeriodPolicy>::getGoodFramesLower(isisU16_t* value, DAEstatus& status)
//{
//    readRegister(FCOUNTG0, value, status);
//      return 0;
//}

//int EnvironmentCard<EnvPeriodPolicy>::getGoodFramesUpper(isisU16_t* value, DAEstatus& status)
//{
//    readRegister(FCOUNTG1, value, status);
//      return 0;
//}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::getGoodFrames(isisU32_t* value, DAEstatus& status)
{
        return readRegister(FCOUNTG, value, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::getRawPPPLower(isisU32_t* value, DAEstatus& status)
{
    return readRegister(PCOUNTR0, value, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::getRawPPPUpper(isisU32_t* value, DAEstatus& status)
{
        isisU32_t value1 = 0;
    readRegister(PCOUNTR1, &value1, status);
        *value = value1 & 0xffff;
        return 0;
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::getRawPPP(isisU64_t* value, DAEstatus& status)
{
        isisU32_t value0 = 0, value1 = 0;
        readRegister(PCOUNTR0, &value0, status);
        readRegister(PCOUNTR1, &value1, status);
        *value = (isisU64_t)value0 | ((isisU64_t)value1 << 32);
        return 0;
}


template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::getGoodPPPLower(isisU32_t* value, DAEstatus& status)
{
    return readRegister(PCOUNTG0, value, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::getGoodPPPUpper(isisU32_t* value, DAEstatus& status)
{
        isisU32_t value1 = 0;
    readRegister(PCOUNTG1, &value1, status);
        *value = value1 & 0xffff;
        return 0;
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::getGoodPPP(isisU64_t* value, DAEstatus& status)
{
        isisU32_t value0 = 0, value1 = 0;
        readRegister(PCOUNTG0, &value0, status);
        readRegister(PCOUNTG1, &value1, status);
        *value = (isisU64_t)value0 | ((isisU64_t)value1 << 32);
        return 0;
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::resetRunController(DAEstatus& status)
{
    return setAndClearRunControlBits(RCRESET, true, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::enableSMPVeto(DAEstatus& status)
{
    return setVetoRegisterBits(RVSMP, true, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::enableExternalVeto(int veto_number, DAEstatus& status)
{
        switch(veto_number)
        {
                case 0:
                        return setVetoRegisterBits(RVEXT0, true, status);
                        break;
                case 1:
                        return setVetoRegisterBits(RVEXT1, true, status);
                        break;
                case 2:
                        return setVetoRegisterBits(RVEXT2, true, status);
                        break;
                case 3:
                        return setVetoRegisterBits(RVEXT3, true, status);
                        break;
                default:
                        status.addWarningVa(FAC_DAE, "Attempting to enable invalid veto number %d", veto_number);
                        break;
        }
        return DAEstatus::Success;
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::enableInternalVeto(DAEstatus& status)
{
    return setVetoRegisterBits(RVINT, true, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::enableFIFOVeto(DAEstatus& status)
{
    return setVetoRegisterBits(RVFIFO, true, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::enableTS2PulseVeto(DAEstatus& status)
{
    return setVetoRegisterBits(RVTS2P, true, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::enableISIS50HzVeto(DAEstatus& status)
{
    return setVetoRegisterBits(RVHZ50, true, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::disableSMPVeto(DAEstatus& status)
{
    return clearVetoRegisterBits(RVSMP, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::disableExternalVeto(int veto_number, DAEstatus& status)
{
        switch(veto_number)
        {
                case 0:
                        return clearVetoRegisterBits(RVEXT0, status);
                        break;
                case 1:
                        return clearVetoRegisterBits(RVEXT1, status);
                        break;
                case 2:
                        return clearVetoRegisterBits(RVEXT2, status);
                        break;
                case 3:
                        return clearVetoRegisterBits(RVEXT3, status);
                        break;
                default:
                        status.addWarningVa(FAC_DAE, "Attempting to disable invalid veto number %d", veto_number);
                        break;
        }
        return DAEstatus::Success;
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::disableInternalVeto(DAEstatus& status)
{
    return clearVetoRegisterBits(RVINT, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::disableFIFOVeto(DAEstatus& status)
{
    return clearVetoRegisterBits(RVFIFO, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::disableTS2PulseVeto(DAEstatus& status)
{
    return clearVetoRegisterBits(RVTS2P, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::disableISIS50HzVeto(DAEstatus& status)
{
    return clearVetoRegisterBits(RVHZ50, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::getSMPVetoedFrames(isisU32_t* value, DAEstatus& status)
{
    return readRegister(SMPVETFRM, value, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::getExternalVetoedFrames(int veto_number, isisU32_t* value, DAEstatus& status)
{
//                      return readRegister(EXTVETFRMTOT, value, status);
        switch(veto_number)
        {
                case 0:
                        return readRegister(EXT0VETFRM, value, status);
                        break;
                case 1:
                        return readRegister(EXT1VETFRM, value, status);
                        break;
                case 2:
                        return readRegister(EXT2VETFRM, value, status);
                        break;
                case 3:
                        return readRegister(EXT3VETFRM, value, status);
                        break;
                default:
                        status.addWarningVa(FAC_DAE, "Attempting to read invalid veto number %d", veto_number);
                        break;
        }
        return DAEstatus::Success;
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::getFIFOVetoedFrames(isisU32_t* value, DAEstatus& status)
{
    return readRegister(FIFOVETFRM, value, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::getTS2PulseVetoedFrames(isisU32_t* value, DAEstatus& status)
{
    return readRegister(TS2PVETFRM, value, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::getISIS50HzVetoedFrames(isisU32_t* value, DAEstatus& status)
{
    return readRegister(HZ50VETFRM, value, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::clearSMPVetoedFrames(DAEstatus& status)
{
    isisU32_t value = 0;
    writeRegister(SMPVETFRM, value, status);
        return 0;
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::clearExternalVetoedFrames(DAEstatus& status)
{
    isisU32_t value = 0;
    writeRegister(EXT0VETFRM, value, status);
        return 0;
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::clearFIFOVetoedFrames(DAEstatus& status)
{
    isisU32_t value = 0;
    writeRegister(FIFOVETFRM, value, status);
        return 0;
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::setFrameSyncDelay(isisU32_t value, DAEstatus& status)             // in us
{
        if (value == 0)
        {
                value = 1;      // probably a muon DAE
        }
        if ((value >> 19) != 0)
        {
                status.add(FAC_ENVCARD, SEV_ERROR, ERRTYPE_INVCARD, "Frame sync delay too big (> 18 bits wide)");
        }
        clearRunControlBits(RCFSENABLEOUT, status);
        setAndClearRunControlBits(RCDELFSFIFORS, true, status);
        writeRegister(FSDELAY, value, status);
        setRunControlBits(RCFSENABLEOUT, true, status);
        return 0;
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::getFrameSyncDelay(isisU32_t* value, DAEstatus& status)            // in us
{
        return readRegister(FSDELAY, value, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::enableHardwarePeriods(DAEstatus& status) 
   { 
       return clearRunControlBits(RCPERSZEQZERO, status); 
   } 
    
template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::disableHardwarePeriods(DAEstatus& status) 
   { 
       return setRunControlBits(RCPERSZEQZERO, true, status); 
   } 

template <class EnvPeriodPolicy>
bool EnvironmentCard<EnvPeriodPolicy>::usingHardwarePeriods(DAEstatus& status)
   {
                isisU32_t value;
                readRegister(RCONTROL, &value, status);
                if (value & RCPERSZEQZERO)
                {
                        return false;
                }
                else
                {
                        return true;
                }
   }
    
// converion factor is
//
// 4e13 / 1024 * 1.602e-19 * 1e6 / 3600 = 1.738e-6
//
// 4e13/1024 is a calibration: 1024 for 10 bit ADC, 4e13 for full load proton reading
//

#define PPP_TO_UAMPH    1.738E-6

template <class EnvPeriodPolicy>
float EnvironmentCard<EnvPeriodPolicy>::getGoodUAmpHours(DAEstatus& status)
{
        float good_uamps;
        isisU32_t low = 0, upper = 0;
        getGoodPPPLower(&low, status);
        getGoodPPPUpper(&upper, status);
        good_uamps = static_cast<float>(((65536.0 * 65536.0 * upper) + low) * PPP_TO_UAMPH);
        return good_uamps;
}

template <class EnvPeriodPolicy>
float EnvironmentCard<EnvPeriodPolicy>::getRawUAmpHours(DAEstatus& status)
{
        float raw_uamps;
        isisU32_t low = 0, upper = 0;
        getRawPPPLower(&low, status);
        getRawPPPUpper(&upper, status);
        raw_uamps = static_cast<float>(((65536.0 * 65536.0 * upper) + low) * PPP_TO_UAMPH);
        return raw_uamps;
}

// delay and width in 20ns steps
template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::enableFChopperVeto(int chopper_number, int delay, int width, DAEstatus& status)
{
        static const isisU32_t delay_mapping[] = { FC0WINDLY, FC1WINDLY, FC2WINDLY, FC3WINDLY };
        static const isisU32_t window_mapping[] = { FC0WINWTH, FC1WINWTH, FC2WINWTH, FC3WINWTH };
        static const isisU32_t veto_mapping[] = { RVFCHOP0, RVFCHOP1, RVFCHOP2, RVFCHOP3 };

        if (m_options & EnvironmentCard<EnvPeriodPolicy>::FChopperVeto)
        {
                writeRegister(delay_mapping[chopper_number], delay, status);
                writeRegister(window_mapping[chopper_number], width, status);
                status.addInfoVa(FAC_DAE, "Fermi chopper %d delay,width (us) = %f,%f\n", chopper_number, delay / 50.0, width / 50.0);
                return setVetoRegisterBits(veto_mapping[chopper_number], true, status);
        }
        else
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Fermi Chopper Veto Not Available");
                return DAEstatus::Failure;
        }
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::disableFChopperVeto(int chopper_number, DAEstatus& status)
{
        static const isisU32_t veto_mapping[] = { RVFCHOP0, RVFCHOP1, RVFCHOP2, RVFCHOP3 };
        if (m_options & EnvironmentCard<EnvPeriodPolicy>::FChopperVeto)
        {
                return clearVetoRegisterBits(veto_mapping[chopper_number], status);
        }
        else
        {
                return DAEstatus::Success;
        }
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::getFChopperVetoedFrames(int chopper_number, isisU32_t* value, DAEstatus& status)
{
        *value = 0;
        static const isisU32_t mapping[] = { FC0VETFRM, FC1VETFRM, FC2VETFRM, FC3VETFRM };
        if (m_options & EnvironmentCard<EnvPeriodPolicy>::FChopperVeto)
        {
                readRegister(mapping[chopper_number], value, status);
        }
        return DAEstatus::Success;
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::setVetoRegisterBits(isisU32_t mask, bool preserve, DAEstatus& status)
{
    return setRegisterBits(RVETO, mask, preserve, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::clearVetoRegisterBits(isisU32_t mask, DAEstatus& status)
{
        return clearRegisterBits(RVETO, mask, status);
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::printVetoDetails(std::ostream& os, DAEstatus& status)
{
        int i;
        isisU32_t veto_reg, frames;
        readRegister(RVETO, &veto_reg, status);
        for(i=0; veto_details[i].name != NULL; i++)
        {
                if (!veto_details[i].pc_only)
                {
                        readRegister(veto_details[i].counter_addr, &frames, status);
                        os << veto_details[i].name << " is " << ((veto_reg & veto_details[i].mask) != 0 ? "ENABLED (vetoed " : "DISABLED (counted ") << frames << ") frames\n";
                }
        }
        return DAEstatus::Success;
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::whichVeto(std::ostream& os, DAEstatus& status)
{
        int i;
        isisU32_t veto_reg = 0, rf1 = 0, rf2 = 0;
        double rfdiff;
        int poll_time = 5;  // in seconds
        int nveto;
        for(nveto = 0; veto_details[nveto].name != NULL; ++nveto)
                ;
        isisU32_t* vframes1 = new isisU32_t[nveto];
        isisU32_t* vframes2 = new isisU32_t[nveto];
        readRegister(RVETO, &veto_reg, status);
        getRawFrames(&rf1, status);
        for(i=0; i < nveto; i++)
        {
                if (!veto_details[i].pc_only)
                {
                        vframes1[i] = 0;
                        readRegister(veto_details[i].counter_addr, &(vframes1[i]), status);
                }
        }
        Sleep(poll_time * 1000);
        for(i=0; i < nveto; i++)
        {
                if (!veto_details[i].pc_only)
                {
                        vframes2[i] = 0;
                        readRegister(veto_details[i].counter_addr, &(vframes2[i]), status);
                }
        }
        getRawFrames(&rf2, status);
        rfdiff = rf2 - rf1;
        for(i=0; i < nveto; i++)
        {
                if ( ((veto_reg & veto_details[i].mask) != 0) && !veto_details[i].pc_only )
                {
                        os << veto_details[i].name << " vetoed ";
                        if (rfdiff > 0.0)
                        {
                                os << (int)(100.0 * (vframes2[i] - vframes1[i]) / rfdiff);
                        }
                        else
                        {
                                os << "<unknown>";
                        }
                        os << "% (last " << poll_time << " seconds), ";
                        if (rf2 > 0)
                        {
                                os << (int)(100.0 * vframes2[i] / rf2);
                        }
                        else
                        {
                                os << "<unknown>";
                        }
                        os << "% (since run start)\n";
                }
        }
        delete[] vframes1;
        delete[] vframes2;
        return DAEstatus::Success;
}

template <class EnvPeriodPolicy>
int EnvironmentCard<EnvPeriodPolicy>::resetCardState(DAEstatus& status)
{
        LOGSTR_INFORMATION("Nothing to do");
        return ISISVME::Success;
}

template class EnvironmentCard<DAE2EnvPeriodPolicy>;
template class EnvironmentCard<DAE3EnvPeriodPolicy>;