-/* $Id$
-// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
-// -- Copyright © Uli
+// $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 <stdio.h>
#include <string.h>
-#include "AliL3MemHandler.h"
-#include "AliL3Transform.h"
#include "AliL3Logging.h"
-
-#include "AliL3DigitData.h"
+#include "AliL3Transform.h"
#include "AliL3TrackSegmentData.h"
#include "AliL3SpacePointData.h"
#include "AliL3TrackArray.h"
+#include "AliL3MemHandler.h"
-/** \class AliL3MemHandler
-// _____________________________________________________________
+/** \class AliL3MemHandler
+//<pre>
+//_____________________________________________________________
// AliL3MemHandler
//
-// The L3 Binary File handler
+// The HLT Binary File handler
//
-//
-// This class does all the memory I/O handling on raw binary files.
-// For the moment the compressed binary files are run-length encoded, using
-// 10 bit digits.
+// This class does all the memory I/O handling of HLT binary files.
//
// Examples:
-//
+// ---------
+//
// 1) Reading a binary file:
//
// AliL3MemHandler file;
// file.SetBinaryInput(filename);
//
-// UInt_t ndigits;
-// AliL3DigitRowData *data = file.CompBinary2Memory(ndigits);
+// UInt_t nrowss;
+// AliL3DigitRowData *data = file.CompBinary2Memory(nrowss);
//
-// for(int i=0; i<NumberOfRowsInPatch; i++)
+// for(int i=0; i<nrows; i++)
// {
//
// AliL3DigitData *dataPt = (AliL3DigitData*)data->fDigitData;
// newfile.SetBinaryOutput(newfilename);
// newfile.Memory2CompBinary((UInt_t)NumberOfRowsInPatch,(AliL3DigitRowData*)data);
// newfile.CloseBinaryOutput();
-*/
-
+//
+//
+// Compressed file format:
+// -----------------------
+//
+// The data is RLE encoded and currently using _10_ bit range for the ADC-values.
+//</pre>
+*/
+
ClassImp(AliL3MemHandler)
AliL3MemHandler::AliL3MemHandler()
fInBinary = 0;
fOutBinary = 0;
fNRandom = 0;
- Int_t r[2]={0,0};
- Init(0,0,r);
+ Init(0,0);
IsRandom = kFALSE;
fDigits = 0;
fDPt =0;
fNGenerate = 0;
fNUsed = 0;
fNDigits = 0;
-
- Int_t row[2] = {0,175};
- Init(0,0,row);
ResetROI();
}
if(fDPt) delete [] fDPt;
}
+void AliL3MemHandler::Init(Int_t s,Int_t p, Int_t *r=0)
+{
+ fSlice=s;fPatch=p;
+ if(r) {
+ fRowMin=r[0];
+ fRowMax=r[1];
+ }else{
+ fRowMin=AliL3Transform::GetFirstRow(p);
+ fRowMax=AliL3Transform::GetLastRow(p);
+ }
+ ResetROI();
+}
+
void AliL3MemHandler::ResetROI()
{
//Resets the Look-up table for Region of Interest mode.
}
}
-
void AliL3MemHandler::SetROI(Float_t *eta,Int_t *slice)
{
// Init the Look-up table for the Region of Interest mode.
Float_t thetamax = 2*atan(exp(-1.*eta[1]));
- xyz[0] = fTransformer->Row2X(i);
+ xyz[0] = AliL3Transform::Row2X(i);
xyz[1]=0;
xyz[2] = xyz[0]/tan(thetamax);
- fTransformer->Slice2Sector(fSlice,i,sector,row);
- fTransformer->Local2Raw(xyz,sector,row);
+ AliL3Transform::Slice2Sector(fSlice,i,sector,row);
+ AliL3Transform::Local2Raw(xyz,sector,row);
fEtaMinTimeBin[i] = (Int_t)xyz[2];
else
{
Float_t thetamin = 2*atan(exp(-1.*eta[0]));
- xyz[0] = fTransformer->Row2X(i);
- xyz[1] = fTransformer->GetMaxY(i);
+ xyz[0] = AliL3Transform::Row2X(i);
+ xyz[1] = AliL3Transform::GetMaxY(i);
Float_t radii = sqrt(pow(xyz[0],2) + pow(xyz[1],2));
xyz[2] = radii/tan(thetamin);
- fTransformer->Local2Raw(xyz,sector,row);
+ AliL3Transform::Local2Raw(xyz,sector,row);
fEtaMaxTimeBin[i] = (Int_t)xyz[2];
}
}
Bool_t AliL3MemHandler::SetBinaryOutput(char *name)
{
//Set the binary output file.
- fOutBinary = fopen(name,"w");
+ fOutBinary = fopen(name,"w");
if(!fOutBinary){
LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryOutput","File Open")
<<"Pointer to File = 0x0 "<<ENDLOG;
{
Int_t nrandom = 0;
for(Int_t r=fRowMin;r<=fRowMax;r++){
- Int_t npad=fTransformer->GetNPads(r);
+ Int_t npad=AliL3Transform::GetNPads(r);
nrandom += Int_t (fNGenerate * ((Double_t) npad/141.));
}
return 9 * nrandom * sizeof(AliL3DigitData);
if(!IsRandom) return;
ResetRandom();
fNDigits = 0;
- Int_t npad=fTransformer->GetNPads(row);
+ Int_t npad=AliL3Transform::GetNPads(row);
Int_t ntime = fEtaMaxTimeBin[row] - fEtaMinTimeBin[row];
Int_t nrandom = Int_t (fNGenerate * ((Double_t) npad/141.) *
- (Double_t) ntime/(Double_t) fTransformer->GetNTimeBins() );
+ (Double_t) ntime/(Double_t) AliL3Transform::GetNTimeBins() );
for(Int_t n=0;n<nrandom;n++){
Int_t pad = (int)((float)rand()/RAND_MAX*npad);
Int_t dpad = j + pad;
Int_t dtime = k + time;
- if(dpad<0||dpad>=fTransformer->GetNPads(row)) continue;
- if(dtime<0||dtime>=fTransformer->GetNTimeBins()) continue;
+ if(dpad<0||dpad>=AliL3Transform::GetNPads(row)) continue;
+ if(dtime<0||dtime>=AliL3Transform::GetNTimeBins()) continue;
fDigits[fNDigits].fCharge = dcharge;
fDigits[fNDigits].fRow = row;
return kTRUE;
}
-Bool_t AliL3MemHandler::Transform(UInt_t npoint,AliL3SpacePointData *data,
- Int_t slice, AliL3Transform* trans)
+Bool_t AliL3MemHandler::Transform(UInt_t npoint,AliL3SpacePointData *data,Int_t slice)
{
//Transform the space points in data, to global coordinates in slice.
if(!data){
<<"Pointer to AliL3SpacePointData = 0x0 "<<ENDLOG;
return kFALSE;
}
- if(!trans){
- LOG(AliL3Log::kWarning,"AliL3MemHandler::Transform","Object")
- <<"Pointer to AliL3Transform = 0x0 "<<ENDLOG;
- return kFALSE;
- }
+
for(UInt_t i=0;i<npoint;i++){
Float_t xyz[3];
xyz[0] = data[i].fX;
xyz[1] = data[i].fY;
xyz[2] = data[i].fZ;
- trans->Local2Global(xyz,slice);
+ AliL3Transform::Local2Global(xyz,slice);
data[i].fX = xyz[0];
data[i].fY = xyz[1];
data[i].fZ = xyz[2];
return kFALSE;
}
AliL3TrackSegmentData *data = (AliL3TrackSegmentData *)Allocate(array);
+
UInt_t ntrack;
TrackArray2Memory(ntrack,data,array);
Memory2Binary(ntrack,data);
<<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
return kFALSE;
}
+
array->WriteTracks(ntrack,data);
return kTRUE;
}
return kTRUE;
}
-Bool_t AliL3MemHandler::Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array,Int_t slice,
- AliL3Transform* trans)
+Bool_t AliL3MemHandler::Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array,Int_t slice)
{
//Fill the tracks in data into trackarray, and rotate the tracks to global coordinates.
-
+
if(!data){
LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
<<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
<<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
return kFALSE;
}
- if(!trans){
- LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Object")
- <<"Pointer to AliL3Transform = 0x0 "<<ENDLOG;
- return kFALSE;
- }
- array->FillTracks(ntrack,data,slice,trans);
+ array->FillTracks(ntrack,data,slice);
return kTRUE;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff