hpiontrackertrb3unpacker.cc

Go to the documentation of this file.

//_HADES_CLASS_DESCRIPTION
/////////////////////////////////////////////////////////////
//
//  HPionTrackerTrb3Unpacker
//
//  Class for unpacking TRB3 data and filling
//    the PionTracker Raw category
//
/////////////////////////////////////////////////////////////

#include "hpiontrackertrb3unpacker.h"
#include "hades.h"
#include "hcategory.h"
#include "hdebug.h"
#include "hevent.h"
#include "heventheader.h"
#include "hldsource.h"
#include "hldsubevt.h"
#include "hruntimedb.h"
#include "hspectrometer.h"
#include "hpiontrackerdetector.h"
#include "hpiontrackerraw.h"
#include "hpiontrackertrb3lookup.h"
#include "hpiontrackerdef.h"
#include <iostream>

using namespace std;

#define PR(x) std::cout << "++DEBUG: " << #x << " = |" << x << "| (" << __FILE__ << ", " << __LINE__ << ")\n";
#define PRh(x) std::cout << "++DEBUG: " << #x << " = hex |" << std::hex << x << std::dec << "| (" << __FILE__ << ", " << __LINE__ << ")\n";

ClassImp (HPionTrackerTrb3Unpacker)

HPionTrackerTrb3Unpacker::HPionTrackerTrb3Unpacker (UInt_t id)
{
        // constructor
        subEvtId       = id;
        uTrbNetAddress = 0;
        nEvt = 0;

        debugFlag      = 0;
        quietMode      = kFALSE;
        reportCritical = kFALSE;

        pRawCat = NULL;
        pLookup = NULL;
        pTrbBoard = NULL;
}

Bool_t HPionTrackerTrb3Unpacker::init (void)
{
        // creates the raw category and gets the pointer to the TRB3 lookup table

        HPionTrackerDetector * det = (HPionTrackerDetector *) gHades->getSetup()->getDetector ("PionTracker");

        if (!det)
        {
                Error ("init", "No PionTracker found.");
                return kFALSE;
        }

        pRawCat = det->buildCategory (catPionTrackerRaw);
        loc.set (2, 0, 0);
//      loc.set (1, 0);

        pLookup = (HPionTrackerTrb3Lookup *) (gHades->getRuntimeDb()->getContainer ("PionTrackerTrb3Lookup"));

        if (!pLookup)
        {
                Error ("init", "No Pointer to parameter container PionTrackerTrb3Lookup.");
                return kFALSE;
        }

        return kTRUE;
}

Int_t HPionTrackerTrb3Unpacker::execute (void)
{
        // decodes the subevent of the PionTracker and fills the Raw category
        if (gHades->isCalibration())
        {
                //calibration event
                return 1;
        }

        if (gHades->getCurrentEvent()->getHeader()->getId() == 0xe)
        {
                //scaler event
                return 1;
        }

        nEvt = gHades->getCurrentEvent()->getHeader()->getEventSeqNumber(); // Evt Seq. Nb.

        if (NULL == pSubEvt)
        {
#if DEBUG_LEVEL > 0
                Warning ("execute", "EvtId: 0x%x, Unpacker 0x%x ==> no data",
                                 gHades->getCurrentEvent()->getHeader()->getId(), subEvtId);
#endif
                return 1;
        }

        // decode subevent data

// pSubEvt - make sure that there is something for decoding
        if (!pSubEvt)
                return 1;

        UInt_t * databeg = pSubEvt->getData();
        UInt_t * dataend  = pSubEvt->getEnd();

        nEvt = gHades->getCurrentEvent()->getHeader()->getEventSeqNumber();

        size_t data_size = dataend - databeg;

        if (data_size == 0)     return 0;

        size_t datanum = 0;
        size_t datacnt = 0;

        ptstate sm = sm_wait_for_board;

        ptheaderset pths;// = { des_none, -1, -1, -1, -1, -1 };
        ptdataset ptds;// = { -1, -1, -1, -1, -1 };

        for (size_t cnt = 0; cnt < data_size; ++cnt)
        {
                UInt_t d = * (databeg + cnt);

                switch (sm)
                {
                        case sm_wait_for_board:
                                datanum = (d >> 16) & 0xFFFF;   // No. of the data words from one TRB board
                                uTrbNetAddress = d & 0xFFFF;     // TRB net Adddress (Old TRB subevent id)
// PRh(uTrbNetAddress);
                                if (datanum == 0)
                                {
                                        continue;
                                }

                                datacnt = 0;

                                // which module
                                if (uTrbNetAddress == 0x5555)
                                {
                                        cnt += datanum;
                                        continue;
                                }

                                pTrbBoard = pLookup->getBoard (uTrbNetAddress);

                                if (!pTrbBoard)
                                {
                                        Warning ("HPionTrackerTrb3Unpacker::execute",
                                                         "Evt Nr : %i  TrbNetAdress: %x (%i) unpacked but TRB Board not in lookup table",
                                                         nEvt, uTrbNetAddress, uTrbNetAddress);
                                        // skip proper number of words and continue iwth next board
                                        cnt += datanum;
                                        continue;
                                }

                                // next step is sub-sub-event header
                                sm = sm_header;

                                break;

                        // decode sub-sub-event header
                        case sm_header:
                                pths = decodeSubevent(d);
                                ++datacnt;
                                sm = sm_data;

                                break;

                                // decode sub-sub-event data
                        case sm_data:
                        {
                                ++datacnt;

                                if (d == 0xffffffff)
                                {
                                        if (datacnt != datanum)
                                        {
                                                Error ("execute()", "Event %d --> datanum and datacnt differs. datanum=%lu, datacnt=%lu", nEvt, datanum, datacnt);
                                        }

                                        sm = sm_wait_for_board;

                                        break;
                                }
                                else
                                {
                                        switch (pths.design)
                                        {
                                                case des_cosy13:
                                                        ptds = decodeData_Cosy13(d, pths);
                                                        break;
                                                case des_140115:
                                                        ptds = decodeData_140115(d, pths);
                                                        break;
                                                default:
                                                        continue;
                                        }
                                        fillRaw (ptds);
                                }
                        }
                        break;

                        default:
                                datacnt = 0;
                                sm = sm_wait_for_board;
                                break;
                }
        }

        // decode subsubevent data of this TRB
        // .....
        // call function fillRaw to store the data of a channel
        // .....

        return 1;
}


ptheaderset HPionTrackerTrb3Unpacker::decodeSubevent(UInt_t h)
{
        ptheaderset pths;

        bool olddesign = ((h >> 30) & 0x03) == 0x00;
        if (olddesign)
        {
                pths.design = des_cosy13;

                pths.tsref = h & 0xfff;
                pths.evcnt = (h >> 12) & 0x3ff;
                pths.romode = (h >> 22) & 0x3;
                pths.version = 0;
                pths.boardid = (h >> 24) & 0xff;
        }
        else
        {
                pths.design = des_140115;

                pths.tsref = h & 0xfff;
                pths.evcnt = (h >> 12) & 0x3ff;
                pths.romode = (h >> 22) & 0x3;
                pths.version = (h >> 26) & 0xf;
                pths.boardid = (h >> 30) & 0x3;
        }

        return pths;
}

ptdataset HPionTrackerTrb3Unpacker::decodeData_Cosy13(UInt_t d, const ptheaderset & pths)
{
        ptdataset ptds;
        ptds.ts = (d >> 0) & 0xfff;
        ptds.adc = (d >> 12) & 0xfff;
        ptds.strip = (d >> 24) & 0x7f;
        ptds.pileup = (d >> 31) & 0x01;
        ptds.overflow = 0;

        return ptds;
}

ptdataset HPionTrackerTrb3Unpacker::decodeData_140115(UInt_t d, const ptheaderset& hs)
{
        ptdataset ptds;//PR(hs.romode);
        switch (hs.romode)
        {
                case 0x00:
                        ptds.ts = d & 0x7ff;
                        ptds.adc = (d >> 11) & 0xfff;
                        ptds.overflow = (d >> 23) & 0x01;
                        ptds.pileup = (d >> 24) & 0x01;
                        ptds.strip = (d >> 25) & 0x7f;
                        break;
                case 0x01:
                        ptds.ts = d & 0xfff;
                        ptds.adc = (d >> 11) & 0xffe; // adc[11:1]
                        ptds.overflow = (d >> 23) & 0x01;
                        ptds.pileup = (d >> 24) & 0x01;
                        ptds.strip = (d >> 25) & 0x7f;
                        break;
                case 0x02:
                        ptds.ts = d & 0x3fff;
                        ptds.adc = (d >> 11) & 0xff8; // adc[11:1]
                        ptds.overflow = (d >> 23) & 0x01;
                        ptds.pileup = (d >> 24) & 0x01;
                        ptds.strip = (d >> 25) & 0x7f;
                        break;
                case 0x03:
                        ptds.ts = d & 0x3fff;
                        ptds.adc = (d >> 13) & 0xffe; // adc[11:1]
                        ptds.overflow = -1;
                        ptds.pileup = -1;
                        ptds.strip = (d >> 25) & 0x7f;
                        break;
                default:
                        ptds.ts = -1;
                        ptds.adc = -1;
                        ptds.overflow = -1;
                        ptds.pileup = -1;
                        ptds.strip = 0;
                        break;
        }

        return ptds;
}

Bool_t HPionTrackerTrb3Unpacker::fillRaw(const ptdataset& ptds)
{
        return fillRaw(ptds.strip, ptds.ts, ptds.adc, ptds.pileup, ptds.overflow);
}


Bool_t HPionTrackerTrb3Unpacker::fillRaw (Int_t channel, Float_t time, Float_t charge, Char_t pileup, Char_t overflow)
{
        // fill the raw category of the PionTracker for the channel "

        if (pTrbBoard)
        {
                HPionTrackerTrb3LookupChan * ch = pTrbBoard->getChannel (channel);
                ch->getAddress (loc[0], loc[1]);

                if (loc[0] >= 0)
                {
                        HPionTrackerRaw * pRaw = (HPionTrackerRaw *) pRawCat->getObject (loc);

                        if (!pRaw)
                        {
                                pRaw = (HPionTrackerRaw *) pRawCat->getSlot (loc);

//                                                      PRh(pRaw);
//                      if (pRaw) delete pRaw;
// PR(pRaw);
                                if (pRaw)
                                {
//                                      printf("=== new pRaw\n");
                                        pRaw = new (pRaw) HPionTrackerRaw;
                                        pRaw->setAddress (loc[0], loc[1]);
                                }
                                else
                                {
                                        Warning ("HPionTrackerTrb3Unpacker::execute()",
                                                         "Can't get slot mod=%i, chan=%i", loc[0], loc[1]);
                                        return kFALSE;
                                }
                                
                        }
//                      printf("+ pRaw: %x at %x\n", pRaw, &pRaw);

                        pRaw->setData (time, charge, pileup, overflow);
                }
                else
                {
                        Warning ("HPionTrackerTrb3Unpacker::execute()",
                                         "Not found in lookup table: TrbNetAddress=%i, channel=%i", uTrbNetAddress, channel);
                }
        }

        return kTRUE;
}