X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;ds=sidebyside;f=TRD%2FAliTRDrawStream.h;h=515a3b94c5555d2070d222c1421a9fc173c72e28;hb=8f7b1226e6156cef90cac09edaf8b085c8e6f503;hp=825708b44976391791a0adacf074b9cd04385612;hpb=b48576ab83f2092cca5e4c044560768d7a56c551;p=u%2Fmrichter%2FAliRoot.git diff --git a/TRD/AliTRDrawStream.h b/TRD/AliTRDrawStream.h index 825708b4497..515a3b94c55 100644 --- a/TRD/AliTRDrawStream.h +++ b/TRD/AliTRDrawStream.h @@ -1,702 +1,210 @@ -#ifndef ALITRDRAWSTREAM_H -#define ALITRDRAWSTREAM_H - -/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * - * See cxx source for full Copyright notice */ - -/* $Id: AliTRDrawStream.h 27696 2008-07-31 09:18:53Z cblume $ */ - -/////////////////////////////////////////////////////////////////////////////// -// // -// This class provides access to TRD digits in raw data. // -// // -/////////////////////////////////////////////////////////////////////////////// - -#include "AliTRDrawStreamBase.h" - -class AliTRDgeometry; -class AliRawReader; -class AliTRDdigitsManager; -class TTreeSRedirector; -class AliTRDfeeParam; - - -class AliTRDrawStream : public AliTRDrawStreamBase -{ // class def begin - - public: - - //-------------------------------------------------------- - // THE STRUCTURES - //-------------------------------------------------------- - - struct AliTRDrawADC - {//adc struct - - UInt_t *fPos; //! position of ADC 1st word in the buffer - Short_t fADCnumber; // number of the ADC 0 .. 20 - Short_t fExtendedCOL; // column - row from MCM - Short_t fCOL; // column - row from MCM - Int_t fSignals[TRDMAXTBINS]; // signals for this adc - Bool_t fIsShared; // is pad chared between MCMs - Short_t fCorrupted; // is adc word corrupted - - AliTRDrawADC() - : fPos(0) - , fADCnumber(0) - , fExtendedCOL(0) - , fCOL(0) - , fSignals() - , fIsShared(kFALSE) - , fCorrupted(0) - { - // default constructor - }; - - AliTRDrawADC(const AliTRDrawADC& p): - fPos(p.fPos) - , fADCnumber(p.fADCnumber) - , fExtendedCOL(p.fExtendedCOL) - , fCOL(p.fCOL) - , fSignals() - , fIsShared(p.fIsShared) - , fCorrupted(p.fCorrupted) - { - // copy constructor - }; - - AliTRDrawADC &operator=(const AliTRDrawADC &) - { - // assignment operator - // not implemented - return *this; - }; - - }; - - //-------------------------------------------------------- - - struct AliTRDrawMCM - { // mcm struct - Int_t fROB; // ROB number - Int_t fMCM; // MCM number - Int_t fROW; // row number filed during decoding - - UInt_t fEvCounter; // MCM event counter - UInt_t fADCMask; // ADC mask - UInt_t fADCMaskWord; // word with ADC mask in - UInt_t fADCchannel[TRDMAXADC]; // channels to be decoded accrording to ADC mask - - Int_t fADCmax; // number of ADCs fired - Int_t fADCcount; // number of ADCs fired from double checking bit - Int_t fMCMADCWords; // mcm words to expect - Int_t fSingleADCwords; // n of words per ADC - - Int_t fMCMhdCorrupted; // is mcm header corrupted - Int_t fADCmaskCorrupted; // is mcm adc mask corrupted - Int_t fCorrupted; // is mcm data missing - - UInt_t *fPos; //! position of mcm header in the buffer - UInt_t *fAdcDataPos; //! start of ADC data for this mcm - - Int_t fADCcounter; // count the adcs decoded - AliTRDrawADC fADCs[TRDMAXADC]; // 21 adcs - - AliTRDrawMCM() - : fROB(-1) - , fMCM(-1) - , fROW(-1) - , fEvCounter(0) - , fADCMask(0) - , fADCMaskWord(0) - , fADCchannel() - , fADCmax(0) - , fADCcount(0) - , fMCMADCWords(0) - , fSingleADCwords(0) - , fMCMhdCorrupted(0) - , fADCmaskCorrupted(0) - , fCorrupted(0) - , fPos(0) - , fAdcDataPos(0) - , fADCcounter(0) - , fADCs() - { - // default constructor - }; - - AliTRDrawMCM(const AliTRDrawMCM & p): - fROB(p.fROB) - , fMCM(p.fMCM) - , fROW(p.fROW) - , fEvCounter(p.fEvCounter) - , fADCMask(p.fADCMask) - , fADCMaskWord(p.fADCMaskWord) - , fADCchannel() - , fADCmax(p.fADCmax) - , fADCcount(p.fADCcount) - , fMCMADCWords(p.fMCMADCWords) - , fSingleADCwords(p.fSingleADCwords) - , fMCMhdCorrupted(p.fMCMhdCorrupted) - , fADCmaskCorrupted(p.fADCmaskCorrupted) - , fCorrupted(p.fCorrupted) - , fPos(p.fPos) - , fAdcDataPos(p.fAdcDataPos) - , fADCcounter(p.fADCcounter) - , fADCs() - { - // copy constructor - }; - - AliTRDrawMCM &operator=(const AliTRDrawMCM &) - { - // assignment operator - // not implemented - return *this; - }; - - }; - - //-------------------------------------------------------- - - struct AliTRDrawHC - { // hc struct - - //tacklet words of given HC - UInt_t fTrackletWords[MAXTRACKLETSPERHC]; // array to keep tracklet words [mj] - Short_t fTrackletError; // tracklet error - Short_t fNTracklets; // number of tracklet - - // header word 0 - Int_t fSpecialRawV; // Raw data version - Int_t fRawVMajor; // Raw data version - Int_t fRawVMajorOpt; // Raw data version - Int_t fRawVMinor; // Raw data version - Int_t fNExtraWords; // N extra HC header words - Int_t fDCSboard; // DCS board number - Int_t fSM; // Super Module number - Int_t fStack; // Stack number (some people might call it a chamber) - Int_t fLayer; // Layer number (some people might call it a plane) - Int_t fSide; // Side of HC - - // header word 1 - Int_t fTimeBins; // N of t bins - UInt_t fBunchCrossCounter; // Bunch crossing counter - UInt_t fPreTriggerCounter; // Pre Trigger counter - UInt_t fPreTriggerPhase; // Pre Trigger phase - - // error - Int_t fH0Corrupted; // is hc header 0 corrupted - Int_t fH1Corrupted; // is hc header 1 corrupted - Int_t fCorrupted; // is hc data corrupted - - UInt_t *fPos[2]; //! position of the header words in buffer - - Int_t fDET; // filled while decoding - Int_t fROC; // filled while decoding - Int_t fRowMax; // filled while decoding - Int_t fColMax; // filled while decoding - - // hc data - Int_t fMCMmax; // number of mcm found - AliTRDrawMCM fMCMs[TRDMAXMCM]; // 4 ROBS 16 each - - AliTRDrawHC() - : fTrackletWords() //[mj] - , fTrackletError(0) - , fNTracklets(0) - , fSpecialRawV(0) - , fRawVMajor(0) - , fRawVMajorOpt(0) - , fRawVMinor(0) - , fNExtraWords(0) - , fDCSboard(-1) - , fSM(-1) - , fStack(-1) - , fLayer(-1) - , fSide(-1) - , fTimeBins(0) - , fBunchCrossCounter(0) - , fPreTriggerCounter(0) - , fPreTriggerPhase(0) - , fH0Corrupted(0) - , fH1Corrupted(0) - , fCorrupted(0) - , fPos() - , fDET(-1) - , fROC(-1) - , fRowMax(-1) - , fColMax(-1) - , fMCMmax(0) - , fMCMs() - { - // default constructor hc info - }; - - AliTRDrawHC(const AliTRDrawHC & p): - fTrackletWords() //[mj] - , fTrackletError(p.fTrackletError) - , fNTracklets(p.fNTracklets) - , fSpecialRawV(p.fSpecialRawV) - , fRawVMajor(p.fRawVMajor) - , fRawVMajorOpt(p.fRawVMajorOpt) - , fRawVMinor(p.fRawVMinor) - , fNExtraWords(p.fNExtraWords) - , fDCSboard(p.fDCSboard) - , fSM(p.fSM) - , fStack(p.fStack) - , fLayer(p.fLayer) - , fSide(p.fSide) - , fTimeBins(p.fTimeBins) - , fBunchCrossCounter(p.fBunchCrossCounter) - , fPreTriggerCounter(p.fPreTriggerCounter) - , fPreTriggerPhase(p.fPreTriggerPhase) - , fH0Corrupted(p.fH0Corrupted) - , fH1Corrupted(p.fH1Corrupted) - , fCorrupted(p.fCorrupted) - , fPos() - , fDET(p.fDET) - , fROC(p.fROC) - , fRowMax(p.fRowMax) - , fColMax(p.fColMax) - , fMCMmax(p.fMCMmax) - , fMCMs() - { - // copy constructor - }; - - AliTRDrawHC &operator=(const AliTRDrawHC &) - { - // assignment operator - // not implemented - return *this; - }; - - }; - - //-------------------------------------------------------- - - struct AliTRDrawStack - { - UInt_t fHeaderSize; // header size of the stack info - Bool_t fLinksActive[12]; // data links active - 1 per half chamber - Short_t fLinksDataType[12]; // 0 indicating real data for the front-end electronics - Short_t fLinksMonitor[12]; // 0 indicating properly operating link - Short_t fLinkMonitorError[12]; // record link monitor error - Int_t fActiveLinks; // number of active links - UInt_t *fPos; //! position in the buffer - - AliTRDrawHC fHalfChambers[12]; // 12 half chambers in a stack - - AliTRDrawStack() - : fHeaderSize(0) - , fLinksActive() - , fLinksDataType() - , fLinksMonitor() - , fLinkMonitorError() - , fActiveLinks(0) - , fPos(0) - , fHalfChambers() - { - // default constructor - }; - - AliTRDrawStack(const AliTRDrawStack & p): - fHeaderSize(p.fHeaderSize) - , fLinksActive() - , fLinksDataType() - , fLinksMonitor() - , fLinkMonitorError() - , fActiveLinks(p.fActiveLinks) - , fPos(p.fPos) - , fHalfChambers() - { - // copy constructor - }; - - AliTRDrawStack &operator=(const AliTRDrawStack &) - { - // assignment operator - // not implemented - return *this; - }; - - }; - - //-------------------------------------------------------- - - struct AliTRDrawSM - { - UInt_t fHeaderSize; // size of the header in words - Bool_t fTrackletEnable; // tracklet enable bit - Bool_t fStackActive[5]; // map of active/expected stacks - Int_t fActiveStacks; // number of active stacks - Int_t fCorrupted; // is sm info corrupted - Int_t fNexpectedHalfChambers; // number of half chambers to be read out in this sm - Bool_t fClean; // true if everything went OK - false is some error occured - UInt_t *fPos; // location of the sm info - should be the first word (after CDH if not DDL buffer) - - AliTRDrawStack fStacks[5]; // objects for 5 stacks - - AliTRDrawSM() - : fHeaderSize(0) - , fTrackletEnable(0) - , fStackActive() - , fActiveStacks(0) - , fCorrupted(0) - , fNexpectedHalfChambers(0) - , fClean(kTRUE) - , fPos(0) - , fStacks() - { - // Default constructor - }; - - AliTRDrawSM(const AliTRDrawSM & p): - fHeaderSize(p.fHeaderSize) - , fTrackletEnable(p.fTrackletEnable) - , fStackActive() - , fActiveStacks(p.fActiveStacks) - , fCorrupted(p.fCorrupted) - , fNexpectedHalfChambers(p.fNexpectedHalfChambers) - , fClean(p.fClean) - , fPos(p.fPos) - , fStacks() - { - // copy constructor - }; - - AliTRDrawSM &operator=(const AliTRDrawSM &) - { - // assignment operator - // not implemented - return *this; - }; - - }; - - //-------------------------------------------------------- - - AliTRDrawStream(); - AliTRDrawStream(AliRawReader *rawReader); - virtual ~AliTRDrawStream(); - - //-------------------------------------------------------- - - virtual Bool_t Next(); // read the next data in the memory - //virtual Int_t NextChamber(AliTRDdigitsManager *man); // read next chamber data in the momory - virtual Int_t NextChamber(AliTRDdigitsManager *man, UInt_t **trackletContainer, UShort_t **/*errorCodeContainer*/=NULL); // read next chamber data in the memory - virtual Bool_t Init(); // initialize some internal variables - - Int_t NextBuffer(); // go and init next buffer if available - check the implementation file for return values - - Bool_t SetRawVersion(Int_t fraw); // set the raw version - used for backward compat. - - Bool_t IsCurrentPadShared() const {return fADC->fIsShared;} // is current pad shared between mcms - void SetSharedPadReadout(Bool_t fv) {fSharedPadsOn = fv;} // set the flag on if the reader should return the shared pads - - Bool_t DecodeSM(void *buffer, UInt_t length); // decode a buffer - Int_t DecodeSM(); // used with raw reader - Int_t DecodeSM(AliRawReader *reader); // used with raw reader - - Bool_t SetReader(AliRawReader *reader); // set the raw reader to use - - // info from Supermodule Index Word - Bool_t IsTrackletEnableBitSet() const {return fSM.fTrackletEnable;} // get status of tracklet enable bit - Bool_t IsStackActive(Int_t is) const {return fSM.fStackActive[is];} // get status of stack enable bit - Int_t GetNofActiveStacks() const {return fSM.fActiveStacks;} // get number of active stacks from stack mask - UInt_t *GetGTUheaderWords() const {return fSM.fPos;} // get number of active stacks from stack mask - - // info from Stack Index Word - Int_t GetNexpectedHalfChambers() const {return fSM.fNexpectedHalfChambers;} // get number of expected HC in a sm - Int_t GetNofActiveLinksInStack(Int_t is) const {return fSM.fStacks[is].fActiveLinks;} // get number of active links in a stack - Bool_t IsLinkActiveInStack(Int_t is, Int_t il) const {return fSM.fStacks[is].fLinksActive[il];} // check whether the link is active - - // info from Stack Header Word - Short_t GetLinkMonitorError(Int_t is, Int_t il) const {return fSM.fStacks[is].fLinkMonitorError[il];} // get link monitor error - - // info from Tracklet Data - Int_t GetTrackletErrorCode(Int_t is, Int_t il) const {return fSM.fStacks[is].fHalfChambers[il].fTrackletError;} - Int_t GetNTracklets(Int_t is, Int_t il) const {return fSM.fStacks[is].fHalfChambers[il].fNTracklets;} // get number of tracklets - - // info from HC Header Word - Int_t GetSM(Int_t is, Int_t il) const {return fSM.fStacks[is].fHalfChambers[il].fSM;} - Int_t GetLayer(Int_t is, Int_t il) const {return fSM.fStacks[is].fHalfChambers[il].fLayer;} - Int_t GetStack(Int_t is, Int_t il) const {return fSM.fStacks[is].fHalfChambers[il].fStack;} - Int_t GetSide(Int_t is, Int_t il) const {return fSM.fStacks[is].fHalfChambers[il].fSide;} - Int_t GetH0ErrorCode(Int_t is, Int_t il) const {return fSM.fStacks[is].fHalfChambers[il].fH0Corrupted;} - Int_t GetH1ErrorCode(Int_t is, Int_t il) const {return fSM.fStacks[is].fHalfChambers[il].fH1Corrupted;} - Int_t GetNumberOfTimeBins(Int_t is, Int_t il) const { return fSM.fStacks[is].fHalfChambers[il].fTimeBins;} - UInt_t *GetTrackletWords(Int_t is, Int_t il) { return fSM.fStacks[is].fHalfChambers[il].fTrackletWords;} - - // info from HC data - Int_t GetHCErrorCode(Int_t is, Int_t il) const {return fSM.fStacks[is].fHalfChambers[il].fCorrupted;} - Int_t GetHCMCMmax(Int_t is, Int_t il) const {return fSM.fStacks[is].fHalfChambers[il].fMCMmax;} - - // from MCM Header Word - // rob and mcm ordering - // side 0(even link) - ROB: 0 2 4 6 MCM: 12 13 14 15 8 9 10 11 4 5 6 7 0 1 2 3 - // side 1( odd link) - ROB: 1 3 5 7 MCM: 12 13 14 15 8 9 10 11 4 5 6 7 0 1 2 3 - Int_t GetMCM(Int_t stack, Int_t link, Int_t mcm) const {return fSM.fStacks[stack].fHalfChambers[link].fMCMs[mcm].fMCM;} - Int_t GetROB(Int_t stack, Int_t link, Int_t mcm) const {return fSM.fStacks[stack].fHalfChambers[link].fMCMs[mcm].fROB;} - Int_t GetMCMhdErrorCode(Int_t stack, Int_t link, Int_t mcm) const {return fSM.fStacks[stack].fHalfChambers[link].fMCMs[mcm].fMCMhdCorrupted;} - Int_t GetMCMADCMaskErrorCode(Int_t stack, Int_t link, Int_t mcm) const {return fSM.fStacks[stack].fHalfChambers[link].fMCMs[mcm].fADCmaskCorrupted;} - Int_t GetEventNumber(Int_t stack, Int_t link, Int_t mcm) const {return fSM.fStacks[stack].fHalfChambers[link].fMCMs[mcm].fEvCounter;} - Int_t GetADCcount(Int_t stack, Int_t link, Int_t mcm) const {return fSM.fStacks[stack].fHalfChambers[link].fMCMs[mcm].fADCcount;} - - // info from MCM data words - Int_t GetMCMErrorCode(Int_t stack, Int_t link, Int_t mcm) const {return fSM.fStacks[stack].fHalfChambers[link].fMCMs[mcm].fCorrupted;} // get MCM data error code - Int_t GetADCErrorCode(Int_t stack, Int_t link, Int_t mcm, Int_t adc) const {return fSM.fStacks[stack].fHalfChambers[link].fMCMs[mcm].fADCs[adc].fCorrupted;} // get ADC error code - Int_t GetADCnumber(Int_t stack, Int_t link, Int_t mcm, Int_t adc) const {return fSM.fStacks[stack].fHalfChambers[link].fMCMs[mcm].fADCs[adc].fADCnumber;} // get ADC error code - - Int_t GetRow(Int_t stack, Int_t link, Int_t mcm) const {return fSM.fStacks[stack].fHalfChambers[link].fMCMs[mcm].fROW;} // get current row number - Int_t GetCol(Int_t stack, Int_t link, Int_t mcm, Int_t adc) const {return fSM.fStacks[stack].fHalfChambers[link].fMCMs[mcm].fADCs[adc].fCOL;} // get current column number - Int_t GetExtendedCol(Int_t stack, Int_t link, Int_t mcm, Int_t adc) const {return fSM.fStacks[stack].fHalfChambers[link].fMCMs[mcm].fADCs[adc].fExtendedCOL;} // get current column number - - // info from ADC data words - Int_t *GetSignalDirect(Int_t stack, Int_t link, Int_t mcm, Int_t adc) {return fSM.fStacks[stack].fHalfChambers[link].fMCMs[mcm].fADCs[adc].fSignals;} - - - // from here, only works with returning ADC channel pointer using Next() - UInt_t *GetTrackletWords() const { return fHC->fTrackletWords;} // return tracklet words pointer per hc [mj] - Int_t GetTrackletErrorCode() const {return fHC ? fHC->fTrackletError : -1;} // get tracklet error code - Int_t GetNTracklets() const {return fHC ? fHC->fNTracklets : -1;} // get number of tracklets - - Int_t GetSpecialRawVersion() const {return fHC ? fHC->fSpecialRawV : -1;} // return special raw version - Int_t GetMajorRawVersion() const {return fHC ? fHC->fRawVMajor : -1;} // major raw version getter - Int_t GetRawVersion() const {return fHC ? fHC->fRawVMajor : -1;} // compatibility see funtion above - Int_t GetMinorRawVersion() const {return fHC ? fHC->fRawVMinor : -1;} // minor raw version - - Int_t GetSM() const {return fHC ? fHC->fSM : -1;} // SM Position of CURRENT half chamber in full TRD - Int_t GetLayer() const {return fHC ? fHC->fLayer : -1;} // Layer Position of CURRENT half chamber in full TRD - Int_t GetStack() const {return fHC ? fHC->fStack : -1;} // Stack Position of CURRENT half chamber in full TRD - Int_t GetSide() const {return fHC ? fHC->fSide : -1;} // get side - Int_t GetDCS() const { return fHC ? fHC->fDCSboard : -1;} // DCS board number read from data (HC header) - Int_t GetROC() const { return fHC ? fHC->fROC : -1;} // ROB Position of CURRENT half chamber in full TRD - Int_t GetNumberOfTimeBins() const { return fHC ? fHC->fTimeBins : 0;} // Get Ntime bins - UInt_t GetBunchCrossCounter() const {return fHC ? fHC->fBunchCrossCounter : 0;} // get bunch cross counter - UInt_t GetPreTriggerCounter() const {return fHC ? fHC->fPreTriggerCounter : 0;} // get pre trigger info - UInt_t GetPreTriggerPhase() const {return fHC ? fHC->fPreTriggerPhase : 0;} // get trigger phase - - Int_t GetRow() const {return fMCM ? fMCM->fROW : -1;} // get current row number - Int_t GetExtendedCol() const {return fADC ? fADC->fExtendedCOL : -1;} // get current column number - Int_t GetCol() const {return fADC ? fADC->fCOL : -1;} // get current column number - Int_t GetRowMax() const { return fHC ? fHC->fRowMax : -1;} // Get maximum rows in the current HC - Int_t GetColMax() const { return fHC ? fHC->fColMax : -1;} // Get maximum cols in the current HC - // compatibility - Int_t GetMaxRow() const { return fHC ? fHC->fRowMax : -1;} // Get maximum rows in the current HC - Int_t GetMaxCol() const { return fHC ? fHC->fColMax : -1;} // Get maximum cols in the current HC - - UInt_t GetHCword0() const {return fHC ? *fHC->fPos[0] : 0;} // get the HC word 0 - UInt_t GetHCword1() const {return fHC ? *fHC->fPos[1] : 0;} // get the HC word 1 - - Int_t GetDET() const {return fHC ? fHC->fDET : -1;} // get current det number - Int_t GetDet() const {return fHC ? fHC->fDET : -1;} // get current det number - - Int_t GetROB() const {return fMCM ? fMCM->fROB : -1;} // get current ROB number - Int_t GetMCM() const {return fMCM ? fMCM->fMCM : -1;} // get current MCM number - Int_t GetEventNumber() const { return fMCM->fEvCounter;} // MCM Event number and position of current MCM on TRD chamber - - Int_t GetADC() const { return fADC ? fADC->fADCnumber : -1;} // MCM ADC channel and Time Bin of word 1 - Int_t GetTimeBin() const { return 0;} // MCM ADC channel and Time Bin of word 1 - Int_t *GetSignals() const { return fADC ? fADC->fSignals : (Int_t *)fgEmptySignals;} // signals in the n-time bins from data word - - Int_t GetHCErrorCode() const {return fHC ? fHC->fCorrupted : -1;} // get HC error code - Int_t GetH0ErrorCode() const {return fHC ? fHC->fH0Corrupted : -1;} // get HC header word0 error code - Int_t GetH1ErrorCode() const {return fHC ? fHC->fH1Corrupted : -1;} // get HC header word1 error code - Int_t GetMCMErrorCode() const {return fMCM ? fMCM->fCorrupted : -1;} // get MCM data error code - Int_t GetADCErrorCode() const {return fADC ? fADC->fCorrupted : -1;} // get ADC data error code - Int_t GetMCMhdErrorCode() const {return fMCM ? fMCM->fMCMhdCorrupted: -1;} // get MCM header word error code - Int_t GetMCMADCMaskErrorCode() const {return fMCM ? fMCM->fADCmaskCorrupted: -1;} // get MCM adc mask error code - - UInt_t *GetSMstreamPosition() const {return fSM.fPos;} // get position of the SM index word in the buffer - - Bool_t IsSMbufferClean() const {return fSM.fClean;} // is data clean - - //---------------------------------------------------------- - - static void SetNoDebug() {fgDebugFlag = kFALSE;} // allow debug info - static void EnableMemoryReset() {fgEnableMemoryReset = kTRUE;} // allow memory reset - static void SetNoErrorWarning() {fgWarnError = kFALSE;} // disable warning and error info - static void SetForceCleanDataOnly() {fgCleanDataOnly = kTRUE;} // clean data only - static void AllowCorruptedData() {fgCleanDataOnly = kFALSE;} // accept corrupted data - - static void SetExtraWordsFix() {fgExtraSkip = kTRUE;} // extra skip of 24 32-bit words - static void SetSkipCDH() {fgSkipCDH = kTRUE;} // skip of 8 32-bit words - static void SetDumpHead(Int_t iv) {fgDumpHead = iv;} - static void DisableStackNumberChecker() {fgStackNumberChecker = kFALSE;} // set false to cleanroom data - static void DisableStackLinkNumberChecker() {fgStackLinkNumberChecker = kFALSE;} - static void DisableSkipData() {fgSkipData = kFALSE;} // keep reading next words even previous words were corrupted - debugging purpose - static void SetDumpingEnable() {fgDumpingEnable = kTRUE;} - static void SetDumpingMCM(Int_t sm, Int_t stack, Int_t layer, Int_t rob, Int_t mcm) {fgDumpingSM = sm; fgDumpingStack = stack; fgDumpingLayer = layer; fgDumpingROB = rob; fgDumpingMCM = mcm;} - - // this is a temporary solution! - // baseline should come with the HC header word 2 (count from 0!) - - static void EnableDecodeConfigData() {fgEnableDecodeConfigData = kTRUE;} // allow configuration data decoding - static Bool_t fgEnableDecodeConfigData; // flag to decode configuration data - - - //-------------------------------------------------------- - // Decoding functions - //-------------------------------------------------------- - - void DecodeSMInfo(const UInt_t *word, struct AliTRDrawSM *sm) const ; - const char *DumpSMInfo(const struct AliTRDrawSM *sm); - void DecodeStackInfo(const UInt_t *word, struct AliTRDrawStack *st) const; - void DecodeStackHeader(const UInt_t *word, struct AliTRDrawStack *st, Int_t iword) const; - const char *DumpStackInfo(const struct AliTRDrawStack *st); - Bool_t DecodeHCwordH0(const UInt_t *word, struct AliTRDrawHC *hc) const; - Bool_t DecodeHCwordH1(const UInt_t *word, struct AliTRDrawHC *hc) const; - const char *DumpHCinfoH0(const struct AliTRDrawHC *hc); - const char *DumpHCinfoH1(const struct AliTRDrawHC *hc); - void DecodeMCMheader(const UInt_t *word, struct AliTRDrawMCM *mcm) const; - UInt_t GetMCMadcMask(const UInt_t *word, struct AliTRDrawMCM *mcm) const; - void DecodeMask(const UInt_t *word, struct AliTRDrawMCM *mcm) const; - void MCMADCwordsWithTbins(UInt_t fTbins, struct AliTRDrawMCM *mcm) const; - const char *DumpMCMinfo(const struct AliTRDrawMCM *mcm); - const char *DumpMCMadcMask(const struct AliTRDrawMCM *mcm); - - - protected: - - Bool_t InitBuffer(void *buffer, UInt_t length); // init the buffer - called by DecodeSM(void*, UInt_t) - Bool_t DumpWords(UInt_t *px, UInt_t iw, UInt_t marker = 0); // dump some words onto the screen - - void SwapOnEndian(); // swap if endian is BIG - Bool_t SkipWords(UInt_t iw); // skip number of words - Bool_t DecodeGTUheader(); // decode data in GTU header - Bool_t DecodeTracklets(); // decode tracklets - Bool_t DecodeHC(); // decode data in HC - - Bool_t DecodeADC(); // decode 10 ADC words - Bool_t DecodeADCExtended(); // decode TRAP data with ZS and more than 32 samples - - Bool_t DecodeHCheader(); // decode HC header - Bool_t SeekEndOfData(); // go to next end of raw data marker (actually 1 word after) - Bool_t SkipMCMdata(UInt_t iw); // skip this mcm data due to mcm header corruption - Bool_t SeekNextMCMheader(); // go to next mcm header - Bool_t DecodeMCMheader(); // decode mcm header - - Bool_t IsRowValid(); // check if row within the range - Bool_t IsHCheaderOK(); // check if current hc header data make sense - Bool_t IsMCMheaderOK(); // check if current mcm header data make sense - - void ResetCounters(); // reset some counters - void ResetIterators(); // needed for Next() - void ResetPerSM(); // reset every SM - void ResetPerStack(); // reset every Stack - void ResetPerHC(); // reset every HC - void ResetPerMCM(); // reset every MCM - void ResetPerADC(); // reset every ADC - void ResetMemory(); // reset all data members - - AliTRDrawStream(const AliTRDrawStream& st); - AliTRDrawStream &operator=(const AliTRDrawStream &); - - // ----------------- DATA MEMBERS START - - struct AliTRDrawSM fSM; // one SM per buffer - struct AliTRDrawStack *fStack; //! pointer to the current stack - struct AliTRDrawHC *fHC; //! current HC - struct AliTRDrawHC *fLastHC; //! last HC - struct AliTRDrawMCM *fMCM; //! current MCM - struct AliTRDrawADC *fADC; //! current ADC - - UInt_t *fpPos; // current position in the buffer - UInt_t *fpBegin; // begin - pointer to the buffer word 0 - UInt_t *fpEnd; // end of the buffer - - UInt_t fWordLength; // length of the buffer in 32bit words - - Bool_t fIsGlobalDigitsParamSet; // set true if the global digit parameters are already set - - Int_t fStackNumber; // current stack number - Int_t fStackLinkNumber; // current link in the stack - - Int_t fhcMCMcounter; // mcm counter inside single hc - used in Next() - Int_t fmcmADCcounter; // adc counrer inside single adc - used in Next() - - Int_t fLinkTrackletCounter; // count the tracklets in the current HC - Int_t fEndOfTrackletCount; // count link by link (hc by hc) used for debug - Int_t fNWordsCounter; // counts words of given hc having link monitor error - - UInt_t fMaskADCword; // temp mask when decoding adcs - UInt_t fTbinADC; // temp adc - Int_t fDecodedADCs; // counter of decoded adcs [mj] do we need? - - UInt_t fEventCounter; // stores the valid/current MCM event counter - UInt_t fLastEventCounter; // last known event counter of MCM - - Bool_t fSharedPadsOn; // do we want to output shared pads - default is off - Int_t fMaxADCgeom; // maximum ADC channels per mcm - - Bool_t fBufferRead; // set to be true if buffer is read for a given equipment - - AliTRDgeometry *fGeometry; //! TRD geometry - AliRawReader *fRawReader; //! raw reader - - AliTRDfeeParam *fTRDfeeParam; // pointer to the fee params - Int_t fCommonAdditive; // baseline value - - // STATIC - - static Bool_t fgExtraSkip; // whether we should skip the leading 24 words - static Bool_t fgSkipCDH; // whether we should skip CDH (8 words) - static Bool_t fgWarnError; // no errors no warnings - static Bool_t fgCleanDataOnly; // release only clean events = no errors - static Bool_t fgDebugFlag; // allow debugging info - static Bool_t fgEnableMemoryReset; // allow memory reset - static Bool_t fgStackNumberChecker; // decide if we check stack number insanity - set false to cleanroom data - static Bool_t fgStackLinkNumberChecker; // decide if we check stack link number insanity - debuging purpose - static Bool_t fgSkipData; // decide if we skip corrupted data of given HC - static Int_t fgDumpHead; // number of words to dump (from the start of the buffer) on each Init - static Int_t fgEmptySignals[30]; // empty signals in case of ADC pointer = NULL - static Short_t fgMCMordering[16]; // mcm number odering for mcm header corruption check - static Short_t fgROBordering[16]; // mcm number odering for mcm header corruption check - static Int_t fgLastHC; // HC number indicator to check HC numbering - static Int_t fgLastROB; // ROB number indicator to check ROB numbering - static Int_t fgLastIndex; // variable to check mcm number odering - - static Bool_t fgDumpingEnable; // flag to dump MCM data words - - static Int_t fgDumpingSM; // sm number to dump MCM data words - static Int_t fgDumpingStack; // stack number to dump MCM data words - static Int_t fgDumpingLayer; // layer number to dump MCM data words - static Int_t fgDumpingROB; // rob number to dump MCM data words - static Int_t fgDumpingMCM; // mcm number to dump MCM data words - - // ----------------- DATA MEMBERS STOP - - enum ETRDzRawStreamError - { - kDecodeStackInfo = 1 // - , kMissingData = 2 // - , kLinkDataMissing = 3 // - , kHCdataMissing = 4 // - , kTrackletOverflow = 5 // - , kEOTrackeltsMissing = 6 // - , kWrongPadrow = 7 // - , kMCMheaderCorrupted = 8 // - , kWrongMCMorROB = 9 // - , kMCMeventMissmatch = 10 // - , kMCMADCMaskMissing = 11 // - , kHCHeaderCorrupt = 12 // - , kHCHeaderWrongStack = 13 // - , kHCHeaderWrongLayer = 14 // - , kHCHeaderWrongSide = 15 // - , kHCHeaderWrongSM = 16 // - , kHCHeaderWrongDet = 17 // - , kHCHeaderWrongROC = 18 // - , kHCWordMissing = 19 // - , kMCMdataMissing = 20 // - , kMCMoverflow = 21 // - , kADCdataMissing = 22 // - , kADCmaskMissmatch = 23 // - , kWrongPadcolumn = 24 // - }; - - ClassDef(AliTRDrawStream, 0) -}; //clas def end - -#endif +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +//----------------------------------- +// +// decoding of TRD raw data stream +// and translation into digits +// +//---------------------------------- + +#ifndef ALITRDRAWSTREAM_H +#define ALITRDRAWSTREAM_H + +#include "TObject.h" + +#include "AliTRDrawStreamBase.h" +//#include "AliRawReader.h" + +class TObjArray; +class TString; +class TTree; + +class AliRawReader; +class AliTRDdigitsManager; +class AliTRDdigitsParam; +class AliTRDarrayADC; +class AliTRDSignalIndex; + +class AliTRDrawStream : public AliTRDrawStreamBase +{ + public: + AliTRDrawStream(AliRawReader *rawReader = 0x0); + ~AliTRDrawStream(); + + Bool_t SetReader(AliRawReader *rawReader) { fRawReader = rawReader; return kTRUE; } + void SetDigitsManager(AliTRDdigitsManager *digMgr) { fDigitsManager = digMgr; } + + Bool_t ReadEvent(TTree *trackletTree = 0x0); + + Bool_t NextDDL(); + Int_t NextChamber(AliTRDdigitsManager *digMgr, + UInt_t ** /* trackletContainer */, UShort_t ** /* errorContainer */); + + Bool_t ConnectTracklets(TTree *trklTree); + + // legacy code, to be removed + Bool_t SetRawVersion(Int_t) { return kTRUE; } + void SetSharedPadReadout(Bool_t) {} + void SetNoErrorWarning() {} + + // error handling + enum ErrorCode_t { + kUnknown = 0, + kLinkMonitor, + kPtrgCntMismatch, + kNonTrdEq, + kStackHeaderInvalid, + kInvalidDetector, + kNoDigits, + kHCmismatch, + kHCcheckFailed, + kPosUnexp, + kTPmodeInvalid, + kTPmismatch, + kNtimebinsChanged, + kAdcMaskInconsistent, + kAdcCheckInvalid, + kAdcDataAbort, + kAdcChannelsMiss, + kMissMcmHeaders, + kLastErrorCode + }; + + TTree* GetErrorTree() const { return fErrors; } + static const char* GetErrorMessage(ErrorCode_t errCode); + + protected: + Int_t ReadSmHeader(); + Int_t ReadStackIndexHeader(Int_t stack); + + Int_t ReadLinkData(); + Int_t ReadTracklets(); + Int_t ReadHcHeader(); + Int_t ReadTPData(Int_t mode = 1); + Int_t ReadZSData(); + Int_t ReadNonZSData(); + + // MCM header decoding + Int_t ROB(UInt_t mcmhdr) const { return 0x7 & mcmhdr >> 28; } + Int_t MCM(UInt_t mcmhdr) const { return 0xf & mcmhdr >> 24; } + Int_t Row(UInt_t mcmhdr) const { return (ROB(mcmhdr) / 2) * 4 + MCM(mcmhdr) / 4; } + Int_t AdcColOffset(UInt_t mcmhdr) const { return (MCM(mcmhdr) % 4 + 1) * 21 + (ROB(mcmhdr) % 2) * 84 - 1; } + Int_t PadColOffset(UInt_t mcmhdr) const { return (MCM(mcmhdr) % 4 + 1) * 18 + (ROB(mcmhdr) % 2) * 72 + 1; } + Int_t EvNo(UInt_t mcmhdr) const { return 0xfffff & mcmhdr >> 4; } + Int_t Check(UInt_t mcmhdr) const { return 0xf & mcmhdr; } + Int_t CouldBeMCMhdr(UInt_t mcmhdr) const { return ((0xf & mcmhdr) == 0xc); } + + Int_t GetMCMReadoutPos(Int_t mcm) const { return (mcm > -1 && mcm < 16) ? fgkMcmOrder[mcm] : -1; } + Int_t GetROBReadoutPos(Int_t rob) const { return (rob > -1 && rob < 4) ? fgkRobOrder[rob] : -1; } + + // ADC mask decoding + Int_t GetActiveChannels(UInt_t adcmask) const { return 0x1fffff & adcmask >> 4; } + inline Int_t GetNActiveChannelsFromMask(UInt_t adcmask) const; // { Int_t nch = 0; for (Int_t i = 0; i < 21; i++) if ((GetActiveChannels(adcmask) & 1 << i)) nch++; return nch; } + Int_t GetNActiveChannels(UInt_t adcmask) const { return (0x1f & ~(adcmask >> 25)); } + Int_t CouldBeADCmask(UInt_t adcmask) const { return ((0xf & adcmask) == 0xc && (0x3 & adcmask >> 30) == 0x1); } + + // error message generation + TString EquipmentError(ErrorCode_t err = kUnknown, TString msg = ""); + TString StackError (ErrorCode_t err = kUnknown, TString msg = ""); + TString LinkError (ErrorCode_t err = kUnknown, TString msg = ""); + TString ROBError (ErrorCode_t err = kUnknown, TString msg = ""); + TString MCMError (ErrorCode_t err = kUnknown, TString msg = ""); + + static char* fgErrorMessages[kLastErrorCode]; // error messages corresponding to the error codes + + // I/O + AliRawReader *fRawReader; // pointer to the raw reader to take the data from + AliTRDdigitsManager *fDigitsManager; // pointer to the digitsManager to fill the data + AliTRDdigitsParam *fDigitsParam; // pointer to the parameters belonging to the digits + + TTree *fErrors; // tree containing the occured error codes + struct { Int_t fSector; Int_t fStack; Int_t fLink; Int_t fError; Int_t fRob; Int_t fMcm; } + fLastError; // last error which occured + + UInt_t *fPayloadStart; // pointer to start of data payload + UInt_t *fPayloadCurr; // pointer to current reading position in the payload + Int_t fPayloadSize; // size of the payload + + static const Int_t fgkNlinks; // number of links to read + static const Int_t fgkNstacks; // number of stacks to read + static const UInt_t fgkDataEndmarker; // data endmarker + static const UInt_t fgkTrackletEndmarker; // tracklet endmarker + static const Int_t fgkMcmOrder []; // expected readout order of the MCMs + static const Int_t fgkRobOrder []; // expected readout order of the ROBs + + // persistent information + Int_t fNtimebins; // number of timebins + Int_t fLastEvId; // Event ID of last event + + // information valid at current reader position + // all the variables fCurr... refer to the value at the current + // reading position + Int_t fCurrSlot; // current slot + Int_t fCurrLink; // current link + Int_t fCurrRobPos; // current ROB number + Int_t fCurrMcmPos; // current MCM number + + // DDL header + UInt_t fCurrEquipmentId; // current Equipment ID + + // SMU index header + UInt_t fCurrSmuIndexHeaderSize; // current size of the SMU index header + UInt_t fCurrSmuIndexHeaderVersion; // current version of the SMU index header + UInt_t fCurrTrackEnable; // current value of track enable + UInt_t fCurrTrackletEnable; // current value of tracklet enable + UInt_t fCurrStackMask; // current mask of active stacks + + // Stack index header + UInt_t *fCurrStackIndexWord; // current stack index words + UInt_t *fCurrStackHeaderSize; // current stack index sizes + UInt_t *fCurrStackHeaderVersion; // current stack header versions + UInt_t *fCurrLinkMask; // current link masks + UInt_t *fCurrCleanCheckout; // current clean checkout flags + UInt_t *fCurrBoardId; // current board IDs + UInt_t *fCurrHwRev; // current hardware revision + UInt_t *fCurrLinkMonitorFlags; // current link monitor flags + UInt_t *fCurrLinkDataTypeFlags; // current link data flags + UInt_t *fCurrLinkDebugFlags; // current link debug flags + + // HC information + Int_t fCurrSpecial; // current value of the special flag + Int_t fCurrMajor; // current major version + Int_t fCurrMinor; // current minor version + Int_t fCurrAddHcWords; // current number of additional HC-header words + Int_t fCurrSm; // current sector + Int_t fCurrStack; // current stack + Int_t fCurrLayer; // current layer + Int_t fCurrSide; // current side + Int_t fCurrHC; // current HC + Int_t fCurrCheck; // current check bits + Int_t fCurrNtimebins; // current number of timebins + Int_t fCurrBC; // current BC + Int_t fCurrPtrgCnt; // current pretrigger count + Int_t fCurrPtrgPhase; // current pretrigger phase + + // tracklet information + TClonesArray *fTrackletArray; // pointer to array for tracklet storage + + // output data + AliTRDarrayADC *fAdcArray; // pointer to ADC array + AliTRDSignalIndex *fSignalIndex; // pointer to the signal index + TTree *fTrackletTree; // pointer to the tree for tracklet storage + + AliTRDrawStream(const AliTRDrawStream&); // not implemented + AliTRDrawStream& operator=(const AliTRDrawStream&); // not implemented + + ClassDef(AliTRDrawStream, 0); +}; + +Int_t AliTRDrawStream::GetNActiveChannelsFromMask(UInt_t adcmask) const +{ + // return number of active bits in the ADC mask + + adcmask = GetActiveChannels(adcmask); + adcmask = adcmask - ((adcmask >> 1) & 0x55555555); + adcmask = (adcmask & 0x33333333) + ((adcmask >> 2) & 0x33333333); + return (((adcmask + (adcmask >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24; +} + +#endif