[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:                                //
// - DDL identifier with the 4 more significant bits     = 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
  fDDLModuleMap=new AliITSDDLModuleMapSDD();
  fDDLModuleMap->SetDefaultMap();
  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 when a digit is found
// returns kTRUE and fCompletedModule=kTRUE  when a module is completed 


//  UInt_t masksod=8;    // start of DDL 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);
      fCompletedModule=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;
      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: //
	56	// - DDL identifier with the 4 more significant bits = 1000 //
	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
84	fDDLModuleMap=new AliITSDDLModuleMapSDD();
85	fDDLModuleMap->SetDefaultMap();
86	for(Int_t im=0;im<kSDDModules;im++){
87	fLowThresholdArray[im][0]=0;
88	fLowThresholdArray[im][1]=0;
89	}
90	fRawReader->Reset();
91	fRawReader->Select("ITSSDD");
92
93
94	}
95
96	//______________________________________________________________________
97	AliITSRawStreamSDDCompressed::AliITSRawStreamSDDCompressed(const AliITSRawStreamSDDCompressed& rs) :
98	AliITSRawStream(rs.fRawReader),
99	fDDLModuleMap(rs.fDDLModuleMap),
100	fData(0),
101	fCarlosId(-1),
102	fChannel(0),
103	fJitter(0),
104	fDDL(0)
105	{
106	// copy constructor
107	AliError("Copy constructor should not be used.");
108	}
109	//__________________________________________________________________________
110	AliITSRawStreamSDDCompressed& AliITSRawStreamSDDCompressed::operator=(const AliITSRawStreamSDDCompressed& rs) {
111	// assignment operator
112	if (this!=&rs) {}
113	AliError("Assignment opertator should not be used.");
114	return *this;
115	}
116
117	//______________________________________________________________________
118	AliITSRawStreamSDDCompressed::~AliITSRawStreamSDDCompressed(){
119	if(fDDLModuleMap) delete fDDLModuleMap;
120	}
121
122
6297cc01	123	//______________________________________________________________________
	124	Int_t AliITSRawStreamSDDCompressed::DecompAmbra(Int_t value) const
	125	{
	126	// AMBRA decompression (from 8 to 10 bit)
	127
	128	if ((value & 0x80) == 0) {
	129	return value & 0x7f;
	130	} else if ((value & 0x40) == 0) {
	131	return 0x081 + ((value & 0x3f) << 1);
	132	} else if ((value & 0x20) == 0) {
	133	return 0x104 + ((value & 0x1f) << 3);
	134	} else {
	135	return 0x208 + ((value & 0x1f) << 4);
	136	}
	137
	138	}
7765ca40	139	//______________________________________________________________________
	140	Bool_t AliITSRawStreamSDDCompressed::Next()
	141	{
	142	// read the next raw digit
	143	// returns kFALSE if there is no digit left
	144	// returns kTRUE and fCompletedModule=kFALSE when a digit is found
	145	// returns kTRUE and fCompletedModule=kTRUE when a module is completed
	146
f7bcb379	147
f7bcb379	148	// UInt_t masksod=8; // start of DDL has the 4 most significant bits = 1000
7765ca40	149	UInt_t maskeom=15; // end of module has the 4 most significant bits = 1111
7765ca40	150	UInt_t maskmod=15; // last 4 bits for module number in end of module word
f7bcb379	151	// UInt_t maskDDL=0xFF; // last 8 bits for DDL number in start of DDL word
f7bcb379	152
7765ca40	153	UInt_t maskCarlos=15<<27; // 4 bits (27-30) for CarlosId in data word
	154	UInt_t maskSide=1<<26; // 1 bit (26) for side in data word
	155	UInt_t maskAnode=255<<18; // 8 bits (18-25) for Nanode in data word
	156	UInt_t maskTb=255<<10; // 8 bits (10-27) for Ntimebin in data word
	157	UInt_t maskADC=1023; // 10 bits (0-9) for ADC in data word
f7bcb379	158
f7bcb379	159	while(kTRUE){
f7bcb379	160	if (!fRawReader->ReadNextInt(fData)) return kFALSE; // read next word
	161	UInt_t mostsigbits=fData>>28;
	162	if(mostsigbits==maskeom){
	163	fCarlosId=fData&maskmod;
cb6d8373	164	fDDL=fRawReader->GetDDLID();
f7bcb379	165	fModuleID = GetModuleNumber(fDDL,fCarlosId);
	166	fCompletedModule=kTRUE;
	167	return kTRUE;
	168	}else{
	169	fCarlosId=(fData&maskCarlos)>>27;
cb6d8373	170	fDDL=fRawReader->GetDDLID();
f7bcb379	171	fModuleID = GetModuleNumber(fDDL,fCarlosId);
	172	fChannel=(fData&maskSide)>>26;
	173	fCoord1=(fData&maskAnode)>>18;
	174	fCoord2=(fData&maskTb)>>10;
6297cc01	175	Int_t sig8bit=fData&maskADC;
	176	sig8bit+=fLowThresholdArray[fModuleID-kSPDModules][fChannel];
	177	fSignal=DecompAmbra(sig8bit);
f7bcb379	178	fCompletedModule=kFALSE;
	179	return kTRUE;
	180	}
7765ca40	181	}
	182	return kFALSE;
	183	}
	184
	185