#include "AliBitPacking.h"
#include "AliDAQ.h"
#include "AliFstream.h"
+#include "AliITSFOSignalsSPD.h"
ClassImp(AliITSDDLRawData)
AliITSDDLRawData::AliITSDDLRawData():
fVerbose(0),
fIndex(-1),
-fHalfStaveModule(-1){
+fHalfStaveModule(-1),
+fSDDRawFormat(7){
//Default constructor
}
TObject(source),
fVerbose(source.fVerbose),
fIndex(source.fIndex),
-fHalfStaveModule(source.fHalfStaveModule){
+fHalfStaveModule(source.fHalfStaveModule),
+fSDDRawFormat(source.fSDDRawFormat){
//Copy Constructor
}
this->fIndex=source.fIndex;
this->fHalfStaveModule=source.fHalfStaveModule;
this->fVerbose=source.fVerbose;
+ this->fSDDRawFormat=source.fSDDRawFormat;
return *this;
}
ix=digs->GetCoord2(); // Strip Number
is=digs->GetCompressedSignal(); // ADC Signal
// cout<<" Module:"<<mod-500<<" N/P side:"<<iz<<" Strip Number:"<<ix<<" Amplidute:"<<is-1<<endl;
- if(is<0) is = 4096 + is;
+ if(is<0) is = 0;
+ if(is>4095) is = 4095;
if (fVerbose==2)
ftxt<<"DDL:"<<ddl<<" Mod: "<<modR<<" N/P: "<<iz<<" Strip: "<<ix<<" Value: "<<is-1<<endl;
//Silicon Drift Detector
//
+void AliITSDDLRawData::GetDigitsSDDCompressed(TClonesArray *ITSdigits, Int_t mod, UInt_t *buf){
+//This method packs the SDD digits in the compressed format (32 bit per digit)
+// see AliITSRawStreamSDDCompressed for details on the dta format
+
+ UInt_t dataWord=0;
+ Int_t ndigits = ITSdigits->GetEntries();
+ AliITSdigit *digs;
+ if(ndigits){
+ for (Int_t digit=0;digit<ndigits;digit++) {
+ digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
+ Int_t iz=digs->GetCoord1(); // Anode
+ Int_t ix=digs->GetCoord2(); // Time
+ Int_t is=digs->GetCompressedSignal(); // ADC Signal - 8 bit
+ dataWord=mod<<27;
+ Int_t sid=0;
+ if(iz>=256){
+ sid=1;
+ iz-=256;
+ }
+ dataWord+=sid<<26;
+ dataWord+=iz<<18;
+ dataWord+=ix<<10;
+ UInt_t adcEncoded=0;
+ Int_t shift=0;
+ if(is < 8) shift=2;
+ else if(is<16) shift=3;
+ else if(is<32) shift=4;
+ else if(is<64) shift=5;
+ else if(is<128) shift=6;
+ else shift=7;
+ adcEncoded=shift+((is-(1<<shift))<<3);
+ dataWord+=adcEncoded;
+ fIndex++;
+ buf[fIndex]=dataWord;
+ }
+ }
+ UInt_t finalWord=UInt_t(15)<<28;
+ finalWord+=mod;
+ fIndex++;
+ buf[fIndex]=finalWord;
+}
+
+//______________________________________________________________________
+
void AliITSDDLRawData::GetDigitsSDD(TClonesArray *ITSdigits,Int_t mod,Int_t modR,Int_t ddl,UInt_t *buf){
//This method packs the SDD digits in a proper 32 bits structure
Int_t ix;
if value >=128value = value - (1 << 7) (word is 7 bit long)
*/
+ //if(digarr[anode][tb]<4) continue; // not write <4 cnts above tL
if(digarr[anode][tb]<8){
bitinfo1[3] = 2;
wordinfo1[2] = 2;
//PIXEL
//
-void AliITSDDLRawData::GetDigitsSPD(TClonesArray *ITSdigits,Int_t mod,Int_t ddl, UInt_t *buf){
+void AliITSDDLRawData::GetDigitsSPD(TClonesArray *ITSdigits,Int_t mod,Int_t ddl, UInt_t *buf, AliITSFOSignalsSPD* foSignals){
//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
Int_t chipLow = AliITSRawStreamSPD::GetOnlineChipFromOffline(mod,0);
Int_t chipHigh = AliITSRawStreamSPD::GetOnlineChipFromOffline(mod,159);
+
if (chipLow>chipHigh) {chipLow -= 4; chipHigh += 4;}
+ UInt_t eq = AliITSRawStreamSPD::GetOnlineEqIdFromOffline(mod);
UInt_t hs = AliITSRawStreamSPD::GetOnlineHSFromOffline(mod);
// create int map to later hold all digits sorted
AliITSIntMap* digMap = new AliITSIntMap();
UInt_t baseWord=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;
+ // _______________________________________________________________________
+ // Preprocess the digits - sort them in integer map (Henrik Tydesjo)
+ // Needed to have exact same order as in real raw data
AliITSdigit *digs;
- ofstream ftxt;
- if(ndigits){
+ 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);
+ 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.
Int_t iz=digs->GetCoord1(); // Cell number in Z direction
Int_t ix=digs->GetCoord2(); // Cell number in X direction
- if(fVerbose==2)
- ftxt<<"DDL:"<<ddl<<" Mod:"<<mod<<" Row:"<<ix<<" Col:"<<iz<<endl;
- UInt_t dummyDDL,dummyHS,chip,col,row;
+ if(fVerbose==2) ftxt<<"DDL:"<<ddl<<" Mod:"<<mod<<" Row:"<<ix<<" Col:"<<iz<<endl;
+ UInt_t dummyDDL, dummyHS, chip, col, row;
AliITSRawStreamSPD::OfflineToOnline(mod,iz,ix,dummyDDL,dummyHS,chip,col,row);
// insert digit into map...
// (reverse order of cols and rows as in real raw data)
- digMap->Insert(chip*256*32+(32-col)*256+(256-row),row);
+ digMap->Insert(chip*256*32+(31-col)*256+(255-row),row);
}
}
+ // _______________________________________________________________________
+ // Procedure for writing raw data (Henrik Tydesjo)
+ // Reimplemented because of unreadability (5 Mar 2009)
+ // Now also with fast-or signals
+ Int_t previousChip = chipLow-1;
+ Int_t chip = chipLow-1;
+ UInt_t chipHitCount = 0;
+
+
UInt_t nrHits = digMap->GetNrEntries();
- if (nrHits>0) {
- Int_t chip = 0;
- for (UInt_t nHit=0; nHit<nrHits; nHit++) {
- Int_t key = digMap->GetKeyIndex(nHit);
- chip = key/(256*32);
- Int_t col = 32 - (key%(256*32))/256;
- Int_t row = digMap->GetValIndex(nHit);
-
- if(previousChip==-1) { // first hit
- //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=chipLow; i<chip; i++) {
- WriteChipHeader(i,hs,baseWord);
- WriteChipTrailer(buf,0,baseWord);
- }
- WriteChipHeader(chip,hs,baseWord);
- WriteHit(buf,row,col,baseWord);
- chipHitCount++;
- previousChip=chip;
- }//end if
- else{
- if(previousChip!=(Int_t)chip) {
- WriteChipTrailer(buf,chipHitCount,baseWord);
- chipHitCount=0;
- for(Int_t i=previousChip+1; i<chip; i++) {
- WriteChipHeader(i,hs,baseWord);
- WriteChipTrailer(buf,0,baseWord);
- }//end for
- WriteChipHeader(chip,hs,baseWord);
- previousChip=chip;
- }//end if
- chipHitCount++;
- WriteHit(buf,row,col,baseWord);
- }//end else
- }//end for
- //Even if there aren't digits for a given chip
- //the chip header and the chip trailer are stored
- WriteChipTrailer(buf,chipHitCount,baseWord);
- chipHitCount=0;
- for(Int_t i=chip+1;i<=chipHigh;i++){
- WriteChipHeader(i,hs,baseWord);
- WriteChipTrailer(buf,0,baseWord);
- }//end for
- }//end if
- else{
- //In this module there aren't digits but
- //the chip header and chip trailer are stored anyway
- for(Int_t i=chipLow; i<=chipHigh; i++){
- WriteChipHeader(i,hs,baseWord);
- WriteChipTrailer(buf,0,baseWord);
- }//end for
- }//end else
+ for (UInt_t nHit=0; nHit<nrHits; nHit++) {
+
+ Int_t key = digMap->GetKeyIndex(nHit);
+ chip = key/(256*32);
+ Int_t col = 31 - (key%(256*32))/256;
+ Int_t row = digMap->GetValIndex(nHit);
+
+ // add trailer for previous chip (if there was one...)
+ if (chip>previousChip && previousChip>chipLow-1) {
+ WriteChipTrailer(buf, chipHitCount, foSignals->GetSignal(eq,hs,previousChip), baseWord);
+ }
+
+ // add headers/trailers for chips without hits (if any)
+ for (Int_t ch=previousChip+1; ch<chip; ch++) {
+ WriteChipHeader(ch, hs, baseWord);
+ WriteChipTrailer(buf, 0, foSignals->GetSignal(eq,hs,ch), baseWord);
+ }
+
+ // if new chip, add header
+ if (chip>previousChip) {
+ WriteChipHeader(chip, hs, baseWord);
+ chipHitCount = 0;
+ previousChip = chip;
+ }
+
+ chipHitCount++;
+
+ // add pixel hit
+ WriteHit(buf,row,col,baseWord);
+
+ }
+
+ // add trailer for last chip (if there was one...)
+ if (chip>chipLow-1) {
+ WriteChipTrailer(buf, chipHitCount, foSignals->GetSignal(eq,hs,chip), baseWord);
+ }
+
+ // add REMAINING headers/trailers for chips without hits (if any)
+ for (Int_t ch=chip+1; ch<=chipHigh; ch++) {
+ WriteChipHeader(ch, hs, baseWord);
+ WriteChipTrailer(buf, 0, foSignals->GetSignal(eq,hs,ch), baseWord);
+ }
+ // _______________________________________________________________________
+
delete digMap;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-Int_t AliITSDDLRawData::RawDataSPD(TBranch* branch){
+Int_t AliITSDDLRawData::RawDataSPD(TBranch* branch, AliITSFOSignalsSPD* foSignals){
//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];
+ TString fileName;
AliFstream* outfile; // logical name of the output file
AliRawDataHeaderSim header;
//loop over DDLs
- for(Int_t i=0;i<AliDAQ::NumberOfDdls("ITSSPD");i++){
- strcpy(fileName,AliDAQ::DdlFileName("ITSSPD",i)); //The name of the output file.
- outfile = new AliFstream(fileName);
+ for(Int_t ddl=0;ddl<AliDAQ::NumberOfDdls("ITSSPD");ddl++){
+ fileName.Form("%s",AliDAQ::DdlFileName("ITSSPD",ddl)); //The name of the output file.
+ outfile = new AliFstream(fileName.Data());
//write Dummy DATA HEADER
UInt_t dataHeaderPosition=outfile->Tellp();
outfile->WriteBuffer((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);
+ Int_t moduleNumber = AliITSRawStreamSPD::GetModuleNumber(ddl, 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,mod,i,buf);
+ GetDigitsSPD(digits, moduleNumber, ddl, buf, foSignals);
outfile->WriteBuffer((char *)buf,((fIndex+1)*sizeof(UInt_t)));
for(Int_t i=0;i<(fIndex+1);i++){
buf[i]=0;
fIndex=-1;
TClonesArray*& digits = * (TClonesArray**) branch->GetAddress();
- char fileName[15];
+ TString fileName;
AliFstream* outfile; // logical name of the output file
AliRawDataHeaderSim header;
//loop over DDLs
for(Int_t i=0;i<AliDAQ::NumberOfDdls("ITSSSD");i++){
- strcpy(fileName,AliDAQ::DdlFileName("ITSSSD",i)); //The name of the output file.
- outfile = new AliFstream(fileName);
+ fileName.Form("%s",AliDAQ::DdlFileName("ITSSSD",i)); //The name of the output file.
+ outfile = new AliFstream(fileName.Data());
//write Dummy DATA HEADER
UInt_t dataHeaderPosition=outfile->Tellp();
outfile->WriteBuffer((char*)(&header),sizeof(header));
fIndex=-1;
TClonesArray*& digits = * (TClonesArray**) branch->GetAddress();
- char fileName[15];
+ TString fileName;
AliFstream* outfile; // logical name of the output file
AliRawDataHeaderSim header;
+
+ if(fSDDRawFormat!=0){
+ for(Int_t ibit=0; ibit<8; ibit++) header.SetAttribute(ibit);
+ }else{
+ for(Int_t ibit=0; ibit<5; ibit++) header.SetAttribute(ibit);
+ for(Int_t ibit=5; ibit<8; ibit++) header.ResetAttribute(ibit);
+ }
UInt_t skippedword, carlosFooterWord,fifoFooterWord,jitterWord;
Bool_t retcode;
retcode = AliBitPacking::PackWord(0x3FFFFFFF,carlosFooterWord,0,31);
retcode = AliBitPacking::PackWord(0x3F1F1F1F,fifoFooterWord,0,31);
- retcode = AliBitPacking::PackWord(0x7F00000E,jitterWord,0,31);
-
+ if(fSDDRawFormat!=0) retcode = AliBitPacking::PackWord(0x7F000000,jitterWord,0,31);
+ else retcode = AliBitPacking::PackWord(0x80000000,jitterWord,0,31);
+
//loop over DDLs
for(Int_t i=0;i<AliDAQ::NumberOfDdls("ITSSDD");i++){
- strcpy(fileName,AliDAQ::DdlFileName("ITSSDD",i)); //The name of the output file.
- outfile = new AliFstream(fileName);
+ fileName.Form("%s",AliDAQ::DdlFileName("ITSSDD",i)); //The name of the output file.
+ outfile = new AliFstream(fileName.Data());
//write Dummy DATA HEADER
UInt_t dataHeaderPosition=outfile->Tellp();
outfile->WriteBuffer((char*)(&header),sizeof(header));
//first 1 "dummy" word to be skipped
- retcode = AliBitPacking::PackWord(0xFFFFFFFF,skippedword,0,31);
- outfile->WriteBuffer((char*)(&skippedword),sizeof(skippedword));
+ if(fSDDRawFormat!=0){
+ retcode = AliBitPacking::PackWord(0xFFFFFFFF,skippedword,0,31);
+ outfile->WriteBuffer((char*)(&skippedword),sizeof(skippedword));
+ }
//Loops over Modules of a particular DDL
for (Int_t mod=0; mod<AliITSRawStreamSDD::kModulesPerDDL; mod++){
//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->WriteBuffer((char *)buf,((fIndex+1)*sizeof(UInt_t)));
- for(Int_t iw=0;iw<3;iw++) outfile->WriteBuffer((char*)(&carlosFooterWord),sizeof(carlosFooterWord));
+ if(fSDDRawFormat==0){
+ GetDigitsSDDCompressed(digits,mod,buf);
+ outfile->WriteBuffer((char *)buf,((fIndex+1)*sizeof(UInt_t)));
+ }else{
+ GetDigitsSDD(digits,mod,moduleNumber,i,buf);
+ outfile->WriteBuffer((char *)buf,((fIndex+1)*sizeof(UInt_t)));
+ for(Int_t iw=0;iw<3;iw++) outfile->WriteBuffer((char*)(&carlosFooterWord),sizeof(carlosFooterWord));
+ }
fIndex=-1;
}//end if
}//end for
// 12 words with FIFO footers (=4 FIFO x 3 3F1F1F1F words per DDL)
- for(Int_t iw=0;iw<12;iw++) outfile->WriteBuffer((char*)(&fifoFooterWord),sizeof(fifoFooterWord));
-
+ if(fSDDRawFormat!=0){
+ for(Int_t iw=0;iw<12;iw++) outfile->WriteBuffer((char*)(&fifoFooterWord),sizeof(fifoFooterWord));
+ }
outfile->WriteBuffer((char*)(&jitterWord),sizeof(jitterWord));
-
//Write REAL DATA HEADER
UInt_t currentFilePosition=outfile->Tellp();
outfile->Seekp(dataHeaderPosition);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AliITSDDLRawData::WriteChipTrailer(UInt_t *buf,Int_t ChipHitCount,UInt_t &BaseWord){
+void AliITSDDLRawData::WriteChipTrailer(UInt_t *buf, Int_t ChipHitCount, Bool_t foBit, UInt_t &BaseWord){
//This method writes a chip trailer
//pixel fill word
if((ChipHitCount%2)!=0){
AliBitPacking::PackWord(0xC000,BaseWord,16,31);
}
- AliBitPacking::PackWord(ChipHitCount,BaseWord,0,13);
+ AliBitPacking::PackWord(ChipHitCount,BaseWord,0,11);
+ AliBitPacking::PackWord(0x0,BaseWord,12,12);
+ AliBitPacking::PackWord(foBit,BaseWord,13,13);
AliBitPacking::PackWord(0x0,BaseWord,14,15);
fIndex++;
buf[fIndex]=BaseWord;