[u/mrichter/AliRoot.git] / TRD / AliTRDmcmSim.h

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

/* $Id$ */

///////////////////////////////////////////////////////
//                                                   //
//  Multi Chip Module Simulation Class               //
//                                                   //
///////////////////////////////////////////////////////

#include <TObject.h>
#include "AliTRDCommonParam.h"
#include "AliTRDcalibDB.h"

class TClonesArray;

class AliRunLoader;
class AliTRDfeeParam;
class AliTRDSimParam;
class AliTRDtrapConfig;
class AliTRDcalibDB;
class AliTRDgeometry;
class AliTRDpadPlane;
class AliTRDarrayADC;
class AliTRDdigitsManager;

class AliTRDmcmSim : public TObject {
 public:
                    AliTRDmcmSim();
  virtual          ~AliTRDmcmSim();

          void      Init( Int_t cha, Int_t rob, Int_t mcm, Bool_t newEvent = kFALSE );   // Initialize MCM by the position parameters
	  void      Reset();                                   // clears filter registers and internal data

	  Bool_t    LoadMCM(AliRunLoader* const runloader, Int_t det, Int_t rob, Int_t mcm);
	  void      NoiseTest(Int_t nsamples, Int_t mean, Int_t sigma, Int_t inputGain = 1, Int_t inputTail = 2);

          void      SetData(Int_t iadc, Int_t *adc);           // Set ADC data with array 
          void      SetData(Int_t iadc, Int_t it, Int_t adc ); // Set ADC data
	  void      SetData(AliTRDarrayADC *adcArray, 
			    AliTRDdigitsManager *digitsManager = 0x0);         // Set ADC data from adcArray
          void      SetDataPedestal(Int_t iadc );              // Fill ADC data with pedestal values
  static  void      SetApplyCut(Bool_t applyCut) { fgApplyCut = applyCut; }

          Int_t     GetDetector() const  { return fDetector;  };     // Returns Chamber ID (0-539)
          Int_t     GetRobPos() const { return fRobPos; };     // Returns ROB position (0-7)
          Int_t     GetMcmPos() const { return fMcmPos; };     // Returns MCM position (0-17) (16,17 are mergers)
          Int_t     GetRow() const    { return fRow;    };     // Returns Row number on chamber where the MCM is sitting
	  Int_t     GetCol( Int_t iadc );                      // Get corresponding column (0-143) from for ADC channel iadc = [0:20]
	  // for the ADC/Col mapping, see: http://wiki.kip.uni-heidelberg.de/ti/TRD/index.php/Image:ROB_MCM_numbering.pdf
  static  Bool_t    GetApplyCut() { return fgApplyCut; }

	  void WriteData(AliTRDarrayADC *digits);

	  Int_t     ProduceRawStream( UInt_t *buf, Int_t bufsize, UInt_t iEv = 0 ); // Produce raw data stream - Read data format
	  Int_t     ProduceTrackletStream( UInt_t *buf, Int_t bufsize ); // produce the tracklet stream for this MCM
		
	  // different stages of processing in the TRAP
	  void      Filter();                                  // Apply digital filters for existing data (according to configuration)
	  void      ZSMapping();                               // Do ZS mapping for existing data
	  void      Tracklet();                                // Run tracklet preprocessor and perform tracklet fit

	  // apply individual filters to all channels and timebins
	  void      FilterPedestal();                   // Apply pedestal filter
	  void      FilterGain();                       // Apply gain filter
	  void      FilterTail();                       // Apply tail filter

	  // filter initialization (resets internal registers)
	  void      FilterPedestalInit();
	  void      FilterGainInit();
	  void      FilterTailInit(Int_t baseline); //??? automatic baseline??

	  // feed single sample to individual filter
	  // this changes the internal registers
	  // all filters operate on 12-bit values!
	  UShort_t  FilterPedestalNextSample(Int_t adc, Int_t timebin, UShort_t value);
	  UShort_t  FilterGainNextSample(Int_t adc, UShort_t value);
	  UShort_t  FilterTailNextSample(Int_t adc, UShort_t value);

	  // tracklet calculation
	  void      AddHitToFitreg(Int_t adc, UShort_t timebin, UShort_t qtot, Short_t ypos, Int_t label);
	  void      CalcFitreg();
	  void      TrackletSelection();
	  void      FitTracklet();

	  TClonesArray* GetTrackletArray() const { return fTrackletArray; }

	  // data display
	  void      Print(Option_t* const option="") const;   // print stored data to stdout
	  void      Draw(Option_t* const option ="");         // draw data (ADC data, hits and tracklets)
	  void      DumpData( char *f, char *target );  // Dump data stored (only for debugging)

 protected:
	  Bool_t    CheckInitialized();                 // Check whether the class is initialized
	  
	  Bool_t    fInitialized;                       // Status whether the class is initialized or not
	  Int_t     fMaxTracklets;                      // maximum number of tracklet-words submitted per mcm **new** //???
	  Int_t     fDetector;                             // Chamber ID
	  Int_t     fRobPos;                            // ROB Position on chamber 
	  Int_t     fMcmPos;                            // MCM Position on chamber 
	  Int_t     fRow;                               // Pad row number (0-11 or 0-15) of the MCM on chamber
	  Int_t     fNADC;                              // Number of ADC (usually 21) //??? static const
	  Int_t     fNTimeBin;                          // Number of Timebins (variable)  //??? why stored here? taken from TRAPconfig
	  Int_t   **fADCR;                              // Array with MCM ADC values (Raw, 12 bit)
	  Int_t   **fADCF;                              // Array with MCM ADC values (Filtered, 12 bit)
	  UInt_t   *fMCMT;                              // tracklet word for one mcm/trap-chip **new** //??? needed?
	  TClonesArray *fTrackletArray;                 // Array of AliTRDtrackletMCM which contains MC information in addition to the tracklet word
	  Int_t   **fZSM;                               // Zero suppression map
	  Int_t    *fZSM1Dim;                           // Zero suppression map (1 dimensional projection)

	  static const Int_t fgkAddDigits = 2;          // additional digits used for internal representation
	                                                // all internal data as after data control block (i.e. 12 bit), s. TRAP manual
	  static const Int_t fgkNCPU = 4;               // Number of CPUs in the TRAP
	  Int_t     fFitPtr[fgkNCPU];                   // pointer to the tracklet to be calculated by CPU i
	  static const Int_t fgkNHitsMC = 100;          // maximum number of hits for which MC information is kept

	  // Parameter classes
	  AliTRDfeeParam    *fFeeParam;                 // FEE parameters
	  AliTRDtrapConfig  *fTrapConfig;               // TRAP config
	  AliTRDSimParam    *fSimParam;                 // Simulation parameters
	  AliTRDCommonParam *fCommonParam;              // common parameters
	  AliTRDcalibDB     *fCal;                      // Calibration interface
	  AliTRDgeometry    *fGeo;                      // Geometry

	  AliTRDdigitsManager *fDigitsManager;          // pointer to digits manager used for MC label calculation

	  // internal filter registers
	  UInt_t*   fPedAcc;                            // Accumulator for pedestal filter
	  UInt_t*   fGainCounterA;                      // Counter for values above FGTA in the gain filter
	  UInt_t*   fGainCounterB;                      // Counter for values above FGTB in the gain filter
 	  UShort_t* fTailAmplLong;                      // Amplitude of the long component in the tail filter
 	  UShort_t* fTailAmplShort;                     // Amplitude of the short component in the tail filter

	  // hit detection
	  // individual hits can be stored as MC info
	  struct Hit_t {                                // Array of detected hits (only available in MC)
	    Int_t fChannel;                             // ADC channel of the hit
	    Int_t fTimebin;                             // timebin of the hit
	    Int_t fQtot;                                // total charge of the hit
	    Int_t fYpos;                                // calculated y-position
	    Int_t fLabel;                               // label (only in MC)
	  } fHits[fgkNHitsMC];
	  Int_t fNHits;                                 // Number of detected hits

	  // tracklet calculation
	  struct FitReg_t {                             // pointer to the 18 fit registers 
	    Int_t   fNhits;                             // number of hits
	    UInt_t fQ0;                                 // charge accumulated in first window
	    UInt_t fQ1;                                 // charge accumulated in second window
	    UInt_t fSumX;                               // sum x
	    Int_t fSumY;                                // sum y 
	    UInt_t fSumX2;                              // sum x**2
	    UInt_t fSumY2;                              // sum y**2
	    Int_t fSumXY;                               // sum x*y
	  } *fFitReg;

	  //??? cleaning up
	  void Sort2(UShort_t  idx1i, UShort_t  idx2i, UShort_t  val1i, UShort_t  val2i, 
		     UShort_t *idx1o, UShort_t *idx2o, UShort_t *val1o, UShort_t *val2o) const;
	  void Sort3(UShort_t  idx1i, UShort_t  idx2i, UShort_t  idx3i, 
		     UShort_t  val1i, UShort_t  val2i, UShort_t  val3i, 
		     UShort_t *idx1o, UShort_t *idx2o, UShort_t *idx3o, 
		     UShort_t *val1o, UShort_t *val2o, UShort_t *val3o);
	  void Sort6To4(UShort_t  idx1i, UShort_t  idx2i, UShort_t  idx3i, UShort_t  idx4i, UShort_t  idx5i, UShort_t  idx6i, 
			UShort_t  val1i, UShort_t  val2i, UShort_t  val3i, UShort_t  val4i, UShort_t  val5i, UShort_t  val6i, 
			UShort_t *idx1o, UShort_t *idx2o, UShort_t *idx3o, UShort_t *idx4o, 
			UShort_t *val1o, UShort_t *val2o, UShort_t *val3o, UShort_t *val4o);
	  void Sort6To2Worst(UShort_t  idx1i, UShort_t  idx2i, UShort_t  idx3i, UShort_t  idx4i, UShort_t  idx5i, UShort_t  idx6i, 
			     UShort_t  val1i, UShort_t  val2i, UShort_t  val3i, UShort_t  val4i, UShort_t  val5i, UShort_t  val6i, 
			     UShort_t *idx5o, UShort_t *idx6o);

	  UInt_t AddUintClipping(UInt_t a, UInt_t b, UInt_t nbits) const;  // Add a and b (unsigned) with clipping to the maximum value representable by nbits

 private:
	  AliTRDmcmSim(const AliTRDmcmSim &m);             // not implemented
	  AliTRDmcmSim &operator=(const AliTRDmcmSim &m);  // not implemented

	  static Bool_t fgApplyCut;

  ClassDef(AliTRDmcmSim,4)
};

#endif
Commit	Line	Data
ab9f7002	1	#ifndef ALITRDMCMSIM_H
ab9f7002	2	#define ALITRDMCMSIM_H
dfd03fc3	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	// Multi Chip Module Simulation Class //
	11	// //
	12	///////////////////////////////////////////////////////
	13
	14	#include <TObject.h>
40bd6ee4	15	#include "AliTRDCommonParam.h"
40bd6ee4	16	#include "AliTRDcalibDB.h"
ab9f7002	17
ab9f7002	18	class TClonesArray;
dfd03fc3	19
b0a41e80	20	class AliRunLoader;
dfd03fc3	21	class AliTRDfeeParam;
ecf39416	22	class AliTRDSimParam;
b0a41e80	23	class AliTRDtrapConfig;
ecf39416	24	class AliTRDcalibDB;
dfd03fc3	25	class AliTRDgeometry;
1d93b218	26	class AliTRDpadPlane;
b65e5048	27	class AliTRDarrayADC;
40bd6ee4	28	class AliTRDdigitsManager;
dfd03fc3	29
dfd03fc3	30	class AliTRDmcmSim : public TObject {
dfd03fc3	31	public:
ecf39416	32	AliTRDmcmSim();
ecf39416	33	virtual ~AliTRDmcmSim();
dfd03fc3	34
b0a41e80	35	void Init( Int_t cha, Int_t rob, Int_t mcm, Bool_t newEvent = kFALSE ); // Initialize MCM by the position parameters
	36	void Reset(); // clears filter registers and internal data
	37
ab9f7002	38	Bool_t LoadMCM(AliRunLoader* const runloader, Int_t det, Int_t rob, Int_t mcm);
b0a41e80	39	void NoiseTest(Int_t nsamples, Int_t mean, Int_t sigma, Int_t inputGain = 1, Int_t inputTail = 2);
dfd03fc3	40
dfd03fc3	41	void SetData(Int_t iadc, Int_t *adc); // Set ADC data with array
ecf39416	42	void SetData(Int_t iadc, Int_t it, Int_t adc ); // Set ADC data
40bd6ee4	43	void SetData(AliTRDarrayADC *adcArray,
40bd6ee4	44	AliTRDdigitsManager *digitsManager = 0x0); // Set ADC data from adcArray
dfd03fc3	45	void SetDataPedestal(Int_t iadc ); // Fill ADC data with pedestal values
40bd6ee4	46	static void SetApplyCut(Bool_t applyCut) { fgApplyCut = applyCut; }
dfd03fc3	47
b0a41e80	48	Int_t GetDetector() const { return fDetector; }; // Returns Chamber ID (0-539)
0c349049	49	Int_t GetRobPos() const { return fRobPos; }; // Returns ROB position (0-7)
	50	Int_t GetMcmPos() const { return fMcmPos; }; // Returns MCM position (0-17) (16,17 are mergers)
	51	Int_t GetRow() const { return fRow; }; // Returns Row number on chamber where the MCM is sitting
ecf39416	52	Int_t GetCol( Int_t iadc ); // Get corresponding column (0-143) from for ADC channel iadc = [0:20]
ecf39416	53	// for the ADC/Col mapping, see: http://wiki.kip.uni-heidelberg.de/ti/TRD/index.php/Image:ROB_MCM_numbering.pdf
40bd6ee4	54	static Bool_t GetApplyCut() { return fgApplyCut; }
dfd03fc3	55
b0a41e80	56	void WriteData(AliTRDarrayADC *digits);
1d93b218	57
b0a41e80	58	Int_t ProduceRawStream( UInt_t *buf, Int_t bufsize, UInt_t iEv = 0 ); // Produce raw data stream - Read data format
1d93b218	59	Int_t ProduceTrackletStream( UInt_t *buf, Int_t bufsize ); // produce the tracklet stream for this MCM
b0a41e80	60
	61	// different stages of processing in the TRAP
	62	void Filter(); // Apply digital filters for existing data (according to configuration)
ecf39416	63	void ZSMapping(); // Do ZS mapping for existing data
b0a41e80	64	void Tracklet(); // Run tracklet preprocessor and perform tracklet fit
dfd03fc3	65
b0a41e80	66	// apply individual filters to all channels and timebins
	67	void FilterPedestal(); // Apply pedestal filter
	68	void FilterGain(); // Apply gain filter
	69	void FilterTail(); // Apply tail filter
dfd03fc3	70
b0a41e80	71	// filter initialization (resets internal registers)
	72	void FilterPedestalInit();
	73	void FilterGainInit();
	74	void FilterTailInit(Int_t baseline); //??? automatic baseline??
ecf39416	75
b0a41e80	76	// feed single sample to individual filter
	77	// this changes the internal registers
	78	// all filters operate on 12-bit values!
	79	UShort_t FilterPedestalNextSample(Int_t adc, Int_t timebin, UShort_t value);
	80	UShort_t FilterGainNextSample(Int_t adc, UShort_t value);
	81	UShort_t FilterTailNextSample(Int_t adc, UShort_t value);
1d93b218	82
b0a41e80	83	// tracklet calculation
	84	void AddHitToFitreg(Int_t adc, UShort_t timebin, UShort_t qtot, Short_t ypos, Int_t label);
	85	void CalcFitreg();
	86	void TrackletSelection();
	87	void FitTracklet();
1d93b218	88
ab9f7002	89	TClonesArray* GetTrackletArray() const { return fTrackletArray; }
dfd03fc3	90
b0a41e80	91	// data display
ab9f7002	92	void Print(Option_t* const option="") const; // print stored data to stdout
ab9f7002	93	void Draw(Option_t* const option =""); // draw data (ADC data, hits and tracklets)
b0a41e80	94	void DumpData( char f, char target ); // Dump data stored (only for debugging)
dfd03fc3	95
b0a41e80	96	protected:
	97	Bool_t CheckInitialized(); // Check whether the class is initialized
	98
	99	Bool_t fInitialized; // Status whether the class is initialized or not
	100	Int_t fMaxTracklets; // maximum number of tracklet-words submitted per mcm new //???
	101	Int_t fDetector; // Chamber ID
	102	Int_t fRobPos; // ROB Position on chamber
	103	Int_t fMcmPos; // MCM Position on chamber
	104	Int_t fRow; // Pad row number (0-11 or 0-15) of the MCM on chamber
	105	Int_t fNADC; // Number of ADC (usually 21) //??? static const
	106	Int_t fNTimeBin; // Number of Timebins (variable) //??? why stored here? taken from TRAPconfig
	107	Int_t **fADCR; // Array with MCM ADC values (Raw, 12 bit)
	108	Int_t **fADCF; // Array with MCM ADC values (Filtered, 12 bit)
	109	UInt_t fMCMT; // tracklet word for one mcm/trap-chip new* //??? needed?
	110	TClonesArray *fTrackletArray; // Array of AliTRDtrackletMCM which contains MC information in addition to the tracklet word
	111	Int_t **fZSM; // Zero suppression map
	112	Int_t *fZSM1Dim; // Zero suppression map (1 dimensional projection)
dfd03fc3	113
b0a41e80	114	static const Int_t fgkAddDigits = 2; // additional digits used for internal representation
	115	// all internal data as after data control block (i.e. 12 bit), s. TRAP manual
	116	static const Int_t fgkNCPU = 4; // Number of CPUs in the TRAP
	117	Int_t fFitPtr[fgkNCPU]; // pointer to the tracklet to be calculated by CPU i
	118	static const Int_t fgkNHitsMC = 100; // maximum number of hits for which MC information is kept
dfd03fc3	119
b0a41e80	120	// Parameter classes
	121	AliTRDfeeParam *fFeeParam; // FEE parameters
	122	AliTRDtrapConfig *fTrapConfig; // TRAP config
	123	AliTRDSimParam *fSimParam; // Simulation parameters
40bd6ee4	124	AliTRDCommonParam *fCommonParam; // common parameters
b0a41e80	125	AliTRDcalibDB *fCal; // Calibration interface
	126	AliTRDgeometry *fGeo; // Geometry
	127
40bd6ee4	128	AliTRDdigitsManager *fDigitsManager; // pointer to digits manager used for MC label calculation
40bd6ee4	129
b0a41e80	130	// internal filter registers
	131	UInt_t* fPedAcc; // Accumulator for pedestal filter
	132	UInt_t* fGainCounterA; // Counter for values above FGTA in the gain filter
	133	UInt_t* fGainCounterB; // Counter for values above FGTB in the gain filter
	134	UShort_t* fTailAmplLong; // Amplitude of the long component in the tail filter
	135	UShort_t* fTailAmplShort; // Amplitude of the short component in the tail filter
	136
	137	// hit detection
	138	// individual hits can be stored as MC info
ab9f7002	139	struct Hit_t { // Array of detected hits (only available in MC)
	140	Int_t fChannel; // ADC channel of the hit
	141	Int_t fTimebin; // timebin of the hit
	142	Int_t fQtot; // total charge of the hit
	143	Int_t fYpos; // calculated y-position
	144	Int_t fLabel; // label (only in MC)
	145	} fHits[fgkNHitsMC];
b0a41e80	146	Int_t fNHits; // Number of detected hits
	147
	148	// tracklet calculation
ab9f7002	149	struct FitReg_t { // pointer to the 18 fit registers
	150	Int_t fNhits; // number of hits
	151	UInt_t fQ0; // charge accumulated in first window
	152	UInt_t fQ1; // charge accumulated in second window
	153	UInt_t fSumX; // sum x
	154	Int_t fSumY; // sum y
	155	UInt_t fSumX2; // sum x**2
	156	UInt_t fSumY2; // sum y**2
	157	Int_t fSumXY; // sum x*y
	158	} *fFitReg;
b0a41e80	159
	160	//??? cleaning up
	161	void Sort2(UShort_t idx1i, UShort_t idx2i, UShort_t val1i, UShort_t val2i,
ab9f7002	162	UShort_t idx1o, UShort_t idx2o, UShort_t val1o, UShort_t val2o) const;
b0a41e80	163	void Sort3(UShort_t idx1i, UShort_t idx2i, UShort_t idx3i,
	164	UShort_t val1i, UShort_t val2i, UShort_t val3i,
	165	UShort_t idx1o, UShort_t idx2o, UShort_t *idx3o,
	166	UShort_t val1o, UShort_t val2o, UShort_t *val3o);
	167	void Sort6To4(UShort_t idx1i, UShort_t idx2i, UShort_t idx3i, UShort_t idx4i, UShort_t idx5i, UShort_t idx6i,
	168	UShort_t val1i, UShort_t val2i, UShort_t val3i, UShort_t val4i, UShort_t val5i, UShort_t val6i,
	169	UShort_t idx1o, UShort_t idx2o, UShort_t idx3o, UShort_t idx4o,
	170	UShort_t val1o, UShort_t val2o, UShort_t val3o, UShort_t val4o);
	171	void Sort6To2Worst(UShort_t idx1i, UShort_t idx2i, UShort_t idx3i, UShort_t idx4i, UShort_t idx5i, UShort_t idx6i,
	172	UShort_t val1i, UShort_t val2i, UShort_t val3i, UShort_t val4i, UShort_t val5i, UShort_t val6i,
	173	UShort_t idx5o, UShort_t idx6o);
	174
ab9f7002	175	UInt_t AddUintClipping(UInt_t a, UInt_t b, UInt_t nbits) const; // Add a and b (unsigned) with clipping to the maximum value representable by nbits
b0a41e80	176
	177	private:
	178	AliTRDmcmSim(const AliTRDmcmSim &m); // not implemented
	179	AliTRDmcmSim &operator=(const AliTRDmcmSim &m); // not implemented
	180
40bd6ee4	181	static Bool_t fgApplyCut;
b0a41e80	182
b0a41e80	183	ClassDef(AliTRDmcmSim,4)
dfd03fc3	184	};
	185
	186	#endif