CSCTFEvent.cc

Go to the documentation of this file.

#include "EventFilter/CSCTFRawToDigi/src/CSCTFEvent.h"
#include "EventFilter/CSCTFRawToDigi/src/CSCSPHeader.h"
#include <string.h>
#include <stdexcept>

unsigned int CSCTFEvent::unpack(const unsigned short *buf, unsigned int length) {
    // Clean up
    nRecords = 0;
    bzero(sp,sizeof(sp));

    // Make sure that we are running right platform (can't imagine opposite)
    if( sizeof(unsigned long long)!=8 || sizeof(unsigned short)!=2 )
        throw std::runtime_error(std::string("Wrong platform: sizeof(unsigned long long)!=8 || sizeof(unsigned short)!=2"));

    // Type of coruptions
    unsigned long coruptions=0;

    // Combine 64-bit ddu word for simlicity and efficiency
    unsigned long long *dduWord = (unsigned long long*) buf, word_1=0, word_2=0;
    // 'length' counts ddu words now
    length /= sizeof(unsigned long long)/sizeof(unsigned short);
    // Set of markers
    bool spHeader=false, spTrailer=false;
    unsigned long spWordCount=0, spWordCountExpected=0;

    // Run through the buffer and check its structure
    unsigned int index=0;
    while( index<length ){
        word_1 = word_2;          // delay by 1 DDU word
        word_2 = dduWord[index];  // current DDU word

        if( spHeader && !spTrailer ) spWordCount++;

        if( (word_1&0xF000F000F000F000LL)==0x9000900090009000LL &&
            (word_2&0xF000F000F000F000LL)==0xA000A000A000A000LL ){
            if( spHeader ){
                coruptions |= MISSING_TRAILER;
                break;
            }
            spHeader=true;
            spTrailer=false;
            // number of 64-bit words between header and trailer
            spWordCount=0;
            spWordCountExpected=0;
            // need header to calculate expected word count
            CSCSPHeader header;
            const unsigned short *spWord = (unsigned short*) &dduWord[index-1];
            // we are here because we have a header => we are safe from crash instantiating one
            header.unpack(spWord);

            // Counter block exists only in format version 4.3 and higher
            if( header.format_version() && !header.empty() ){
                if( length > index+1 ){ spWord += 4; } else { coruptions |= OUT_OF_BUFFER; break; }
            }

            // Calculate expected record length (internal variable 'shift' counts 16-bit words)
            for(unsigned short tbin=0,shift=0; tbin<header.nTBINs() && !header.empty(); tbin++){
                // check if didn't pass end of event, keep in mind that 'length', 'index', and 'spWordCountExpected' counts 64-bit words
                if( length <= index+spWordCountExpected+2 ){
                    coruptions |= OUT_OF_BUFFER;
                    break;
                } else {
                    // In the format version >=5.3 with zero_supression
                    if( header.format_version()>=3 && header.suppression() ){
                        //  we seek the loop index untill it matches the current non-empty tbin
                        if( ((spWord[shift+7]>>8) & 0x7) != tbin+1 ) continue;
                        //  otherwise there may be no more non-empty tbins and we ran into the trailer
                        if( (spWord[shift+0]&0xF000)==0xF000 && (spWord[shift+1]&0xF000)==0xF000 && (spWord[shift+2]&0xF000)==0xF000 && (spWord[shift+3]&0xF000)==0xF000 &&
                            (spWord[shift+4]&0xF000)==0xE000 && (spWord[shift+5]&0xF000)==0xE000 && (spWord[shift+6]&0xF000)==0xE000 && (spWord[shift+7]&0xF000)==0xE000 ) break;
                    }

                    // Data Block Header always exists if we got so far
                    spWordCountExpected += 2;
                    // 15 ME data blocks
                    for(unsigned int me_block=0; me_block<15; me_block++)
                        if( header.active()&(1<<(me_block/3)) && (!header.suppression() || spWord[shift+0]&(1<<me_block)) )
                            spWordCountExpected += 1;
                    // 2 MB data blocks
                    for(unsigned int mb_block=0; mb_block<2; mb_block++)
                        if( header.active()&0x20 && (!header.suppression() || spWord[shift+1]&(1<<(mb_block+12))) )
                            spWordCountExpected += 1;
                    // 3 SP data blocks
                    for(unsigned int sp_block=0; sp_block<3; sp_block++)
                        if( header.active()&0x40 && (!header.suppression() || spWord[shift+1]&(0xF<<(sp_block*4))) )
                            spWordCountExpected += 1;

                    shift = spWordCountExpected*4; // multiply by 4 because 'shift' is a 16-bit array index and 'spWordCountExpected' conuts 64-bit words
                }
            }

            // Counter block exists only in format version 4.3 and higher
            if( header.format_version() && !header.empty() ) spWordCountExpected += 1;

            if( coruptions&OUT_OF_BUFFER ) break;
        }

        //if( !spHeader && spTrailer ) coruptions |= NONSENSE; ///???

        if( (word_1&0xF000F000F000F000LL)==0xF000F000F000F000LL &&
            (word_2&0xF000F000F000F000LL)==0xE000E000E000E000LL ){
            if( spTrailer ){
                coruptions |= MISSING_HEADER;
                break;
            }
            spHeader=false;
            spTrailer=true;

            if( spWordCount!=spWordCountExpected+2 ){
                coruptions |= WORD_COUNT;
                break;
            }
            // main unpacking
            const unsigned short *spWord = (unsigned short*) &dduWord[index-spWordCount-1];
            if( nRecords<12 ) {
                if( sp[nRecords++].unpack(spWord) ) coruptions |= NONSENSE;
            } else {
                coruptions |= CONFIGURATION;
                break;
            }
        }

        index++;
    }

    return coruptions;
}