From 108615fc5537b30188ecc37429f9b1873f0645f0 Mon Sep 17 00:00:00 2001 From: franken Date: Thu, 22 Mar 2001 15:19:09 +0000 Subject: [PATCH] This commit was generated by cvs2svn to compensate for changes in r3176, which included commits to RCS files with non-trunk default branches. --- HLT/src/.nfs002b88e300000129 | Bin 0 -> 4096 bytes HLT/src/AliL3Benchmark.cxx | 155 +++++ HLT/src/AliL3Benchmark.h | 33 + HLT/src/AliL3ClustFinder.cxx | 484 ++++++++++++++ HLT/src/AliL3ClustFinder.h | 83 +++ HLT/src/AliL3ConfMapFit.cxx | 510 ++++++++++++++ HLT/src/AliL3ConfMapFit.h | 30 + HLT/src/AliL3ConfMapPoint.cxx | 223 +++++++ HLT/src/AliL3ConfMapPoint.h | 184 ++++++ HLT/src/AliL3ConfMapTrack.cxx | 317 +++++++++ HLT/src/AliL3ConfMapTrack.h | 66 ++ HLT/src/AliL3ConfMapper.cxx | 834 +++++++++++++++++++++++ HLT/src/AliL3ConfMapper.h | 142 ++++ HLT/src/AliL3Defs.h | 11 + HLT/src/AliL3DigitData.h | 29 + HLT/src/AliL3Display.cxx | 363 ++++++++++ HLT/src/AliL3Display.h | 35 + HLT/src/AliL3Evaluate.cxx | 760 +++++++++++++++++++++ HLT/src/AliL3Evaluate.h | 89 +++ HLT/src/AliL3FileHandler.cxx | 379 +++++++++++ HLT/src/AliL3FileHandler.h | 54 ++ HLT/src/AliL3GlobalMerger.cxx | 184 ++++++ HLT/src/AliL3GlobalMerger.h | 27 + HLT/src/AliL3HoughTrack.cxx | 277 ++++++++ HLT/src/AliL3HoughTrack.h | 46 ++ HLT/src/AliL3InterMerger.cxx | 137 ++++ HLT/src/AliL3InterMerger.h | 26 + HLT/src/AliL3LinkDef.h | 36 + HLT/src/AliL3Logger.cxx | 69 ++ HLT/src/AliL3Logger.h | 32 + HLT/src/AliL3Logging.h | 33 + HLT/src/AliL3MemHandler.cxx | 1096 +++++++++++++++++++++++++++++++ HLT/src/AliL3MemHandler.h | 151 +++++ HLT/src/AliL3Merger.cxx | 415 ++++++++++++ HLT/src/AliL3Merger.h | 76 +++ HLT/src/AliL3RootTypes.h | 105 +++ HLT/src/AliL3SpacePointData.h | 17 + HLT/src/AliL3Track.cxx | 281 ++++++++ HLT/src/AliL3Track.h | 158 +++++ HLT/src/AliL3TrackArray.cxx | 405 ++++++++++++ HLT/src/AliL3TrackArray.h | 62 ++ HLT/src/AliL3TrackMerger.cxx | 280 ++++++++ HLT/src/AliL3TrackMerger.h | 36 + HLT/src/AliL3TrackSegmentData.h | 27 + HLT/src/AliL3Transform.cxx | 574 ++++++++++++++++ HLT/src/AliL3Transform.h | 65 ++ HLT/src/AliL3Vertex.cxx | 60 ++ HLT/src/AliL3Vertex.h | 49 ++ HLT/src/AliL3VertexArray.cxx | 106 +++ HLT/src/AliL3VertexArray.h | 108 +++ HLT/src/AliL3VertexData.h | 16 + HLT/src/AliL3VertexFinder.cxx | 99 +++ HLT/src/AliL3VertexFinder.h | 55 ++ HLT/src/AliLevel3.cxx | 473 +++++++++++++ HLT/src/AliLevel3.h | 88 +++ HLT/src/AliLevel3_Root.cxx | 448 +++++++++++++ HLT/src/AliLevel3_Root.h | 85 +++ HLT/src/Makefile | 84 +++ HLT/src/Makefile_Root | 444 +++++++++++++ HLT/src/doit | 3 + HLT/src/speedtest.cxx | 53 ++ HLT/src/speedtest.h | 25 + 62 files changed, 11592 insertions(+) create mode 100644 HLT/src/.nfs002b88e300000129 create mode 100644 HLT/src/AliL3Benchmark.cxx create mode 100644 HLT/src/AliL3Benchmark.h create mode 100644 HLT/src/AliL3ClustFinder.cxx create mode 100644 HLT/src/AliL3ClustFinder.h create mode 100644 HLT/src/AliL3ConfMapFit.cxx create mode 100644 HLT/src/AliL3ConfMapFit.h create mode 100644 HLT/src/AliL3ConfMapPoint.cxx create mode 100644 HLT/src/AliL3ConfMapPoint.h create mode 100644 HLT/src/AliL3ConfMapTrack.cxx create mode 100644 HLT/src/AliL3ConfMapTrack.h create mode 100644 HLT/src/AliL3ConfMapper.cxx create mode 100644 HLT/src/AliL3ConfMapper.h create mode 100644 HLT/src/AliL3Defs.h create mode 100644 HLT/src/AliL3DigitData.h create mode 100644 HLT/src/AliL3Display.cxx create mode 100644 HLT/src/AliL3Display.h create mode 100644 HLT/src/AliL3Evaluate.cxx create mode 100644 HLT/src/AliL3Evaluate.h create mode 100644 HLT/src/AliL3FileHandler.cxx create mode 100644 HLT/src/AliL3FileHandler.h create mode 100644 HLT/src/AliL3GlobalMerger.cxx create mode 100644 HLT/src/AliL3GlobalMerger.h create mode 100644 HLT/src/AliL3HoughTrack.cxx create mode 100644 HLT/src/AliL3HoughTrack.h create mode 100644 HLT/src/AliL3InterMerger.cxx create mode 100644 HLT/src/AliL3InterMerger.h create mode 100644 HLT/src/AliL3LinkDef.h create mode 100644 HLT/src/AliL3Logger.cxx create mode 100644 HLT/src/AliL3Logger.h create mode 100644 HLT/src/AliL3Logging.h create mode 100644 HLT/src/AliL3MemHandler.cxx create mode 100644 HLT/src/AliL3MemHandler.h create mode 100644 HLT/src/AliL3Merger.cxx create mode 100644 HLT/src/AliL3Merger.h create mode 100644 HLT/src/AliL3RootTypes.h create mode 100644 HLT/src/AliL3SpacePointData.h create mode 100644 HLT/src/AliL3Track.cxx create mode 100644 HLT/src/AliL3Track.h create mode 100644 HLT/src/AliL3TrackArray.cxx create mode 100644 HLT/src/AliL3TrackArray.h create mode 100644 HLT/src/AliL3TrackMerger.cxx create mode 100644 HLT/src/AliL3TrackMerger.h create mode 100644 HLT/src/AliL3TrackSegmentData.h create mode 100644 HLT/src/AliL3Transform.cxx create mode 100644 HLT/src/AliL3Transform.h create mode 100644 HLT/src/AliL3Vertex.cxx create mode 100644 HLT/src/AliL3Vertex.h create mode 100644 HLT/src/AliL3VertexArray.cxx create mode 100644 HLT/src/AliL3VertexArray.h create mode 100644 HLT/src/AliL3VertexData.h create mode 100644 HLT/src/AliL3VertexFinder.cxx create mode 100644 HLT/src/AliL3VertexFinder.h create mode 100644 HLT/src/AliLevel3.cxx create mode 100644 HLT/src/AliLevel3.h create mode 100644 HLT/src/AliLevel3_Root.cxx create mode 100644 HLT/src/AliLevel3_Root.h create mode 100644 HLT/src/Makefile create mode 100644 HLT/src/Makefile_Root create mode 100644 HLT/src/doit create mode 100644 HLT/src/speedtest.cxx create mode 100644 HLT/src/speedtest.h diff --git a/HLT/src/.nfs002b88e300000129 b/HLT/src/.nfs002b88e300000129 new file mode 100644 index 0000000000000000000000000000000000000000..171df4b5e12bac48ecfb266342dbd5cf8c184b11 GIT binary patch literal 4096 zcmYc?2=nw+Fx4|*00IF92CMKwtH=%+hWGXi3~5D)dD*FXAQ`+MJ1aH2xFFd?FD+BA zG&4yrFCV+|I;esAIjLo-ImXHPDXIF!MalY(Ihj7jzNtm&sYQCp6&2VukBW|lz-S0i y90JBhh6c(?iVDI)p%j}nYQSg+jE2By2#kinXb6mkz-S1JhQMeDjE2C_3IPCei64Ui literal 0 HcmV?d00001 diff --git a/HLT/src/AliL3Benchmark.cxx b/HLT/src/AliL3Benchmark.cxx new file mode 100644 index 00000000000..385ed1fd9f1 --- /dev/null +++ b/HLT/src/AliL3Benchmark.cxx @@ -0,0 +1,155 @@ +#include +#include "TGraphAsymmErrors.h" +#include "TString.h" +#include "TStopwatch.h" +#include "AliL3Benchmark.h" +#include "TStopwatch.h" +#include "TMath.h" +#include "AliL3Logging.h" + +ClassImp(AliL3Benchmark) + +AliL3Benchmark::AliL3Benchmark() +{ + fNbench = 0; + fNmax = 20; + fNames = 0; + fTimer = 0; + fSum = 0; + fMin = 0; + fMax = 0; + fCount = 0; +// fStopwatch = 0; +} + +AliL3Benchmark::~AliL3Benchmark() +{ + fNbench = 0; + if (fNames) {delete [] fNames; fNames = 0;} + if (fTimer) {delete [] fTimer; fTimer = 0;} + if (fSum) {delete [] fSum; fSum = 0;} + if (fMin) {delete [] fMin; fMin = 0;} + if (fMax) {delete [] fMax; fMax = 0;} + if (fCount) {delete [] fCount; fCount =0;} +// if(fStopwatch) {delete fStopwatch; fStopwatch =0;} +} + +Int_t AliL3Benchmark::GetBench(const char *name) +{ + for (Int_t i=0;iReset(); +// fStopwatch->Start(); + } else if (bench >=0) { + // Resume the existen benchmark + fTimer[bench].Reset(); + fTimer[bench].Start(); +// if(fStopwatch) {delete fStopwatch; fStopwatch =0;} +// fStopwatch = new TStopwatch(); +// fStopwatch->Reset(); +// fStopwatch->Start(); + } + else + LOG(AliL3Log::kWarning,"AliL3Benchmark::Start","Start") + <<"too many benches"<Stop(); +// Float_t val = fStopwatch->CpuTime(); + + fSum[bench] += val; + fCount[bench]++; + if(fCount[bench]==1){ + fMin[bench] = val; + fMax[bench] = val; + } + else{ + if(valfMax[bench])fMax[bench]=val; + } +} + +void AliL3Benchmark::Analyze(const char* name){ + Float_t *x = new Float_t[fNbench]; + Float_t *y = new Float_t[fNbench]; + Float_t *eyl = new Float_t[fNbench]; + Float_t *eyh = new Float_t[fNbench]; + char filename[256]; + sprintf(filename,"%s.dat",name); + FILE *f= fopen(filename,"w"); + for (Int_t i=0;iSetTitle("benchmark"); + gr->SetMarkerStyle(8); + gr->SetMinimum(0); + gr->Draw("ALP"); + gr->Write(); + file->Close(); + delete file; + file=0; + delete[] x; + delete[] y; + delete[] eyl; + delete[] eyh; +} + + diff --git a/HLT/src/AliL3Benchmark.h b/HLT/src/AliL3Benchmark.h new file mode 100644 index 00000000000..92a3a78da49 --- /dev/null +++ b/HLT/src/AliL3Benchmark.h @@ -0,0 +1,33 @@ +#ifndef AliL3_Benchmark +#define AliL3_Benchmark + +#include + +class TStopwatch; +class TString; +class AliL3Benchmark { + +private: + + Int_t fNbench; //Number of active benchmarks + Int_t fNmax; //Maximum number of benchmarks initialized + TString *fNames; //Names of benchmarks + TStopwatch *fTimer; //Timers + Float_t *fSum; + Float_t *fMin; + Float_t *fMax; + Int_t *fCount; + +// TStopwatch *fStopwatch; //Stopwatch +public: + AliL3Benchmark(); + virtual ~AliL3Benchmark(); + Int_t GetBench(const char *name); + void Start(const char *name); + void Stop(const char *name); + void Analyze(const char* name); + + ClassDef(AliL3Benchmark,0) //L3 benchmark +}; + +#endif diff --git a/HLT/src/AliL3ClustFinder.cxx b/HLT/src/AliL3ClustFinder.cxx new file mode 100644 index 00000000000..30fdda18478 --- /dev/null +++ b/HLT/src/AliL3ClustFinder.cxx @@ -0,0 +1,484 @@ +//Author: Anders Strand Vestbo +//Last Modified: 14.12.2000 + +#include + +#include "AliL3Logging.h" +#include "AliL3ClustFinder.h" +#include "AliL3Transform.h" +#include "AliL3DigitData.h" +#include "AliL3SpacePointData.h" + +// +//Simple clusterfinder. Initial version by Tonko. +// + +ClassImp(AliL3ClustFinder) + +AliL3ClustFinder::AliL3ClustFinder() +{ + + fDeconvTime=false; + fDeconvPad=false; + fXYErr = 0; + fZErr = 0; +} + +AliL3ClustFinder::AliL3ClustFinder(AliL3Transform *transform) +{ + + fTransform = transform; + + fThreshold = 20; + fDeconvTime = true; + fDeconvPad = true; +} + + +AliL3ClustFinder::~AliL3ClustFinder() +{ + //destructor +} + + + void AliL3ClustFinder::SetTransformer( AliL3Transform *transform ) + { + fTransform = transform; + } + + +void AliL3ClustFinder::InitSlice(Int_t slice,Int_t patch,Int_t firstrow, Int_t lastrow,Int_t nmaxpoints) +{ + fNClusters = 0; + fMaxNClusters = nmaxpoints; + fCurrentSlice = slice; + fCurrentPatch = patch; + fFirstRow = firstrow; + fLastRow = lastrow; +} + + +void AliL3ClustFinder::InitSlice(Int_t slice,Int_t patch,Int_t nmaxpoints) +{ + fNClusters = 0; + fMaxNClusters = nmaxpoints; + fCurrentSlice = slice; + fCurrentPatch = patch; +} + +void AliL3ClustFinder::SetOutputArray(AliL3SpacePointData *pt) +{ + + fSpacePointData = pt; +} + +void AliL3ClustFinder::Read(UInt_t ndigits,AliL3DigitRowData *ptr) +{ + fNDigitRowData = ndigits; + fDigitRowData = ptr; + +} + +void AliL3ClustFinder::ProcessDigits() +{ + //Loop over rows, and call processrow + + + AliL3DigitRowData *tempPt = (AliL3DigitRowData*)fDigitRowData; + + for(Int_t i=fFirstRow; i<=fLastRow; i++) + { + fCurrentRow = i; + ProcessRow(tempPt); + Byte_t *tmp = (Byte_t*)tempPt; + Int_t size = sizeof(AliL3DigitRowData) + tempPt->fNDigit*sizeof(AliL3DigitData); + tmp += size; + tempPt = (AliL3DigitRowData*)tmp; + } + + LOG(AliL3Log::kInformational,"AliL3ClustFinder","Cluster Finder") + <fNDigit; start++) + { + AliL3DigitData *bins = tempPt->fDigitData; + + if(bins[start].fPad!=last_pad) + {//new pad + + last_pad=bins[start].fPad; + + if(r2==pres2) + { + r1=pres2; + r2=pres1; + } + else + { + r1=pres1; + r2=pres2; + } + pres_cou1=pres_cou2; + pres_cou2=0; + + start_new=-1; + + cl_counter=0; + prev_start=0; + + + }//Looping over pads + + UInt_t av,charge; + UInt_t mean; + UInt_t flags; + Int_t last_falling=0; +// UInt_t *ri; + resx **ri; + UInt_t tmp_charge; + + //Set flag: + flags=0; + + cl_counter++; + if(cl_counter>MAX_C) {LOG(AliL3Log::kWarning,"AliL3ClustFinder::ProcessRow","Cluster Finder") + <-1) + { + start=start_new; + start_new=-1; + } + } + //average and charge + av=charge=0; + + //ok, create a new cluster: + go_on=1; + + if(fDeconvTime) + { + + last_falling=flags=0; + } + + if(fDeconvPad) + { + flags=0; + } + + + //block to introduce new variables: + { + UInt_t last_a; + last_a=0; + + //Loop over this sequenz: + while(1) + { + UInt_t aa; + //Int_t start_temp=start; + + //get the adc-value: + aa=bins[start].fCharge; + + + if(fDeconvTime) + { + //Check if the last pixel in this sequenz is bigger or smaller than this: + if(aa>last_a) + { + if(last_falling) + { + start_new=start; + break; + } + } + else last_falling=1; + last_a=aa; + + } + //sum of total charge of this cluster on this pad + charge +=aa; + //this one is needed to determine the mean over all pads: + //av += start * (aa); + av+=bins[start].fTime*(aa); + + if((bins[start+1].fTime)!=(bins[start].fTime+1) || + ((bins[start+1].fPad)!=(bins[start].fPad))) break; + + start++; + }//Loop over sequenz + }//block of new variables + + if(fDeconvTime) + { + if(start_new>0) flags = FLAG_DOUBLE_T; + } + //calculate mean in time direction for this sequenz: + if(charge) + { + //mean=cog for this sequenz: + mean=av/charge; + } + else + { + charge=1; + mean=1; + } + //get the pointer to results on previous pad(s) + ri=r1; + + //Center of gravity in pad direction + //tmp_charge=charge*bins[start-1].fPad; + tmp_charge=charge*bins[start].fPad; + + //compare with prevously stored results (previous pads) + for(int k=0; kmean; + + + if(v<-PARAM1) break; + + //goto next mean on previous pad + ri++; + + //is there a matching cluster on previous pad: + if(v<=PARAM1) + { + //ok, we got a new one, so we will add the new and the old + rr=&rr_local; + + //Add this function somewhere + memcpy7((UInt_t *)rr,(UInt_t *)rr_tmp); + + /* in case we found another sequenz-section on this pad + don't loop over all sequenzes on last pad but start + where we found a matching candidate for this sequenz- + section, adjust upper limit (=pres_cou1)*/ + r1=ri; + pres_cou1-=1+k; + + if(fDeconvPad) + { + if(charge>rr->scharge) + { + if(rr->falling) + { + //previous state was falling + flags |= FLAG_DOUBLE_PAD; + rr_tmp->flags |= flags; + //and create a new one + break; + } + } + else + { + rr->falling = 1; + } + + } + //don't create a new one + go_on=0; + + //store the pointer to the matched in "2" +// r2[pres_cou2++] = (UInt_t) rr_tmp; + r2[pres_cou2++] = rr_tmp; + + //calculate and fill the new means, charge etc. in rr_tmp + //charge on this pad to determine whether we cut in pad direction + rr->scharge = charge; + //unset FLAG_ONEPAD since we have at least 2 pads + rr->flags &= (~FLAG_ONEPAD); + //summ the charges for de/dx + rr->charge += charge; + //calculate mean in pad direction + rr->pad += tmp_charge; + //calculate mean in time direction + rr->t+=av; + //store the mean of this sequenz on this pad + rr->mean = mean; + + //Copy it back to storage + memcpy7((UInt_t *)rr_tmp,(UInt_t *)rr); + + //we found a matching one so stop looping over pads on previous pad + break; + + }//matching cluster on previous pads + }//loop: means on previous pad + + //here we create from scratch new clusters + if(go_on) + { + //store this one beacuse it is the first +// r2[pres_cou2++]= (UInt_t )r; + r2[pres_cou2++]= r; + + mstore((UInt_t *)r,av,tmp_charge,charge,flags|FLAG_ONEPAD,mean,trackID); + r++; + } + + if(fDeconvTime) + { + + //maybe we still have to do something + if(start_new>=0) goto redo; + } + + }//end of loop over digits + + + //number of clusters found + cl_found = r-aliresx; + + //tot_cl_found+=cl_found; + + //there was something on this padrow + rows++; + + WriteClusters(cl_found,aliresx); + +} + +void AliL3ClustFinder::memcpy7(UInt_t *dst, UInt_t *src) +{ + Int_t i; + for(i=0; i<7; i++) + { + *dst++ = *src++; + } + return; +} + +void AliL3ClustFinder::mstore(UInt_t *r,UInt_t av,UInt_t pad,UInt_t ch,UInt_t flags,UInt_t mean,Int_t *trackID) +{ + resx *rr = (resx *) r; + + rr->mean = mean; + rr->charge = ch; + rr->flags =flags; + rr->scharge = ch; + rr->pad = pad; + rr->t = av; + rr->falling=0; + + rr->trackID[0]=trackID[0]; + rr->trackID[1]=trackID[1]; + rr->trackID[2]=trackID[2]; + return; +} + +void AliL3ClustFinder::WriteClusters(Int_t ncl,resx *r) +{ +/* + if(fNClusters >= fMaxNClusters) + { + LOG(AliL3Log::kError,"AliL3ClustFinder::WriteClusters","Cluster Finder") + < 54) {thisrow = fCurrentRow-55; thissector = fCurrentSlice+36;} + else {thisrow = fCurrentRow; thissector = fCurrentSlice;} + fTransform->Raw2Local(xyz,thissector,thisrow,fpad,ftime); + if(xyz[0]==0) LOG(AliL3Log::kError,"AliL3ClustFinder","Cluster Finder") + <= fMaxNClusters) + { + LOG(AliL3Log::kError,"AliL3ClustFinder::WriteClusters","Cluster Finder") + < + +#include "AliL3Logging.h" +#include "AliL3ConfMapFit.h" +#include "AliL3Vertex.h" +#include "AliL3ConfMapTrack.h" +#include "AliL3ConfMapPoint.h" + +//_______________________________ +// AliL3ConfMapFit +// +// Fit class for conformal mapping tracking + +ClassImp(AliL3ConfMapFit) + +Double_t AliL3ConfMapFit::pi=3.14159265358979323846; + +AliL3ConfMapFit::AliL3ConfMapFit(AliL3ConfMapTrack *track,AliL3Vertex *vertex) +{ + //constructor + fTrack = track; + fVertex = vertex; + BFACT = 0.0029980; + bField = 0.2; + +} + +Int_t AliL3ConfMapFit::FitHelix() +{ + if(FitCircle()) + { + LOG(AliL3Log::kError,"AliL3ConfMapFit::FitHelix","TrackFit")<GetNumberOfPoints(); + // + // Loop over hits calculating average + Int_t co=0; + + for(fTrack->StartLoop(); fTrack->LoopDone(); fTrack->GetNextHit()) + { + co++; + AliL3ConfMapPoint *cHit = (AliL3ConfMapPoint*)fTrack->currentHit; + cHit->SetXYWeight( 1./ (Double_t)(cHit->GetXerr()*cHit->GetXerr() + cHit->GetYerr()*cHit->GetYerr()) ); + wsum += cHit->GetXYWeight() ; + xav += cHit->GetXYWeight() * cHit->GetX() ; + yav += cHit->GetXYWeight() * cHit->GetY() ; + } + if(co!=num_of_hits) + LOG(AliL3Log::kError,"AliL3ConfMapFit::FitCircle","TrackFit")<ComesFromMainVertex() == true) + { + wsum += fVertex->GetXYWeight() ; + xav += fVertex->GetX() ; + yav += fVertex->GetY() ; + } + + xav = xav / wsum ; + yav = yav / wsum ; +// +// CALCULATE , , AND WITH = 0, & = 0 +// + Double_t xxav = 0.0 ; + Double_t xyav = 0.0 ; + Double_t yyav = 0.0 ; + Double_t xi, yi ; + + for(fTrack->StartLoop(); fTrack->LoopDone(); fTrack->GetNextHit()) + { + //AliL3ConfMapPoint *cHit = (AliL3ConfMapPoint *)hits->At(hit_counter); + AliL3ConfMapPoint *cHit = (AliL3ConfMapPoint*)fTrack->currentHit; + xi = cHit->GetX() - xav ; + yi = cHit->GetY() - yav ; + xxav += xi * xi * cHit->GetXYWeight() ; + xyav += xi * yi * cHit->GetXYWeight() ; + yyav += yi * yi * cHit->GetXYWeight() ; + } + + if (fTrack->ComesFromMainVertex() == true) + { + xi = fVertex->GetX() - xav ; + yi = fVertex->GetY() - yav ; + xxav += xi * xi * fVertex->GetXYWeight() ; + xyav += xi * yi * fVertex->GetXYWeight() ; + yyav += yi * yi * fVertex->GetXYWeight() ; + } + xxav = xxav / wsum ; + xyav = xyav / wsum ; + yyav = yyav / wsum ; +// +//--> ROTATE COORDINATES SO THAT = 0 +// +//--> SIGN(C**2 - S**2) = SIGN(XXAV - YYAV) > +//--> & > ==> NEW : (XXAV-YYAV) > 0 +//--> SIGN(S) = SIGN(XYAV) > + + Double_t a = fabs( xxav - yyav ) ; + Double_t b = 4.0 * xyav * xyav ; + + Double_t asqpb = a * a + b ; + Double_t rasqpb = sqrt ( asqpb) ; + + Double_t splus = 1.0 + a / rasqpb ; + Double_t sminus = b / (asqpb * splus) ; + + splus = sqrt (0.5 * splus ) ; + sminus = sqrt (0.5 * sminus) ; +// +//-> FIRST REQUIRE : SIGN(C**2 - S**2) = SIGN(XXAV - YYAV) +// + Double_t sinrot, cosrot ; + if ( xxav <= yyav ) { + cosrot = sminus ; + sinrot = splus ; + } + else { + cosrot = splus ; + sinrot = sminus ; + } +// +//-> REQUIRE : SIGN(S) = SIGN(XYAV) * SIGN(C) (ASSUMING SIGN(C) > 0) +// + if ( xyav < 0.0 ) sinrot = - sinrot ; +// +//--> WE NOW HAVE THE SMALLEST ANGLE THAT GUARANTEES > +//--> TO GET THE SIGN OF THE CHARGE RIGHT, THE NEW X-AXIS MUST POINT +//--> OUTWARD FROM THE ORGIN. WE ARE FREE TO CHANGE SIGNS OF BOTH +//--> COSROT AND SINROT SIMULTANEOUSLY TO ACCOMPLISH THIS. +// +//--> CHOOSE SIGN OF C WISELY TO BE ABLE TO GET THE SIGN OF THE CHARGE +// + if ( cosrot*xav+sinrot*yav < 0.0 ) { + cosrot = -cosrot ; + sinrot = -sinrot ; + } +// +//-> NOW GET AND RSCALE= SQRT() +// + Double_t rrav = xxav + yyav ; + Double_t rscale = sqrt(rrav) ; + + xxav = 0.0 ; + yyav = 0.0 ; + xyav = 0.0 ; + Double_t xrrav = 0.0 ; + Double_t yrrav = 0.0 ; + Double_t rrrrav = 0.0 ; + + Double_t xixi, yiyi, riri, wiriri, xold, yold ; + + //for (hit_counter=0; hit_counterStartLoop(); fTrack->LoopDone(); fTrack->GetNextHit()) + { + //AliL3ConfMapPoint *cHit = (AliL3ConfMapPoint*)hits->At(hit_counter); + AliL3ConfMapPoint* cHit = (AliL3ConfMapPoint*)fTrack->currentHit; + + xold = cHit->GetX() - xav ; + yold = cHit->GetY() - yav ; + // + //--> ROTATE SO THAT = 0 & DIVIDE BY RSCALE SO THAT = 1 + // + xi = ( cosrot * xold + sinrot * yold ) / rscale ; + yi = ( -sinrot * xold + cosrot * yold ) / rscale ; + + xixi = xi * xi ; + yiyi = yi * yi ; + riri = xixi + yiyi ; + wiriri = cHit->GetXYWeight() * riri ; + + xyav += cHit->GetXYWeight() * xi * yi ; + xxav += cHit->GetXYWeight() * xixi ; + yyav += cHit->GetXYWeight() * yiyi ; + + xrrav += wiriri * xi ; + yrrav += wiriri * yi ; + rrrrav += wiriri * riri ; + } + // +// Include vertex if required +// + if (fTrack->ComesFromMainVertex() == true) + { + xold = fVertex->GetX() - xav ; + yold = fVertex->GetY() - yav ; + // + //--> ROTATE SO THAT = 0 & DIVIDE BY RSCALE SO THAT = 1 + // + xi = ( cosrot * xold + sinrot * yold ) / rscale ; + yi = ( -sinrot * xold + cosrot * yold ) / rscale ; + + xixi = xi * xi ; + yiyi = yi * yi ; + riri = xixi + yiyi ; + wiriri = fVertex->GetXYWeight() * riri ; + + xyav += fVertex->GetXYWeight() * xi * yi ; + xxav += fVertex->GetXYWeight() * xixi ; + yyav += fVertex->GetXYWeight() * yiyi ; + + xrrav += wiriri * xi ; + yrrav += wiriri * yi ; + rrrrav += wiriri * riri ; + } + // + // + // + //--> DIVIDE BY WSUM TO MAKE AVERAGES + // + xxav = xxav / wsum ; + yyav = yyav / wsum ; + xrrav = xrrav / wsum ; + yrrav = yrrav / wsum ; + rrrrav = rrrrav / wsum ; + xyav = xyav / wsum ; + + Int_t const ntry = 5 ; +// +//--> USE THESE TO GET THE COEFFICIENTS OF THE 4-TH ORDER POLYNIMIAL +//--> DON'T PANIC - THE THIRD ORDER TERM IS ZERO ! +// + Double_t xrrxrr = xrrav * xrrav ; + Double_t yrryrr = yrrav * yrrav ; + Double_t rrrrm1 = rrrrav - 1.0 ; + Double_t xxyy = xxav * yyav ; + + Double_t c0 = rrrrm1*xxyy - xrrxrr*yyav - yrryrr*xxav ; + Double_t c1 = - rrrrm1 + xrrxrr + yrryrr - 4.0*xxyy ; + Double_t c2 = 4.0 + rrrrm1 - 4.0*xxyy ; + Double_t c4 = - 4.0 ; +// +//--> COEFFICIENTS OF THE DERIVATIVE - USED IN NEWTON-RAPHSON ITERATIONS +// + Double_t c2d = 2.0 * c2 ; + Double_t c4d = 4.0 * c4 ; +// +//--> 0'TH VALUE OF LAMDA - LINEAR INTERPOLATION BETWEEN P(0) & P(YYAV) +// +// LAMDA = YYAV * C0 / (C0 + YRRSQ * (XXAV-YYAV)) + Double_t lamda = 0.0 ; + Double_t dlamda = 0.0 ; +// + Double_t chiscl = wsum * rscale * rscale ; + Double_t dlamax = 0.001 / chiscl ; + + Double_t p, pd ; + for ( int itry = 1 ; itry <= ntry ; itry++ ) { + p = c0 + lamda * (c1 + lamda * (c2 + lamda * lamda * c4 )) ; + pd = (c1 + lamda * (c2d + lamda * lamda * c4d)) ; + dlamda = -p / pd ; + lamda = lamda + dlamda ; + if (fabs(dlamda)< dlamax) break ; + } + + Double_t chi2 = (Double_t)(chiscl * lamda) ; + + fTrack->SetChiSq1(chi2); + // Double_t dchisq = chiscl * dlamda ; +// +//--> NOW CALCULATE THE MATRIX ELEMENTS FOR ALPHA, BETA & KAPPA +// + Double_t h11 = xxav - lamda ; + Double_t h14 = xrrav ; + Double_t h22 = yyav - lamda ; + Double_t h24 = yrrav ; + Double_t h34 = 1.0 + 2.0*lamda ; + if ( h11 == 0.0 || h22 == 0.0 ){ + LOG(AliL3Log::kError,"AliL3ConfMapFit::FitCircle","TrackFit")< fabs(h24) ) { + ratio = h24 / h22 ; + rootsq = ratio * ratio + rootsq ; + kappa = 1.0 / sqrt(rootsq) ; + beta = - ratio * kappa ; + } + else { + ratio = h22 / h24 ; + rootsq = 1.0 + ratio * ratio * rootsq ; + beta = 1.0 / sqrt(rootsq) ; + if ( h24 > 0 ) beta = - beta ; + kappa = -ratio * beta ; + } + Double_t alpha = - (h14/h11) * kappa ; +// +//--> transform these into the lab coordinate system +//--> first get kappa and back to real dimensions +// + Double_t kappa1 = kappa / rscale ; + Double_t dbro = 0.5 / kappa1 ; +// +//--> next rotate alpha and beta and scale +// + Double_t alphar = (cosrot * alpha - sinrot * beta)* dbro ; + Double_t betar = (sinrot * alpha + cosrot * beta)* dbro ; +// +//--> then translate by (xav,yav) +// + Double_t acent = (double)(xav - alphar) ; + Double_t bcent = (double)(yav - betar ) ; + Double_t radius = (double)dbro ; +// +// Get charge +// + Double_t q = ( ( yrrav < 0 ) ? 1 : -1 ) ; + + fTrack->SetCharge(q); + +// +// Get other track parameters +// + Double_t x0, y0,phi0,r0,psi,pt ; + if ( fTrack->ComesFromMainVertex() == true ) + { + //flag = 1 ; // primary track flag + x0 = fVertex->GetX() ; + y0 = fVertex->GetY() ; + phi0 = fVertex->GetPhi() ; + r0 = fVertex->GetR() ; + fTrack->SetPhi0(phi0); + fTrack->SetR0(r0); + } + else + { + //AliL3ConfMapPoint *lHit = (AliL3ConfMapPoint*)hits->Last(); + AliL3ConfMapPoint *lHit = (AliL3ConfMapPoint*)fTrack->lastHit; + //flag = 0 ; // primary track flag + x0 = lHit->GetX() ; + y0 = lHit->GetY() ; + phi0 = atan2(lHit->GetY(),lHit->GetX()); + if ( phi0 < 0 ) phi0 += 2*pi; + r0 = sqrt ( lHit->GetX() * lHit->GetX() + lHit->GetY() * lHit->GetY() ) ; + fTrack->SetPhi0(phi0); + fTrack->SetR0(r0); + } + // + psi = (Double_t)atan2(bcent-y0,acent-x0) ; + psi = psi + q * 0.5F * pi ; + if ( psi < 0 ) psi = psi + 2*pi; + + pt = (Double_t)(BFACT * bField * radius ) ; + fTrack->SetPsi(psi); + fTrack->SetPt(pt); + + // +// Get errors from fast fit +// + //if ( getPara()->getErrors ) getErrorsCircleFit ( acent, bcent, radius ) ; +// + return 0 ; + +} + +//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// Fit Line in s-z plane +//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +Int_t AliL3ConfMapFit::FitLine ( ) +{ + // + //Initialization + // + Double_t sum = 0.F ; + Double_t ss = 0.F ; + Double_t sz = 0.F ; + Double_t sss = 0.F ; + Double_t ssz = 0.F ; + // + //find sum , sums ,sumz, sumss + // + Double_t dx, dy ; + Double_t radius = (Double_t)(fTrack->GetPt() / ( BFACT * bField ) ) ; + + //TObjArray *hits = fTrack->GetHits(); + //Int_t num_of_hits = fTrack->GetNumberOfPoints(); + + if ( fTrack->ComesFromMainVertex() == true ) + { + dx = ((AliL3ConfMapPoint*)fTrack->firstHit)->GetX() - fVertex->GetX(); + dy = ((AliL3ConfMapPoint*)fTrack->firstHit)->GetY() - fVertex->GetY() ; + } + else + { + dx = ((AliL3ConfMapPoint *)fTrack->firstHit)->GetX() - ((AliL3ConfMapPoint *)fTrack->lastHit)->GetX() ; + dy = ((AliL3ConfMapPoint *)fTrack->firstHit)->GetY() - ((AliL3ConfMapPoint *)fTrack->lastHit)->GetY() ; + //dx = ((AliL3ConfMapPoint *)hits->First())->GetX() - ((AliL3ConfMapPoint *)hits->Last())->GetX() ; + //dy = ((AliL3ConfMapPoint *)hits->First())->GetY() - ((AliL3ConfMapPoint *)hits->Last())->GetY() ; + } + + Double_t localPsi = 0.5F * sqrt ( dx*dx + dy*dy ) / radius ; + Double_t total_s ; + + if ( fabs(localPsi) < 1. ) + { + total_s = 2.0 * radius * asin ( localPsi ) ; + } + else + { + total_s = 2.0 * radius * pi ; + } + + AliL3ConfMapPoint *previousHit = NULL; + + // FtfBaseHit *previousHit = 0 ; + + //for ( startLoop() ; done() ; nextHit() ) { + Double_t dpsi,s; + + // for(hit_counter=0; hit_counterStartLoop(); fTrack->LoopDone(); fTrack->GetNextHit()) + { + // AliL3ConfMapPoint *cHit = (AliL3ConfMapPoint*)hits->At(hit_counter); + AliL3ConfMapPoint *cHit = (AliL3ConfMapPoint*)fTrack->currentHit; + // if ( currentHit != firstHit ) + if(cHit != fTrack->firstHit)// hits->First()) + { + dx = cHit->GetX() - previousHit->GetX() ; + dy = cHit->GetY() - previousHit->GetY() ; + dpsi = 0.5 * (Double_t)sqrt ( dx*dx + dy*dy ) / radius ; + fTrack->SetPsierr(dpsi); + s = previousHit->GetS() - 2.0 * radius * (Double_t)asin ( dpsi ) ; + cHit->SetS(s); + } + else + cHit->SetS(total_s); + // cHit->s = total_s ; + + sum += cHit->GetZWeight() ; + ss += cHit->GetZWeight() * cHit->GetS() ; + sz += cHit->GetZWeight() * cHit->GetZ() ; + sss += cHit->GetZWeight() * cHit->GetS() * cHit->GetS() ; + ssz += cHit->GetZWeight() * cHit->GetS() * cHit->GetZ() ; + previousHit = cHit ; + } + + Double_t chi2,det = sum * sss - ss * ss; + if ( fabs(det) < 1e-20) + { + chi2 = 99999.F ; + fTrack->SetChiSq2(chi2); + return 0 ; + } + + //Compute the best fitted parameters A,B + Double_t tanl,z0,dtanl,dz0; + + tanl = (Double_t)((sum * ssz - ss * sz ) / det ); + z0 = (Double_t)((sz * sss - ssz * ss ) / det ); + + fTrack->SetTgl(tanl); + fTrack->SetZ0(z0); + + // calculate chi-square + + chi2 = 0.; + Double_t r1 ; + + //for(hit_counter=0; hit_counterStartLoop(); fTrack->LoopDone(); fTrack->GetNextHit()) + { + //AliL3ConfMapPoint *cHit = (AliL3ConfMapPoint*)hits->At(hit_counter); + AliL3ConfMapPoint *cHit = (AliL3ConfMapPoint*)fTrack->currentHit; + r1 = cHit->GetZ() - tanl * cHit->GetS() - z0 ; + chi2 += (Double_t) ( (Double_t)cHit->GetZWeight() * (r1 * r1) ); + } + fTrack->SetChiSq2(chi2); + // + // calculate estimated variance + // varsq=chi/(double(n)-2.) + // calculate covariance matrix + // siga=sqrt(varsq*sxx/det) + // sigb=sqrt(varsq*sum/det) + // + dtanl = (Double_t) ( sum / det ); + dz0 = (Double_t) ( sss / det ); + + fTrack->SetTglerr(dtanl); + fTrack->SetZ0err(dz0); + + return 0 ; +} diff --git a/HLT/src/AliL3ConfMapFit.h b/HLT/src/AliL3ConfMapFit.h new file mode 100644 index 00000000000..8cfb69a21b3 --- /dev/null +++ b/HLT/src/AliL3ConfMapFit.h @@ -0,0 +1,30 @@ +#ifndef ALIL3_ConfMapFit +#define ALIL3_ConfMapFit + +#include "AliL3RootTypes.h" + +class AliL3ConfMapTrack; +class AliL3Vertex; + +class AliL3ConfMapFit { + + private: + AliL3ConfMapTrack *fTrack; //! + AliL3Vertex *fVertex; //! + Double_t BFACT; + Double_t bField; + + static Double_t pi; + + public: + AliL3ConfMapFit (AliL3ConfMapTrack *track,AliL3Vertex *vertex); + virtual ~AliL3ConfMapFit() {}; + + Int_t FitHelix(); + Int_t FitCircle(); + Int_t FitLine(); + + ClassDef(AliL3ConfMapFit,1) //Conformal mapping fit class +}; + +#endif diff --git a/HLT/src/AliL3ConfMapPoint.cxx b/HLT/src/AliL3ConfMapPoint.cxx new file mode 100644 index 00000000000..e212b8b3f01 --- /dev/null +++ b/HLT/src/AliL3ConfMapPoint.cxx @@ -0,0 +1,223 @@ +//Author: Anders Strand Vestbo + +//________________________________ +// AliL3ConfMapPoint +// +// Hit class for conformal mapper + +#include +#include +#include "AliL3Logging.h" + +#include "AliL3ConfMapPoint.h" +#include "AliL3SpacePointData.h" +#include "AliL3Vertex.h" +#include "AliL3ConfMapTrack.h" + +//ClassImp(AliL3ConfMapPoint) + +AliL3ConfMapPoint::AliL3ConfMapPoint() +{ + //Constructor + + SetUsage(false); + SetHitNumber(-1); + SetX(0); + SetY(0); + SetZ(0); + SetXerr(0); + SetYerr(0); + SetZerr(0); + + SetPhi(0.); + SetEta(0.); + + SetXprime(0.); + SetYprime(0.); + SetXprimeerr(0.); + SetYprimeerr(0.); + SetIntPoint(0., 0., 0., 0., 0., 0.); + SetShiftedCoord(); + SetMCTrackID(0.,0.,0.); +} + +AliL3ConfMapPoint::~AliL3ConfMapPoint() +{ + // Destructor. + // Does nothing except destruct. +} + +Bool_t AliL3ConfMapPoint::ReadHits(AliL3SpacePointData* hits ){ + SetHitNumber(hits->fID); + SetPadRow(hits->fPadRow); + Int_t slice = (hits->fID>>25) & 0x7f; + SetSector(slice); + SetX(hits->fX); + SetY(hits->fY); + SetZ(hits->fZ); + SetXerr(sqrt(hits->fXYErr)); + SetYerr(sqrt(hits->fXYErr)); + SetZerr(sqrt(hits->fZErr)); + return kTRUE; +} + +void AliL3ConfMapPoint::Setup(AliL3Vertex *vertex) +{ + //Setup. Sets the vertex, conformal coordinates, and phi and eta of each hit. + + SetIntPoint(vertex->GetX(), vertex->GetY(), vertex->GetZ(), + vertex->GetXErr(), vertex->GetYErr(), vertex->GetZErr()); + SetShiftedCoord(); + SetConfCoord(); + // The angles are set properly if they are set after the interaction point and the shifted coordinates + SetAngles(); + //SetDist(0., 0.); + + return; +} + +void AliL3ConfMapPoint::SetIntPoint(const Double_t in_x,const Double_t in_y, + const Double_t in_z, + const Double_t in_x_err, const Double_t in_y_err, + const Double_t in_z_err) +{ + // Defines a new interaction point. This point is needed to calculate + // the conformal coordinates. + + SetXt(in_x); + SetYt(in_y); + SetZt(in_z); + SetXterr(in_x_err); + SetYterr(in_y_err); + SetZterr(in_z_err); + + return; +} + +void AliL3ConfMapPoint::SetAllCoord(const AliL3ConfMapPoint *preceding_hit) +{ + // Sets the interaction point, the shifted coordinates, and the conformal mapping coordinates. + // These values are calculated from the interaction point of the given cluster which should be a + // already found cluster on the same track. + + if (this == preceding_hit) { + SetIntPoint(preceding_hit->GetX(), preceding_hit->GetY(), preceding_hit->GetZ(), + preceding_hit->GetXerr(), preceding_hit->GetYerr(), preceding_hit->GetZerr()); + } + + else { + SetIntPoint(preceding_hit->GetXt(), preceding_hit->GetYt(), preceding_hit->GetZt(), + preceding_hit->GetXterr(), preceding_hit->GetYterr(), preceding_hit->GetZterr()); + } + + SetShiftedCoord(); + SetConfCoord(); + + return; +} + +void AliL3ConfMapPoint::SetShiftedCoord() +{ + // Sets the coordinates with resepct to the given vertex point + + SetXv(GetX() - fXt); + SetYv(GetY() - fYt); + SetZv(GetZ() - fZt); + /* + SetXverr(TMath::Sqrt(GetXerr()*GetXerr() + fXterr*fXterr)); + SetYverr(TMath::Sqrt(GetYerr()*GetYerr() + fYterr*fYterr)); + SetZverr(TMath::Sqrt(GetZerr()*GetZerr() + fZterr*fZterr)); + */ + return; +} + +void AliL3ConfMapPoint::SetConfCoord() +{ + // Calculates the conformal coordinates of one cluster. + // If the option "vertex_constraint" applies the interaction point is + // assumed to be at (0, 0, 0). Otherwise the function will use the + // interaction point specified by fXt and fYt. + + Double_t r2; + Double_t xyErrorScale = 1; + Double_t szErrorScale = 1; + + if ((r2 = fXv*fXv + fYv*fYv)) + { + fXprime = fXv / r2; + fYprime = -fYv / r2; + // fXprimeerr = TMath::Sqrt(TMath::Power((-fXv * fXv + fYv*fYv) * fXverr, 2) + TMath::Power( 2*fXv*fYv*fYverr, 2)) / TMath::Power(fXv*fXv + fYv*fYv, 2); + // fXprimeerr = TMath::Sqrt(TMath::Power((-fXv * fXv - 3*fYv*fYv) * fYverr, 2) + TMath::Power(-2*fXv*fYv*fXverr, 2)) / TMath::Power(fXv*fXv + fYv*fYv, 2); + + + //set weights: + //fWxy = r2*r2 / (TMath::Power(xyErrorScale,2)*(TMath::Power(xerr,2)+TMath::Power(yerr,2))); + fWxy = r2*r2 / ((xyErrorScale*xyErrorScale)*((xerr*xerr)+(yerr*yerr))); + s = 0; //track trajectory + //fWz = (Double_t)(1./TMath::Power(szErrorScale*zerr,2)); + fWz = (Double_t)(1./(szErrorScale*zerr*zerr)); + } + + else { + fXprime = 0.; + fYprime = 0.; + fXprimeerr = 0.; + fYprimeerr = 0.; + fWxy = 0; + fWz = 0; + s = 0; + } + + return; +} + +void AliL3ConfMapPoint::SetAngles() +{ + // Calculates the angle phi and the pseudorapidity eta for each cluster. + /* + Double_t r = TMath::Sqrt(x*x + y*y); + + fPhi = TMath::ATan2(y,x); + if(fPhi<0) fPhi = fPhi + 2*TMath::Pi(); + fEta = 3.*z/(TMath::Abs(z)+2.*r); + return; + */ + // Double_t r3dim = TMath::Sqrt(fXv*fXv + fYv*fYv + fZv*fZv); + Double_t r3dim = sqrt(fXv*fXv + fYv*fYv + fZv*fZv); + //Double_t r2dim = TMath::Sqrt(fXv*fXv + fYv*fYv); + + /*if (r2dim == 0.) { + // If r2dim == 0 the pseudorapidity eta cannot be calculated (division by zero)! + // This can only happen if the point is lying on the z-axis and this should never be possible. + cerr << "The pseudorapidity eta cannot be calculated (division by zero)! Set to 1.e-10." << endl; + r2dim = 1.e-10; + } + + if (fXv == 0.) { + fPhi = (fYv > 0.) ? TMath::Pi() / 2. : - TMath::Pi() / 2.; + } + + else { + fPhi = (fXv > 0.) ? TMath::ASin(fYv/r2dim) : TMath::Pi() - TMath::ASin(fYv/r2dim); + } + + if (fPhi < 0.) { + fPhi += 2. * TMath::Pi(); + } + */ + //fPhi = TMath::ATan2(y,x); + fPhi = atan2(y,x); + //if(fPhi<0) fPhi = fPhi + 2*TMath::Pi(); + + //fEta = 0.5 * TMath::Log((r3dim + fZv)/(r3dim - fZv)); + fEta = 0.5 * log((r3dim + fZv)/(r3dim - fZv)); + return; +} +/* +AliL3ConfMapTrack *AliL3ConfMapPoint::GetTrack(TClonesArray *tracks) const +{ + // Returns the pointer to the track to which this hit belongs. + + return (AliL3ConfMapTrack*)tracks->At(this->GetTrackNumber()); +} +*/ diff --git a/HLT/src/AliL3ConfMapPoint.h b/HLT/src/AliL3ConfMapPoint.h new file mode 100644 index 00000000000..0ace9747a43 --- /dev/null +++ b/HLT/src/AliL3ConfMapPoint.h @@ -0,0 +1,184 @@ +#ifndef ALIL3_ConfMapPoint +#define ALIL3_ConfMapPoint + +#include "AliL3RootTypes.h" + +class AliL3SpacePointData; +class AliL3ConfMapTrack; +class AliL3Vertex; + +class AliL3ConfMapPoint { + + private: + + Int_t fHitNumber; + Int_t fTrackNumber; + Int_t fNextHitNumber; + Bool_t fUsed; + + Int_t fPadrow; + Int_t fSector; + + //global coordinates and their errors + Double_t x; + Double_t y; + Double_t z; + Double_t xerr; + Double_t yerr; + Double_t zerr; + + Double_t fWxy; // x-y weight on x-y + Double_t fWz; // z weight on z + Float_t s; //track trajectory + + // Interaction point + Double_t fXt; // x-value of the interaction point + Double_t fYt; // y-value of the interaction point + Double_t fZt; // z-value of the interaction point + + Double_t fXterr; // error of mXt + Double_t fYterr; // error of mYt + Double_t fZterr; // error of mZt + + // conformal mapping coordinates + Double_t fXprime; // transformed x + Double_t fYprime; // transformed y + + Double_t fXprimeerr; // error of mXprime + Double_t fYprimeerr; // error of mYprime + + // coordinates with respect to the vertex + + // cartesian coordinates + Double_t fXv; // x with respect to vertex + Double_t fYv; // y with respect to vertex + Double_t fZv; // z with respect to vertex + + Double_t fXverr; // error of mXv + Double_t fYverr; // error of mYv + Double_t fZverr; // error of mZv + + // spherical coordinates + Double_t fPhi; // angle phi + Double_t fEta; // pseudorapidity + + + public: + + AliL3ConfMapPoint(); + virtual ~AliL3ConfMapPoint(); + + Bool_t ReadHits(AliL3SpacePointData* hits ); //! + + AliL3ConfMapPoint *nextVolumeHit; //! + AliL3ConfMapPoint *nextRowHit; //! + + AliL3ConfMapPoint *nextTrackHit; //! Linked chain of points in a track + Short_t phiIndex; + Short_t etaIndex; + + Double_t xyChi2; + Double_t szChi2; + Int_t fMCTrackID[3]; //MClabel of tracks, may overlap + + // getter + Double_t GetX() const {return x;} + Double_t GetY() const {return y;} + Double_t GetZ() const {return z;} + Double_t GetXerr() const {return xerr;} + Double_t GetYerr() const {return yerr;} + Double_t GetZerr() const {return zerr;} + Int_t GetPadRow() const {return fPadrow;} + Int_t GetSector() const {return fSector;} + + Double_t GetXYWeight() const {return fWxy;} + Double_t GetZWeight() const {return fWz;} + Float_t GetS() const {return s;} + + //AliL3ConfMapTrack *GetTrack(TClonesArray *tracks) const; + + Bool_t GetUsage() const {return fUsed;} + Double_t GetPhi() const { return fPhi; } + Double_t GetEta() const { return fEta; } + + Double_t GetXprime() const { return fXprime; } + Double_t GetYprime() const { return fYprime; } + Double_t GetXprimeerr() const { return fXprimeerr; } + Double_t GetYprimeerr() const { return fYprimeerr; } + + Double_t GetXt() const { return fXt; } + Double_t GetYt() const { return fYt; } + Double_t GetZt() const { return fZt; } + Double_t GetXterr() const { return fXterr; } + Double_t GetYterr() const { return fYterr; } + Double_t GetZterr() const { return fZterr; } + + Double_t GetXv() const { return fXv; } + Double_t GetYv() const { return fYv; } + Double_t GetZv() const { return fZv; } + Double_t GetXverr() const { return fXverr; } + Double_t GetYverr() const { return fYverr; } + Double_t GetZverr() const { return fZverr; } + + Int_t GetHitNumber() const {return fHitNumber;} + Int_t GetNextHitNumber() const {return fNextHitNumber;} + Int_t GetTrackNumber() const {return fTrackNumber;} + // Int_t const *GetMCTrackID() const {return fMCTrackID;} + + // setter + void SetX(Double_t f) {x=f;} + void SetY(Double_t f) {y=f;} + void SetZ(Double_t f) {z=f;} + void SetXerr(Double_t f) {xerr=f;} + void SetYerr(Double_t f) {yerr=f;} + void SetZerr(Double_t f) {zerr=f;} + void SetPadRow(Int_t f) {fPadrow=f;} + void SetSector(Int_t f) {fSector=f;} + void SetMCTrackID(Int_t f,Int_t g,Int_t h) {fMCTrackID[0] = f; fMCTrackID[1]=g; fMCTrackID[2]=h;} + + void SetXYWeight(Float_t f) {fWxy = f;} + void SetZWeight(Float_t f) {fWz = f;} + void SetS(Float_t f) {s = f;} + + void SetUsage(Bool_t f) {fUsed=f;} + + void SetPhi(Double_t f) { fPhi = f; } + void SetEta(Double_t f) { fEta = f; } + + void SetXprime(Double_t f) { fXprime = f; } + void SetYprime(Double_t f) { fYprime = f; } + void SetXprimeerr(Double_t f) { fXprimeerr = f; } + void SetYprimeerr(Double_t f) { fYprimeerr = f; } + + void SetXt(Double_t f) { fXt = f; } + void SetYt(Double_t f) { fYt = f; } + void SetZt(Double_t f) { fZt = f; } + void SetXterr(Double_t f) { fXterr = f; } + void SetYterr(Double_t f) { fYterr = f; } + void SetZterr(Double_t f) { fZterr = f; } + + void SetXv(Double_t f) { fXv = f; } + void SetYv(Double_t f) { fYv = f; } + void SetZv(Double_t f) { fZv = f; } + void SetXverr(Double_t f) { fXverr = f; } + void SetYverr(Double_t f) { fYverr = f; } + void SetZverr(Double_t f) { fZverr = f; } + + void SetHitNumber(Int_t f) {fHitNumber=f;} + void SetTrackNumber(Int_t f) {fTrackNumber=f;} + void SetNextHitNumber(Int_t f) {fNextHitNumber=f;} + + void Setup(AliL3Vertex *vertex);// does the usual setup in the right order + void SetAngles();// calculate spherical angles and set values + void SetIntPoint(const Double_t in_x = 0.,const Double_t in_y = 0., + const Double_t in_z = 0.,const Double_t in_x_err = 0., + const Double_t in_y_err = 0., const Double_t in_z_err = 0.); + //-> set interaction point + void SetShiftedCoord();// set shifted coordinates + void SetAllCoord(const AliL3ConfMapPoint *hit);// set conformal mapping coordinates in respect to given hit + void SetConfCoord();// conformal mapping + +// ClassDef(AliL3ConfMapPoint, 1) //Conformal mapping hit class. +}; + +#endif diff --git a/HLT/src/AliL3ConfMapTrack.cxx b/HLT/src/AliL3ConfMapTrack.cxx new file mode 100644 index 00000000000..f38a99c097d --- /dev/null +++ b/HLT/src/AliL3ConfMapTrack.cxx @@ -0,0 +1,317 @@ + +//Author: Anders Strand Vestbo +//Author: Uli Frankenfeld +//Last Modified: 13.12.2000 + +//____________________________________ +// AliL3ConfMapTrack +// +// Track class for conformal mapper + +#include "AliL3RootTypes.h" +#include "AliL3Logging.h" +#include "AliL3Vertex.h" +#include "AliL3ConfMapPoint.h" +#include "AliL3ConfMapFit.h" +#include "AliL3ConfMapTrack.h" +#include + +ClassImp(AliL3ConfMapTrack) + + +AliL3ConfMapTrack::AliL3ConfMapTrack() +{ + //Constructor + + fChiSq[0] = 0.; + fChiSq[1] = 0.; + +} + +AliL3ConfMapTrack::~AliL3ConfMapTrack() +{ + +} + +void AliL3ConfMapTrack::DeleteCandidate() +{ + //Deletes this track by resetting all its parameters. Does not delete + //the object itself. + + AliL3ConfMapPoint *curHit = (AliL3ConfMapPoint*)firstHit; + AliL3ConfMapPoint *nextHit; + + while(curHit != 0) + { + nextHit = (AliL3ConfMapPoint*)curHit->nextTrackHit; + curHit->nextTrackHit = 0; + curHit = nextHit; + } + + UInt_t *hit_numbers = GetHitNumbers(); + for(Int_t i=0; iSetUsage(usage); + } + return; +} + +void AliL3ConfMapTrack::Reset() +{ + //Resets the fit parameters of this track. + + //xy-plane + s11Xy = 0; + s12Xy = 0; + s22Xy = 0; + g1Xy = 0; + g2Xy = 0; + fChiSq[0] = 0.; + + //sz-plane + s11Sz = 0; + s12Sz = 0; + s22Sz = 0; + g1Sz = 0; + g2Sz = 0; + fChiSq[1] = 0; + SetLength(0); + + +} + +void AliL3ConfMapTrack::UpdateParam(AliL3ConfMapPoint *thisHit) +{ + //Function to update fit parameters of track + //Also, it updates the hit pointers. + + + //Increment the number of hits assigned to this track: + + //fNHits++; + Int_t nhits = GetNHits(); + nhits++; + SetNHits(nhits); //SetNHits(nhits++); + + //Set the hit pointers: + //if(fNHits == 1) + if(GetNHits()==1) + firstHit = thisHit; + else + ((AliL3ConfMapPoint*)lastHit)->nextTrackHit = thisHit; + lastHit = thisHit; + + + s11Xy = s11Xy + thisHit->GetXYWeight() ; + s12Xy = s12Xy + thisHit->GetXYWeight() * thisHit->GetXprime() ; + s22Xy = s22Xy + thisHit->GetXYWeight() * pow((thisHit->GetXprime()),2) ; + g1Xy = g1Xy + thisHit->GetXYWeight() * thisHit->GetYprime() ; + g2Xy = g2Xy + thisHit->GetXYWeight() * thisHit->GetXprime() * thisHit->GetYprime() ; + + ddXy = s11Xy * s22Xy - pow((s12Xy),2) ; + if ( ddXy != 0 ) + { + a1Xy = ( g1Xy * s22Xy - g2Xy * s12Xy ) / ddXy ; + a2Xy = ( g2Xy * s11Xy - g1Xy * s12Xy ) / ddXy ; + } + + // Now in the sz plane + s11Sz = s11Sz + thisHit->GetZWeight() ; + s12Sz = s12Sz + thisHit->GetZWeight() * thisHit->GetS() ; + s22Sz = s22Sz + thisHit->GetZWeight() * thisHit->GetS() * thisHit->GetS() ; + g1Sz = g1Sz + thisHit->GetZWeight() * thisHit->GetZ() ; + g2Sz = g2Sz + thisHit->GetZWeight() * thisHit->GetS() * thisHit->GetZ() ; + + + ddSz = s11Sz * s22Sz - s12Sz * s12Sz ; + if ( ddSz != 0 ) { + a1Sz = ( g1Sz * s22Sz - g2Sz * s12Sz ) / ddSz ; + a2Sz = ( g2Sz * s11Sz - g1Sz * s12Sz ) / ddSz ; + } + +} + + +void AliL3ConfMapTrack::Fill(AliL3Vertex *vertex,Double_t max_Dca) +{ + //Fill track variables with or without fit. + + //fRadius = sqrt(a2Xy*a2Xy+1)/(2*fabs(a1Xy)); + Double_t radius = sqrt(a2Xy*a2Xy+1)/(2*fabs(a1Xy)); + SetRadius(radius); + + //fPt = (Double_t)(BFACT * bField * fRadius); + Double_t pt = (Double_t)(BFACT * bField * GetRadius()); + SetPt(pt); + + if(GetPt() > max_Dca) //go for fit of helix in real space + { + AliL3ConfMapFit *fit = new AliL3ConfMapFit(this,vertex); + fit->FitHelix(); + UpdateToFirstPoint(); + + delete fit; + } + else if(GetPt() == 0) + LOG(AliL3Log::kError,"AliL3ConfMapTrack::Fill","Tracks")<Last(); + AliL3ConfMapPoint *lHit = (AliL3ConfMapPoint*)lastHit; + Double_t radius = sqrt(lHit->GetX()*lHit->GetX()+lHit->GetY()*lHit->GetY()); + + //Get the track parameters + + Double_t tPhi0 = GetPsi() + GetCharge() * 0.5 * pi / fabs(GetCharge()) ; + Double_t x0 = GetR0() * cos(GetPhi0()) ; + Double_t y0 = GetR0() * sin(GetPhi0()) ; + Double_t rc = fabs(GetPt()) / ( BFACT * bField ) ; + Double_t xc = x0 - rc * cos(tPhi0) ; + Double_t yc = y0 - rc * sin(tPhi0) ; + + //Check helix and cylinder intersect + + Double_t fac1 = xc*xc + yc*yc ; + Double_t sfac = sqrt( fac1 ) ; + + if ( fabs(sfac-rc) > radius || fabs(sfac+rc) < radius ) { + LOG(AliL3Log::kError,"AliL3ConfMapTrack::UpdateToLastPoint","Tracks")< 2.*pi ) deltat -= 2. * pi ; + Double_t z = GetZ0() + rc * GetTgl() * deltat ; + + + Double_t xExtra = radius * cos(phi) ; + Double_t yExtra = radius * sin(phi) ; + + Double_t tPhi = atan2(yExtra-yc,xExtra-xc); + + //if ( tPhi < 0 ) tPhi += 2. * M_PI ; + + Double_t tPsi = tPhi - GetCharge() * 0.5 * pi / fabs(GetCharge()) ; + if ( tPsi > 2. * pi ) tPsi -= 2. * pi ; + if ( tPsi < 0. ) tPsi += 2. * pi ; + + //And finally, update the track parameters + + SetCenterX(xc); + SetCenterY(yc); + SetR0(radius); + SetPhi0(phi); + SetZ0(z); + SetPsi(tPsi); +} + +Int_t AliL3ConfMapTrack::GetMCLabel() +{ + //For evaluation study. + //Returns the MCtrackID of the belonging clusters. + //If MCLabel < 0, means that track is fake. + + return 0; + /* + Int_t num_of_clusters = GetNumberOfPoints(); + S *s=new S[num_of_clusters]; + Int_t i; + for (i=0; iUncheckedAt(i); + lab=fabs(c->fMCTrackID[0]); + Int_t j; + for (j=0; jmax) {max=s[i].max; lab=s[i].lab;} + + delete[] s; + + for (i=0; iUncheckedAt(i); + if (fabs(c->fMCTrackID[1]) == lab || + fabs(c->fMCTrackID[2]) == lab ) max++; + } + + //check if more than 10% of the clusters are incorrectly assigned (fake track): + + if (1.-Float_t(max)/num_of_clusters > 0.10) + { + return -lab; + } + Int_t tail=Int_t(0.08*174); + if (num_of_clusters < tail) return lab; + + max=0; + for (i=1; i<=tail; i++) { + AliL3ConfMapPoint *c = (AliL3ConfMapPoint*)fPoints->UncheckedAt(num_of_clusters-i); + if (lab == fabs(c->fMCTrackID[0]) || + lab == fabs(c->fMCTrackID[1]) || + lab == fabs(c->fMCTrackID[2])) max++; + } + if (max < Int_t(0.5*tail)) + { + //printf("Wrong innermost clusters\n"); + return -lab; + } + return lab; + */ +} + diff --git a/HLT/src/AliL3ConfMapTrack.h b/HLT/src/AliL3ConfMapTrack.h new file mode 100644 index 00000000000..df2557392fa --- /dev/null +++ b/HLT/src/AliL3ConfMapTrack.h @@ -0,0 +1,66 @@ +#ifndef ALIL3_ConfMapTrack +#define ALIL3_ConfMapTrack + +#include + +#include "AliL3Track.h" + +#include "AliL3RootTypes.h" +#include "AliL3ConfMapPoint.h" + +class AliL3Vertex; + +class AliL3ConfMapTrack :public AliL3Track { + + private: + + + public: + + AliL3ConfMapTrack(); + virtual ~AliL3ConfMapTrack(); + void Fill(AliL3Vertex *vertex,Double_t max_Dca); + void UpdateToFirstPoint(); + void Reset(); + void UpdateParam(AliL3ConfMapPoint *hit); + void DeleteCandidate(); + + void StartLoop() {currentHit = firstHit;} //! + void GetNextHit() {currentHit = ((AliL3ConfMapPoint*)currentHit)->nextTrackHit;} //! + Int_t LoopDone() {return currentHit != 0;} //! + AliL3ConfMapPoint *currentHit; //! + AliL3ConfMapPoint *lastHit; //! + AliL3ConfMapPoint *firstHit; //! + + + // getter + Double_t const *GetChiSq() const { return fChiSq;} + Int_t GetMCLabel(); + + // setter + void SetChiSq1(Double_t f) {fChiSq[0]=f;} + void SetChiSq2(Double_t f) {fChiSq[1]=f;} + void SetProperties(Bool_t fUsage); + + Double_t fChiSq[2]; + + //fit parameters. Bad naming convention, i know... + Double_t s11Xy ; + Double_t s12Xy ; + Double_t s22Xy ; + Double_t g1Xy ; + Double_t g2Xy ; + Double_t s11Sz ; + Double_t s12Sz ; + Double_t s22Sz ; + Double_t g1Sz ; + Double_t g2Sz ; + + Double_t ddXy, a1Xy, a2Xy ; /*fit par in xy */ + Double_t ddSz, a1Sz, a2Sz ; /*fit par in sz */ + + ClassDef(AliL3ConfMapTrack,1) //Conformal mapping track class +}; + +#endif + diff --git a/HLT/src/AliL3ConfMapper.cxx b/HLT/src/AliL3ConfMapper.cxx new file mode 100644 index 00000000000..0d4f90a622c --- /dev/null +++ b/HLT/src/AliL3ConfMapper.cxx @@ -0,0 +1,834 @@ + +//Author: Anders Strand Vestbo +//Last Modified: 15.12.2000 + +#include +#include +#include +#include "AliL3ConfMapper.h" + +#include "AliL3Logging.h" +#include "AliL3Transform.h" +#include "AliL3Vertex.h" +#include "AliL3ConfMapTrack.h" +#include "AliL3ConfMapPoint.h" +#include "AliL3TrackArray.h" + +// +//AliL3ConfMapper +// +//Conformal mapping base class + +ClassImp(AliL3ConfMapper) + +Double_t AliL3ConfMapper::pi=3.14159265358979323846; +Double_t AliL3ConfMapper::twopi=2*pi; +Double_t AliL3ConfMapper::todeg=180./pi; + +AliL3ConfMapper::AliL3ConfMapper() +{ + //Default constructor + fVertex = NULL; + fTrack = NULL; + fHit = NULL; + fHits = NULL; + fVolume = NULL; + fRow = NULL; + fBench = (Bool_t)true; + fParamSet = (Bool_t)false; + fVertexConstraint = (Bool_t)true; +} + + +AliL3ConfMapper::~AliL3ConfMapper() +{ + // Destructor. + + if(fVolume) { + delete [] fVolume; + } + if(fRow) { + delete [] fRow; + } + if(fHits) { + delete [] (Byte_t *)fHits; + } + if(fHit) { + delete [] fHit; + } + if(fTrack) { + delete fTrack; + } + +} + +void AliL3ConfMapper::InitSector(Int_t sector,Int_t *rowrange,Float_t *etarange) +{ + //Initialize tracker for tracking in a given sector. + //Resets track and hit arrays. + //Here it is also possible to specify a subsector, by defining + //rowrange[0]=innermost row; + //rowrange[1]=outermostrow; + //Finally you can specify etaslices to save time (assuming a good seed from TRD...) + + if(fHit) + { + delete [] fHit; + } + + if(fHits) { + delete [] (Byte_t *)fHits; + } + + if(fTrack) + { + delete fTrack; + } + + //Define tracking area: + if(rowrange) + { + fRowMin = rowrange[0]; + fRowMax = rowrange[1]; + } + else //complete sector + { + fRowMin = 0; + fRowMax = 173; + } + if(etarange) + { + fEtaMin = etarange[0]; + fEtaMax = etarange[1]; + } + else + { + fEtaMin = 0; + fEtaMax = sector < 18 ? 0.9 : -0.9; + } + + //Set the angles to sector 2: + fPhiMin = -1.*10/todeg;//fParam->GetAngle(sector) - 10/todeg; + fPhiMax = 10/todeg;//fParam->GetAngle(sector) + 10/todeg; + + //rotation angles for sector 2: + //cos: 0.766044 sin: 0.642788 + + Int_t max_num_of_tracks = 3000; + Int_t max_num_of_hits = 90000; +// Int_t max_num_of_hits = 20000; +// Int_t max_num_of_tracks = 2000; + + fHits= (AliL3ConfMapPoint **) new Byte_t[sizeof(AliL3ConfMapPoint *)*max_num_of_hits]; + fHit = new AliL3ConfMapPoint[max_num_of_hits]; + for(Int_t i=0;i>25) & 0x7f; + thisHit->SetHitNumber(hits[i].fID); + thisHit->SetPadRow(hits[i].fPadRow); + thisHit->SetSector(slice); + thisHit->SetX(hits[i].fX); + thisHit->SetY(hits[i].fY); + thisHit->SetZ(hits[i].fZ); + thisHit->SetXerr(sqrt(hits[i].fXYErr)); + thisHit->SetYerr(sqrt(hits[i].fXYErr)); + thisHit->SetZerr(sqrt(hits[i].fZErr)); +// thisHit->SetXerr(3.16227766016837941e-01); +// thisHit->SetYerr(3.16227766016837941e-01); +// thisHit->SetZerr(4.47213595499957928e-01); + thisHit++; + +// fHits[i]->ReadHits(&(hits[i])); +// thisHit->ReadHits(&(hits[i])); +// thisHit++; + } + fClustersUnused += nhit; + LOG(AliL3Log::kInformational,"AliL3ConfMapper::ReadHits","#hits")<At(j); +// AliL3ConfMapPoint *thisHit = &(fHit[j]); + AliL3ConfMapPoint *thisHit = fHits[j]; + + thisHit->Setup(fVertex); + + Int_t localrow = thisHit->GetPadRow(); + + //reset pointers: + thisHit->nextVolumeHit=thisHit->nextRowHit=0; + + if(localrow < fRowMin || localrow > fRowMax) + continue; + + + //Get indexes: + thisHit->phiIndex=(Int_t)((thisHit->GetPhi()-fPhiMin)/phiSlice +1); + + if(thisHit->phiIndex<1 || thisHit->phiIndex>fNumPhiSegment) + { + fPhiHitsOutOfRange++; + continue; + } + + thisHit->etaIndex=(Int_t)((thisHit->GetEta()-fEtaMin)/etaSlice + 1); + if(thisHit->etaIndex<1 || thisHit->etaIndex>fNumEtaSegment) + { + fEtaHitsOutOfRange++; + continue; + } + + //set volume pointers + volumeIndex = localrow*fNumPhiEtaSegmentPlusOne+thisHit->phiIndex*fNumEtaSegmentPlusOne+thisHit->etaIndex; + if(fVolume[volumeIndex].first == NULL) + fVolume[volumeIndex].first = (void *)thisHit; + else + ((AliL3ConfMapPoint *)fVolume[volumeIndex].last)->nextVolumeHit=thisHit; + fVolume[volumeIndex].last = (void *)thisHit; + + + //set row pointers + if(fRow[localrow].first == NULL) + fRow[localrow].first = (void *)thisHit; + else + ((AliL3ConfMapPoint *)(fRow[localrow].last))->nextRowHit = thisHit; + fRow[localrow].last = (void *)thisHit; + + } + +} + +void AliL3ConfMapper::MainVertexTracking_a() +{ + //Tracking with vertex constraint. + + if(!fParamSet) + { + LOG(AliL3Log::kError,"AliL3ConfMapper::MainVertexTracking","Parameters")< 2) + + fGoodDist=goodDist; + SetMaxAngleTracklet(maxangle, vertex_constraint); +} + +void AliL3ConfMapper::ClusterLoop() +{ + //Loop over hits, starting at outermost padrow, and trying to build segments. + + Int_t row_segm,lastrow = fRowMin + fMinPoints[fVertexConstraint]; + AliL3ConfMapPoint *hit; + + //Loop over rows, and try to create tracks from the hits. + //Starts at the outermost row, and loops as long as a track can be build, due to length. + + for(row_segm = fRowMax; row_segm >= lastrow; row_segm--) + { + if(fRow[row_segm].first && ((AliL3ConfMapPoint*)fRow[row_segm].first)->GetPadRow() < fRowMin + 1) + break; + for(hit = (AliL3ConfMapPoint*)fRow[row_segm].first; hit!=0; hit=hit->nextRowHit) + { + if(hit->GetUsage() == true) + continue; + else + CreateTrack(hit); + } + } + + return; +} + + +void AliL3ConfMapper::CreateTrack(AliL3ConfMapPoint *hit) +{ + //Tries to create a track from the initial hit given by ClusterLoop() + + AliL3ConfMapPoint *closest_hit = NULL; + AliL3ConfMapTrack *track = NULL; + + Int_t point; + Int_t tracks = nTracks; + nTracks++; + + track = (AliL3ConfMapTrack*)fTrack->NextTrack(); + + //reset hit parameters: + track->Reset(); + + UInt_t *trackhitnumber = track->GetHitNumbers(); + + //set conformal coordinates if we are looking for non vertex tracks + if(!fVertexConstraint) + { + hit->SetAllCoord(hit); + } + + //fill fit parameters of initial track: + track->UpdateParam(hit); //here the number of hits is incremented. + trackhitnumber[track->GetNumberOfPoints()-1] = hit->GetHitNumber(); + + Double_t dx,dy; + //create tracklets: + + for(point=1; pointGetX() - ((AliL3ConfMapPoint*)hit)->GetX(); + dy = ((AliL3ConfMapPoint*)closest_hit)->GetY() - ((AliL3ConfMapPoint*)hit)->GetY(); + //track->fLength += (Double_t)sqrt ( dx * dx + dy * dy ) ; + Double_t length = track->GetLength()+(Double_t)sqrt ( dx * dx + dy * dy ); + track->SetLength(length); + + //closest_hit->SetS(track->fLength); + closest_hit->SetS(track->GetLength()); + + //update fit parameters + track->UpdateParam(closest_hit); + trackhitnumber[track->GetNumberOfPoints()-1] = closest_hit->GetHitNumber(); + + hit = closest_hit; + } + else + { + //closest hit does not exist: + track->DeleteCandidate(); + fTrack->RemoveLast(); + nTracks--; + point = fTrackletLength[fVertexConstraint]; + } + } + + //tracklet is long enough to be extended to a track + if(track->GetNumberOfPoints() == fTrackletLength[fVertexConstraint]) + { + + track->SetProperties(true); + + if(TrackletAngle(track) > fMaxAngleTracklet[fVertexConstraint]) + {//proof if the first points seem to be a beginning of a track + + track->SetProperties(false); + track->DeleteCandidate(); + fTrack->RemoveLast(); + nTracks--; + } + + else//good tracklet ->proceed, follow the trackfit + { + tracks++; + + //define variables to keep the total chi: + Double_t xyChi2 = track->fChiSq[0]; + Double_t szChi2 = track->fChiSq[1]; + + for(point = fTrackletLength[fVertexConstraint]; point <= fNumRowSegment; point++) + { + track->fChiSq[0] = fHitChi2Cut; + closest_hit = GetNextNeighbor((AliL3ConfMapPoint*)track->lastHit,track); + + if(closest_hit) + { + + //keep total chi: + Double_t lxyChi2 = track->fChiSq[0]-track->fChiSq[1]; + xyChi2 += lxyChi2; + closest_hit->xyChi2 = lxyChi2; + + //update track length: + //track->fLength = closest_hit->GetS(); + track->SetLength(closest_hit->GetS()); + szChi2 += track->fChiSq[1]; + closest_hit->szChi2 = track->fChiSq[1]; + + track->UpdateParam(closest_hit); + trackhitnumber[track->GetNumberOfPoints()-1] = closest_hit->GetHitNumber(); + + //add closest hit to track + closest_hit->SetUsage(true); + closest_hit->SetTrackNumber(tracks-1); + + }//closest_hit + + else + { + //closest hit does not exist + point = fNumRowSegment; //continue with next hit in segment + }//else + + }//create tracks + + //store track chi2: + track->fChiSq[0] = xyChi2; + track->fChiSq[1] = szChi2; + Double_t normalized_chi2 = (track->fChiSq[0]+track->fChiSq[1])/track->GetNumberOfPoints(); + + //remove tracks with not enough points already now + if(track->GetNumberOfPoints() < fMinPoints[fVertexConstraint] || normalized_chi2 > fTrackChi2Cut) + { + track->SetProperties(false); + nTracks--; + track->DeleteCandidate(); + fTrack->RemoveLast(); + tracks--; + } + + else + { + fClustersUnused -= track->GetNumberOfPoints(); + track->ComesFromMainVertex(fVertexConstraint); + //mark track as main vertex track or not + track->SetSector(2); //only needed for testing purposes. + track->SetRowRange(fRowMin,fRowMax); + + if(fVertexConstraint) + fMainVertexTracks++; + } + + }//good tracklet + + } + + return; +} + +AliL3ConfMapPoint *AliL3ConfMapper::GetNextNeighbor(AliL3ConfMapPoint *start_hit, + AliL3ConfMapTrack *track) +{ + //When forming segments: Finds closest hit to input hit + //When forming tracks: Find closest hit to track fit. + + Double_t dist,closest_dist = fMaxDist; + + AliL3ConfMapPoint *hit = NULL; + AliL3ConfMapPoint *closest_hit = NULL; + + Int_t sub_row_segm; + Int_t sub_phi_segm; + Int_t sub_eta_segm; + Int_t volumeIndex; + Int_t test_hit; + + Int_t max_row = start_hit->GetPadRow()-1; + Int_t min_row; + + if(track) //finding hit close to trackfit + { + min_row = start_hit->GetPadRow()-fRowScopeTrack[fVertexConstraint]; + } + else + { + min_row = start_hit->GetPadRow()-fRowScopeTracklet[fVertexConstraint]; + } + + //make a smart loop + Int_t loop_eta[9] = {0,0,0,-1,-1,-1,1,1,1}; + Int_t loop_phi[9] = {0,-1,1,0,-1,1,0,-1,1}; + + if(min_row < fRowMin) + min_row = fRowMin; + if(max_row < fRowMin) + return 0; //reached the last padrow under consideration + + else + { + //loop over sub rows + for(sub_row_segm=max_row; sub_row_segm>=min_row; sub_row_segm--) + { + //loop over subsegments, in the order defined above. + for(Int_t i=0; i<9; i++) + { + sub_phi_segm = start_hit->phiIndex + loop_phi[i]; + + if(sub_phi_segm<0) + sub_phi_segm += fNumPhiSegment; + + else if(sub_phi_segm >=fNumPhiSegment) + sub_phi_segm -= fNumPhiSegment; + + //loop over sub eta segments + + sub_eta_segm = start_hit->etaIndex + loop_eta[i]; + + if(sub_eta_segm < 0 || sub_eta_segm >=fNumEtaSegment) + continue;//segment exceeds bounds->skip it + + //loop over hits in this sub segment: + volumeIndex= sub_row_segm*fNumPhiEtaSegmentPlusOne + + sub_phi_segm*fNumEtaSegmentPlusOne + sub_eta_segm; + + if(volumeIndex<0) + {//debugging + LOG(AliL3Log::kError,"AliL3ConfMapper::GetNextNeighbor","Memory")<nextVolumeHit) + { + + if(!hit->GetUsage()) + {//hit was not used before + + //set conformal mapping if looking for nonvertex tracks: + if(!fVertexConstraint) + { + hit->SetAllCoord(start_hit); + } + + if(track)//track search - look for nearest neighbor to extrapolated track + { + if(!VerifyRange(start_hit,hit)) + continue; + + test_hit = EvaluateHit(start_hit,hit,track); + + if(test_hit == 0)//chi2 not good enough, keep looking + continue; + else if(test_hit==2)//chi2 good enough, return it + return hit; + else + closest_hit = hit;//chi2 acceptable, but keep looking + + }//track search + + else //tracklet search, look for nearest neighbor + { + + if((dist=CalcDistance(start_hit,hit)) < closest_dist) + { + if(!VerifyRange(start_hit,hit)) + continue; + closest_dist = dist; + closest_hit = hit; + + //if this hit is good enough, return it: + if(closest_dist < fGoodDist) + return closest_hit; + } + else + continue;//sub hit was farther away than a hit before + + }//tracklet search + + }//hit not used before + + else continue; //sub hit was used before + + }//loop over hits in sub segment + + }//loop over sub segments + + }//loop over subrows + + }//else + + //closest hit found: + if(closest_hit)// && closest_dist < mMaxDist) + return closest_hit; + else + return 0; +} + +Int_t AliL3ConfMapper::EvaluateHit(AliL3ConfMapPoint *start_hit,AliL3ConfMapPoint *hit,AliL3ConfMapTrack *track) +{ + //Check if space point gives a fit with acceptable chi2. + + Double_t temp,dxy,lchi2,dx,dy,slocal,dsz,lszChi2; + temp = (track->a2Xy*hit->GetXprime()-hit->GetYprime()+track->a1Xy); + dxy = temp*temp/(track->a2Xy*track->a2Xy + 1.); + + //Calculate chi2 + lchi2 = (dxy*hit->GetXYWeight()); + + if(lchi2 > track->fChiSq[0])//chi2 was worse than before. + return 0; + + //calculate s and the distance hit-line + dx = start_hit->GetX()-hit->GetX(); + dy = start_hit->GetY()-hit->GetY(); + //slocal = track->fLength+sqrt(dx*dx+dy*dy); + slocal = track->GetLength()+sqrt(dx*dx+dy*dy); + + temp = (track->a2Sz*slocal-hit->GetZ()+track->a1Sz); + dsz = temp*temp/(track->a2Sz*track->a2Sz+1); + + //calculate chi2 + lszChi2 = dsz*hit->GetZWeight(); + lchi2 += lszChi2; + + + //check whether chi2 is better than previous one: + if(lchi2 < track->fChiSq[0]) + { + track->fChiSq[0] = lchi2; + track->fChiSq[1] = lszChi2; + + hit->SetS(slocal); + + //if chi2 good enough, stop here: + if(lchi2 < fGoodHitChi2) + return 2; + + return 1; + } + + return 0; + +} + +Double_t AliL3ConfMapper::CalcDistance(const AliL3ConfMapPoint *hit1,const AliL3ConfMapPoint *hit2) const +{ + //Return distance between two clusters, defined by Pablo + + Double_t phi_diff = fabs( hit1->GetPhi() - hit2->GetPhi() ); + if (phi_diff > pi) phi_diff = twopi - phi_diff; + + return todeg*fabs(hit1->GetPadRow() - hit2->GetPadRow()) * (phi_diff + fabs( hit1->GetEta() - hit2->GetEta() )); +} + +Bool_t AliL3ConfMapper::VerifyRange(const AliL3ConfMapPoint *hit1,const AliL3ConfMapPoint *hit2) const +{ + //Check if the hit are within reasonable range in phi and eta + Double_t dphi,deta;//maxphi=0.1,maxeta=0.1; + dphi = fabs(hit1->GetPhi() - hit2->GetPhi()); + if(dphi > pi) dphi = fabs(twopi - dphi); + if(dphi > fMaxPhi) return false; + + deta = fabs(hit1->GetEta() - hit2->GetEta()); + if(deta > fMaxEta) return false; + + return true; + +} + +Double_t AliL3ConfMapper::TrackletAngle(const AliL3ConfMapTrack *track,Int_t n) const +{ + // Returns the angle 'between' the last three points (started at point number n) on this track. + + return 0; + /* + Double_t x1[2]; + Double_t x2[2]; + Double_t angle1,angle2; + TObjArray *hits = track->GetHits(); + + if (n > track->GetNumberOfPoints()) { + n = track->GetNumberOfPoints(); + } + + if (n<3) + return 0; + + + x1[0] = ((AliL3ConfMapPoint *)hits->At(n-2))->GetX() - ((AliL3ConfMapPoint *)hits->At(n-3))->GetX(); + x1[1] = ((AliL3ConfMapPoint *)hits->At(n-2))->GetY() - ((AliL3ConfMapPoint *)hits->At(n-3))->GetY(); + + x2[0] = ((AliL3ConfMapPoint *)hits->At(n-1))->GetX() - ((AliL3ConfMapPoint *)hits->At(n-2))->GetX(); + x2[1] = ((AliL3ConfMapPoint *)hits->At(n-1))->GetY() - ((AliL3ConfMapPoint *)hits->At(n-2))->GetY(); + + angle1 = atan2(x1[1],x1[0]); + angle2 = atan2(x2[1],x1[0]); + return fabs(angle1-angle2); + */ +} + +Int_t AliL3ConfMapper::FillTracks() +{ + //Fill track parameters. Which basically means do a fit of helix in real space, + //which should be done in order to get nice tracks. + + Int_t num_of_tracks = nTracks; + LOG(AliL3Log::kInformational,"AliL3ConfMapper::FillTracks","nTracks")<Sort(); + for(int i=0; iGetTrack(i); + track->Fill(fVertex,fMaxDca); + } + return 1; + +} + +Double_t AliL3ConfMapper::CpuTime() +{ + //Return the Cputime in seconds. + + return (Double_t)(clock()) / CLOCKS_PER_SEC; +} diff --git a/HLT/src/AliL3ConfMapper.h b/HLT/src/AliL3ConfMapper.h new file mode 100644 index 00000000000..48b11f2eff1 --- /dev/null +++ b/HLT/src/AliL3ConfMapper.h @@ -0,0 +1,142 @@ +#ifndef ALIL3_ConfMapper +#define ALIL3_ConfMapper + +#include "AliL3RootTypes.h" + +#include "AliL3SpacePointData.h" + +class AliL3ConfMapPoint; +class AliL3ConfMapTrack; +class AliL3Vertex; +class AliL3TrackArray; + +struct AliL3ConfMapContainer +{ + void *first; + void *last; +}; + +class AliL3ConfMapper { + + private: + + Bool_t fBench; //run-time measurements) + + Int_t nTracks; //number of tracks build. + + // AliTPCParam *fParam; + AliL3Vertex *fVertex; //! + Bool_t fParamSet; + Bool_t fVertexFinder; //Include vertexfinding or not (latter case vertex=(0,0,0)) + + AliL3ConfMapPoint **fHits; //! + AliL3ConfMapPoint *fHit; //! + AliL3TrackArray *fTrack; //! + Double_t fMaxDca; //cut value for momentum fit + + AliL3ConfMapContainer *fVolume; //! Segment volume + AliL3ConfMapContainer *fRow; //! Row volume + + //Number of cells (segments) + Int_t fNumRowSegment; // Total number of padrows + Int_t fNumPhiSegment; // number of phi segments + Int_t fNumEtaSegment; // number of eta segments + Int_t fNumRowSegmentPlusOne; + Int_t fNumPhiSegmentPlusOne; + Int_t fNumEtaSegmentPlusOne; + Int_t fNumPhiEtaSegmentPlusOne; + Int_t fBounds; + Int_t fPhiHitsOutOfRange; + Int_t fEtaHitsOutOfRange; + + //tracking range: + Float_t fPhiMin; //MinPhi angle to consider + Float_t fPhiMax; //MaxPhi angle to consider + Float_t fEtaMin; //MinEta to consider + Float_t fEtaMax; //MaxEta to consider + Int_t fRowMin; //Minimum row to consider + Int_t fRowMax; //Maximum row to consider + + Bool_t fVertexConstraint; //vertex constraint (true or false) + Int_t fTrackletLength[2]; //minimal length of tracks + Int_t fRowScopeTracklet[2]; //number of row segments to look for the next point of a tracklet + Int_t fRowScopeTrack[2]; //number of row segments to look for the next point of a track + Int_t fMinPoints[2]; //minimum number of points on one track + + // Cuts + Double_t fMaxAngleTracklet[2]; //limit of angle between to pieces of a tracklet + Int_t fMaxDist; //maximum distance between two hits + Double_t fHitChi2Cut; //Maximum hit chi2 + Double_t fGoodHitChi2; //Chi2 to stop looking for next hit + Double_t fTrackChi2Cut; //Maximum track chi2 + Double_t fGoodDist; //In segment building, distance consider good enough + Double_t fMaxPhi; + Double_t fMaxEta; + + // Tracking informtion + Int_t fMainVertexTracks; //number of tracks coming from the main vertex + Int_t fClustersUnused; //number of unused clusters + + static Double_t todeg; + static Double_t pi; + static Double_t twopi; + + //setter: + void SetMinPoints(Int_t f,Bool_t vertex_constraint) {fMinPoints[(Int_t)vertex_constraint] = f; } + void SetVertexConstraint(Bool_t f) {fVertexConstraint =f;} + + void SetTrackletLength(Int_t f,Bool_t vert) {fTrackletLength[(Int_t)vert]=f;} + void SetRowScopeTrack(Int_t f, Bool_t vertex_constraint) { fRowScopeTrack[(Int_t)vertex_constraint] = f; } // sets one row scope for tracks + void SetRowScopeTracklet(Int_t f, Bool_t vertex_constraint) { fRowScopeTracklet[(Int_t)vertex_constraint] = f; } // sets one row scope for tracklets + void SetMaxAngleTracklet(Double_t f, Bool_t vertex_constraint) { fMaxAngleTracklet[(Int_t)vertex_constraint] = f; } // sets one angle cut + + void SetPointers(); + Double_t CpuTime(); + + public: + + AliL3ConfMapper(); + // AliL3ConfMapper(AliTPCParam *param,AliL3Vertex *vertex,Bool_t bench=(Bool_t)false); + virtual ~AliL3ConfMapper(); + + void InitSector(Int_t sector,Int_t *rowrange=0,Float_t *etarange=0); + void SetVertex(AliL3Vertex *vertex){fVertex = vertex;} + void MainVertexTracking_a(); + void MainVertexTracking_b(); + void MainVertexTracking(); + void NonVertexTracking(); + void MainVertexSettings(Int_t trackletlength, Int_t tracklength, + Int_t rowscopetracklet, Int_t rowscopetrack,Double_t maxphi=0.1,Double_t maxeta=0.1); + void NonVertexSettings(Int_t trackletlength, Int_t tracklength, + Int_t rowscopetracklet, Int_t rowscopetrack); + Bool_t ReadHits(UInt_t count, AliL3SpacePointData* hits ); + void ClusterLoop(); + void CreateTrack(AliL3ConfMapPoint *hit); + AliL3ConfMapPoint *GetNextNeighbor(AliL3ConfMapPoint *start_hit,AliL3ConfMapTrack *track=NULL); + Int_t EvaluateHit(AliL3ConfMapPoint *start_hit,AliL3ConfMapPoint *hit,AliL3ConfMapTrack *track); + + Double_t CalcDistance(const AliL3ConfMapPoint *hit1,const AliL3ConfMapPoint *hit2) const; + Double_t TrackletAngle(const AliL3ConfMapTrack *track,Int_t n=3) const; + Bool_t VerifyRange(const AliL3ConfMapPoint *hit1,const AliL3ConfMapPoint *hit2) const; + Int_t FillTracks(); + + //getters + Int_t GetNumberOfTracks() {return nTracks;} + AliL3TrackArray *GetTracks() {return fTrack;} + Double_t GetMaxDca() const {return fMaxDca;} + AliL3Vertex* GetVertex() const + { + return fVertex; + } + + //setters + void SetTrackCuts(Double_t hitChi2Cut, Double_t goodHitChi2, Int_t trackChi2Cut, Int_t maxdist); + void SetTrackletCuts(Double_t maxangle,Double_t goodDist,Bool_t vertex_constraint); //Set cut of tracklet for the given vertex_constraint + void SetNSegments(Int_t f,Int_t g) {fNumPhiSegment=f,fNumEtaSegment=g;} //Set number of subvolumes (#segments in (phi,eta) + void SetParamDone(Bool_t f) {fParamSet = (Bool_t)f;} + void SetMaxDca(Double_t f) {fMaxDca = f;} + + ClassDef(AliL3ConfMapper,1) //Base class for conformal mapping tracking +}; + +#endif diff --git a/HLT/src/AliL3Defs.h b/HLT/src/AliL3Defs.h new file mode 100644 index 00000000000..129d8df68b5 --- /dev/null +++ b/HLT/src/AliL3Defs.h @@ -0,0 +1,11 @@ +#ifndef _ALIL3DEFS_H_ +#define _ALIL3DEFS_H_ + +#include "AliL3RootTypes.h" + +const Int_t NRows[5][2] = {{ 0, 45},{46,77},{78,109},{110,141},{142,173}}; +const Double_t Pi = 3.14159265358979323846; +const Double_t ToRad = Pi/180.; + + +#endif /* _ALIL3DEFS_H_ */ diff --git a/HLT/src/AliL3DigitData.h b/HLT/src/AliL3DigitData.h new file mode 100644 index 00000000000..de898516f43 --- /dev/null +++ b/HLT/src/AliL3DigitData.h @@ -0,0 +1,29 @@ +#ifndef _DIGITDATA_H_ +#define _DIGITDATA_H_ + +#include "AliL3RootTypes.h" + +struct AliL3DigitData +{ + UShort_t fCharge; + UChar_t fPad; + UShort_t fTime; +}; +typedef struct AliL3DigitData AliL3DigitData; + +struct AliL3DigitRowData +{ + UInt_t fNDigit; + UInt_t fRow; + AliL3DigitData fDigitData[0]; +}; +typedef struct AliL3DigitRowData AliL3DigitRowData; + +struct AliL3RandomDigitData{ + UChar_t fRow; + UShort_t fCharge; + UChar_t fPad; + UShort_t fTime; +}; +typedef struct AliL3RandomDigitData AliL3RandomDigitData; +#endif /* _DIGITDATA_H_ */ diff --git a/HLT/src/AliL3Display.cxx b/HLT/src/AliL3Display.cxx new file mode 100644 index 00000000000..a425989f23a --- /dev/null +++ b/HLT/src/AliL3Display.cxx @@ -0,0 +1,363 @@ +//Author: Anders Strand Vestbo +//Last Modified: 12.01.2001 + +#include +#include +#include +#include +#include +#include + +#include "AliSimDigits.h" +#include "AliTPCParam.h" +#include "AliL3Transform.h" +#include "AliL3Track.h" +#include "AliL3TrackArray.h" +#include "AliL3SpacePointData.h" +#include "AliL3FileHandler.h" +#include "AliL3Logging.h" +#include "AliL3Display.h" + +// AliL3Display +// Simple display class for the Level3 tracker. + +ClassImp(AliL3Display) + +AliL3Display::AliL3Display() +{ + fGeom = NULL; + fTracks = NULL; +} + +AliL3Display::AliL3Display(Int_t *slice) +{ + //Ctor. Specify which slices you want to look at. + + TFile *file = new TFile("alice.geom"); + if(file->IsOpen()) + LOG(AliL3Log::kError,"AliL3Display::AliL3Display","File Open") + <<"Geometry file alice.geom does not exist"<Get("AliceGeom"); + fMinSlice = slice[0]; + fMaxSlice = slice[1]; + + file->Close(); + delete file; +} + +AliL3Display::~AliL3Display() +{ + + if(fTracks) + delete fTracks; + +} + +void AliL3Display::Setup(Char_t *trackfile) +{ + //Read in the hit and track information from produced files. + + Char_t fname[256]; + AliL3FileHandler *clusterfile[36][5]; + for(Int_t s=fMinSlice; s<=fMaxSlice; s++) + { + for(Int_t p=0; p<5; p++) + { + clusterfile[s][p] = new AliL3FileHandler(); + sprintf(fname,"points_%d_%d.raw",s,p); + if(!clusterfile[s][p]->SetBinaryInput(fname)) + { + LOG(AliL3Log::kError,"AliL3Evaluation::Setup","File Open") + <<"Inputfile "<Allocate(); + clusterfile[s][p]->Binary2Memory(fNcl[s][p],fClusters[s][p]); + clusterfile[s][p]->CloseBinaryInput(); + } + } + + + AliL3FileHandler *tfile = new AliL3FileHandler(); + if(!tfile->SetBinaryInput(trackfile)) + { + LOG(AliL3Log::kError,"AliL3Evaluation::Setup","File Open") + <<"Inputfile "<Binary2TrackArray(fTracks); + tfile->CloseBinaryInput(); + delete tfile; + +} + +void AliL3Display::DisplayTracks(Int_t min_hits) +{ + //Display the found tracks. + + TCanvas *c1 = new TCanvas("c1","",700,700); + c1->cd(); + TView *v = new TView(1); + v->SetRange(-430,-560,-430,430,560,1710); + c1->Clear(); + c1->SetFillColor(1); + c1->SetTheta(90.); + c1->SetPhi(0.); + + Int_t ntracks = fTracks->GetNTracks(); + TPolyLine3D *line = new TPolyLine3D[ntracks]; + Float_t xcl[174]; + Float_t ycl[174]; + Float_t zcl[174]; + + for(Int_t j=0; jGetCheckedTrack(j); + if(!gtrack) continue; + Int_t nHits = gtrack->GetNHits(); + UInt_t *hitnum = gtrack->GetHitNumbers(); + if(nHits < min_hits) continue; + TPolyMarker3D *pm = new TPolyMarker3D(nHits); + for(Int_t h=0; h>25) & 0x7f; + Int_t patch = (id>>22) & 0x7; + UInt_t pos = id&0x3fffff; + + AliL3SpacePointData *points = fClusters[slice][patch]; + + if(!points) { + LOG(AliL3Log::kError,"AliL3Display::DisplayTracks","Clusterarray") + <<"No points at slice "<=fNcl[slice][patch]) {printf("Error \n"); continue;} + xcl[h] = points[pos].fX; + ycl[h] = points[pos].fY; + zcl[h] = points[pos].fZ; + pm->SetPoint(h,xcl[h],ycl[h],zcl[h]); + } + pm->SetMarkerColor(3); + pm->Draw(); + TPolyLine3D *current_line = &(line[j]); + current_line = new TPolyLine3D(nHits,xcl,ycl,zcl,""); + + current_line->SetLineColor(4); + current_line->Draw("same"); + } + + fGeom->Draw("same"); + + c1->x3d(); + +} + +void AliL3Display::DisplayClusters() +{ + //Display all clusters. + + TCanvas *c1 = new TCanvas("c1","",700,700); + c1->cd(); + TView *v = new TView(1); + v->SetRange(-430,-560,-430,430,560,1710); + c1->Clear(); + c1->SetFillColor(1); + c1->SetTheta(90.); + c1->SetPhi(0.); + + for(Int_t s=fMinSlice; s<=fMaxSlice; s++) + { + for(Int_t p=0;p<1;p++) + { + AliL3SpacePointData *points = fClusters[s][p]; + if(!points) continue; + Int_t npoints = fNcl[s][p]; + TPolyMarker3D *pm = new TPolyMarker3D(npoints); + + Float_t xyz[3]; + for(Int_t i=0; iSetPoint(i,xyz[0],xyz[1],xyz[2]); + + } + pm->SetMarkerColor(2); + pm->Draw(""); + } + } + fGeom->Draw("same"); + + c1->x3d(); +} + + +void AliL3Display::DisplayAll(Int_t min_hits) +{ + //Display tracks & all hits. + + + TCanvas *c1 = new TCanvas("c1","",700,700); + c1->cd(); + TView *v = new TView(1); + v->SetRange(-430,-560,-430,430,560,1710); + c1->Clear(); + c1->SetFillColor(1); + c1->SetTheta(90.); + c1->SetPhi(0.); + + for(Int_t s=fMinSlice; s<=fMaxSlice; s++) + { + for(Int_t p=0;p<1;p++) + { + AliL3SpacePointData *points = fClusters[s][p]; + if(!points) continue; + Int_t npoints = fNcl[s][p]; + TPolyMarker3D *pm = new TPolyMarker3D(npoints); + + Float_t xyz[3]; + for(Int_t i=0; iSetPoint(i,xyz[0],xyz[1],xyz[2]); + + } + pm->SetMarkerColor(2); + pm->Draw(""); + } + } + + Int_t ntracks = fTracks->GetNTracks(); + TPolyLine3D *line = new TPolyLine3D[ntracks]; + Float_t xcl[174]; + Float_t ycl[174]; + Float_t zcl[174]; + + + for(Int_t j=0; jGetCheckedTrack(j); + if(!gtrack) continue; + Int_t nHits = gtrack->GetNHits(); + UInt_t *hitnum = gtrack->GetHitNumbers(); + if(nHits < min_hits) continue; + TPolyMarker3D *pm = new TPolyMarker3D(nHits); + for(Int_t h=0; h>25) & 0x7f; + Int_t patch = (id>>22) & 0x7; + UInt_t pos = id&0x3fffff; + + AliL3SpacePointData *points = fClusters[slice][patch]; + + if(!points) { + LOG(AliL3Log::kError,"AliL3Display::DisplayTracks","Clusterarray") + <<"No points at slice "<=fNcl[slice][patch]) {printf("Error \n"); continue;} + xcl[h] = points[pos].fX; + ycl[h] = points[pos].fY; + zcl[h] = points[pos].fZ; + pm->SetPoint(h,xcl[h],ycl[h],zcl[h]); + } + pm->SetMarkerColor(3); + pm->Draw(); + TPolyLine3D *current_line = &(line[j]); + current_line = new TPolyLine3D(nHits,xcl,ycl,zcl,""); + + current_line->SetLineColor(4); + current_line->Draw("same"); + } + + fGeom->Draw("same"); + + c1->x3d(); + +} + +void AliL3Display::DisplayClusterRow(Int_t slice,Int_t padrow,Char_t *digitsFile) +{ + //Display the found clusters on this row together with the raw data. + + + TFile *file = new TFile(digitsFile); + AliTPCParam *param = (AliTPCParam*)file->Get("75x40_100x60"); + TTree *TD=(TTree*)file->Get("TreeD_75x40_100x60"); + AliSimDigits da, *digits=&da; + TD->GetBranch("Segment")->SetAddress(&digits); //Return pointer to branch segment. + AliL3Transform *transform = new AliL3Transform(); + + Int_t sector,row; + transform->Slice2Sector(slice,padrow,sector,row); + Int_t npads = param->GetNPads(sector,row); + Int_t ntimes = param->GetMaxTBin(); + TH2F *histdig = new TH2F("histdig","",npads,0,npads-1,ntimes,0,ntimes-1); + TH2F *histfast = new TH2F("histfast","",npads,0,npads-1,ntimes,0,ntimes-1); + + Int_t sectors_by_rows=(Int_t)TD->GetEntries(); + Int_t i; + for (i=0; iGetEvent(i)) continue; + Int_t sec,ro; + param->AdjustSectorRow(digits->GetID(),sec,ro); + + if(sec != sector) continue; + if(ro < row) continue; + if(ro != row) break; + printf("sector %d row %d\n",sec,ro); + digits->First(); + while (digits->Next()) { + Int_t it=digits->CurrentRow(), ip=digits->CurrentColumn(); + Short_t dig = digits->GetDigit(it,ip); + if(dig<=param->GetZeroSup()) continue; + if(it < param->GetMaxTBin()-1 && it > 0) + if(digits->GetDigit(it+1,ip) <= param->GetZeroSup() + && digits->GetDigit(it-1,ip) <= param->GetZeroSup()) + continue; + + histdig->Fill(ip,it,dig); + } + } + + + for(Int_t p=0;p<1;p++) + { + AliL3SpacePointData *points = fClusters[slice][p]; + if(!points) continue; + + Int_t npoints = fNcl[slice][p]; + Float_t xyz[3]; + for(Int_t i=0; iGlobal2Raw(xyz,sector,row); + histfast->Fill((Int_t)xyz[1],(Int_t)xyz[2],1); + + } + + } + + TCanvas *c1 = new TCanvas("c1","",2); + c1->cd(); + histdig->Draw(); + + histfast->SetMarkerColor(2); + histfast->SetMarkerStyle(4); + + histdig->GetXaxis()->SetTitle("Pad"); + histdig->GetYaxis()->SetTitle("Time"); + histdig->Draw("hist"); + histfast->Draw("psame"); + +} diff --git a/HLT/src/AliL3Display.h b/HLT/src/AliL3Display.h new file mode 100644 index 00000000000..9942daf6ded --- /dev/null +++ b/HLT/src/AliL3Display.h @@ -0,0 +1,35 @@ +#ifndef ALIL3_Display +#define ALIL3_Display + +#include +#include + +class AliL3SpacePointData; +class AliL3TrackArray; + +class AliL3Display : public TObject { + + private: + TGeometry *fGeom; + AliL3SpacePointData *fClusters[36][5]; //! + AliL3TrackArray *fTracks; //! + UInt_t fNcl[36][5]; + + Int_t fMinSlice; + Int_t fMaxSlice; + + public: + AliL3Display(); + AliL3Display(Int_t *slice); + virtual ~AliL3Display(); + + void Setup(Char_t *trackfile); + void DisplayTracks(Int_t min_hits=10); + void DisplayAll(Int_t min_hits=10); + void DisplayClusters(); + void DisplayClusterRow(Int_t slice,Int_t padrow,Char_t *digitsFile); + + ClassDef(AliL3Display,1) +}; + +#endif diff --git a/HLT/src/AliL3Evaluate.cxx b/HLT/src/AliL3Evaluate.cxx new file mode 100644 index 00000000000..356be2973a3 --- /dev/null +++ b/HLT/src/AliL3Evaluate.cxx @@ -0,0 +1,760 @@ +//Author: Anders Strand Vestbo +//Last Modified: 5.01.2001 + +#include +#include +#include +#include +#include +#include + +#include "AliRun.h" +#include "AliSimDigits.h" +#include "AliTPC.h" +#include "AliTPCClustersArray.h" +#include "AliTPCClustersRow.h" +#include "AliTPCcluster.h" +#include "AliTPCParam.h" + +#include "AliL3Transform.h" +#include "AliL3SpacePointData.h" +#include "AliL3Track.h" +#include "AliL3FileHandler.h" +#include "AliL3TrackArray.h" +#include "AliL3Evaluate.h" +#include "AliL3Logging.h" + +//AliL3Evaluate +//Class for tracking evaluation. + +ClassImp(AliL3Evaluate) + +AliL3Evaluate::AliL3Evaluate() +{ + fMCFile = NULL; + fTracks = NULL; + fMCclusterfile = NULL; +} + +AliL3Evaluate::AliL3Evaluate(Char_t *mcfile,Int_t *slice) +{ + //Normal constructor. Input are the rootfile containing the + //original MC information of the simulated event. + + fMCFile = new TFile(mcfile,"READ"); + if(!fMCFile->IsOpen()) + { + LOG(AliL3Log::kError,"AliL3Evaluation::AliL3Evaluation","File Open") + <<"Inputfile "<Get("75x40_100x60"); + fTransform = new AliL3Transform(); + + fMinSlice = slice[0]; + fMaxSlice = slice[1]; + +} + +AliL3Evaluate::~AliL3Evaluate() +{ + if(fDigitsTree) + fDigitsTree->Delete(); + + + /*if(fMCFile) + { + fMCFile->Close(); + delete fMCFile; + } + */ + if(fTransform) + delete fTransform; + if(fTracks) + delete fTracks; + if(fPtRes) + delete fPtRes; + if(fNGoodTracksPt) + delete fNGoodTracksPt; + if(fNFoundTracksPt) + delete fNFoundTracksPt; + if(fNFakeTracksPt) + delete fNFakeTracksPt; + if(fTrackEffPt) + delete fTrackEffPt; + if(fFakeTrackEffPt) + delete fFakeTrackEffPt; + if(fNGoodTracksEta) + delete fNGoodTracksEta; + if(fNFoundTracksEta) + delete fNFoundTracksEta; + if(fNFakeTracksEta) + delete fNFakeTracksEta; + if(fTrackEffEta) + delete fTrackEffEta; + if(fFakeTrackEffEta) + delete fFakeTrackEffEta; +} + +void AliL3Evaluate::Setup(Char_t *trackfile,Char_t *clustfile) +{ + //Setup for using the slow simulator. + //Read in the hit and track information from produced files. + + fIsSlow = true; + + Char_t fname[256]; + AliL3FileHandler *clusterfile[36][5]; + for(Int_t s=fMinSlice; s<=fMaxSlice; s++) + { + for(Int_t p=0; p<5; p++) + { + clusterfile[s][p] = new AliL3FileHandler(); + sprintf(fname,"points_%d_%d.raw",s,p); + if(!clusterfile[s][p]->SetBinaryInput(fname)) + { + LOG(AliL3Log::kError,"AliL3Evaluation::Setup","File Open") + <<"Inputfile "<Allocate(); + clusterfile[s][p]->Binary2Memory(fNcl[s][p],fClusters[s][p]); + clusterfile[s][p]->CloseBinaryInput(); + } + } + + + AliL3FileHandler *tfile = new AliL3FileHandler(); + if(!tfile->SetBinaryInput(trackfile)) + { + LOG(AliL3Log::kError,"AliL3Evaluation::Setup","File Open") + <<"Inputfile "<Binary2TrackArray(fTracks); + tfile->CloseBinaryInput(); + delete tfile; + + if(!SetDigitsTree()) + LOG(AliL3Log::kError,"AliL3Evaluation::Setup","Digits Tree") + <<"Error setting up digits tree"<IsOpen()) + LOG(AliL3Log::kError,"AliL3Evaluation::SetupFast","File Open") + <<"Inputfile "<SetBinaryInput(fname)) + { + LOG(AliL3Log::kError,"AliL3Evaluation::Setup","File Open") + <<"Inputfile "<Allocate(); + clusterfile[s][p]->Binary2Memory(fNcl[s][p],fClusters[s][p]); + clusterfile[s][p]->CloseBinaryInput(); + } + } + + + AliL3FileHandler *tfile = new AliL3FileHandler(); + if(!tfile->SetBinaryInput(trackfile)) + { + LOG(AliL3Log::kError,"AliL3Evaluation::Setup","File Open") + <<"Inputfile "<Binary2TrackArray(fTracks); + tfile->CloseBinaryInput(); + delete tfile; + + if(!SetMCParticleArray()) + LOG(AliL3Log::kError,"AliL3Evaluation::SetupFast","Particle array") + <<"Error setting up particle array"<cd(); + fDigitsTree = (TTree*)fMCFile->Get("TreeD_75x40_100x60"); + if(!fDigitsTree) return false; + fDigitsTree->GetBranch("Segment")->SetAddress(&fDigits); + for(Int_t i=0; iGetEntries(); i++) + { + if(!fDigitsTree->GetEvent(i)) continue; + Int_t se,ro,slice,slicerow; + fParam->AdjustSectorRow(fDigits->GetID(),se,ro); + fTransform->Sector2Slice(slice,slicerow,se,ro); + fRowid[slice][slicerow] = i; + } + + return true; +} + +Bool_t AliL3Evaluate::SetMCParticleArray() +{ + fMCFile->cd(); + AliRun *gAlice = (AliRun*)fMCFile->Get("gAlice"); + if (!gAlice) + { + LOG(AliL3Log::kError,"AliL3Evaluate::SetParticleArray","gAlice") + <<"AliRun object non existing on file"<GetEvent(0); + fParticles=gAlice->Particles(); + return true; +} + + +TObjArray *AliL3Evaluate::DefineGoodTracks(Int_t slice,Int_t *padrow,Int_t good_number,Int_t *particle_id) +{ + //Loop over MC particles, and mark the good ones + //(which the tracker should find...) + + Int_t np=fParticles->GetEntriesFast(); + AliTPC *TPC = (AliTPC*)gAlice->GetDetector("TPC"); + TPC->SetParam(fParam); + Int_t ver = TPC->IsVersion(); + LOG(AliL3Log::kInformational,"AliL3Evaluate::DefineGoodTracks","TPC version") + <<"TPC version "<GetParam()->GetNRowUp(); + //Int_t nrows=TPC->GetParam()->GetNRowLow()+nrow_up; + Int_t zero=TPC->GetParam()->GetZeroSup(); + + //Int_t number_of_rows = padrow[1] - padrow[0] + 1; + + Int_t *good = new Int_t[np]; + for(Int_t ii=0; iicd(); + AliTPCClustersArray carray; + carray.Setup(fParam); + carray.SetClusterType("AliTPCcluster"); + Bool_t clusterok = carray.ConnectTree("Segment Tree"); + if(!clusterok) + LOG(AliL3Log::kError,"AliL3Evaluate::DefineGoodTracks","Cluster Array") + <<"Error loading clusters from rootfile"<AdjustSectorRow(s->GetID(),sec,row); + fTransform->Sector2Slice(sl,lr,sec,row); + + if(sl != slice) {carray.ClearRow(sec,row); continue;} + if(lr != i) {carray.ClearRow(sec,row); continue;} + AliTPCClustersRow *cRow = carray.GetRow(sec,row); + for(Int_t j=0; jGetArray()->GetEntriesFast(); j++) + { + AliTPCcluster *cluster=(AliTPCcluster*)(*cRow)[j]; + Int_t lab=cluster->GetLabel(0); + if(lab<0) continue; + lab=TMath::Abs(lab); + good[lab]++; + } + if(carray.GetRow(sec,row)) + carray.ClearRow(sec,row); + } + } + else if(ver==2) + { + if(!fIsSlow) + LOG(AliL3Log::kError,"AliL3Evaluate::DefineGoodTracks","TPC version") + <<"TPC version "<GetEvent(index)) continue; + Int_t sec,row; + fParam->AdjustSectorRow(fDigits->GetID(),sec,row); + fDigits->First(); + while (fDigits->Next()) { + Int_t it=fDigits->CurrentRow(), ip=fDigits->CurrentColumn(); + Short_t dig = fDigits->GetDigit(it,ip); + Int_t idx0=fDigits->GetTrackID(it,ip,0); + Int_t idx1=fDigits->GetTrackID(it,ip,1); + Int_t idx2=fDigits->GetTrackID(it,ip,2); + if (idx0>=0 && dig>=zero) count[idx0]+=1; + if (idx1>=0 && dig>=zero) count[idx1]+=1; + if (idx2>=0 && dig>=zero) count[idx2]+=1; + } + for (Int_t j=0; j1) {//at least two digits at this padrow + good[j]++; + } + count[j]=0; + } + } + delete[] count; + } + else + { + LOG(AliL3Log::kError,"AliL3Evaluation::FillEffHistos","TPC version") + <<"No valid TPC version found"<GetEntriesFast(); i++) + { + TParticle *p = (TParticle*)fParticles->UncheckedAt(i); + if(p->GetFirstMother()>0) continue; //secondary particle + if(good[i] < good_number) {continue;} + + Double_t ptg=p->Pt(),pxg=p->Px(),pyg=p->Py(),pzg=p->Pz(); + Double_t phi_part = TMath::ATan2(pyg,pxg); + if (phi_part < 0) phi_part += 2*TMath::Pi(); + + + if(phi_part < phi_min*torad || phi_part > phi_max*torad) {continue;} + if(ptg<0.100) continue; + if(fabs(pzg/ptg)>0.999) {continue;} + Int_t entries = good_part->GetEntriesFast(); + good_part->AddLast(p); + particle_id[entries] = i; + } + delete [] good; + return good_part; +} + +void AliL3Evaluate::EvaluatePatch(Int_t slice,Int_t patch,Int_t min_points,Int_t good_number) +{ + //Make efficiency plots for tracking on patch level (before any merging). + + Int_t row[5][2] = {{ 0, 45},{46,77},{78,109},{110,141},{142,173}}; + Int_t *particle_id = new Int_t[fParticles->GetEntriesFast()]; + TObjArray *good_particles = DefineGoodTracks(slice,row[patch],good_number,particle_id); + SetMinPoints(min_points); + AssignIDs(); + FillEffHistos(good_particles,particle_id); + delete good_particles; + delete [] particle_id; +} + +void AliL3Evaluate::EvaluateSlice(Int_t slice,Int_t min_points,Int_t good_number) +{ + //Make efficiency plots for tracking on a slice (after merging). + //min_points = minimum points on track to be considered for evaluation + //good_number = minimum hits (padrows) produced by simulated track for consideration. + + Int_t row[174] = {0,173}; + Int_t *particle_id = new Int_t[fParticles->GetEntriesFast()]; + TObjArray *good_particles = DefineGoodTracks(slice,row,good_number,particle_id); + SetMinPoints(min_points); + AssignIDs(); + FillEffHistos(good_particles,particle_id); + delete good_particles; + delete [] particle_id; +} + +void AliL3Evaluate::EvaluateGlobal() +{ + //Make efficiency plots for tracking on several slices. + /* + Int_t row[174] = {0,173}; + TObjArray *good_particles = DefineGoodTracks(slice,row,good_number); + FillEffHistos(good_particles); + delete good_particles; + */ +} + +void AliL3Evaluate::FillEffHistos(TObjArray *good_particles,Int_t *particle_id) +{ + //Fill the efficiency histograms. + + + CreateHistos(); + + for(Int_t i=0; iGetEntriesFast(); i++) + { + TParticle *p = (TParticle*)good_particles->UncheckedAt(i); + Double_t ptg=p->Pt(),pzg=p->Pz(); + Float_t dipangle=TMath::ATan2(pzg,ptg)*180./TMath::Pi(); + fNGoodTracksPt->Fill(ptg); + fNGoodTracksEta->Fill(dipangle); + Int_t found = 0; + for(Int_t k=0; kGetNTracks(); k++) + { + AliL3Track *track = fTracks->GetCheckedTrack(k); + if(!track) continue; + Int_t nHits = track->GetNumberOfPoints(); + if(nHits < fMinPointsOnTrack) break; + + Int_t tracklabel; + tracklabel = track->GetMCid(); + + if(TMath::Abs(tracklabel) != particle_id[i]) continue; + found=1; + if(tracklabel == particle_id[i]) {fNFoundTracksPt->Fill(ptg); fNFoundTracksEta->Fill(dipangle);} + else {fNFakeTracksPt->Fill(ptg); fNFakeTracksEta->Fill(dipangle);} + Float_t pt=track->GetPt(); + fPtRes->Fill((pt-ptg)/ptg*100.); + break; + + } + } + + + Stat_t ngood=fNGoodTracksPt->GetEntries(); + Stat_t nfound=fNFoundTracksPt->GetEntries(); + Stat_t nfake=fNFakeTracksPt->GetEntries(); + + LOG(AliL3Log::kInformational,"AliL3Evaluate::FillEffHistos","Efficiency") + <Sumw2(); fNGoodTracksPt->Sumw2(); + fTrackEffPt->Divide(fNFoundTracksPt,fNGoodTracksPt,1,1.,"b"); + fFakeTrackEffPt->Divide(fNFakeTracksPt,fNGoodTracksPt,1,1.,"b"); + fTrackEffPt->SetMaximum(1.4); + fTrackEffPt->SetXTitle("P_{T} [GeV]"); + fTrackEffPt->SetLineWidth(2); + fFakeTrackEffPt->SetFillStyle(3013); + fTrackEffPt->SetLineColor(4); + fFakeTrackEffPt->SetFillColor(2); + + fNFoundTracksEta->Sumw2(); fNGoodTracksEta->Sumw2(); + fTrackEffEta->Divide(fNFoundTracksEta,fNGoodTracksEta,1,1.,"b"); + fFakeTrackEffEta->Divide(fNFakeTracksEta,fNGoodTracksEta,1,1.,"b"); + fTrackEffEta->SetMaximum(1.4); + fTrackEffEta->SetXTitle("#lambda [degrees]"); + fTrackEffEta->SetLineWidth(2); + fFakeTrackEffEta->SetFillStyle(3013); + fTrackEffEta->SetLineColor(4); + fFakeTrackEffEta->SetFillColor(2); + +} + +void AliL3Evaluate::AssignIDs() +{ + //Assign MC id to the tracks. + + UInt_t *index=0,tmp_ind=0; + Int_t *pID=0,npoints=0; + + if(!fIsSlow) + { + pID = GetFastIDs(tmp_ind,npoints); + index = (UInt_t*)tmp_ind; + } + + fTracks->QSort(); + LOG(AliL3Log::kDebug,"AliL3Evaluate::AssignIDs","Track Loop") + <<"Assigning MC id to the found tracks...."<GetNTracks(); i++) + { + AliL3Track *track = (AliL3Track*)fTracks->GetCheckedTrack(i); + if(!track) + { + LOG(AliL3Log::kWarning,"AliL3Evaluate::AssignIDs","Track Loop") + <GetNumberOfPoints() < fMinPointsOnTrack) break; + Int_t tID; + if(!fIsSlow) + tID = GetMCTrackLabel(track,index,pID,npoints); + else + tID = GetMCTrackLabel(track); + track->SetMCid(tID); + printf("track %i id %d\n",i,tID); + } + + if(!fIsSlow) + { + delete [] pID; + delete [] index; + } + +} + + +struct S {Int_t lab; Int_t max;}; +Int_t AliL3Evaluate::GetMCTrackLabel(AliL3Track *track,UInt_t *index,Int_t *pID,Int_t npoints) +{ + //Returns the MCtrackID of the belonging clusters. + //If MCLabel < 0, means that track is fake. + //Fake track means that more than 10 percent of clusters are assigned incorrectly. + + Int_t num_of_clusters = track->GetNumberOfPoints(); + S *s=new S[num_of_clusters]; + Int_t i; + for (i=0; iGetHitNumbers(); + UInt_t id; + + Int_t **trackID; + + if(fIsSlow) + trackID = GetClusterIDs(track); + else + trackID = GetClusterIDs(track,index,pID,npoints); + + + Int_t lab=123456789; + for (i=0; i>25) & 0x7f; + Int_t patch = (id>>22) & 0x7; + UInt_t pos = id&0x3fffff; + + AliL3SpacePointData *points = fClusters[slice][patch]; + + if(!points) + continue; + + if(pos>=fNcl[slice][patch]) + { + LOG(AliL3Log::kError,"AliL3Evaluate::GetMCTrackLabel","Clusterarray") + <max) {max=s[i].max; lab=s[i].lab;} + + delete[] s; + + for (i=0; i>25) & 0x7f; + Int_t patch = (id>>22) & 0x7; + UInt_t pos = id&0x3fffff; + + AliL3SpacePointData *points = fClusters[slice][patch]; + + if(!points) + continue; + + if(pos>=fNcl[slice][patch]) + { + LOG(AliL3Log::kError,"AliL3Evaluate::GetMCTrackLabel","Clusterarray") + < 0.10) + { + return -lab; + } + + delete [] trackID; + return lab; +} + + +Int_t **AliL3Evaluate::GetClusterIDs(AliL3Track *track,UInt_t *index,Int_t *pID,Int_t npoints) +{ + //Return the MC information of all clusters belonging to track. + + Int_t num_of_clusters = track->GetNumberOfPoints(); + Int_t **trackID = new Int_t*[num_of_clusters]; + + UInt_t *hitnum = track->GetHitNumbers(); + UInt_t id; + + + Float_t xyz[3]; + Int_t sector,padrow; + for(Int_t i=0; i>25) & 0x7f; + Int_t patch = (id>>22) & 0x7; + UInt_t pos = id&0x3fffff; + + AliL3SpacePointData *points = fClusters[slice][patch]; + + if(!points) + { + LOG(AliL3Log::kError,"AliL3Evaluate::GetClusterIDs","Clusterarray") + <<"No points at slice "<=fNcl[slice][patch]) + { + LOG(AliL3Log::kError,"AliL3Evaluate::GetClusterIDs","Clusterarray") + <Slice2Sector(slice,padrow,se,ro); + fTransform->Global2Raw(xyz,se,ro); + + if(fIsSlow) + { + Int_t p = fRowid[slice][padrow]; + + if(!fDigitsTree->GetEvent(p)) + LOG(AliL3Log::kError,"AliL3Evaluate::GetClusterIDs","Digits Tree") + <<"Error reading digits tree"<GetTrackID((Int_t)xyz[2],(Int_t)xyz[1],0); + trackID[i][1] = fDigits->GetTrackID((Int_t)xyz[2],(Int_t)xyz[1],1); + trackID[i][2] = fDigits->GetTrackID((Int_t)xyz[2],(Int_t)xyz[1],2); + } + else + { + Int_t tmp_pid=0; + for(Int_t ii=0; iiIsOpen()) + { + LOG(AliL3Log::kError,"AliL3Evaluate::Write2File","File Open") + <<"Problems opening rootfile"<cd(); + fPtRes->Write(); + fNGoodTracksPt->Write(); + fNFoundTracksPt->Write(); + fNFakeTracksPt->Write(); + fTrackEffPt->Write(); + fFakeTrackEffPt->Write(); + fNGoodTracksEta->Write(); + fNFoundTracksEta->Write(); + fNFakeTracksEta->Write(); + fTrackEffEta->Write(); + fFakeTrackEffEta->Write(); + + of->Close(); + delete of; + +} + diff --git a/HLT/src/AliL3Evaluate.h b/HLT/src/AliL3Evaluate.h new file mode 100644 index 00000000000..24d53b75194 --- /dev/null +++ b/HLT/src/AliL3Evaluate.h @@ -0,0 +1,89 @@ +#ifndef ALIL3_Evaluate +#define ALIL3_Evaluate + +#include +#include +#include +#include "AliSimDigits.h" + +class AliL3Track; +class TClonesArray; +class TFile; +class AliL3TrackArray; +class AliL3SpacePointData; +class TH1F; +class AliL3Transform; +class AliTPCParam; +class TTree; +class AliSimDigits; +class TObjArray; + +class AliL3Evaluate : public TObject { + + private: + + TFile *fMCFile; + TFile *fMCclusterfile; //If you run the fast simulator. + TClonesArray *fParticles; + AliL3TrackArray *fTracks; //! + AliTPCParam *fParam; + AliL3SpacePointData *fClusters[36][5]; //! + AliL3Transform *fTransform; //! + AliSimDigits *fDigits; + TTree *fDigitsTree; + Int_t fMinSlice; + Int_t fMaxSlice; + UInt_t fNcl[36][5]; + Int_t fRowid[36][174]; + Int_t fMinPointsOnTrack; //Minimum points on track to be considered. + Bool_t fIsSlow; + Int_t fNFastPoints; + UInt_t fMcIndex; + Int_t fMcId; + + //Histograms + TH1F *fPtRes; + TH1F *fNGoodTracksPt; + TH1F *fNFoundTracksPt; + TH1F *fNFakeTracksPt; + TH1F *fTrackEffPt; + TH1F *fFakeTrackEffPt; + TH1F *fNGoodTracksEta; + TH1F *fNFoundTracksEta; + TH1F *fNFakeTracksEta; + TH1F *fTrackEffEta; + TH1F *fFakeTrackEffEta; + + void FillEffHistos(TObjArray *good_particles,Int_t *particle_id); + void AssignIDs(); + Bool_t SetDigitsTree(); + Bool_t SetMCParticleArray(); + TObjArray *DefineGoodTracks(Int_t slice,Int_t *padrow,Int_t good_number,Int_t *particle_id); + Int_t GetMCTrackLabel(AliL3Track *track,UInt_t *index=0,Int_t *pID=0,Int_t npoints=0); + Int_t **GetClusterIDs(AliL3Track *track,UInt_t *index=0,Int_t *pID=0,Int_t npoints=0); + Int_t *GetFastIDs(UInt_t &tmp_ind,Int_t &npoints); + + public: + AliL3Evaluate(); + AliL3Evaluate(Char_t *mcfile,Int_t *slice); + + virtual ~AliL3Evaluate(); + + void Setup(Char_t *trackfile,Char_t *clustfile); + void SetupFast(Char_t *trackfile,Char_t *clustfile,Char_t *mcClusterfile); + void CreateHistos(Int_t nbin=20,Int_t xlow=0,Int_t xup=4); + void EvaluatePatch(Int_t slice,Int_t patch,Int_t min_points,Int_t good_number); + void EvaluateSlice(Int_t slice,Int_t min_points,Int_t good_number); + void EvaluateGlobal(); + void Write2File(Char_t *outputfile); + + TH1F *GetTrackEffPt() {return fTrackEffPt;} + TH1F *GetTrackEffEta() {return fTrackEffEta;} + TH1F *GetPtRes() {return fPtRes;} + + void SetMinPoints(Int_t f) {fMinPointsOnTrack = f;} + + ClassDef(AliL3Evaluate,1) +}; + +#endif diff --git a/HLT/src/AliL3FileHandler.cxx b/HLT/src/AliL3FileHandler.cxx new file mode 100644 index 00000000000..d1e7b1af8cf --- /dev/null +++ b/HLT/src/AliL3FileHandler.cxx @@ -0,0 +1,379 @@ + +//Author: Uli Frankenfeld +//Last Modified: 17.12.2000 + +#include +#include +#include +#include +#include + +#include "AliL3Transform.h" +#include "AliL3Logging.h" +#include "AliL3MemHandler.h" +#include "AliL3FileHandler.h" + +#include "AliTPCClustersArray.h" +#include "AliTPCcluster.h" +#include "AliTPCClustersRow.h" +#include "AliTPCParam.h" +#include "AliSimDigits.h" + +#include "AliL3DigitData.h" +#include "AliL3TrackSegmentData.h" +#include "AliL3SpacePointData.h" +#include "AliL3TrackArray.h" +//_____________________________________________________________ +// +// The L3 Binary File handler +// + +ClassImp(AliL3FileHandler) + +AliL3FileHandler::AliL3FileHandler(){ + //Default constructor + fInAli = 0; + fParam = 0; + fTransformer = 0; + fMC =0; +} + + +AliL3FileHandler::~AliL3FileHandler(){ + //Destructor + if(fTransformer) delete fTransformer; + if(fMC) CloseMCOutput(); +} + +Bool_t AliL3FileHandler::SetMCOutput(char *name){ + fMC = fopen(name,"w"); + if(!fMC){ + LOG(AliL3Log::kWarning,"AliL3FileHandler::SetMCOutput","File Open") + <<"Pointer to File = 0x0 "<IsOpen()){ + LOG(AliL3Log::kError,"AliL3FileHandler::SetAliInput","File Open") + <<"Ali File "<GetName()<<" does not exist"<Get("75x40_100x60"); + if(!fParam){ + LOG(AliL3Log::kError,"AliL3FileHandler::SetAliInput","File Open") + <<"No AliTPCParam 75x40_100x60 in File "<GetName()<IsOpen()) fInAli->Close(); + delete fInAli; + fInAli = 0; +} + +Bool_t AliL3FileHandler::IsDigit(){ + if(!fInAli){ + LOG(AliL3Log::kWarning,"AliL3FileHandler::IsDigit","File") + <<"Pointer to TFile = 0x0 "<Get("TreeD_75x40_100x60"); + if(t){ + LOG(AliL3Log::kInformational,"AliL3FileHandler::IsDigit","File Type") + <<"Found Digit Tree -> Use Fast Cluster Finder"< Use Cluster Tree"<IsOpen()){ + LOG(AliL3Log::kWarning,"AliL3FileHandler::AliDigits2Memory","File") + <<"No Input avalible: TFile not opend"<cd(); + TTree *t=(TTree*)fInAli->Get("TreeD_75x40_100x60"); + if(!t){ + LOG(AliL3Log::kWarning,"AliL3FileHandler::AliDigits2Binary","AliRoot") + <<"No Digit Tree inside!"<GetBranch("Segment")->SetAddress(&dummy); + UShort_t dig; + Int_t time,pad,sector,row; + Int_t nrows=0; + Int_t ndigitcount=0; + Int_t entries = (Int_t)t->GetEntries(); + Int_t ndigits[entries]; + Int_t lslice,lrow; + for(Int_t n=0; nGetEntries(); n++) + { + t->GetEvent(n); + fParam->AdjustSectorRow(digarr.GetID(),sector,row); + fTransformer->Sector2Slice(lslice,lrow,sector,row); + if(fSlice != lslice || lrowfRowMax) continue; +// if(fSlice != lslice) continue; + + Float_t xyz[3]; + ndigits[lrow] = 0; + digarr.First(); + do { + time=digarr.CurrentRow(); + pad=digarr.CurrentColumn(); + dig = digarr.GetDigit(time,pad); + if(dig<=fParam->GetZeroSup()) continue; + if(time < fParam->GetMaxTBin()-1 && time > 0) + if(digarr.GetDigit(time+1,pad) <= fParam->GetZeroSup() + && digarr.GetDigit(time-1,pad) <= fParam->GetZeroSup()) + continue; + + fTransformer->Raw2Local(xyz,sector,row,pad,time); + if(fParam->GetPadRowRadii(sector,row)<230./250.*fabs(xyz[2])) + continue; + + ndigits[lrow]++; //for this row only + ndigitcount++; //total number of digits to be published + + } while (digarr.Next()); + + nrows++; + } + Int_t size = sizeof(AliL3DigitData)*ndigitcount + + nrows*sizeof(AliL3DigitRowData); + + LOG(AliL3Log::kDebug,"AliL3FileHandler::AliDigits2Memory","Digits") + <GetEntries(); n++) + { + t->GetEvent(n); + + Float_t xyz[3]; + fParam->AdjustSectorRow(digarr.GetID(),sector,row); + fTransformer->Sector2Slice(lslice,lrow,sector,row); +// if(fSlice != lslice) continue; + if(fSlice != lslice || lrowfRowMax) continue; + tempPt->fRow = lrow; + tempPt->fNDigit = ndigits[lrow]; + + Int_t localcount=0; + digarr.First(); + do { + dig=digarr.CurrentDigit(); + if (dig<=fParam->GetZeroSup()) continue; + time=digarr.CurrentRow(); + pad=digarr.CurrentColumn(); + if(time < fParam->GetMaxTBin()-1 && time > 0) + if(digarr.GetDigit(time-1,pad) <= fParam->GetZeroSup() && + digarr.GetDigit(time+1,pad) <= fParam->GetZeroSup()) continue; + + //Exclude data outside cone: + fTransformer->Raw2Local(xyz,sector,row,pad,time); + if(fParam->GetPadRowRadii(sector,row)<230./250.*fabs(xyz[2])) + continue; + + if(localcount >= ndigits[lrow]) + LOG(AliL3Log::kFatal,"AliL3FileHandler::AliDigits2Binary","Memory") + <fDigitData[localcount].fCharge=dig; + tempPt->fDigitData[localcount].fPad=pad; + tempPt->fDigitData[localcount].fTime=time; + localcount++; + } while (digarr.Next()); + + Byte_t *tmp = (Byte_t*)tempPt; + Int_t size = sizeof(AliL3DigitRowData) + + ndigits[lrow]*sizeof(AliL3DigitData); + tmp += size; + tempPt = (AliL3DigitRowData*)tmp; + } + savedir->cd(); + return data; +} + +///////////////////////////////////////// Point IO +Bool_t AliL3FileHandler::AliPoints2Binary(){ + Bool_t out = kTRUE; + UInt_t npoint; + AliL3SpacePointData *data = AliPoints2Memory(npoint); + out = Memory2Binary(npoint,data); + Free(); + return out; +} + +AliL3SpacePointData * AliL3FileHandler::AliPoints2Memory(UInt_t & npoint){ + AliL3SpacePointData *data = 0; + npoint=0; + if(!fInAli){ + LOG(AliL3Log::kWarning,"AliL3FileHandler::AliPoints2Memory","File") + <<"No Input avalible: no object TFile"<IsOpen()){ + LOG(AliL3Log::kWarning,"AliL3FileHandler::AliPoints2Memory","File") + <<"No Input avalible: TFile not opend"<cd(); + + AliTPCClustersArray carray; + carray.Setup(fParam); + carray.SetClusterType("AliTPCcluster"); + Bool_t clusterok = carray.ConnectTree("Segment Tree"); + if(!clusterok) return 0; + + AliTPCClustersRow ** clusterrow = + new AliTPCClustersRow*[ (int)carray.GetTree()->GetEntries()]; + Int_t *rows = new int[ (int)carray.GetTree()->GetEntries()]; + Int_t *sects = new int[ (int)carray.GetTree()->GetEntries()]; + Int_t sum=0; + + Int_t lslice,lrow; + for(Int_t i=0; iGetEntries(); i++){ + AliSegmentID *s = carray.LoadEntry(i); + Int_t sector,row; + fParam->AdjustSectorRow(s->GetID(),sector,row); + rows[i] = row; + sects[i] = sector; + clusterrow[i] = 0; + fTransformer->Sector2Slice(lslice,lrow,sector,row); + if(fSlice != lslice || lrowfRowMax) continue; + clusterrow[i] = carray.GetRow(sector,row); + if(clusterrow[i]) + sum+=clusterrow[i]->GetArray()->GetEntriesFast(); + } + UInt_t size = sum*sizeof(AliL3SpacePointData); + + LOG(AliL3Log::kDebug,"AliL3FileHandler::AliPoints2Memory","File") + <GetEntries(); i++){ + if(!clusterrow[i]) continue; + Int_t row = rows[i]; + Int_t sector = sects[i]; + fTransformer->Sector2Slice(lslice,lrow,sector,row); + Int_t entries_in_row = clusterrow[i]->GetArray()->GetEntriesFast(); + for(Int_t j = 0;jGetZ(); + data[n].fY = c->GetY(); + data[n].fX = fParam->GetPadRowRadii(sector,row); + data[n].fID = n+((fSlice&0x7f)<<25)+((fPatch&0x7)<<22);//uli + data[n].fPadRow = lrow; + data[n].fXYErr = c->GetSigmaY2(); + data[n].fZErr = c->GetSigmaZ2(); + if(fMC) fprintf(fMC,"%d %d\n",data[n].fID,c->GetLabel(0)); + n++; + } + } + for(Int_t i=0;iGetEntries();i++){ + Int_t row = rows[i]; + Int_t sector = sects[i]; + if(carray.GetRow(sector,row)) + carray.ClearRow(sector,row); + } + + delete [] clusterrow; + delete [] rows; + delete [] sects; + savedir->cd(); + + return data; +} + diff --git a/HLT/src/AliL3FileHandler.h b/HLT/src/AliL3FileHandler.h new file mode 100644 index 00000000000..6038b2f2959 --- /dev/null +++ b/HLT/src/AliL3FileHandler.h @@ -0,0 +1,54 @@ +#ifndef ALIL3FILEHANDLER_H +#define ALIL3FILEHANDLER_H + +#include "AliTPCParam.h" +#include "AliL3MemHandler.h" +#include +#include +#include +class AliL3SpacePointData; +class AliL3DigitRowData; +class AliL3TrackSegmentData; +class AliL3TrackArray; + +class AliL3FileHandler:public AliL3MemHandler{ + private: + TFile *fInAli; + AliTPCParam *fParam; + AliL3Transform *fTransformer;//! + Bool_t SetAliInput(); + + FILE *fMC;//! + + public: + AliL3FileHandler(); + virtual ~AliL3FileHandler(); +// void Init(Int_t s,Int_t p,Int_t* row){fSlice=s;fPatch=p;fRowMin=row[0];fRowMax=row[1];} + + Int_t GetRowMin(){return fRowMin;} + Int_t GetRowMax(){return fRowMax;} + Int_t GetSlice(){return fSlice;} + Int_t GetPatch(){return fPatch;} + + Bool_t SetAliInput(char *name); + Bool_t SetAliInput(TFile *file); + void CloseAliInput(); + Bool_t IsDigit(); + + Bool_t SetMCOutput(char *name); + Bool_t SetMCOutput(FILE *file); + void CloseMCOutput(); + + //Digit IO + Bool_t AliDigits2Binary(); + AliL3DigitRowData *AliDigits2Memory(UInt_t & nrow); //Allocates Memory + Bool_t AliDigits2CompBinary(); + + //Point IO + Bool_t AliPoints2Binary(); + AliL3SpacePointData *AliPoints2Memory(UInt_t & npoint);//Allocates Memory + + ClassDef(AliL3FileHandler,1) // Level3 +}; + +#endif diff --git a/HLT/src/AliL3GlobalMerger.cxx b/HLT/src/AliL3GlobalMerger.cxx new file mode 100644 index 00000000000..f6e4f70856d --- /dev/null +++ b/HLT/src/AliL3GlobalMerger.cxx @@ -0,0 +1,184 @@ + +//Author: Uli Frankenfeld +//Last Modified: 06.12.2000 + +#include +#include +#include "AliL3Logging.h" +#include "AliL3GlobalMerger.h" +#include "AliL3Track.h" +#include "AliL3Transform.h" +#include "AliL3TrackArray.h" +//_____________________________________________________________ +// +// The L3 Slice merger +// + +ClassImp(AliL3GlobalMerger) + +AliL3GlobalMerger::AliL3GlobalMerger(){ + //Default constructor + Is2Global(kTRUE); + SetParameter(2,2,0.001,0.05,0.1); +} + + +AliL3GlobalMerger::AliL3GlobalMerger(Int_t first,Int_t last):AliL3Merger(last-first+1){ + //Constructor. + fNSlices = last-first+1; + fFirst = first; + fLast = last; + Is2Global(kTRUE); + SetParameter(2,2,0.001,0.1,0.4); +} + +AliL3GlobalMerger::~AliL3GlobalMerger(){ + //Destructor +} + +void AliL3GlobalMerger::InitSlice(Int_t slice){ + // + // Select Sector The following FillTracks call will + // fill this Sector + // + fSlice = slice; + fCurrentTracks = fSlice - fFirst; +} + +void AliL3GlobalMerger::SlowMerge(){ + void* ntuple=GetNtuple(); + AliL3Track *track[2]; + AliL3TrackArray *tout = GetOutTracks(); + if(fNSlices<2){ + LOG(AliL3Log::kWarning,"AliL3GlobalMerger::SlowMerge","Slice Number") + <<"Need more than one Slice!"< the border of the slices + fTransformer->Local2GlobalAngle(&angle,slice); + for(Int_t s0=0;s0GetNTracks();s0++){ + AliL3Track *track0=ttt0->GetTrack(s0); + track0->CalculateHelix(); + track0->CalculateEdgePoint(angle); + if(!track0->IsPoint()) ttt0->Remove(s0); + } +// ttt0->Compress(); + for(Int_t s1=0;s1GetNTracks();s1++){ + AliL3Track *track1=ttt1->GetTrack(s1); + track1->CalculateHelix(); + track1->CalculateEdgePoint(angle); + if(!track1->IsPoint()) ttt1->Remove(s1); + } +// ttt1->Compress(); + Bool_t merge = kTRUE; + while(merge){ + Int_t min0=-1,min1=-1; + Double_t min=10; + for(Int_t s0=0;s0GetNTracks();s0++){ + AliL3Track *track0=ttt0->GetCheckedTrack(s0); + if(!track0) continue; + if(!track0->CalculateEdgePoint(angle)) continue; + for(Int_t s1=0;s1GetNTracks();s1++){ + AliL3Track *track1=ttt1->GetCheckedTrack(s1); + if(!track1) continue; + if(!track1->CalculateEdgePoint(angle)) continue; + Double_t diff = TrackDiff(track0,track1); + if(diff>=0&&diff=0&&min1>=0){ + AliL3Track *track0=ttt0->GetTrack(min0); + AliL3Track *track1=ttt1->GetTrack(min1); + track[0] = track0; + track[1] = track1; + SortGlobalTracks(track,2); + MultiMerge(tout,track,2); + track0->CalculateEdgePoint(angle); + track1->CalculateEdgePoint(angle); + track0->CalculateReferencePoint(angle); + track1->CalculateReferencePoint(angle); + PrintDiff(track0,track1); + FillNtuple(ntuple,track0,track1); + ttt0->Remove(min0); + ttt1->Remove(min1); +// ttt0->Compress(); +// ttt1->Compress(); + } + else merge = kFALSE; + } + LOG(AliL3Log::kInformational,"AliL3GlobalMerger::SlowMerge","Result") + <GetNTracks()< the border of the slices + fTransformer->Local2GlobalAngle(&angle,slice); + if(i==0) + ttt0->QSort(); + ttt1->QSort(); + Bool_t *ismatched0 = new Bool_t[ttt0->GetNTracks()]; + Bool_t *ismatched1 = new Bool_t[ttt1->GetNTracks()]; + Int_t n0=0,n1=0; + for(Int_t s0=0;s0GetNTracks();s0++){ + ismatched0[s0]=kFALSE; + AliL3Track *track0=ttt0->GetCheckedTrack(s0); + if(!track0) continue; + track0->CalculateHelix(); + track0->CalculateEdgePoint(angle); + if(track0->IsPoint()) {n0++;track0->CalculateReferencePoint(angle);} + } + for(Int_t s1=0;s1GetNTracks();s1++){ + ismatched1[s1]=kFALSE; + AliL3Track *track1=ttt1->GetCheckedTrack(s1); + if(!track1) continue; + track1->CalculateHelix(); + track1->CalculateEdgePoint(angle); + if(track1->IsPoint()) {n1++;track1->CalculateReferencePoint(angle);} + } + for(Int_t s0=0;s0GetNTracks();s0++){ + AliL3Track *track0=ttt0->GetCheckedTrack(s0); + if(!track0) continue; + if(!track0->IsPoint()) continue; + for(Int_t s1=0;s1GetNTracks();s1++){ + if(ismatched1[s1]) continue; + AliL3Track *track1=ttt1->GetCheckedTrack(s1); + if(!track1) continue; + if(!track1->IsPoint()) continue; + if(IsRTrack(track0,track1)){ + track[0] = track0; + track[1] = track1; + SortGlobalTracks(track,2); + MultiMerge(tout,track,2); + ismatched0[s0]=kTRUE; + ismatched1[s1]=kTRUE; + ttt0->Remove(s0); + ttt1->Remove(s1); + } + } + } + LOG(AliL3Log::kInformational,"AliL3GlobalMerger::Merge","Result") + <GetNTracks()< + +#include "AliL3Transform.h" +#include "AliL3Defs.h" +#include "AliL3HoughTrack.h" + +ClassImp(AliL3HoughTrack) + + +AliL3HoughTrack::AliL3HoughTrack() +{ + //Constructor + + fWeight = 0; + fMinDist=0; + fTransform = new AliL3Transform(); + fDLine = 0; + fPsiLine = 0; + fIsHelix = true; +} + + +AliL3HoughTrack::~AliL3HoughTrack() +{ + //Destructor + if(fTransform) + delete fTransform; +} + +void AliL3HoughTrack::Set(AliL3Track *track) +{ + + AliL3HoughTrack *tpt = (AliL3HoughTrack*)track; + + fWeight = tpt->GetWeight(); + fDLine = tpt->GetDLine(); + fPsiLine = tpt->GetPsiLine(); + SetNHits(tpt->GetWeight()); + SetRowRange(tpt->GetFirstRow(),tpt->GetLastRow()); + fIsHelix = false; + + +} + +void AliL3HoughTrack::SetTrackParameters(Double_t kappa,Double_t phi,Int_t weight) +{ + + fWeight = weight; + fMinDist = 100000; + SetKappa(kappa); + SetPhi0(phi); + Double_t pt = fabs(BFACT*bField/kappa); + SetPt(pt); + Double_t radius = 1/fabs(kappa); + SetRadius(radius); + + //set nhits for sorting. + SetNHits(weight); + + SetCharge(copysign(1,kappa)); + Double_t charge = -1.*kappa; + Double_t trackPhi0 = GetPhi0() + charge*0.5*Pi/fabs(charge); + + //The first point on track is origo: + Double_t x0=0; + Double_t y0=0; + + Double_t xc = x0 - GetRadius() * cos(trackPhi0) ; + Double_t yc = y0 - GetRadius() * sin(trackPhi0) ; + SetCenterX(xc); + SetCenterY(yc); + fIsHelix = true; +} + +void AliL3HoughTrack::SetLineParameters(Double_t psi,Double_t D,Int_t weight,Int_t *rowrange,Int_t ref_row) +{ + //Initialize a track piece, not yet a track + //Used in case of straight line transformation + + //Transform line parameters to coordinate system of slice: + + D = D + fTransform->Row2X(ref_row)*cos(psi); + + fDLine = D; + fPsiLine = psi; + fWeight = weight; + SetNHits(weight); + SetRowRange(rowrange[0],rowrange[1]); + fIsHelix = false; + +} + +void AliL3HoughTrack::SetBestMCid(Int_t mcid,Double_t min_dist) +{ + + if(min_dist < fMinDist) + { + fMinDist = min_dist; + SetMCid(mcid); + } + +} + +void AliL3HoughTrack::GetLineCrossingPoint(Int_t padrow,Double_t *xy) +{ + + + if(fIsHelix) + { + printf("AliL3HoughTrack::GetLineCrossingPoint : Track is not a line\n"); + return; + } + + Double_t xhit = fTransform->Row2X(padrow); + Double_t a = -1/tan(fPsiLine); + Double_t b = fDLine/sin(fPsiLine); + + Double_t yhit = a*xhit + b; + xy[0] = xhit; + xy[1] = yhit; + +} + +Double_t AliL3HoughTrack::GetCrossingAngle(Int_t padrow) +{ + //Calculate the crossing angle between track and given padrow. + + if(!fIsHelix) + { + printf("AliL3HoughTrack::GetCrossingAngle : Track is not a helix\n"); + return 0; + } + + if(!IsLocal()) + { + printf("Track is not given in local coordinates\n"); + return 0; + } + + Float_t xyz[3]; + if(!GetCrossingPoint(padrow,xyz)) + printf("AliL3HoughTrack::GetCrossingPoint : Track does not cross line!!\n"); + + + //Convert center of curvature to local coordinates: + //Float_t xyz_coc[3] = {GetCenterX(),GetCenterY(),0}; + //fTransform->Global2Local(xyz_coc,slice); + + //Take the dot product of the tangent vector of the track, and + //vector perpendicular to the padrow. + + Double_t tangent[2]; + //tangent[1] = (xyz[0] - xyz_coc[0])/GetRadius(); + //tangent[0] = -1.*(xyz[1] - xyz_coc[1])/GetRadius(); + tangent[1] = (xyz[0] - GetCenterX())/GetRadius(); + tangent[0] = -1.*(xyz[1] - GetCenterY())/GetRadius(); + + Double_t perp_padrow[2] = {1,0}; //locally in slice + + Double_t cos_beta = fabs(tangent[0]*perp_padrow[0] + tangent[1]*perp_padrow[1]); + return acos(cos_beta); + +} + +Bool_t AliL3HoughTrack::GetCrossingPoint(Int_t padrow,Float_t *xyz) +{ + //Assumes the track is given in local coordinates + + if(!fIsHelix) + { + printf("AliL3HoughTrack::GetCrossingPoint : Track is not a helix\n"); + return 0; + } + + + if(!IsLocal()) + { + printf("GetCrossingPoint: Track is given on global coordinates\n"); + return false; + } + + Double_t xHit = fTransform->Row2X(padrow); + + //xyz[0] = fTransform->Row2X(padrow); + xyz[0] = xHit; + Double_t aa = (xHit - GetCenterX())*(xHit - GetCenterX()); + Double_t r2 = GetRadius()*GetRadius(); + if(aa > r2) + return false; + + Double_t aa2 = sqrt(r2 - aa); + Double_t y1 = GetCenterY() + aa2; + Double_t y2 = GetCenterY() - aa2; + xyz[1] = y1; + if(fabs(y2) < fabs(y1)) xyz[1] = y2; + xyz[2] = 0; //only consider transverse plane + + return true; +} + + +Bool_t AliL3HoughTrack::GetCrossingPoint(Int_t slice,Int_t padrow,Float_t *xyz) +{ + //Calculate the crossing point in transverse plane of this track and given + //padrow (y = a*x + b). Point is given in local coordinates in slice. + //Assumes the track is given in global coordinates. + + if(!fIsHelix) + { + printf("AliL3HoughTrack::GetCrossingPoint : Track is not a helix\n"); + return 0; + } + + + if(IsLocal()) + { + printf("GetCrossingPoint: Track is given in local coordintes!!!\n"); + return false; + } + + Double_t padrowradii = fTransform->Row2X(padrow); + + + Float_t rotation_angle = (slice*20)*ToRad; + + Float_t cs,sn; + cs = cos(rotation_angle); + sn = sin(rotation_angle); + + Double_t a = -1.*cs/sn; + Double_t b = padrowradii/sn; + + Double_t ycPrime = GetCenterY() - b ; + Double_t aa = ( 1. + a * a ) ; + Double_t bb = -2. * ( GetCenterX() + a * ycPrime ) ; + Double_t cc = ( GetCenterX() * GetCenterX() + ycPrime * ycPrime - GetRadius() * GetRadius() ) ; + + Double_t racine = bb * bb - 4. * aa * cc ; + if ( racine < 0 ) return false ; + Double_t rootRacine = sqrt(racine) ; + + Double_t oneOverA = 1./aa; +// +// First solution +// + Double_t x1 = 0.5 * oneOverA * ( -1. * bb + rootRacine ) ; + Double_t y1 = a * x1 + b ; + Double_t r1 = sqrt(x1*x1+y1*y1); +// +// Second solution +// + Double_t x2 = 0.5 * oneOverA * ( -1. * bb - rootRacine ) ; + Double_t y2 = a * x2 + b ; + Double_t r2 = sqrt(x2*x2+y2*y2); +// +// Choose close to (0,0) +// + Double_t xHit ; + Double_t yHit ; + if ( r1 < r2 ) { + xHit = x1 ; + yHit = y1 ; + } + else { + xHit = x2 ; + yHit = y2 ; + } + + xyz[0] = xHit; + xyz[1] = yHit; + xyz[2] = 0; + + fTransform->Global2Local(xyz,slice); + + return true; +} diff --git a/HLT/src/AliL3HoughTrack.h b/HLT/src/AliL3HoughTrack.h new file mode 100644 index 00000000000..58358032ac3 --- /dev/null +++ b/HLT/src/AliL3HoughTrack.h @@ -0,0 +1,46 @@ +#ifndef ALIL3_HOUGH_Track +#define ALIL3_HOUGH_Track + +#include "AliL3Track.h" + +class AliL3Transform; + +class AliL3HoughTrack : public AliL3Track { + + private: + + AliL3Transform *fTransform; //! + Double_t fMinDist; + Int_t fWeight; + + Double_t fDLine; + Double_t fPsiLine; + + Bool_t fIsHelix; + + public: + AliL3HoughTrack(); + virtual ~AliL3HoughTrack(); + + void Set(AliL3Track *track); + + void SetTrackParameters(Double_t kappa,Double_t phi,Int_t weight); + void SetLineParameters(Double_t psi,Double_t D,Int_t weight,Int_t *rowrange,Int_t ref_row); + Int_t GetWeight() {return fWeight;} + Double_t GetPsiLine() {return fPsiLine;} + Double_t GetDLine() {return fDLine;} + + void GetLineCrossingPoint(Int_t padrow,Double_t *xy); + Double_t GetCrossingAngle(Int_t padrow); + Bool_t GetCrossingPoint(Int_t slice,Int_t padrow,Float_t *xyz); + Bool_t GetCrossingPoint(Int_t padrow,Float_t *xyz); + + void SetBestMCid(Int_t f,Double_t min_dist); + void SetDLine(Double_t f) {fDLine=f;} + void SetPsiLine(Double_t f) {fPsiLine=f;} + + ClassDef(AliL3HoughTrack,1) + +}; + +#endif diff --git a/HLT/src/AliL3InterMerger.cxx b/HLT/src/AliL3InterMerger.cxx new file mode 100644 index 00000000000..63af89321ca --- /dev/null +++ b/HLT/src/AliL3InterMerger.cxx @@ -0,0 +1,137 @@ + +//Author: Uli Frankenfeld +//Last Modified: 06.12.2000 + +#include +#include +#include "AliL3Logging.h" +#include "AliL3InterMerger.h" +#include "AliL3Track.h" +#include "AliL3TrackSegmentData.h" +#include "AliL3Transform.h" +#include "AliL3TrackArray.h" + +//_____________________________________________________________ +// +// The L3 track segment merger +// + +ClassImp(AliL3InterMerger) + +AliL3InterMerger::AliL3InterMerger():AliL3Merger(1){ + //Default constructor + Is2Global(kFALSE); + SetParameter(2,2,.3,.3,.3); + fRowMax = fRowMin = 0; +} + + +AliL3InterMerger::~AliL3InterMerger(){ + //Destructor + +} + +void AliL3InterMerger::SlowMerge(){ + Int_t nrow= fRowMax-fRowMin+1; + void *ntuple=GetNtuple(); + AliL3TrackArray * tracks = GetInTracks(0); + const Int_t kNIn =tracks->GetNTracks(); + AliL3Track *tr[2]; + Bool_t merge = kTRUE; + for(Int_t in=0;inGetCheckedTrack(in)->CalculateHelix(); + while(merge){ + Int_t inmin=-1,outmin=-1; + Double_t min=10; + for(Int_t out=0;outGetCheckedTrack(out); + if(!outertrack) continue; + for(Int_t in=0;inGetCheckedTrack(in); + if(!innertrack) continue; + if(outertrack->GetNHits()+innertrack->GetNHits()>nrow) continue; + + Double_t diff = TrackDiff(innertrack,outertrack); + + if(diff>=0&&diff=0&&outmin>=0){ + AliL3Track *outertrack=tracks->GetTrack(outmin); + AliL3Track *innertrack=tracks->GetTrack(inmin); + tr[0]=innertrack; + tr[1]=outertrack; + SortTracks(tr,2); + MultiMerge(tracks,tr,2); + outertrack->CalculatePoint(tr[0]->GetLastPointX()); + innertrack->CalculatePoint(tr[0]->GetLastPointX()); + PrintDiff(innertrack,outertrack); + FillNtuple(ntuple,innertrack,outertrack); + tracks->Remove(outmin); + tracks->Remove(inmin); + } + else merge = kFALSE; + } + LOG(AliL3Log::kInformational,"AliL3InterMerger::SlowMerge","Result") + <GetNTracks()-kNIn<AddTracks(GetInTracks(0)); +} + +Int_t AliL3InterMerger::Merge(){ + Int_t nrow= fRowMax-fRowMin+1; + Double_t xval =fTransformer->Row2X((fRowMax+fRowMin)/2); + AliL3TrackArray * tracks = GetInTracks(0); + const Int_t kNIn =tracks->GetNTracks(); + AliL3Track *tr[2]; + for(Int_t in=0;inGetCheckedTrack(in); + if(t){ + t->CalculateHelix(); + t->CalculatePoint(xval); + } + } + for(Int_t out=0;outGetCheckedTrack(out); + if(!outertrack) continue; + for(Int_t in=0;inGetCheckedTrack(in); + if(!innertrack) continue; + if(outertrack->GetNHits()+innertrack->GetNHits()>nrow) continue; + + if(IsTrack(innertrack,outertrack)){ + tr[0]=innertrack; + tr[1]=outertrack; + SortTracks(tr,2); + if(tr[0]->GetLastPointX()GetFirstPointX()){ + MultiMerge(tracks,tr,2); + tracks->Remove(out); + tracks->Remove(in); + break; + } + } + } + } + Int_t nmerged = tracks->GetNTracks()-kNIn; + LOG(AliL3Log::kInformational,"AliL3InterMerger::Merge","Result") + <AddTracks(GetInTracks(0)); + + return nmerged; +} + + diff --git a/HLT/src/AliL3InterMerger.h b/HLT/src/AliL3InterMerger.h new file mode 100644 index 00000000000..9d6aa5da50b --- /dev/null +++ b/HLT/src/AliL3InterMerger.h @@ -0,0 +1,26 @@ +#ifndef ALIL3INTERMERGER_H +#define ALIL3INTERMERGER_H + +#ifndef __CINT__ +#include "AliL3Merger.h" +#endif + +class AliL3InterMerger : public AliL3Merger { + + private: + Int_t fPatch; + Int_t fRowMin; + Int_t fRowMax; + public: + AliL3InterMerger(); + virtual ~AliL3InterMerger(); + + void Init(Int_t *row,Int_t p){fRowMin=row[0];fRowMax=row[1];fPatch=p;} + void SlowMerge(); + Int_t Merge(); + void MMerge(); //Loop over tracks from different subsectors + + ClassDef(AliL3InterMerger,1) +}; + +#endif diff --git a/HLT/src/AliL3LinkDef.h b/HLT/src/AliL3LinkDef.h new file mode 100644 index 00000000000..a3d03a64c32 --- /dev/null +++ b/HLT/src/AliL3LinkDef.h @@ -0,0 +1,36 @@ +#ifdef __CINT__ + +#pragma link off all globals; +#pragma link off all classes; +#pragma link off all functions; + +#pragma link C++ class AliL3Benchmark; +#pragma link C++ class AliL3DigitRowData; +#pragma link C++ class AliL3DigitData; +#pragma link C++ class AliL3SpacePointData; +#pragma link C++ class AliL3ConfMapper; +#pragma link C++ class AliL3ConfMapPoint; +#pragma link C++ class AliL3Vertex; +#pragma link C++ class AliL3VertexFinder; +#pragma link C++ class AliL3VertexArray; +#pragma link C++ class AliL3Track; +#pragma link C++ class AliL3HoughTrack; +#pragma link C++ class AliL3ConfMapTrack; +#pragma link C++ class AliL3ConfMapFit; +#pragma link C++ class AliL3Transform; +#pragma link C++ class AliL3Merger; +#pragma link C++ class AliL3TrackMerger; +#pragma link C++ class AliL3GlobalMerger; +#pragma link C++ class AliL3InterMerger; +#pragma link C++ class AliLevel3; +#pragma link C++ class AliL3ClustFinder; +#pragma link C++ class AliL3TrackArray; +#pragma link C++ class AliL3Logger; +#pragma link C++ class AliL3MemHandler; +#pragma link C++ class AliL3FileHandler; +#pragma link C++ class AliL3Evaluate; +#pragma link C++ class AliL3Display; + + +#endif + diff --git a/HLT/src/AliL3Logger.cxx b/HLT/src/AliL3Logger.cxx new file mode 100644 index 00000000000..84d30a50475 --- /dev/null +++ b/HLT/src/AliL3Logger.cxx @@ -0,0 +1,69 @@ +#include "AliL3Logging.h" +#ifdef use_logging +#include "AliL3Logger.h" +#include + +int AliL3Logger::kAll= AliL3Log::kAll; +int AliL3Logger::kDebug = AliL3Log::kDebug; +int AliL3Logger::kInformational = AliL3Log::kInformational; +int AliL3Logger::kWarning = AliL3Log::kWarning; +int AliL3Logger::kError = AliL3Log::kError; +int AliL3Logger::kFatal = AliL3Log::kFatal; + +AliL3Logger::AliL3Logger(){ + gLogLevel=AliL3Log::kAll; + dn = so = se = sm =0; +} +AliL3Logger::~AliL3Logger(){ + if(dn) {gLog.DelServer(dn);delete dn;} + if(so) {gLog.DelServer(so);delete so;} + if(se) {gLog.DelServer(se);delete se;} + if(sm) {gLog.DelServer(sm);delete sm;} + if(of) {of->close();delete of;} +} +void AliL3Logger::Set(int l){gLogLevel |=l;} +void AliL3Logger::UnSet(int l){gLogLevel &=(~l);} +void AliL3Logger::UseDevNull(){ + if(dn) return; + dn = new AliL3DevNullLogServer(); + gLog.AddServer(dn); +} +void AliL3Logger::UseStdout(){ + if(so)return; + so = new AliL3StdoutLogServer(); + gLog.AddServer(so); +} +void AliL3Logger::UseStderr(){ + if(se) return; + se = new AliL3StderrLogServer(); + gLog.AddServer(se); +} + +void AliL3Logger::UseStream(char *name){ + if(sm) return; +// static ofstream of; + if(of) of->close(); + delete of; + of =0; + of = new ofstream(); + of->open(name); + sm = new AliL3StreamLogServer(*of); + gLog.AddServer(sm); +} +void AliL3Logger::NotUseDevNull(){ + if(dn) {gLog.DelServer(dn);delete dn;dn=0;} +} +void AliL3Logger::NotUseStdout(){ + if(so) {gLog.DelServer(so);delete so;so=0;} +} +void AliL3Logger::NotUseStderr(){ + if(se) {gLog.DelServer(se);delete se;se=0;} +} + +void AliL3Logger::NotUseStream(){ + if(sm) {gLog.DelServer(sm);delete sm;sm=0;} + if(of) {of->close();delete of;of=0;} +} + +#endif + diff --git a/HLT/src/AliL3Logger.h b/HLT/src/AliL3Logger.h new file mode 100644 index 00000000000..2ab6a723912 --- /dev/null +++ b/HLT/src/AliL3Logger.h @@ -0,0 +1,32 @@ +class MLUCLogServer; +class ofstream; + +class AliL3Logger{ + public: + static int kAll; + static int kDebug; + static int kInformational; + static int kWarning; + static int kError; + static int kFatal; + AliL3Logger(); + ~AliL3Logger(); + void Set(int l); + void UnSet(int l); + void UseDevNull(); + void UseStdout(); + void UseStderr(); + void UseStream(char *name="AliLevel3.log"); + void NotUseDevNull(); + void NotUseStdout(); + void NotUseStderr(); + void NotUseStream(); + private: + MLUCLogServer *dn; + MLUCLogServer *so; + MLUCLogServer *se; + MLUCLogServer *sm; + ofstream *of; +}; + + diff --git a/HLT/src/AliL3Logging.h b/HLT/src/AliL3Logging.h new file mode 100644 index 00000000000..40d7b57ae9b --- /dev/null +++ b/HLT/src/AliL3Logging.h @@ -0,0 +1,33 @@ +#ifndef ALIL3LOGGING_H +#define ALIL3LOGGING_H + +#define use_logging + +#ifdef use_logging + +#include "/heim/franken/lib/MLUC/include/MLUCLog.hpp" +#include "/heim/franken/lib/MLUC/include/MLUCLogServer.hpp" + +typedef MLUCLog AliL3Log; +typedef MLUCLogServer AliL3LogServer; +typedef MLUCDevNullLogServer AliL3DevNullLogServer; +typedef MLUCStdoutLogServer AliL3StdoutLogServer; +typedef MLUCStderrLogServer AliL3StderrLogServer; +typedef MLUCStreamLogServer AliL3StreamLogServer; + +#else +#include +class AliL3Log{ + public: + enum TLogLevel { kNone = 0, kDebug= 0x01, kInformational = 0x02, kWarning = 0x04, kError = 0x08 , kFatal = 0x10, kPrimary = 0x80, kAll = 0x9F }; + enum TLogCmd { kEnd, kPrec, kHex, kDec }; +}; + +#define LOG( lvl, origin, keyword ) cerr + +#define ENDLOG endl + +#endif +#endif // ALIL3LOGGING_H + + diff --git a/HLT/src/AliL3MemHandler.cxx b/HLT/src/AliL3MemHandler.cxx new file mode 100644 index 00000000000..ccaf2275da0 --- /dev/null +++ b/HLT/src/AliL3MemHandler.cxx @@ -0,0 +1,1096 @@ +//Author: Uli Frankenfeld +//Last Modified: 17.12.2000 + +#include +#include +#include +#include + +#include "AliL3MemHandler.h" +#include "AliL3Transform.h" +#include "AliL3Logging.h" + +#include "AliL3DigitData.h" +#include "AliL3TrackSegmentData.h" +#include "AliL3SpacePointData.h" +#include "AliL3TrackArray.h" +//_____________________________________________________________ +// +// The L3 Binary File handler +// + +ClassImp(AliL3MemHandler) + +AliL3MemHandler::AliL3MemHandler(){ + //Default constructor + fPt = 0; + fSize =0; + fInBinary = 0; + fOutBinary = 0; + fNRandom = 0; + Int_t r[2]={0,0}; + Init(0,0,r); + IsRandom = kFALSE; + fDigits = 0; + fDPt =0; + fNGenerate = 0; + fNUsed = 0; + fNDigits = 0; + + Int_t row[2] = {0,173}; + Init(0,0,row); + ResetROI(); +} + + +AliL3MemHandler::~AliL3MemHandler(){ + //Destructor + if(fPt) delete[] fPt; + if(fDigits) delete [] fDigits; + if(fDPt) delete [] fDPt; +} + +void AliL3MemHandler::ResetROI(){ + for(Int_t i=fRowMin; i<=fRowMax; i++) + { + fEtaMinTimeBin[i] = 0; + fEtaMaxTimeBin[i] = 445; + } +} + + +void AliL3MemHandler::SetROI(Float_t *eta,Int_t *slice){ + if(eta[1]==0) + { + LOG(AliL3Log::kWarning,"AliL3MemHandler::SetROI","Eta Values") + <<"Bad ROI parameters. IDIOT! "<Row2X(i); + xyz[1]=0; + xyz[2] = xyz[0]/tan(thetamax); + fTransformer->Slice2Sector(fSlice,i,sector,row); + fTransformer->Local2Raw(xyz,sector,row); + + fEtaMinTimeBin[i] = (Int_t)xyz[2]; + + if(eta[0]==0) + fEtaMaxTimeBin[i] = 445; + else + { + Float_t thetamin = 2*atan(exp(-1.*eta[0])); + xyz[0] = fTransformer->Row2X(i); + xyz[1] = fTransformer->GetMaxY(i); + Float_t radii = sqrt(pow(xyz[0],2) + pow(xyz[1],2)); + xyz[2] = radii/tan(thetamin); + fTransformer->Local2Raw(xyz,sector,row); + fEtaMaxTimeBin[i] = (Int_t)xyz[2]; + } + } + +} + +Bool_t AliL3MemHandler::SetBinaryInput(char *name){ + fInBinary = fopen(name,"r"); + if(!fInBinary){ + LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryInput","File Open") + <<"Pointer to File = 0x0 "<GetOutSize()); +} + +Byte_t *AliL3MemHandler::Allocate(UInt_t size){ + if(fPt){ + LOG(AliL3Log::kWarning,"AliL3MemHandler::Allocate","Memory") + <<"Delete Memory"< 1) { + i = first; + j = last; + for (;;) { + while (++i < last && CompareDigits(a[i], a[first]) < 0) + ; + while (--j > first && CompareDigits(a[j], a[first]) > 0) + ; + if (i >= j) + break; + + tmp = a[i]; + a[i] = a[j]; + a[j] = tmp; + } + if (j == first) { + ++first; + continue; + } + tmp = a[first]; + a[first] = a[j]; + a[j] = tmp; + if (j - first < last - (j + 1)) { + QSort(a, first, j); + first = j + 1; // QSort(j + 1, last); + } else { + QSort(a, j + 1, last); + last = j; // QSort(first, j); + } + } +} + +UInt_t AliL3MemHandler::GetRandomSize(){ + Int_t nrandom = 0; + for(Int_t r=fRowMin;r<=fRowMax;r++){ + Int_t npad=fTransformer->GetNPads(r); + nrandom += Int_t (fNGenerate * ((Double_t) npad/141.)); + } + return 9 * nrandom * sizeof(AliL3DigitData); +} + +void AliL3MemHandler::Generate(Int_t row){ + if(!IsRandom) return; + ResetRandom(); + fNDigits = 0; + Int_t npad=fTransformer->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() ); + + for(Int_t n=0;nfRow,fDPt[d]->fPad, +// fDPt[d]->fTime,fDPt[d]->fCharge); +} + + +void AliL3MemHandler::DigitizePoint(Int_t row, Int_t pad, + Int_t time,Int_t charge){ + for(Int_t j=-1;j<2;j++){ + for(Int_t k=-1;k<2;k++){ + Int_t dcharge = charge; + if(j) dcharge /=2; + if(k) dcharge /=2; + if(dcharge<10) continue; + 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; + + fDigits[fNDigits].fCharge = dcharge; + fDigits[fNDigits].fRow = row; + fDigits[fNDigits].fPad = dpad; + fDigits[fNDigits].fTime = dtime; + fDPt[fNDigits] = &fDigits[fNDigits]; + fNDigits++; + } + } +} + +///////////////////////////////////////// Digit IO +Bool_t AliL3MemHandler::Memory2Binary(UInt_t nrow,AliL3DigitRowData *data){ + if(!fOutBinary){ + LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","File") + <<"No Output File"<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; + } + LOG(AliL3Log::kDebug,"AliL3MemHandler::Memory2Binary","Memory") + <fNDigit; + + if(fread(byte_pt,size,1,fInBinary)!=1) break; + byte_pt += size; + outsize += size; + + row_pt = (AliL3DigitRowData *) byte_pt; + rowcount++; + } + nrow= rowcount; + LOG(AliL3Log::kDebug,"AliL3MemHandler::Binary2Memory","Memory") + <fPad; + data[ndata].fTime = fDPt[fNUsed]->fTime; + data[ndata].fCharge = fDPt[fNUsed]->fCharge; + ndata++; + fNUsed++; +} + +void AliL3MemHandler::MergeDataRandom(AliL3DigitData *data, UInt_t & ndata, + UInt_t row, UShort_t pad, UShort_t time, UShort_t charge){ +// AddData(data,ndata,row,pad,time,charge); + 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; + data[ndata].fCharge = ch; + fNUsed++; + } + ndata++; +} + +void AliL3MemHandler::AddDataRandom(AliL3DigitData *data, UInt_t & ndata, + UInt_t row, UShort_t pad, UShort_t time, UShort_t charge){ + Int_t action; + while((action=ComparePoints(row,pad,time))==1){ + AddRandom(data,ndata); + } + if(action==0){ + MergeDataRandom(data,ndata,row,pad,time,charge); + } + if(action<0){ + AddData(data,ndata,row,pad,time,charge); + } +} + +void AliL3MemHandler::Write(UInt_t *comp, UInt_t & index, + UInt_t & subindex, UShort_t value){ + UInt_t shift[3] = {0,10,20}; + comp[index] |= (value&0x03ff)<>shift[subindex])&0x03ff; + if(subindex == 2){ + subindex = 0; + index++; + } + else subindex++; + + return value; +} + +UShort_t AliL3MemHandler::Test(UInt_t *comp, + UInt_t index, UInt_t subindex){ + UInt_t shift[3] = {0,10,20}; + return (comp[index]>>shift[subindex])&0x03ff; +} + +Int_t AliL3MemHandler::Memory2CompMemory(UInt_t nrow, + AliL3DigitRowData *data,UInt_t *comp){ + if(!comp){ + LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2CompMemory","Memory") + <<"Pointer to compressed data = 0x0 "<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;digfNDigit;dig++){ + if(row_pt->fDigitData[dig].fPad <200){ + ddd[row_pt->fDigitData[dig].fPad]++; + } + } + for(Int_t d=0;d<200;d++){ + if(ddd[d]){ + npad++; + maxpad =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) + continue; + Write(comp,index,subindex,pad); +// write zero if time != 0 + if(digitfNDigit && row_pt->fDigitData[digit].fPad == pad){ + if(row_pt->fDigitData[digit].fTime>0){ + Write(comp,index,subindex,0); + Write(comp,index,subindex,row_pt->fDigitData[digit].fTime); + } + } + while(digitfNDigit && row_pt->fDigitData[digit].fPad == pad){ + UShort_t charge = row_pt->fDigitData[digit].fCharge; + if(charge>=1024){ + charge=1023; + } + Write(comp,index,subindex,charge); + if(digit+1fNDigit&&row_pt->fDigitData[digit+1].fPad == pad){ + if(row_pt->fDigitData[digit].fTime +1 != + row_pt->fDigitData[digit+1].fTime){ + Write(comp,index,subindex,0); + UShort_t nzero = row_pt->fDigitData[digit+1].fTime - + (row_pt->fDigitData[digit].fTime +1); + Write(comp,index,subindex,nzero); + } + } + digit++; + } + Write(comp,index,subindex,0); + Write(comp,index,subindex,0); + } + + Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+ + sizeof(AliL3DigitRowData); + Byte_t *byte_pt =(Byte_t *) row_pt; + byte_pt += size; + row_pt = (AliL3DigitRowData *) byte_pt; + } + while(subindex) + Write(comp,index,subindex,0); + return index * sizeof(UInt_t); +} + +Int_t AliL3MemHandler::CompMemory2Memory(UInt_t nrow, + AliL3DigitRowData *data,UInt_t *comp){ + if(!comp){ + LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2Memory","Memory") + <<"Pointer to compressed data = 0x0 "<fRow=row; + Generate(row); + UShort_t npad = Read(comp,index,subindex); + for(UShort_t p=0;p=fEtaMinTimeBin[row]&&time<=fEtaMaxTimeBin[row]) +// AddData(row_pt->fDigitData,ndigit,row,pad,time,charge); + AddDataRandom(row_pt->fDigitData,ndigit,row,pad,time,charge); + time++; + } + UShort_t tshift = Read(comp,index,subindex); + if(tshift ==0) break; + time += tshift; + } + } + row_pt->fNDigit = ndigit; + Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+ + sizeof(AliL3DigitRowData); + Byte_t *byte_pt =(Byte_t *) row_pt; + byte_pt += size; + outsize += size; + row_pt = (AliL3DigitRowData *) byte_pt; + } + return outsize; +} + +UInt_t AliL3MemHandler::GetCompMemorySize(UInt_t nrow,AliL3DigitRowData *data){ + if(!data){ + LOG(AliL3Log::kWarning,"AliL3MemHandler::GetCompMemorySize","Memory") + <<"Pointer to AliL3DigitRowData = 0x0 "<fNDigit;dig++){ + if(row_pt->fDigitData[dig].fPad <200){ + ddd[row_pt->fDigitData[dig].fPad]++; + } + } + for(Int_t d=0;d<200;d++){ + if(ddd[d]){ + npad++; + maxpad =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) + continue; + index++; +// write zero if time != 0 + if(digitfNDigit && row_pt->fDigitData[digit].fPad == pad){ + if(row_pt->fDigitData[digit].fTime>0){ + index++; + index++; + } + } + while(digitfNDigit && row_pt->fDigitData[digit].fPad == pad){ + index++; + if(digit+1fNDigit&&row_pt->fDigitData[digit+1].fPad == pad){ + if(row_pt->fDigitData[digit].fTime +1 != + row_pt->fDigitData[digit+1].fTime){ + index++; + index++; + } + } + digit++; + } + index++; + index++; + } + + Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+ + sizeof(AliL3DigitRowData); + Byte_t *byte_pt =(Byte_t *) row_pt; + byte_pt += size; + row_pt = (AliL3DigitRowData *) byte_pt; + } + while(index%3) + index++; + return (index/3) * sizeof(UInt_t); +} + +UInt_t AliL3MemHandler::GetMemorySize(UInt_t nrow,UInt_t *comp){ + if(!comp){ + LOG(AliL3Log::kWarning,"AliL3MemHandler::GetMemorySize","Memory") + <<"Pointer to compressed data = 0x0 "<SetBinaryInput(fInBinary); + UInt_t *comp =(UInt_t *)handler->Allocate(); + handler->CompBinary2CompMemory(nrow,comp); + UInt_t size = GetMemorySize(nrow,comp); + AliL3DigitRowData *data = (AliL3DigitRowData *)Allocate(size); + CompMemory2Memory(nrow,data,comp); + handler->Free(); + delete handler; + return data; +} + +Bool_t AliL3MemHandler::Memory2CompBinary(UInt_t nrow,AliL3DigitRowData *data){ + Bool_t out = kTRUE; + AliL3MemHandler * handler = new AliL3MemHandler(); + UInt_t size = GetCompMemorySize(nrow,data); + UInt_t *comp =(UInt_t *)handler->Allocate(size); + Memory2CompMemory(nrow,data,comp); + CompMemory2CompBinary(nrow,comp,size); + handler->Free(); + delete handler; + return out; +} + + +///////////////////////////////////////// Point IO +Bool_t AliL3MemHandler::Memory2Binary(UInt_t npoint,AliL3SpacePointData *data){ + if(!fOutBinary){ + LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","File") + <<"No Output File"<Local2Global(xyz,slice); + data[i].fX = xyz[0]; + data[i].fY = xyz[1]; + data[i].fZ = xyz[2]; + } + return kTRUE; +} + +Bool_t AliL3MemHandler::Binary2Memory(UInt_t & npoint,AliL3SpacePointData *data){ + if(!fInBinary){ + LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","File") + <<"No Input File"<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; + } + LOG(AliL3Log::kDebug,"AliL3MemHandler::Memory2Binary","File") + <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; + ntrack++; + } + LOG(AliL3Log::kDebug,"AliL3MemHandler::Binary2Memory","File") + <WriteTracks(ntrack,data); + return kTRUE; +} + +Bool_t AliL3MemHandler::Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array){ + if(!data){ + LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory") + <<"Pointer to AliL3TrackSegmentData = 0x0 "<FillTracks(ntrack,data); + return kTRUE; +} + +Bool_t AliL3MemHandler::Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array,Int_t slice, AliL3Transform* trans){ + if(!data){ + LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory") + <<"Pointer to AliL3TrackSegmentData = 0x0 "<FillTracks(ntrack,data,slice,trans); + return kTRUE; +} + diff --git a/HLT/src/AliL3MemHandler.h b/HLT/src/AliL3MemHandler.h new file mode 100644 index 00000000000..e7ca8804224 --- /dev/null +++ b/HLT/src/AliL3MemHandler.h @@ -0,0 +1,151 @@ +#ifndef ALIL3MEMHANDLER_H +#define ALIL3MEMHANDLER_H + +#include "AliL3RootTypes.h" +#include +#include +#include "AliL3DigitData.h" +#include "AliL3Transform.h" +class AliL3SpacePointData; +class AliL3DigitRowData; +class AliL3TrackSegmentData; +class AliL3TrackArray; +class AliL3RandomPointData; + +class AliL3MemHandler{ + private: + AliL3Transform *fTransformer;//! + FILE *fInBinary;//! + FILE *fOutBinary;//! + Byte_t *fPt;//! + UInt_t fSize; + + AliL3RandomDigitData **fDPt;//! + AliL3RandomDigitData *fDigits;//! + Bool_t IsRandom; + Int_t fNRandom; + Int_t fNGenerate; + Int_t fNUsed; + Int_t fNDigits; + + void Write(UInt_t *comp, UInt_t & index, UInt_t & subindex, UShort_t value); + UShort_t Read(UInt_t *comp, UInt_t & index, UInt_t & subindex); + UShort_t Test(UInt_t *comp, UInt_t index, UInt_t subindex); + + void DigitizePoint(Int_t row,Int_t pad, Int_t time,Int_t charge); + void QSort(AliL3RandomDigitData **a, Int_t first, Int_t last); + Int_t ComparePoints(UInt_t row,UShort_t pad,UShort_t time); + Int_t CompareDigits(AliL3RandomDigitData *a,AliL3RandomDigitData *b); + void AddData(AliL3DigitData *data,UInt_t & ndata, + UInt_t row,UShort_t pad,UShort_t time,UShort_t charge); + void AddRandom(AliL3DigitData *data,UInt_t & ndata); + void MergeDataRandom(AliL3DigitData *data,UInt_t & ndata, + UInt_t row,UShort_t pad,UShort_t time,UShort_t charge); + void AddDataRandom(AliL3DigitData *data,UInt_t & ndata, + UInt_t row,UShort_t pad,UShort_t time,UShort_t charge); + + protected: + Int_t fRowMin; + Int_t fRowMax; + Int_t fSlice; + Int_t fPatch; + + Int_t fEtaMinTimeBin[174]; + Int_t fEtaMaxTimeBin[174]; + + + public: + AliL3MemHandler(); + virtual ~AliL3MemHandler(); + + void Reset(){CloseBinaryInput();CloseBinaryOutput();Free();} + void Init(AliL3Transform *t){fTransformer = t;} + void Init(Int_t s,Int_t p,Int_t* row){fSlice=s;fPatch=p;fRowMin=row[0];fRowMax=row[1]; ResetROI();} + + Bool_t SetBinaryInput(char *name); + Bool_t SetBinaryInput(FILE *file); + void CloseBinaryInput(); + + Bool_t SetBinaryOutput(char *name); + Bool_t SetBinaryOutput(FILE *file); + void CloseBinaryOutput(); + + //Random cluster + void SetRandomCluster(Int_t maxnumber); + void SetRandomSeed(UInt_t seed){srand(seed);} + void SetRandomSeed(); + + void ResetRandom(){fNDigits = 0; fNUsed = 0;} + void Generate(Int_t row); + void SetNGenerate(Int_t number){(number>fNRandom)?fNGenerate=fNRandom:fNGenerate = number;} + + void SetROI(Float_t *eta,Int_t *slice); + void ResetROI(); + + //Digit IO + Bool_t Memory2Binary(UInt_t nrow,AliL3DigitRowData *data); + Bool_t Binary2Memory(UInt_t & nrow,AliL3DigitRowData *data); + + Int_t Memory2CompMemory(UInt_t nrow,AliL3DigitRowData *data,UInt_t *comp); + Int_t CompMemory2Memory(UInt_t nrow,AliL3DigitRowData *data,UInt_t *comp); + Bool_t CompMemory2CompBinary(UInt_t nrow,UInt_t *comp, UInt_t size=0); + Bool_t CompBinary2CompMemory(UInt_t & nrow,UInt_t *comp); + + AliL3DigitRowData *CompBinary2Memory(UInt_t & nrow); + Bool_t Memory2CompBinary(UInt_t nrow,AliL3DigitRowData *data); + UInt_t GetNRow(UInt_t *comp,UInt_t size); + + //Point IO + Bool_t Memory2Binary(UInt_t npoint,AliL3SpacePointData *data); + Bool_t Binary2Memory(UInt_t & npoint,AliL3SpacePointData *data); + Bool_t Transform(UInt_t npoint,AliL3SpacePointData *data, + Int_t slice, AliL3Transform* trans); + + //Track IO + Bool_t Memory2Binary(UInt_t ntrack,AliL3TrackSegmentData *data); + Bool_t Binary2Memory(UInt_t & ntrack,AliL3TrackSegmentData *data); + Bool_t TrackArray2Binary(AliL3TrackArray *array); + Bool_t Binary2TrackArray(AliL3TrackArray *array); + Bool_t TrackArray2Memory(UInt_t & ntrack,AliL3TrackSegmentData *data, + AliL3TrackArray *array); + Bool_t Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data, + AliL3TrackArray *array); + Bool_t Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data, + AliL3TrackArray *array,Int_t slice, AliL3Transform* trans); + + //Memory Allocation + UInt_t GetAllocatedSize(){return fSize;} + UInt_t GetFileSize(); + UInt_t GetMemorySize(UInt_t nrow,UInt_t *comp); + UInt_t GetCompMemorySize(UInt_t nrow,AliL3DigitRowData *data); + UInt_t GetRandomSize(); + + Byte_t *Allocate(UInt_t size); + Byte_t *Allocate(); // allocate size of Binary Input File + Byte_t *Allocate(AliL3TrackArray *array); + void Free(); + + ClassDef(AliL3MemHandler,1) +}; + +inline Int_t AliL3MemHandler::ComparePoints(UInt_t row,UShort_t pad,UShort_t time){ + if(fNUsed>=fNDigits) return -2; + + if(pad==fDPt[fNUsed]->fPad&&time==fDPt[fNUsed]->fTime) return 0; + + if(padfPad) return -1; + if(pad==fDPt[fNUsed]->fPad&&timefTime) return -1; + + return 1; +} + +inline Int_t AliL3MemHandler::CompareDigits(AliL3RandomDigitData *a,AliL3RandomDigitData *b){ + if(a->fPad==b->fPad && a->fTime == b->fTime) return 0; + + if(a->fPadfPad) return -1; + if(a->fPad==b->fPad && a->fTimefTime) return -1; + + return 1; +} + +#endif diff --git a/HLT/src/AliL3Merger.cxx b/HLT/src/AliL3Merger.cxx new file mode 100644 index 00000000000..12fbe2a84f4 --- /dev/null +++ b/HLT/src/AliL3Merger.cxx @@ -0,0 +1,415 @@ + +//Author: Uli Frankenfeld +//Last Modified: 06.12.2000 + +#include "AliL3Logging.h" +#include +#include +#include "AliL3Merger.h" +#include "AliL3Track.h" +#include "AliL3TrackSegmentData.h" +#include "AliL3Transform.h" +#include "AliL3TrackArray.h" + +#ifdef use_root //use root ntuple for slow merge +#include +#include +#include +#endif +//_____________________________________________________________ +// +// The L3 merger base class +// + +ClassImp(AliL3Merger) + +AliL3Merger::AliL3Merger(){ + //Default constructor + fTransformer= 0; + SetArray(0); +} + + +AliL3Merger::AliL3Merger(Int_t ntrackarrays){ + //Constructor. + SetArray(ntrackarrays); + fCurrentTracks=0; +} + +AliL3Merger::~AliL3Merger(){ + //Destructor + DeleteArray(); +} + +void AliL3Merger::DeleteArray(){ + for(Int_t i=0; iReset(); + } + fOutTrack->Reset(); +} + +void AliL3Merger::FillTracks(Int_t ntracks, AliL3TrackSegmentData* tr){ + //Read tracks from shared memory (or memory) + AliL3TrackArray *destination = GetInTracks(fCurrentTracks); + if(Is2Global()) + destination->FillTracks(ntracks, tr, fSlice, fTransformer); + else + destination->FillTracks(ntracks, tr); +} + +void AliL3Merger::AddAllTracks(){ + for(Int_t i=0; iAddTracks(in); + } +} + +void AliL3Merger::SortGlobalTracks(AliL3Track **tracks, Int_t ntrack){ + AliL3Track **tmp = new AliL3Track*[ntrack]; + for(Int_t i=0;iGetFirstPointX(),2)+pow(tracks[i]->GetFirstPointY(),2); + Double_t r=sqrt(rr); + if(rGetFirstPointX()GetFirstPointX(); + mini=i; + } + } + t[j]=mini; + tracks[mini]=0; + } + for(Int_t i=0;iGetNHits(); + } + if(nps>174){ + LOG(AliL3Log::kWarning,"AliL3Merger::MultiMerge","Adding Points") + <NextTrack(); + //copy points + UInt_t nn[174]; + nps = 0; + +// for(Int_t i=0;i=0;i--){ + memcpy(&nn[nps],tracks[i]->GetHitNumbers(),tracks[i]->GetNHits()*sizeof(UInt_t)); + nps+=tracks[i]->GetNHits(); + } + AliL3Track *tpf=tracks[0]; + AliL3Track *tpl=tracks[ntrack-1]; + + newtrack->SetNHits(nps); + newtrack->SetHits(nps,nn); + newtrack->SetFirstPoint(tpf->GetFirstPointX(),tpf->GetFirstPointY(),tpf->GetFirstPointZ()); + newtrack->SetLastPoint(tpl->GetLastPointX(),tpl->GetLastPointY(),tpl->GetLastPointZ()); + newtrack->SetPt(tpf->GetPt()); + newtrack->SetPsi(tpf->GetPsi()); + newtrack->SetTgl(tpf->GetTgl()); + newtrack->SetCharge(tpf->GetCharge()); + return newtrack; +} + +void* AliL3Merger::GetNtuple(char *varlist){ +#ifdef use_root + TNtuple* nt = new TNtuple("ntuple","ntuple",varlist); + return (void*) nt; +#else + return 0; +#endif +} + +void* AliL3Merger::GetNtuple(){ +#ifdef use_root + TNtuple* nt = new TNtuple("ntuple","ntuple", + "dx:dy:dz:dk:dpsi:dtgl:dq:disx:disy:disz:dis:n0:n1:diff:drx:dry:drz"); + return (void*) nt; +#else + return 0; +#endif +} + +Bool_t AliL3Merger::WriteNtuple(char *filename, void* nt){ +#ifdef use_root + TNtuple *ntuple=(TNtuple *) nt; + TFile *f = new TFile(filename,"RECREATE"); + ntuple->Write(); + f->Close(); + delete ntuple; + return kTRUE; +#else + return kFALSE; +#endif +} + +void AliL3Merger::FillNtuple(void *nt,AliL3Track *innertrack,AliL3Track *outertrack){ + Float_t data[17]; + if(outertrack->IsPoint()&&innertrack->IsPoint()){ + data[0] =Float_t(innertrack->GetPointX()-outertrack->GetPointX()); + data[1] =Float_t(innertrack->GetPointY()-outertrack->GetPointY()); + data[2] =Float_t(innertrack->GetPointZ()-outertrack->GetPointZ()); + data[3] =Float_t(innertrack->GetKappa()-outertrack->GetKappa()); + Double_t psi= innertrack->GetPointPsi() - outertrack->GetPointPsi(); + if(psi>PI) psi-=2*PI; + if(psi<-PI)psi+=2*PI; + data[4] =Float_t(psi); + data[5] =Float_t(innertrack->GetTgl()-outertrack->GetTgl()); + data[6] =Float_t(innertrack->GetCharge()-outertrack->GetCharge()); + data[7] =Float_t(innertrack->GetLastPointX()-outertrack->GetFirstPointX()); + data[8] =Float_t(innertrack->GetLastPointY()-outertrack->GetFirstPointY()); + data[9] =Float_t(innertrack->GetLastPointZ()-outertrack->GetFirstPointZ()); + data[10] =sqrt(pow(data[7],2)+pow(data[8],2)+pow(data[9],2)); + data[11]= outertrack->GetNHits(); + data[12]= innertrack->GetNHits(); + data[13] = Float_t(TrackDiff(innertrack,outertrack)); +#ifdef use_root + TNtuple *ntuple = (TNtuple *) nt; + ntuple->Fill(data); +#endif + } +} + +void AliL3Merger::FillNtuple(void *nt,Float_t *data){ +#ifdef use_root + TNtuple *ntuple = (TNtuple *) nt; + ntuple->Fill(data); +#endif +} + +Double_t AliL3Merger::GetAngle(Double_t a1,Double_t a2){ + Double_t da = a1 - a2 +4*PI; + da = fmod(da,2*PI); + if(da>PI) da = 2*PI -da; + return da; +} + +void AliL3Merger::SetParameter(Double_t maxy, Double_t maxz, Double_t maxkappa, Double_t maxpsi, Double_t maxtgl){ + fMaxY = maxy; + fMaxZ = maxz; + fMaxKappa = maxkappa; + fMaxPsi = maxpsi; + fMaxTgl = maxtgl; +} + +Bool_t AliL3Merger::IsTrack(AliL3Track *innertrack,AliL3Track *outertrack){ + + if(innertrack->GetCharge()!=outertrack->GetCharge()) return kFALSE; + if( (!innertrack->IsPoint()) || (!outertrack->IsPoint()) ) return kFALSE; + if(innertrack->GetNHits()+outertrack->GetNHits()>174) return kFALSE; + + if(fabs(innertrack->GetPointY()-outertrack->GetPointY()) >fMaxY) return kFALSE; + if(fabs(innertrack->GetPointZ()-outertrack->GetPointZ()) >fMaxZ) return kFALSE; + if(fabs(innertrack->GetKappa()-outertrack->GetKappa()) >fMaxKappa) return kFALSE; + if(GetAngle(innertrack->GetPointPsi(),outertrack->GetPointPsi()) >fMaxPsi) return kFALSE; + if(fabs(innertrack->GetTgl()-outertrack->GetTgl()) >fMaxTgl) return kFALSE; + //if no rejection up to this point: merge!! + return kTRUE; +} + +Bool_t AliL3Merger::IsRTrack(AliL3Track *innertrack,AliL3Track *outertrack){ + return IsTrack(innertrack,outertrack); +} + +Double_t AliL3Merger::TrackDiff(AliL3Track *innertrack,AliL3Track *outertrack){ + Double_t diff =-1; + Double_t x[4],y[4],z[4],dy[4],dz[4]; + AliL3Track *tracks[2]; + + tracks[0] = innertrack; + tracks[1] = outertrack; + SortGlobalTracks(tracks,2); + innertrack = tracks[0]; + outertrack = tracks[1]; + + x[0] = innertrack->GetFirstPointX(); + x[1] = innertrack->GetLastPointX(); + x[2] = outertrack->GetFirstPointX(); + x[3] = outertrack->GetLastPointX(); + + y[0] = innertrack->GetFirstPointY(); + y[1] = innertrack->GetLastPointY(); + y[2] = outertrack->GetFirstPointY(); + y[3] = outertrack->GetLastPointY(); + + z[0] = innertrack->GetFirstPointZ(); + z[1] = innertrack->GetLastPointZ(); + z[2] = outertrack->GetFirstPointZ(); + z[3] = outertrack->GetLastPointZ(); + + + outertrack->CalculatePoint(x[0]); + if(!outertrack->IsPoint()) return diff; + dy[0] = fabs(y[0] - outertrack->GetPointY()); + dz[0] = fabs(z[0] - outertrack->GetPointZ()); + + outertrack->CalculatePoint(x[1]); + if(!outertrack->IsPoint()) return diff; + dy[1] = fabs(y[1] - outertrack->GetPointY()); + dz[1] = fabs(z[1] - outertrack->GetPointZ()); + + innertrack->CalculatePoint(x[2]); + if(!innertrack->IsPoint()) return diff; + dy[2] = fabs(y[2] - innertrack->GetPointY()); + dz[2] = fabs(z[2] - innertrack->GetPointZ()); + + innertrack->CalculatePoint(x[3]); + if(!innertrack->IsPoint()) return diff; + dy[3] = fabs(y[3] - innertrack->GetPointY()); + dz[3] = fabs(z[3] - innertrack->GetPointZ()); + + diff=0; + for(Int_t i=0;i<4;i++) + diff+=sqrt(dy[i]*dy[i]+dz[i]*dz[i]); + return diff; +} + + + +void AliL3Merger::PrintDiff(AliL3Track *innertrack,AliL3Track *outertrack){ + if(!innertrack->IsPoint()||!outertrack->IsPoint()){ + cerr<<"AliL3Merger::PrintDiff: No Points"<GetPointX()-outertrack->GetPointX(); + Double_t dy = innertrack->GetPointY()-outertrack->GetPointY(); + Double_t dz = innertrack->GetPointZ()-outertrack->GetPointZ(); + Double_t dk = innertrack->GetKappa()-outertrack->GetKappa(); + Double_t dpsi= innertrack->GetPointPsi() - outertrack->GetPointPsi(); + if(dpsi>PI) dpsi-=2*PI; + if(dpsi<-PI)dpsi+=2*PI; +// Double_t dpsi = GetAngle(innertrack->GetPointPsi(),outertrack->GetPointPsi()); + Double_t dtgl= innertrack->GetTgl()-outertrack->GetTgl(); + Double_t dq =innertrack->GetCharge()-outertrack->GetCharge(); + + fprintf(stderr,"dx: %4f dy: %4f dz: %4f dk: %4f dpsi: %4f dtgl: %4f dq: %4f\n", + dx,dy,dz,dk,dpsi,dtgl,dq); +cerr<<"---------------------------"<GetNTracks();j++){ + AliL3Track *track=ttt->GetCheckedTrack(j); + if(!track) continue; + track->CalculateHelix(); +// Double_t angle = atan2(track->GetLastPointY(),track->GetLastPointX()); +// if(angle<0) angle+=PI; + if(track->CalculatePoint(135)) +// if(!track->CalculateEdgePoint(angle)) cerr<<"**************"<CalculatePoint(track->GetLastPointX())) +// if(track->CalculatePoint(0)) + { +// PrintTrack(track); +// track->CalculateReferencePoint(PI/180.); + track->CalculateReferencePoint(0.001); + fprintf(stderr,"npt: %3d dx: %8.5f dy: %8.5f dz: %8.5f\n", + track->GetNHits(),(float)track->GetPointX()-track->GetPointX(), + (float)track->GetPointY()-track->GetPointY(), + (float)track->GetPointZ()-track->GetPointZ()); + + cerr<<"---------------------------"<GetNHits(),track->GetPt(),track->GetPsi(), + track->GetTgl(),track->GetCharge()); + fprintf(stderr, + "x1: %6.2f y1: %6.2f z1: %6.2f xl: %6.2f yl: %6.2f zl: %6.2f\n", + track->GetFirstPointX(),track->GetFirstPointY(),track->GetFirstPointZ(), + track->GetLastPointX(),track->GetLastPointY(),track->GetLastPointZ()); + if(track->IsPoint()){ + fprintf(stderr, + "R: %.2f Xc: %.2f Yc: %.2f Xp: %.2f Yp: %.2f Zp: %.2f Psip: %.2f\n", + track->GetRadius(),track->GetCenterX(),track->GetCenterY(), + track->GetPointX(),track->GetPointY(),track->GetPointZ(), + track->GetPointPsi()); + } +} + + + + diff --git a/HLT/src/AliL3Merger.h b/HLT/src/AliL3Merger.h new file mode 100644 index 00000000000..9bc00703759 --- /dev/null +++ b/HLT/src/AliL3Merger.h @@ -0,0 +1,76 @@ +#ifndef ALIL3MERGER_H +#define ALIL3MERGER_H +#define PI 3.14159265358979312 + +#include "AliL3RootTypes.h" + +class AliL3Track; +class AliL3TrackSegmentData; +class AliL3Vertex; +class AliL3Transform; +class AliL3TrackArray; + +class AliL3Merger { + private: + Double_t fMaxY; + Double_t fMaxZ; + Double_t fMaxKappa; + Double_t fMaxPsi; + Double_t fMaxTgl; + void SetArray(Int_t nin); + void DeleteArray(); + + AliL3TrackArray **fInTrack;//! + Int_t fNIn; + + AliL3TrackArray *fOutTrack;//! + + protected: + Int_t fCurrentTracks; + Int_t fSlice; + AliL3Vertex *fVertex;//! + AliL3Transform *fTransformer;//! + Bool_t f2Global; + Bool_t Is2Global(Bool_t is){f2Global=is;return f2Global;} + + public: + AliL3Merger(); + AliL3Merger(Int_t ntrackarrays); + virtual ~AliL3Merger(); + + Int_t GetNIn(){return fNIn;} + AliL3TrackArray *GetInTracks(Int_t in){return fInTrack[in];} + AliL3TrackArray *GetOutTracks(){return fOutTrack;} + + Bool_t Is2Global(){return f2Global;} + void SetTransformer(AliL3Transform *trans){fTransformer = trans;} + void SetVertex(AliL3Vertex *vertex){fVertex=vertex;} + void Reset(); + void SetParameter(Double_t maxy=1., Double_t maxz=1., Double_t maxkappa=0.001, Double_t maxpsi=0.05, Double_t maxtgl=0.1); + void FillTracks(Int_t ntracks, AliL3TrackSegmentData* tr); //Fill tracks in fTrackArray[fCurrentTracks] + Double_t GetAngle(Double_t a1,Double_t a2); + void* GetNtuple(); + void* GetNtuple(char *varlist); + Bool_t WriteNtuple(char *filename,void* nt); + void FillNtuple(void* nt,Float_t *data); + void FillNtuple(void* nt,AliL3Track *innertrack,AliL3Track *outertrack); + void AddAllTracks();//Copy all Tracks to Output Array + void SortGlobalTracks(AliL3Track **tracks, Int_t ntrack); + void SortTracks(AliL3Track **tracks, Int_t ntrack); + void AddTrack(AliL3TrackArray *mergedtrack,AliL3Track *track); + AliL3Track * MultiMerge(AliL3TrackArray *mergedtrack,AliL3Track **tracks, Int_t ntrack); + AliL3Track * MergeTracks(AliL3TrackArray *mergedtrack,AliL3Track *t0,AliL3Track *t1); + Bool_t IsTrack(AliL3Track *innertrack,AliL3Track *outertrack); + Bool_t IsRTrack(AliL3Track *innertrack,AliL3Track *outertrack); + Double_t TrackDiff(AliL3Track *innertrack,AliL3Track *outertrack); + void Print(); + void PrintDiff(AliL3Track *innertrack,AliL3Track *outertrack); + void PrintTrack(AliL3Track *track); +// Int_t WriteTracks(Char_t *file); +// Int_t WriteInTracks(Char_t *file); +// Int_t WriteAllTracks(Char_t *file); + + ClassDef(AliL3Merger,1) +}; + +#endif diff --git a/HLT/src/AliL3RootTypes.h b/HLT/src/AliL3RootTypes.h new file mode 100644 index 00000000000..afee044bde6 --- /dev/null +++ b/HLT/src/AliL3RootTypes.h @@ -0,0 +1,105 @@ +#ifndef ALIL3ROOTTYPES_H +#define ALIL3ROOTTYPES_H + + +////////////////////////////////////////////////////////////////////////// +// // +// Basic types used by level3 // +// // +////////////////////////////////////////////////////////////////////////// +#include +#include + +//#define no_root //switch on the root + +#ifndef no_root +#define use_root +#include +#include + +#else + +#ifndef ROOT_Rtypes +//---- types ------------------------------------------------------------------- + +typedef char Char_t; //Signed Character 1 byte +typedef unsigned char UChar_t; //Unsigned Character 1 byte +typedef short Short_t; //Signed Short integer 2 bytes +typedef unsigned short UShort_t; //Unsigned Short integer 2 bytes +#ifdef R__INT16 +typedef long Int_t; //Signed integer 4 bytes +typedef unsigned long UInt_t; //Unsigned integer 4 bytes +#else +typedef int Int_t; //Signed integer 4 bytes +typedef unsigned int UInt_t; //Unsigned integer 4 bytes +#endif +#ifdef R__B64 +typedef int Seek_t; //File pointer +typedef long Long_t; //Signed long integer 4 bytes +typedef unsigned long ULong_t; //Unsigned long integer 4 bytes +#else +typedef int Seek_t; //File pointer +typedef long Long_t; //Signed long integer 8 bytes +typedef unsigned long ULong_t; //Unsigned long integer 8 bytes +#endif +typedef float Float_t; //Float 4 bytes +typedef double Double_t; //Float 8 bytes +typedef char Text_t; //General string +typedef unsigned char Bool_t; //Boolean (0=false, 1=true) +typedef unsigned char Byte_t; //Byte (8 bits) +typedef short Version_t; //Class version identifier +typedef const char Option_t; //Option string +typedef int Ssiz_t; //String size +typedef float Real_t; //TVector and TMatrix element type + +typedef void (*VoidFuncPtr_t)(); //pointer to void function + + +//---- constants --------------------------------------------------------------- + +#ifndef NULL +#define NULL 0 +#endif + +const Bool_t kTRUE = 1; +const Bool_t kFALSE = 0; + +const Int_t kMaxInt = 2147483647; +const Int_t kMaxShort = 32767; +const size_t kBitsPerByte = 8; +const Ssiz_t kNPOS = ~(Ssiz_t)0; + + +//---- ClassDef macros --------------------------------------------------------- + + +#define ClassDef(name,id) + +#define ClassImp(name) +#endif //end of Rtypes + +#endif //end of root selection + +//---- Timms AliL3EventDataType from AliL3EventDataType.h + +union AliL3EventDataTypeRoot{ + ULong_t fID; + unsigned char fDescr[8]; +}; + +typedef union AliL3EventDataTypeRoot AliL3EventDataTypeRoot; + +#define ROOT_UNKNOWN_DATAID (((ULong_t)'UNKN')<<32 | 'OWN ') +#define ROOT_COMPOSITE_DATAID (((ULong_t)'COMP')<<32 | 'OSIT') +#define ROOT_ADCCOUNTS_DATAID (((ULong_t)'ADCC')<<32 | 'OUNT') +#define ROOT_ADCCOUNTS_UNPACKED_DATAID (((ULong_t)'ADCC')<<32 | 'NTUP') +#define ROOT_CLUSTERS_DATAID (((ULong_t)'CLUS')<<32 | 'TERS') +#define ROOT_SPACEPOINTS_DATAID (((ULong_t)'SPAC')<<32 | 'EPTS') +#define ROOT_VERTEXDATA_DATAID (((ULong_t)'VRTX')<<32 | 'DATA') +#define ROOT_TRACKSEGMENTS_DATAID (((ULong_t)'TRAC')<<32 | 'SEGS') +#define ROOT_SLICETRACKS_DATAID (((ULong_t)'SLCT')<<32 | 'RCKS') +#define ROOT_TRACKS_DATAID (((ULong_t)'TRAC')<<32 | 'KS ') +#define ROOT_NODELIST_DATAID (((ULong_t)'NODE')<<32 | 'LIST') +#define ROOT_EVENTTRIGGER_DATAID (((ULong_t)'EVTT')<<32 | 'RG ') + +#endif diff --git a/HLT/src/AliL3SpacePointData.h b/HLT/src/AliL3SpacePointData.h new file mode 100644 index 00000000000..0782815b787 --- /dev/null +++ b/HLT/src/AliL3SpacePointData.h @@ -0,0 +1,17 @@ +#ifndef SPACEPOINTDATA_H +#define SPACEPOINTDATA_H + +#include "AliL3RootTypes.h" +struct AliL3SpacePointData{ + Float_t fX; + Float_t fY; + Float_t fZ; + UInt_t fID; //contains slice patch and number + UChar_t fPadRow; + Float_t fXYErr; + Float_t fZErr; +}; +typedef struct AliL3SpacePointData AliL3SpacePointData; + + +#endif /* SPACEPOINTDATA_H */ diff --git a/HLT/src/AliL3Track.cxx b/HLT/src/AliL3Track.cxx new file mode 100644 index 00000000000..6638705051e --- /dev/null +++ b/HLT/src/AliL3Track.cxx @@ -0,0 +1,281 @@ +//Author: Anders Strand Vestbo +//Author: Uli Frankenfeld +//Last Modified: 06.03.2001 + +//____________________________________ +// AliL3Track +// +// Base track class for L3 + +//Changes: + +//14.03.01: Moved fHitNumbers from protected to private.-ASV +// Set memory to zero in ctor. +// Moved fNHits 2 private. Protected data members not a good idea after all. +//19.03.01: Made the method void Set(AliL3Track) virtual. + +#include "AliL3RootTypes.h" + +#include "AliL3Logging.h" +#include "AliL3Track.h" +#include + +ClassImp(AliL3Track) + +Float_t AliL3Track::BFACT = 0.0029980; +Float_t AliL3Track::bField = 0.2; +Double_t AliL3Track::pi=3.14159265358979323846; + +AliL3Track::AliL3Track() +{ + //Constructor + + fNHits = 0; + fMCid = -1; + fKappa=0; + fRadius=0; + fCenterX=0; + fCenterY=0; + ComesFromMainVertex(false); + fQ = 0; + fPhi0=0; + fPsi=0; + fR0=0; + fTanl=0; + fZ0=0; + fPt=0; + fLength=0; + fIsLocal=true; + fRowRange[0]=0; + fRowRange[1]=0; + memset(fHitNumbers,0,174*sizeof(UInt_t)); +} + +void AliL3Track::Set(AliL3Track *tpt){ + + SetRowRange(tpt->GetFirstRow(),tpt->GetLastRow()); + SetPhi0(tpt->GetPhi0()); + SetKappa(tpt->GetKappa()); + SetNHits(tpt->GetNHits()); + + SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ()); + + SetLastPoint(tpt->GetLastPointX(),tpt->GetLastPointY(),tpt->GetLastPointZ()); + SetPt(tpt->GetPt()); + SetPsi(tpt->GetPsi()); + SetTgl(tpt->GetTgl()); + SetCharge(tpt->GetCharge()); + + SetHits(tpt->GetNHits(),(UInt_t *)tpt->GetHitNumbers()); + +/* + fPhi0 = track->GetPhi0(); + fKappa = track->GetKappa(); + + fRowRange[0] = track->GetFirstRow(); + fRowRange[1] = track->GetLastRow(); + fQ = track->GetCharge(); + fFirstPoint[0] = track->GetFirstPointX(); + fFirstPoint[1] = track->GetFirstPointY(); + fFirstPoint[2] = track->GetFirstPointZ(); + fLastPoint[0] = track->GetLastPointX(); + fLastPoint[1] = track->GetLastPointY(); + fLastPoint[2] = track->GetLastPointZ(); + fPt = track->GetPt(); + fTanl = track->GetTgl(); + fPsi = track->GetPsi(); + fQ = track->GetCharge(); + fNHits = track->GetNHits(); + memcpy(fHitNumbers,track->GetHitNumbers(),fNHits*sizeof(UInt_t)); +*/ +} + + +AliL3Track::~AliL3Track() +{ + +} + +Double_t AliL3Track::GetP() const +{ + // Returns total momentum. + + return fabs(GetPt())*sqrt(1. + GetTgl()*GetTgl()); + +} + +Double_t AliL3Track::GetPseudoRapidity() const +{ + return 0.5 * log((GetP() + GetPz()) / (GetP() - GetPz())); +} + +Double_t AliL3Track::GetEta() const +{ + return GetPseudoRapidity(); +} + +Double_t AliL3Track::GetRapidity() const +{ + Double_t m_pi = 0.13957; + return 0.5 * log((m_pi + GetPz()) / (m_pi - GetPz())); +} + +void AliL3Track::CalculateHelix(){ + //Calculate Radius, CenterX and Centery from Psi, X0, Y0 + // + + fRadius = fPt / (BFACT*bField); + if(fRadius) fKappa = 1./fRadius; + else fRadius = 999999; //just zero + Double_t trackPhi0 = fPsi + fQ *0.5 * pi; + + fCenterX = fFirstPoint[0] - fRadius * cos(trackPhi0); + fCenterY = fFirstPoint[1] - fRadius * sin(trackPhi0); +} + +Bool_t AliL3Track::CalculateReferencePoint(Double_t angle){ + // Global coordinate: crossing point with y = ax+ b; a=tan(angle-Pi/2); + // + const Double_t rr=132; //position of referece plane + const Double_t xr = cos(angle) *rr; + const Double_t yr = sin(angle) *rr; + + Double_t a = tan(angle-pi/2); + Double_t b = yr - a * xr; + + Double_t pp=(fCenterX+a*fCenterY-a*b)/(1+pow(a,2)); + Double_t qq=(pow(fCenterX,2)+pow(fCenterY,2)-2*fCenterY*b+pow(b,2)-pow(fRadius,2))/(1+pow(a,2)); + + Double_t racine = pp*pp-qq; + if(racine<0) return IsPoint(kFALSE); //no Point + + Double_t rootRacine = sqrt(racine); + Double_t x0 = pp+rootRacine; + Double_t x1 = pp-rootRacine; + Double_t y0 = a*x0 + b; + Double_t y1 = a*x1 + b; + + Double_t diff0 = sqrt(pow(x0-xr,2)+pow(y0-yr,2)); + Double_t diff1 = sqrt(pow(x1-xr,2)+pow(y1-yr,2)); + + if(diff0pi){ + if(trackPhi0rmin&&r0rmin&&r1pi){ + if(trackPhi0pi){ + if(trackPhi0 + +#include "AliL3RootTypes.h" + +class AliL3Track { + + private: + + Int_t fNHits; + + Int_t fMCid; //Assigned id from MC data. + Double_t fKappa; // Curvature + Double_t fRadius; // Radius of the helix (projected to a circle) + Double_t fCenterX; // x coordinate of the center of the helix (projected to a circle) + Double_t fCenterY; // y coordinate of the center of the helix (projected to a circle) + Bool_t fFromMainVertex; // true if tracks origin is the main vertex, otherwise false + + Int_t fRowRange[2]; //Subsector where this track was build + Int_t fSector; //Sector # where this track was build + + //data from momentum fit + Int_t fQ; //charge measured fit + + //track parameters: + Double_t fPhi0; //azimuthal angle of the first point + Double_t fPsi; //azimuthal angle of the momentum + Double_t fR0; //radius of the first point + Double_t fTanl; //tan of dipangle at (r,phi,z) + Double_t fZ0; //z coordinate of the first point + Double_t fPt; //transverse momentum + Double_t fLength; + + Double_t fPterr; + Double_t fPsierr; + Double_t fZ0err; + Double_t fTanlerr; + + Double_t fFirstPoint[3]; + Double_t fLastPoint[3]; + Double_t fPoint[3]; + Double_t fPointPsi; //azimuthal angle of the momentum at Point + Bool_t fIsPoint; //Helix crosses the X-plane + Bool_t IsPoint(Bool_t ispoint) {fIsPoint = ispoint;return fIsPoint;} + + Bool_t fIsLocal; //Track given in local coordinates. + + UInt_t fHitNumbers[174]; //Array of hit numbers for this track + + protected: + + static Float_t BFACT; + static Float_t bField; + static Double_t pi; + + public: + + AliL3Track(); + virtual ~AliL3Track(); + + virtual void Set(AliL3Track* track); + + Bool_t CalculateReferencePoint(Double_t angle);//Calculate Reference Point + Bool_t CalculateEdgePoint(Double_t angle);//Calculate crossing point with line + Bool_t CalculatePoint(Double_t xplane);//Calculate crossing point with X-plane + Bool_t IsPoint() {return fIsPoint;} + void CalculateHelix(); + Double_t GetDistance(Double_t x0,Double_t x1){return 0;} + + Bool_t IsLocal() {return fIsLocal;} + + // getter + Double_t GetFirstPointX() {return fFirstPoint[0];} + Double_t GetFirstPointY() {return fFirstPoint[1];} + Double_t GetFirstPointZ() {return fFirstPoint[2];} + Double_t GetLastPointX() {return fLastPoint[0];} + Double_t GetLastPointY() {return fLastPoint[1];} + Double_t GetLastPointZ() {return fLastPoint[2];} + + Double_t GetPointPsi() {return fPointPsi;} + Double_t GetPointX() {return fPoint[0];} + Double_t GetPointY() {return fPoint[1];} + Double_t GetPointZ() {return fPoint[2];} + + Double_t GetPt() const {return fPt;} + Double_t GetTgl() const {return fTanl;} + Double_t GetPhi0() const {return fPhi0;} + Double_t GetPsi() const {return fPsi;} + Double_t GetR0() const {return fR0;} + Double_t GetZ0() const {return fZ0;} + + Double_t GetKappa() const { return fKappa;} + Double_t GetRadius() const { return fRadius;} + Double_t GetCenterX() const { return fCenterX;} + Double_t GetCenterY() const { return fCenterY;} + + Int_t GetNHits() {return fNHits;} + Int_t GetNumberOfPoints() const {return fNHits;} + Bool_t ComesFromMainVertex() const { return fFromMainVertex;} + + Double_t GetPx() const { return fPt*cos(fPsi);} + Double_t GetPy() const { return fPt*sin(fPsi);} + Double_t GetPz() const { return fPt*fTanl;} + + Double_t GetP() const; + Double_t GetPseudoRapidity() const; + Double_t GetEta() const; + Double_t GetRapidity() const; + + Int_t GetCharge() const { return fQ;} + Int_t GetMCid() const {return fMCid;} + Double_t GetLength() const {return fLength;} + + Int_t GetFirstRow() const {return fRowRange[0];} + Int_t GetLastRow() const {return fRowRange[1];} + + UInt_t *GetHitNumbers() {return fHitNumbers;} + + // setter + void SetMCid(Int_t f) {fMCid = f;} + void SetFirstPoint(Double_t f,Double_t g,Double_t h) {fFirstPoint[0]=f; fFirstPoint[1]=g; fFirstPoint[2]=h;} + void SetLastPoint(Double_t f,Double_t g,Double_t h) {fLastPoint[0]=f; fLastPoint[1]=g; fLastPoint[2]=h;} + + void SetHits(Int_t nhits,UInt_t *hits) {memcpy(fHitNumbers,hits,nhits*sizeof(UInt_t));} + + void SetPhi0(Double_t f) {fPhi0 = f;} + void SetPsi(Double_t f) {fPsi = f;} + void SetR0(Double_t f) {fR0 = f;} + void SetTgl(Double_t f) {fTanl =f;} + void SetZ0(Double_t f) {fZ0 = f;} + void SetPt(Double_t f) {fPt = f;} + void SetLength(Double_t f) {fLength = f;} + void SetPterr(Double_t f) {fPterr = f;} + void SetPsierr(Double_t f) {fPsierr = f;} + void SetZ0err(Double_t f) {fZ0err = f;} + void SetTglerr(Double_t f) {fTanlerr = f;} + void SetKappa(Double_t f) {fKappa = f;} + + void SetNHits(Int_t f) {fNHits = f;} + + void SetRowRange(Int_t f,Int_t g) {fRowRange[0]=f; fRowRange[1]=g;} + void SetSector(Int_t f) {fSector = f;} + + void SetRadius(Double_t f) { fRadius = f; } + void SetCenterX(Double_t f) { fCenterX = f; } + void SetCenterY(Double_t f) { fCenterY = f; } + + void SetCharge(Int_t f) { fQ = f; } + + void ComesFromMainVertex(Bool_t f) { fFromMainVertex = f; } + + ClassDef(AliL3Track,1) //Conformal mapping track class +}; + +#endif + diff --git a/HLT/src/AliL3TrackArray.cxx b/HLT/src/AliL3TrackArray.cxx new file mode 100644 index 00000000000..72488ae1f6b --- /dev/null +++ b/HLT/src/AliL3TrackArray.cxx @@ -0,0 +1,405 @@ +//Author: Uli Frankenfeld +//Last Modified: 06.12.2000 + +#include +#include +#include +#include "AliL3Logging.h" +#include "AliL3TrackArray.h" +#include "AliL3HoughTrack.h" +#include "AliL3ConfMapTrack.h" +#include "AliL3TrackSegmentData.h" +#include "AliL3Transform.h" +#include "AliL3ConfMapPoint.h" +//_____________________________________________________________ +// +// The L3 TrackArray +// + +ClassImp(AliL3TrackArray) + +AliL3TrackArray::AliL3TrackArray(){ + //Default constructor + fSize = 0; + fNTracks=0; + fNAbsent=0; + fTrackType='t'; + SetSize(); +} + + +AliL3TrackArray::AliL3TrackArray(Int_t ntrack){ + //Constructor. + fSize = 0; + fNTracks=0; + fNAbsent=0; + fTrackType='t'; + SetSize(ntrack); +} + +AliL3TrackArray::AliL3TrackArray(char* tracktype,Int_t ntrack){ + //Constructor. + fSize = 0; + fNTracks=0; + fNAbsent=0; + if(strcmp(tracktype,"AliL3Track")==0) fTrackType='t'; + if(strcmp(tracktype,"AliL3ConfMapTrack")==0) fTrackType='c'; + if(strcmp(tracktype,"AliL3HoughTrack")==0) fTrackType='h'; + SetSize(ntrack); +} + +AliL3TrackArray::AliL3TrackArray(char* tracktype){ + //Constructor. + fSize = 0; + fNTracks=0; + fNAbsent=0; + if(strcmp(tracktype,"AliL3Track")==0) fTrackType='t'; + if(strcmp(tracktype,"AliL3ConfMapTrack")==0) fTrackType='c'; + if(strcmp(tracktype,"AliL3HoughTrack")==0) fTrackType='h'; + SetSize(); +} + + +AliL3TrackArray::~AliL3TrackArray(){ + //Destructor + DeleteArray(); +} + + +AliL3Track *AliL3TrackArray::NextTrack(){ + if(fNTracksSetPt(trs->fPt); + track->SetPsi(trs->fPsi); + track->SetTgl(trs->fTgl); + track->SetNHits(trs->fNPoints); + track->SetCharge(trs->fCharge); + track->SetFirstPoint(trs->fX,trs->fY,trs->fZ); + track->SetLastPoint(trs->fLastX,trs->fLastY,trs->fLastZ); + track->SetHits( trs->fNPoints, trs->fPointIDs ); + UChar_t *tmpP = (UChar_t*)trs; + tmpP += sizeof(AliL3TrackSegmentData)+trs->fNPoints*sizeof(UInt_t); + trs = (AliL3TrackSegmentData*)tmpP; + } +} + +void AliL3TrackArray::FillTracks(Int_t ntracks, AliL3TrackSegmentData* tr,Int_t slice, AliL3Transform* trans){ + //Read tracks from shared memory (or memory) + AliL3TrackSegmentData *trs = tr; + for(Int_t i=0; iSetPt(trs->fPt); + Float_t psi[1]; + psi[0]=trs->fPsi; + trans->Local2GlobalAngle(psi,slice); + track->SetPsi(psi[0]); + track->SetTgl(trs->fTgl); + track->SetNHits(trs->fNPoints); + track->SetCharge(trs->fCharge); + Float_t first[3]; + first[0]=trs->fX;first[1]=trs->fY;first[2]=trs->fZ; + trans->Local2Global(first,slice); + track->SetFirstPoint(first[0],first[1],first[2]); + Float_t last[3]; + last[0]=trs->fLastX;last[1]=trs->fLastY;last[2]=trs->fLastZ; + trans->Local2Global(last,slice); + track->SetLastPoint(last[0],last[1],last[2]); + track->SetHits( trs->fNPoints, trs->fPointIDs ); + UChar_t *tmpP = (UChar_t*)trs; + tmpP += sizeof(AliL3TrackSegmentData)+trs->fNPoints*sizeof(UInt_t); + trs = (AliL3TrackSegmentData*)tmpP; + } +} + +UInt_t AliL3TrackArray::GetOutSize(){ + UInt_t count = GetOutCount(); //use only present tracks + UInt_t tHits = 0; + for(Int_t i=0;iGetNHits(); + } + + //calculate size of track + return count*sizeof(AliL3TrackSegmentData)+sizeof(UInt_t)*tHits; +} + +UInt_t AliL3TrackArray::WriteTracks(UInt_t & ntracks,AliL3TrackSegmentData* tr){ + ntracks = GetOutCount(); + return WriteTracks(tr); +} + +UInt_t AliL3TrackArray::WriteTracks(AliL3TrackSegmentData* tr){ + if(GetTrackType()=='c') return WriteConfMapTracks(tr); + AliL3TrackSegmentData *tP = tr; + UInt_t *pP; + UInt_t size = 0; + for(Int_t i=0; ifX = track->GetFirstPointX(); + tP->fY = track->GetFirstPointY(); + tP->fZ = track->GetFirstPointZ(); + tP->fPt = track->GetPt(); + tP->fLastX = track->GetLastPointX(); + tP->fLastY = track->GetLastPointY(); + tP->fLastZ = track->GetLastPointZ(); + tP->fPsi = track->GetPsi(); + tP->fTgl = track->GetTgl(); + tP->fCharge = track->GetCharge(); + tP->fNPoints = track->GetNHits(); + pP = (UInt_t*)track->GetHitNumbers(); + for (UInt_t j=0;jfNPoints;j++){ + tP->fPointIDs[j] = pP[j]; + } + Byte_t *tmpP = (Byte_t *)tP; + tmpP += sizeof(AliL3TrackSegmentData)+tP->fNPoints*sizeof(UInt_t); + size += sizeof(AliL3TrackSegmentData)+tP->fNPoints*sizeof(UInt_t); + tP = (AliL3TrackSegmentData*)tmpP; + } + return size; +} + +UInt_t AliL3TrackArray::WriteConfMapTracks(AliL3TrackSegmentData* tr){ + // use first and last point objects + AliL3TrackSegmentData *tP = tr; + UInt_t *pP; + UInt_t size = 0; + for(Int_t i=0; ilastHit; + AliL3ConfMapPoint *lastHit = (AliL3ConfMapPoint*)track->firstHit; + tP->fX = hit->GetX(); + tP->fY = hit->GetY(); + tP->fZ = hit->GetZ(); + tP->fLastX = lastHit->GetX(); + tP->fLastY = lastHit->GetY(); + tP->fLastZ = lastHit->GetZ(); + +// tP->fX = track->GetFirstPointX(); +// tP->fY = track->GetFirstPointY(); +// tP->fZ = track->GetFirstPointZ(); + tP->fPt = track->GetPt(); +// tP->fLastX = track->GetLastPointX(); +// tP->fLastY = track->GetLastPointY(); +// tP->fLastZ = track->GetLastPointZ(); + tP->fPsi = track->GetPsi(); + tP->fTgl = track->GetTgl(); + tP->fCharge = track->GetCharge(); + tP->fNPoints = track->GetNHits(); + pP = (UInt_t*)track->GetHitNumbers(); + for (UInt_t j=0;jfNPoints;j++){ + tP->fPointIDs[j] = pP[j]; + } + Byte_t *tmpP = (Byte_t *)tP; + tmpP += sizeof(AliL3TrackSegmentData)+tP->fNPoints*sizeof(UInt_t); + size +=sizeof(AliL3TrackSegmentData)+tP->fNPoints*sizeof(UInt_t); + tP = (AliL3TrackSegmentData*)tmpP; + } + return size; +} + +void AliL3TrackArray::AddTracks(AliL3TrackArray *newtrack){ + if(GetTrackType() != newtrack->GetTrackType()) + return; + if(fSize < fNTracks+newtrack->GetNPresent()) + SetSize(fSize+newtrack->GetSize()); + for(Int_t i =0;iGetNTracks();i++){ + AliL3Track *tpt = newtrack->GetCheckedTrack(i); + if(!tpt) continue; + newtrack->Remove(i); + AliL3Track *track = NextTrack(); + track->SetNHits(tpt->GetNHits()); + track->SetHits(tpt->GetNHits(),(UInt_t *)tpt->GetHitNumbers()); + track->SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ()); + track->SetLastPoint(tpt->GetLastPointX(),tpt->GetLastPointY(),tpt->GetLastPointZ()); + track->SetPt(tpt->GetPt()); + track->SetPsi(tpt->GetPsi()); + track->SetTgl(tpt->GetTgl()); + track->SetCharge(tpt->GetCharge()); + } +} + + +void AliL3TrackArray::Compress(){ + if(GetNPresent()==GetNTracks()) return; + AliL3Track **tmp = new AliL3Track *[fNTracks]; + Int_t present=0; + Int_t absent=GetNPresent(); + for(Int_t i=0;i 1) { + i = first; + j = last; + for (;;) { + while (++i < last && TrackCompare(a[i], a[first]) < 0) + ; + while (--j > first && TrackCompare(a[j], a[first]) > 0) + ; + if (i >= j) + break; + + tmp = a[i]; + a[i] = a[j]; + a[j] = tmp; + } + if (j == first) { + ++first; + continue; + } + tmp = a[first]; + a[first] = a[j]; + a[j] = tmp; + if (j - first < last - (j + 1)) { + QSort(a, first, j); + first = j + 1; // QSort(j + 1, last); + } else { + QSort(a, j + 1, last); + last = j; // QSort(first, j); + } + } +} + +Int_t AliL3TrackArray::TrackCompare(AliL3Track *a, AliL3Track *b){ + // Compare the two tracks. + + if(a->GetNHits() < b->GetNHits()) return 1; + if(a->GetNHits() > b->GetNHits()) return -1; + return 0; +} + + diff --git a/HLT/src/AliL3TrackArray.h b/HLT/src/AliL3TrackArray.h new file mode 100644 index 00000000000..3876c3f2711 --- /dev/null +++ b/HLT/src/AliL3TrackArray.h @@ -0,0 +1,62 @@ +#ifndef ALIL3TRACKARRAY_H +#define ALIL3TRACKARRAY_H + +#include "AliL3RootTypes.h" +class AliL3ConfMapTrack; +class AliL3Track; +class AliL3TrackSegmentData; +class AliL3Transform; + +class AliL3TrackArray{ + private: + void DeleteArray(); + + Char_t fTrackType; + Int_t fSize; + Bool_t *fIsPresent;//! + Int_t fNAbsent; + + AliL3Track **fTrack;//! + Int_t fNTracks; + + UInt_t WriteConfMapTracks(AliL3TrackSegmentData* tr); + + public: + AliL3TrackArray(); + AliL3TrackArray(Int_t ntrack); + AliL3TrackArray(char* tracktype,Int_t ntrack); + AliL3TrackArray(char* tracktype); + virtual ~AliL3TrackArray(); + Int_t GetTrackType(){return fTrackType;} + Int_t GetSize(){return fSize;} + Bool_t SetSize(Int_t newsize=2000); + + Int_t GetNPresent(){return (fNTracks- fNAbsent);} + + Int_t GetNTracks(){return fNTracks;} + AliL3Track *NextTrack(); + AliL3Track *GetCheckedTrack(Int_t t){if(fIsPresent[t]) return fTrack[t]; return 0;} + AliL3Track *GetTrack(Int_t t){return fTrack[t];} + + void Remove(Int_t track); + void RemoveLast() {fNTracks--;} + void Compress(); + void Reset(); + void QSort(); + void QSort( AliL3Track **a, Int_t first, Int_t last); + Int_t TrackCompare(AliL3Track *a, AliL3Track *b); + + + void FillTracks(Int_t ntracks, AliL3TrackSegmentData* tr,Int_t slice, + AliL3Transform* trans); //Fill tracks and transform + void FillTracks(Int_t ntracks, AliL3TrackSegmentData* tr); //Fill tracks + UInt_t WriteTracks(AliL3TrackSegmentData* tr); //Write tracks + UInt_t WriteTracks(UInt_t & ntracks,AliL3TrackSegmentData* tr); //Write tracks + UInt_t GetOutSize(); + UInt_t GetOutCount(){return (UInt_t) GetNPresent();} + void AddTracks(AliL3TrackArray *newtrack);//add all Tracks to this + + ClassDef(AliL3TrackArray,1) +}; + +#endif diff --git a/HLT/src/AliL3TrackMerger.cxx b/HLT/src/AliL3TrackMerger.cxx new file mode 100644 index 00000000000..54bf977447b --- /dev/null +++ b/HLT/src/AliL3TrackMerger.cxx @@ -0,0 +1,280 @@ + +//Author: Uli Frankenfeld +//Last Modified: 06.12.2000 + +#include +#include +#include "AliL3Logging.h" +#include "AliL3TrackMerger.h" +#include "AliL3Track.h" +#include "AliL3TrackSegmentData.h" +#include "AliL3Transform.h" +#include "AliL3TrackArray.h" + +//_____________________________________________________________ +// +// The L3 track segment merger +// + +ClassImp(AliL3TrackMerger) + +AliL3TrackMerger::AliL3TrackMerger(){ + //Default constructor + Is2Global(kFALSE); + fSlow = kFALSE; + SetParameter(); +// fRowMin = 0; +// fRowMax = 0; +} + + +AliL3TrackMerger::AliL3TrackMerger(Int_t nsubsectors):AliL3Merger(nsubsectors){ + //Constructor. + fNSubSector = nsubsectors; + Is2Global(kFALSE); + fSlow = kFALSE; + SetParameter(); + //fRowMin = new Int_t(nsubsectors); + //fRowMax = new Int_t(nsubsectors); +} + +AliL3TrackMerger::~AliL3TrackMerger(){ + //Destructor +} + +void AliL3TrackMerger::SetRows(Int_t *row){ + for(Int_t i =0;iGetNTracks(); + const Int_t kNIn =tracksin->GetNTracks(); + const Int_t kNMerged =mergedtrack->GetNTracks(); + AliL3Track *tracks[2]; + Bool_t merge = kTRUE; + while(merge){ + Int_t inmin=-1,outmin=-1; + Double_t min=10; + for(Int_t out=0;outGetCheckedTrack(out); + if(!outertrack) continue; + for(Int_t in=0;inGetCheckedTrack(in); + if(!innertrack) continue; + Double_t diff = TrackDiff(innertrack,outertrack); + if(diff>=0&&diff=0&&outmin>=0){ + AliL3Track *outertrack=tracksout->GetTrack(outmin); + AliL3Track *innertrack=tracksin->GetTrack(inmin); + tracks[0]=innertrack; + tracks[1]=outertrack; + SortTracks(tracks,2); + MultiMerge(mergedtrack,tracks,2); + outertrack->CalculatePoint(xval); + innertrack->CalculatePoint(xval); + PrintDiff(innertrack,outertrack); + FillNtuple(ntuple,innertrack,outertrack); + tracksout->Remove(outmin); + tracksin->Remove(inmin); +// tracksout->Compress(); +// tracksin->Compress(); + } + else merge = kFALSE; + } + LOG(AliL3Log::kInformational,"AliL3TrackMerger::SlowMerge","Result") + <GetNTracks()-kNMerged<Row2X((fRowMax[patch]+fRowMin[patch])/2); + Int_t nrow= fRowMax[patch]-fRowMin[patch]+1; + const Int_t kNIn =tracks->GetNTracks(); + AliL3Track *tr[2]; + for(Int_t in=0;inGetCheckedTrack(in); + if(t){ + t->CalculateHelix(); + t->CalculatePoint(xval); + } + } + for(Int_t out=0;outGetCheckedTrack(out); + if(!outertrack) continue; + for(Int_t in=0;inGetCheckedTrack(in); + if(!innertrack) continue; + if(outertrack->GetNHits()+innertrack->GetNHits()>nrow) continue; + + if(IsTrack(innertrack,outertrack)){ + tr[0]=innertrack; + tr[1]=outertrack; + SortTracks(tr,2); + if(tr[0]->GetLastPointX()GetFirstPointX()){ + MultiMerge(tracks,tr,2); + tracks->Remove(out); + tracks->Remove(in); + break; + } + } + } + } + Int_t nmerged = tracks->GetNTracks()-kNIn; + LOG(AliL3Log::kInformational,"AliL3TrackMerger::InterMerge","Result") + <AddTracks(GetInTracks(0)); + LOG(AliL3Log::kInformational,"AliL3TrackMerger::Merge","Result") + <GetNPresent() + <=0;i--){ + AliL3TrackArray *tout = GetOutTracks(); + if(i==subsec) tout = GetInTracks(subsec+1); + AliL3TrackArray *tin = GetInTracks(i); + Double_t xval = fTransformer->Row2X(fRowMax[i]); + Double_t xmax = fTransformer->Row2X(fRowMax[i+1]); + Double_t ymax = xval*tan(edge0); + for(Int_t out=0;outGetNTracks();out++){ + AliL3Track *outtrack=tout->GetCheckedTrack(out); + if(!outtrack) continue; + outtrack->CalculateHelix(); + outtrack->CalculatePoint(xval); + if(outtrack->IsPoint()&&fabs(outtrack->GetPointY())>ymax){ + if(outtrack->GetNHits()<10) + tout->Remove(out); + } + } +// tout->Compress(); + for(Int_t in=0;inGetNTracks();in++){ + AliL3Track *intrack=(AliL3Track*)tin->GetTrack(in); + intrack->CalculateHelix(); + intrack->CalculatePoint(xval); + } + tin->QSort(); + tout->QSort(); + + if(fSlow) SlowMerge(ttt,tin,tout,xval); + else Merge(ttt,tin,tout); + for(Int_t in=0;inGetNTracks();in++){ + AliL3Track *intrack=(AliL3Track*)tin->GetCheckedTrack(in); + if(!intrack) continue; + if(intrack->CalculateEdgePoint(edge0)){ + if(intrack->GetPointX()Remove(in); + } + } + else if(intrack->CalculateEdgePoint(edge1)){ + if(intrack->GetPointX()Remove(in); + } + } + } +/* + for(Int_t in=0;inGetNTracks();in++){ + AliL3Track *intrack=(AliL3Track*)tin->GetCheckedTrack(in); + if(!intrack) continue; + if(intrack->GetNHits()<10) continue; + AddTrack(ttt,intrack); + tin->Remove(in); + } +*/ + } // end subsector loop + LOG(AliL3Log::kInformational,"AliL3TrackMerger::Merge","Result") + <GetNPresent() + <GetNTracks(); + const Int_t kNIn =tracksin->GetNTracks(); + const Int_t kNMerged =mergedtrack->GetNTracks(); + + Bool_t *ismatchedin = new Bool_t[kNIn]; + for(Int_t in =0;inGetCheckedTrack(out); + if(!outertrack) continue; + for(Int_t in =0;inGetCheckedTrack(in); + if(!innertrack) continue; + if(outertrack==innertrack) continue; + if(outertrack->GetCharge()!=innertrack->GetCharge()) continue; + if(IsTrack(innertrack,outertrack)){ + tracks[0]=innertrack; tracks[1]=outertrack; + SortTracks(tracks,2); + if(tracks[0]->GetLastPointX()GetFirstPointX()){ + MultiMerge(mergedtrack,tracks,2); + tracksout->Remove(out); + tracksin->Remove(in); + ismatchedin[in]=kTRUE; + ismatchedout[out]=kTRUE; + break; + } + } + } + } + + Int_t nmerged = mergedtrack->GetNTracks()-kNMerged; + LOG(AliL3Log::kInformational,"AliL3TrackMerger::Merge","Result") + < +#include +//___________________________ +// AliL3Transform +// +// Transformation class for ALICE TPC. + +ClassImp(AliL3Transform); + + +AliL3Transform::AliL3Transform(){ + //constructor + Init(); +} + + +AliL3Transform::~AliL3Transform(){ +} + +void AliL3Transform::Init(){ + //sector: + fNTimeBins = 512; //?uli + fNRowLow = 55; + fNRowUp = 119; + fNSectorLow = 36; + fNSectorUp = 36; + fNSector = 72; + fPadPitchWidthLow = 0.400000; + fPadPitchWidthUp = 0.600000; + fZWidth = 0.56599998474121093750; + fZSigma = 0.22880849748219134199; + + //slices: + fNSlice = 36; + fNRow = 174; + fPi = 3.14159265358979323846; + for(Int_t i=0;i<36;i++){ + fCos[i] = cos(fPi/9*i); + fSin[i] = sin(fPi/9*i); + } + + fX[0] = 88.850006103515625; + fX[1] = 89.600006103515625; + fX[2] = 90.350006103515625; + fX[3] = 91.100006103515625; + fX[4] = 91.850006103515625; + fX[5] = 92.600006103515625; + fX[6] = 93.350006103515625; + fX[7] = 94.100006103515625; + fX[8] = 94.850006103515625; + fX[9] = 95.600006103515625; + fX[10] = 96.350006103515625; + fX[11] = 97.100006103515625; + fX[12] = 97.850006103515625; + fX[13] = 98.600006103515625; + fX[14] = 99.350006103515625; + fX[15] = 100.100006103515625; + fX[16] = 100.850006103515625; + fX[17] = 101.600006103515625; + fX[18] = 102.350006103515625; + fX[19] = 103.100006103515625; + fX[20] = 103.850006103515625; + fX[21] = 104.600006103515625; + fX[22] = 105.350006103515625; + fX[23] = 106.100006103515625; + fX[24] = 106.850006103515625; + fX[25] = 107.600006103515625; + fX[26] = 108.350006103515625; + fX[27] = 109.100006103515625; + fX[28] = 109.850006103515625; + fX[29] = 110.600006103515625; + fX[30] = 111.350006103515625; + fX[31] = 112.100006103515625; + fX[32] = 112.850006103515625; + fX[33] = 113.600006103515625; + fX[34] = 114.350006103515625; + fX[35] = 115.100006103515625; + fX[36] = 115.850006103515625; + fX[37] = 116.600006103515625; + fX[38] = 117.350006103515625; + fX[39] = 118.100006103515625; + fX[40] = 118.850006103515625; + fX[41] = 119.600006103515625; + fX[42] = 120.350006103515625; + fX[43] = 121.100006103515625; + fX[44] = 121.850006103515625; + fX[45] = 122.600006103515625; + fX[46] = 123.350006103515625; + fX[47] = 124.100006103515625; + fX[48] = 124.850006103515625; + fX[49] = 125.600006103515625; + fX[50] = 126.350006103515625; + fX[51] = 127.100006103515625; + fX[52] = 127.850006103515625; + fX[53] = 128.600006103515625; + fX[54] = 129.350006103515625; + fX[55] = 132.574996948242188; + fX[56] = 133.574996948242188; + fX[57] = 134.574996948242188; + fX[58] = 135.574996948242188; + fX[59] = 136.574996948242188; + fX[60] = 137.574996948242188; + fX[61] = 138.574996948242188; + fX[62] = 139.574996948242188; + fX[63] = 140.574996948242188; + fX[64] = 141.574996948242188; + fX[65] = 142.574996948242188; + fX[66] = 143.574996948242188; + fX[67] = 144.574996948242188; + fX[68] = 145.574996948242188; + fX[69] = 146.574996948242188; + fX[70] = 147.574996948242188; + fX[71] = 148.574996948242188; + fX[72] = 149.574996948242188; + fX[73] = 150.574996948242188; + fX[74] = 151.574996948242188; + fX[75] = 152.574996948242188; + fX[76] = 153.574996948242188; + fX[77] = 154.574996948242188; + fX[78] = 155.574996948242188; + fX[79] = 156.574996948242188; + fX[80] = 157.574996948242188; + fX[81] = 158.574996948242188; + fX[82] = 159.574996948242188; + fX[83] = 160.574996948242188; + fX[84] = 161.574996948242188; + fX[85] = 162.574996948242188; + fX[86] = 163.574996948242188; + fX[87] = 164.574996948242188; + fX[88] = 165.574996948242188; + fX[89] = 166.574996948242188; + fX[90] = 167.574996948242188; + fX[91] = 168.574996948242188; + fX[92] = 169.574996948242188; + fX[93] = 170.574996948242188; + fX[94] = 171.574996948242188; + fX[95] = 172.574996948242188; + fX[96] = 173.574996948242188; + fX[97] = 174.574996948242188; + fX[98] = 175.574996948242188; + fX[99] = 176.574996948242188; + fX[100] = 177.574996948242188; + fX[101] = 178.574996948242188; + fX[102] = 179.574996948242188; + fX[103] = 180.574996948242188; + fX[104] = 181.574996948242188; + fX[105] = 182.574996948242188; + fX[106] = 183.574996948242188; + fX[107] = 184.574996948242188; + fX[108] = 185.574996948242188; + fX[109] = 186.574996948242188; + fX[110] = 187.574996948242188; + fX[111] = 188.574996948242188; + fX[112] = 189.574996948242188; + fX[113] = 190.574996948242188; + fX[114] = 191.574996948242188; + fX[115] = 192.574996948242188; + fX[116] = 193.574996948242188; + fX[117] = 194.574996948242188; + fX[118] = 195.574996948242188; + fX[119] = 196.574996948242188; + fX[120] = 197.574996948242188; + fX[121] = 198.574996948242188; + fX[122] = 199.574996948242188; + fX[123] = 200.574996948242188; + fX[124] = 201.574996948242188; + fX[125] = 202.574996948242188; + fX[126] = 203.574996948242188; + fX[127] = 204.574996948242188; + fX[128] = 205.574996948242188; + fX[129] = 206.574996948242188; + fX[130] = 207.574996948242188; + fX[131] = 208.574996948242188; + fX[132] = 209.574996948242188; + fX[133] = 210.574996948242188; + fX[134] = 211.574996948242188; + fX[135] = 212.574996948242188; + fX[136] = 213.574996948242188; + fX[137] = 214.574996948242188; + fX[138] = 215.574996948242188; + fX[139] = 216.574996948242188; + fX[140] = 217.574996948242188; + fX[141] = 218.574996948242188; + fX[142] = 219.574996948242188; + fX[143] = 220.574996948242188; + fX[144] = 221.574996948242188; + fX[145] = 222.574996948242188; + fX[146] = 223.574996948242188; + fX[147] = 224.574996948242188; + fX[148] = 225.574996948242188; + fX[149] = 226.574996948242188; + fX[150] = 227.574996948242188; + fX[151] = 228.574996948242188; + fX[152] = 229.574996948242188; + fX[153] = 230.574996948242188; + fX[154] = 231.574996948242188; + fX[155] = 232.574996948242188; + fX[156] = 233.574996948242188; + fX[157] = 234.574996948242188; + fX[158] = 235.574996948242188; + fX[159] = 236.574996948242188; + fX[160] = 237.574996948242188; + fX[161] = 238.574996948242188; + fX[162] = 239.574996948242188; + fX[163] = 240.574996948242188; + fX[164] = 241.574996948242188; + fX[165] = 242.574996948242188; + fX[166] = 243.574996948242188; + fX[167] = 244.574996948242188; + fX[168] = 245.574996948242188; + fX[169] = 246.574996948242188; + fX[170] = 247.574996948242188; + fX[171] = 248.574996948242188; + fX[172] = 249.574996948242188; + fX[173] = 250.574996948242188; + fNPads[0] = 71; + fNPads[1] = 71; + fNPads[2] = 71; + fNPads[3] = 73; + fNPads[4] = 73; + fNPads[5] = 73; + fNPads[6] = 75; + fNPads[7] = 75; + fNPads[8] = 75; + fNPads[9] = 77; + fNPads[10] = 77; + fNPads[11] = 77; + fNPads[12] = 79; + fNPads[13] = 79; + fNPads[14] = 79; + fNPads[15] = 81; + fNPads[16] = 81; + fNPads[17] = 81; + fNPads[18] = 83; + fNPads[19] = 83; + fNPads[20] = 83; + fNPads[21] = 85; + fNPads[22] = 85; + fNPads[23] = 85; + fNPads[24] = 87; + fNPads[25] = 87; + fNPads[26] = 87; + fNPads[27] = 89; + fNPads[28] = 89; + fNPads[29] = 89; + fNPads[30] = 89; + fNPads[31] = 91; + fNPads[32] = 91; + fNPads[33] = 91; + fNPads[34] = 93; + fNPads[35] = 93; + fNPads[36] = 93; + fNPads[37] = 95; + fNPads[38] = 95; + fNPads[39] = 95; + fNPads[40] = 97; + fNPads[41] = 97; + fNPads[42] = 97; + fNPads[43] = 99; + fNPads[44] = 99; + fNPads[45] = 99; + fNPads[46] = 101; + fNPads[47] = 101; + fNPads[48] = 101; + fNPads[49] = 103; + fNPads[50] = 103; + fNPads[51] = 103; + fNPads[52] = 105; + fNPads[53] = 105; + fNPads[54] = 105; + fNPads[55] = 73; + fNPads[56] = 73; + fNPads[57] = 73; + fNPads[58] = 75; + fNPads[59] = 75; + fNPads[60] = 75; + fNPads[61] = 75; + fNPads[62] = 77; + fNPads[63] = 77; + fNPads[64] = 77; + fNPads[65] = 79; + fNPads[66] = 79; + fNPads[67] = 79; + fNPads[68] = 81; + fNPads[69] = 81; + fNPads[70] = 81; + fNPads[71] = 81; + fNPads[72] = 83; + fNPads[73] = 83; + fNPads[74] = 83; + fNPads[75] = 85; + fNPads[76] = 85; + fNPads[77] = 85; + fNPads[78] = 85; + fNPads[79] = 87; + fNPads[80] = 87; + fNPads[81] = 87; + fNPads[82] = 89; + fNPads[83] = 89; + fNPads[84] = 89; + fNPads[85] = 91; + fNPads[86] = 91; + fNPads[87] = 91; + fNPads[88] = 91; + fNPads[89] = 93; + fNPads[90] = 93; + fNPads[91] = 93; + fNPads[92] = 95; + fNPads[93] = 95; + fNPads[94] = 95; + fNPads[95] = 95; + fNPads[96] = 97; + fNPads[97] = 97; + fNPads[98] = 97; + fNPads[99] = 99; + fNPads[100] = 99; + fNPads[101] = 99; + fNPads[102] = 101; + fNPads[103] = 101; + fNPads[104] = 101; + fNPads[105] = 101; + fNPads[106] = 103; + fNPads[107] = 103; + fNPads[108] = 103; + fNPads[109] = 105; + fNPads[110] = 105; + fNPads[111] = 105; + fNPads[112] = 105; + fNPads[113] = 107; + fNPads[114] = 107; + fNPads[115] = 107; + fNPads[116] = 109; + fNPads[117] = 109; + fNPads[118] = 109; + fNPads[119] = 111; + fNPads[120] = 111; + fNPads[121] = 111; + fNPads[122] = 111; + fNPads[123] = 113; + fNPads[124] = 113; + fNPads[125] = 113; + fNPads[126] = 115; + fNPads[127] = 115; + fNPads[128] = 115; + fNPads[129] = 115; + fNPads[130] = 117; + fNPads[131] = 117; + fNPads[132] = 117; + fNPads[133] = 119; + fNPads[134] = 119; + fNPads[135] = 119; + fNPads[136] = 121; + fNPads[137] = 121; + fNPads[138] = 121; + fNPads[139] = 121; + fNPads[140] = 123; + fNPads[141] = 123; + fNPads[142] = 123; + fNPads[143] = 125; + fNPads[144] = 125; + fNPads[145] = 125; + fNPads[146] = 125; + fNPads[147] = 127; + fNPads[148] = 127; + fNPads[149] = 127; + fNPads[150] = 129; + fNPads[151] = 129; + fNPads[152] = 129; + fNPads[153] = 129; + fNPads[154] = 131; + fNPads[155] = 131; + fNPads[156] = 131; + fNPads[157] = 133; + fNPads[158] = 133; + fNPads[159] = 133; + fNPads[160] = 135; + fNPads[161] = 135; + fNPads[162] = 135; + fNPads[163] = 135; + fNPads[164] = 137; + fNPads[165] = 137; + fNPads[166] = 137; + fNPads[167] = 139; + fNPads[168] = 139; + fNPads[169] = 139; + fNPads[170] = 139; + fNPads[171] = 141; + fNPads[172] = 141; + fNPads[173] = 141; +} + + +Double_t AliL3Transform::GetEta(Float_t *xyz) +{ + Double_t r3 = sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]+xyz[2]*xyz[2]); + Double_t eta = 0.5 * log((r3+xyz[2])/(r3-xyz[2])); + return eta; +} + +Double_t AliL3Transform::GetPhi(Float_t *xyz) +{ + + Double_t phi = atan2(xyz[1],xyz[0]); + //if(phi<0) phi=phi+2*TMath::Pi(); + return phi; +} + + +Bool_t AliL3Transform::Slice2Sector(Int_t slice, Int_t slicerow, Int_t & sector, Int_t &row) const{ + if(slicerow<0&&slicerow>=fNRow) return kFALSE; + if(slice<0||slice>=fNSlice) return kFALSE; + + if(slicerow=fNSector) return kFALSE; + if(sector=fNSector||row<0) return kFALSE; + if(sector=fNRowLow) return kFALSE; + slice = sector; + slicerow = row; + } + else{ + if(row>=fNRowUp) return kFALSE; + slice = sector - fNSectorLow; + slicerow = row + fNRowLow; + } + return kTRUE; +} + +Double_t AliL3Transform::Row2X(Int_t slicerow){ + if(slicerow<0||slicerow>=fNRow) return 0; + return fX[slicerow]; +} + +void AliL3Transform::Local2Global(Float_t *xyz,Int_t slice) +{ + //Transformation to global coordinate system + Float_t x0 = xyz[0]; + Float_t y0 = xyz[1]; + Float_t cs,sn; + cs = fCos[slice]; + sn = fSin[slice]; + xyz[0]=x0*cs-y0*sn; + xyz[1]=x0*sn+y0*cs; + xyz[2]=xyz[2];//global z=local z +} + +void AliL3Transform::Local2GlobalAngle(Float_t *angle,Int_t slice){ + angle[0] = fmod(angle[0]+slice*fPi/9,2*fPi); +} + +void AliL3Transform::Global2LocalAngle(Float_t *angle,Int_t slice){ + angle[0] = angle[0]-slice*fPi/9; + if(angle[0]<0) angle[0]+=2*fPi; +} + +void AliL3Transform::Raw2Local(Float_t *xyz,Int_t sector,Int_t row,Float_t pad,Float_t time) +{ + //Transformation from rawdata to local coordinate system + + Int_t slice,slicerow; + Sector2Slice(slice, slicerow, sector, row); + + xyz[0]=Row2X(slicerow); + Int_t npads= fNPads[slicerow]; + if(sector +#include "AliL3Logging.h" +#include "AliL3Vertex.h" + +//_____________________________________________________________ +// +// AliL3Vertex +// +// stores the information of the vertex position +// + + +ClassImp(AliL3Vertex) +AliL3Vertex::AliL3Vertex(){ + // + // default constructor for the AliL3Vertex class. + // + + //Set vertex to zero. + SetZero(); +} + +AliL3Vertex::~AliL3Vertex(){ + // + // destructor + // +} + +void AliL3Vertex::SetZero(){ + // doit + SetX(0); + SetY(0); + SetZ(0); + SetXErr(1); + SetYErr(1); + SetZErr(1); + fR=0; + fPhi=0; + + fMWxy = 1.; +} + +void AliL3Vertex::Read(AliL3VertexData *vertex){ + // doit + SetX(vertex->fX); + SetY(vertex->fY); + SetZ(vertex->fZ); + SetXErr(vertex->fXErr); + SetYErr(vertex->fYErr); + SetZErr(vertex->fZErr); + fR=0; + fPhi=0; + + fMWxy = 1.; +} + diff --git a/HLT/src/AliL3Vertex.h b/HLT/src/AliL3Vertex.h new file mode 100644 index 00000000000..7c7cddb85db --- /dev/null +++ b/HLT/src/AliL3Vertex.h @@ -0,0 +1,49 @@ +#ifndef AliL3VERTEX_H +#define AliL3VERTEX_H + +#include "AliL3RootTypes.h" +#include "AliL3VertexData.h" + +class AliL3Vertex { + private: + Double_t fX; + Double_t fY; + Double_t fZ; + Double_t fPhi; + Double_t fR; + + Double_t fXErr; + Double_t fYErr; + Double_t fZErr; + + Double_t fMWxy; + + public: + AliL3Vertex(); + AliL3Vertex(AliL3Vertex&){;} + virtual ~AliL3Vertex(); + void SetZero(); + + void Read(AliL3VertexData *vertex); + + Double_t GetX() const {return fX;} + Double_t GetY() const {return fY;} + Double_t GetZ() const {return fZ;} + Double_t GetXErr() const {return fXErr;} + Double_t GetYErr() const {return fYErr;} + Double_t GetZErr() const {return fZErr;} + Double_t GetPhi() const {return fPhi;} + Double_t GetR() const {return fR;} + Double_t GetXYWeight() const {return fMWxy;} + void SetX(Double_t f) {fX=f;} + void SetY(Double_t f) {fY=f;} + void SetZ(Double_t f) {fZ=f;} + void SetXErr(Double_t f) {fXErr=f;} + void SetYErr(Double_t f) {fYErr=f;} + void SetZErr(Double_t f) {fZErr=f;} + + void SetXYWeight(Double_t f) {fMWxy = f;} + + ClassDef(AliL3Vertex,1) // Level3 +}; +#endif diff --git a/HLT/src/AliL3VertexArray.cxx b/HLT/src/AliL3VertexArray.cxx new file mode 100644 index 00000000000..b384d9ef99f --- /dev/null +++ b/HLT/src/AliL3VertexArray.cxx @@ -0,0 +1,106 @@ +//Author: Uli Frankenfeld +//Last Modified: 07.11.2000 + +#include "AliL3Logging.h" +//#include +#include +#include "AliL3VertexArray.h" + +//_____________________________________________________________ +// The L3 Fast Vertex Finder Base Class +// +// usage: +// +//for(Int_t sec=0;secmax){ + max = array[i]; + xbin =i; + } + } + Int_t hmax = max/2; + Int_t xmin,xmax; + Int_t ops = 0; + xmin = xbin; + while(xmin--){ + if(xmin<0) {ops++;break;} + if(array[xmin]=nbin) {ops++;break;} + if(array[xmax]= nbin/2){xmin = 2 * xbin - nbin +1;xmax = nbin-1;} + else{xmin = 0;xmax = 2 * xbin;} + } + Double_t sumw=0; + Double_t sumw2=0; + Double_t sumwx=0; + Double_t sumwx2=0; + for(Int_t bin = xmin;bin<=xmax;bin++){ + sumw += array[bin]; + sumw2 += array[bin] * array[bin]; + sumwx += array[bin] * vertex[bin]; + sumwx2 += array[bin] * vertex[bin] * vertex[bin]; + } + if(sumw){ + Double_t mean = sumwx/sumw; + Double_t rms2 = fabs(sumwx2/sumw - mean*mean); + fZSectorErr = sqrt(rms2/sumw); + fZSector = mean; + } + else{fZSectorErr = fZSector = 0;} +} + diff --git a/HLT/src/AliL3VertexArray.h b/HLT/src/AliL3VertexArray.h new file mode 100644 index 00000000000..1c34af24b16 --- /dev/null +++ b/HLT/src/AliL3VertexArray.h @@ -0,0 +1,108 @@ +#ifndef AliL3VERTEXARRAY_H +#define AliL3VERTEXARRAY_H + +#include +#include "AliL3RootTypes.h" + +class AliL3VertexArray{ + private: + + Char_t fArray[8320][8][8]; + Double_t fZSector; + Double_t fZSectorErr; + Int_t fMaxSeed; + Int_t fNSeed; + Float_t fZSeed[400]; + Float_t fRSeed[400]; + Int_t fSecSeed[400]; + + void FindMean(Float_t *vertex,Int_t *array, Int_t len); + void AnalyzeSector(Float_t *vertex, Int_t *array, Int_t len); + + public: + AliL3VertexArray(){fNSeed=0;fMaxSeed=400;} + AliL3VertexArray(AliL3VertexArray&){fNSeed=0;fMaxSeed=400;} + AliL3VertexArray(Int_t maxseed){fNSeed=0;fMaxSeed=maxseed;} + virtual ~AliL3VertexArray(){;} + + Int_t GetContent(Float_t z,Float_t r,Int_t sec); + Int_t Trace(Float_t z,Float_t r,Int_t sec,Float_t vertex); + + Double_t GetZSectorErr(){return fZSectorErr;} + Double_t GetZSector(){return fZSector;} + Int_t GetMaxSeed(){return fMaxSeed;} + Int_t GetNSeed(){return fNSeed;} + Float_t GetRSeed(Int_t i){if(i<400) return fRSeed[i]; else return -999;} + Float_t GetZSeed(Int_t i){if(i<400) return fZSeed[i]; else return -999;} + Float_t GetSecSeed(Int_t i){if(i<400) return fSecSeed[i]; else return -999;} + + void FillSector2D(Float_t z,Float_t r,Int_t sec); + void FillSectorSeed2D(Float_t z,Float_t r,Int_t sec); + void FillSector3D(Float_t x,Float_t y, Float_t z); + void FillSectorSeed3D(Float_t x,Float_t y, Float_t z); + void FindSectorVertex(Double_t pos = 0,Double_t range = 60,Int_t nbin = 60); + void ResetSector(); + + ClassDef(AliL3VertexArray,1) // Level3 + +}; + +inline void AliL3VertexArray::FillSector3D(Float_t x, Float_t y, Float_t z){ + // Filling routine in coordinates + Int_t sec = Int_t( (y+.168*x)/(.336*x)*8); // 8 subsec!! + Float_t r = sqrt(pow(y,2)+pow(x,2)); + FillSector2D(z,r,sec); +} + +inline void AliL3VertexArray:: FillSectorSeed3D(Float_t x,Float_t y, Float_t z){ + // Filling routine for seeds in coordinates + Int_t sec = Int_t( (y+.168*x)/(.336*x)*8); // 8 subsec!! + Float_t r = sqrt(pow(y,2)+pow(x,2)); + FillSectorSeed2D(z,r,sec); +} + +inline void AliL3VertexArray::FillSectorSeed2D(Float_t z,Float_t r,Int_t sec){ + // Filling routine in r,z coordinates + if(fNSeed>=400) return; + fZSeed[fNSeed] = z; fRSeed[fNSeed] = r; fSecSeed[fNSeed] = sec; + fNSeed++; +} + +inline void AliL3VertexArray::FillSector2D(Float_t z,Float_t r,Int_t sec){ + // Filling routine for seeds in r,z coordinates + if(z>r||z<=0||r<220||r>=252) return; + fArray[Int_t(z/r*32*260)][(Int_t(r-220))/4][sec] += 1; +} + +inline Int_t AliL3VertexArray::GetContent(Float_t z,Float_t r,Int_t sec){ + // Return content of array in r,z coordinates + if(z>r||z<=0||r<220||r>=252) return 0; + return fArray[Int_t(z/r*32*260)][(Int_t(r-220))/4][sec]; +} + +inline void AliL3VertexArray::ResetSector(){ + // do it! + fZSector=0; + fZSectorErr=0; + fNSeed=0; + for(Int_t i =0;i<400;i++) + fZSeed[i] = fRSeed[i] = fSecSeed[i] = 0; + for(Int_t z=0;z<8320;z++) + for(Int_t r=0;r<8;r++) + for(Int_t sec =0;sec<8;sec++) + fArray[z][r][sec] = 0; +} + +inline Int_t AliL3VertexArray::Trace(Float_t z,Float_t r,Int_t sec,Float_t vertex){ +// count the number of entries along starting from z,r to vertex,0 + Int_t cont=0; + for(Int_t i = 0;i<8;i++){ + Float_t ry = 222 +(i*4); + Float_t zx = (ry/r)*(z-vertex)+vertex; + cont += GetContent(zx,ry,sec); + } + if(cont < 5) return 0; + return cont; +} + +#endif diff --git a/HLT/src/AliL3VertexData.h b/HLT/src/AliL3VertexData.h new file mode 100644 index 00000000000..6a9ea879bb1 --- /dev/null +++ b/HLT/src/AliL3VertexData.h @@ -0,0 +1,16 @@ +#ifndef VERTEXDATA_H +#define VERTEXDATA_H + +#include "AliL3RootTypes.h" + +struct AliL3VertexData{ + Double_t fX; + Double_t fY; + Double_t fZ; + Double_t fXErr; + Double_t fYErr; + Double_t fZErr; +}; +typedef struct AliL3VertexData AliL3VertexData; + +#endif /* VERTEXDATA_H */ diff --git a/HLT/src/AliL3VertexFinder.cxx b/HLT/src/AliL3VertexFinder.cxx new file mode 100644 index 00000000000..b406876fde6 --- /dev/null +++ b/HLT/src/AliL3VertexFinder.cxx @@ -0,0 +1,99 @@ +//Author: Uli Frankenfeld +//Last Modified: 07.11.2000 + +#include +#include "AliL3Logging.h" +#include "AliL3VertexArray.h" +#include "AliL3Vertex.h" +#include "AliL3VertexFinder.h" +#include "AliL3SpacePointData.h" + +//_____________________________________________________________ +// +// AliL3VertexFinder +// +// Implementation of AliL3Array +// usage: +// +// ResetSector(); +// for(n=0;n=firstRow) + FillSector3D(hits[n].fX,hits[n].fY,hits[n].fZ); //copy data in 3D + } +} + +void AliL3VertexFinder::Analyze(){ + FindSectorVertex(); + SetZ(GetZSector()); + SetZErr(GetZSectorErr()); + LOG(AliL3Log::kInformational,"AliL3VertexFinder::Analyze","Result") + <SetX(GetX()); + vertex->SetY(GetZ()); + vertex->SetZ(GetZ()); + vertex->SetXErr(GetXErr()); + vertex->SetYErr(GetYErr()); + vertex->SetZErr(GetZErr()); + + vertex->SetXYWeight(GetXYWeight()); +} + +void AliL3VertexFinder::Write(AliL3VertexData *vertex){ + vertex->fX=GetX(); + vertex->fY=GetZ(); + vertex->fZ=GetZ(); + vertex->fXErr=GetXErr(); + vertex->fYErr=GetYErr(); + vertex->fZErr=GetZErr(); +} diff --git a/HLT/src/AliL3VertexFinder.h b/HLT/src/AliL3VertexFinder.h new file mode 100644 index 00000000000..e232673c0f2 --- /dev/null +++ b/HLT/src/AliL3VertexFinder.h @@ -0,0 +1,55 @@ +#ifndef AliL3VERTEXFINDER_H +#define AliL3VERTEXFINDER_H + +#include "AliL3VertexArray.h" +#include "AliL3SpacePointData.h" +#include "AliL3VertexData.h" + +class AliL3Vertex; + +class AliL3VertexFinder:public AliL3VertexArray{ + private: + Double_t fX; + Double_t fY; + Double_t fZ; + Double_t fPhi; + Double_t fR; + + Double_t fXErr; + Double_t fYErr; + Double_t fZErr; + + Double_t fMWxy; + + public: + AliL3VertexFinder(); + AliL3VertexFinder(AliL3VertexFinder&){;} + virtual ~AliL3VertexFinder(); + + void Reset(); + void Read(Int_t ncluster, AliL3SpacePointData* hits); + void Analyze(); + void Write(AliL3Vertex *vertex); + void Write(AliL3VertexData *vertex); + + Double_t GetX() const {return fX;} + Double_t GetY() const {return fY;} + Double_t GetZ() const {return fZ;} + Double_t GetXErr() const {return fXErr;} + Double_t GetYErr() const {return fYErr;} + Double_t GetZErr() const {return fZErr;} + Double_t GetPhi() const {return fPhi;} + Double_t GetR() const {return fR;} + Double_t GetXYWeight() const {return fMWxy;} + void SetX(Double_t f) {fX=f;} + void SetY(Double_t f) {fY=f;} + void SetZ(Double_t f) {fZ=f;} + void SetXErr(Double_t f) {fXErr=f;} + void SetYErr(Double_t f) {fYErr=f;} + void SetZErr(Double_t f) {fZErr=f;} + + void SetXYWeight(Double_t f) {fMWxy = f;} + + ClassDef(AliL3VertexFinder,1) // Level3 +}; +#endif diff --git a/HLT/src/AliLevel3.cxx b/HLT/src/AliLevel3.cxx new file mode 100644 index 00000000000..3e4986400f0 --- /dev/null +++ b/HLT/src/AliLevel3.cxx @@ -0,0 +1,473 @@ +//Author: Uli Frankenfeld +//Author: Anders Strand Vestbo +//Last Modified: 13.12.2000 + +#include "AliL3Logging.h" + +#include +#include +#include +#include +#include + +//#include +//#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 "<IsOpen()) + { + LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open") + <<"Inputfile "<IsOpen()) + { + LOG(AliL3Log::kWarning,"AliLevel3::AliLevel3","File Open") + <<"no output file!"<IsOpen()) + { + LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open") + <<"Inputfile does not exist"<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<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<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") + <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;iGetNIn();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'); +} diff --git a/HLT/src/AliLevel3.h b/HLT/src/AliLevel3.h new file mode 100644 index 00000000000..59ed0a5044b --- /dev/null +++ b/HLT/src/AliLevel3.h @@ -0,0 +1,88 @@ +#ifndef ALILEVEL3_H +#define ALILEVEL3_H + +#include +#include +#include + +#include "AliL3DigitData.h" + +class AliL3SpacePointData; +class AliL3DigitRowData; +class AliL3TrackSegmentData; +class AliL3DigitData; +class AliL3Transform; +class TClonesArray; +class AliTPCParam; +class AliL3ConfMapper; +class AliL3Vertex; +class AliL3VertexFinder; +class AliL3TrackMerger; +class AliL3GlobalMerger; +class TDirectory; +class AliL3Transform; +class AliL3ClustFinder; +class AliL3Merger; +class AliL3InterMerger; +class AliL3FileHandler; +class AliL3Benchmark; + +class AliLevel3 : public TObject { + + private: + UInt_t fNTrackData; + AliL3TrackSegmentData* fTrackData; //! + AliL3ConfMapper *fTracker; //! + AliL3Vertex *fVertex; //! + AliL3VertexFinder *fVertexFinder; //! + AliL3TrackMerger *fTrackMerger; //! + AliL3GlobalMerger *fGlobalMerger; //! + AliL3InterMerger *fInterMerger; //! + AliL3ClustFinder *fClusterFinder; //! + AliL3FileHandler *fFileHandler; //! + AliL3Benchmark *fBenchmark;//! + Int_t fNPatch; + Char_t fPath[256]; + AliL3Transform *fTransformer; //! + TDirectory *savedir; + TFile *fInputFile; + TFile *fOutputFile; + Bool_t fFindVertex; + void Init(); + void WriteSpacePoints(UInt_t npoints,AliL3SpacePointData *points, + Int_t slice,Int_t patch); + void WriteResults(); + Int_t WriteTracks(char *filename,AliL3Merger *merger,char opt='o'); + Float_t fEta[2]; + Bool_t fDoRoi; + Bool_t fUseBinary; + Bool_t fWriteOut; + void SetPath(char *p){sprintf(fPath,"%s",p);} + public: + AliLevel3 (); + AliLevel3(Char_t *infile,Char_t *outfile); + AliLevel3(TFile *in, TFile *out); + virtual ~AliLevel3(); + + void SetTrackerParam(Int_t phi_segments=50,Int_t eta_segments=100, + Int_t trackletlength=3,Int_t tracklength=5, + Int_t rowscopetracklet=2,Int_t rowscopetrack=3, + Double_t min_pt_fit=0,Double_t maxangle=1.31, + Double_t goodDist=5,Double_t hitChi2Cut=10, + Double_t goodHitChi2=20,Double_t trackChi2Cut=50, + Int_t maxdist=50); + + + void ProcessEvent(Int_t first,Int_t last); + void ProcessSlice(Int_t slice); + + + void UseBinaryInput(char *path){SetPath(path);fUseBinary=kTRUE;} + void DoMc(char* file="point_mc.dat"); + void DoBench(char* name="benchmark"); + void DoRoi(Float_t e0=0.4,Float_t e1=0.5){fEta[0]=e0;fEta[1]=e1;fDoRoi=kTRUE;} + void WriteFiles(){fWriteOut = kTRUE;} + ClassDef(AliLevel3,1) //Interface class for Level3-tracking +}; + +#endif diff --git a/HLT/src/AliLevel3_Root.cxx b/HLT/src/AliLevel3_Root.cxx new file mode 100644 index 00000000000..82c3f4193f2 --- /dev/null +++ b/HLT/src/AliLevel3_Root.cxx @@ -0,0 +1,448 @@ +//Author: Uli Frankenfeld +//Author: Anders Strand Vestbo +//Last Modified: 13.12.2000 + +#include +#include +#include +#include +#include + +#include "AliL3Logging.h" +#include "AliLevel3_Root.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 "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 "<IsOpen()) + { + LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open") + <<"Inputfile "<IsOpen()) + { + LOG(AliL3Log::kWarning,"AliLevel3::AliLevel3","File Open") + <<"no output file!"<IsOpen()) + { + LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open") + <<"Inputfile does not exist"<Analyze(name); +} + +void AliLevel3::DoMc(char* 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]; +// 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(0) + cerr<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(0) + cerr<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") + <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){ + AliL3MemHandler *memory = new AliL3MemHandler(); + memory->SetBinaryOutput(filename); + if(opt=='a'||opt=='i'){ //add intracks + for(Int_t i=0;iGetNIn();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'); +} diff --git a/HLT/src/AliLevel3_Root.h b/HLT/src/AliLevel3_Root.h new file mode 100644 index 00000000000..ccfe2d91268 --- /dev/null +++ b/HLT/src/AliLevel3_Root.h @@ -0,0 +1,85 @@ +#ifndef ALILEVEL3_H +#define ALILEVEL3_H + +#include +#include + +#include "AliL3DigitData.h" +#include "AliL3RootTypes.h" + +class AliL3SpacePointData; +class AliL3DigitRowData; +class AliL3TrackSegmentData; +class AliL3DigitData; +class AliL3Transform; +class AliL3ConfMapper; +class AliL3Vertex; +class AliL3VertexFinder; +class AliL3TrackMerger; +class AliL3GlobalMerger; +class AliL3Transform; +class AliL3ClustFinder; +class AliL3Merger; +class AliL3InterMerger; +class AliL3MemHandler; +class AliL3Benchmark; + +class AliLevel3{ + + private: + UInt_t fNTrackData; + AliL3TrackSegmentData* fTrackData; //! + AliL3ConfMapper *fTracker; //! + AliL3Vertex *fVertex; //! + AliL3VertexFinder *fVertexFinder; //! + AliL3TrackMerger *fTrackMerger; //! + AliL3GlobalMerger *fGlobalMerger; //! + AliL3InterMerger *fInterMerger; //! + AliL3ClustFinder *fClusterFinder; //! + AliL3MemHandler *fFileHandler; //! + AliL3Benchmark *fBenchmark;//! + Int_t fNPatch; + Char_t fPath[256]; + AliL3Transform *fTransformer; //! + TDirectory *savedir; + TFile *fInputFile; + TFile *fOutputFile; + Bool_t fFindVertex; + void Init(); + void WriteSpacePoints(UInt_t npoints,AliL3SpacePointData *points, + Int_t slice,Int_t patch); + void WriteResults(); + Int_t WriteTracks(char *filename,AliL3Merger *merger,char opt='o'); + Float_t fEta[2]; + Bool_t fDoRoi; + Bool_t fUseBinary; + Bool_t fWriteOut; + void SetPath(char *p){sprintf(fPath,"%s",p);} + public: + AliLevel3 (); + AliLevel3(Char_t *infile,Char_t *outfile); + AliLevel3(TFile *in, TFile *out); + virtual ~AliLevel3(); + + void SetTrackerParam(Int_t phi_segments=50,Int_t eta_segments=100, + Int_t trackletlength=3,Int_t tracklength=5, + Int_t rowscopetracklet=2,Int_t rowscopetrack=3, + Double_t min_pt_fit=0,Double_t maxangle=1.31, + Double_t goodDist=5,Double_t hitChi2Cut=10, + Double_t goodHitChi2=20,Double_t trackChi2Cut=50, + Int_t maxdist=50); + + + void ProcessEvent(Int_t first,Int_t last); + void ProcessSlice(Int_t slice); + + + void UseBinaryInput(char *path){SetPath(path);fUseBinary=kTRUE;} + void DoMc(char* file="point_mc.dat"); + void DoBench(char* name="benchmark"); + void DoRoi(Float_t e0=0.4,Float_t e1=0.5){fEta[0]=e0;fEta[1]=e1;fDoRoi=kTRUE;} + void WriteFiles(){fWriteOut = kTRUE;} + ClassDef(AliLevel3,1) //Interface class for Level3-tracking +}; + +#endif diff --git a/HLT/src/Makefile b/HLT/src/Makefile new file mode 100644 index 00000000000..6ec72628458 --- /dev/null +++ b/HLT/src/Makefile @@ -0,0 +1,84 @@ +############################### TPC Makefile ################################## + +# Include machine specific definitions + +include $(ALICE_ROOT)/conf/GeneralDef +include $(ALICE_ROOT)/conf/MachineDef.$(ALICE_TARGET) + +PACKAGE = AliL3 + +# C++ sources + + +SRCS = AliL3ConfMapper.cxx AliL3ConfMapPoint.cxx AliLevel3.cxx\ + AliL3ConfMapTrack.cxx AliL3ConfMapFit.cxx AliL3Track.cxx\ + AliL3Transform.cxx AliL3TrackMerger.cxx AliL3VertexArray.cxx \ + AliL3Vertex.cxx AliL3VertexFinder.cxx AliL3HoughTrack.cxx\ + AliL3Merger.cxx AliL3GlobalMerger.cxx AliL3ClustFinder.cxx \ + AliL3TrackArray.cxx AliL3InterMerger.cxx AliL3Logger.cxx \ + AliL3MemHandler.cxx AliL3FileHandler.cxx AliL3Evaluate.cxx \ + AliL3Benchmark.cxx AliL3Display.cxx + + +# C++ Headers + +HDRS = $(SRCS:.cxx=.h) AliL3LinkDef.h +# Library dictionary + +DICT = AliL3Cint.cxx +DICTH = $(DICT:.cxx=.h) +DICTO = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(DICT)) + +# FORTRAN Objectrs + +FOBJS = $(FSRCS:.f=.o) + +# C Objects + +COBJS = $(CSRCS:.c=.o) + +# C++ Objects + +OBJS = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(SRCS)) $(DICTO) + +# C++ compilation flags + +CXXFLAGS = $(CXXOPTS) -g -I$(ROOTSYS)/include -I. -I$(ALICE_ROOT)/include/ -I$(ALICE_ROOT)/TPC -I$(ALICE_ROOT)/CONTAINERS + +#CXXFLAGS = $(CXXOPTS) -g -Wall -I$(ROOTSYS)/include -I. -I $(ALICE_ROOT)/TPC -I$(ALICE_ROOT)/include/ -DCOMPILING + +# FORTRAN compilation flags + +FFLAGS = $(FOPT) + +##### TARGETS ##### + +# Target + +SLIBRARY = $(LIBDIR)/libAliL3.$(SL) + +default: $(SLIBRARY) + +$(LIBDIR)/libAliL3.$(SL): $(OBJS) + +$(DICT): $(HDRS) + +depend: $(SRCS) + +TOCLEAN = $(OBJS) *Cint.h *Cint.cxx + +############################### General Macros ################################ + +include $(ALICE_ROOT)/conf/GeneralMacros + +############################ Dependencies ##################################### + +include tgt_$(ALICE_TARGET)/Make-depend + +########### +so: + rm -fr $(ALICE_ROOT)/lib/tgt_Linux/libAliL3.so +clean: + rm -fr tgt_Linux/*.o + rm -fr $(ALICE_ROOT)/lib/tgt_Linux/libAliL3.so + rm -fr $(DICT) $(DICTH) $(DICTO) diff --git a/HLT/src/Makefile_Root b/HLT/src/Makefile_Root new file mode 100644 index 00000000000..27ca8c3e523 --- /dev/null +++ b/HLT/src/Makefile_Root @@ -0,0 +1,444 @@ +# Makefile for the ROOT test programs. +# This Makefile shows nicely how to compile and link applications +# using the ROOT libraries on all supported platforms. +# +# Copyright (c) 2000 Rene Brun and Fons Rademakers +# +# Author: Fons Rademakers, 29/2/2000 + +ARCH = linuxegcs +# ARCH = linuxalphaegcs + +CXX = +ObjSuf = o +SrcSuf = cxx +ExeSuf = +DllSuf = so +OutPutOpt = -o + +EVENTLIB = $(EVENTSO) + +ROOTCFLAGS := $(shell root-config --cflags) +ROOTLIBS := $(shell root-config --libs) +ROOTGLIBS := $(shell root-config --glibs) + + +ifeq ($(ARCH),hpux) +# HP-UX with CC +CXX = CC +CXXFLAGS = -O +Z +LD = CC +LDFLAGS = -O +a1 -z +SOFLAGS = -b +DllSuf = sl +endif + +ifeq ($(ARCH),hpuxacc) +# HP-UX 10.x with aCC +CXX = aCC +CXXFLAGS = -O +Z +LD = aCC +LDFLAGS = -O -z +SOFLAGS = -b +endif + +ifeq ($(ARCH),hpuxegcs) +# HP-UX 10.x with g++ +CXXFLAGS = -O -fPIC +CXX = g++ +LD = g++ +LDFLAGS = -O +SOFLAGS = -fPIC -shared +endif + +ifeq ($(ARCH),aix) +# IBM AIX +CXX = xlC +CXXFLAGS = -O +LD = xlC +LDFLAGS = -O +SOFLAGS = +endif + +ifeq ($(ARCH),aixegcs) +# IBM AIX with GCC +CXX = g++ +CXXFLAGS = -O +LD = g++ +LDFLAGS = -O +SOFLAGS = -shared +endif + +ifeq ($(ARCH),solaris) +# Solaris CC +CXX = /opt/SUNWspro/bin/CC +CXXFLAGS = -O -KPIC +LD = /opt/SUNWspro/bin/CC +LDFLAGS = -O +SOFLAGS = -G +endif + +ifeq ($(ARCH),solarisCC5) +# Solaris CC 5.0 +CXX = CC +CXXFLAGS = -O -KPIC -D__SunOS_5_6 -library=iostream,no%Cstd +LD = CC +LDFLAGS = -O -library=iostream,no%Cstd -o +SOFLAGS = -G +endif + +ifeq ($(ARCH),solarisegcs) +# Solaris egcs +CXX = g++ +CXXFLAGS = -O -fPIC +LD = CC +LDFLAGS = -O +SOFLAGS = -shared +endif + +ifeq ($(ARCH),solarisgcc) +# Solaris gcc +CXX = g++ +CXXFLAGS = -O -fPIC +LD = g++ +LDFLAGS = -O +SOFLAGS = -shared +endif + +ifeq ($(ARCH),solariskcc) +# Solaris kcc +CXX = KCC +CXXFLAGS = -O4 -KPIC +LD = KCC +LDFLAGS = -O4 +SOFLAGS = +endif + +ifeq ($(ARCH),solarisx86) +# Solaris CC on Intel +CXX = CC +CXXFLAGS = -O -KPIC +LD = CC +LDFLAGS = -O +SOFLAGS = -G +endif + +ifeq ($(ARCH),sgicc) +# SGI +CXX = CC -n32 -I/usr/include/CC.sgi +CXXFLAGS = -O +LD = CC -n32 -I/usr/include/CC.sgi +LDFLAGS = -O +SOFLAGS = -shared +endif + +ifeq ($(ARCH),sgiegcs) +# SGI 6.x with EGCS +CXX = g++ +CXXFLAGS = -O -Wall -fPIC +LD = g++ +LDFLAGS = -O -Wl,-u,__builtin_new -Wl,-u,__builtin_delete -Wl,-u,__nw__FUiPv +SOFLAGS = -shared +endif + +ifeq ($(ARCH),sgin32egcs) +# SGI 6.x with EGCS for n32 ABI +CXX = g++ +CXXFLAGS = -O -Wall -fPIC +LD = g++ +LDFLAGS = -O -L/usr/lib32 -Wl,-woff,134 +SOFLAGS = -shared +endif + +ifeq ($(ARCH),sgigcc) +# SGI with GCC +CXX = g++ +CXXFLAGS = -O -Wall -fPIC +LD = g++ +LDFLAGS = -O -Wl,-u,__builtin_new -Wl,-u,__builtin_delete -Wl,-u,__nw__FUiPv +SOFLAGS = -shared +endif + +ifeq ($(ARCH),sgikcc) +# SGI with KCC +CXX = KCC -n32 --no_exceptions +CXXFLAGS = -O +LD = KCC -n32 --no_exceptions +LDFLAGS = -O +SOFLAGS = +endif + +ifeq ($(ARCH),alphagcc) +# Alpha/OSF with g++ +CXX = g++ +CXXFLAGS = -O -Wall -fPIC +LD = g++ +LDFLAGS = -O +SOFLAGS = -Wl,-expect_unresolved,* -shared +endif + +ifeq ($(ARCH),alphaegcs) +# Alpha/OSF with egcs +CXX = g++ +CXXFLAGS = -O -Wall -fPIC +LD = g++ +LDFLAGS = -O +SOFLAGS = -Wl,-expect_unresolved,* -shared +endif + +ifeq ($(ARCH),alphakcc) +# Alpha/OSF with kai compiler (not yet valid) +CXX = g++ +CXXFLAGS = -O -fPIC +LD = g++ +LDFLAGS = -O +SOFLAGS = -Wl,-expect_unresolved,* -shared +endif + +ifeq ($(ARCH),alphacxx6) +# Alpha/OSF with cxx6 +CXX = cxx +CXXFLAGS = -O0 +LD = cxx +LDFLAGS = -O +SOFLAGS = -Wl,-expect_unresolved,* -shared +endif + +ifeq ($(ARCH),alphacxx) +# Alpha/OSF with cxx5 +CXX = cxx +CXXFLAGS = -O +LD = cxx +LDFLAGS = -O +SOFLAGS = -Wl,-expect_unresolved,* -call_shared +endif + +ifeq ($(ARCH),linux) +# Linux with gcc 2.7.2.x +CXX = g++ +CXXFLAGS = -O -Wall -fPIC +LD = g++ +LDFLAGS = -O +SOFLAGS = -shared +endif + +ifeq ($(ARCH),linuxrh42) +# Linux with gcc 2.7.2.x (RedHat 4.2) +CXX = g++ +CXXFLAGS = -O -Wall -fPIC +LD = g++ +LDFLAGS = -O +SOFLAGS = -shared +endif + +ifeq ($(ARCH),linuxdeb) +# Linux with gcc 2.7.2.x +CXX = g++ +CXXFLAGS = -O -Wall -fPIC +LD = g++ +LDFLAGS = -O +SOFLAGS = -shared +endif + +ifeq ($(ARCH),linuxdeb2) +# Linux with gcc 2.7.2.x +CXX = g++ +CXXFLAGS = -O -Wall -fPIC +LD = g++ +LDFLAGS = -O +SOFLAGS = -shared +endif + +ifeq ($(ARCH),linuxsuse6) +# Linux with gcc 2.7.2.x +CXX = g++ +CXXFLAGS = -O -Wall -fPIC +LD = g++ +LDFLAGS = -O +SOFLAGS = -shared +endif + +ifeq ($(ARCH),linuxegcs) +# Linux with egcs (>= RedHat 5.2) +CXX = g++ +CXXFLAGS = -O2 -Wall -fPIC +LD = g++ +LDFLAGS = -O2 +SOFLAGS = -shared +endif + +ifeq ($(ARCH),linuxkcc) +# Linux with the KAI compiler +CXX = KCC +CXXFLAGS = -fPIC +K0 +LD = KCC +LDFLAGS = -O +SOFLAGS = +endif + +ifeq ($(ARCH),linuxppcegcs) +# MkLinux with egcs/glibc +CXX = g++ +CXXFLAGS = -O -Wall -fPIC +LD = g++ +LDFLAGS = -O +SOFLAGS = -shared -Wl,-soname, +endif + +ifeq ($(ARCH),linuxia64gcc) +# Itanium Linux with gcc 2.9x +CXX = g++ +CXXFLAGS = -O -Wall -fPIC +LD = g++ +LDFLAGS = -O +SOFLAGS = -shared +endif + +ifeq ($(ARCH),linuxalphaegcs) +# Alpha Linux with egcs +CXX = g++ +CXXFLAGS = -O2 -Wall -fPIC -mcpu=ev6 +LD = g++ +LDFLAGS = -O2 +SOFLAGS = -shared -mcpu=ev6 +endif + +ifeq ($(ARCH),mklinux) +# MkLinux with libc5 +CXX = g++ +CXXFLAGS = -O -Wall -fPIC +LD = g++ +LDFLAGS = -O +SOFLAGS = -shared -Wl,-soname, +endif + +ifeq ($(ARCH),freebsd) +# FreeBSD with libc5 +CXX = g++ +CXXFLAGS = -O -pipe -W -Wall -fPIC +LD = g++ +LDFLAGS = -O +SOFLAGS = -shared -Wl,-x +endif + +ifeq ($(ARCH),freebsd4) +# FreeBSD with glibc +CXX = g++ +CXXFLAGS = -O -pipe -W -Wall -fPIC +LD = g++ +LDFLAGS = -O +SOFLAGS = -shared -Wl,-x +endif + +ifeq ($(ARCH),hiux) +# Hitachi HIUX +CXX = g++ +CXXFLAGS = -O2 -fPIC +LD = g++ +LDFLAGS = -Wl,+s +SOFLAGS = -Wl,-b,-E -nostdlib -nostartfiles +DllSuf = sl +endif + +ifeq ($(ARCH),win32) +# Windows with the VC++ compiler +ObjSuf = obj +SrcSuf = cxx +ExeSuf = .exe +DllSuf = dll +OutPutOpt = -out: +CXX = cl +CXXOPT = -O2 +#CXXOPT = -Z7 +CXXFLAGS = $(CXXOPT) -G5 -MD -DWIN32 -D_WINDOWS -nologo \ + -DVISUAL_CPLUSPLUS -D_X86_=1 -D_DLL +LD = link +LDOPT = -opt:ref +#LDOPT = -debug +LDFLAGS = $(LDOPT) -pdb:none -nologo -nodefaultlib -incremental:no +SOFLAGS = -DLL +SYSLIBS = msvcrt.lib oldnames.lib kernel32.lib ws2_32.lib mswsock.lib \ + advapi32.lib user32.lib gdi32.lib comdlg32.lib winspool.lib \ + msvcirt.lib +EVENTLIB = libEvent.lib + +ROOTLIBS := $(shell root-config --nonew --libs) +ROOTGLIBS := $(shell root-config --nonew --glibs) +endif + +ifeq ($(CXX),) +$(error $(ARCH) invalid architecture) +endif + +CXXFLAGS += $(ROOTCFLAGS) +LIBS = $(ROOTLIBS) $(SYSLIBS) +GLIBS = $(ROOTGLIBS) $(SYSLIBS) + +#------------------------------------------------------------------------------ + +SRCS = AliL3ConfMapper.cxx AliL3ConfMapPoint.cxx AliLevel3_Root.cxx\ + AliL3ConfMapTrack.cxx AliL3ConfMapFit.cxx AliL3Track.cxx\ + AliL3Transform.cxx AliL3TrackMerger.cxx AliL3VertexArray.cxx \ + AliL3Vertex.cxx AliL3VertexFinder.cxx AliL3HoughTrack.cxx\ + AliL3Merger.cxx AliL3GlobalMerger.cxx AliL3ClustFinder.cxx \ + AliL3TrackArray.cxx AliL3InterMerger.cxx AliL3Logger.cxx \ + AliL3MemHandler.cxx AliL3Benchmark.cxx\ + +HDRS = $(SRCS:.cxx=.h) AliL3LinkDef.h + +DICT = AliL3Cint.cxx +DICTH = $(DICT:.cxx=.h) +DICTO = $(DICT:.cxx=.o) + +OBJS = $(SRCS:.cxx=.o) $(DICTO) + +LEVELSO = libAliL3.$(DllSuf) + +PROGRAMS = $(LEVELSO) + +#------------------------------------------------------------------------------ + +.SUFFIXES: .$(SrcSuf) .$(ObjSuf) .$(DllSuf) + +all: $(PROGRAMS) + + +$(LEVELSO): $(OBJS) +ifeq ($(ARCH),aix) + /usr/ibmcxx/bin/makeC++SharedLib $(OutPutOpt) $(LEVELSO) $(LIBS) -p 0 $(OBJS) +else +ifeq ($(ARCH),alphacxx) +# due to a bug in cxx/ld under osf3.xx, one cannot use cxx to generate +# a shared library. One must use ld instead. + ld -L/usr/lib/cmplrs/cxx -rpath /usr/lib/cmplrs/cxx -expect_unresolved "*" \ + -g0 -O1 -shared /usr/lib/cmplrs/cc/crt0.o /usr/lib/cmplrs/cxx/_main.o \ + -o Hello.so Hello.o HelloDict.o -lcxxstd -lcxx -lexc -lots -lc +else +ifeq ($(ARCH),win32) + $(LD) $(SOFLAGS) $(LDFLAGS) $^ $(LIBS) $(OutPutOpt)$@ +else + $(LD) $(SOFLAGS) $(LDFLAGS) $^ $(OutPutOpt) $@ +endif +endif +endif + +clean: + @rm -f $(OBJS) $(DICT) $(DICTH) $(PROGRAMS) core + +distclean: clean + @rm -f $(PROGRAMS) $(EVENTSO) $(EVENTLIB) *Dict.* *.def *.exp \ + *.root *.ps .def so_locations + +.SUFFIXES: .$(SrcSuf) + +### + +#AliL3LinkDef.$(ObjSuf): fwhm.h + +$(DICT): $(HDRS) + @echo "Generating dictionary HelloDict..." + @rootcint -f $(DICT) -c $(HDRS) + + +.$(SrcSuf).$(ObjSuf): + $(CXX) $(CXXFLAGS) -c $< diff --git a/HLT/src/doit b/HLT/src/doit new file mode 100644 index 00000000000..2f3bde33b14 --- /dev/null +++ b/HLT/src/doit @@ -0,0 +1,3 @@ +g++ -O -Wall -fPIC -ffast-math speedtest.cxx -o speedtest +# g++ -O -Wall -fPIC -mcpu=ev6 speedtest.cxx -o speedtest +# cxx -O -Wall -fPIC -lm speedtest.cxx -o speedtest diff --git a/HLT/src/speedtest.cxx b/HLT/src/speedtest.cxx new file mode 100644 index 00000000000..a6211b73db3 --- /dev/null +++ b/HLT/src/speedtest.cxx @@ -0,0 +1,53 @@ +#include "speedtest.h" + +int main(int arg,char **arc){ + int n = 0; + if(arg!=2) {cerr<<"usage: speedtest #loops \n";return -1;} + n = atoi(arc[1]); +// cerr<<"allocate: "<>25) & 0x7f; + array[i].SetSector(slice); + array[i].SetX(hit.fX); + array[i].SetY(hit.fY); + array[i].SetZ(hit.fZ); + array[i].SetXerr(sqrt((double)hit.fXYErr)); +// array[i].SetYerr(sqrt(hit.fXYErr)); +// array[i].SetZerr(sqrt(hit.fZErr)); + } +*/ +// for(int i=0;i +#define ALIL3LOGGING_H +class AliL3Log{ + public: + enum TLogLevel { kNone = 0, kDebug= 0x01, kInformational = 0x02, kWarning = 0x04, kError = 0x08 , kFatal = 0x10, kPrimary = 0x80, kAll = 0x9F }; + enum TLogCmd { kEnd, kPrec, kHex, kDec }; +}; +#define LOG( lvl, origin, keyword ) cerr +#define ENDLOG endl +#define no_root + +#include +#include +#include +#include +#include "AliL3ConfMapPoint.cxx" + +double CpuTime() +{ + //Return the Cputime in seconds. + + return (double)(clock()) / CLOCKS_PER_SEC; +} + + -- 2.43.0