htoftrb3unpacker.cc

Go to the documentation of this file.

//_HADES_CLASS_DESCRIPTION
/////////////////////////////////////////////////////////////
//
//  HTofTrb3Unpacker
//
//  Class for unpacking TRB3 data and filling
//    the Tof Raw category
//
//  Basic subevent decoding and eventual TDC corrections are
//  performed by decode function in the base class
//  see: /base/datasource/htrb3unpacker.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 "htofdetector.h"
#include "htofraw.h"
#include "htofrawsim.h"
#include "htoftrb3lookup.h"
#include "htoftrb3unpacker.h"
#include "tofdef.h"
#include "htrbnetunpacker.h"

#include <iostream>

using namespace std;

ClassImp(HTofTrb3Unpacker)

// JAM: this little switch will enable that we also take single leading edges into account
//#define TOF_USE_LEADING_WITHOUT_TRAILING_EDGES 1

// JAM: this little switch will enable that we also take single trailing edges into account
//#define TOF_USE_TRAILING_WITHOUT_LEADING_EDGES 1

// switch on filtering of tdc messages with first time window as defined below
//#define TOF_USE_TIME_WINDOW 1

// first time window to filter out some unusable hits. units are nanoseconds relative to trigger (channel 0)
#define TOF_TIME_MIN -300.0
#define TOF_TIME_MAX  1500.0
// TODO: optionally put this into some parameter container.
Bool_t HTofTrb3Unpacker::fHasPrintedTDC = kFALSE;

HTofTrb3Unpacker::HTofTrb3Unpacker(vector<UInt_t>& ids) : HTrb3TdcUnpacker(ids),
    fLookup(0), fTimeRef(kTRUE), fTimeShift(0.) {
        // constructor
        pRawCat = NULL;
}

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

    HTofDetector* det = (HTofDetector*) gHades->getSetup()->getDetector("Tof");
    if (!det) {
        Error("init", "No TOF Detector found.");
        return kFALSE;
    }

    if(gHades->getEmbeddingMode()==0) {
        pRawCat=gHades->getSetup()->getDetector("Tof")->buildCategory(catTofRaw);
    } else {
        pRawCat=((HTofDetector*)(gHades->getSetup()->getDetector("Tof")))->buildMatrixCategory("HTofRawSim",0.5F);
    }
    if (!pRawCat) return kFALSE;

    gHades->getCurrentEvent ()->addCategory (catTofRaw, pRawCat, "Tof");

    fLoc.set(3, 0, 0, 0);

    fLookup = (HTofTrb3Lookup*) (gHades->getRuntimeDb()->getContainer("TofTrb3Lookup"));
    if (!fLookup) {
        Error("init", "No Pointer to parameter container TofTrb3Lookup.");
        return kFALSE;
    }

    if (NULL == trbNetUnpacker) {
        if (gHades->getDataSource()) {
            HDataSource* source = gHades->getDataSource();
            if (source->InheritsFrom("HldSource")) {
                trbNetUnpacker =
                        ((HldSource *) gHades->getDataSource())->getTrbNetUnpacker();
            } else {
                Warning("init",
                        "DataSource not inherited from HldSource! trbNetUnpacker == 0 ");
            }
        } else {
            Warning("init",
                    "Could not retrieve DataSource! trbNetUnpacker == 0 ");
        }
    }

    if (!trbNetUnpacker->init()) {
        Error("init()", "Failed to initialize HTrbNetUnpacker!");
        return kFALSE;
    }

    return kTRUE;
}

Bool_t HTofTrb3Unpacker::reinit(void)
{
    // Called in the beginning of each run, used here to initialize TDC unpacker
    // if TDCs processors are not yet created, use parameter to instantiate them
    // if auto register TDC feature is used in setup of unpackers (by setting
    // setMinAddress()+setMaxAddress() manually)

    if (numTDC() == 0 )  // configure the tdcs only the first time we come here (do not if autoregister is used):
    {
        if (fMinAddress == 0 && fMaxAddress == 0)
        {
            // here evaluate which subevents are configured in lookup table:
            Int_t numTDC = fLookup->getSize();
            Int_t offset = fLookup->getArrayOffset() ;
            for (Int_t slot = 0; slot < numTDC; ++slot) {

                Int_t trbnetaddress = offset+slot;

                HTofTrb3LookupBoard* tdc = fLookup->getBoard(trbnetaddress);
                if(tdc){
                    Int_t nChan = tdc->getSize();
                    if (trbnetaddress) {
                        Int_t tindex = addTDC(trbnetaddress,nChan);
                        Info("reinit", "Added TDC 0x%04x with %d channels from HTofTrb3Lookup to map index %d",
                             trbnetaddress, nChan,tindex);
                    }
                }
            }

            // set the expected range for the automatic adding of TDC structures:

            setMinAddress(fLookup->getArrayOffset());
            setMaxAddress(fLookup->getArrayOffset() + fLookup->getSize());
            fUseTDCFromLookup = kTRUE; // do not use auto register if set in
            fHasPrintedTDC = kTRUE;

        } else {
            Info("reinit", "TDCs will be added in auto register mode between min address 0x%04x and max address 0x%04x!",fMinAddress,fMaxAddress);
        }
    }
    // we do not call reinit of superclass, since we do not use tdc calibration parameters in hydra anymore!
    return kTRUE;
}

Int_t HTofTrb3Unpacker::execute(void) {



    if (gHades->isCalibration()) {
        //calibration event
        return 1;
    }

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

    // if there is no data, do not try to analyze it
    // pSubEvt - make sure that there is something for decoding
    if (!pSubEvt)
        return 1;

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

    // decodes the subevent and fill arrays, see: htrb3unpacker.h
    if (!decode()) {
        Error("decode",
                "subsubevent decoding failed!!! Evt Nr : %i SubEvtId: %x", nEvt,
                getSubEvtId());
        return -1;
    }

    // correct for reference time here!
    // we don't check for proper time reference correction
    // to avoid event skipping
    // this must be done better in future but now is a good workaround

    if (fTimeRef) {
        correctRefTimeCh(REFCHAN);
    }

    const Double_t timeUnit=1e9;


    for (UInt_t ntdc = 0; ntdc < numActiveTDC(); ntdc++) {
        HTrb3TdcUnpacker::TDC* tdc = getActiveTDC(ntdc);

        // check the lookup table
        HTofTrb3LookupBoard *board = fLookup->getBoard(tdc->getTrbAddr());
        if (!board) {
            if (debugFlag > 0)
                Warning("execute",
                        "Evt Nr : %i  SubEvId: %x (%i) unpacked but TDC Board 0x%x not in lookup table",
                        nEvt, getSubEvtId(), getSubEvtId(), tdc->getTrbAddr());
            continue;
        }

        // fill the raw category for RPC detector
        for (UInt_t i = 0; i < tdc->numChannels(); i++) {
            if(REFCHAN == i) continue;

            HTrb3TdcUnpacker::ChannelRec& theRecord = tdc->getCh(i);

// ignore channels without rising hits already here
#ifndef TOF_USE_TRAILING_WITHOUT_LEADING_EDGES
            if (theRecord.rising_mult < 1)
                continue;
#endif
            HTofTrb3LookupChan *chan = board->getChannel(i);
            if (chan == 0) {
                Warning("execute", "Missing channel %u in lookup table", i);
                continue;
            }
            chan->getAddress(fLoc[0], fLoc[1], fLoc[2]);

            // if channel not connected in lookup-table, ignore it
            if (fLoc[0] < 0)  { // empty slot default is -1
                continue;
            }
            /*
            // exclude all not defined and broken channels
            if (!chan->isDefinedChannel() || chan->isBrokenChannel())
                continue;
            */

            //if (chan->getSide() == 'n' ) continue; // not connected

#ifdef TOF_USE_TIME_WINDOW
            // later we may get this from parameter container or other setup file. For the moment  fix it
            Double_t tmin = TOF_TIME_MIN;
            Double_t tmax = TOF_TIME_MAX;
#endif
            UInt_t lix = 0;
            for (lix = 0; lix < theRecord.rising_mult; ++lix) {
                Double_t tm0 = theRecord.rising_tm[lix] * timeUnit;
                if (debugFlag > 0)
                    Warning("execute", "JJJJ current hit leading: tm0:%e, apply time shift:%e", tm0, fTimeShift);
                tm0 +=fTimeShift;

#ifdef TOF_USE_TIME_WINDOW
                if ((tm0 < tmin) || (tm0 > tmax)) {
                    if (debugFlag > 0)
                        Warning("execute",
                                "JJJJ Rejecting leading hit outside tmin:%e or tmax:%e",
                                tmin, tmax);
                    continue; // leading edge outside the time window
                }

#endif
                // now look for corresponding trailing edge:
                if (lix < theRecord.falling_mult) {
                    Double_t tm1 = theRecord.falling_tm[lix] * timeUnit;
                    if (debugFlag > 0)
                        Warning("execute", "JJJJ current hit falling: tm1:%e, apply time shift:%e",
                                tm1, fTimeShift);
                    tm1 +=fTimeShift;


#ifdef TOF_USE_TIME_WINDOW
                    if ((tm1 < tmin) || (tm1 > tmax)) {
                        if (debugFlag > 0)
                            Warning("execute",
                                    "JJJJ Rejecting trailing hit outside tmin:%e or tmax:%e",
                                    tmin, tmax);

#ifdef TOF_USE_LEADING_WITHOUT_TRAILING_EDGES
                        tm1=0.0; // still we take incomplete leading edge
#else
                        continue; // skip both leading and trailing
#endif
                    } // if ((tm1 < tmin) || (tm1 > tmax))


#endif
                    //
                    // TODO: optional filter out hits that do not fulfill the time threshold parameter
                    //Double_t tot=tm1-tm0;
                    // however, this can be also done in subsequent calibrator object

/////// ACCEPTED HITS ARE HERE //////////////////////////////////
                    // regular case with leading/trailing edges of ChannelRec in order
                    if (addRawHit(tm0, tm1, chan) != 0)
                        continue; // we will skip this if this channel is not mapped to detector cell

////////// END ACCEPTED HITS/////////////////////////////////////
                } // if lix<theRecord.falling_mul
                else {
#ifdef TOF_USE_LEADING_WITHOUT_TRAILING_EDGES
                    // here we treat hist with only leading edges, no corresponding trailing edge
                    // such hit will deliver tot width of -1
                    if(addRawHit(tm0, 0.0, chan)!=0)
                    continue;
#endif
                }
            } // for lix

////////////// optional now check for single trailing edges?
#ifdef TOF_USE_TRAILING_WITHOUT_LEADING_EDGES

            for (UInt_t tix=lix; tix< theRecord.falling_mult; ++tix)
            {
                Double_t tm1=theRecord.falling_tm[tix] * timeUnit;

#ifdef TOF_USE_TIME_WINDOW
                    if ((tm1 < tmin) || (tm1 > tmax)) {

                        if (debugFlag > 0)
                            Warning("execute",
                                    "JJJJ Rejecting trailing hit outside tmin:%e or tmax:%e",
                                    tmin, tmax);
                        continue;
#endif

                if(addRawHit(0.0, tm1, chan)!=0)
                    continue;
            }
             ////////////////////
#endif
/////////////// end single trailing edges


        } // loop over TDC channels
    } // loop over TDC
    return 1;
}

Int_t HTofTrb3Unpacker::addRawHit(Double_t t_leading, Double_t t_trailing,HTofTrb3LookupChan *chan)
{

    // from here we got access to TDC channel and should map it to RPC channel
    HTofRaw* raw = (HTofRaw*) pRawCat->getObject(fLoc);

    if (!raw) {
        raw = (HTofRaw *) pRawCat->getSlot(fLoc);
        if(gHades->getEmbeddingMode()==0) {
            raw = new (raw) HTofRaw;
        } else{
            raw=new (raw) HTofRawSim;
        }

        if(raw){
            raw->setSector((Char_t)fLoc[0]);
            raw->setModule((Char_t)fLoc[1]);
            raw->setCell((Char_t)fLoc[2]);

        } else {
            if (debugFlag > 0)
                Warning("addRawHit()", "Can't get slot sec=%i, column=%i, cell=%i",
                        fLoc[0], fLoc[1],fLoc[2]);
            return -1;
        }
    }

    Char_t side     = chan->getSide();

    if(side=='r') {
        raw->setRightTime(t_leading);
        raw->setRightCharge(t_trailing - t_leading);
    } else if (side=='l') {
        raw->setLeftTime(t_leading);
        raw->setLeftCharge(t_trailing - t_leading);
    }



    if (debugFlag > 1)
        Warning("addRawHit",
                "ADDING hit for sec:%d column:%d cell:%d tm0:%e tm1:%e",
                fLoc[0], fLoc[1], fLoc[2], t_leading, t_trailing);
    return 0;
}