[u/mrichter/AliRoot.git] / HLT / src / AliLevel3.cxx

//Author:        Uli Frankenfeld
//Author:        Anders Strand Vestbo
//Last Modified: 13.12.2000

#include "AliL3Logging.h"

#include <TFile.h>
#include <TDirectory.h>
#include <TClonesArray.h>
#include <TStopwatch.h>
#include <iostream.h>

//#include <AliTPCcluster.h>
//#include "AliTPCParam.h"
#include "AliLevel3.h"
#include "AliL3ConfMapper.h"
#include "AliL3Vertex.h"
#include "AliL3VertexFinder.h"
#include "AliL3TrackMerger.h"
#include "AliL3GlobalMerger.h"
#include "AliL3InterMerger.h"
#include "AliL3ConfMapPoint.h"
#include "AliL3ConfMapTrack.h"
#include "AliL3Transform.h"
#include "AliL3ClustFinder.h"
#include "AliL3DigitData.h"
#include "AliL3TrackArray.h"
#include "AliL3MemHandler.h"
#include "AliL3FileHandler.h"
#include "AliL3Benchmark.h"

#include "AliL3DigitData.h"
#include "AliL3TrackSegmentData.h"
#include "AliL3SpacePointData.h"
#include "AliL3VertexData.h"

//_______________________________________
//
//  AliLevel3
//
//  Interface class for Level3 tracker.
//  Tracking is done by calling constructor with input,output 
//  given as argument. 
//  You must always remember to set the tracking parameters. E.g.:
// 
//  AliLevel3 *level3 = new AliLevel3(inputfile,outputfile);
//  level3->SetTrackerParam(); //Sets default tracking parameters
//  level3->ProcessSector(2,2);  //Does tracking on sector 2 (actually 2+38)

ClassImp(AliLevel3)

AliLevel3::AliLevel3(){
  fInputFile=0;
  fOutputFile=0;
  Init();
}

AliLevel3::AliLevel3(Char_t *infile,Char_t *outfile){
  //Constructor. Calls constructor of the tracker, vertexfinder and merger classes.

  fOutputFile = new TFile(outfile,"NEW");
  
  if(!fOutputFile->IsOpen())
    {
    LOG(AliL3Log::kWarning, "AliLevel3::AliLevel3","File Open")
    <<"Delete your old "<<outfile<<" file!"<<ENDLOG;
    }
  fInputFile = new TFile(infile,"READ");
  
  if(!fInputFile->IsOpen())
    {
    LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open")
    <<"Inputfile "<<infile<<" does not exist"<<ENDLOG;
    return;
    }
  
  Init();
}

AliLevel3::AliLevel3(TFile *in, TFile *out){
  fOutputFile = out;
  fInputFile  =  in;
  if(!in){
    LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open")
    <<"Pointer to InFile 0x0!"<<ENDLOG;
    return;
  }  
  if(!out){
    LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open")
    <<"Pointer to OutFile 0x0!"<<ENDLOG;
    return;
  }  
  
  if(!fOutputFile->IsOpen())
    {
    LOG(AliL3Log::kWarning,"AliLevel3::AliLevel3","File Open")
    <<"no output file!"<<ENDLOG;
      return;
    }
  if(!fInputFile->IsOpen())
    {
    LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open")
    <<"Inputfile does not exist"<<ENDLOG;
      return;
    }
  Init();
}

void AliLevel3::Init(){
  fWriteOut = kFALSE;
  fGlobalMerger=0;
  fTransformer = new AliL3Transform();
  fDoRoi = kFALSE;
  fUseBinary =kFALSE;
  SetPath("");
  fFindVertex =kTRUE;
  fNPatch = 5;   //number of patches change row in process 
  fVertexFinder = new AliL3VertexFinder();
  fVertex = new AliL3Vertex();
  fTracker = new AliL3ConfMapper();
  fTrackMerger = new AliL3TrackMerger(fNPatch);
  fInterMerger = new AliL3InterMerger();
  fFileHandler = new AliL3FileHandler();
  fFileHandler->SetAliInput(fInputFile);
  fBenchmark = new AliL3Benchmark();
}

void AliLevel3::DoBench(char* name){
  fBenchmark->Analyze(name);
}

void AliLevel3::DoMc(char* file){
  if(!fFileHandler->IsDigit())
    fFileHandler->SetMCOutput(file);
}

AliLevel3::~AliLevel3(){
  //Destructor
  if(fVertexFinder)  delete fVertexFinder;
  if(fVertex)  delete fVertex;
  if(fTracker) delete fTracker;
  if(fTransformer) delete fTransformer;
  if(fTrackMerger) delete fTrackMerger;
  if(fInterMerger) delete fInterMerger;
  if(fFileHandler) delete fFileHandler;
}

void AliLevel3::SetTrackerParam(Int_t phi_segments, Int_t eta_segments,
				   Int_t trackletlength, Int_t tracklength,
				   Int_t rowscopetracklet, Int_t rowscopetrack,
				   Double_t min_pt_fit, Double_t maxangle,
				   Double_t goodDist, Double_t hitChi2Cut,
				   Double_t goodHitChi2, Double_t trackChi2Cut,
				   Int_t maxdist)
{
  //Set parameters input to the tracker
  //If no arguments are given, default parameters will be used
  
  fTracker->SetNSegments(phi_segments,eta_segments);
  fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
  fTracker->SetMaxDca(min_pt_fit);
  fTracker->SetTrackletCuts(maxangle,goodDist,true);
  fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist);

  fTracker->SetParamDone(true);
}

void AliLevel3::ProcessEvent(Int_t first,Int_t last){
  //Do tracking on all slices in region [first,last]
  //Slices numbering in TPC goes from 0-35, which means that 1 slice
  //corresponds to inner+outer sector.E.g. slice 2 corresponds to
  //inner=2 + outer=38.
  fGlobalMerger= new AliL3GlobalMerger(first,last);  
  for(Int_t i=first; i<=last; i++){
    ProcessSlice(i);
    fGlobalMerger->SetVertex(fVertex);
    fGlobalMerger->SetTransformer(fTransformer);
    fGlobalMerger->InitSlice(i);
    fBenchmark->Start("Fill Global Merger");
    fGlobalMerger->FillTracks(fNTrackData,fTrackData);
    fBenchmark->Stop("Fill Global Merger");
    fFileHandler->Free();   //free the memory
    fNTrackData=0;
    fTrackData=0;
  }
  fBenchmark->Start("Global Merger");
  fGlobalMerger->Merge();
//  fGlobalMerger->SlowMerge();
  fBenchmark->Stop("Global Merger");

  if(fWriteOut) WriteResults(); 
  delete fGlobalMerger; fGlobalMerger = 0;
}

void AliLevel3::ProcessSlice(Int_t slice){
  char name[256];
  Bool_t isdigit = fFileHandler->IsDigit();
//  Int_t row[5][2] = {{ 0,173}};
  Int_t row[5][2] = {{ 0, 45},{46,77},{78,109},{110,141},{142,173}};
  const Int_t maxpoints=100000;
  const Int_t pointsize = maxpoints * sizeof(AliL3SpacePointData);
  AliL3MemHandler *memory = new AliL3MemHandler();

  fTrackMerger->Reset();
  fTrackMerger->SetTransformer(fTransformer);
  fTrackMerger->SetRows(row[0]);
  for(Int_t patch=fNPatch-1;patch>=0;patch--){
    fFileHandler->Init(slice,patch,row[patch]);
    fFileHandler->Init(fTransformer);
    UInt_t npoints=0;
    AliL3SpacePointData *points =0;
    UInt_t ndigits=0;
    AliL3DigitRowData *digits =0;
    if(fUseBinary){

      if(!fDoRoi){ 
        if(0){     //Binary to Memory
          fFileHandler->Free();
          sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
          fFileHandler->SetBinaryInput(name);
          digits= (AliL3DigitRowData *)fFileHandler->CompBinary2Memory(ndigits);
          fFileHandler->CloseBinaryInput(); 
        }

        if(1){     //Binary to Memory with Benchmark 
          fFileHandler->Free();
          sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
          memory->SetBinaryInput(name);
          UInt_t compsize=memory->GetFileSize();
          UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
          memory->CompBinary2CompMemory(ndigits,comp);
          memory->CloseBinaryInput();
          UInt_t datasize=memory->GetMemorySize(ndigits,comp);
          digits=(AliL3DigitRowData *)fFileHandler->Allocate(datasize);
          fBenchmark->Start("Unpacker"); 
          fFileHandler->CompMemory2Memory(ndigits,digits,comp); 
          fBenchmark->Stop("Unpacker");
          memory->Free();
        }
  
        if(0){     //Binary to Memory with Random
          fFileHandler->Free();
          fFileHandler->ResetRandom();
          fFileHandler->SetRandomCluster(100);
          fFileHandler->SetNGenerate(100);
          sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
          memory->SetBinaryInput(name);
          UInt_t compsize=memory->GetFileSize();
          UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
          memory->CompBinary2CompMemory(ndigits,comp);
          memory->CloseBinaryInput();
          UInt_t dsize=memory->GetMemorySize(ndigits,comp);
          UInt_t rsize=fFileHandler->GetRandomSize();       
          digits=(AliL3DigitRowData*)fFileHandler->Allocate(dsize+rsize);
          fBenchmark->Start("Unpacker");
          fFileHandler->CompMemory2Memory(ndigits,digits,comp); 
          fBenchmark->Stop("Unpacker");
          memory->Free();
          if(1)
            cerr<<endl<<dsize/1024<<" "<<rsize/1024<<" "
                                    <<100.*rsize/dsize<<"%"<<endl;
        }
      }

      else{     //Binary to Memory with Roi
        fFileHandler->Free();
        Int_t sli[2]={0,0};
        fFileHandler->SetROI(fEta,sli);
        sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
        memory->SetBinaryInput(name);
        UInt_t compsize=memory->GetFileSize();
        UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
        memory->CompBinary2CompMemory(ndigits,comp);
        memory->CloseBinaryInput();
        UInt_t datasize=memory->GetMemorySize(ndigits,comp);
        digits=(AliL3DigitRowData *)fFileHandler->Allocate(datasize);
        fBenchmark->Start("Unpacker"); 
        datasize = fFileHandler->CompMemory2Memory(ndigits,digits,comp); 
        fBenchmark->Stop("Unpacker"); 
        memory->Free();
        if(1)
         cerr<<endl<<datasize/1024<<" "<<endl;
      }


      points = (AliL3SpacePointData *) memory->Allocate(pointsize);
  
      fClusterFinder = new AliL3ClustFinder(fTransformer);
      fClusterFinder->InitSlice(slice,patch,row[patch][0],row[patch][1]
                                                               ,maxpoints);
      fClusterFinder->SetXYError(0.1);
      fClusterFinder->SetZError(0.2);
      fClusterFinder->SetOutputArray(points);
      fBenchmark->Start("Read Cluster Finder");
      fClusterFinder->Read(ndigits,digits);
      fBenchmark->Stop("Read Cluster Finder");
      fBenchmark->Start("Cluster Finder");
      fClusterFinder->ProcessDigits();
      fBenchmark->Stop("Cluster Finder");
      npoints = fClusterFinder->GetNumberOfClusters();
      delete fClusterFinder;
      fClusterFinder =0;
      fFileHandler->Free();

    LOG(AliL3Log::kInformational,"AliLevel3::ProcessSlice","Cluster Finder")
      <<AliL3Log::kDec<<"Found "<<npoints<<" Points"<<ENDLOG;
    }

    else{
      if(isdigit){
        sprintf(name,"digits_%d_%d.raw",slice,patch);
   
        if(0){    //Ali to Binary
          fFileHandler->SetBinaryOutput(name);
          fFileHandler->AliDigits2CompBinary();
          fFileHandler->CloseBinaryOutput();
        }
  
        if(1){     //Ali to Memory
          digits=(AliL3DigitRowData *)fFileHandler->AliDigits2Memory(ndigits);
          if(fWriteOut){   //Memory to Binary
            fFileHandler->SetBinaryOutput(name);
            fFileHandler->Memory2CompBinary(ndigits,digits);
            fFileHandler->CloseBinaryOutput();
          }
        }
      }
      else   points = fFileHandler->AliPoints2Memory(npoints);
    }

    if(patch == fNPatch-1){
      // Vertex
      if(fFindVertex){
      // Vertex Finder
      
        fBenchmark->Start("Vertex Finder Read");
        fVertexFinder->Reset();
        fVertexFinder->Read(npoints,points);
        fBenchmark->Stop("Vertex Finder Read"); 
        fBenchmark->Start("Vertex Finder");
        fVertexFinder->Analyze();
        AliL3VertexData vertex[1];
        fVertexFinder->Write(vertex);
        fVertex->Read(vertex);
        fBenchmark->Stop("Vertex Finder"); 
      }
      else{
        //use 0,0,0 for vertex
        fVertex->SetZero();
      }
      fTrackMerger->SetVertex(fVertex);
    }
    fTracker->InitSector(slice,row[patch]);
    fTracker->SetVertex(fVertex);
    fBenchmark->Start("Tracker Read Hits");
    fTracker->ReadHits(npoints,points);
    fBenchmark->Stop("Tracker Read Hits");
    fBenchmark->Start("MainVertexTracking A"); 
    fTracker->MainVertexTracking_a();
    fBenchmark->Stop("MainVertexTracking A");
    fBenchmark->Start("MainVertexTracking B"); 
    fTracker->MainVertexTracking_b();
    fBenchmark->Stop("MainVertexTracking B");
    fBenchmark->Start("Tracking fit");
    fTracker->FillTracks();
    fBenchmark->Stop("Tracking fit");

    if(fWriteOut) 
       WriteSpacePoints(npoints, points, slice, patch); //do after Tracking
    fFileHandler->Free();

    UInt_t ntracks0 =0;
    AliL3TrackSegmentData *trackdata0  = 
         (AliL3TrackSegmentData *) memory->Allocate(fTracker->GetTracks());
    memory->TrackArray2Memory(ntracks0,trackdata0,fTracker->GetTracks());
    
    //write tracks
    if(fWriteOut){
      sprintf(name,"tracks_tr_%d_%d.raw",slice,patch);
      memory->SetBinaryOutput(name);
      memory->Memory2Binary(ntracks0,trackdata0);
      memory->CloseBinaryOutput();
    }
    
    fInterMerger->Reset();
    fInterMerger->SetTransformer(fTransformer);
    fInterMerger->Init(row[patch],patch);

    fBenchmark->Start("Fill Inter Merger");
    fInterMerger->FillTracks(ntracks0,trackdata0);
    fBenchmark->Stop("Fill Inter Merger");
    fBenchmark->Start("Inter Merger");
    fInterMerger->Merge();
//    fInterMerger->SlowMerge();
    
    fBenchmark->Stop("Inter Merger");

    //write inter merged tracks
    if(fWriteOut){
      sprintf(name,"tracks_im_%d_%d.raw",slice,patch);
      WriteTracks(name,fInterMerger,'i'); //write output of intermerger
    }
    memory->Free();
    
    UInt_t ntracks1 =0;
    AliL3TrackSegmentData *trackdata1 =
      (AliL3TrackSegmentData *) memory->Allocate(fInterMerger->GetInTracks(0));
    memory->TrackArray2Memory(ntracks1,trackdata1,fInterMerger->GetInTracks(0));

    fTrackMerger->InitSector(slice,patch);
    fBenchmark->Start("Fill Patch Merger");
    fTrackMerger->FillTracks(ntracks1,trackdata1);
    fBenchmark->Stop("Fill Patch Merger");

    memory->Free();
  }
  fBenchmark->Start("Patch Merger");
//  fTrackMerger->SlowMerge();
  fTrackMerger->Merge();
  fBenchmark->Stop("Patch Merger");
  //write merged tracks
  if(fWriteOut){
    sprintf(name,"tracks_tm_%d.raw",slice);
    WriteTracks(name,fTrackMerger,'o'); //write output of trackmerger
  }
 
  fTrackData = (AliL3TrackSegmentData *) 
                         fFileHandler->Allocate(fTrackMerger->GetOutTracks());

  fFileHandler->TrackArray2Memory(fNTrackData,fTrackData,
                                                fTrackMerger->GetOutTracks());

  delete memory;
}

void AliLevel3::WriteSpacePoints(UInt_t npoints,AliL3SpacePointData *points,
                                                      Int_t slice,Int_t patch){
  char name[256];
  sprintf(name,"points_%d_%d.raw",slice,patch);
  AliL3MemHandler * memory = new AliL3MemHandler();
  memory->SetBinaryOutput(name);
  memory->Transform(npoints,points,slice,fTransformer);
  memory->Memory2Binary(npoints,points);
  memory->CloseBinaryOutput();
  delete  memory;
}


Int_t AliLevel3::WriteTracks(char *filename,AliL3Merger *merger,char opt){
  AliL3FileHandler *memory = new AliL3FileHandler();
  memory->SetBinaryOutput(filename);
  if(opt=='a'||opt=='i'){  //add intracks
    for(Int_t i=0;i<merger->GetNIn();i++){
      AliL3TrackArray *tr=merger->GetInTracks(i);
      memory->TrackArray2Binary(tr);
    }
  }

  if(opt=='o'||opt=='a'){
    AliL3TrackArray *tr=merger->GetOutTracks();
    memory->TrackArray2Binary(tr);
  }

  memory->CloseBinaryOutput();
 
  return 1;
}

void AliLevel3::WriteResults()
{
  //Write the resulting tracks to outputfile
  WriteTracks("tracks.raw",fGlobalMerger,'a');
}
Commit	Line	Data
108615fc	1	//Author: Uli Frankenfeld
	2	//Author: Anders Strand Vestbo
	3	//Last Modified: 13.12.2000
	4
	5	#include "AliL3Logging.h"
	6
	7	#include <TFile.h>
	8	#include <TDirectory.h>
	9	#include <TClonesArray.h>
	10	#include <TStopwatch.h>
	11	#include <iostream.h>
	12
	13	//#include <AliTPCcluster.h>
	14	//#include "AliTPCParam.h"
	15	#include "AliLevel3.h"
	16	#include "AliL3ConfMapper.h"
	17	#include "AliL3Vertex.h"
	18	#include "AliL3VertexFinder.h"
	19	#include "AliL3TrackMerger.h"
	20	#include "AliL3GlobalMerger.h"
	21	#include "AliL3InterMerger.h"
	22	#include "AliL3ConfMapPoint.h"
	23	#include "AliL3ConfMapTrack.h"
	24	#include "AliL3Transform.h"
	25	#include "AliL3ClustFinder.h"
	26	#include "AliL3DigitData.h"
	27	#include "AliL3TrackArray.h"
	28	#include "AliL3MemHandler.h"
	29	#include "AliL3FileHandler.h"
	30	#include "AliL3Benchmark.h"
	31
	32	#include "AliL3DigitData.h"
	33	#include "AliL3TrackSegmentData.h"
	34	#include "AliL3SpacePointData.h"
	35	#include "AliL3VertexData.h"
	36
	37	//_______________________________________
	38	//
	39	// AliLevel3
	40	//
	41	// Interface class for Level3 tracker.
	42	// Tracking is done by calling constructor with input,output
	43	// given as argument.
	44	// You must always remember to set the tracking parameters. E.g.:
	45	//
	46	// AliLevel3 *level3 = new AliLevel3(inputfile,outputfile);
	47	// level3->SetTrackerParam(); //Sets default tracking parameters
	48	// level3->ProcessSector(2,2); //Does tracking on sector 2 (actually 2+38)
	49
	50	ClassImp(AliLevel3)
	51
	52	AliLevel3::AliLevel3(){
	53	fInputFile=0;
	54	fOutputFile=0;
	55	Init();
	56	}
	57
	58	AliLevel3::AliLevel3(Char_t infile,Char_t outfile){
	59	//Constructor. Calls constructor of the tracker, vertexfinder and merger classes.
	60
	61	fOutputFile = new TFile(outfile,"NEW");
	62
	63	if(!fOutputFile->IsOpen())
	64	{
65	LOG(AliL3Log::kWarning, "AliLevel3::AliLevel3","File Open")
66	<<"Delete your old "<<outfile<<" file!"<<ENDLOG;
67	}
68	fInputFile = new TFile(infile,"READ");
69
70	if(!fInputFile->IsOpen())
71	{
72	LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open")
73	<<"Inputfile "<<infile<<" does not exist"<<ENDLOG;
74	return;
75	}
76
77	Init();
78	}
79
80	AliLevel3::AliLevel3(TFile in, TFile out){
81	fOutputFile = out;
82	fInputFile = in;
83	if(!in){
84	LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open")
85	<<"Pointer to InFile 0x0!"<<ENDLOG;
86	return;
87	}
88	if(!out){
89	LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open")
90	<<"Pointer to OutFile 0x0!"<<ENDLOG;
91	return;
92	}
93
94	if(!fOutputFile->IsOpen())
95	{
96	LOG(AliL3Log::kWarning,"AliLevel3::AliLevel3","File Open")
97	<<"no output file!"<<ENDLOG;
98	return;
99	}
100	if(!fInputFile->IsOpen())
101	{
102	LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open")
103	<<"Inputfile does not exist"<<ENDLOG;
104	return;
105	}
106	Init();
107	}
108
109	void AliLevel3::Init(){
110	fWriteOut = kFALSE;
111	fGlobalMerger=0;
112	fTransformer = new AliL3Transform();
113	fDoRoi = kFALSE;
114	fUseBinary =kFALSE;
115	SetPath("");
116	fFindVertex =kTRUE;
117	fNPatch = 5; //number of patches change row in process
118	fVertexFinder = new AliL3VertexFinder();
119	fVertex = new AliL3Vertex();
120	fTracker = new AliL3ConfMapper();
121	fTrackMerger = new AliL3TrackMerger(fNPatch);
122	fInterMerger = new AliL3InterMerger();
123	fFileHandler = new AliL3FileHandler();
124	fFileHandler->SetAliInput(fInputFile);
125	fBenchmark = new AliL3Benchmark();
126	}
127
128	void AliLevel3::DoBench(char* name){
129	fBenchmark->Analyze(name);
130	}
131
132	void AliLevel3::DoMc(char* file){
133	if(!fFileHandler->IsDigit())
134	fFileHandler->SetMCOutput(file);
135	}
136
137	AliLevel3::~AliLevel3(){
138	//Destructor
139	if(fVertexFinder) delete fVertexFinder;
140	if(fVertex) delete fVertex;
141	if(fTracker) delete fTracker;
142	if(fTransformer) delete fTransformer;
143	if(fTrackMerger) delete fTrackMerger;
144	if(fInterMerger) delete fInterMerger;
145	if(fFileHandler) delete fFileHandler;
146	}
147
148	void AliLevel3::SetTrackerParam(Int_t phi_segments, Int_t eta_segments,
149	Int_t trackletlength, Int_t tracklength,
150	Int_t rowscopetracklet, Int_t rowscopetrack,
151	Double_t min_pt_fit, Double_t maxangle,
152	Double_t goodDist, Double_t hitChi2Cut,
153	Double_t goodHitChi2, Double_t trackChi2Cut,
154	Int_t maxdist)
155	{
156	//Set parameters input to the tracker
157	//If no arguments are given, default parameters will be used
158
159	fTracker->SetNSegments(phi_segments,eta_segments);
160	fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
161	fTracker->SetMaxDca(min_pt_fit);
162	fTracker->SetTrackletCuts(maxangle,goodDist,true);
163	fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist);
164
165	fTracker->SetParamDone(true);
166	}
167
168	void AliLevel3::ProcessEvent(Int_t first,Int_t last){
169	//Do tracking on all slices in region [first,last]
170	//Slices numbering in TPC goes from 0-35, which means that 1 slice
171	//corresponds to inner+outer sector.E.g. slice 2 corresponds to
172	//inner=2 + outer=38.
173	fGlobalMerger= new AliL3GlobalMerger(first,last);
174	for(Int_t i=first; i<=last; i++){
175	ProcessSlice(i);
176	fGlobalMerger->SetVertex(fVertex);
177	fGlobalMerger->SetTransformer(fTransformer);
178	fGlobalMerger->InitSlice(i);
179	fBenchmark->Start("Fill Global Merger");
180	fGlobalMerger->FillTracks(fNTrackData,fTrackData);
181	fBenchmark->Stop("Fill Global Merger");
182	fFileHandler->Free(); //free the memory
183	fNTrackData=0;
184	fTrackData=0;
185	}
186	fBenchmark->Start("Global Merger");
187	fGlobalMerger->Merge();
188	// fGlobalMerger->SlowMerge();
189	fBenchmark->Stop("Global Merger");
190
191	if(fWriteOut) WriteResults();
192	delete fGlobalMerger; fGlobalMerger = 0;
193	}
194
195	void AliLevel3::ProcessSlice(Int_t slice){
196	char name[256];
197	Bool_t isdigit = fFileHandler->IsDigit();
198	// Int_t row[5][2] = {{ 0,173}};
199	Int_t row[5][2] = {{ 0, 45},{46,77},{78,109},{110,141},{142,173}};
200	const Int_t maxpoints=100000;
201	const Int_t pointsize = maxpoints * sizeof(AliL3SpacePointData);
202	AliL3MemHandler *memory = new AliL3MemHandler();
203
204	fTrackMerger->Reset();
205	fTrackMerger->SetTransformer(fTransformer);
206	fTrackMerger->SetRows(row[0]);
207	for(Int_t patch=fNPatch-1;patch>=0;patch--){
208	fFileHandler->Init(slice,patch,row[patch]);
209	fFileHandler->Init(fTransformer);
210	UInt_t npoints=0;
211	AliL3SpacePointData *points =0;
212	UInt_t ndigits=0;
213	AliL3DigitRowData *digits =0;
214	if(fUseBinary){
215
216	if(!fDoRoi){
217	if(0){ //Binary to Memory
218	fFileHandler->Free();
219	sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
220	fFileHandler->SetBinaryInput(name);
221	digits= (AliL3DigitRowData *)fFileHandler->CompBinary2Memory(ndigits);
222	fFileHandler->CloseBinaryInput();
223	}
224
225	if(1){ //Binary to Memory with Benchmark
226	fFileHandler->Free();
227	sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
228	memory->SetBinaryInput(name);
229	UInt_t compsize=memory->GetFileSize();
230	UInt_t comp=(UInt_t )memory->Allocate(compsize);
231	memory->CompBinary2CompMemory(ndigits,comp);
232	memory->CloseBinaryInput();
233	UInt_t datasize=memory->GetMemorySize(ndigits,comp);
234	digits=(AliL3DigitRowData *)fFileHandler->Allocate(datasize);
235	fBenchmark->Start("Unpacker");
236	fFileHandler->CompMemory2Memory(ndigits,digits,comp);
237	fBenchmark->Stop("Unpacker");
238	memory->Free();
239	}
240
241	if(0){ //Binary to Memory with Random
242	fFileHandler->Free();
243	fFileHandler->ResetRandom();
244	fFileHandler->SetRandomCluster(100);
245	fFileHandler->SetNGenerate(100);
246	sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
247	memory->SetBinaryInput(name);
248	UInt_t compsize=memory->GetFileSize();
249	UInt_t comp=(UInt_t )memory->Allocate(compsize);
250	memory->CompBinary2CompMemory(ndigits,comp);
251	memory->CloseBinaryInput();
252	UInt_t dsize=memory->GetMemorySize(ndigits,comp);
253	UInt_t rsize=fFileHandler->GetRandomSize();
254	digits=(AliL3DigitRowData*)fFileHandler->Allocate(dsize+rsize);
255	fBenchmark->Start("Unpacker");
256	fFileHandler->CompMemory2Memory(ndigits,digits,comp);
257	fBenchmark->Stop("Unpacker");
258	memory->Free();
259	if(1)
260	cerr<<endl<<dsize/1024<<" "<<rsize/1024<<" "
261	<<100.*rsize/dsize<<"%"<<endl;
262	}
263	}
264
265	else{ //Binary to Memory with Roi
266	fFileHandler->Free();
267	Int_t sli[2]={0,0};
268	fFileHandler->SetROI(fEta,sli);
269	sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
270	memory->SetBinaryInput(name);
271	UInt_t compsize=memory->GetFileSize();
272	UInt_t comp=(UInt_t )memory->Allocate(compsize);
273	memory->CompBinary2CompMemory(ndigits,comp);
274	memory->CloseBinaryInput();
275	UInt_t datasize=memory->GetMemorySize(ndigits,comp);
276	digits=(AliL3DigitRowData *)fFileHandler->Allocate(datasize);
277	fBenchmark->Start("Unpacker");
278	datasize = fFileHandler->CompMemory2Memory(ndigits,digits,comp);
279	fBenchmark->Stop("Unpacker");
280	memory->Free();
281	if(1)
282	cerr<<endl<<datasize/1024<<" "<<endl;
283	}
284
285
286	points = (AliL3SpacePointData *) memory->Allocate(pointsize);
287
288	fClusterFinder = new AliL3ClustFinder(fTransformer);
289	fClusterFinder->InitSlice(slice,patch,row[patch][0],row[patch][1]
290	,maxpoints);
291	fClusterFinder->SetXYError(0.1);
292	fClusterFinder->SetZError(0.2);
293	fClusterFinder->SetOutputArray(points);
294	fBenchmark->Start("Read Cluster Finder");
295	fClusterFinder->Read(ndigits,digits);
296	fBenchmark->Stop("Read Cluster Finder");
297	fBenchmark->Start("Cluster Finder");
298	fClusterFinder->ProcessDigits();
299	fBenchmark->Stop("Cluster Finder");
300	npoints = fClusterFinder->GetNumberOfClusters();
301	delete fClusterFinder;
302	fClusterFinder =0;
303	fFileHandler->Free();
304
305	LOG(AliL3Log::kInformational,"AliLevel3::ProcessSlice","Cluster Finder")
306	<<AliL3Log::kDec<<"Found "<<npoints<<" Points"<<ENDLOG;
307	}
308
309	else{
310	if(isdigit){
311	sprintf(name,"digits_%d_%d.raw",slice,patch);
312
313	if(0){ //Ali to Binary
314	fFileHandler->SetBinaryOutput(name);
315	fFileHandler->AliDigits2CompBinary();
316	fFileHandler->CloseBinaryOutput();
317	}
318
319	if(1){ //Ali to Memory
320	digits=(AliL3DigitRowData *)fFileHandler->AliDigits2Memory(ndigits);
321	if(fWriteOut){ //Memory to Binary
322	fFileHandler->SetBinaryOutput(name);
323	fFileHandler->Memory2CompBinary(ndigits,digits);
324	fFileHandler->CloseBinaryOutput();
325	}
326	}
327	}
328	else points = fFileHandler->AliPoints2Memory(npoints);
329	}
330
331	if(patch == fNPatch-1){
332	// Vertex
333	if(fFindVertex){
334	// Vertex Finder
335
336	fBenchmark->Start("Vertex Finder Read");
337	fVertexFinder->Reset();
338	fVertexFinder->Read(npoints,points);
339	fBenchmark->Stop("Vertex Finder Read");
340	fBenchmark->Start("Vertex Finder");
341	fVertexFinder->Analyze();
342	AliL3VertexData vertex[1];
343	fVertexFinder->Write(vertex);
344	fVertex->Read(vertex);
345	fBenchmark->Stop("Vertex Finder");
346	}
347	else{
348	//use 0,0,0 for vertex
349	fVertex->SetZero();
350	}
351	fTrackMerger->SetVertex(fVertex);
352	}
353	fTracker->InitSector(slice,row[patch]);
354	fTracker->SetVertex(fVertex);
355	fBenchmark->Start("Tracker Read Hits");
356	fTracker->ReadHits(npoints,points);
357	fBenchmark->Stop("Tracker Read Hits");
358	fBenchmark->Start("MainVertexTracking A");
359	fTracker->MainVertexTracking_a();
360	fBenchmark->Stop("MainVertexTracking A");
361	fBenchmark->Start("MainVertexTracking B");
362	fTracker->MainVertexTracking_b();
363	fBenchmark->Stop("MainVertexTracking B");
364	fBenchmark->Start("Tracking fit");
365	fTracker->FillTracks();
366	fBenchmark->Stop("Tracking fit");
367
368	if(fWriteOut)
369	WriteSpacePoints(npoints, points, slice, patch); //do after Tracking
370	fFileHandler->Free();
371
372	UInt_t ntracks0 =0;
373	AliL3TrackSegmentData *trackdata0 =
374	(AliL3TrackSegmentData *) memory->Allocate(fTracker->GetTracks());
375	memory->TrackArray2Memory(ntracks0,trackdata0,fTracker->GetTracks());
376
377	//write tracks
378	if(fWriteOut){
379	sprintf(name,"tracks_tr_%d_%d.raw",slice,patch);
380	memory->SetBinaryOutput(name);
381	memory->Memory2Binary(ntracks0,trackdata0);
382	memory->CloseBinaryOutput();
383	}
384
385	fInterMerger->Reset();
386	fInterMerger->SetTransformer(fTransformer);
387	fInterMerger->Init(row[patch],patch);
388
389	fBenchmark->Start("Fill Inter Merger");
390	fInterMerger->FillTracks(ntracks0,trackdata0);
391	fBenchmark->Stop("Fill Inter Merger");
392	fBenchmark->Start("Inter Merger");
393	fInterMerger->Merge();
394	// fInterMerger->SlowMerge();
395
396	fBenchmark->Stop("Inter Merger");
397
398	//write inter merged tracks
399	if(fWriteOut){
400	sprintf(name,"tracks_im_%d_%d.raw",slice,patch);
401	WriteTracks(name,fInterMerger,'i'); //write output of intermerger
402	}
403	memory->Free();
404
405	UInt_t ntracks1 =0;
406	AliL3TrackSegmentData *trackdata1 =
407	(AliL3TrackSegmentData *) memory->Allocate(fInterMerger->GetInTracks(0));
408	memory->TrackArray2Memory(ntracks1,trackdata1,fInterMerger->GetInTracks(0));
409
410	fTrackMerger->InitSector(slice,patch);
411	fBenchmark->Start("Fill Patch Merger");
412	fTrackMerger->FillTracks(ntracks1,trackdata1);
413	fBenchmark->Stop("Fill Patch Merger");
414
415	memory->Free();
416	}
417	fBenchmark->Start("Patch Merger");
418	// fTrackMerger->SlowMerge();
419	fTrackMerger->Merge();
420	fBenchmark->Stop("Patch Merger");
421	//write merged tracks
422	if(fWriteOut){
423	sprintf(name,"tracks_tm_%d.raw",slice);
424	WriteTracks(name,fTrackMerger,'o'); //write output of trackmerger
425	}
426
427	fTrackData = (AliL3TrackSegmentData *)
428	fFileHandler->Allocate(fTrackMerger->GetOutTracks());
429
430	fFileHandler->TrackArray2Memory(fNTrackData,fTrackData,
431	fTrackMerger->GetOutTracks());
432
433	delete memory;
434	}
435
436	void AliLevel3::WriteSpacePoints(UInt_t npoints,AliL3SpacePointData *points,
437	Int_t slice,Int_t patch){
438	char name[256];
439	sprintf(name,"points_%d_%d.raw",slice,patch);
440	AliL3MemHandler * memory = new AliL3MemHandler();
441	memory->SetBinaryOutput(name);
442	memory->Transform(npoints,points,slice,fTransformer);
443	memory->Memory2Binary(npoints,points);
444	memory->CloseBinaryOutput();
445	delete memory;
446	}
447
448
449	Int_t AliLevel3::WriteTracks(char filename,AliL3Merger merger,char opt){
450	AliL3FileHandler *memory = new AliL3FileHandler();
451	memory->SetBinaryOutput(filename);
452	if(opt=='a'\|\|opt=='i'){ //add intracks
453	for(Int_t i=0;i<merger->GetNIn();i++){
454	AliL3TrackArray *tr=merger->GetInTracks(i);
455	memory->TrackArray2Binary(tr);
456	}
457	}
458
459	if(opt=='o'\|\|opt=='a'){
460	AliL3TrackArray *tr=merger->GetOutTracks();
461	memory->TrackArray2Binary(tr);
462	}
463
464	memory->CloseBinaryOutput();
465
466	return 1;
467	}
468
469	void AliLevel3::WriteResults()
470	{
471	//Write the resulting tracks to outputfile
472	WriteTracks("tracks.raw",fGlobalMerger,'a');
473	}