[u/mrichter/AliRoot.git] / ITS / AliITSRawStreamSDDCompressed.cxx

/**************************************************************************
 * Copyright(c) 2007-2009, 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.                  *
 **************************************************************************/

/* $Id $*/

///////////////////////////////////////////////////////////////////
//                                                               //
// Class to decode compressed SDD Raw Data format                //
// The 32 bits for a data word are defined as follows:           //
//   31 control bit (0=data word, 1= control word)               //
//   30 -                                                        //
//   29  |                                                       //
//   28  |-> 4 bits to identify the Carlos (0-11) inside the DDL //
//   27 -                                                        //
//   26 detecot side (0= left, =right)                           //
//   25 -                                                        //
//   24  |                                                       //
//   23  |                                                       //
//   22  |                                                       //
//   21  |-> 8 bits to identify the anode number (0-255)         //
//   20  |                                                       //
//   19  |                                                       //
//   18 -                                                        //
//   17 -                                                        //
//   16  |                                                       //
//   15  |                                                       //
//   14  |                                                       //
//   13  |-> 8 bits to identify the time bin (0-255)             //
//   12  |                                                       //
//   11  |                                                       //
//   10 -                                                        //
//    9 -                                                        //
//    8  |                                                       //
//    7  |                                                       //
//    6  |                                                       //
//    5  |                                                       //
//    4  |-> 10 bit for the ADC counts                           //
//    3  |                                                       //
//    2  |                                                       //
//    1  |                                                       //
//    0 -                                                        //
//                                                               //
// Plus 2 types of control words:                                //
// - Jitter word     = 1000                                      //
// - End of module data (needed by the Cluster Finder)   = 1111  //
//                                                               //
// Origin: F.Prino, Torino, prino@to.infn.it                     //
//                                                               //
///////////////////////////////////////////////////////////////////


#include "AliITSRawStreamSDDCompressed.h"
#include "AliRawReader.h"
#include "AliLog.h"

ClassImp(AliITSRawStreamSDDCompressed)
  

//______________________________________________________________________
AliITSRawStreamSDDCompressed::AliITSRawStreamSDDCompressed(AliRawReader* rawReader) :
  AliITSRawStream(rawReader),
fDDLModuleMap(0),
fData(0),
fCarlosId(-1),
fChannel(0),
fJitter(0),
fDDL(0)
{
// create an object to read ITS SDD raw digits
  for(Int_t im=0;im<kSDDModules;im++){
    fLowThresholdArray[im][0]=0;
    fLowThresholdArray[im][1]=0;
  }
  fRawReader->Reset();
  fRawReader->Select("ITSSDD");


}

//______________________________________________________________________
AliITSRawStreamSDDCompressed::AliITSRawStreamSDDCompressed(const AliITSRawStreamSDDCompressed& rs) :
AliITSRawStream(rs.fRawReader),
fDDLModuleMap(rs.fDDLModuleMap),
fData(0),
fCarlosId(-1),
fChannel(0),
fJitter(0),
fDDL(0)
{
  // copy constructor
  AliError("Copy constructor should not be used.");
}
//__________________________________________________________________________
AliITSRawStreamSDDCompressed& AliITSRawStreamSDDCompressed::operator=(const AliITSRawStreamSDDCompressed& rs) {
  // assignment operator
  if (this!=&rs) {}
  AliError("Assignment opertator should not be used.");
  return *this;
}

//______________________________________________________________________
AliITSRawStreamSDDCompressed::~AliITSRawStreamSDDCompressed(){
  if(fDDLModuleMap) delete fDDLModuleMap;
}


//______________________________________________________________________
Int_t AliITSRawStreamSDDCompressed::DecompAmbra(Int_t value) const
{
  // AMBRA decompression (from 8 to 10 bit)
  
  if ((value & 0x80) == 0) {
    return value & 0x7f;
  } else if ((value & 0x40) == 0) {
    return 0x081 + ((value & 0x3f) << 1);
  } else if ((value & 0x20) == 0) {
    return 0x104 + ((value & 0x1f) << 3);
  } else {
    return 0x208 + ((value & 0x1f) << 4);
  }
  
}
//______________________________________________________________________
Bool_t AliITSRawStreamSDDCompressed::Next()
{
// read the next raw digit
// returns kFALSE if there is no digit left
// returns kTRUE and fCompletedModule=kFALSE and fCompletedDDL=kFALSE when a digit is found
// returns kTRUE and fCompletedModule=kTRUE  and fCompletedDDL=kFALSE when a module is completed (=3x3FFFFFFF footer words)
// returns kTRUE and fCompletedModule=kFALSE and fCompletedDDL=kTRUE  when a DDL is completed (=jitter word)


  UInt_t maskjit=8;    // Jitter word has the 4 most significant bits = 1000
  UInt_t maskeom=15;   // end of module has the 4 most significant bits = 1111
  UInt_t maskmod=15;   // last 4 bits for module number in end of module word
  //  UInt_t maskDDL=0xFF; // last 8 bits for DDL number in start of DDL word
    
  UInt_t maskCarlos=15<<27; // 4 bits  (27-30) for CarlosId in data word
  UInt_t maskSide=1<<26;    // 1 bit   (26)    for side     in data word
  UInt_t maskAnode=255<<18; // 8 bits  (18-25) for Nanode   in data word
  UInt_t maskTb=255<<10;    // 8 bits  (10-27) for Ntimebin in data word
  UInt_t maskADC=1023;      // 10 bits (0-9)   for ADC      in data word
    
  while(kTRUE){
    if (!fRawReader->ReadNextInt(fData)) return kFALSE;  // read next word
    UInt_t mostsigbits=fData>>28; 
    if(mostsigbits==maskeom){
      fCarlosId=fData&maskmod;
      fDDL=fRawReader->GetDDLID();
      fModuleID = GetModuleNumber(fDDL,fCarlosId);
      fCompletedDDL=kFALSE;
      fCompletedModule=kTRUE;
      return kTRUE;
    } else if(mostsigbits==maskjit){
      fJitter = fData&0x000000ff;      
      fCompletedModule=kFALSE;
      fCompletedDDL=kTRUE;
      return kTRUE;
    }else{
      fCarlosId=(fData&maskCarlos)>>27;
      fDDL=fRawReader->GetDDLID();
      fModuleID = GetModuleNumber(fDDL,fCarlosId);
      fChannel=(fData&maskSide)>>26;
      fCoord1=(fData&maskAnode)>>18;
      fCoord2=(fData&maskTb)>>10;
      Int_t sig8bit=fData&maskADC;
      sig8bit+=fLowThresholdArray[fModuleID-kSPDModules][fChannel];
      fSignal=DecompAmbra(sig8bit);
      fCompletedModule=kFALSE;
      fCompletedDDL=kFALSE;
      return kTRUE;
    }
  }
  return kFALSE;
}
Commit	Line	Data
7765ca40	1	/**************************************************************************
	2	* Copyright(c) 2007-2009, 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	/* $Id $*/
	17
	18	///////////////////////////////////////////////////////////////////
	19	// //
	20	// Class to decode compressed SDD Raw Data format //
	21	// The 32 bits for a data word are defined as follows: //
	22	// 31 control bit (0=data word, 1= control word) //
	23	// 30 - //
	24	// 29 \| //
	25	// 28 \|-> 4 bits to identify the Carlos (0-11) inside the DDL //
	26	// 27 - //
	27	// 26 detecot side (0= left, =right) //
	28	// 25 - //
	29	// 24 \| //
	30	// 23 \| //
	31	// 22 \| //
	32	// 21 \|-> 8 bits to identify the anode number (0-255) //
	33	// 20 \| //
	34	// 19 \| //
	35	// 18 - //
	36	// 17 - //
	37	// 16 \| //
	38	// 15 \| //
	39	// 14 \| //
	40	// 13 \|-> 8 bits to identify the time bin (0-255) //
	41	// 12 \| //
	42	// 11 \| //
	43	// 10 - //
	44	// 9 - //
	45	// 8 \| //
	46	// 7 \| //
	47	// 6 \| //
	48	// 5 \| //
	49	// 4 \|-> 10 bit for the ADC counts //
	50	// 3 \| //
	51	// 2 \| //
	52	// 1 \| //
	53	// 0 - //
	54	// //
	55	// Plus 2 types of control words: //
de075dae	56	// - Jitter word = 1000 //
7765ca40	57	// - End of module data (needed by the Cluster Finder) = 1111 //
	58	// //
	59	// Origin: F.Prino, Torino, prino@to.infn.it //
	60	// //
	61	///////////////////////////////////////////////////////////////////
	62
	63
	64
	65	#include "AliITSRawStreamSDDCompressed.h"
	66	#include "AliRawReader.h"
	67	#include "AliLog.h"
	68
	69	ClassImp(AliITSRawStreamSDDCompressed)
	70
	71
	72
	73	//______________________________________________________________________
	74	AliITSRawStreamSDDCompressed::AliITSRawStreamSDDCompressed(AliRawReader* rawReader) :
	75	AliITSRawStream(rawReader),
	76	fDDLModuleMap(0),
	77	fData(0),
	78	fCarlosId(-1),
	79	fChannel(0),
	80	fJitter(0),
	81	fDDL(0)
	82	{
	83	// create an object to read ITS SDD raw digits
7765ca40	84	for(Int_t im=0;im<kSDDModules;im++){
	85	fLowThresholdArray[im][0]=0;
	86	fLowThresholdArray[im][1]=0;
	87	}
	88	fRawReader->Reset();
	89	fRawReader->Select("ITSSDD");
	90
	91
	92	}
	93
	94	//______________________________________________________________________
	95	AliITSRawStreamSDDCompressed::AliITSRawStreamSDDCompressed(const AliITSRawStreamSDDCompressed& rs) :
	96	AliITSRawStream(rs.fRawReader),
	97	fDDLModuleMap(rs.fDDLModuleMap),
	98	fData(0),
	99	fCarlosId(-1),
	100	fChannel(0),
	101	fJitter(0),
	102	fDDL(0)
	103	{
	104	// copy constructor
	105	AliError("Copy constructor should not be used.");
	106	}
	107	//__________________________________________________________________________
	108	AliITSRawStreamSDDCompressed& AliITSRawStreamSDDCompressed::operator=(const AliITSRawStreamSDDCompressed& rs) {
	109	// assignment operator
	110	if (this!=&rs) {}
	111	AliError("Assignment opertator should not be used.");
	112	return *this;
	113	}
	114
	115	//______________________________________________________________________
	116	AliITSRawStreamSDDCompressed::~AliITSRawStreamSDDCompressed(){
	117	if(fDDLModuleMap) delete fDDLModuleMap;
	118	}
	119
	120
6297cc01	121	//______________________________________________________________________
	122	Int_t AliITSRawStreamSDDCompressed::DecompAmbra(Int_t value) const
	123	{
	124	// AMBRA decompression (from 8 to 10 bit)
	125
	126	if ((value & 0x80) == 0) {
	127	return value & 0x7f;
	128	} else if ((value & 0x40) == 0) {
	129	return 0x081 + ((value & 0x3f) << 1);
	130	} else if ((value & 0x20) == 0) {
	131	return 0x104 + ((value & 0x1f) << 3);
	132	} else {
	133	return 0x208 + ((value & 0x1f) << 4);
	134	}
	135
	136	}
7765ca40	137	//______________________________________________________________________
	138	Bool_t AliITSRawStreamSDDCompressed::Next()
	139	{
	140	// read the next raw digit
	141	// returns kFALSE if there is no digit left
de075dae	142	// returns kTRUE and fCompletedModule=kFALSE and fCompletedDDL=kFALSE when a digit is found
	143	// returns kTRUE and fCompletedModule=kTRUE and fCompletedDDL=kFALSE when a module is completed (=3x3FFFFFFF footer words)
	144	// returns kTRUE and fCompletedModule=kFALSE and fCompletedDDL=kTRUE when a DDL is completed (=jitter word)
7765ca40	145
f7bcb379	146
de075dae	147	UInt_t maskjit=8; // Jitter word has the 4 most significant bits = 1000
7765ca40	148	UInt_t maskeom=15; // end of module has the 4 most significant bits = 1111
7765ca40	149	UInt_t maskmod=15; // last 4 bits for module number in end of module word
f7bcb379	150	// UInt_t maskDDL=0xFF; // last 8 bits for DDL number in start of DDL word
f7bcb379	151
7765ca40	152	UInt_t maskCarlos=15<<27; // 4 bits (27-30) for CarlosId in data word
	153	UInt_t maskSide=1<<26; // 1 bit (26) for side in data word
	154	UInt_t maskAnode=255<<18; // 8 bits (18-25) for Nanode in data word
	155	UInt_t maskTb=255<<10; // 8 bits (10-27) for Ntimebin in data word
	156	UInt_t maskADC=1023; // 10 bits (0-9) for ADC in data word
f7bcb379	157
f7bcb379	158	while(kTRUE){
f7bcb379	159	if (!fRawReader->ReadNextInt(fData)) return kFALSE; // read next word
	160	UInt_t mostsigbits=fData>>28;
	161	if(mostsigbits==maskeom){
	162	fCarlosId=fData&maskmod;
cb6d8373	163	fDDL=fRawReader->GetDDLID();
f7bcb379	164	fModuleID = GetModuleNumber(fDDL,fCarlosId);
de075dae	165	fCompletedDDL=kFALSE;
f7bcb379	166	fCompletedModule=kTRUE;
f7bcb379	167	return kTRUE;
de075dae	168	} else if(mostsigbits==maskjit){
	169	fJitter = fData&0x000000ff;
	170	fCompletedModule=kFALSE;
	171	fCompletedDDL=kTRUE;
	172	return kTRUE;
f7bcb379	173	}else{
f7bcb379	174	fCarlosId=(fData&maskCarlos)>>27;
cb6d8373	175	fDDL=fRawReader->GetDDLID();
f7bcb379	176	fModuleID = GetModuleNumber(fDDL,fCarlosId);
	177	fChannel=(fData&maskSide)>>26;
	178	fCoord1=(fData&maskAnode)>>18;
	179	fCoord2=(fData&maskTb)>>10;
6297cc01	180	Int_t sig8bit=fData&maskADC;
	181	sig8bit+=fLowThresholdArray[fModuleID-kSPDModules][fChannel];
	182	fSignal=DecompAmbra(sig8bit);
f7bcb379	183	fCompletedModule=kFALSE;
de075dae	184	fCompletedDDL=kFALSE;
f7bcb379	185	return kTRUE;
f7bcb379	186	}
7765ca40	187	}
	188	return kFALSE;
	189	}
	190
	191