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

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

///////////////////////////////////////////////////////////////////////////////
///
/// 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. 
///
///////////////////////////////////////////////////////////////////////////////

#include "AliVZERORawStream.h"
#include "AliRawReader.h"
#include "AliLog.h"
#include "AliDAQ.h"

ClassImp(AliVZERORawStream)

//_____________________________________________________________________________
AliVZERORawStream::AliVZERORawStream(AliRawReader* rawReader) :
  fTrigger(0),
  fTriggerMask(0),
  fPosition(-1),
  fRawReader(rawReader),
  fData(NULL)
{
  // create an object to read VZERO raw data
  //
  // select the raw data corresponding to
  // the VZERO detector id
  fRawReader->Reset();
  AliDebug(1,Form("Selecting raw data for detector %d",AliDAQ::DetectorID("VZERO")));
  fRawReader->Select("VZERO");

  // Initalize the containers
  for(Int_t i = 0; i < kNChannels; i++) {
    fTime[i] = fWidth[i] = 0.;
    for(Int_t j = 0; j < kNEvOfInt; j++) {
      fADC[i][j] = 0.;
      fIsInt[i][j] = fIsBB[i][j] = fIsBG[i][j] = kFALSE;
    }
    fBBScalers[i] = fBGScalers[i] = 0;
    for(Int_t j = 0; j < kNBunches; j++) {
      fChargeMB[i][j] = 0;
      fIsIntMB[i][j] = fIsBBMB[i][j] = fIsBGMB[i][j] = kFALSE;
    }
  }
  for(Int_t i = 0; i < kNScalers; i++) fScalers[i] = 0;
  for(Int_t i = 0; i < kNBunches; i++) fBunchNumbers[i] = 0;
}

//_____________________________________________________________________________
AliVZERORawStream::~AliVZERORawStream()
{
  // destructor
}

//_____________________________________________________________________________
void AliVZERORawStream::Reset()
{
  // reset raw stream params

  // Reinitalize the containers
  for(Int_t i = 0; i < kNChannels; i++) {
    fTime[i] = fWidth[i] = 0.;
    for(Int_t j = 0; j < kNEvOfInt; j++) {
      fADC[i][j] = 0.;
      fIsInt[i][j] = fIsBB[i][j] = fIsBG[i][j] = kFALSE;
    }
    fBBScalers[i] = fBGScalers[i] = 0;
    for(Int_t j = 0; j < kNBunches; j++) {
      fChargeMB[i][j] = 0;
      fIsIntMB[i][j] = fIsBBMB[i][j] = fIsBGMB[i][j] = kFALSE;
    }
  }
  for(Int_t i = 0; i < kNScalers; i++) fScalers[i] = 0;
  for(Int_t i = 0; i < kNBunches; i++) fBunchNumbers[i] = 0;

  fTrigger = fTriggerMask = 0;
  fPosition = -1;
  fData = NULL;

  if (fRawReader) fRawReader->Reset();
}

//_____________________________________________________________________________
Bool_t AliVZERORawStream::Next()
{
  // read next digit from the VZERO raw data stream
  // return kFALSE in case of error or no digits left

  if (fPosition >= 0) return kFALSE;

  if (!fRawReader->ReadNextData(fData)) return kFALSE;
  if (fRawReader->GetDataSize() == 0) return kFALSE;
     
  if (fRawReader->GetDataSize() != 5936) {
     fRawReader->AddFatalErrorLog(kRawDataSizeErr,Form("size %d != 5936",fRawReader->GetDataSize()));
     AliWarning(Form("Wrong VZERO raw data size: %d, expected 5936 bytes!",fRawReader->GetDataSize()));
     return kFALSE;
  }

  fPosition = 0;

  fTrigger = GetNextWord() & 0xffff;
  fTriggerMask = GetNextWord() & 0xffff;

  for(Int_t iScaler = 0; iScaler < kNScalers; iScaler++)
     fScalers[iScaler] = GetNextWord();

  for(Int_t iBunch = 0; iBunch < kNBunches; iBunch++)
     fBunchNumbers[iBunch] = GetNextWord();
 
  for (Int_t  iCIU = 0; iCIU < 8; iCIU++) { 
 
  // decoding of one Channel Interface Unit numbered iCIU - there are 8 channels per CIU (and 8 CIUs) :
  
    for (Int_t iChannel_Offset = iCIU*8; iChannel_Offset < (iCIU*8)+8; iChannel_Offset=iChannel_Offset+4) { 
      for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
        for(Int_t iEvOfInt = 0; iEvOfInt < kNEvOfInt; iEvOfInt++) {
          UShort_t data = GetNextShort();
          fADC[iChannel][iEvOfInt] = Float_t (data & 0x3ff);
          fIsInt[iChannel][iEvOfInt] = (data >> 10) & 0x1;
        }
      }
      for(Int_t iEvOfInt = 0; iEvOfInt < kNEvOfInt; iEvOfInt=iEvOfInt+2) {
        UShort_t data = GetNextShort();
        for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {          
          fIsBB[iChannel][iEvOfInt] = (data >>  2*(iChannel-iChannel_Offset)) & 0x1;
          fIsBG[iChannel][iEvOfInt] = (data >> (2*(iChannel-iChannel_Offset)+1)) & 0x1; 
	  if(iEvOfInt < (kNEvOfInt - 1)) {      
             fIsBB[iChannel][iEvOfInt+1] = (data >> (8+ 2*(iChannel-iChannel_Offset))) & 0x1;
             fIsBG[iChannel][iEvOfInt+1] = (data >> (8+ 2*(iChannel-iChannel_Offset)+1)) & 0x1;
	  }
        }
      }

      GetNextShort();

      for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
        for(Int_t iBunch = 0; iBunch < kNBunches; iBunch++) {
          UShort_t data = GetNextShort();
          fChargeMB[iChannel][iBunch] = data & 0x3ff;
          fIsIntMB[iChannel][iBunch] = (data >> 10) & 0x1;
        } 
      }
   
      for(Int_t iBunch = 0; iBunch < kNBunches; iBunch=iBunch+2) {
        UShort_t data = GetNextShort();
        for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {  
          fIsBBMB[iChannel][iBunch] = (data >>  2*iBunch) & 0x1;
          fIsBGMB[iChannel][iBunch] = (data >> (2*iBunch+1)) & 0x1;
	  if(iBunch < (kNBunches - 1)) {
             fIsBBMB[iChannel][iBunch+1] = (data >> (8+2*iBunch)) & 0x1;
             fIsBGMB[iChannel][iBunch+1] = (data >> (8+2*iBunch+1)) & 0x1;
	  }	  
        }
      }
  
      GetNextShort();
   
      for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
        fBBScalers[iChannel] = ((ULong64_t)GetNextWord()) << 32;
        fBBScalers[iChannel] |= GetNextWord();
        fBGScalers[iChannel] = ((ULong64_t)GetNextWord()) << 32;
        fBGScalers[iChannel] |= GetNextWord();
      }

    } 

//    for(Int_t iChannel = iCIU*8; iChannel < (iCIU*8) + 8; iChannel++) { 
//    In fact times are stored the other way around in raw data...
      for(Int_t iChannel = (iCIU*8) + 7; iChannel >= iCIU*8; iChannel--) { 
        UInt_t time = GetNextWord();
      	Float_t coarse1  = 25. * ((time >> 8) & 0xf );
	Float_t coarse2  = 25. / 8. * ((time >> 5) & 0x7 );
	Float_t fine     = 25. / 256. * (time & 0x1f);
	// fTime[iChannel] = time & 0xfff;
	fTime[iChannel]  = coarse1 + coarse2 + fine;
	fWidth[iChannel] = 0.4 * ( (time >> 12) & 0x7f);   // HPTDC used in pairing mode
    }
    
    // End of decoding of one CIU card
    // printf("Number of bytes used at end of reading CIU card number %d %d \n\n", iCIU+1, fPosition); 
    
  } // end of decoding the eight CIUs
    
  return kTRUE;
}

//_____________________________________________________________________________
UInt_t AliVZERORawStream::GetNextWord()
{
  // This method returns the next 32 bit word
  // inside the raw data payload.
  // The method is supposed to be endian (platform)
  // independent.
  if (!fData || fPosition < 0) AliFatal("Raw data payload buffer is not yet initialized !");

  UInt_t word = 0;
  word |= fData[fPosition++];
  word |= fData[fPosition++] << 8;
  word |= fData[fPosition++] << 16;
  word |= fData[fPosition++] << 24;

  return word;
}

//_____________________________________________________________________________
UShort_t AliVZERORawStream::GetNextShort()
{
  // This method returns the next 16 bit word
  // inside the raw data payload.
  // The method is supposed to be endian (platform)
  // independent.
  if (!fData || fPosition < 0) AliFatal("Raw data payload buffer is not yet initialized !");

  UShort_t word = 0;
  word |= fData[fPosition++];
  word |= fData[fPosition++] << 8;

  return word;
}
Commit	Line	Data
2eb38194	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	///////////////////////////////////////////////////////////////////////////////
	17	///
	18	/// This is a class for reading the VZERO DDL raw data
	19	/// The format of the raw data corresponds to the one
e6bc1a67	20	/// implemented in AliVZEROBuffer class.
2eb38194	21	///
	22	///////////////////////////////////////////////////////////////////////////////
	23
	24	#include "AliVZERORawStream.h"
	25	#include "AliRawReader.h"
	26	#include "AliLog.h"
	27	#include "AliDAQ.h"
	28
	29	ClassImp(AliVZERORawStream)
	30
	31	//_____________________________________________________________________________
	32	AliVZERORawStream::AliVZERORawStream(AliRawReader* rawReader) :
726d762c	33	fTrigger(0),
726d762c	34	fTriggerMask(0),
2eb38194	35	fPosition(-1),
	36	fRawReader(rawReader),
	37	fData(NULL)
	38	{
	39	// create an object to read VZERO raw data
	40	//
	41	// select the raw data corresponding to
	42	// the VZERO detector id
	43	fRawReader->Reset();
	44	AliDebug(1,Form("Selecting raw data for detector %d",AliDAQ::DetectorID("VZERO")));
	45	fRawReader->Select("VZERO");
726d762c	46
	47	// Initalize the containers
	48	for(Int_t i = 0; i < kNChannels; i++) {
db0db003	49	fTime[i] = fWidth[i] = 0.;
726d762c	50	for(Int_t j = 0; j < kNEvOfInt; j++) {
db0db003	51	fADC[i][j] = 0.;
726d762c	52	fIsInt[i][j] = fIsBB[i][j] = fIsBG[i][j] = kFALSE;
	53	}
	54	fBBScalers[i] = fBGScalers[i] = 0;
	55	for(Int_t j = 0; j < kNBunches; j++) {
	56	fChargeMB[i][j] = 0;
	57	fIsIntMB[i][j] = fIsBBMB[i][j] = fIsBGMB[i][j] = kFALSE;
	58	}
	59	}
	60	for(Int_t i = 0; i < kNScalers; i++) fScalers[i] = 0;
	61	for(Int_t i = 0; i < kNBunches; i++) fBunchNumbers[i] = 0;
2eb38194	62	}
	63
	64	//_____________________________________________________________________________
	65	AliVZERORawStream::~AliVZERORawStream()
	66	{
	67	// destructor
	68	}
	69
	70	//_____________________________________________________________________________
	71	void AliVZERORawStream::Reset()
	72	{
	73	// reset raw stream params
	74
726d762c	75	// Reinitalize the containers
726d762c	76	for(Int_t i = 0; i < kNChannels; i++) {
db0db003	77	fTime[i] = fWidth[i] = 0.;
726d762c	78	for(Int_t j = 0; j < kNEvOfInt; j++) {
db0db003	79	fADC[i][j] = 0.;
726d762c	80	fIsInt[i][j] = fIsBB[i][j] = fIsBG[i][j] = kFALSE;
	81	}
	82	fBBScalers[i] = fBGScalers[i] = 0;
	83	for(Int_t j = 0; j < kNBunches; j++) {
	84	fChargeMB[i][j] = 0;
	85	fIsIntMB[i][j] = fIsBBMB[i][j] = fIsBGMB[i][j] = kFALSE;
	86	}
	87	}
	88	for(Int_t i = 0; i < kNScalers; i++) fScalers[i] = 0;
	89	for(Int_t i = 0; i < kNBunches; i++) fBunchNumbers[i] = 0;
	90
	91	fTrigger = fTriggerMask = 0;
	92	fPosition = -1;
	93	fData = NULL;
2eb38194	94
	95	if (fRawReader) fRawReader->Reset();
	96	}
	97
	98	//_____________________________________________________________________________
	99	Bool_t AliVZERORawStream::Next()
	100	{
	101	// read next digit from the VZERO raw data stream
	102	// return kFALSE in case of error or no digits left
	103
726d762c	104	if (fPosition >= 0) return kFALSE;
	105
	106	if (!fRawReader->ReadNextData(fData)) return kFALSE;
	107	if (fRawReader->GetDataSize() == 0) return kFALSE;
e6bc1a67	108
	109	if (fRawReader->GetDataSize() != 5936) {
	110	fRawReader->AddFatalErrorLog(kRawDataSizeErr,Form("size %d != 5936",fRawReader->GetDataSize()));
	111	AliWarning(Form("Wrong VZERO raw data size: %d, expected 5936 bytes!",fRawReader->GetDataSize()));
	112	return kFALSE;
726d762c	113	}
	114
	115	fPosition = 0;
	116
	117	fTrigger = GetNextWord() & 0xffff;
	118	fTriggerMask = GetNextWord() & 0xffff;
	119
726d762c	120	for(Int_t iScaler = 0; iScaler < kNScalers; iScaler++)
e6bc1a67	121	fScalers[iScaler] = GetNextWord();
726d762c	122
726d762c	123	for(Int_t iBunch = 0; iBunch < kNBunches; iBunch++)
e6bc1a67	124	fBunchNumbers[iBunch] = GetNextWord();
	125
	126	for (Int_t iCIU = 0; iCIU < 8; iCIU++) {
	127
	128	// decoding of one Channel Interface Unit numbered iCIU - there are 8 channels per CIU (and 8 CIUs) :
726d762c	129
e6bc1a67	130	for (Int_t iChannel_Offset = iCIU8; iChannel_Offset < (iCIU8)+8; iChannel_Offset=iChannel_Offset+4) {
	131	for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
	132	for(Int_t iEvOfInt = 0; iEvOfInt < kNEvOfInt; iEvOfInt++) {
	133	UShort_t data = GetNextShort();
db0db003	134	fADC[iChannel][iEvOfInt] = Float_t (data & 0x3ff);
e6bc1a67	135	fIsInt[iChannel][iEvOfInt] = (data >> 10) & 0x1;
	136	}
	137	}
	138	for(Int_t iEvOfInt = 0; iEvOfInt < kNEvOfInt; iEvOfInt=iEvOfInt+2) {
	139	UShort_t data = GetNextShort();
	140	for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
6f27a54e	141	fIsBB[iChannel][iEvOfInt] = (data >> 2*(iChannel-iChannel_Offset)) & 0x1;
6f27a54e	142	fIsBG[iChannel][iEvOfInt] = (data >> (2*(iChannel-iChannel_Offset)+1)) & 0x1;
a346d69a	143	if(iEvOfInt < (kNEvOfInt - 1)) {
	144	fIsBB[iChannel][iEvOfInt+1] = (data >> (8+ 2*(iChannel-iChannel_Offset))) & 0x1;
	145	fIsBG[iChannel][iEvOfInt+1] = (data >> (8+ 2*(iChannel-iChannel_Offset)+1)) & 0x1;
	146	}
e6bc1a67	147	}
	148	}
	149
	150	GetNextShort();
	151
	152	for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
	153	for(Int_t iBunch = 0; iBunch < kNBunches; iBunch++) {
	154	UShort_t data = GetNextShort();
	155	fChargeMB[iChannel][iBunch] = data & 0x3ff;
	156	fIsIntMB[iChannel][iBunch] = (data >> 10) & 0x1;
	157	}
	158	}
	159
	160	for(Int_t iBunch = 0; iBunch < kNBunches; iBunch=iBunch+2) {
	161	UShort_t data = GetNextShort();
	162	for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
6f27a54e	163	fIsBBMB[iChannel][iBunch] = (data >> 2*iBunch) & 0x1;
6f27a54e	164	fIsBGMB[iChannel][iBunch] = (data >> (2*iBunch+1)) & 0x1;
a346d69a	165	if(iBunch < (kNBunches - 1)) {
	166	fIsBBMB[iChannel][iBunch+1] = (data >> (8+2*iBunch)) & 0x1;
	167	fIsBGMB[iChannel][iBunch+1] = (data >> (8+2*iBunch+1)) & 0x1;
	168	}
e6bc1a67	169	}
	170	}
	171
	172	GetNextShort();
	173
	174	for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
	175	fBBScalers[iChannel] = ((ULong64_t)GetNextWord()) << 32;
	176	fBBScalers[iChannel] \|= GetNextWord();
	177	fBGScalers[iChannel] = ((ULong64_t)GetNextWord()) << 32;
	178	fBGScalers[iChannel] \|= GetNextWord();
	179	}
	180
	181	}
	182
db0db003	183	// for(Int_t iChannel = iCIU8; iChannel < (iCIU8) + 8; iChannel++) {
	184	// In fact times are stored the other way around in raw data...
	185	for(Int_t iChannel = (iCIU8) + 7; iChannel >= iCIU8; iChannel--) {
	186	UInt_t time = GetNextWord();
	187	Float_t coarse1 = 25. * ((time >> 8) & 0xf );
	188	Float_t coarse2 = 25. / 8. * ((time >> 5) & 0x7 );
	189	Float_t fine = 25. / 256. * (time & 0x1f);
	190	// fTime[iChannel] = time & 0xfff;
	191	fTime[iChannel] = coarse1 + coarse2 + fine;
e58b4e66	192	fWidth[iChannel] = 0.4 * ( (time >> 12) & 0x7f); // HPTDC used in pairing mode
e6bc1a67	193	}
	194
	195	// End of decoding of one CIU card
	196	// printf("Number of bytes used at end of reading CIU card number %d %d \n\n", iCIU+1, fPosition);
	197
	198	} // end of decoding the eight CIUs
	199
2eb38194	200	return kTRUE;
	201	}
	202
	203	//_____________________________________________________________________________
726d762c	204	UInt_t AliVZERORawStream::GetNextWord()
2eb38194	205	{
	206	// This method returns the next 32 bit word
	207	// inside the raw data payload.
	208	// The method is supposed to be endian (platform)
	209	// independent.
	210	if (!fData \|\| fPosition < 0) AliFatal("Raw data payload buffer is not yet initialized !");
	211
726d762c	212	UInt_t word = 0;
2eb38194	213	word \|= fData[fPosition++];
	214	word \|= fData[fPosition++] << 8;
	215	word \|= fData[fPosition++] << 16;
	216	word \|= fData[fPosition++] << 24;
	217
	218	return word;
	219	}
726d762c	220
	221	//_____________________________________________________________________________
	222	UShort_t AliVZERORawStream::GetNextShort()
	223	{
	224	// This method returns the next 16 bit word
	225	// inside the raw data payload.
	226	// The method is supposed to be endian (platform)
	227	// independent.
	228	if (!fData \|\| fPosition < 0) AliFatal("Raw data payload buffer is not yet initialized !");
	229
	230	UShort_t word = 0;
	231	word \|= fData[fPosition++];
	232	word \|= fData[fPosition++] << 8;
	233
	234	return word;
	235	}