[u/mrichter/AliRoot.git] / VZERO / AliVZERORawStream.h

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

///////////////////////////////////////////////////////////////////////////////
///
/// This is a class for reading the VZERO DDL raw data
/// The format of the raw data corresponds to the one
/// implemented in AliVZEROBuffer class.
///
/// PLEASE NOTE that Int_t channel is here the FEE channel from 0 to 63 in the 
/// order defined by Yannick Zoccarato which is not the same order as the order 
/// defined in aliroot by the naming and numbering conventions.
/// Therefore one has to go from FEE_Channel to AliRoot_Channel using 
/// GetOfflineChannel(Int_t channel)  when going from Online to Offline !!!
///
///////////////////////////////////////////////////////////////////////////////

#include <TObject.h>
#include <TMath.h>

class AliRawReader;

class AliVZERORawStream: public TObject {
  public :
    AliVZERORawStream(AliRawReader* rawReader);
    virtual ~AliVZERORawStream();

    virtual void      Reset();
    virtual Bool_t    Next();

// Getters of various scalers and Minimum Bias flags :

   ULong64_t          GetBBScalers(Int_t channel) const  
      { return        fBBScalers[channel]; }
   ULong64_t          GetBGScalers(Int_t channel) const  
      { return        fBGScalers[channel]; }
   UInt_t             GetTriggerScalers(Int_t num_scaler) const 
      { return        fScalers[num_scaler]; }
   UInt_t             GetBunchNumbersMB(Int_t num_bunch) const 
      { return        fBunchNumbers[num_bunch]; }
   UShort_t           GetChargeMB(Int_t channel, Int_t num_bunch) const  
      { return        fChargeMB[channel][num_bunch]; } 
   Bool_t             GetIntMBFlag(Int_t channel, Int_t num_bunch) const   
      { return        fIsIntMB[channel][num_bunch]; } 
   Bool_t             GetBBMBFlag(Int_t channel, Int_t num_bunch) const   
      { return        fIsBBMB[channel][num_bunch]; }  
   Bool_t             GetBGMBFlag(Int_t channel, Int_t num_bunch) const   
      { return        fIsBGMB[channel][num_bunch]; }      
       
// Getters of ADC signals, ADC pedestals, time information and corresponding flags :

    Short_t           GetADC(Int_t channel) const
      { return TMath::MaxElement(kNEvOfInt, fADC[channel]); }    // maximum value instead of central clock
//    { return fADC[channel][kNEvOfInt/2]; }
            
    Short_t           GetPedestal(Int_t channel, Int_t event) const
      { return fADC[channel][event]; }
    Bool_t            GetIntegratorFlag(Int_t channel, Int_t event) const
      { return fIsInt[channel][event]; }
    Bool_t            GetBBFlag(Int_t channel, Int_t event) const
      { return fIsBB[channel][event]; } 
    Bool_t            GetBGFlag(Int_t channel, Int_t event) const
      { return fIsBG[channel][event]; }   
    Short_t           GetTime(Int_t channel) const
      { return fTime[channel]; }
    Short_t           GetWidth(Int_t channel) const
      { return fWidth[channel]; }

    UShort_t          GetTriggerInputs() const
      { return fTrigger; }
    UShort_t          GetTriggerInputsMask() const
      { return fTriggerMask; }

// Getter of Offline Channel number as used in aliroot (defined by aliroot 
// numbering convention) from FEE channel (electronic channel number given 
// by the V0 electronics readout) - See comment above - 

    Int_t              GetOfflineChannel(Int_t channel)  const
      { Int_t  fOfflineChannel[64] = {39, 38, 37, 36, 35, 34, 33, 32, 
                                      47, 46, 45, 44, 43, 42, 41, 40, 
			              55, 54, 53, 52, 51, 50, 49, 48, 
			              63, 62, 61, 60, 59, 58, 57, 56,
			               7,  6,  5,  4,  3,  2,  1,  0, 
			              15, 14, 13, 12, 11, 10,  9,  8,
			              23, 22, 21, 20, 19, 18, 17, 16, 
			              31, 30, 29, 28, 27, 26, 25, 24};
               return fOfflineChannel[channel]; }	

    enum EVZERORawDataParams {
      kNChannels = 64, // number of electronic channels in V0 (FEE numbering)
      kNEvOfInt  = 21, // number of events of interest
      kNScalers  = 16, // number of scalers
      kNBunches  = 10  // number of bunches used in Minimum Bias information 
    };

    enum EVZERORawStreamError {
      kRawDataSizeErr = 1
    };

  private:

    AliVZERORawStream(const AliVZERORawStream& stream);
    AliVZERORawStream& operator = (const AliVZERORawStream& stream);

    UInt_t GetNextWord();
    UShort_t GetNextShort();

    ULong64_t     fBBScalers[kNChannels];        // 'Beam-Beam' scalers for all channels
    ULong64_t     fBGScalers[kNChannels];        // 'Beam-Gas' scalers for all channels
    UInt_t        fScalers[kNScalers];           // Trigger scalers
    UInt_t        fBunchNumbers[kNBunches];      // Bunch numbers for the previous 10 MB events
    UShort_t      fChargeMB[kNChannels][kNBunches]; // ADC counts for all channels for the previous 10 MB events
    Bool_t        fIsIntMB[kNChannels][kNBunches];  // 'Integrator' flag for all channels for the previous 10 MB events
    Bool_t        fIsBBMB[kNChannels][kNBunches];   // 'Beam-Beam' flag for all channels for the previous 10 MB events
    Bool_t        fIsBGMB[kNChannels][kNBunches];   // 'Beam-Gas' for all channels for the previous 10 MB events

    Short_t       fADC[kNChannels][kNEvOfInt];   // ADC counts for all channels and all events of interest
    Bool_t        fIsInt[kNChannels][kNEvOfInt]; // 'Integrator' flag for all channels 
    Bool_t        fIsBB[kNChannels][kNEvOfInt];  // 'Beam-Beam' flag for all channels
    Bool_t        fIsBG[kNChannels][kNEvOfInt];  // 'Beam-Gas' flag for all channels
    Short_t       fTime[kNChannels];             // leading time for all channels - from HPTDC - in HPTDC units
    Short_t       fWidth[kNChannels];            // pulse width for all channels - from HPTDC - in HPTDC units

    UShort_t      fTrigger;        // VZERO trigger inputs
    UShort_t      fTriggerMask;    // VZERO trigger inputs mask

    Int_t         fPosition;       // current position in the raw-data payload
    

    AliRawReader* fRawReader;      // object for reading the raw data

    UChar_t*      fData;           // pointer to raw data payload

    ClassDef(AliVZERORawStream, 0) // class for reading VZERO DDL raw data
};

#endif
Commit	Line	Data
2eb38194	1	#ifndef ALIVZERORAWSTREAM_H
	2	#define ALIVZERORAWSTREAM_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	///////////////////////////////////////////////////////////////////////////////
	7	///
	8	/// This is a class for reading the VZERO DDL raw data
	9	/// The format of the raw data corresponds to the one
	10	/// implemented in AliVZEROBuffer class.
	11	///
1ecef4c5	12	/// PLEASE NOTE that Int_t channel is here the FEE channel from 0 to 63 in the
	13	/// order defined by Yannick Zoccarato which is not the same order as the order
	14	/// defined in aliroot by the naming and numbering conventions.
	15	/// Therefore one has to go from FEE_Channel to AliRoot_Channel using
	16	/// GetOfflineChannel(Int_t channel) when going from Online to Offline !!!
	17	///
2eb38194	18	///////////////////////////////////////////////////////////////////////////////
	19
	20	#include <TObject.h>
db0db003	21	#include <TMath.h>
2eb38194	22
	23	class AliRawReader;
	24
	25	class AliVZERORawStream: public TObject {
	26	public :
	27	AliVZERORawStream(AliRawReader* rawReader);
	28	virtual ~AliVZERORawStream();
	29
bfe07a27	30	virtual void Reset();
	31	virtual Bool_t Next();
	32
	33	// Getters of various scalers and Minimum Bias flags :
	34
	35	ULong64_t GetBBScalers(Int_t channel) const
	36	{ return fBBScalers[channel]; }
	37	ULong64_t GetBGScalers(Int_t channel) const
	38	{ return fBGScalers[channel]; }
	39	UInt_t GetTriggerScalers(Int_t num_scaler) const
	40	{ return fScalers[num_scaler]; }
	41	UInt_t GetBunchNumbersMB(Int_t num_bunch) const
	42	{ return fBunchNumbers[num_bunch]; }
	43	UShort_t GetChargeMB(Int_t channel, Int_t num_bunch) const
	44	{ return fChargeMB[channel][num_bunch]; }
	45	Bool_t GetIntMBFlag(Int_t channel, Int_t num_bunch) const
	46	{ return fIsIntMB[channel][num_bunch]; }
	47	Bool_t GetBBMBFlag(Int_t channel, Int_t num_bunch) const
	48	{ return fIsBBMB[channel][num_bunch]; }
	49	Bool_t GetBGMBFlag(Int_t channel, Int_t num_bunch) const
	50	{ return fIsBGMB[channel][num_bunch]; }
	51
	52	// Getters of ADC signals, ADC pedestals, time information and corresponding flags :
	53
1d51e5e5	54	Short_t GetADC(Int_t channel) const
db0db003	55	{ return TMath::MaxElement(kNEvOfInt, fADC[channel]); } // maximum value instead of central clock
	56	// { return fADC[channel][kNEvOfInt/2]; }
	57
1d51e5e5	58	Short_t GetPedestal(Int_t channel, Int_t event) const
8094d3d3	59	{ return fADC[channel][event]; }
bfe07a27	60	Bool_t GetIntegratorFlag(Int_t channel, Int_t event) const
	61	{ return fIsInt[channel][event]; }
	62	Bool_t GetBBFlag(Int_t channel, Int_t event) const
	63	{ return fIsBB[channel][event]; }
	64	Bool_t GetBGFlag(Int_t channel, Int_t event) const
	65	{ return fIsBG[channel][event]; }
1d51e5e5	66	Short_t GetTime(Int_t channel) const
726d762c	67	{ return fTime[channel]; }
1d51e5e5	68	Short_t GetWidth(Int_t channel) const
a83ba31a	69	{ return fWidth[channel]; }
726d762c	70
b090e6a3	71	UShort_t GetTriggerInputs() const
	72	{ return fTrigger; }
	73	UShort_t GetTriggerInputsMask() const
	74	{ return fTriggerMask; }
	75
1ecef4c5	76	// Getter of Offline Channel number as used in aliroot (defined by aliroot
	77	// numbering convention) from FEE channel (electronic channel number given
	78	// by the V0 electronics readout) - See comment above -
	79
	80	Int_t GetOfflineChannel(Int_t channel) const
	81	{ Int_t fOfflineChannel[64] = {39, 38, 37, 36, 35, 34, 33, 32,
	82	47, 46, 45, 44, 43, 42, 41, 40,
	83	55, 54, 53, 52, 51, 50, 49, 48,
	84	63, 62, 61, 60, 59, 58, 57, 56,
	85	7, 6, 5, 4, 3, 2, 1, 0,
	86	15, 14, 13, 12, 11, 10, 9, 8,
	87	23, 22, 21, 20, 19, 18, 17, 16,
	88	31, 30, 29, 28, 27, 26, 25, 24};
	89	return fOfflineChannel[channel]; }
	90
726d762c	91	enum EVZERORawDataParams {
1ecef4c5	92	kNChannels = 64, // number of electronic channels in V0 (FEE numbering)
bfe07a27	93	kNEvOfInt = 21, // number of events of interest
	94	kNScalers = 16, // number of scalers
	95	kNBunches = 10 // number of bunches used in Minimum Bias information
726d762c	96	};
2eb38194	97
	98	enum EVZERORawStreamError {
	99	kRawDataSizeErr = 1
	100	};
	101
	102	private:
	103
	104	AliVZERORawStream(const AliVZERORawStream& stream);
	105	AliVZERORawStream& operator = (const AliVZERORawStream& stream);
	106
726d762c	107	UInt_t GetNextWord();
	108	UShort_t GetNextShort();
	109
bfe07a27	110	ULong64_t fBBScalers[kNChannels]; // 'Beam-Beam' scalers for all channels
	111	ULong64_t fBGScalers[kNChannels]; // 'Beam-Gas' scalers for all channels
	112	UInt_t fScalers[kNScalers]; // Trigger scalers
	113	UInt_t fBunchNumbers[kNBunches]; // Bunch numbers for the previous 10 MB events
	114	UShort_t fChargeMB[kNChannels][kNBunches]; // ADC counts for all channels for the previous 10 MB events
	115	Bool_t fIsIntMB[kNChannels][kNBunches]; // 'Integrator' flag for all channels for the previous 10 MB events
	116	Bool_t fIsBBMB[kNChannels][kNBunches]; // 'Beam-Beam' flag for all channels for the previous 10 MB events
	117	Bool_t fIsBGMB[kNChannels][kNBunches]; // 'Beam-Gas' for all channels for the previous 10 MB events
726d762c	118
1d51e5e5	119	Short_t fADC[kNChannels][kNEvOfInt]; // ADC counts for all channels and all events of interest
bfe07a27	120	Bool_t fIsInt[kNChannels][kNEvOfInt]; // 'Integrator' flag for all channels
	121	Bool_t fIsBB[kNChannels][kNEvOfInt]; // 'Beam-Beam' flag for all channels
	122	Bool_t fIsBG[kNChannels][kNEvOfInt]; // 'Beam-Gas' flag for all channels
1d51e5e5	123	Short_t fTime[kNChannels]; // leading time for all channels - from HPTDC - in HPTDC units
1d51e5e5	124	Short_t fWidth[kNChannels]; // pulse width for all channels - from HPTDC - in HPTDC units
2eb38194	125
bfe07a27	126	UShort_t fTrigger; // VZERO trigger inputs
bfe07a27	127	UShort_t fTriggerMask; // VZERO trigger inputs mask
2eb38194	128
bfe07a27	129	Int_t fPosition; // current position in the raw-data payload
1ecef4c5	130
2eb38194	131
bfe07a27	132	AliRawReader* fRawReader; // object for reading the raw data
2eb38194	133
bfe07a27	134	UChar_t* fData; // pointer to raw data payload
2eb38194	135
	136	ClassDef(AliVZERORawStream, 0) // class for reading VZERO DDL raw data
	137	};
	138
	139	#endif