2 // Original: AliHLTMerger.cxx,v 1.16 2005/06/14 10:55:21 cvetan
4 /**************************************************************************
5 * This file is property of and copyright by the ALICE HLT Project *
6 * ALICE Experiment at CERN, All rights reserved. *
8 * Primary Authors: Uli Frankenfeld, maintained by *
9 * Matthias Richter <Matthias.Richter@ift.uib.no> *
10 * for The ALICE HLT Project. *
12 * Permission to use, copy, modify and distribute this software and its *
13 * documentation strictly for non-commercial purposes is hereby granted *
14 * without fee, provided that the above copyright notice appears in all *
15 * copies and that both the copyright notice and this permission notice *
16 * appear in the supporting documentation. The authors make no claims *
17 * about the suitability of this software for any purpose. It is *
18 * provided "as is" without express or implied warranty. *
19 **************************************************************************/
21 /** @file AliHLTTPCMerger.cxx
22 @author Uli Frankenfeld, maintained by Matthias Richter
24 @brief The HLT TPC merger base class
27 #include "AliHLTTPCLogging.h"
28 #include "AliHLTTPCMerger.h"
29 #include "AliHLTTPCTrack.h"
30 #include "AliHLTTPCTrackSegmentData.h"
31 #include "AliHLTTPCTransform.h"
32 #include "AliHLTTPCTrackArray.h"
34 #ifdef use_root //use root ntuple for slow merge
44 ClassImp(AliHLTTPCMerger)
46 AliHLTTPCMerger::AliHLTTPCMerger()
49 fSlice(0), // TODO its not quite clear were this member is set
51 f2Global(false), // TODO: initialization was missing at all, assuming false for the moment
69 AliHLTTPCMerger::~AliHLTTPCMerger()
75 void AliHLTTPCMerger::InitMerger(Int_t ntrackarrays,Char_t *tracktype)
77 //Used to setup all arrays
79 if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
80 else if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
81 #ifdef INCLUDE_TPC_HOUGH
82 else if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
85 LOG(AliHLTTPCLog::kError,"AliHLTTPCMerger::AliHLTTPCMerger","Track types")
86 <<"Unknown tracktype"<<ENDLOG;
87 SetArray(ntrackarrays);
92 void AliHLTTPCMerger::DeleteArray()
95 for(Int_t i=0; i<fNIn;i++)
97 if(!fInTrack[i]) continue;
109 void AliHLTTPCMerger::SetArray(Int_t nin)
112 DeleteArray();//Make sure arrays are cleaned
115 fInTrack = new AliHLTTPCTrackArray*[fNIn];
116 for(Int_t i=0; i<fNIn;i++)
118 #ifdef INCLUDE_TPC_HOUGH
120 fInTrack[i] = new AliHLTTPCTrackArray("AliHLTTPCHoughTrack");
123 fInTrack[i] = new AliHLTTPCTrackArray("AliHLTTPCTrack");
126 #ifdef INCLUDE_TPC_HOUGH
128 fOutTrack= new AliHLTTPCTrackArray("AliHLTTPCHoughTrack");
131 fOutTrack= new AliHLTTPCTrackArray("AliHLTTPCTrack");
134 void AliHLTTPCMerger::Reset()
137 for(Int_t i=0; i<fNIn;i++)
139 fInTrack[i]->Reset();
144 void AliHLTTPCMerger::FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr)
146 //Read tracks from shared memory (or memory)
147 AliHLTTPCTrackArray *destination = GetInTracks(fCurrentTracks);
149 destination->FillTracksChecked(tr, ntracks, 0, fSlice);
151 destination->FillTracksChecked(tr, ntracks, 0);
154 void AliHLTTPCMerger::AddAllTracks()
157 for(Int_t i=0; i<GetNIn();i++)
159 AliHLTTPCTrackArray *in = GetInTracks(i);
160 AliHLTTPCTrackArray *out = GetOutTracks();
165 void AliHLTTPCMerger::SortGlobalTracks(AliHLTTPCTrack **tracks, Int_t ntrack)
168 AliHLTTPCTrack **tmp = new AliHLTTPCTrack*[ntrack];
169 for(Int_t i=0;i<ntrack;i++) tmp[i] = tracks[i];
170 Int_t *t = new Int_t[ntrack];
171 for(Int_t i=0;i<ntrack;i++) t[i]=-1;
173 for(Int_t j=0;j<ntrack;j++)
177 for(Int_t i=0;i<ntrack;i++)
179 if(!tracks[i]) continue;
180 Double_t rr=pow(tracks[i]->GetFirstPointX(),2)+pow(tracks[i]->GetFirstPointY(),2);
190 for(Int_t i=0;i<ntrack;i++) tracks[i] = tmp[t[i]];
195 void AliHLTTPCMerger::SortTracks(AliHLTTPCTrack **tracks, Int_t ntrack) const
198 AliHLTTPCTrack **tmp = new AliHLTTPCTrack*[ntrack];
199 for(Int_t i=0;i<ntrack;i++) tmp[i] = tracks[i];
200 Int_t *t = new Int_t[ntrack];
201 for(Int_t i=0;i<ntrack;i++) t[i]=-1;
203 for(Int_t j=0;j<ntrack;j++)
207 for(Int_t i=0;i<ntrack;i++)
209 if(!tracks[i]) continue;
210 if(tracks[i]->GetFirstPointX()<minx)
212 minx=tracks[i]->GetFirstPointX();
219 for(Int_t i=0;i<ntrack;i++) tracks[i] = tmp[t[i]];
224 void AliHLTTPCMerger::AddTrack(AliHLTTPCTrackArray *mergedtrack,AliHLTTPCTrack *track)
227 AliHLTTPCTrack *t[1];
229 MultiMerge(mergedtrack,t,1);
232 AliHLTTPCTrack * AliHLTTPCMerger::MergeTracks(AliHLTTPCTrackArray *mergedtrack,AliHLTTPCTrack *t0,AliHLTTPCTrack *t1)
235 AliHLTTPCTrack *t[2];
239 return MultiMerge(mergedtrack,t,2);
242 AliHLTTPCTrack * AliHLTTPCMerger::MultiMerge(AliHLTTPCTrackArray *mergedtracks,AliHLTTPCTrack **tracks, Int_t ntrack)
244 //multi merge the tracks
247 for(Int_t i=0;i<ntrack;i++)
249 nps+=tracks[i]->GetNHits();
251 if(nps>AliHLTTPCTransform::GetNRows())
253 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMerger::MultiMerge","Adding Points")
254 <<AliHLTTPCLog::kDec<<"Too many Points: "<<nps<<ENDLOG;
259 AliHLTTPCTrack *newtrack = mergedtracks->NextTrack();
261 UInt_t * nn = new UInt_t[AliHLTTPCTransform::GetNRows()];
264 // for(Int_t i=0;i<ntrack;i++){
265 for(Int_t i=ntrack-1;i>=0;i--)
267 memcpy(&nn[nps],tracks[i]->GetHitNumbers(),tracks[i]->GetNHits()*sizeof(UInt_t));
268 nps+=tracks[i]->GetNHits();
270 AliHLTTPCTrack *tpf=tracks[0];
271 AliHLTTPCTrack *tpl=tracks[ntrack-1];
272 AliHLTTPCTrack *best = tpf;
273 if(tpf->GetNHits()<tpl->GetNHits() && Is2Global())
274 best = tpl;//Best means = most points and therefore best fit (in global case)
276 newtrack->SetNHits(nps);
277 newtrack->SetHits(nps,nn);
278 newtrack->SetFirstPoint(tpf->GetFirstPointX(),tpf->GetFirstPointY(),tpf->GetFirstPointZ());
279 newtrack->SetLastPoint(tpl->GetLastPointX(),tpl->GetLastPointY(),tpl->GetLastPointZ());
280 newtrack->SetPt(best->GetPt());
281 newtrack->SetPsi(best->GetPsi());
282 newtrack->SetTgl(best->GetTgl());
283 newtrack->SetCharge(tpf->GetCharge());
288 void* AliHLTTPCMerger::GetNtuple(char *varlist) const
292 TNtuple* nt = new TNtuple("ntuple","ntuple",varlist);
299 void* AliHLTTPCMerger::GetNtuple() const
303 TNtuple* nt = new TNtuple("ntuple","ntuple",
304 "dx:dy:dz:dk:dpsi:dtgl:dq:disx:disy:disz:dis:n0:n1:diff:drx:dry:drz");
311 Bool_t AliHLTTPCMerger::WriteNtuple(char *filename, void* nt) const
315 TNtuple *ntuple=(TNtuple *) nt;
316 TFile *f = new TFile(filename,"RECREATE");
326 void AliHLTTPCMerger::FillNtuple(void *nt,AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack)
330 if(outertrack->IsPoint()&&innertrack->IsPoint())
332 data[0] =Float_t(innertrack->GetPointX()-outertrack->GetPointX());
333 data[1] =Float_t(innertrack->GetPointY()-outertrack->GetPointY());
334 data[2] =Float_t(innertrack->GetPointZ()-outertrack->GetPointZ());
335 data[3] =Float_t(innertrack->GetKappa()-outertrack->GetKappa());
336 Double_t psi= innertrack->GetPointPsi() - outertrack->GetPointPsi();
337 if(psi>AliHLTTPCTransform::Pi()) psi-=AliHLTTPCTransform::TwoPi();
338 else if(psi<-AliHLTTPCTransform::Pi()) psi+=AliHLTTPCTransform::TwoPi();
339 data[4] =Float_t(psi);
340 data[5] =Float_t(innertrack->GetTgl()-outertrack->GetTgl());
341 data[6] =Float_t(innertrack->GetCharge()-outertrack->GetCharge());
342 data[7] =Float_t(innertrack->GetLastPointX()-outertrack->GetFirstPointX());
343 data[8] =Float_t(innertrack->GetLastPointY()-outertrack->GetFirstPointY());
344 data[9] =Float_t(innertrack->GetLastPointZ()-outertrack->GetFirstPointZ());
345 data[10] =sqrt(pow(data[7],2)+pow(data[8],2)+pow(data[9],2));
346 data[11]= outertrack->GetNHits();
347 data[12]= innertrack->GetNHits();
348 data[13] = Float_t(TrackDiff(innertrack,outertrack));
353 TNtuple *ntuple = (TNtuple *) nt;
359 void AliHLTTPCMerger::FillNtuple(void *nt,Float_t *data) const
363 TNtuple *ntuple = (TNtuple *) nt;
368 Double_t AliHLTTPCMerger::GetAngle(Double_t a1,Double_t a2)
371 Double_t da = a1 - a2 + 4*AliHLTTPCTransform::Pi();
372 da = fmod(da,AliHLTTPCTransform::TwoPi());
373 if(da>AliHLTTPCTransform::Pi()) da = AliHLTTPCTransform::TwoPi()-da;
377 void AliHLTTPCMerger::SetParameter(Double_t maxy, Double_t maxz, Double_t maxkappa, Double_t maxpsi, Double_t maxtgl)
379 //set parameters for merger
382 fMaxKappa = maxkappa;
387 Bool_t AliHLTTPCMerger::IsTrack(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack)
389 //is track to be merged
390 if(innertrack->GetCharge()!=outertrack->GetCharge()) return kFALSE;
391 if( (!innertrack->IsPoint()) || (!outertrack->IsPoint()) ) return kFALSE;
392 if(innertrack->GetNHits()+outertrack->GetNHits()>AliHLTTPCTransform::GetNRows()) return kFALSE;
394 if(fabs(innertrack->GetPointY()-outertrack->GetPointY()) >fMaxY) return kFALSE;
395 if(fabs(innertrack->GetPointZ()-outertrack->GetPointZ()) >fMaxZ) return kFALSE;
396 if(fabs(innertrack->GetKappa()-outertrack->GetKappa()) >fMaxKappa) return kFALSE;
397 if(GetAngle(innertrack->GetPointPsi(),outertrack->GetPointPsi()) >fMaxPsi) return kFALSE;
398 if(fabs(innertrack->GetTgl()-outertrack->GetTgl()) >fMaxTgl) return kFALSE;
399 //if no rejection up to this point: merge!!
403 Bool_t AliHLTTPCMerger::IsRTrack(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack)
406 return IsTrack(innertrack,outertrack);
409 Double_t AliHLTTPCMerger::TrackDiff(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack)
411 //return track difference
413 Double_t x[4],y[4],z[4],dy[4],dz[4];
414 AliHLTTPCTrack *tracks[2];
416 tracks[0] = innertrack;
417 tracks[1] = outertrack;
418 SortGlobalTracks(tracks,2);
419 innertrack = tracks[0];
420 outertrack = tracks[1];
422 x[0] = innertrack->GetFirstPointX();
423 x[1] = innertrack->GetLastPointX();
424 x[2] = outertrack->GetFirstPointX();
425 x[3] = outertrack->GetLastPointX();
427 y[0] = innertrack->GetFirstPointY();
428 y[1] = innertrack->GetLastPointY();
429 y[2] = outertrack->GetFirstPointY();
430 y[3] = outertrack->GetLastPointY();
432 z[0] = innertrack->GetFirstPointZ();
433 z[1] = innertrack->GetLastPointZ();
434 z[2] = outertrack->GetFirstPointZ();
435 z[3] = outertrack->GetLastPointZ();
438 outertrack->CalculatePoint(x[0]);
439 if(!outertrack->IsPoint()) return diff;
440 dy[0] = fabs(y[0] - outertrack->GetPointY());
441 dz[0] = fabs(z[0] - outertrack->GetPointZ());
443 outertrack->CalculatePoint(x[1]);
444 if(!outertrack->IsPoint()) return diff;
445 dy[1] = fabs(y[1] - outertrack->GetPointY());
446 dz[1] = fabs(z[1] - outertrack->GetPointZ());
448 innertrack->CalculatePoint(x[2]);
449 if(!innertrack->IsPoint()) return diff;
450 dy[2] = fabs(y[2] - innertrack->GetPointY());
451 dz[2] = fabs(z[2] - innertrack->GetPointZ());
453 innertrack->CalculatePoint(x[3]);
454 if(!innertrack->IsPoint()) return diff;
455 dy[3] = fabs(y[3] - innertrack->GetPointY());
456 dz[3] = fabs(z[3] - innertrack->GetPointZ());
459 for(Int_t i=0;i<4;i++)
460 diff+=sqrt(dy[i]*dy[i]+dz[i]*dz[i]);
464 void AliHLTTPCMerger::PrintDiff(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack)
467 if(!innertrack->IsPoint()||!outertrack->IsPoint())
469 LOG(AliHLTTPCLog::kInformational,"AliHLTTPCMerger::PrintDiff","No Points")<<ENDLOG;
470 //cerr<<"AliHLTTPCMerger::PrintDiff: No Points"<<endl;
471 //cerr<<"---------------------------"<<endl;
475 Double_t dx = innertrack->GetPointX()-outertrack->GetPointX();
476 Double_t dy = innertrack->GetPointY()-outertrack->GetPointY();
477 Double_t dz = innertrack->GetPointZ()-outertrack->GetPointZ();
478 Double_t dk = innertrack->GetKappa()-outertrack->GetKappa();
479 Double_t dpsi= innertrack->GetPointPsi() - outertrack->GetPointPsi();
480 if(dpsi>AliHLTTPCTransform::Pi()) dpsi-=AliHLTTPCTransform::TwoPi();
481 else if(dpsi<-AliHLTTPCTransform::Pi())dpsi+=AliHLTTPCTransform::TwoPi();
482 //Double_t dpsi = GetAngle(innertrack->GetPointPsi(),outertrack->GetPointPsi());
483 Double_t dtgl= innertrack->GetTgl()-outertrack->GetTgl();
484 Double_t dq =innertrack->GetCharge()-outertrack->GetCharge();
486 LOG(AliHLTTPCLog::kInformational,"AliHLTTPCMerger::PrintDiff","Points") <<"dx: "<<dx<<" dy: "<<dy<<" dz: "<<dz<<" dk: "<<dk<<" dpsi: "<<dpsi<<" dtgl: "<<dtgl<<" dq: "<<dq<<ENDLOG;
487 //fprintf(stderr,"dx: %4f dy: %4f dz: %4f dk: %4f dpsi: %4f dtgl: %4f dq: %4f\n",dx,dy,dz,dk,dpsi,dtgl,dq);
488 //cerr<<"---------------------------"<<endl;
492 void AliHLTTPCMerger::Print()
495 for(Int_t i=0; i<fNIn; i++)
497 AliHLTTPCTrackArray *ttt= GetInTracks(i);
498 for(Int_t j =0;j<ttt->GetNTracks();j++)
500 AliHLTTPCTrack *track=ttt->GetCheckedTrack(j);
502 track->CalculateHelix();
503 // Double_t angle = atan2(track->GetLastPointY(),track->GetLastPointX());
504 // if(angle<0) angle+=AliHLTTPCTransform::Pi();
505 if(track->CalculatePoint(135))
506 // if(!track->CalculateEdgePoint(angle)) cerr<<"**************"<<endl;
507 // if(track->CalculatePoint(track->GetLastPointX()))
508 // if(track->CalculatePoint(0))
510 // PrintTrack(track);
511 // track->CalculateReferencePoint(AliHLTTPCTransform::Pi()/180.);
512 track->CalculateReferencePoint(0.001);
513 Float_t dx=(float)track->GetPointX()-track->GetPointX();
514 Float_t dy=(float)track->GetPointY()-track->GetPointY();
515 Float_t dz=(float)track->GetPointZ()-track->GetPointZ();
516 LOG(AliHLTTPCLog::kInformational,"AliHLTTPCMerger::Print","RefPoint") <<"npt: "<<track->GetNHits()<<" dx: "<<dx<<" dy: "<<dy<<" dz: "<<dz<<ENDLOG;
518 //fprintf(stderr,"npt: %3d dx: %8.5f dy: %8.5f dz: %8.5f\n",track->GetNHits(),dx,dy,dz);
519 //cerr<<"---------------------------"<<endl;
525 void AliHLTTPCMerger::PrintTrack(AliHLTTPCTrack *track)
528 fprintf(stderr,"npt: %3d pt: %.2f psi: %.2f tgl: %5.2f q: %2d\n",
529 track->GetNHits(),track->GetPt(),track->GetPsi(),
530 track->GetTgl(),track->GetCharge());
532 "x1: %6.2f y1: %6.2f z1: %6.2f xl: %6.2f yl: %6.2f zl: %6.2f\n",
533 track->GetFirstPointX(),track->GetFirstPointY(),track->GetFirstPointZ(),
534 track->GetLastPointX(),track->GetLastPointY(),track->GetLastPointZ());
538 "R: %.2f Xc: %.2f Yc: %.2f Xp: %.2f Yp: %.2f Zp: %.2f Psip: %.2f\n",
539 track->GetRadius(),track->GetCenterX(),track->GetCenterY(),
540 track->GetPointX(),track->GetPointY(),track->GetPointZ(),
541 track->GetPointPsi());