isiscrpt.cpp

Go to the documentation of this file.

#include "stdafx.h"

#include "isiscrpt.h"
#include "isisraw.h"


static const char* inst_abrv_mappings[][2] = {
        { "SURF", "SRF" },
        { "INES", "INS" },
        { "CRISP", "CSP" },
//      { "ENGINX", "ENG" },
        { "IRIS", "IRS" },
//      { "OSIRIS", "OSI" },
        { "MAPS", "MAP" },
        { "MARI", "MAR" },
        { "MERLIN", "MER" },
        { "TOSCA", "TSC" },
        { "HRPD", "HRP" },
//      { "PEARL", "PRL" },
        { "POLARIS", "POL" },
        { "SANDALS", "SLS" },
        { "PRISMA", "PRS" },
        { "ROTAX", "RTX" },
        { "VESUVIO", "VES" },     // EVS at the moment
        { NULL, NULL }
};

// short names only used for the ISIS VMS RAW files that are generated on neutron instruments
static const char* getInstAbrv(const char* inst_name)
{
        static char buffer[256];
        int i;
        if (getenv("SHORTNAME") != NULL)
        {
                strncpy(buffer, getenv("SHORTNAME"), sizeof(buffer));
                return buffer;
        }
        strncpy(buffer, inst_name, sizeof(buffer));
        for(i=0; inst_abrv_mappings[i][0] != NULL; i++)
        {
                if (stricmp(inst_name, inst_abrv_mappings[i][0]) == 0)
                {
                        strncpy(buffer, inst_abrv_mappings[i][1], sizeof(buffer));
                }
        }
        NULL_TERMINATE(buffer);
        return buffer;
}

ISISCRPT_STRUCT::ISISCRPT_STRUCT(ISISDAE::DAEType dae_type_, const std::string& comp_name)
{       
//      TCHAR buffer[MAX_COMPUTERNAME_LENGTH+1];        
//      DWORD nbuffer = MAX_COMPUTERNAME_LENGTH+1;      
        memset(this, 0, sizeof(ISISCRPT_STRUCT));       
        version = ISISCRPT_VERSION;
        spacePadCopy(rcsid, crpt_rcsid, sizeof(rcsid));
        NULL_TERMINATE(rcsid);
        run_status = RUNSTATUS_SETUP;
        dae_type = dae_type_;
        se_status = SESTATUS_INRANGE;
//      GetComputerName(buffer, &nbuffer);
        setInstName(comp_name);
        strncpy(long_title, "long title", sizeof(long_title));
        time_scaler = 6;
        ntrg = 1;                       // number of time regimes (=1)
        nper = 1;                       // number of periods
        nper_daq = 1;
        nperseq = 0;            // number of period sequences
        run_number = 1;
        nsp[0] = 2;
        ntc[0] = 1;
        persize = (nsp[0] + 1) * (ntc[0] + 1);
        timr_dae[0] = timr_crpt[0] = timr_file[0] = 1;  // without wiring tables, all spectra/detectors go to index 0 and we need a valid Time regime
//      auto_save_frames = 5000;
        auto_save_value = 5000;
        period_output_delay = 20000;
        software_period = 0; // first
        update_poll_time = 5;
        log_nlines = 0;
        magic = 0x12345678;
        monitoring.n = 5;
        crpt_size = sizeof(ISISCRPT_STRUCT);

        uamp_scale = 1.0;

//      tcb_maxtime = 400000;   // max time dae can handle
        tcb_maxtime = 16 * 1000 * 1000;   // max time dae can handle - set to 16 seconds for TS2
        tcb_maxdelay = ((1 << 18) - 1); // max delay on frame clock in microseconds, 18 bit register

        setDAESpecificParameters();

        ICPClock* the_clock = g_icp_clock.get();
        the_clock->getParameters(icp_clock.perf_counter, icp_clock.proc_freq, icp_clock.filetime);

        markUninitialised();   // as we only have default values
}

int ISISCRPT_STRUCT::setDAESpecificParameters()
{
        if (dae_type == ISISDAE::MuonDAE2 || dae_type == ISISDAE::MuonDAE3)
        {
                clock_frequency = 2;
                electronics_delay = 0;
                tcb_mintime = 0.0;
        }
        else // ISISDAE::NeutronDAE2 || ISISDAE::NeutronDAE3
        {
                clock_frequency = 32;           // dae clock frequency (MHz) 32 for DAE2
                electronics_delay = 7;          // get 0.21us for free (7 clock pulses) on neutron dae2
//              tcb_mintime = 5.0f + (float)electronics_delay / (float)clock_frequency;                 // lowest time dae can handle
                tcb_mintime = 5.0;                      // lowest time dae can handle
        }
        tcb_minwidth = 0.25;    // minimum channel width dae can handle (0.25)
        if (getenv("ISISICP_MIN_TCBWIDTH") != NULL)
        {
                tcb_minwidth = static_cast<float>(atof(getenv("ISISICP_MIN_TCBWIDTH")));        // minimum channel width dae can handle
        }
        return 0;
}

// copy one string to another and pad out the destination string with spaces
// if it is longer
int spacePadCopy(char* output, const char* input, int output_size)
{
        int i, n = 0;
        while( (n < output_size) && (input[n] != '\0') )
        {
                output[n] = input[n];
                n++;
        }
        for(i=n; i<output_size; i++)
        {
                output[i] = ' ';
        }
        return 0;
}

int spacePadCopyVa(char* output, int output_size, const char* format, ... )
{
        va_list args;
        int i, n;
        va_start(args, format);
        n = vsnprintf(output, output_size, format, args);
        va_end(args);
        if (n >= 0)
        {
                for(i=n; i<output_size; i++)
                {
                        output[i] = ' ';
                }
        }
        return 0;
}



int spaceTrimCopy(char* output, int output_size, const char* input, int input_size)
{
        int n = 0;
        n = input_size; 
        while( (n > 0) && (input[n-1] == ' ') )
        {
                n--;
        }
        if (n >= output_size)
        {
                n = output_size - 1;
        }
        strncpy(output, input, n);
        output[n] = '\0';
        return 0;
}

int ISISCRPT_STRUCT::getCharItem(const char* item_name, long spec, std::string& cvalue, DAEstatus& status) const
{
        int i;
        char ctemp[256];
        memset(ctemp, ' ', sizeof(ctemp));
#include "isiscrpt_items.h"
        for(i=0; i< sizeof(char_items) / sizeof(char_item); i++)
        {
                if (!strcmp(item_name, char_items[i].name))
                {
                        cvalue = char_items[i].val;
                        return DAEstatus::Success;
                }
        }
        if (!strcmp(item_name, "HDR"))
        {
                strncpy(&(ctemp[0]), this->inst_abrv, 3);
                sprintf(&(ctemp[3]), "%05d", this->run_number % VMS_RUN_MASK);
                strncpy(&(ctemp[8]), this->user_name, 20);
                strncpy(&(ctemp[28]), this->long_title, 24);
                ISISRAW::vmstime(&(ctemp[52]), 21, this->stop_time); // use 21 rather than 20 to allow NULL termination
                sprintf(&(ctemp[72]), "%8.2f", this->update_good_uamph);
                for(i=0; i<80; i++)
                {
                        if (ctemp[i] == '\0')
                        {
                                ctemp[i] = ' ';
                        }
                }
                ctemp[80] = '\0';
                cvalue = ctemp;
                return DAEstatus::Success;
        }
        if (!strcmp(item_name, "CRPB"))
        {
                ISISRAW::vmstime(&(ctemp[64]), 21, this->stop_time); // use 21 rather than 20 to allow NULL termination
                for(i=0; i<128; i++)
                {
                        if (ctemp[i] == '\0')
                        {
                                ctemp[i] = ' ';
                        }
                }
                ctemp[128] = '\0';
                cvalue = ctemp;
                return DAEstatus::Success;
        }
        return DAEstatus::Failure;
}

int ISISCRPT_STRUCT::getCharItem(const char* item_name, std::string& cvalue, DAEstatus& status) const
{
        return getCharItem(item_name, 1, cvalue, status);
}

int ISISCRPT_STRUCT::getIntItem(const char* item_name, long& lVal, DAEstatus& status) const
{
        std::string sitem_name;
        std::string tmp_item;
        size_t n;
        long spec_no;
        // handle case of item_spectrum which means we average the array
        // item[ndet] for that particular spectrum
        sitem_name = item_name;
        n = sitem_name.find('_');
        if (n != std::string::npos)
        {
                spec_no = atol(item_name+n+1);
                tmp_item = sitem_name.substr(0,n);
                return getIntItem(tmp_item.c_str(), &spec_no, 1, &lVal, status);
        }
        else
        {
                spec_no = 0;
                return getIntItem(item_name, &spec_no, 0, &lVal, status);
        }
}

// nspec number of 0 means no spec average
int ISISCRPT_STRUCT::getIntItem(const char* item_name, const long* spec_array, int nspec, long* lVal, DAEstatus& status) const
{
        int i, j, n;
        std::string sitem_name;
        std::string tmp_item;
        const int* pVal = NULL;
//    lVal = -1000;
#include "isiscrpt_items.h"
        for(i=0; i< sizeof(int_items) / sizeof(int_item); i++)
        {
                if (!strcmp(item_name, int_items[i].name))
                {
                        for(j=0; j < (nspec == 0 ? 1 : nspec); j++)
                        {
                                lVal[j] = *(int_items[i].pi);
                        }
                        return DAEstatus::Success;
                }
        }
        if (nspec == 0)
        {
                return DAEstatus::Failure;
        }
        tmp_item = item_name;
        pVal = NULL;
        for(i=0; i< sizeof(int_array_items) / sizeof(int_array_item); i++)
        {
                if (!tmp_item.compare(int_array_items[i].name))
                {
                        if (int_array_items[i].dim1 == 0)
                        {
                                n = *(int_array_items[i].dim0);
                        }
                        else
                        {
                                n = *(int_array_items[i].dim0) * *(int_array_items[i].dim1);
                        }
                        if (n == this->ndet)
                        {
                                pVal = int_array_items[i].pi;
                        }
                }
        }
        if (pVal == NULL)
        {
                return DAEstatus::Failure;
        }
        for(j=0; j<nspec; j++)
        {
                lVal[j] = 0;
                n = 0;
                for(i=0; i<this->ndet; i++)
                {
                        if (this->spec[i] == spec_array[j])
                        {
                                lVal[j] += pVal[i];
                                n++;
                        }
                }
                if (n > 0)
                {
                        lVal[j] = lVal[j] / n;
                }
        }
        return DAEstatus::Success;
}

int ISISCRPT_STRUCT::getRealItem(const char* item_name, const long* spec_array, int nspec, double* dblVal, DAEstatus& status) const
{
        int i, j, n;
        std::string sitem_name;
        std::string tmp_item;
        const float* pVal = NULL;
//    dblVal = -1000.0;
#include "isiscrpt_items.h"
        for(i=0; i< sizeof(real_items) / sizeof(real_item); i++)
        {
                if (!strcmp(item_name, real_items[i].name))
                {
                        for(j=0; j < (nspec == 0 ? 1 : nspec); j++)
                        {
                                dblVal[j] = *(real_items[i].pf);
                        }
                        return DAEstatus::Success;
                }
        }
        if (nspec == 0)
        {
                return DAEstatus::Failure;
        }
        tmp_item = item_name;
        pVal = NULL;
        for(i=0; i< sizeof(real_array_items) / sizeof(real_array_item); i++)
        {
                if (!tmp_item.compare(real_array_items[i].name))
                {
                        if (real_array_items[i].dim1 == 0)
                        {
                                n = *(real_array_items[i].dim0);
                        }
                        else
                        {
                                n = *(real_array_items[i].dim0) * *(real_array_items[i].dim1);
                        }
                        if (n == this->ndet)
                        {
                                pVal = real_array_items[i].pf;
                        }
                }
        }
        if (pVal == NULL)
        {
                return DAEstatus::Failure;
        }
        for(j=0; j<nspec; j++)
        {
                dblVal[j] = 0.0;
                n = 0;
                for(i=0; i<this->ndet; i++)
                {
                        if (this->spec[i] == spec_array[j])
                        {
                                dblVal[j] += pVal[i];
                                n++;
                        }
                }
                if (n > 0)
                {
                        dblVal[j] = dblVal[j] / (double)n;
                }
        }
        return DAEstatus::Success;
}

int ISISCRPT_STRUCT::getRealItem(const char* item_name, double& dblVal, DAEstatus& status) const
{
        size_t n;
        long spec_no;
        std::string sitem_name;
        std::string tmp_item;
    dblVal = -1000.0;
        // handle case of item_spectrum which means we average the arrat item[ndet] for
        // that particular spectrum
        sitem_name = item_name;
        n = sitem_name.find('_');
        if (n == std::string::npos)
        {
                spec_no = 0;
                return getRealItem(item_name, &spec_no, 0, &dblVal, status);
        }
        else
        {
                spec_no = atol(item_name+n+1);
                tmp_item = sitem_name.substr(0,n);
                return getRealItem(tmp_item.c_str(), &spec_no, 1, &dblVal, status);
        }
}

int ISISCRPT_STRUCT::getIntArrayItemSize(const char* item_name, const long* spec_array, int nspec, int* dims_array, int& ndims, DAEstatus& status) const
{
#include "isiscrpt_items.h"
        if ( !strcmp(item_name, "SPECTRUMT0") )  // spectrum including time bin 0
        {
                int ntc = 0;
                for(int i=0; i<nspec; ++i)
                {
                        ntc = std::max(ntc, this->spectrumNTC(spec_array[i]));
                }
                dims_array[0] = ntc + 1;
                ndims = 1;
                return DAEstatus::Success;
        }
        return DAEstatus::Failure;
}

int ISISCRPT_STRUCT::getIntArrayItemSize(const char* item_name, int* dims_array, int& ndims, DAEstatus& status) const
{
        int spec_from, spec_to;
        std::string str;
        SplitItem split_item;
        splitItemName(item_name, split_item);
#include "isiscrpt_items.h"
        if ( !strncmp(item_name, "CNT", 3) && (strlen(item_name) >= 5) && (item_name[4] == '[') )   // e.g. CNT1[53:789]
        {
                long tr = atol(item_name + 3);
                str = item_name;
                if (parseSpectraRange(str, spec_from, spec_to) == DAEstatus::Failure)
                {
                        return DAEstatus::Failure;
                }
                dims_array[0] = spec_to - spec_from + 1;
                dims_array[1] = (this->ntc[tr-1] + 1);
                ndims = 2;
                return DAEstatus::Success;
        }
        if ( !strncmp(item_name, "CNT", 3) )   // CNT1
        {
                long tr = atol(item_name + 3);
                dims_array[0] = this->getNumSpectra(tr, true) * this->nper;
                dims_array[1] = (this->ntc[tr-1] + 1);
                ndims = 2;
                return DAEstatus::Success;
        }
        if ( !strcmp(item_name, "SPECTRUMT0") )   // spectrum including time bin 0
        {
                int ntc = 0;
                for(int i=0; i<this->ntrg; ++i)
                {
                        ntc = std::max(ntc, this->ntc[i]);
                }
                dims_array[0] = ntc + 1;
                ndims = 1;
                return DAEstatus::Success;
        }
        if ( !strncmp(item_name, "TCB", 3) && (strlen(item_name) > 3) )         // raw bin boundaries
        {
                long tr = atol(item_name + 3);
                dims_array[0] = this->ntc[tr-1] + 1;
                ndims = 1;
                return DAEstatus::Success;
        }
        if (!strncmp(item_name, "SPECTRUM_", 9) || !strcmp(item_name, "SPECTRUM"))
        {
                dims_array[0] = this->spectrumNTC(split_item.number); // ignore bin 0
                ndims = 1;
                return DAEstatus::Success;
        }
        // isisraw compatability: 32 word structure of mixed int and real values
        if (!strcmp(item_name, "IRPB"))
        {
                dims_array[0] = 32;
                ndims = 1;
                return DAEstatus::Success;
        }
        // isisraw compatability: 64 word structure of int values
        if (!strcmp(item_name, "DAEP"))
        {
                dims_array[0] = 64;
                ndims = 1;
                return DAEstatus::Success;
        }
        for(int i=0; i< sizeof(int_array_items) / sizeof(int_array_item); i++)
        {
                if (!strcmp(item_name, int_array_items[i].name))
                {
                        if (int_array_items[i].dim1 == 0)
                        {
                                dims_array[0] = *(int_array_items[i].dim0);
                                ndims = 1;
                        }
                        else
                        {
                                dims_array[0] = *(int_array_items[i].dim0);
                                dims_array[1] = *(int_array_items[i].dim1);
                                ndims = 2;
                        }
                        return DAEstatus::Success;
                }
        }
        return DAEstatus::Failure;
}

int ISISCRPT_STRUCT::getRealArrayItemSize(const char* item_name, int* dims_array, int& ndims, DAEstatus& status) const
{
        SplitItem split_item;
        splitItemName(item_name, split_item);
#include "isiscrpt_items.h"
        if ( (!strncmp(item_name, "RSPECTRUM_", 10)) || 
                 (!strncmp(item_name, "RSPECERR_", 9)) ||
                 (!strcmp(item_name, "RSPECTRUM")) ||
                 (!strcmp(item_name, "RSPECERR")) )
        {
                dims_array[0] = spectrumNTC(split_item.number); // no bin 0
                ndims = 1;
                return DAEstatus::Success;
        }
        if ( !strncmp(item_name, "RTCB_", 5) )
        {
                dims_array[0] = spectrumNTC(split_item.number) + 1;
                ndims = 1;
                return DAEstatus::Success;
        }
        if ( !strncmp(item_name, "RTCB", 4) )   //RTCB1 etc
        {
                long tr = atol(item_name+4);
                dims_array[0] = this->ntc[tr-1] + 1;
                ndims = 1;
                return DAEstatus::Success;
        }
        if ( !strncmp(item_name, "TIM", 3) )   // TIM1 etc
        {
                long tr = atol(item_name+3);
                dims_array[0] = this->ntc[tr-1] + 1;
                ndims = 1;
                return DAEstatus::Success;
        }
        // isisraw compatability: 32 word structure of mixed int and real values
        if (!strcmp(item_name, "RRPB"))
        {
                dims_array[0] = 32;
                ndims = 1;
                return DAEstatus::Success;
        }
        for(int i=0; i< sizeof(real_array_items) / sizeof(real_array_item); i++)
        {
                if (!strcmp(item_name, real_array_items[i].name))
                {
                        if (real_array_items[i].dim1 == 0)
                        {
                                dims_array[0] = *(real_array_items[i].dim0);
                                ndims = 1;
                        }
                        else
                        {
                                dims_array[0] = *(real_array_items[i].dim0);
                                dims_array[1] = *(real_array_items[i].dim1);
                                ndims = 2;
                        }
                        return DAEstatus::Success;
                }
        }
        return DAEstatus::Failure;
}

int ISISCRPT_STRUCT::getIntArrayItem(const isisU32_t* raw_data, int raw_data_size, const char* item_name, const long* spec_array, int nspec, long* larray, DAEstatus& status) const
{
        SplitItem split_item;
        splitItemName(item_name, split_item);
#include "isiscrpt_items.h"
        std::string str;
        int i, j, k, n;
        time_t now;
        int spec_from, spec_to;
        std::string sitem_name = item_name;
        time(&now);
        if ( !strncmp(item_name, "CNT", 3) && (strlen(item_name) >= 5) && (item_name[4] == '[') )   // e.g. CNT1[53:789]
        {
                long tr = atol(item_name + 3);
                str = item_name;
                if (parseSpectraRange(str, spec_from, spec_to) == DAEstatus::Failure)
                {
                        return DAEstatus::Failure;
                }
                n = (this->ntc[tr-1] + 1) * (spec_to - spec_from + 1);
                uint32_t offset = this->spectrumCRPTOffsetImpl(spec_from, 0, raw_data_size);
                for(i=0; i<n ; i++)
                {
                        larray[i] = raw_data[i + offset];
                }
                return DAEstatus::Success;
        }
        if ( !strncmp(item_name, "CNT", 3) )  // e.g. CNT1
        {
                long tr = atol(item_name + 3);
                n = (this->ntc[tr-1] + 1) * (this->getNumSpectra(tr, true));
                for(j=0; j<this->nper; ++j)
                {
                        uint32_t offset = this->trCRPTOffset(tr, j, raw_data_size);
                        if (true)
                        {
                                for(i=0; i<n; ++i)
                                {
                                        larray[i+n*j] = raw_data[i+offset];
                                }
                        }
                        else
                        {
                                memset(larray+n*j, 0, n * sizeof(long));
                        }
                }
                return DAEstatus::Success;
        }
        if ( !strncmp(item_name, "TCB", 3) )   // TCB1 etc
        {
                int offset = 0;
                for(k=0; k<nspec; k++)
                {
                        int ntc = this->spectrumNTC(spec_array[k]);
                        int tr = this->spectrumCRPTTR(spec_array[k]);
                        for(i=0; i<ntc+1; i++)
                        {
                                larray[i + offset] = this->tcb[tr-1][i]; 
                        }
                        offset += (ntc + 1);
                        return DAEstatus::Success;
                }
        }
        if (!strcmp(item_name, "SPECTRUMT0"))   // spectra including time bin 0 
        {
                int k = 0, ntcmax = 0;
                for(j=0; j<nspec; j++)
                {
                        ntcmax = std::max(ntcmax, this->spectrumNTC(spec_array[j]));
                }
                for(j=0; j<nspec; j++)
                {
                        int ntc = this->spectrumNTC(spec_array[j]);
                        uint32_t offset = this->spectrumCRPTOffsetImpl(spec_array[j], 0, raw_data_size);
                        for(i=0; i < ntc+1; i++)
                        {
                                larray[i + k] = raw_data[offset+i];
                        }
                        k += (ntcmax + 1);
                }
                return DAEstatus::Success;
        }
        if (!strcmp(item_name, "SPECTRUM")) // spectra without time bin 0
        {
                int k = 0;
                for(j=0; j<nspec; j++)
                {
                        int ntc = this->spectrumNTC(spec_array[j]);
                        uint32_t offset = this->spectrumCRPTOffsetImpl(spec_array[j], 0, raw_data_size);
                        for(i=0; i<ntc; i++) // offset+1+i as ignore channel 0
                        {
                                larray[i + k] = raw_data[offset+1+i];
                        }
                        k += ntc;
                }
                return DAEstatus::Success;
        }
        // isisraw compatability: 32 word structure of mixed int and real values
        if (!strcmp(item_name, "IRPB")) 
        {
                memset(larray, 0, 32 * nspec * sizeof(int)); 
                for(k=0; k<nspec; k++)
                {
                        n = k * 32;
                        larray[0 + n] = this->update_duration;
                        larray[1 + n] = 1;
                        larray[9 + n] = this->update_good_frames;
                        larray[10 + n] = this->update_raw_frames;
                        larray[12 + n] = this->update_duration;
                }
                return DAEstatus::Success;
        }
        // isisraw compatability: 64 word structure of int values
        if (!strcmp(item_name, "DAEP"))
        {
                memset(larray, 0, 64 * nspec * sizeof(int)); 
                for(k=0; k<nspec; k++)
                {
                        n = k * 64;
                        larray[0 + n] = 4;
                        larray[1 + n] = larray[0 + n] * (this->nsp[0] + 1) * (this->ntc[0] + 1) * this->nper_daq;
                        larray[3 + n] = this->update_good_ppp_high;
                        larray[4 + n] = this->update_good_ppp_low;
                        larray[5 + n] = this->update_total_ppp_high;
                        larray[6 + n] = this->update_total_ppp_low;
                        larray[23 + n] = this->tcb_delay / 4;
                        if (this->tcb_sync == FrameSyncInternalTest)
                        {
                                larray[24 + n] = 1;
                        }
                        else
                        {
                                larray[24 + n] = 0; // external
                        }
                        if (this->ntrg > 1)
                        {
                                larray[29 + n] = this->ntrg;
                                for(i=0; i<this->ntrg; i++)
                                {
                                        larray[30 + i + n] = this->tcb_trdelay[i];
                                }
                        }
                        else
                        {
                                larray[29 + n] = 0;
                        }
                }
                return DAEstatus::Success;
        }
        for(i=0; i< sizeof(int_array_items) / sizeof(int_array_item); i++)
        {
                if (!strcmp(item_name, int_array_items[i].name))
                {
                        if (int_array_items[i].dim1 == 0)
                        {
                                n = *(int_array_items[i].dim0);
                        }
                        else
                        {
                                n = *(int_array_items[i].dim0) * *(int_array_items[i].dim1);
                        }
                        for(k=0; k<nspec; k++)
                        {
                                for(j=0; j<n; j++)
                                {
                                        larray[j + k * n] = int_array_items[i].pi[j];
                                }
                        }
                        return DAEstatus::Success;
                }
        }
        return DAEstatus::Failure;
}

int ISISCRPT_STRUCT::getIntArrayItem(const isisU32_t* raw_data, int raw_data_size, const char* item_name, long* larray, DAEstatus& status) const
{
        size_t n;
        long spec_no;
        std::string sitem_name, tmp_item;
        sitem_name = item_name;
        n = sitem_name.find('_');
        if (n != std::string::npos)
        {
                spec_no = atol(item_name+n+1);
                tmp_item = sitem_name.substr(0,n);
                return getIntArrayItem(raw_data, raw_data_size, tmp_item.c_str(), &spec_no, 1, larray, status);
        }
        else
        {
                spec_no = 0;
                return getIntArrayItem(raw_data, raw_data_size, item_name, &spec_no, 1, larray, status);
        }
}

int ISISCRPT_STRUCT::getRealArrayItem(const isisU32_t* raw_data, int raw_data_size, const char* item_name, double* darray, DAEstatus& status) const
{
        return getRealArrayItemHelper<double>(raw_data, raw_data_size, item_name, darray, status);
}

int ISISCRPT_STRUCT::getRealArrayItem(const isisU32_t* raw_data, int raw_data_size, const char* item_name, float* farray, DAEstatus& status) const
{
        return getRealArrayItemHelper<float>(raw_data, raw_data_size, item_name, farray, status);
}

int ISISCRPT_STRUCT::getRealArrayItem(const isisU32_t* raw_data, int raw_data_size, const char* item_name, const long* spec_array, int nspec, double* darray, DAEstatus& status) const
{
        return getRealArrayItemHelper<double>(raw_data, raw_data_size, item_name, spec_array, nspec, darray, status);
}

int ISISCRPT_STRUCT::getRealArrayItem(const isisU32_t* raw_data, int raw_data_size, const char* item_name, const long* spec_array, int nspec, float* farray, DAEstatus& status) const
{
        return getRealArrayItemHelper<float>(raw_data, raw_data_size, item_name, spec_array, nspec, farray, status);
}

template <typename T>
int ISISCRPT_STRUCT::getRealArrayItemHelper(const isisU32_t* raw_data, int raw_data_size, const char* item_name, T* darray, DAEstatus& status) const
{
        size_t n; 
        long spec_no;
        std::string sitem_name, tmp_item;
        sitem_name = item_name;
        n = sitem_name.find('_');
        if (n != std::string::npos)
        {
                spec_no = atol(item_name+n+1);
                tmp_item = sitem_name.substr(0,n);
                return getRealArrayItemHelper<T>(raw_data, raw_data_size, tmp_item.c_str(), &spec_no, 1, darray, status);
        }
        else
        {
                spec_no = 0;
                return getRealArrayItemHelper<T>(raw_data, raw_data_size, item_name, &spec_no, 1, darray, status);
        }
}

template <typename T>
int ISISCRPT_STRUCT::getRealArrayItemHelper(const isisU32_t* raw_data, int raw_data_size, const char* item_name, const long* spec_array, int nspec, T* darray, DAEstatus& /*status*/) const
{
#include "isiscrpt_items.h"
        int i, j, k, n;
        std::string sitem_name = item_name;
//      long sum;
        if ( !strncmp(item_name, "RTCB", 4) || !strncmp(item_name, "TIM", 3) )  // TCB1 or TIM1 etc
        {
                n = 0;
                for(k=0; k<nspec; k++)
                {
                        int ntc = this->spectrumNTC(spec_array[k]);
                        int tr = this->spectrumCRPTTR(spec_array[k]);
                        for(i=0; i<ntc+1; i++)
                        {
                                darray[i + n] = this->rtcb[tr-1][i];
                        }
                        n += ntc;
                }
                return DAEstatus::Success;
        }
        if (!strcmp(item_name, "RSPECTRUM"))
        {
                n = 0;
                for(k=0; k<nspec; k++)
                {
                        uint32_t offset = this->spectrumCRPTOffsetImpl(spec_array[k], 0, raw_data_size);
                        int ntc = this->spectrumNTC(spec_array[k]);
                        int tr = this->spectrumCRPTTR(spec_array[k]);
                        for(i=0; i<ntc; i++) // n+1+i as ignore time channel 0
                        {
                                darray[i + n] = raw_data[offset+1+i] / (this->rtcb[tr-1][i+1] - this->rtcb[tr-1][i]);
                        }
                        n += ntc;
                }
                return DAEstatus::Success;
        }
        if (!strcmp(item_name, "RSPECERR"))
        {
                n = 0;
                for(k=0; k<nspec; k++)
                {
                        uint32_t offset = this->spectrumCRPTOffsetImpl(spec_array[k], 0, raw_data_size);
                        int ntc = this->spectrumNTC(spec_array[k]);
                        int tr = this->spectrumCRPTTR(spec_array[k]);
                        for(i=0; i<ntc; i++)   // n+1+i as ignore time channel 0
                        {
                                darray[i + n] = static_cast<T>(sqrt((double)raw_data[offset+1+i]) / (this->rtcb[tr-1][i+1] - this->rtcb[tr-1][i]));
                        }
                        n += ntc;
                }
                return DAEstatus::Success;
        }
        // isisraw compatability: 32 word structure of mixed int and real values
        if (!strcmp(item_name, "RRPB")) 
        {
                memset(darray, 0, 32 * nspec * sizeof(float)); 
                for(k=0; k<nspec; k++)
                {
                        n = k * 32;
                        darray[7 + n] = this->update_good_uamph;
                        darray[8 + n] = this->update_raw_uamph;
                }
                return DAEstatus::Success;
        }

        for(i=0; i< sizeof(real_array_items) / sizeof(real_array_item); i++)
        {
                if (!strcmp(item_name, real_array_items[i].name))
                {
                        if (real_array_items[i].dim1 == 0)
                        {
                                n = *(real_array_items[i].dim0);
                        }
                        else
                        {
                                n = *(real_array_items[i].dim0) * *(real_array_items[i].dim1);
                        }
                        for(k=0; k<nspec; k++)
                        {
                                for(j=0; j<n; j++)
                                {
                                        darray[j + k * n] = real_array_items[i].pf[j];
                                }
                        }
                        return DAEstatus::Success;
                }
        }
        return DAEstatus::Failure;
}

void ISISCRPT_STRUCT::splitItemName(const std::string& sitem_name, SplitItem& split_item)
{
        int num;
        size_t n = sitem_name.find('_');
        if (n != std::string::npos)
        {
                num = atol(sitem_name.c_str()+n+1);
        }
        else
        {
                num = 0;
        }
        split_item.item = sitem_name.substr(0,n);
        split_item.number = num;
}


int ISISCRPT_STRUCT::getNumSpectra(bool include_spectrum_zero) const
{
        int n = 0;
        for(int i=0; i<ntrg; ++i)
        {
                n += nsp[i];
        }
        if (include_spectrum_zero)
        {
                n += 1;    // only one spectrum zero not per TR at the moment 
        }
        return n;
}

int ISISCRPT_STRUCT::getNumSpectra(int tr, bool include_spectrum_zero) const
{
        int n = 0;
        if (tr >= 1 && tr <= ntrg)
        {
                n = nsp[tr - 1];
        }
        if (include_spectrum_zero && tr == spectrumCRPTTR(0))
        {
                n += 1; // only one spectrum zero not per TR at the moment 
        }
        return n;
}


int ISISCRPT_STRUCT::getHighestSpectrumNumber() const
{
        int n = 0;
        for(int i=0; i<ntrg; ++i)
        {
                n += nsp[i];
        }
        return n;
}


int ISISCRPT_STRUCT::buildTimeRegimeMap()
{
        for(int i=0; i < this->ntrg; ++i)
        {
                for(int j=0; j < this->ntrg; ++j)
                {
                        for(int k=0; k < 1 + this->ntc[j]; ++k)
                        {
                                this->tcb_map[i][j][k] = simpleChannelRebin(k, j+1, i+1);
                        }
                }
        }
        return 0;
}

int ISISCRPT_STRUCT::channelLookup(int from_chan, int from_tr, int to_tr, float tof_val) const
{
        int simp_chan = this->tcb_map[to_tr-1][from_tr-1][from_chan];   // cached result of simpleChannelRebin()
        const float* to_rtcb = this->rtcb[to_tr-1];
        int ntc = this->ntc[to_tr-1];
        int i = simp_chan;
        if (from_chan == 0)
        {
                return 0;
        }
        while(i >= 1 && i < ntc)
        {
                if (to_rtcb[i] <= tof_val)
                {
                        ++i;
                        continue;
                }
                if (to_rtcb[i-1] > tof_val)
                {
                        --i;
                        continue;
                }
                break;
        }
        return i;
}

int ISISCRPT_STRUCT::simpleChannelRebin(int from_chan, int from_tr, int to_tr) const
{
        if (from_chan == 0)
        {
                return 0;
        }
        const float* from_rtcb = this->rtcb[from_tr-1];
        const float* to_rtcb = this->rtcb[to_tr-1];
        // we use bin centre as if the old bin centre lies in the new bin, then the old bin probably had
        // the most overlap with that new bin's boundaries 
        float tof_val = (from_rtcb[from_chan-1] + from_rtcb[from_chan]) / 2.0; // bin centre 
        int ntc = this->ntc[to_tr-1];
        int to_chan = ( std::upper_bound(to_rtcb, to_rtcb + ntc, tof_val) - to_rtcb );
        if ( to_chan == ntc )
        {
                return 0;   // cannot find it on upper end; upper_bound will return 0 if cannot find on lower end
        }
//      int to_chan = 0;
//      for(int i=0; i<m_crpt->ntc[to_tr-1]; ++i)
//      {
//              if ( (to_rtcb[i] <= tof_low) )
//              {
//                      to_chan = i + 1;
//              }
//      }
        return to_chan;
}

int ISISCRPT_STRUCT::randomisedChannelRebin(int from_chan, int from_tr, int to_tr) const
{
        if (from_chan == 0)
        {
                return 0;
        }
        const float* from_rtcb = this->rtcb[from_tr-1];
        const float* to_rtcb = this->rtcb[to_tr-1];
        float ran = (float)rand() / (float)(RAND_MAX+1);
        float tof_val = from_rtcb[from_chan-1] + ran * (from_rtcb[from_chan] - from_rtcb[from_chan-1]); 
        int ntc = this->ntc[to_tr-1];
        int to_chan = channelLookup(from_chan, from_tr, to_tr, tof_val);
//      if ( to_chan != (std::upper_bound(to_rtcb, to_rtcb + ntc, tof_val) - to_rtcb) )
//      {
//              throw std::runtime_error("error");
//      }
        if ( to_chan == ntc )
        {
                return 0;   // cannot find it on upper end; upper_bound will return 0 if cannot find on lower end
        }
        return to_chan;
}

void ISISCRPT_STRUCT::setInstName(const std::string& comp_name)
{
        // strip NDX prefix if present
        if (strncmp(comp_name.c_str(), "NDX", 3) == 0)
        {
                strncpy(inst_name, comp_name.c_str()+3, sizeof(inst_name));
        }
        else
        {
                strncpy(inst_name, comp_name.c_str(), sizeof(inst_name));
        }
        NULL_TERMINATE(inst_name);
        strncpy(inst_abrv, getInstAbrv(inst_name), sizeof(inst_abrv));
        NULL_TERMINATE(inst_abrv);
}