daeset.cpp

Go to the documentation of this file.

#include <iostream>
#include <sstream>

#include <time.h>
#include "isisdae.h"

static ISISDAE* dae = 0;
static bool simulate_vme = (getenv("SIMULATE_VME") != 0 ? true : false);
static std::ostringstream *dae_pOut, *dae_pInf, *dae_pWarn, 
                *dae_pErr, *dae_pDbg;

extern "C" 
{
        void __stdcall DAE_DEVICE(short& tempchan, int& simulate);
        void __stdcall DAESET(short& zaachan,int crat[],int daep[], 
                int dat1[], int modn[],int mpos[],int& ndet,int& nper,
                int& ntrg,int pmap[],int& nfpp, int& pre1, int spec[],
                int tcb1[], int timr[], int ntcftr[], int nosftr[], int& vaxmax,
                int& status, int& daebegerror, int& logstatus, int& delay, 
                int& synch,int vetoes[], int& cper, int& save_permax, 
                int save_tpoffset[], int& datamode, int& tables_only);
        void __stdcall DAEPAUSE(short& zaachan, isisU32_t& igfc, 
                isisU32_t& irfc, int& status);
        void __stdcall DAERESUME(short& zaachan, int& cper, int& save_permax, 
                                                 int& save_tpoffset, int& status);
        void __stdcall DAEEND(isisU32_t dat1[], int daep[], int ntcftr[], int nosftr[],
                                          int& nper, int& ntrg, short& zaachan, isisU32_t& igfc, isisU32_t& irfc,
                                          int& status);
        int __stdcall RIO(isis32_t& bus_addr, isisU16_t* word, isis16_t& device);
        int __stdcall WIO(isis32_t& bus_addr, isisU16_t* word, isis16_t& device);
        int __stdcall RIOD(isis32_t& bus_addr, isisU16_t* word, isis32_t& nwrds, isis16_t& device);
        int __stdcall WIOD(isis32_t& bus_addr, isisU16_t* word, isis32_t& nwrds, isis16_t& device);
        int rio_c(long bus_addr, isisU16_t* word, short device);
        int read_crpt_c(int **start, int& section, int& size);
        int open_dae_cds(const char* name);
        int __stdcall WMEM(isis32_t& bus_addr, isisU16_t* word, isisU16_t& device);
        int __stdcall RMEM(isis32_t& bus_addr, isisU16_t* word, isisU16_t& device);
        int __stdcall WMEMD(isis32_t& bus_addr, isisU16_t* word, isis32_t& nwrds, isisU16_t& device);
        int __stdcall RMEMD(isis32_t& bus_addr, isisU16_t* word, isis32_t& nwrds, isisU16_t& device);
        int __stdcall RMEMVI(isis32_t& bus_addr, isisU32_t* buffer, isisU32_t& length, 
                isis16_t& device, isis32_t& wrd_len);
        int __stdcall DAECP(int code);
    int read_crpt_array_c(int start, int length, int section[]);
        int set_dae_streams(std::ostringstream* pOut, std::ostringstream* pInf, std::ostringstream* pWarn, 
                           std::ostringstream* pErr, std::ostringstream* pDbg);
};


int __stdcall WIO(isis32_t& bus_addr, isisU16_t* word, isis16_t& device)
{
        OUTPUT_MESSAGE(*dae_pErr,"WIO error" << std::endl);
        return 0;
}

int __stdcall WIOD(isis32_t& bus_addr, isisU16_t* word, isis32_t& nwrds, isis16_t& device)
{
        OUTPUT_MESSAGE(*dae_pErr,"WIOD error" << std::endl);
        return 0;
}

int rio_c(long bus_addr, isisU16_t* word, short device)
{
        return RIO(bus_addr, word, device);
}

int read_crpt_c(int **start, int& section, int& size)
{
        OUTPUT_MESSAGE(*dae_pErr,"read_crpt_c error" << std::endl);
        return 0;
}

int open_dae_cds(const char* name)
{
        if (dae == 0)
        {       
                dae = new ISISDAE(dae_pOut, dae_pInf, dae_pWarn, dae_pErr, dae_pDbg, simulate_vme);
                if ( getenv("ISISVME_DEVICE") != NULL )
                {
                        dae->open(getenv("ISISVME_DEVICE"));
                }
                else
                {
                        dae->open("VXI0::MEMACC");
                }
        }
        return 1;
}

int __stdcall WMEM(isis32_t& bus_addr, isisU16_t* word, isisU16_t& device)
{
        OUTPUT_MESSAGE(*dae_pErr,"wmem error" << std::endl);
        return 0;
}

int __stdcall WMEMD(isis32_t& bus_addr, isisU16_t* word, isis32_t& nwrds, isisU16_t& device)
{
        OUTPUT_MESSAGE(*dae_pErr,"wmemd error" << std::endl);
    return 0;
}

int __stdcall RMEM(isis32_t& bus_addr, isisU16_t* word, isisU16_t& device)
{
        isisU32_t temp;
        dae->readHistogramMemory(bus_addr, &temp, 1);
        *word = (isisU16_t)temp;
        return 1;
}

int __stdcall RMEMD(isis32_t& bus_addr, isisU16_t* word, isis32_t& nwrds, isisU16_t& device)
{
    if ( ((unsigned long)word % sizeof(isisU32_t)) == 0 )
        {
                dae->readHistogramMemory(bus_addr, (isisU32_t*)word, nwrds / 2);
                return 1;
        }
        else
        {
                OUTPUT_MESSAGE(*dae_pErr,"RMEMD error - address not 32bit aligned" << std::endl);
                return 0;
        }
}

int __stdcall RMEMVI(isis32_t& bus_addr, isisU32_t* buffer, isisU32_t& length, 
                isis16_t& device, isis32_t& wrd_len)
{
        if (wrd_len == 4)
        {
            dae->readHistogramMemory(bus_addr, buffer, length);
                return 1;
        }
        else
        {
                OUTPUT_MESSAGE(*dae_pErr,"RMEMVI: illegal word length " << wrd_len << std::endl);
                return 0;
        }
}

int __stdcall RIO(isis32_t& bus_addr, isisU16_t* word, isis16_t& device)
{
        switch(bus_addr)
        {

                case 1544:
                        dae->getGoodFramesLower(word);
                        break;

                case 1548:
                        dae->getGoodFramesUpper(word);
                        break;

                case 1552:
                        dae->getRawFramesLower(word);
                        break;

                case 1556:
                        dae->getRawFramesUpper(word);
                        break;

                case 2208:
                        dae->getRawPPPLower(word);
                        break;

                case 2210:
                        dae->getRawPPPMiddle(word);
                        break;

                case 2212:
                        dae->getRawPPPUpper(word);
                        break;

                case 2224:
                        dae->getGoodPPPLower(word);
                        break;

                case 2226:
                        dae->getGoodPPPMiddle(word);
                        break;

                case 2228:
                        dae->getGoodPPPUpper(word);
                        break;

                default:
                        OUTPUT_MESSAGE(*dae_pErr,"RIO: unknown address " << bus_addr << std::endl);
                        return 0;
                        break;
        }
        return 1;
}

int __stdcall RIOD(isis32_t& bus_addr, isisU16_t* word, isisU32_t& nwrds, isis16_t& device)
{
        OUTPUT_MESSAGE(*dae_pErr,"riod error" << std::endl);    
    return 0;
}

void __stdcall DAESET(short& zaachan,int crat[],int daep[], int dat1[],
    int modn[],int mpos[],int& ndet,int& nper,
    int& ntrg,int pmap[],int& nfpp, int& pre1, int spec[],
        int tcb1[], int timr[], int ntcftr[], int nosftr[], int& vaxmax,
    int& status, int& daebegerror, int& logstatus, int& delay, 
        int& synch,int vetoes[], int& cper, int& save_permax, 
        int save_tpoffset[], int& datamode, int& tables_only)
{
// crat[ndet] daep[2] dat1[vaxmax] modn[ndet] mpos[ndet]
// pmap[256]  spec[ndet] tcp1[ntc1+1] timr[ndet] vetos[5]
// ntcftr[16] nosftr[16] save_tpoffset[16]
        int trcn[16];
        int i, j, len;
        OUTPUT_MESSAGE(*dae_pInf,"Entering VME DAEBEG" << std::endl);
        if (dae == 0)
        {
                OUTPUT_MESSAGE(*dae_pErr,"Error - no DAE assigned" << std::endl);
                return;
        }
        status = 0;
        logstatus = 0;
        daebegerror = 0;
        if (ndet > 13*64*1024)
        {
                OUTPUT_MESSAGE(*dae_pErr,"Too many detectors" << std::endl);
                daebegerror=6;  // too many detectors
                return;
        }
        int ic, maxcrate = 0;
        for(i=0; i<ndet; i++)
        {
                if (crat[i] > maxcrate)
                {
                        maxcrate = crat[i];
                }
        }
        for(i=0; i<16; i++)
        {
                trcn[i] = 0;
        }
        for(j=0; j<ndet; j++)
        {
                ic = crat[j];
                if (trcn[ic] != 0)
                {
                        if (trcn[ic] != timr[j])
                        {
                                OUTPUT_MESSAGE(*dae_pErr,"Time regime problem" << std::endl);
                                daebegerror = 1;
                                return;
                        }
                }
                else
                {
                        trcn[ic] = timr[j];
                }
        }
        for(i=0; i<maxcrate; i++)
        {
                if (trcn[i] == 0)
                {
                        OUTPUT_MESSAGE(*dae_pInf,"Warning: Time regime " << trcn[i] << " for crate " << i << std::endl);
//                      daebegerror = 2;
//                      return;
                }
                if (datamode == 1 && trcn[i] > 1)
                {
                        OUTPUT_MESSAGE(*dae_pErr,"Time regime > 1 for crate " << i << std::endl);
                        daebegerror = 3;
                        return;
                }
        }
        int permax = 0;
        for(i=0; i<ntrg; i++)
        {
                permax += (ntcftr[i]+1) * (nosftr[i]+1);
        }
        save_permax = permax;
        len = permax * nper;    // len * daep[0] bytes of memory
        if (len * daep[0] > daep[1])
        {
                OUTPUT_MESSAGE(*dae_pErr,"Not enough DAE memory" << std::endl);
                daebegerror = 4;
                return;
        }
        if (len > vaxmax)
        {
                OUTPUT_MESSAGE(*dae_pErr,"Not enough CRPT memory" << std::endl);
                daebegerror = 5;
                return;
        }
    OUTPUT_MESSAGE(*dae_pInf,"DAE memory = " << (len * daep[0]) / (1024 * 1024) << " Mb" << std::endl);
    OUTPUT_MESSAGE(*dae_pInf,"NPER = " << nper << std::endl);
        dae->stopRun();
        dae->resetRunController();
    if (tables_only == 0)
        {
                dae->clearHistogramMemory();
        }
        else
        {
                OUTPUT_MESSAGE(*dae_pInf,"TABLES ONLY - memory not zerod" << std::endl);
        }
        // TCG
        // prescale
        OUTPUT_MESSAGE(*dae_pInf, "Programming Time channels" << std::endl);
// need to allow for the prescale and delay 
        unsigned long * new_tcb1 = new unsigned long[ntcftr[0]+1];
    int pulse_generator = 0;   // are we using a pulse generator to simulate a frame synch delay?
    if (getenv("PULSE_GENERATOR") != 0)
        {
                pulse_generator = atol(getenv("PULSE_GENERATOR"));
        }
        int frame_delay;
        if (pulse_generator == 1)
        {
                frame_delay = ((tcb1[0] * pre1) / 32);
                OUTPUT_MESSAGE(*dae_pInf,"PULSE_GENERATOR: frame delay = " << 4 * delay + frame_delay << " us" << std::endl);
                for(i=0; i <= ntcftr[0]; i++)
                {
// tcb are in clock pulses, delay is in us hence * 32
                        new_tcb1[i] = tcb1[i] * pre1 - frame_delay * 32;
                        if ( (new_tcb1[i] & 0xff000000) != 0 )
                        {
                                OUTPUT_MESSAGE(*dae_pWarn,"Warning: TCG value larger than 24 bits" << std::endl);
                        }
                }
        }
        else
        {
                OUTPUT_MESSAGE(*dae_pInf, "Frame sync delay = " << delay * 4 << " us" << std::endl);
                for(i=0; i <= ntcftr[0]; i++)
                {
// tcb are in clock pulses, delay is in us hence * 32
//                      new_tcb1[i] = tcb1[i] * pre1  + (4 * delay) * 32;
// get 0.21us for free (7 clock pulses)
                        new_tcb1[i] = tcb1[i] * pre1  - 7;
                        if ( (new_tcb1[i] & 0xff000000) != 0 )
                        {
                                OUTPUT_MESSAGE(*dae_pWarn,"Warning: TCG value larger than 24 bits" << std::endl);
                        }
                }
        }
        OUTPUT_MESSAGE(*dae_pInf,"setting " << ntcftr[0] << " time channels from " << (double)new_tcb1[0] / 32.0 << " to " << (double)new_tcb1[ntcftr[0]] / 32.0 << " us" << std::endl);
        dae->setTimeChannels(new_tcb1, ntcftr[0]);
        delete[] new_tcb1;
        dae->setFrameSyncDelay(4 * delay);
        OUTPUT_MESSAGE(*dae_pInf,"Programming POSLUT" << std::endl);
        dae->programDAE1POSLUT(crat, maxcrate, modn, mpos, spec, ndet, nper);
//
        dae->setFrameSync(synch == 1);
//
        OUTPUT_MESSAGE(*dae_pInf,  "Setting vetos" << std::endl);
        dae->setDAE1Vetos(vetoes, 3);
        logstatus = 1;  // OK
        OUTPUT_MESSAGE(*dae_pInf , "Starting run" << std::endl);
    if (tables_only == 0)
        {
            dae->startRun(true);
        }
        else
        {
                dae->startRun(false);   // don't clear frames and ppp
        }
        status = 1;
        OUTPUT_MESSAGE(*dae_pInf,"Leaving VME DAEBEG" << std::endl);
}

void __stdcall DAEPAUSE(short& zaachan, isisU32_t& igfc, isisU32_t& irfc, int& status)
{
    OUTPUT_MESSAGE(*dae_pInf , "Entering VME DAEPAUSE" << std::endl);
        status = 1;
        dae->stopRun();
        dae->getRawFrames(&irfc);
        dae->getGoodFrames(&igfc);
// return 0 as the frame count to avoid overcounting. DAE1 zerod these
// counters on stop/start data collection, but DAE-II doesn't
        irfc = igfc = 0;
    OUTPUT_MESSAGE(*dae_pInf , "Leaving VME DAEPAUSE" << std::endl);

}

void __stdcall DAERESUME(short& zaachan, int& cper, int& save_permax, int& save_tpoffset, int& status)
{
        OUTPUT_MESSAGE(*dae_pInf , "Entering VME DAERESUME" << std::endl);
        status = 1;
        dae->changePeriod(cper);
        dae->startRun(false);
        OUTPUT_MESSAGE(*dae_pInf , "Leaving VME DAERESUME" << std::endl);
}

void __stdcall DAEEND(isisU32_t dat1[], int daep[], int ntcftr[], int nosftr[],
                                          int& nper, int& ntrg, short& zaachan, isisU32_t& igfc, isisU32_t& irfc,
                                          int& status)
{
        int i;
        bool differ = false;
        isisU32_t* temp_buffer;
        OUTPUT_MESSAGE(*dae_pInf , "Entering VME DAEEND" << std::endl);
        dae->stopRun();
        dae->getRawFrames(&irfc);
        dae->getGoodFrames(&igfc);
        int permax = 0;
        for(i=0; i<ntrg; i++)
        {
                *dae_pInf << "Time regime " << i+1 << " NTC " << ntcftr[i] << " NOS " << nosftr[i] << std::endl;
                permax += (ntcftr[i] + 1) * (nosftr[i] + 1);
        }
        int len = permax * nper;
        *dae_pInf << nper << " periods of size " << permax << " words" << std::endl;
        temp_buffer = 0 /* new isisU32_t[len] */ ;
// these two reads should be the same 
//      std::cerr << "Trying readAllDAE1Spectra()" << std::endl;
//      dae->readAllDAE1Spectra(temp_buffer);

        SYSTEMTIME s;
        GetSystemTime(&s);
        *dae_pInf << "Trying readHistogramMemory() " << (double)s.wSecond + (double)s.wMilliseconds/1000.0 << std::endl;
        dae->readHistogramMemory(0, dat1, len);
        GetSystemTime(&s);
        *dae_pInf << "Done readHistogramMemory() " << (double)s.wSecond + (double)s.wMilliseconds/1000.0 << std::endl;
#if 0
        std::cerr << "Checking for differences ..." << std::endl;
        for(i=0; i< len; i++)
        {
                if (temp_buffer[i] != dat1[i])
                {
                        differ = true;
//                      std::cerr << i << " " << hex << temp_buffer[i] << " " << dat1[i] << dec << std::endl;
                }
        }
        if (differ) 
        {
                std::cerr << "they differ";
        }
        std::cerr << std::endl;
#endif
        delete[] temp_buffer;
        status = 1;
        OUTPUT_MESSAGE(*dae_pInf , "Leaving VME DAEEND" << std::endl);
}

int __stdcall DAECP(int code)
{
        OUTPUT_MESSAGE(*dae_pErr , "error - called VME DAECP" << std::endl);
        return 0;
}

int read_crpt_array_c(int start, int length, int section[])
{
        OUTPUT_MESSAGE(*dae_pErr , "error - called VME read_crpt_array_c" << std::endl);
    return 1;
}