[u/mrichter/AliRoot.git] / ITS / AliITSCompressRawDataSDD.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 the SDD Raw Data from the CarlosRX format to  //
// a compressed format consisting in a word of 32 bit per cell   //
// 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 detecor 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 typs of control words:                                 //
// - End of module data (needed by the Cluster Finder)           //
//       first 4 most significant bits                   = 1111  //
// - Jitter word                                                 //
//       first 4 most significant bits                   = 1000  //
//                                                               //
// Origin: F.Prino, Torino, prino@to.infn.it                     //
//                                                               //
///////////////////////////////////////////////////////////////////

#include"AliLog.h"
#include "AliITSCompressRawDataSDD.h"
#include "AliRawReader.h"
#include "AliRawReaderDate.h"
#include "AliRawReaderRoot.h"
#include "AliITSRawStreamSDD.h"


ClassImp(AliITSCompressRawDataSDD)

AliITSCompressRawDataSDD::AliITSCompressRawDataSDD():
TObject(),
fRawReader(0),
fPointerToData(0),
fSizeInMemory(0)
{
  // default constructor
}
//______________________________________________________________________
AliITSCompressRawDataSDD::~AliITSCompressRawDataSDD(){
  // raw reader is passed from outdside, don't delete it
}
//______________________________________________________________________
UInt_t AliITSCompressRawDataSDD::CompressEvent(UChar_t* inputPtr){
  // Method to be used in HLT
  UInt_t siz=0;
  memcpy(fPointerToData,inputPtr,32); // event header, 8 words
  fPointerToData+=32;
  siz+=32;
  UInt_t word=0;
  AliITSRawStreamSDD s(fRawReader);
  s.SetDecompressAmbra(kFALSE);
  Int_t mask1=0xFF000000;
  Int_t mask2=0x00FF0000;
  Int_t mask3=0x0000FF00;
  Int_t mask4=0x000000FF;
  while(s.Next()){
    if(s.IsCompletedModule()==kTRUE){
      word=UInt_t(15)<<28;
      word+=s.GetCarlosId();
      if(siz+4<fSizeInMemory){
	*(fPointerToData)=(word&mask4);
	++fPointerToData;
	*(fPointerToData)=(word&mask3)>>8;
	++fPointerToData;
	*(fPointerToData)=(word&mask2)>>16;
	++fPointerToData;
	*(fPointerToData)=(word&mask1)>>24;
	++fPointerToData;
	siz+=4;
      }
    }else if(s.IsCompletedDDL()==kTRUE){
      word=UInt_t(8)<<28;
      word+=s.GetJitter();
      if(siz+4<fSizeInMemory){
	*(fPointerToData)=(word&mask4);
	++fPointerToData;
	*(fPointerToData)=(word&mask3)>>8;
	++fPointerToData;
	*(fPointerToData)=(word&mask2)>>16;
	++fPointerToData;
	*(fPointerToData)=(word&mask1)>>24;
	++fPointerToData;
	siz+=4;
      }
    }else{
      word=s.GetCarlosId()<<27;
      word+=s.GetChannel()<<26;
      word+=s.GetCoord1()<<18;
      word+=s.GetCoord2()<<10;
      word+=s.GetEightBitSignal();
      if(siz+4<fSizeInMemory){
	*(fPointerToData)=(word&mask4);
	++fPointerToData;
	*(fPointerToData)=(word&mask3)>>8;
	++fPointerToData;
	*(fPointerToData)=(word&mask2)>>16;
	++fPointerToData;
	*(fPointerToData)=(word&mask1)>>24;
	++fPointerToData;
	siz+=4;
      }
    }
  }
  return siz;
}
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
f7bcb379	16	/* $Id$*/
7765ca40	17
	18	///////////////////////////////////////////////////////////////////
	19	// //
	20	// Class to decode the SDD Raw Data from the CarlosRX format to //
	21	// a compressed format consisting in a word of 32 bit per cell //
	22	// The 32 bits for a data word are defined as follows: //
	23	// 31 control bit (0=data word, 1= control word) //
	24	// 30 - //
	25	// 29 \| //
	26	// 28 \|-> 4 bits to identify the Carlos (0-11) inside the DDL //
	27	// 27 - //
de075dae	28	// 26 detecor side (0= left, =right) //
7765ca40	29	// 25 - //
	30	// 24 \| //
	31	// 23 \| //
	32	// 22 \| //
	33	// 21 \|-> 8 bits to identify the anode number (0-255) //
	34	// 20 \| //
	35	// 19 \| //
	36	// 18 - //
	37	// 17 - //
	38	// 16 \| //
	39	// 15 \| //
	40	// 14 \| //
	41	// 13 \|-> 8 bits to identify the time bin (0-255) //
	42	// 12 \| //
	43	// 11 \| //
	44	// 10 - //
	45	// 9 - //
	46	// 8 \| //
	47	// 7 \| //
	48	// 6 \| //
	49	// 5 \| //
	50	// 4 \|-> 10 bit for the ADC counts //
	51	// 3 \| //
	52	// 2 \| //
	53	// 1 \| //
	54	// 0 - //
	55	// //
de075dae	56	// Plus 2 typs of control words: //
f7bcb379	57	// - End of module data (needed by the Cluster Finder) //
f7bcb379	58	// first 4 most significant bits = 1111 //
de075dae	59	// - Jitter word //
de075dae	60	// first 4 most significant bits = 1000 //
7765ca40	61	// //
	62	// Origin: F.Prino, Torino, prino@to.infn.it //
	63	// //
	64	///////////////////////////////////////////////////////////////////
	65
f7bcb379	66	#include"AliLog.h"
7765ca40	67	#include "AliITSCompressRawDataSDD.h"
	68	#include "AliRawReader.h"
	69	#include "AliRawReaderDate.h"
	70	#include "AliRawReaderRoot.h"
	71	#include "AliITSRawStreamSDD.h"
	72
	73
	74	ClassImp(AliITSCompressRawDataSDD)
	75
f7bcb379	76	AliITSCompressRawDataSDD::AliITSCompressRawDataSDD():
	77	TObject(),
	78	fRawReader(0),
	79	fPointerToData(0),
de075dae	80	fSizeInMemory(0)
f7bcb379	81	{
f7bcb379	82	// default constructor
7765ca40	83	}
f7bcb379	84	//______________________________________________________________________
	85	AliITSCompressRawDataSDD::~AliITSCompressRawDataSDD(){
	86	// raw reader is passed from outdside, don't delete it
	87	}
f7bcb379	88	//______________________________________________________________________
	89	UInt_t AliITSCompressRawDataSDD::CompressEvent(UChar_t* inputPtr){
	90	// Method to be used in HLT
	91	UInt_t siz=0;
	92	memcpy(fPointerToData,inputPtr,32); // event header, 8 words
	93	fPointerToData+=32;
	94	siz+=32;
	95	UInt_t word=0;
	96	AliITSRawStreamSDD s(fRawReader);
6297cc01	97	s.SetDecompressAmbra(kFALSE);
f7bcb379	98	Int_t mask1=0xFF000000;
	99	Int_t mask2=0x00FF0000;
	100	Int_t mask3=0x0000FF00;
	101	Int_t mask4=0x000000FF;
	102	while(s.Next()){
de075dae	103	if(s.IsCompletedModule()==kTRUE){
3ee08066	104	word=UInt_t(15)<<28;
de075dae	105	word+=s.GetCarlosId();
f7bcb379	106	if(siz+4<fSizeInMemory){
2cc6c8fe	107	*(fPointerToData)=(word&mask4);
f7bcb379	108	++fPointerToData;
	109	*(fPointerToData)=(word&mask3)>>8;
	110	++fPointerToData;
2cc6c8fe	111	*(fPointerToData)=(word&mask2)>>16;
	112	++fPointerToData;
	113	*(fPointerToData)=(word&mask1)>>24;
f7bcb379	114	++fPointerToData;
	115	siz+=4;
	116	}
de075dae	117	}else if(s.IsCompletedDDL()==kTRUE){
3ee08066	118	word=UInt_t(8)<<28;
de075dae	119	word+=s.GetJitter();
	120	if(siz+4<fSizeInMemory){
	121	*(fPointerToData)=(word&mask4);
	122	++fPointerToData;
	123	*(fPointerToData)=(word&mask3)>>8;
	124	++fPointerToData;
	125	*(fPointerToData)=(word&mask2)>>16;
	126	++fPointerToData;
	127	*(fPointerToData)=(word&mask1)>>24;
	128	++fPointerToData;
	129	siz+=4;
	130	}
	131	}else{
	132	word=s.GetCarlosId()<<27;
	133	word+=s.GetChannel()<<26;
	134	word+=s.GetCoord1()<<18;
	135	word+=s.GetCoord2()<<10;
	136	word+=s.GetEightBitSignal();
f7bcb379	137	if(siz+4<fSizeInMemory){
2cc6c8fe	138	*(fPointerToData)=(word&mask4);
f7bcb379	139	++fPointerToData;
	140	*(fPointerToData)=(word&mask3)>>8;
	141	++fPointerToData;
2cc6c8fe	142	*(fPointerToData)=(word&mask2)>>16;
	143	++fPointerToData;
	144	*(fPointerToData)=(word&mask1)>>24;
f7bcb379	145	++fPointerToData;
	146	siz+=4;
	147	}
	148	}
	149	}
	150	return siz;
	151	}