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

/**************************************************************************
 * Copyright(c) 1998-2003, 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$ */


//This class contains all the necessary methods to create the Raw Data
//files (slides) for the ITS data challenges for:
//SPD 
//SDD
//SSD

#include <stdlib.h>
#include <Riostream.h>
#include <TClonesArray.h>
#include <TTree.h>
#include <TMath.h>
#include "AliITS.h"
#include "AliITSgeom.h"
#include "AliITSdigitSPD.h"
#include "AliITSdigitSDD.h"
#include "AliITSdigitSSD.h"
#include "AliITSDDLRawData.h"
#include "AliRawDataHeader.h"
#include "AliITSRawStreamSPD.h"
#include "AliITSRawStreamSDD.h"
#include "AliITSRawStreamSSD.h"
#include "AliBitPacking.h"

ClassImp(AliITSDDLRawData)

////////////////////////////////////////////////////////////////////////////////////////
AliITSDDLRawData::AliITSDDLRawData(){
  //Default constructor
  fIndex=-1;
  fHalfStaveModule=-1;
  fVerbose=0;
}

////////////////////////////////////////////////////////////////////////////////////////

AliITSDDLRawData::AliITSDDLRawData(const AliITSDDLRawData &source) : 
    TObject(source){
  //Copy Constructor
  this->fIndex=source.fIndex;
  this->fHalfStaveModule=source.fHalfStaveModule;
  this->fVerbose=source.fVerbose;
  return;
}

////////////////////////////////////////////////////////////////////////////////////////

AliITSDDLRawData& AliITSDDLRawData::operator=(const AliITSDDLRawData &source){
  //Assigment operator
  this->fIndex=source.fIndex;
  this->fHalfStaveModule=source.fHalfStaveModule;
  this->fVerbose=source.fVerbose;
  return *this;
}

////////////////////////////////////////////////////////////////////////////////////////
//STRIP 
//

void AliITSDDLRawData::GetDigitsSSD(TClonesArray *ITSdigits,Int_t mod,Int_t modR,Int_t ddl,UInt_t *buf){
  //This method packs the SSD digits in a proper 32 bits structure
  Int_t ix;
  Int_t iz;
  Int_t is;
  UInt_t word;
  UInt_t baseWord;
  Int_t ndigits = ITSdigits->GetEntries();
  AliITSdigit *digs;
  ofstream ftxt;
  if(ndigits){
    if (fVerbose==2){
      ftxt.open("SSDdigits.txt",ios::app);
    }
    for (Int_t digit=0;digit<ndigits;digit++) {
      digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
      iz=digs->GetCoord1();  // If iz==0, N side and if iz=1 P side
      ix=digs->GetCoord2();  // Strip Numbar
      is=digs->GetCompressedSignal();  // ADC Signal
      // cout<<" Module:"<<mod-500<<" N/P side:"<<iz<<" Strip Number:"<<ix<<" Amplidute:"<<is-1<<endl;
      if (fVerbose==2)
	ftxt<<"DDL:"<<ddl<<" Mod: "<<modR<<" N/P: "<<iz<<" Strip: "<<ix<<" Value: "<<is-1<<endl;
      baseWord=0;
      word=is-1;
      AliBitPacking::PackWord(word,baseWord,0,9);//ADC data
      word=ix;
      AliBitPacking::PackWord(word,baseWord,10,19);//Strip Number
      word=iz;      
      AliBitPacking::PackWord(word,baseWord,20,20);//ADC Channel ID (N or P side)
      word=mod;
      AliBitPacking::PackWord(word,baseWord,21,31);//ADC module ID
      fIndex++;
      buf[fIndex]=baseWord;
    }//end for
  }//end if
  if (fVerbose==2)
    ftxt.close();
  return;
}//end GetDigitsSSD

////////////////////////////////////////////////////////////////////////////////////////
//Silicon Drift Detector
//

void AliITSDDLRawData::GetDigitsSDD(TClonesArray *ITSdigits,Int_t mod,Int_t modR,Int_t ddl,UInt_t *buf){  
  //This method packs the SSD digits in a proper 32 bits structure
  Int_t ix;
  Int_t iz;
  Int_t is;
  UInt_t word;
  UInt_t baseWord;
  Int_t ndigits = ITSdigits->GetEntries();
  AliITSdigit *digs;
  ofstream ftxt;
  if(ndigits){
    //cout<<"Mudule "<<mod<<" number of digits "<<ndigits<<endl;
    if (fVerbose==2)
      ftxt.open("SDDdigits.txt",ios::app);
    for (Int_t digit=0;digit<ndigits;digit++) {
      digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
      iz=digs->GetCoord1();  // Anode
      ix=digs->GetCoord2();  // Time
      is=digs->GetCompressedSignal();  // ADC Signal
      if (fVerbose==2)
	ftxt<<"DDL:"<<ddl<<" MID:"<<modR<<" An:"<<iz<<" T:"<<ix<<" A:"<<is<<endl;
      //      cout<<"Amplitude value:"<<is<<" Time Bucket:"<<ix<<" Anode:"<<iz<<endl;
      if (is>255){Error("GetDigitsSDD", "bits words is needed)!!!");}
      baseWord=0;
      /*
      //10 bits words for amplitude value
      word=is;
      AliBitPacking::PackWord(word,baseWord,0,9);//ADC data
      word=ix;
      AliBitPacking::PackWord(word,baseWord,10,17);//Time bucket
      word=iz;
      AliBitPacking::PackWord(word,baseWord,18,26);//Anode Number
      word=mod;
      AliBitPacking::PackWord(word,baseWord,27,31);//Module number
      */
      
      //8bits words for amplitude value
      word=is;
      AliBitPacking::PackWord(word,baseWord,0,7);//ADC data
      word=ix;
      AliBitPacking::PackWord(word,baseWord,8,15);//Time bucket
      word=iz;
      AliBitPacking::PackWord(word,baseWord,16,24);//Anode Number
      word=mod;
      AliBitPacking::PackWord(word,baseWord,25,31);//Module number
     
      fIndex++;
      buf[fIndex]=baseWord;
    }//end for
  }//end if
  if(fVerbose==2)
    ftxt.close();
  return;
}//end GetDigitsSDD

////////////////////////////////////////////////////////////////////////////////////////
//PIXEL 
//

void AliITSDDLRawData::GetDigitsSPD(TClonesArray *ITSdigits,Int_t mod,Int_t ddl, UInt_t *buf){
  //This method packs the SPD digits in a proper 32 structure
  //Since data is zero suppressed,the coordinates for the chip having zero digits 
  //doesn't get listed in the galice.root file. However the SPD format requires 
  //the empty chip to be written with chip header and chip trailer.
  Int_t ix;
  Int_t iz;
  Int_t chipNo=0;
  UInt_t baseWord=0;
  UInt_t hitRow=0;
  Int_t chipHitCount=0;  //Number of Hit in the current chip
  Int_t previousChip=-1; //Previuos chip respect to the actual aone
  Int_t ndigits = ITSdigits->GetEntries(); //number of digits in the current module
  //cout<<"      Number of digits in the current module:"<<ndigits<<" module:"<<mod<<endl;
  AliITSdigit *digs;
  fHalfStaveModule++;    //It's a private variable used to distinguish between the firs  
                         //and the second module of an Half Stave Module
  ofstream ftxt;
  if(ndigits){
    //loop over digits
    if (fVerbose==2)
      ftxt.open("SPDdigits.txt",ios::app);
    for (Int_t digit=0;digit<ndigits;digit++){
      digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
      /*---------------------------------------------------------------------------
       *     Each module contains 5 read out chips of 256 rows and 32 columns.
       *     So, the cell number in Z direction varies from 0 to 159.  Therefore,
       *     to get the chip address (0 to 4), we need to divide column number by 32.
       *     ---------------------------------------------------------------------*/
      iz=digs->GetCoord1();  // Cell number in Z direction 
      ix=digs->GetCoord2();  // Cell number in X direction
      chipNo=iz/32;
      if(fVerbose==2)
	ftxt<<"DDL:"<<ddl<<" Mod:"<<mod<<" Row:"<<ix<<" Col:"<<iz<<endl;
      hitRow=iz-chipNo*32;
      if(fHalfStaveModule){
	chipNo+=5;
	fHalfStaveModule=-1;
      }//end if
      if(previousChip==-1){
	//loop over chip without digits 
	//Even if there aren't digits for a given chip 
	//the chip header and the chip trailer are stored
	for(Int_t i=0;i<(iz/32);i++){
	  if(chipNo>4)
	    WriteChipHeader(i+5,(mod/2),baseWord);
	  else
	    WriteChipHeader(i,(mod/2),baseWord);
	  WriteChipTrailer(buf,chipHitCount,baseWord);
	  chipHitCount=0;
	}//end for
	WriteChipHeader(chipNo,(mod/2),baseWord);
	chipHitCount++;
	WriteHit(buf,ix,hitRow,baseWord);
	previousChip=chipNo;
      }//end if
      else{
	if(previousChip!=chipNo){
	  WriteChipTrailer(buf,chipHitCount,baseWord);
	  chipHitCount=0;
	  for(Int_t i=previousChip+1;i<chipNo;i++){
	    WriteChipHeader(i,(mod/2),baseWord);
	    WriteChipTrailer(buf,0,baseWord);
	    chipHitCount=0;
	  }//end for
	  WriteChipHeader(chipNo,(mod/2),baseWord);
	  previousChip=chipNo;
	}//end if
	chipHitCount++;
	WriteHit(buf,ix,hitRow,baseWord);
      }//end else
    }//end for
    //Even if there aren't digits for a given chip 
    //the chip header and the chip trailer are stored
    Int_t end=4;
    if(chipNo>4)end+=5;
    WriteChipTrailer(buf,chipHitCount,baseWord);
    chipHitCount=0;
    for(Int_t i=chipNo+1;i<=end;i++){
      WriteChipHeader(i,(mod/2),baseWord);
      WriteChipTrailer(buf,0,baseWord);
      chipHitCount=0;
    }//end for
  }//end if
  else{
    //In this module there aren't digits but
    //the chip header and chip trailer are store anyway
    if(fHalfStaveModule){
      chipNo=5;
      fHalfStaveModule=-1;
    }//end if
    for(Int_t i=0;i<5;i++){
      WriteChipHeader(chipNo+i,(mod/2),baseWord);
      WriteChipTrailer(buf,chipHitCount,baseWord);
      chipHitCount=0;
    }//end for
  }//end else 
  if(fVerbose==2)
    ftxt.close();
  return;
}//end GetDigitsSPD

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Int_t AliITSDDLRawData::RawDataSPD(TBranch* branch){
  //This method creates the Raw data files for SPD detectors
  const Int_t kSize=21000; //256*32*5=40960 max number of digits per module
  UInt_t buf[kSize];      //One buffer cell can contain 2 digits 
  fIndex=-1;

  TClonesArray*& digits = * (TClonesArray**) branch->GetAddress();
  char fileName[15];
  ofstream outfile;         // logical name of the output file 
  AliRawDataHeader header;

  //loop over DDLs
  for(Int_t i=0;i<AliITSRawStreamSPD::kDDLsNumber;i++){
    sprintf(fileName,"ITSSPD_%d.ddl",i+AliITSRawStreamSPD::kDDLOffset); //The name of the output file.
#ifndef __DECCXX
    outfile.open(fileName,ios::binary);
#else
    outfile.open(fileName);
#endif
    //write Dummy DATA HEADER
    UInt_t dataHeaderPosition=outfile.tellp();
    outfile.write((char*)(&header),sizeof(header));
    //Loops over Modules of a particular DDL
    for (Int_t mod=0; mod<AliITSRawStreamSPD::kModulesPerDDL; mod++){
      Int_t moduleNumber = AliITSRawStreamSPD::GetModuleNumber(i, mod);
      digits->Clear();
      branch->GetEvent(moduleNumber);
      //For each Module, buf contains the array of data words in Binary format	  
      //fIndex gives the number of 32 bits words in the buffer for each module
      GetDigitsSPD(digits,moduleNumber,i,buf);
      outfile.write((char *)buf,((fIndex+1)*sizeof(UInt_t)));
      for(Int_t i=0;i<(fIndex+1);i++){
	buf[i]=0;
      }//end for
      fIndex=-1;
    }//end for
    
    //Write REAL DATA HEADER
    UInt_t currentFilePosition=outfile.tellp();
    outfile.seekp(dataHeaderPosition);
    header.fSize=currentFilePosition-dataHeaderPosition;
    outfile.write((char*)(&header),sizeof(header));
    outfile.close();
  }//end for

  return 0;  
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Int_t AliITSDDLRawData::RawDataSSD(TBranch* branch){
  //This method creates the Raw data files for SSD detectors
  const Int_t kSize=1536;//768*2 Number of stripe * number of sides(N and P)
  UInt_t buf[kSize];      
  fIndex=-1;

  TClonesArray*& digits = * (TClonesArray**) branch->GetAddress();
  char fileName[15];
  ofstream outfile;         // logical name of the output file 
  AliRawDataHeader header;

  //loop over DDLs  
  for(Int_t i=0;i<AliITSRawStreamSSD::kDDLsNumber;i++){
    sprintf(fileName,"ITSSSD_%d.ddl",i+AliITSRawStreamSSD::kDDLOffset); //The name of the output file
#ifndef __DECCXX
    outfile.open(fileName,ios::binary);
#else
    outfile.open(fileName);
#endif
    //write Dummy DATA HEADER
    UInt_t dataHeaderPosition=outfile.tellp();
    outfile.write((char*)(&header),sizeof(header));
    
    //Loops over Modules of a particular DDL
    for (Int_t mod=0; mod<AliITSRawStreamSSD::kModulesPerDDL; mod++){
      Int_t moduleNumber = AliITSRawStreamSSD::GetModuleNumber(i, mod);
      if(moduleNumber!=-1){
	digits->Clear();
	branch->GetEvent(moduleNumber);
	//For each Module, buf contains the array of data words in Binary format	  
	//fIndex gives the number of 32 bits words in the buffer for each module
	GetDigitsSSD(digits,mod,moduleNumber,i,buf);
	outfile.write((char *)buf,((fIndex+1)*sizeof(UInt_t)));
	fIndex=-1;
      }//end if
    }//end for

    //Write REAL DATA HEADER
    UInt_t currentFilePosition=outfile.tellp();
    outfile.seekp(dataHeaderPosition);
    header.fSize=currentFilePosition-dataHeaderPosition;
    header.SetAttribute(0);  // valid data
    outfile.write((char*)(&header),sizeof(header));
    outfile.close();
  }//end for

  return 0;  
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Int_t AliITSDDLRawData::RawDataSDD(TBranch* branch){
    //This method creates the Raw data files for SDD detectors
  const Int_t kSize=131072; //256*512
  UInt_t buf[kSize];      
  fIndex=-1;

  TClonesArray*& digits = * (TClonesArray**) branch->GetAddress();
  char fileName[15];
  ofstream outfile;             // logical name of the output file 
  AliRawDataHeader header;

  //loop over DDLs  
  for(Int_t i=0;i<AliITSRawStreamSDD::kDDLsNumber;i++){
    sprintf(fileName,"ITSSDD_%d.ddl",i+AliITSRawStreamSDD::kDDLOffset); //The name of the output file
#ifndef __DECCXX
    outfile.open(fileName,ios::binary);
#else
    outfile.open(fileName);
#endif
    //write Dummy DATA HEADER
    UInt_t dataHeaderPosition=outfile.tellp();
    outfile.write((char*)(&header),sizeof(header));

    //Loops over Modules of a particular DDL
    for (Int_t mod=0; mod<AliITSRawStreamSDD::kModulesPerDDL; mod++){
      Int_t moduleNumber = AliITSRawStreamSDD::GetModuleNumber(i, mod);
      if(moduleNumber!=-1){
	digits->Clear();
	branch->GetEvent(moduleNumber);
	//For each Module, buf contains the array of data words in Binary format	  
	//fIndex gives the number of 32 bits words in the buffer for each module
	//	cout<<"MODULE NUMBER:"<<mapSDD[i][mod]<<endl;
	GetDigitsSDD(digits,mod,moduleNumber,i,buf);
	outfile.write((char *)buf,((fIndex+1)*sizeof(UInt_t)));
	fIndex=-1;
      }//end if
    }//end for
    
    //Write REAL DATA HEADER
    UInt_t currentFilePosition=outfile.tellp();
    outfile.seekp(dataHeaderPosition);
    header.fSize=currentFilePosition-dataHeaderPosition;
    header.SetAttribute(0);  // valid data
    outfile.write((char*)(&header),sizeof(header));
    outfile.close();
  }//end for

  return 0;  
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void AliITSDDLRawData::WriteChipHeader(Int_t ChipAddr,Int_t /*EventCnt*/,UInt_t &BaseWord){
  //This method writes a chip header 
  //cout<<"Chip: "<<ChipAddr<<" Half Stave module:"<<EventCnt<<endl;
  BaseWord=0;
  AliBitPacking::PackWord(ChipAddr,BaseWord,0,3);
//  AliBitPacking::PackWord(EventCnt,BaseWord,4,10);
  AliBitPacking::PackWord(0,BaseWord,4,10);
  AliBitPacking::PackWord(0x7,BaseWord,11,13);
  AliBitPacking::PackWord(0x1,BaseWord,14,15);
  return;
}//end WriteChipHeader

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void AliITSDDLRawData::ReadChipHeader(Int_t &ChipAddr,Int_t &EventCnt,UInt_t BaseWord){
  //This method reads a chip header
  UInt_t temp=AliBitPacking::UnpackWord(BaseWord,0,3);
  ChipAddr=(Int_t)temp;
  temp=AliBitPacking::UnpackWord(BaseWord,4,10);
  EventCnt=(Int_t)temp;
  if(fVerbose)
    Info("ReadChipHeader", "Chip:&d Half Stave module:%d",ChipAddr,EventCnt);
  return;
}//end ReadChipHeader

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void  AliITSDDLRawData::WriteChipTrailer(UInt_t *buf,Int_t ChipHitCount,UInt_t &BaseWord){
  //This method writes a chip trailer
  //pixel fill word
  if((ChipHitCount%2)!=0){
    AliBitPacking::PackWord(0xC000,BaseWord,0,15);
  }
  AliBitPacking::PackWord(ChipHitCount,BaseWord,16,29);
  AliBitPacking::PackWord(0x0,BaseWord,30,31);
  fIndex++;
  buf[fIndex]=BaseWord;
  BaseWord=0;
  return;
}//end WriteChipTrailer

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void  AliITSDDLRawData::ReadChipTrailer(Int_t &ChipHitCount,UInt_t BaseWord){
  //This method reads a chip trailer
  UInt_t temp=AliBitPacking::UnpackWord(BaseWord,16,29);
  ChipHitCount=(Int_t)temp;
  return;
}//end ReadChipTrailer

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void  AliITSDDLRawData::WriteHit(UInt_t *buf,Int_t RowAddr,Int_t HitAddr,UInt_t &BaseWord){
  //This method writs an hit
  if(!BaseWord){
    AliBitPacking::PackWord(HitAddr,BaseWord,0,4);
    AliBitPacking::PackWord(RowAddr,BaseWord,5,12);
    AliBitPacking::PackWord(2,BaseWord,14,15);
  }//end if
  else{
    AliBitPacking::PackWord(HitAddr,BaseWord,16,20);
    AliBitPacking::PackWord(RowAddr,BaseWord,21,28);
    AliBitPacking::PackWord(2,BaseWord,30,31);
    fIndex++;
    buf[fIndex]=BaseWord;
    BaseWord=0;
  }//end else
  return;
}//end WriteHit
Commit	Line	Data
2e9f335b	1	/**************************************************************************
	2	* Copyright(c) 1998-2003, 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	**************************************************************************/
9f992f70	15
30c1018e	16	/* $Id$ */
a79660fb	17
9f992f70	18
a79660fb	19	//This class contains all the necessary methods to create the Raw Data
	20	//files (slides) for the ITS data challenges for:
	21	//SPD
	22	//SDD
	23	//SSD
2e9f335b	24
2e9f335b	25	#include <stdlib.h>
c9bd9d3d	26	#include <Riostream.h>
2e9f335b	27	#include <TClonesArray.h>
2e9f335b	28	#include <TTree.h>
c9bd9d3d	29	#include <TMath.h>
	30	#include "AliITS.h"
	31	#include "AliITSgeom.h"
e869281d	32	#include "AliITSdigitSPD.h"
	33	#include "AliITSdigitSDD.h"
	34	#include "AliITSdigitSSD.h"
2e9f335b	35	#include "AliITSDDLRawData.h"
0421c3d1	36	#include "AliRawDataHeader.h"
	37	#include "AliITSRawStreamSPD.h"
	38	#include "AliITSRawStreamSDD.h"
	39	#include "AliITSRawStreamSSD.h"
113c12f1	40	#include "AliBitPacking.h"
2e9f335b	41
	42	ClassImp(AliITSDDLRawData)
	43
	44	////////////////////////////////////////////////////////////////////////////////////////
	45	AliITSDDLRawData::AliITSDDLRawData(){
a79660fb	46	//Default constructor
2e9f335b	47	fIndex=-1;
2e9f335b	48	fHalfStaveModule=-1;
9f992f70	49	fVerbose=0;
2e9f335b	50	}
	51
	52	////////////////////////////////////////////////////////////////////////////////////////
	53
ac74f489	54	AliITSDDLRawData::AliITSDDLRawData(const AliITSDDLRawData &source) :
ac74f489	55	TObject(source){
a79660fb	56	//Copy Constructor
2e9f335b	57	this->fIndex=source.fIndex;
2e9f335b	58	this->fHalfStaveModule=source.fHalfStaveModule;
9f992f70	59	this->fVerbose=source.fVerbose;
2e9f335b	60	return;
	61	}
	62
	63	////////////////////////////////////////////////////////////////////////////////////////
	64
	65	AliITSDDLRawData& AliITSDDLRawData::operator=(const AliITSDDLRawData &source){
	66	//Assigment operator
	67	this->fIndex=source.fIndex;
	68	this->fHalfStaveModule=source.fHalfStaveModule;
9f992f70	69	this->fVerbose=source.fVerbose;
2e9f335b	70	return *this;
	71	}
	72
	73	////////////////////////////////////////////////////////////////////////////////////////
	74	//STRIP
	75	//
	76
0b3c7dfc	77	void AliITSDDLRawData::GetDigitsSSD(TClonesArray ITSdigits,Int_t mod,Int_t modR,Int_t ddl,UInt_t buf){
a79660fb	78	//This method packs the SSD digits in a proper 32 bits structure
2e9f335b	79	Int_t ix;
	80	Int_t iz;
	81	Int_t is;
0b3c7dfc	82	UInt_t word;
0b3c7dfc	83	UInt_t baseWord;
2e9f335b	84	Int_t ndigits = ITSdigits->GetEntries();
2e9f335b	85	AliITSdigit *digs;
9f992f70	86	ofstream ftxt;
2e9f335b	87	if(ndigits){
9f992f70	88	if (fVerbose==2){
	89	ftxt.open("SSDdigits.txt",ios::app);
	90	}
2e9f335b	91	for (Int_t digit=0;digit<ndigits;digit++) {
2e9f335b	92	digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
ecee53fc	93	iz=digs->GetCoord1(); // If iz==0, N side and if iz=1 P side
ecee53fc	94	ix=digs->GetCoord2(); // Strip Numbar
7f1a504b	95	is=digs->GetCompressedSignal(); // ADC Signal
2e9f335b	96	// cout<<" Module:"<<mod-500<<" N/P side:"<<iz<<" Strip Number:"<<ix<<" Amplidute:"<<is-1<<endl;
9f992f70	97	if (fVerbose==2)
9f992f70	98	ftxt<<"DDL:"<<ddl<<" Mod: "<<modR<<" N/P: "<<iz<<" Strip: "<<ix<<" Value: "<<is-1<<endl;
a79660fb	99	baseWord=0;
a79660fb	100	word=is-1;
113c12f1	101	AliBitPacking::PackWord(word,baseWord,0,9);//ADC data
a79660fb	102	word=ix;
113c12f1	103	AliBitPacking::PackWord(word,baseWord,10,19);//Strip Number
a79660fb	104	word=iz;
113c12f1	105	AliBitPacking::PackWord(word,baseWord,20,20);//ADC Channel ID (N or P side)
a79660fb	106	word=mod;
113c12f1	107	AliBitPacking::PackWord(word,baseWord,21,31);//ADC module ID
2e9f335b	108	fIndex++;
a79660fb	109	buf[fIndex]=baseWord;
2e9f335b	110	}//end for
2e9f335b	111	}//end if
9f992f70	112	if (fVerbose==2)
9f992f70	113	ftxt.close();
2e9f335b	114	return;
	115	}//end GetDigitsSSD
	116
	117	////////////////////////////////////////////////////////////////////////////////////////
	118	//Silicon Drift Detector
	119	//
	120
0b3c7dfc	121	void AliITSDDLRawData::GetDigitsSDD(TClonesArray ITSdigits,Int_t mod,Int_t modR,Int_t ddl,UInt_t buf){
a79660fb	122	//This method packs the SSD digits in a proper 32 bits structure
2e9f335b	123	Int_t ix;
	124	Int_t iz;
	125	Int_t is;
0b3c7dfc	126	UInt_t word;
0b3c7dfc	127	UInt_t baseWord;
2e9f335b	128	Int_t ndigits = ITSdigits->GetEntries();
2e9f335b	129	AliITSdigit *digs;
9f992f70	130	ofstream ftxt;
2e9f335b	131	if(ndigits){
2e9f335b	132	//cout<<"Mudule "<<mod<<" number of digits "<<ndigits<<endl;
9f992f70	133	if (fVerbose==2)
9f992f70	134	ftxt.open("SDDdigits.txt",ios::app);
2e9f335b	135	for (Int_t digit=0;digit<ndigits;digit++) {
2e9f335b	136	digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
ecee53fc	137	iz=digs->GetCoord1(); // Anode
ecee53fc	138	ix=digs->GetCoord2(); // Time
7f1a504b	139	is=digs->GetCompressedSignal(); // ADC Signal
9f992f70	140	if (fVerbose==2)
9f992f70	141	ftxt<<"DDL:"<<ddl<<" MID:"<<modR<<" An:"<<iz<<" T:"<<ix<<" A:"<<is<<endl;
2e9f335b	142	// cout<<"Amplitude value:"<<is<<" Time Bucket:"<<ix<<" Anode:"<<iz<<endl;
0421c3d1	143	if (is>255){Error("GetDigitsSDD", "bits words is needed)!!!");}
a79660fb	144	baseWord=0;
2e9f335b	145	/*
2e9f335b	146	//10 bits words for amplitude value
a79660fb	147	word=is;
113c12f1	148	AliBitPacking::PackWord(word,baseWord,0,9);//ADC data
a79660fb	149	word=ix;
113c12f1	150	AliBitPacking::PackWord(word,baseWord,10,17);//Time bucket
a79660fb	151	word=iz;
113c12f1	152	AliBitPacking::PackWord(word,baseWord,18,26);//Anode Number
a79660fb	153	word=mod;
113c12f1	154	AliBitPacking::PackWord(word,baseWord,27,31);//Module number
2e9f335b	155	*/
	156
	157	//8bits words for amplitude value
a79660fb	158	word=is;
113c12f1	159	AliBitPacking::PackWord(word,baseWord,0,7);//ADC data
a79660fb	160	word=ix;
113c12f1	161	AliBitPacking::PackWord(word,baseWord,8,15);//Time bucket
a79660fb	162	word=iz;
113c12f1	163	AliBitPacking::PackWord(word,baseWord,16,24);//Anode Number
a79660fb	164	word=mod;
113c12f1	165	AliBitPacking::PackWord(word,baseWord,25,31);//Module number
2e9f335b	166
2e9f335b	167	fIndex++;
a79660fb	168	buf[fIndex]=baseWord;
2e9f335b	169	}//end for
2e9f335b	170	}//end if
9f992f70	171	if(fVerbose==2)
9f992f70	172	ftxt.close();
2e9f335b	173	return;
	174	}//end GetDigitsSDD
	175
	176	////////////////////////////////////////////////////////////////////////////////////////
	177	//PIXEL
	178	//
	179
0b3c7dfc	180	void AliITSDDLRawData::GetDigitsSPD(TClonesArray ITSdigits,Int_t mod,Int_t ddl, UInt_t buf){
9f992f70	181	//This method packs the SPD digits in a proper 32 structure
	182	//Since data is zero suppressed,the coordinates for the chip having zero digits
	183	//doesn't get listed in the galice.root file. However the SPD format requires
	184	//the empty chip to be written with chip header and chip trailer.
2e9f335b	185	Int_t ix;
2e9f335b	186	Int_t iz;
a79660fb	187	Int_t chipNo=0;
0b3c7dfc	188	UInt_t baseWord=0;
0b3c7dfc	189	UInt_t hitRow=0;
a79660fb	190	Int_t chipHitCount=0; //Number of Hit in the current chip
a79660fb	191	Int_t previousChip=-1; //Previuos chip respect to the actual aone
2e9f335b	192	Int_t ndigits = ITSdigits->GetEntries(); //number of digits in the current module
	193	//cout<<" Number of digits in the current module:"<<ndigits<<" module:"<<mod<<endl;
	194	AliITSdigit *digs;
	195	fHalfStaveModule++; //It's a private variable used to distinguish between the firs
	196	//and the second module of an Half Stave Module
9f992f70	197	ofstream ftxt;
2e9f335b	198	if(ndigits){
2e9f335b	199	//loop over digits
9f992f70	200	if (fVerbose==2)
9f992f70	201	ftxt.open("SPDdigits.txt",ios::app);
2e9f335b	202	for (Int_t digit=0;digit<ndigits;digit++){
	203	digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
	204	/*---------------------------------------------------------------------------
	205	* Each module contains 5 read out chips of 256 rows and 32 columns.
9f992f70	206	* So, the cell number in Z direction varies from 0 to 159. Therefore,
2e9f335b	207	* to get the chip address (0 to 4), we need to divide column number by 32.
2e9f335b	208	* ---------------------------------------------------------------------*/
ecee53fc	209	iz=digs->GetCoord1(); // Cell number in Z direction
ecee53fc	210	ix=digs->GetCoord2(); // Cell number in X direction
a79660fb	211	chipNo=iz/32;
9f992f70	212	if(fVerbose==2)
9f992f70	213	ftxt<<"DDL:"<<ddl<<" Mod:"<<mod<<" Row:"<<ix<<" Col:"<<iz<<endl;
a79660fb	214	hitRow=iz-chipNo*32;
2e9f335b	215	if(fHalfStaveModule){
a79660fb	216	chipNo+=5;
2e9f335b	217	fHalfStaveModule=-1;
2e9f335b	218	}//end if
a79660fb	219	if(previousChip==-1){
2e9f335b	220	//loop over chip without digits
	221	//Even if there aren't digits for a given chip
	222	//the chip header and the chip trailer are stored
	223	for(Int_t i=0;i<(iz/32);i++){
a79660fb	224	if(chipNo>4)
a79660fb	225	WriteChipHeader(i+5,(mod/2),baseWord);
2e9f335b	226	else
a79660fb	227	WriteChipHeader(i,(mod/2),baseWord);
a79660fb	228	WriteChipTrailer(buf,chipHitCount,baseWord);
9f992f70	229	chipHitCount=0;
2e9f335b	230	}//end for
a79660fb	231	WriteChipHeader(chipNo,(mod/2),baseWord);
	232	chipHitCount++;
	233	WriteHit(buf,ix,hitRow,baseWord);
9f992f70	234	previousChip=chipNo;
2e9f335b	235	}//end if
2e9f335b	236	else{
a79660fb	237	if(previousChip!=chipNo){
9f992f70	238	WriteChipTrailer(buf,chipHitCount,baseWord);
9f992f70	239	chipHitCount=0;
a79660fb	240	for(Int_t i=previousChip+1;i<chipNo;i++){
	241	WriteChipHeader(i,(mod/2),baseWord);
	242	WriteChipTrailer(buf,0,baseWord);
9f992f70	243	chipHitCount=0;
2e9f335b	244	}//end for
a79660fb	245	WriteChipHeader(chipNo,(mod/2),baseWord);
a79660fb	246	previousChip=chipNo;
2e9f335b	247	}//end if
9f992f70	248	chipHitCount++;
a79660fb	249	WriteHit(buf,ix,hitRow,baseWord);
2e9f335b	250	}//end else
	251	}//end for
	252	//Even if there aren't digits for a given chip
	253	//the chip header and the chip trailer are stored
a79660fb	254	Int_t end=4;
	255	if(chipNo>4)end+=5;
	256	WriteChipTrailer(buf,chipHitCount,baseWord);
9f992f70	257	chipHitCount=0;
a79660fb	258	for(Int_t i=chipNo+1;i<=end;i++){
	259	WriteChipHeader(i,(mod/2),baseWord);
	260	WriteChipTrailer(buf,0,baseWord);
9f992f70	261	chipHitCount=0;
2e9f335b	262	}//end for
	263	}//end if
	264	else{
	265	//In this module there aren't digits but
	266	//the chip header and chip trailer are store anyway
	267	if(fHalfStaveModule){
a79660fb	268	chipNo=5;
2e9f335b	269	fHalfStaveModule=-1;
	270	}//end if
	271	for(Int_t i=0;i<5;i++){
a79660fb	272	WriteChipHeader(chipNo+i,(mod/2),baseWord);
a79660fb	273	WriteChipTrailer(buf,chipHitCount,baseWord);
9f992f70	274	chipHitCount=0;
2e9f335b	275	}//end for
2e9f335b	276	}//end else
9f992f70	277	if(fVerbose==2)
9f992f70	278	ftxt.close();
2e9f335b	279	return;
	280	}//end GetDigitsSPD
	281
2e9f335b	282	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2e9f335b	283
0421c3d1	284	Int_t AliITSDDLRawData::RawDataSPD(TBranch* branch){
a79660fb	285	//This method creates the Raw data files for SPD detectors
a79660fb	286	const Int_t kSize=21000; //256325=40960 max number of digits per module
0b3c7dfc	287	UInt_t buf[kSize]; //One buffer cell can contain 2 digits
2e9f335b	288	fIndex=-1;
2e9f335b	289
0421c3d1	290	TClonesArray& digits = (TClonesArray**) branch->GetAddress();
2e9f335b	291	char fileName[15];
2e9f335b	292	ofstream outfile; // logical name of the output file
0421c3d1	293	AliRawDataHeader header;
	294
	295	//loop over DDLs
	296	for(Int_t i=0;i<AliITSRawStreamSPD::kDDLsNumber;i++){
	297	sprintf(fileName,"ITSSPD_%d.ddl",i+AliITSRawStreamSPD::kDDLOffset); //The name of the output file.
30c1018e	298	#ifndef __DECCXX
0421c3d1	299	outfile.open(fileName,ios::binary);
30c1018e	300	#else
0421c3d1	301	outfile.open(fileName);
30c1018e	302	#endif
0421c3d1	303	//write Dummy DATA HEADER
	304	UInt_t dataHeaderPosition=outfile.tellp();
	305	outfile.write((char*)(&header),sizeof(header));
2e9f335b	306	//Loops over Modules of a particular DDL
0421c3d1	307	for (Int_t mod=0; mod<AliITSRawStreamSPD::kModulesPerDDL; mod++){
	308	Int_t moduleNumber = AliITSRawStreamSPD::GetModuleNumber(i, mod);
	309	digits->Clear();
	310	branch->GetEvent(moduleNumber);
2e9f335b	311	//For each Module, buf contains the array of data words in Binary format
2e9f335b	312	//fIndex gives the number of 32 bits words in the buffer for each module
0421c3d1	313	GetDigitsSPD(digits,moduleNumber,i,buf);
0b3c7dfc	314	outfile.write((char )buf,((fIndex+1)sizeof(UInt_t)));
2e9f335b	315	for(Int_t i=0;i<(fIndex+1);i++){
	316	buf[i]=0;
	317	}//end for
	318	fIndex=-1;
	319	}//end for
	320
0421c3d1	321	//Write REAL DATA HEADER
0b3c7dfc	322	UInt_t currentFilePosition=outfile.tellp();
0421c3d1	323	outfile.seekp(dataHeaderPosition);
0421c3d1	324	header.fSize=currentFilePosition-dataHeaderPosition;
0421c3d1	325	outfile.write((char*)(&header),sizeof(header));
0421c3d1	326	outfile.close();
2e9f335b	327	}//end for
0421c3d1	328
2e9f335b	329	return 0;
	330	}
	331
	332	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	333
0421c3d1	334	Int_t AliITSDDLRawData::RawDataSSD(TBranch* branch){
a79660fb	335	//This method creates the Raw data files for SSD detectors
a79660fb	336	const Int_t kSize=1536;//7682 Number of stripe number of sides(N and P)
0b3c7dfc	337	UInt_t buf[kSize];
2e9f335b	338	fIndex=-1;
0421c3d1	339
0421c3d1	340	TClonesArray& digits = (TClonesArray**) branch->GetAddress();
2e9f335b	341	char fileName[15];
0421c3d1	342	ofstream outfile; // logical name of the output file
0421c3d1	343	AliRawDataHeader header;
2e9f335b	344
0421c3d1	345	//loop over DDLs
	346	for(Int_t i=0;i<AliITSRawStreamSSD::kDDLsNumber;i++){
	347	sprintf(fileName,"ITSSSD_%d.ddl",i+AliITSRawStreamSSD::kDDLOffset); //The name of the output file
30c1018e	348	#ifndef __DECCXX
0421c3d1	349	outfile.open(fileName,ios::binary);
30c1018e	350	#else
0421c3d1	351	outfile.open(fileName);
30c1018e	352	#endif
0421c3d1	353	//write Dummy DATA HEADER
	354	UInt_t dataHeaderPosition=outfile.tellp();
	355	outfile.write((char*)(&header),sizeof(header));
2e9f335b	356
2e9f335b	357	//Loops over Modules of a particular DDL
0421c3d1	358	for (Int_t mod=0; mod<AliITSRawStreamSSD::kModulesPerDDL; mod++){
	359	Int_t moduleNumber = AliITSRawStreamSSD::GetModuleNumber(i, mod);
	360	if(moduleNumber!=-1){
	361	digits->Clear();
	362	branch->GetEvent(moduleNumber);
2e9f335b	363	//For each Module, buf contains the array of data words in Binary format
2e9f335b	364	//fIndex gives the number of 32 bits words in the buffer for each module
0421c3d1	365	GetDigitsSSD(digits,mod,moduleNumber,i,buf);
0b3c7dfc	366	outfile.write((char )buf,((fIndex+1)sizeof(UInt_t)));
2e9f335b	367	fIndex=-1;
	368	}//end if
	369	}//end for
0421c3d1	370
0421c3d1	371	//Write REAL DATA HEADER
0b3c7dfc	372	UInt_t currentFilePosition=outfile.tellp();
0421c3d1	373	outfile.seekp(dataHeaderPosition);
	374	header.fSize=currentFilePosition-dataHeaderPosition;
	375	header.SetAttribute(0); // valid data
	376	outfile.write((char*)(&header),sizeof(header));
	377	outfile.close();
2e9f335b	378	}//end for
0421c3d1	379
2e9f335b	380	return 0;
	381	}
	382
	383	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	384
0421c3d1	385	Int_t AliITSDDLRawData::RawDataSDD(TBranch* branch){
a79660fb	386	//This method creates the Raw data files for SDD detectors
a79660fb	387	const Int_t kSize=131072; //256*512
0b3c7dfc	388	UInt_t buf[kSize];
2e9f335b	389	fIndex=-1;
2e9f335b	390
0421c3d1	391	TClonesArray& digits = (TClonesArray**) branch->GetAddress();
0421c3d1	392	char fileName[15];
2e9f335b	393	ofstream outfile; // logical name of the output file
0421c3d1	394	AliRawDataHeader header;
	395
	396	//loop over DDLs
	397	for(Int_t i=0;i<AliITSRawStreamSDD::kDDLsNumber;i++){
	398	sprintf(fileName,"ITSSDD_%d.ddl",i+AliITSRawStreamSDD::kDDLOffset); //The name of the output file
30c1018e	399	#ifndef __DECCXX
0421c3d1	400	outfile.open(fileName,ios::binary);
30c1018e	401	#else
0421c3d1	402	outfile.open(fileName);
30c1018e	403	#endif
0421c3d1	404	//write Dummy DATA HEADER
	405	UInt_t dataHeaderPosition=outfile.tellp();
	406	outfile.write((char*)(&header),sizeof(header));
	407
2e9f335b	408	//Loops over Modules of a particular DDL
0421c3d1	409	for (Int_t mod=0; mod<AliITSRawStreamSDD::kModulesPerDDL; mod++){
	410	Int_t moduleNumber = AliITSRawStreamSDD::GetModuleNumber(i, mod);
	411	if(moduleNumber!=-1){
	412	digits->Clear();
	413	branch->GetEvent(moduleNumber);
2e9f335b	414	//For each Module, buf contains the array of data words in Binary format
2e9f335b	415	//fIndex gives the number of 32 bits words in the buffer for each module
a79660fb	416	// cout<<"MODULE NUMBER:"<<mapSDD[i][mod]<<endl;
0421c3d1	417	GetDigitsSDD(digits,mod,moduleNumber,i,buf);
0b3c7dfc	418	outfile.write((char )buf,((fIndex+1)sizeof(UInt_t)));
2e9f335b	419	fIndex=-1;
	420	}//end if
	421	}//end for
	422
0421c3d1	423	//Write REAL DATA HEADER
0b3c7dfc	424	UInt_t currentFilePosition=outfile.tellp();
0421c3d1	425	outfile.seekp(dataHeaderPosition);
	426	header.fSize=currentFilePosition-dataHeaderPosition;
	427	header.SetAttribute(0); // valid data
	428	outfile.write((char*)(&header),sizeof(header));
	429	outfile.close();
2e9f335b	430	}//end for
0421c3d1	431
2e9f335b	432	return 0;
	433	}
	434
	435	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	436
7193a823	437	void AliITSDDLRawData::WriteChipHeader(Int_t ChipAddr,Int_t /EventCnt/,UInt_t &BaseWord){
a79660fb	438	//This method writes a chip header
2e9f335b	439	//cout<<"Chip: "<<ChipAddr<<" Half Stave module:"<<EventCnt<<endl;
2e9f335b	440	BaseWord=0;
113c12f1	441	AliBitPacking::PackWord(ChipAddr,BaseWord,0,3);
7193a823	442	// AliBitPacking::PackWord(EventCnt,BaseWord,4,10);
7193a823	443	AliBitPacking::PackWord(0,BaseWord,4,10);
113c12f1	444	AliBitPacking::PackWord(0x7,BaseWord,11,13);
113c12f1	445	AliBitPacking::PackWord(0x1,BaseWord,14,15);
2e9f335b	446	return;
	447	}//end WriteChipHeader
	448
	449	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	450
0b3c7dfc	451	void AliITSDDLRawData::ReadChipHeader(Int_t &ChipAddr,Int_t &EventCnt,UInt_t BaseWord){
a79660fb	452	//This method reads a chip header
113c12f1	453	UInt_t temp=AliBitPacking::UnpackWord(BaseWord,0,3);
2e9f335b	454	ChipAddr=(Int_t)temp;
113c12f1	455	temp=AliBitPacking::UnpackWord(BaseWord,4,10);
2e9f335b	456	EventCnt=(Int_t)temp;
9f992f70	457	if(fVerbose)
0421c3d1	458	Info("ReadChipHeader", "Chip:&d Half Stave module:%d",ChipAddr,EventCnt);
2e9f335b	459	return;
	460	}//end ReadChipHeader
	461
	462	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	463
0b3c7dfc	464	void AliITSDDLRawData::WriteChipTrailer(UInt_t *buf,Int_t ChipHitCount,UInt_t &BaseWord){
a79660fb	465	//This method writes a chip trailer
2e9f335b	466	//pixel fill word
2e9f335b	467	if((ChipHitCount%2)!=0){
7193a823	468	AliBitPacking::PackWord(0xC000,BaseWord,0,15);
2e9f335b	469	}
7193a823	470	AliBitPacking::PackWord(ChipHitCount,BaseWord,16,29);
113c12f1	471	AliBitPacking::PackWord(0x0,BaseWord,30,31);
2e9f335b	472	fIndex++;
	473	buf[fIndex]=BaseWord;
	474	BaseWord=0;
	475	return;
	476	}//end WriteChipTrailer
	477
	478	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	479
0b3c7dfc	480	void AliITSDDLRawData::ReadChipTrailer(Int_t &ChipHitCount,UInt_t BaseWord){
a79660fb	481	//This method reads a chip trailer
7193a823	482	UInt_t temp=AliBitPacking::UnpackWord(BaseWord,16,29);
2e9f335b	483	ChipHitCount=(Int_t)temp;
	484	return;
	485	}//end ReadChipTrailer
	486
	487	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	488
0b3c7dfc	489	void AliITSDDLRawData::WriteHit(UInt_t *buf,Int_t RowAddr,Int_t HitAddr,UInt_t &BaseWord){
a79660fb	490	//This method writs an hit
2e9f335b	491	if(!BaseWord){
113c12f1	492	AliBitPacking::PackWord(HitAddr,BaseWord,0,4);
	493	AliBitPacking::PackWord(RowAddr,BaseWord,5,12);
	494	AliBitPacking::PackWord(2,BaseWord,14,15);
2e9f335b	495	}//end if
2e9f335b	496	else{
113c12f1	497	AliBitPacking::PackWord(HitAddr,BaseWord,16,20);
	498	AliBitPacking::PackWord(RowAddr,BaseWord,21,28);
	499	AliBitPacking::PackWord(2,BaseWord,30,31);
2e9f335b	500	fIndex++;
	501	buf[fIndex]=BaseWord;
	502	BaseWord=0;
	503	}//end else
	504	return;
	505	}//end WriteHit
	506