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

// Author: Anders Vestbo <mailto:vestbo$fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>
//*-- Copyright &copy ASV

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

#include "AliL3Logging.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 "AliL3ClustFinderNew.h"
#include "AliL3DigitData.h"
#include "AliL3TrackArray.h"
#include "AliL3MemHandler.h"
#ifdef use_aliroot
#include "AliL3FileHandler.h"
#endif
#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)
//Begin_Html
/*
<img src="tpcsectorsnb.gif">
*/
//End_Html

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;
  fEta[0] = 0.;
  fEta[1] = 0.9;
  fUseBinary =kFALSE;
  SetPath("");
  fFindVertex =kTRUE;
  if(1){
    fNPatch = 1;   //number of patches change row in process
    fRow[0][0] = 0;     // first row
    fRow[0][1] = 175;   // last row
  }
  if(0){
    fNPatch = 2;   //number of patches change row in process
    fRow[0][0] = 0;     // first row
    fRow[0][1] = 54;
    fRow[1][0] = 55;
    fRow[1][1] = 175;   // last row
  }
  if(0){
    fNPatch = 5;   //number of patches change row in process
    fRow[0][0] = 0;     // first row
    fRow[0][1] = 45;
    fRow[1][0] = 46;
    fRow[1][1] = 77;
    fRow[2][0] = 78;
    fRow[2][1] = 109;
    fRow[3][0] = 110;
    fRow[3][1] = 141;
    fRow[4][0] = 142;
    fRow[4][1] = 175;   // last row
  }
  if(0){
    fNPatch = 6;   //number of patches change row in process
    fRow[0][0] = 0;     // first row
    fRow[0][1] = 31;
    fRow[1][0] = 32;
    fRow[1][1] = 63;
    fRow[2][0] = 64;
    fRow[2][1] = 91;
    fRow[3][0] = 92;
    fRow[3][1] = 119;
    fRow[4][0] = 120;
    fRow[4][1] = 143;   
    fRow[5][0] = 144;
    fRow[5][1] = 175;   // last row 
  }
  fVertexFinder = new AliL3VertexFinder();
  fVertex = new AliL3Vertex();
  fTracker = new AliL3ConfMapper();
  fTrackMerger = new AliL3TrackMerger(fNPatch);
  fInterMerger = new AliL3InterMerger();
  #ifdef use_aliroot
  fFileHandler = new AliL3FileHandler();
  fFileHandler->SetAliInput(fInputFile);
  #else
  fFileHandler = new AliL3MemHandler();
  #endif
  fBenchmark = new AliL3Benchmark();
}

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

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

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);
    fGlobalMerger->FillTracks(fNTrackData,fTrackData);
    fFileHandler->Free();   //free the memory
    fNTrackData=0;
    fTrackData=0;
  }
  fBenchmark->Start("Global Merger");
  fGlobalMerger->AddAllTracks();
  //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 UseCF = kFALSE;
#ifdef use_aliroot
  UseCF = fFileHandler->IsDigit();
#endif
  const Int_t maxpoints=100000;
  const Int_t pointsize = maxpoints * sizeof(AliL3SpacePointData);
  AliL3MemHandler *memory = new AliL3MemHandler();

  fTrackMerger->Reset();
  fTrackMerger->SetTransformer(fTransformer);
  fTrackMerger->SetRows(fRow[0]);
  for(Int_t patch=fNPatch-1;patch>=0;patch--){
    fFileHandler->Init(slice,patch,fRow[patch]);
    fFileHandler->Init(fTransformer);
    UInt_t npoints=0;
    AliL3SpacePointData *points =0;
    UInt_t ndigits=0;
    AliL3DigitRowData *digits =0;
    if(UseCF){
      if(fUseBinary){
        if(!fDoRoi){ 
          if(0){     //Binary to Memory
            fFileHandler->Free();
            sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
            if(!fFileHandler->SetBinaryInput(name)) return;
            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);
            if(!memory->SetBinaryInput(name)) return;
            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);
            if(!memory->SetBinaryInput(name)) return;
            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();
          }
        }

        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);
          if(!memory->SetBinaryInput(name)) return;
          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();
        }
      }//end UseBinary
      else{
#ifdef use_aliroot
        fBenchmark->Start("Dummy Unpacker");
        sprintf(name,"digits_%d_%d.raw",slice,patch);
        fBenchmark->Stop("Dummy Unpacker");

        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();
          }
        }
#endif
      }//end else UseBinary

      points = (AliL3SpacePointData *) memory->Allocate(pointsize);
  
      fClusterFinder = new AliL3ClustFinderNew(fTransformer);
      fClusterFinder->InitSlice(slice,patch,fRow[patch][0],fRow[patch][1]
                                                               ,maxpoints);
      fClusterFinder->SetXYError(0.1);
      fClusterFinder->SetZError(0.2);
      fClusterFinder->SetOutputArray(points);
      fClusterFinder->Read(ndigits,digits);
      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;
    
    
    }//end UseCF
    else{// if not use Clusterfinder
      if(fUseBinary){//Binary to Memory
        memory->Free();
        sprintf(name,"/%spoints_%d_%d.raw",fPath,slice,patch);
        if(!memory->SetBinaryInput(name)) return;
        points = (AliL3SpacePointData *) memory->Allocate();
        memory->Binary2Memory(npoints,points);
        memory->CloseBinaryInput();
        LOG(AliL3Log::kInformational,"AliLevel3::ProcessSlice","Read Cluster")
        <<AliL3Log::kDec<<"Found "<<npoints<<" Points in File"<<ENDLOG;
      }
#ifdef use_aliroot
      else{
        points = fFileHandler->AliPoints2Memory(npoints);
      }
#endif
      fBenchmark->Start("Dummy Unpacker");
      fBenchmark->Stop("Dummy Unpacker");
      fBenchmark->Start("Dummy CF");
      fBenchmark->Stop("Dummy CF");
    }
   
    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,fRow[patch]);//,fEta);
    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

    //free memory
    if(UseCF)
      memory->Free();
    else
      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(fRow[patch],patch);

    fInterMerger->FillTracks(ntracks0,trackdata0);
    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);
    fTrackMerger->FillTracks(ntracks1,trackdata1);

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