-/* $Id$
-// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>, Anders Vestbo <mailto:vestbo$fi.uib.no>
-// -- Copyright © Uli
-// changes done by Constantin Loizides <mailto:loizides@ikf.physik.uni-frankfurt.de>
-*/
-
-#include <math.h>
-#include <time.h>
-#include <iostream.h>
-#include <stdio.h>
-#include <string.h>
+// @(#) $Id$
-#include "AliL3MemHandler.h"
-#include "AliL3Transform.h"
-#include "AliL3Logging.h"
-
-#include "AliL3DigitData.h"
-#include "AliL3TrackSegmentData.h"
-#include "AliL3SpacePointData.h"
-#include "AliL3TrackArray.h"
+// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>, Anders Vestbo <mailto:vestbo$fi.uib.no>, Constantin Loizides <mailto:loizides@ikf.uni-frankfurt.de>
+//*-- Copyright © ALICE HLT Group
/** \class AliL3MemHandler
+<pre>
//_____________________________________________________________
// AliL3MemHandler
//
//
// AliL3MemHandler file;
// file.SetBinaryInput(filename);
+// file.Init(slice,patch);
+//
+// UInt_t nrowss;
+// AliL3DigitRowData *data = file.CompBinary2Memory(nrows);
//
-// UInt_t ndigits;
-// AliL3DigitRowData *data = file.CompBinary2Memory(ndigits);
-//
-// for(int i=0; i<NumberOfRowsInPatch; i++)
+// for(int i=0; i<nrows; i++)
// {
//
// AliL3DigitData *dataPt = (AliL3DigitData*)data->fDigitData;
// for(int j=0; j<data->fNDigit; j++)
// {
-// pad = dataPt[j].fPad;
-// time = dataPt[j].fTime;
-// charge = dataPt[j].fCharge;
-// }
+// pad = dataPt[j].fPad;
+// time = dataPt[j].fTime;
+// charge = dataPt[j].fCharge;
+// }
//
// file.UpdateRowPointer(data);
//
// //into a new file, you can do the following:
//
// AliL3MemHandler newfile;
+// newfile.Init(slice,patch);
// newfile.SetBinaryOutput(newfilename);
// newfile.Memory2CompBinary((UInt_t)NumberOfRowsInPatch,(AliL3DigitRowData*)data);
// newfile.CloseBinaryOutput();
// -----------------------
//
// The data is RLE encoded and currently using _10_ bit range for the ADC-values.
-</pre> */
+</pre>
+*/
+
+#include "AliL3RootTypes.h"
+#include "AliL3StandardIncludes.h"
+#include "AliL3DigitData.h"
+#include "AliL3Logging.h"
+#include "AliL3Transform.h"
+#include "AliL3TrackSegmentData.h"
+#include "AliL3SpacePointData.h"
+#include "AliL3TrackArray.h"
+#include "AliL3MemHandler.h"
+
+#if __GNUC__ >= 3
+using namespace std;
+#endif
ClassImp(AliL3MemHandler)
AliL3MemHandler::AliL3MemHandler()
-{
+{
//Constructor
-
fPt = 0;
fSize =0;
fInBinary = 0;
fOutBinary = 0;
fNRandom = 0;
Init(0,0);
- IsRandom = kFALSE;
- fDigits = 0;
+ fIsRandom = kFALSE;
+ fRandomDigits = 0;
fDPt =0;
fNGenerate = 0;
fNUsed = 0;
{
//Destructor
if(fPt) delete[] fPt;
- if(fDigits) delete [] fDigits;
+ if(fRandomDigits) delete [] fRandomDigits;
if(fDPt) delete [] fDPt;
}
-void AliL3MemHandler::Init(Int_t s,Int_t p, Int_t *r=0)
+void AliL3MemHandler::Init(Int_t s,Int_t p, Int_t *r)
{
+ //init handler
fSlice=s;fPatch=p;
if(r) {
fRowMin=r[0];
void AliL3MemHandler::ResetROI()
{
//Resets the Look-up table for Region of Interest mode.
-
for(Int_t i=fRowMin; i<=fRowMax; i++)
{
fEtaMinTimeBin[i] = 0;
- fEtaMaxTimeBin[i] = 445;
+ fEtaMaxTimeBin[i] = AliL3Transform::GetNTimeBins()-1;
}
}
-void AliL3MemHandler::SetROI(Float_t *eta,Int_t *slice)
+void AliL3MemHandler::SetROI(Float_t *eta,Int_t */*slice*/)
{
// Init the Look-up table for the Region of Interest mode.
// Here you can specify a certain etaregion, - all data
Bool_t AliL3MemHandler::SetBinaryInput(char *name)
{
//Set the input binary file.
-
fInBinary = fopen(name,"r");
if(!fInBinary){
LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryInput","File Open")
Bool_t AliL3MemHandler::SetBinaryInput(FILE *file)
{
//Set the input binary file.
-
fInBinary = file;
if(!fInBinary){
LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryInput","File Open")
void AliL3MemHandler::CloseBinaryInput()
{
//Close the input file.
-
if(!fInBinary){
LOG(AliL3Log::kWarning,"AliL3MemHandler::CloseBinaryInput","File Close")
<<"Nothing to Close"<<ENDLOG;
Bool_t AliL3MemHandler::SetBinaryOutput(FILE *file)
{
//Set the binary output file.
-
- fOutBinary = file;
+ fOutBinary = file;
if(!fOutBinary){
LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryOutput","File Open")
<<"Pointer to File = 0x0 "<<ENDLOG;
void AliL3MemHandler::CloseBinaryOutput()
{
+ //close binary
if(!fOutBinary){
LOG(AliL3Log::kWarning,"AliL3MemHandler::CloseBinaryOutPut","File Close")
<<"Nothing to Close"<<ENDLOG;
UInt_t AliL3MemHandler::GetFileSize()
{
//Returns the file size in bytes of the input file.
-
if(!fInBinary){
LOG(AliL3Log::kWarning,"AliL3MemHandler::GetFileSize","File")
<<"No Input File"<<ENDLOG;
Byte_t *AliL3MemHandler::Allocate()
{
+ //Allocate
return Allocate(GetFileSize());
}
Byte_t *AliL3MemHandler::Allocate(AliL3TrackArray *array)
{
//Allocate memory for tracks in memory. Used by TrackArray2Binary()
-
if(!array){
LOG(AliL3Log::kWarning,"AliL3MemHandler::Allocate","Memory")
<<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
Byte_t *AliL3MemHandler::Allocate(UInt_t size)
{
//Allocate memory of size in bytes.
-
if(fPt){
LOG(AliL3Log::kWarning,"AliL3MemHandler::Allocate","Memory")
<<"Delete Memory"<<ENDLOG;
void AliL3MemHandler::Free()
{
//Clear the memory, if allocated.
-
if(!fPt){
- LOG(AliL3Log::kWarning,"AliL3MemHandler::Free","Memory")
- <<"No Memory allocated - can't Free"<<ENDLOG;
+ // LOG(AliL3Log::kInformational,"AliL3MemHandler::Free","Memory")
+ // <<"No Memory allocated - can't Free"<<ENDLOG;
return;
}
delete[] fPt;
{
//If you are adding random data to the original data.
- IsRandom = kTRUE;
+ fIsRandom = kTRUE;
fNRandom = maxnumber;
fNDigits = 0;
- if(fDigits) delete [] fDigits;
- fDigits = new AliL3RandomDigitData[fNRandom*9];
+ if(fRandomDigits) delete [] fRandomDigits;
+ fRandomDigits = new AliL3RandomDigitData[fNRandom*9];
if(fDPt) delete [] fDPt;
fDPt = new AliL3RandomDigitData *[fNRandom*9];
}
-void AliL3MemHandler::QSort(AliL3RandomDigitData **a, Int_t first, Int_t last){
+void AliL3MemHandler::QSort(AliL3RandomDigitData **a, Int_t first, Int_t last)
+{
// Sort array of AliL3RandomDigitData pointers using a quicksort algorithm.
// Uses CompareDigits() to compare objects.
}
}
-UInt_t AliL3MemHandler::GetRandomSize()
+UInt_t AliL3MemHandler::GetRandomSize() const
{
+ //get random size
Int_t nrandom = 0;
for(Int_t r=fRowMin;r<=fRowMax;r++){
Int_t npad=AliL3Transform::GetNPads(r);
void AliL3MemHandler::Generate(Int_t row)
{
- //Generate random data on row, if you didn't ask for this, nothing happens here.
+ //Generate random data on row, if you didn't
+ //ask for this, nothing happens here.
- if(!IsRandom) return;
+ if(!fIsRandom) return;
ResetRandom();
fNDigits = 0;
Int_t npad=AliL3Transform::GetNPads(row);
for(Int_t n=0;n<nrandom;n++){
Int_t pad = (int)((float)rand()/RAND_MAX*npad);
Int_t time =(int)((float)rand()/RAND_MAX*ntime+fEtaMinTimeBin[row] );
- Int_t charge = (int)((float)rand()/RAND_MAX*1023);
+ Int_t charge = (int)((float)rand()/RAND_MAX*AliL3Transform::GetADCSat());
DigitizePoint(row,pad,time,charge);
}
QSort(fDPt,0,fNDigits);
- // for(Int_t d=0;d<fNDigits;d++)
- // fprintf(stderr,"%d %d %d %d\n",fDPt[d]->fRow,fDPt[d]->fPad,
- // fDPt[d]->fTime,fDPt[d]->fCharge);
}
if(dpad<0||dpad>=AliL3Transform::GetNPads(row)) continue;
if(dtime<0||dtime>=AliL3Transform::GetNTimeBins()) continue;
- fDigits[fNDigits].fCharge = dcharge;
- fDigits[fNDigits].fRow = row;
- fDigits[fNDigits].fPad = dpad;
- fDigits[fNDigits].fTime = dtime;
- fDPt[fNDigits] = &fDigits[fNDigits];
+ fRandomDigits[fNDigits].fCharge = dcharge;
+ fRandomDigits[fNDigits].fRow = row;
+ fRandomDigits[fNDigits].fPad = dpad;
+ fRandomDigits[fNDigits].fTime = dtime;
+ fDPt[fNDigits] = &fRandomDigits[fNDigits];
fNDigits++;
}
}
return kFALSE;
}
- AliL3DigitRowData *row_pt = data;
+ AliL3DigitRowData *rowPt = data;
Int_t outsize = 0;
for(UInt_t i=0;i<nrow;i++){
- Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit
+ Int_t size = sizeof(AliL3DigitData) * rowPt->fNDigit
+ sizeof(AliL3DigitRowData);
outsize += size;
- fwrite(row_pt,size,1,fOutBinary);
- Byte_t *byte_pt =(Byte_t *) row_pt;
- byte_pt += size;
- row_pt = (AliL3DigitRowData *) byte_pt;
+ fwrite(rowPt,size,1,fOutBinary);
+ Byte_t *bytePt =(Byte_t *) rowPt;
+ bytePt += size;
+ rowPt = (AliL3DigitRowData *) bytePt;
}
LOG(AliL3Log::kDebug,"AliL3MemHandler::Memory2Binary","Memory")
<<AliL3Log::kDec<<"Wrote "<<outsize<<" Bytes to Memory ("
Bool_t AliL3MemHandler::Binary2Memory(UInt_t & nrow,AliL3DigitRowData *data)
{
- //Read inputfile into memory as is, and store it in data. No run-length encoding
- // is assumed.
+ //Read inputfile into memory as is, and store it in data.
+ // No run-length encoding is assumed.
if(!fInBinary){
LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","File")
return kFALSE;
}
rewind(fInBinary);
- AliL3DigitRowData *row_pt = data;
+ AliL3DigitRowData *rowPt = data;
UInt_t rowcount = 0;
Int_t outsize =0;
while(!feof(fInBinary)){
- Byte_t *byte_pt =(Byte_t *) row_pt;
+ Byte_t *bytePt =(Byte_t *) rowPt;
- if(fread(row_pt,sizeof(AliL3DigitRowData),1,fInBinary)!=1) break;
- byte_pt += sizeof(AliL3DigitRowData);
+ if(fread(rowPt,sizeof(AliL3DigitRowData),1,fInBinary)!=1) break;
+
+ bytePt += sizeof(AliL3DigitRowData);
outsize += sizeof(AliL3DigitRowData);
- Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit;
-
- if(fread(byte_pt,size,1,fInBinary)!=1) break;
- byte_pt += size;
- outsize += size;
+ Int_t size = sizeof(AliL3DigitData) * rowPt->fNDigit;
- row_pt = (AliL3DigitRowData *) byte_pt;
+ //if(fread(bytePt,size,1,fInBinary)!=1) break;
+ fread(bytePt,size,1,fInBinary);
+ bytePt += size;
+ outsize += size;
+ rowPt = (AliL3DigitRowData *) bytePt;
rowcount++;
}
nrow= rowcount;
}
void AliL3MemHandler::AddData(AliL3DigitData *data,UInt_t & ndata,
- UInt_t row,UShort_t pad,UShort_t time,UShort_t charge)
+ UInt_t /*row*/,UShort_t pad,UShort_t time,UShort_t charge) const
{
+ //add some data
data[ndata].fPad = pad;
data[ndata].fTime = time;
data[ndata].fCharge = charge;
void AliL3MemHandler::AddRandom(AliL3DigitData *data, UInt_t & ndata)
{
+ //add some random data
data[ndata].fPad = fDPt[fNUsed]->fPad;
data[ndata].fTime = fDPt[fNUsed]->fTime;
data[ndata].fCharge = fDPt[fNUsed]->fCharge;
void AliL3MemHandler::MergeDataRandom(AliL3DigitData *data, UInt_t & ndata,
UInt_t row, UShort_t pad, UShort_t time, UShort_t charge)
{
+ //merge random data
data[ndata].fPad = pad;
data[ndata].fTime = time;
data[ndata].fCharge = charge;
while(ComparePoints(row,pad,time)==0){
Int_t ch = data[ndata].fCharge + fDPt[fNUsed]->fCharge;
- if(charge>1023) ch = 1023;
+ if(charge>=AliL3Transform::GetADCSat()) ch = AliL3Transform::GetADCSat();
data[ndata].fCharge = ch;
fNUsed++;
}
void AliL3MemHandler::AddDataRandom(AliL3DigitData *data, UInt_t & ndata,
UInt_t row, UShort_t pad, UShort_t time, UShort_t charge)
{
+ //add data random
Int_t action;
while((action=ComparePoints(row,pad,time))==1){
AddRandom(data,ndata);
}
void AliL3MemHandler::Write(UInt_t *comp, UInt_t & index,
- UInt_t & subindex, UShort_t value)
+ UInt_t & subindex, UShort_t value) const
{
+ //write compressed data
UInt_t shift[3] = {0,10,20};
if(subindex==0) comp[index] =0; //clean up memory
comp[index] |= (value&0x03ff)<<shift[subindex];
else subindex++;
}
-UShort_t AliL3MemHandler::Read(UInt_t *comp, UInt_t & index, UInt_t & subindex)
-{
+UShort_t AliL3MemHandler::Read(UInt_t *comp, UInt_t & index, UInt_t & subindex) const
+{
+ //read compressed data
UInt_t shift[3] = {0,10,20};
UShort_t value = (comp[index]>>shift[subindex])&0x03ff;
if(subindex == 2){
}
UShort_t AliL3MemHandler::Test(UInt_t *comp,
- UInt_t index, UInt_t subindex)
+ UInt_t index, UInt_t subindex) const
{
+ //supi dupi test
UInt_t shift[3] = {0,10,20};
return (comp[index]>>shift[subindex])&0x03ff;
}
<<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
return 0;
}
- AliL3DigitRowData *row_pt = data;
+ AliL3DigitRowData *rowPt = data;
UInt_t index=0;
UInt_t subindex=0;
for(UInt_t i=0;i<nrow;i++){
- UShort_t value = row_pt->fRow;
+ UShort_t value = rowPt->fRow;
Write(comp,index,subindex,value);
UShort_t maxpad=0;
UShort_t npad=0;
Int_t ddd[1000];
for(Int_t d=0;d<200;d++) ddd[d]=0;
- for(UInt_t dig=0;dig<row_pt->fNDigit;dig++){
- if(row_pt->fDigitData[dig].fPad <200){
- ddd[row_pt->fDigitData[dig].fPad]++;
+ for(UInt_t dig=0;dig<rowPt->fNDigit;dig++){
+ if(rowPt->fDigitData[dig].fPad <200){
+ ddd[rowPt->fDigitData[dig].fPad]++;
}
}
for(Int_t d=0;d<200;d++){
Write(comp,index,subindex,npad);
UInt_t digit=0;
for(UShort_t pad=0;pad <= maxpad;pad++){
- if(digit>=row_pt->fNDigit || row_pt->fDigitData[digit].fPad != pad)
+ if(digit>=rowPt->fNDigit || rowPt->fDigitData[digit].fPad != pad)
continue;
Write(comp,index,subindex,pad);
// write zero if time != 0
- if(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
- if(row_pt->fDigitData[digit].fTime>0){
+ if(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){
+ if(rowPt->fDigitData[digit].fTime>0){
Write(comp,index,subindex,0);
- Write(comp,index,subindex,row_pt->fDigitData[digit].fTime);
+ Write(comp,index,subindex,rowPt->fDigitData[digit].fTime);
}
}
- while(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
- UShort_t charge = row_pt->fDigitData[digit].fCharge;
- if(charge>=1024){
+ while(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){
+ UShort_t charge = rowPt->fDigitData[digit].fCharge;
+ if(charge>=1023){
charge=1023;
}
Write(comp,index,subindex,charge);
- if(digit+1<row_pt->fNDigit&&row_pt->fDigitData[digit+1].fPad == pad){
- if(row_pt->fDigitData[digit].fTime +1 !=
- row_pt->fDigitData[digit+1].fTime){
+ if(digit+1<rowPt->fNDigit&&rowPt->fDigitData[digit+1].fPad == pad){
+ if(rowPt->fDigitData[digit].fTime +1 !=
+ rowPt->fDigitData[digit+1].fTime){
Write(comp,index,subindex,0);
- UShort_t nzero = row_pt->fDigitData[digit+1].fTime -
- (row_pt->fDigitData[digit].fTime +1);
+ UShort_t nzero = rowPt->fDigitData[digit+1].fTime -
+ (rowPt->fDigitData[digit].fTime +1);
Write(comp,index,subindex,nzero);
}
}
Write(comp,index,subindex,0);
Write(comp,index,subindex,0);
}
-
- Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+
+
+ Int_t size = sizeof(AliL3DigitData) * rowPt->fNDigit+
sizeof(AliL3DigitRowData);
- Byte_t *byte_pt =(Byte_t *) row_pt;
- byte_pt += size;
- row_pt = (AliL3DigitRowData *) byte_pt;
+ Byte_t *bytePt =(Byte_t *) rowPt;
+ bytePt += size;
+ rowPt = (AliL3DigitRowData *) bytePt;
}
while(subindex)
Write(comp,index,subindex,0);
{
//Uncompress the run-length encoded data in memory pointed to by comp, and
// store it in data.
-
+
if(!comp){
LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2Memory","Memory")
<<"Pointer to compressed data = 0x0 "<<ENDLOG;
}
Int_t outsize=0;
- AliL3DigitRowData *row_pt = data;
+ AliL3DigitRowData *rowPt = data;
UInt_t index=0;
UInt_t subindex=0;
for(UInt_t i=0;i<nrow;i++){
UInt_t ndigit=0;
UInt_t row =Read(comp,index,subindex);
- row_pt->fRow=row;
+ rowPt->fRow=row;
Generate(row);
UShort_t npad = Read(comp,index,subindex);
for(UShort_t p=0;p<npad;p++){
for(;;){
while( (charge=Read(comp,index,subindex)) != 0){
if(time>=fEtaMinTimeBin[row]&&time<=fEtaMaxTimeBin[row])
- // AddData(row_pt->fDigitData,ndigit,row,pad,time,charge);
- AddDataRandom(row_pt->fDigitData,ndigit,row,pad,time,charge);
+ //AddData(rowPt->fDigitData,ndigit,row,pad,time,charge);
+ //seems we are using this function... but dont know why
+ AddDataRandom(rowPt->fDigitData,ndigit,row,pad,time,charge);
time++;
}
UShort_t tshift = Read(comp,index,subindex);
- if(tshift ==0) break;
+ if(tshift == 0) break;
time += tshift;
}
}
- row_pt->fNDigit = ndigit;
- Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+
+ rowPt->fNDigit = ndigit;
+ Int_t size = sizeof(AliL3DigitData) * rowPt->fNDigit+
sizeof(AliL3DigitRowData);
- Byte_t *byte_pt =(Byte_t *) row_pt;
- byte_pt += size;
+ Byte_t *bytePt =(Byte_t *) rowPt;
+ bytePt += size;
outsize += size;
- row_pt = (AliL3DigitRowData *) byte_pt;
+ rowPt = (AliL3DigitRowData *) bytePt;
}
return outsize;
}
-UInt_t AliL3MemHandler::GetCompMemorySize(UInt_t nrow,AliL3DigitRowData *data)
+UInt_t AliL3MemHandler::GetCompMemorySize(UInt_t nrow,AliL3DigitRowData *data) const
{
//Return the size of RLE data, after compressing data.
<<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
return 0;
}
- AliL3DigitRowData *row_pt = data;
+ AliL3DigitRowData *rowPt = data;
UInt_t index=0;
for(UInt_t i=0;i<nrow;i++){
UShort_t npad=0;
Int_t ddd[1000];
for(Int_t d=0;d<200;d++) ddd[d]=0;
- for(UInt_t dig=0;dig<row_pt->fNDigit;dig++){
- if(row_pt->fDigitData[dig].fPad <200){
- ddd[row_pt->fDigitData[dig].fPad]++;
+ for(UInt_t dig=0;dig<rowPt->fNDigit;dig++){
+ if(rowPt->fDigitData[dig].fPad <200){
+ ddd[rowPt->fDigitData[dig].fPad]++;
}
}
for(Int_t d=0;d<200;d++){
index++;
UInt_t digit=0;
for(UShort_t pad=0;pad <= maxpad;pad++){
- if(digit>=row_pt->fNDigit || row_pt->fDigitData[digit].fPad != pad)
+ if(digit>=rowPt->fNDigit || rowPt->fDigitData[digit].fPad != pad)
continue;
index++;
// write zero if time != 0
- if(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
- if(row_pt->fDigitData[digit].fTime>0){
+ if(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){
+ if(rowPt->fDigitData[digit].fTime>0){
index++;
index++;
}
}
- while(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
+ while(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){
index++;
- if(digit+1<row_pt->fNDigit&&row_pt->fDigitData[digit+1].fPad == pad){
- if(row_pt->fDigitData[digit].fTime +1 !=
- row_pt->fDigitData[digit+1].fTime){
+ if(digit+1<rowPt->fNDigit&&rowPt->fDigitData[digit+1].fPad == pad){
+ if(rowPt->fDigitData[digit].fTime +1 !=
+ rowPt->fDigitData[digit+1].fTime){
index++;
index++;
}
index++;
}
- Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+
+ Int_t size = sizeof(AliL3DigitData) * rowPt->fNDigit+
sizeof(AliL3DigitRowData);
- Byte_t *byte_pt =(Byte_t *) row_pt;
- byte_pt += size;
- row_pt = (AliL3DigitRowData *) byte_pt;
+ Byte_t *bytePt =(Byte_t *) rowPt;
+ bytePt += size;
+ rowPt = (AliL3DigitRowData *) bytePt;
}
while(index%3)
index++;
return (index/3) * sizeof(UInt_t);
}
-UInt_t AliL3MemHandler::GetMemorySize(UInt_t nrow,UInt_t *comp){
+UInt_t AliL3MemHandler::GetMemorySize(UInt_t nrow,UInt_t *comp) const
+{
+ //get memory size
if(!comp){
LOG(AliL3Log::kWarning,"AliL3MemHandler::GetMemorySize","Memory")
<<"Pointer to compressed data = 0x0 "<<ENDLOG;
UInt_t AliL3MemHandler::GetNRow(UInt_t *comp,UInt_t size)
{
+ //get number of rows
if(!comp){
LOG(AliL3Log::kWarning,"AliL3MemHandler::GetNRow","Memory")
<<"Pointer to compressed data = 0x0 "<<ENDLOG;
AliL3DigitRowData *AliL3MemHandler::CompBinary2Memory(UInt_t & nrow)
{
// Read the RLE inputfile, unpack it and return the pointer to it.
-
AliL3MemHandler * handler = new AliL3MemHandler();
handler->SetBinaryInput(fInBinary);
UInt_t *comp =(UInt_t *)handler->Allocate();
}
Int_t size = GetFileSize();
-/*
- UInt_t size,slice,patch,row[2];
- AliL3EventDataTypeRoot datatype;
- UInt_t node;
- if(fread(&datatype,sizeof(AliL3EventDataTypeRoot),1,fInBinary)!=1){
- LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
- <<"File Read Error "<<ENDLOG;
- return kFALSE;
- }
- if(fread(&node,sizeof(UInt_t),1,fInBinary)!=1){
- LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
- <<"File Read Error "<<ENDLOG;
- return kFALSE;
- }
- if(fread(&size,sizeof(UInt_t),1,fInBinary)!=1){
- LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
- <<"File Read Error "<<ENDLOG;
- return kFALSE;
- }
- if(fread(&slice,sizeof(UInt_t),1,fInBinary)!=1){
- LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
- <<"File Read Error "<<ENDLOG;
- return kFALSE;
- }
- if(fread(&patch,sizeof(UInt_t),1,fInBinary)!=1){
- LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
- <<"File Read Error "<<ENDLOG;
- return kFALSE;
- }
- if(fread(row,2*sizeof(UInt_t),1,fInBinary)!=1){
- LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
- <<"File Read Error "<<ENDLOG;
+ npoint = size/sizeof(AliL3SpacePointData);
+ if(size==0) {
+ LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","File")
+ <<"File Size == 0"<<ENDLOG;
return kFALSE;
}
-*/
- npoint = size/sizeof(AliL3SpacePointData);
+
if(fread(data,size,1,fInBinary)!=1){
LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
<<"File Read Error "<<ENDLOG;
<<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
return kFALSE;
}
- AliL3TrackSegmentData *track_pt = data;
+ AliL3TrackSegmentData *trackPt = data;
for(UInt_t i=0;i<ntrack;i++){
- Int_t size=sizeof(AliL3TrackSegmentData)+track_pt->fNPoints*sizeof(UInt_t);
- fwrite(track_pt,size,1,fOutBinary);
- Byte_t *byte_pt = (Byte_t*) track_pt;
- byte_pt += size;
- track_pt = (AliL3TrackSegmentData*) byte_pt;
+ Int_t size=sizeof(AliL3TrackSegmentData)+trackPt->fNPoints*sizeof(UInt_t);
+ fwrite(trackPt,size,1,fOutBinary);
+ Byte_t *bytePt = (Byte_t*) trackPt;
+ bytePt += size;
+ trackPt = (AliL3TrackSegmentData*) bytePt;
}
LOG(AliL3Log::kDebug,"AliL3MemHandler::Memory2Binary","File")
<<AliL3Log::kDec<<"Wrote "<<ntrack<<" Tracks to File"<<ENDLOG;
Bool_t AliL3MemHandler::Binary2Memory(UInt_t & ntrack,AliL3TrackSegmentData *data)
{
//Read the tracks in inputfile, and store it in data.
-
if(!fInBinary){
LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","File")
<<"No Input File"<<ENDLOG;
}
ntrack=0;
- AliL3TrackSegmentData *track_pt = data;
+ AliL3TrackSegmentData *trackPt = data;
rewind(fInBinary);
-/*
- UInt_t size,slice,patch,row[2];
- AliL3EventDataTypeRoot datatype;
- UInt_t node;
- if(fread(&datatype,sizeof(AliL3EventDataTypeRoot),1,fInBinary)!=1){
- LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
- <<"File Read Error "<<ENDLOG;
- return kFALSE;
- }
- if(fread(&node,sizeof(UInt_t),1,fInBinary)!=1){
- LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
- <<"File Read Error "<<ENDLOG;
- return kFALSE;
- }
- if(fread(&size,sizeof(UInt_t),1,fInBinary)!=1){
- LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
- <<"File Read Error "<<ENDLOG;
- return kFALSE;
- }
- if(fread(&slice,sizeof(UInt_t),1,fInBinary)!=1){
- LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
- <<"File Read Error "<<ENDLOG;
- return kFALSE;
- }
- if(fread(&patch,sizeof(UInt_t),1,fInBinary)!=1){
- LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
- <<"File Read Error "<<ENDLOG;
- return kFALSE;
- }
- if(fread(row,2*sizeof(UInt_t),1,fInBinary)!=1){
- LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
- <<"File Read Error "<<ENDLOG;
- return kFALSE;
- }
-*/
+
while(!feof(fInBinary)){
- if(fread(track_pt,sizeof(AliL3TrackSegmentData),1,fInBinary)!=1) break;
- Int_t size=track_pt->fNPoints*sizeof(UInt_t);
- if(fread(track_pt->fPointIDs,size,1,fInBinary)!=1) break;
- Byte_t *byte_pt = (Byte_t*) track_pt;
- byte_pt += sizeof(AliL3TrackSegmentData)+size;
- track_pt = (AliL3TrackSegmentData*) byte_pt;
+ if(fread(trackPt,sizeof(AliL3TrackSegmentData),1,fInBinary)!=1) break;
+ Int_t size=trackPt->fNPoints*sizeof(UInt_t);
+ if(fread(trackPt->fPointIDs,size,1,fInBinary)!=1) break;
+ Byte_t *bytePt = (Byte_t*) trackPt;
+ bytePt += sizeof(AliL3TrackSegmentData)+size;
+ trackPt = (AliL3TrackSegmentData*) bytePt;
ntrack++;
}
LOG(AliL3Log::kDebug,"AliL3MemHandler::Binary2Memory","File")
return kFALSE;
}
AliL3TrackSegmentData *data = (AliL3TrackSegmentData *)Allocate(array);
+
UInt_t ntrack;
TrackArray2Memory(ntrack,data,array);
Memory2Binary(ntrack,data);
return kTRUE;
}
-Bool_t AliL3MemHandler::TrackArray2Memory(UInt_t & ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array)
+Bool_t AliL3MemHandler::TrackArray2Memory(UInt_t & ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array) const
{
//Fill the trackarray into the AliTrackSegmentData structures before writing to outputfile.
if(!data){
<<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
return kFALSE;
}
+
array->WriteTracks(ntrack,data);
return kTRUE;
}
-Bool_t AliL3MemHandler::Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array)
+Bool_t AliL3MemHandler::Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array) const
{
//Fill the tracks in data into trackarray.
return kTRUE;
}
-Bool_t AliL3MemHandler::Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array,Int_t slice)
+Bool_t AliL3MemHandler::Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array,Int_t slice) const
{
//Fill the tracks in data into trackarray, and rotate the tracks to global coordinates.
tmp += size;
tempPt = (AliL3DigitRowData*)tmp;
}
+
+Int_t AliL3MemHandler::ComparePoints(UInt_t /*row*/,UShort_t pad,UShort_t time) const
+{
+ //compare two points
+ if(fNUsed>=fNDigits) return -2;
+
+ if(pad==fDPt[fNUsed]->fPad&&time==fDPt[fNUsed]->fTime) return 0;
+
+ if(pad<fDPt[fNUsed]->fPad) return -1;
+ if(pad==fDPt[fNUsed]->fPad&&time<fDPt[fNUsed]->fTime) return -1;
+
+ return 1;
+}
+
+Int_t AliL3MemHandler::CompareDigits(AliL3RandomDigitData *a,AliL3RandomDigitData *b) const
+{
+ //compare two digits
+ if(a->fPad==b->fPad && a->fTime == b->fTime) return 0;
+
+ if(a->fPad<b->fPad) return -1;
+ if(a->fPad==b->fPad && a->fTime<b->fTime) return -1;
+
+ return 1;
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff