[u/mrichter/AliRoot.git] / ITS / AliITSRawStreamSDD.h

#ifndef ALIITSRAWSTREAMSDD_H
#define ALIITSRAWSTREAMSDD_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

///////////////////////////////////////////////////////////////////////////////
///
/// This class provides access to ITS SDD digits in raw data 
/// (default=simulated data).
///////////////////////////////////////////////////////////////////////////////

#include "AliITSRawStream.h"
#include "AliITSDDLModuleMapSDD.h"

class AliRawReader;


class AliITSRawStreamSDD: public AliITSRawStream {
  public :
    AliITSRawStreamSDD(AliRawReader* rawReader);
    AliITSRawStreamSDD(const AliITSRawStreamSDD& rs);
    AliITSRawStreamSDD& operator=(const AliITSRawStreamSDD& rs);
    virtual ~AliITSRawStreamSDD();

    static UChar_t ReadBlockAttributes(AliRawReader* rawReader);
    static UInt_t  ReadAMSamplFreqFromCDH(UChar_t cdhAttr){
      if(cdhAttr&0x10) return 40;
      else return 20;
    }
    static AliITSRawStream* CreateRawStreamSDD(AliRawReader* rawReader, UChar_t attributes);
    static AliITSRawStream* CreateRawStreamSDD(AliRawReader* rawReader);

    virtual Bool_t   Next();

    virtual Int_t    GetAnode() const {return fCoord1;}
    virtual Int_t    GetTime() const {return fCoord2;}
    virtual Int_t    GetChannel() const {return fChannel;}
    virtual Int_t    GetEightBitSignal() const {return fEightBitSignal;}
    virtual Int_t    GetCarlosId() const {return fCarlosId;}
    virtual Int_t    GetEventId() const {return fEventId;}
    virtual Int_t    GetJitter() const {return fJitter;}  


    virtual void     SetDecompressAmbra(Bool_t deco=kTRUE){
      fDecompressAmbra=deco;
    }
    virtual void SetDDLModuleMap(AliITSDDLModuleMapSDD* ddlsdd){
      if(!fDDLModuleMap) fDDLModuleMap=new AliITSDDLModuleMapSDD();
      fDDLModuleMap->SetDDLMap(ddlsdd);
    }
    virtual void     SetZeroSuppLowThreshold(Int_t iMod, Int_t iSid, Int_t th) 
      {fLowThresholdArray[iMod][iSid]=th;}
    Int_t   GetModuleNumber(UInt_t iDDL, UInt_t iModule) const {
      if(!fDDLModuleMap) return kSPDModules+1; // dummy module number if the DDL map is not set (case of DAs)
      return fDDLModuleMap->GetModuleNumber(iDDL,iModule);
    }
    virtual void     Reset(); 

    enum {kSDDModules = 260};      // number of SDD modules
    enum {kSPDModules = 240};      // number of SPD modules (used as offset)
    enum {kDDLsNumber = 24};       // number of DDLs in SDD
    enum {kModulesPerDDL = 12};    // number of modules in each DDL 
    enum {kCarlosWords = 12};      // number of FIFOCARLOS Words
    enum {kFifoWords =  4};        // number of FIFO Words
    enum ESDDRawStreamError { 
      kDataError = 1,
      kDataFormatErr = 2
    };
  protected:
    virtual Bool_t   SkipHeaderWord(); 
    virtual UInt_t   ReadBits();
    virtual Int_t    DecompAmbra(Int_t value) const;

    static const UInt_t fgkCodeLength[8]; //code length

    AliITSDDLModuleMapSDD* fDDLModuleMap; // mapping DDL/module -> module number 
    UInt_t           fData;         // data read for file
    Bool_t           fResetSkip;    // flag for end of DDL data

    Int_t            fEventId;      // event ID from header
    Int_t            fCarlosId;     // carlos ID
    Int_t            fChannel;      // current channel
    Int_t            fJitter;          // jitter between L0 and pascal stop (x25ns)
    ULong64_t        fChannelData[kModulesPerDDL][2];// packed data for the 2 channels
    UInt_t           fLastBit[kModulesPerDDL][2];    // last filled bit in fChannelData
    UInt_t           fChannelCode[kModulesPerDDL][2];// current channel code
    Bool_t           fReadCode[kModulesPerDDL][2];   // next bits are code or data
    UInt_t           fReadBits[kModulesPerDDL][2];   // number of bits to read
    Int_t            fLowThresholdArray[kSDDModules][2]; // array with low thresholds for all modules

    Int_t            fNfifo[kFifoWords];  // FIFO number
    Int_t            fTimeBin[kModulesPerDDL][2];  // current timebin [ncarlos][nchannels]
    Int_t            fAnode[kModulesPerDDL][2]; // current anode [ncarlos][nchannels]
    UInt_t           fICarlosWord[kCarlosWords]; // Carlos words
    UInt_t           fIFifoWord[kFifoWords];     // FIFO words
    Int_t            fICountFoot[kModulesPerDDL]; // counter for carlos footer words
    Int_t            fEightBitSignal;    // signal at 8 bit
    Bool_t           fDecompressAmbra; //flag to switch off decompression

    ClassDef(AliITSRawStreamSDD, 14) // class for reading ITS SDD raw digits
};

#endif
Commit	Line	Data
	1	#ifndef ALIITSRAWSTREAMSDD_H
	2	#define ALIITSRAWSTREAMSDD_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7
	8	///////////////////////////////////////////////////////////////////////////////
	9	///
	10	/// This class provides access to ITS SDD digits in raw data
	11	/// (default=simulated data).
	12	///////////////////////////////////////////////////////////////////////////////
	13
	14	#include "AliITSRawStream.h"
	15	#include "AliITSDDLModuleMapSDD.h"
	16
	17	class AliRawReader;
	18
	19
	20	class AliITSRawStreamSDD: public AliITSRawStream {
	21	public :
	22	AliITSRawStreamSDD(AliRawReader* rawReader);
	23	AliITSRawStreamSDD(const AliITSRawStreamSDD& rs);
	24	AliITSRawStreamSDD& operator=(const AliITSRawStreamSDD& rs);
	25	virtual ~AliITSRawStreamSDD();
	26
	27	static UChar_t ReadBlockAttributes(AliRawReader* rawReader);
	28	static UInt_t ReadAMSamplFreqFromCDH(UChar_t cdhAttr){
	29	if(cdhAttr&0x10) return 40;
	30	else return 20;
	31	}
	32	static AliITSRawStream* CreateRawStreamSDD(AliRawReader* rawReader, UChar_t attributes);
	33	static AliITSRawStream* CreateRawStreamSDD(AliRawReader* rawReader);
	34
	35	virtual Bool_t Next();
	36
	37	virtual Int_t GetAnode() const {return fCoord1;}
	38	virtual Int_t GetTime() const {return fCoord2;}
	39	virtual Int_t GetChannel() const {return fChannel;}
	40	virtual Int_t GetEightBitSignal() const {return fEightBitSignal;}
	41	virtual Int_t GetCarlosId() const {return fCarlosId;}
	42	virtual Int_t GetEventId() const {return fEventId;}
	43	virtual Int_t GetJitter() const {return fJitter;}
	44
	45
	46	virtual void SetDecompressAmbra(Bool_t deco=kTRUE){
	47	fDecompressAmbra=deco;
	48	}
	49	virtual void SetDDLModuleMap(AliITSDDLModuleMapSDD* ddlsdd){
	50	if(!fDDLModuleMap) fDDLModuleMap=new AliITSDDLModuleMapSDD();
	51	fDDLModuleMap->SetDDLMap(ddlsdd);
	52	}
	53	virtual void SetZeroSuppLowThreshold(Int_t iMod, Int_t iSid, Int_t th)
	54	{fLowThresholdArray[iMod][iSid]=th;}
	55	Int_t GetModuleNumber(UInt_t iDDL, UInt_t iModule) const {
	56	if(!fDDLModuleMap) return kSPDModules+1; // dummy module number if the DDL map is not set (case of DAs)
	57	return fDDLModuleMap->GetModuleNumber(iDDL,iModule);
	58	}
	59	virtual void Reset();
	60
	61	enum {kSDDModules = 260}; // number of SDD modules
	62	enum {kSPDModules = 240}; // number of SPD modules (used as offset)
	63	enum {kDDLsNumber = 24}; // number of DDLs in SDD
	64	enum {kModulesPerDDL = 12}; // number of modules in each DDL
	65	enum {kCarlosWords = 12}; // number of FIFOCARLOS Words
	66	enum {kFifoWords = 4}; // number of FIFO Words
	67	enum ESDDRawStreamError {
	68	kDataError = 1,
	69	kDataFormatErr = 2
	70	};
	71	protected:
	72	virtual Bool_t SkipHeaderWord();
	73	virtual UInt_t ReadBits();
	74	virtual Int_t DecompAmbra(Int_t value) const;
	75
	76	static const UInt_t fgkCodeLength[8]; //code length
	77
	78	AliITSDDLModuleMapSDD* fDDLModuleMap; // mapping DDL/module -> module number
	79	UInt_t fData; // data read for file
	80	Bool_t fResetSkip; // flag for end of DDL data
	81
	82	Int_t fEventId; // event ID from header
	83	Int_t fCarlosId; // carlos ID
	84	Int_t fChannel; // current channel
	85	Int_t fJitter; // jitter between L0 and pascal stop (x25ns)
	86	ULong64_t fChannelData[kModulesPerDDL][2];// packed data for the 2 channels
	87	UInt_t fLastBit[kModulesPerDDL][2]; // last filled bit in fChannelData
	88	UInt_t fChannelCode[kModulesPerDDL][2];// current channel code
	89	Bool_t fReadCode[kModulesPerDDL][2]; // next bits are code or data
	90	UInt_t fReadBits[kModulesPerDDL][2]; // number of bits to read
	91	Int_t fLowThresholdArray[kSDDModules][2]; // array with low thresholds for all modules
	92
	93	Int_t fNfifo[kFifoWords]; // FIFO number
	94	Int_t fTimeBin[kModulesPerDDL][2]; // current timebin [ncarlos][nchannels]
	95	Int_t fAnode[kModulesPerDDL][2]; // current anode [ncarlos][nchannels]
	96	UInt_t fICarlosWord[kCarlosWords]; // Carlos words
	97	UInt_t fIFifoWord[kFifoWords]; // FIFO words
	98	Int_t fICountFoot[kModulesPerDDL]; // counter for carlos footer words
	99	Int_t fEightBitSignal; // signal at 8 bit
	100	Bool_t fDecompressAmbra; //flag to switch off decompression
	101
	102	ClassDef(AliITSRawStreamSDD, 14) // class for reading ITS SDD raw digits
	103	};
	104
	105	#endif