Added split clusters tagging (MC info used)
[u/mrichter/AliRoot.git] / ITS / UPGRADE / AliITSUTrackerGlo.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /*
17   TO CHECK
18   GetBz usage
19
20  */
21
22 //-------------------------------------------------------------------------
23 //  Implementation of the ITS Upgrade tracker mother class.              
24 //-------------------------------------------------------------------------
25 #include <TTree.h>
26 #include <Riostream.h> 
27 #include <TMath.h>
28 #include <TFile.h>
29
30 #include "AliITSUTrackerGlo.h"
31 #include "AliESDEvent.h"
32 #include "AliESDtrack.h"
33 #include "AliITSURecoDet.h"
34 #include "AliITSURecoSens.h"
35 #include "AliITSUReconstructor.h"
36 #include "AliITSReconstructor.h"
37 #include "AliITSUSeed.h"
38 #include "AliITSUAux.h"
39 #include "AliITSUClusterPix.h"
40 using namespace AliITSUAux;
41 using namespace TMath;
42
43 //----------------- tmp stuff -----------------
44
45 ClassImp(AliITSUTrackerGlo)
46
47 const Double_t AliITSUTrackerGlo::fgkToler =  1e-6;// tolerance for layer on-surface check
48
49
50 //_________________________________________________________________________
51 AliITSUTrackerGlo::AliITSUTrackerGlo(AliITSUReconstructor* rec)
52 :  fReconstructor(rec)
53   ,fITS(0)
54   ,fCurrESDtrack(0)
55   ,fCurrESDtrMClb(kDummyLabel)
56   ,fCurrMass(kPionMass)
57   ,fCountProlongationTrials(0)
58   ,fCountITSin(0)
59   ,fCountITSout(0)
60   ,fCountITSrefit(0)
61   ,fHypStore(100)
62   ,fNBranchesAdded(0)
63   ,fNCandidatesAdded(0)
64   ,fCurrHyp(0)
65   ,fSeedsPool("AliITSUSeed",0)
66   ,fFreeSeedsID(0)
67   ,fNFreeSeeds(0)
68   ,fLastSeedID(0)
69   ,fDefTrackConds(0)
70   ,fCurrTrackCond(0)
71   ,fTrackPhase(-1)
72   ,fClInfo(0)
73 #ifdef  _FILL_CONTROL_HISTOS_
74   ,fCHistoArr(0)
75 #endif
76 {
77   // Default constructor
78   if (rec) Init(rec);
79 }
80
81 //_________________________________________________________________________
82 AliITSUTrackerGlo::~AliITSUTrackerGlo()
83 {
84  // Default destructor
85  //  
86   delete[] fClInfo;
87   //
88 #ifdef  _FILL_CONTROL_HISTOS_
89   if (fCHistoArr) {
90     TFile* ctrOut = TFile::Open("itsuControlHistos.root","recreate");
91     ctrOut->cd();
92     AliInfo("Storing control histos");
93     fCHistoArr->Print();
94     //    ctrOut->WriteObject(fCHistoArr,"controlH","kSingleKey");
95     fCHistoArr->Write();
96     ctrOut->Close();
97     delete ctrOut;
98     fCHistoArr = 0;
99   }
100 #endif 
101   //
102 }
103
104 //_________________________________________________________________________
105 void AliITSUTrackerGlo::Init(AliITSUReconstructor* rec)
106 {
107   // init with external reconstructor
108   //
109   fITS = rec->GetITSInterface();
110   int nLr = fITS->GetNLayersActive();
111   fClInfo = new Int_t[nLr<<1];
112   //
113   fSeedsPool.ExpandCreateFast(1000); // RS TOCHECK
114   fFreeSeedsID.Set(1000);
115   //
116 }
117
118 //_________________________________________________________________________
119 void AliITSUTrackerGlo::CreateDefaultTrackCond()
120 {
121   // creates default tracking conditions to be used when recoparam does not provide them
122   int nLr = fITS->GetNLayersActive();
123   fClInfo = new Int_t[nLr<<1];
124   //
125   AliITSUTrackCond* cond = new AliITSUTrackCond();
126   //
127   cond->SetNLayers(fITS->GetNLayersActive());
128   cond->AddNewCondition(nLr);
129   cond->AddGroupPattern( 0xffff ); // require all layers hit
130   //
131   fDefTrackConds.AddLast(cond);
132   //
133   AliInfo("Created conditions: ");
134   for (int i=0;i<fDefTrackConds.GetEntriesFast();i++) fDefTrackConds[i]->Print();
135   //
136 }
137
138
139 //_________________________________________________________________________
140 Int_t AliITSUTrackerGlo::Clusters2Tracks(AliESDEvent *esdEv)
141 {
142   //
143   SetTrackingPhase(kClus2Tracks);
144   //
145 #ifdef  _FILL_CONTROL_HISTOS_
146   if (!fCHistoArr) BookControlHistos();
147 #endif
148
149   TObjArray *trackConds = 0;
150   //
151   fCountProlongationTrials = 0;
152   fCountITSin = 0;
153   fCountITSout = 0;
154   fCountITSrefit = 0;
155   //
156   ResetSeedsPool();
157   int nTrESD = esdEv->GetNumberOfTracks();
158   AliInfo(Form("Will try to find prolongations for %d tracks",nTrESD));
159   int nTrackCond = AliITSUReconstructor::GetRecoParam()->GetNTrackingConditions();
160   if (nTrackCond<1) {
161     if (!fDefTrackConds.GetEntriesFast()) {
162       AliInfo("No tracking conditions found in recoparams, creating default one requesting all layers hit");
163       CreateDefaultTrackCond();
164     }
165     trackConds = &fDefTrackConds;
166     nTrackCond = trackConds->GetEntriesFast();
167   } 
168   else trackConds = AliITSUReconstructor::GetRecoParam()->GetTrackingConditions();
169   //
170   static Bool_t first = kTRUE;
171   if (first) {
172     AliITSUReconstructor::GetRecoParam()->Print();
173     first = kFALSE;
174   }
175   fHypStore.Delete();
176   if (fHypStore.GetSize()<nTrESD) fHypStore.Expand(nTrESD+100);
177   //
178   fITS->ProcessClusters();
179   //
180   FlagSplitClusters(); // tmp RS
181   //
182   for (int icnd=0;icnd<nTrackCond;icnd++) {
183     fCurrTrackCond = (AliITSUTrackCond*)trackConds->UncheckedAt(icnd);
184     // select ESD tracks to propagate
185     for (int itr=0;itr<nTrESD;itr++) {
186       fCurrESDtrack = esdEv->GetTrack(itr);
187       fCurrESDtrMClb = fCurrESDtrack->GetLabel();
188       //
189       if (!NeedToProlong(fCurrESDtrack)) continue;  // are we interested in this track?
190       AliDebug(+1,Form("Processing track %d | M=%.3f Pt=%.3f | MCLabel: %d",itr,fCurrESDtrack->GetMass(kTRUE),fCurrESDtrack->Pt(),fCurrESDtrMClb));//RS
191       FindTrack(fCurrESDtrack, itr);
192     }   
193     //
194     if (AliDebugLevelClass()>+2) {
195       AliInfo(Form("SeedsPool: %d, BookedUpTo: %d, free: %d",fSeedsPool.GetSize(),fSeedsPool.GetEntriesFast(),fNFreeSeeds));
196       fHypStore.Print();
197     }
198     FinalizeHypotheses();
199   }
200   //
201   AliInfo(Form("%d ITSin for %d tried TPC seeds out of %d ESD tracks\n",fCountITSin,fCountProlongationTrials,nTrESD));
202   return 0;
203 }
204
205 //_________________________________________________________________________
206 Int_t AliITSUTrackerGlo::PropagateBack(AliESDEvent *esdEv)
207 {
208   //
209   // Do outward fits in ITS
210   //
211   SetTrackingPhase(kPropBack);
212   int nTrESD = esdEv->GetNumberOfTracks();
213   AliDebug(1,Form("Will propagate back %d tracks",nTrESD));
214   //
215   double bz0 = GetBz();
216   Double_t xyzTrk[3],xyzVtx[3]={GetX(),GetY(),GetZ()};
217   AliITSUTrackHyp dummyTr,*currTr=0;
218   const double kWatchStep=10.; // for larger steps watch arc vs segment difference
219   Double_t times[AliPID::kSPECIES];
220   //
221   //
222   for (int itr=0;itr<nTrESD;itr++) {
223     fCurrESDtrack = esdEv->GetTrack(itr);
224     fCurrESDtrMClb = fCurrESDtrack->GetLabel();
225     // Start time integral and add distance from current position to vertex 
226     if (fCurrESDtrack->IsOn(AliESDtrack::kITSout)) continue; // already done
227     //
228     fCurrESDtrack->GetXYZ(xyzTrk); 
229     Double_t dst = 0.;     // set initial track lenght, tof
230     {
231       double dxs = xyzTrk[0] - xyzVtx[0];
232       double dys = xyzTrk[1] - xyzVtx[1];
233       double dzs = xyzTrk[2] - xyzVtx[2];
234       // RS: for large segment steps d use approximation of cicrular arc s by
235       // s = 2R*asin(d/2R) = d/p asin(p) \approx d/p (p + 1/6 p^3) = d (1+1/6 p^2)
236       // where R is the track radius, p = d/2R = 2C*d (C is the abs curvature)
237       // Hence s^2/d^2 = (1+1/6 p^2)^2
238       dst = dxs*dxs + dys*dys;
239       if (dst > kWatchStep*kWatchStep) { // correct circular part for arc/segment factor
240         double crv = Abs(fCurrESDtrack->GetC(bz0));
241         double fcarc = 1.+crv*crv*dst/6.;
242         dst *= fcarc*fcarc;
243       }
244       dst += dzs*dzs;
245       dst = Sqrt(dst); 
246     }
247     //    
248     fCurrESDtrack->SetStatus(AliESDtrack::kTIME);
249     //
250     if (!fCurrESDtrack->IsOn(AliESDtrack::kITSin)) { // case of tracks w/o ITS prolongation: just set the time integration
251       dummyTr.AliExternalTrackParam::operator=(*fCurrESDtrack);
252       dummyTr.StartTimeIntegral();
253       dummyTr.AddTimeStep(dst);
254       dummyTr.GetIntegratedTimes(times); 
255       fCurrESDtrack->SetIntegratedTimes(times);
256       fCurrESDtrack->SetIntegratedLength(dummyTr.GetIntegratedLength());
257       continue;
258     }
259     //
260     currTr = GetTrackHyp(itr);
261     currTr->StartTimeIntegral();
262     currTr->AddTimeStep(dst);
263     //    printf("Before resetCov: "); currTr->AliExternalTrackParam::Print();
264     currTr->ResetCovariance(10000);
265     if (RefitTrack(currTr,fITS->GetRMax())) { // propagate to exit from the ITS/TPC screen
266       UpdateESDTrack(currTr,AliESDtrack::kITSout);
267       fCountITSout++;
268     }
269     else {
270       AliDebug(2,Form("Refit Failed for track %d | ESDtrack#%d (MClb:%d)",itr,fCurrESDtrack->GetID(),fCurrESDtrMClb));
271       //currTr->AliExternalTrackParam::Print();
272       //currTr->GetWinner()->Print();
273     }
274     //
275   }
276   //
277   AliInfo(Form("%d ITSout in %d ITSin tracks for %d tried TPC seeds out of %d ESD tracks\n",
278                fCountITSout,fCountITSin,fCountProlongationTrials,nTrESD));
279   //
280   return 0;
281 }
282
283 //_________________________________________________________________________
284 Int_t AliITSUTrackerGlo::RefitInward(AliESDEvent *esdEv)
285 {
286   //
287   // refit the tracks inward, using current cov.matrix
288   //
289   SetTrackingPhase(kRefitInw);
290   Int_t nTrESD = esdEv->GetNumberOfTracks();
291   //  AliLog::SetClassDebugLevel("AliITSUTrackerGlo",10);
292
293   AliDebug(1,Form("Will refit inward %d tracks",nTrESD));
294   AliITSUTrackHyp *currTr=0;
295   //
296   for (int itr=0;itr<nTrESD;itr++) {
297     fCurrESDtrack = esdEv->GetTrack(itr);
298     fCurrESDtrMClb = fCurrESDtrack->GetLabel();
299     // Start time integral and add distance from current position to vertex 
300     UInt_t trStat = fCurrESDtrack->GetStatus();
301     if ( !(trStat & AliESDtrack::kITSout) ) continue;
302     if (   trStat & AliESDtrack::kITSrefit ) continue; // already done
303     if (  (trStat & AliESDtrack::kTPCout) && !(trStat & AliESDtrack::kTPCrefit) ) continue;
304     //
305     currTr = GetTrackHyp(itr);
306     currTr->AliExternalTrackParam::operator=(*fCurrESDtrack);  // fetch current ESDtrack kinematics
307     if (RefitTrack(currTr,fITS->GetRMin())) { // propagate up to inside radius of the beam pipe
308       UpdateESDTrack(currTr,AliESDtrack::kITSrefit);
309       fCountITSrefit++;
310     }
311     else {
312       AliDebug(2,Form("Refit Failed for track %d |ESDtrack#%d (MClb:%d)",itr,fCurrESDtrack->GetID(),fCurrESDtrMClb));
313     }
314   }    
315   //
316   AliInfo(Form("%d ITSrefit in %d ITSout in %d ITSin tracks for %d tried TPC seeds out of %d ESD tracks\n",
317                fCountITSrefit,fCountITSout,fCountITSin,fCountProlongationTrials,nTrESD));
318   //
319   //  AliLog::SetClassDebugLevel("AliITSUTrackerGlo",0);
320   return 0;
321 }
322
323 //_________________________________________________________________________
324 Int_t AliITSUTrackerGlo::LoadClusters(TTree * treeRP)
325 {
326   // read from tree (if pointer provided) or directly from the ITS reco interface
327   //
328   return fReconstructor->LoadClusters(treeRP);
329
330
331 //_________________________________________________________________________
332 void AliITSUTrackerGlo::UnloadClusters()
333 {
334   //
335   // To be implemented 
336   //
337   
338   Info("UnloadClusters","To be implemented");
339
340 //_________________________________________________________________________
341 AliCluster * AliITSUTrackerGlo::GetCluster(Int_t /*index*/) const
342 {
343   //
344   // To be implemented 
345   //
346   
347   Info("GetCluster","To be implemented");
348   return 0x0;
349
350
351 //_________________________________________________________________________
352 Bool_t AliITSUTrackerGlo::NeedToProlong(AliESDtrack* esdTr)
353 {
354   // do we need to match this track to ITS?
355   //
356   static double bz = GetBz();
357   if (!esdTr->IsOn(AliESDtrack::kTPCin) ||
358       esdTr->IsOn(AliESDtrack::kTPCout) ||
359       esdTr->IsOn(AliESDtrack::kITSin)  ||
360       esdTr->GetKinkIndex(0)>0) return kFALSE;
361   //
362   if (esdTr->Pt()<AliITSUReconstructor::GetRecoParam()->GetMinPtForProlongation()) return kFALSE;
363   //
364   float dtz[2];
365   esdTr->GetDZ(GetX(),GetY(),GetZ(),bz,dtz); 
366   // if track is not V0 candidata but has large offset wrt IP, reject it. RS TOCHECK
367   if ( !(esdTr->GetV0Index(0)>0 && dtz[0]>AliITSUReconstructor::GetRecoParam()->GetMaxDforV0dghtrForProlongation()) 
368        && (Abs(dtz[0])>AliITSUReconstructor::GetRecoParam()->GetMaxDForProlongation() ||
369            Abs(dtz[1])>AliITSUReconstructor::GetRecoParam()->GetMaxDZForProlongation())) return kFALSE;
370   //
371   return kTRUE;
372 }
373
374 //_________________________________________________________________________
375 void AliITSUTrackerGlo::FindTrack(AliESDtrack* esdTr, Int_t esdID)
376 {
377   // find prolongaion candidates finding for single seed
378   //
379   AliITSUSeed seedUC;  // copy of the seed from the upper layer
380   AliITSUSeed seedT;   // transient seed between the seedUC and new prolongation hypothesis
381   //
382   if (!InitHypothesis(esdTr,esdID)) return;  // initialize prolongations hypotheses tree
383   //
384   AliITSURecoSens *hitSens[AliITSURecoSens::kNNeighbors+1];
385   //
386   TObjArray clArr; // container for transfer of clusters matching to seed
387   //
388   int nLrActive = fITS->GetNLayersActive();
389   for (int ila=nLrActive;ila--;) {
390     int ilaUp = ila+1;                         // prolong seeds from layer above
391     //
392     // for the outermost layer the seed is created from the ESD track
393     int nSeedsUp = (ilaUp==nLrActive) ? 1 : fCurrHyp->GetNSeeds(ilaUp);
394     int maxNBranches   = fCurrTrackCond->GetMaxBranches(ila);
395     int maxNCandidates = fCurrTrackCond->GetMaxCandidates(ila);
396     //
397     for (int isd=0;isd<nSeedsUp;isd++) {
398       AliITSUSeed* seedU;
399       if (ilaUp==nLrActive) {
400         seedU = 0;
401         seedUC.InitFromESDTrack(esdTr);
402       }
403       else {
404         seedU = fCurrHyp->GetSeed(ilaUp,isd);  // seed on prev.active layer to prolong  
405         seedUC = *seedU;                       // its copy will be prolonged
406         seedUC.SetParent(seedU);        
407       }
408       seedUC.ResetFMatrix();                    // reset the matrix for propagation to next layer
409       // go till next active layer
410       AliDebug(2,Form("working on Lr:%d Seed:%d of %d for esdID=%d (MClb:%d) | pT=%.3f",ila,isd,nSeedsUp,esdID,fCurrESDtrMClb,seedUC.Pt()));
411       if (!TransportToLayer(&seedUC, fITS->GetLrIDActive(ilaUp), fITS->GetLrIDActive(ila)) ) {
412         //
413         AliDebug(2,Form("Transport failed | esdID=%d (MClb:%d)",esdID,fCurrESDtrMClb));
414         // Check if the seed satisfies to track definition
415         if (NeedToKill(&seedUC,kTransportFailed) && seedU) KillSeed(seedU,kTRUE);
416         continue; // RS TODO: decide what to do with tracks stopped on higher layers w/o killing
417       }
418       AliITSURecoLayer* lrA = fITS->GetLayerActive(ila);
419       if (!GetRoadWidth(&seedUC, ila)) { // failed to find road width on the layer
420         if (NeedToKill(&seedUC,kRWCheckFailed) && seedU) KillSeed(seedU,kTRUE);
421         continue;
422       }
423       int nsens = lrA->FindSensors(&fTrImpData[kTrPhi0], hitSens);  // find detectors which may be hit by the track
424       AliDebug(2,Form("Will check %d sensors on lr:%d | esdID=%d (MClb:%d)",nsens,ila,esdID,fCurrESDtrMClb));
425       //
426       seedUC.SetLr(ila);
427       //
428       double bz = GetBz();
429       for (int isn=nsens;isn--;) {
430         AliITSURecoSens* sens = hitSens[isn];
431         int ncl = sens->GetNClusters();
432         if (!ncl) continue;
433         seedT = seedUC;
434         //
435         // We need to propagate the seed to sensor on lrA staying in the frame of the sensor from prev.layer,
436         // since the transport matrix should be defined in this frame.
437         double xs; // X in the TF of current seed, corresponding to intersection with sensor plane
438         if (!seedT.GetTrackingXAtXAlpha(sens->GetXTF(),sens->GetPhiTF(),bz, xs)) {
439           if (AliDebugLevelClass()>2) {
440             printf("Failed on GetTrackingXAtXAlpha: X=%.4f alp=%.3f\n",sens->GetXTF(),sens->GetPhiTF());
441             seedT.Print("etp");
442           }
443           continue;
444         }
445         if (xs<seedT.GetX()) {
446           if (!PropagateSeed(&seedT,xs,fCurrMass)) continue;
447         }
448         else { // some low precision tracks may hit the sensor plane outside of the layer radius
449           if (AliDebugLevelClass()>2) {
450             if (!seedT.ContainsFake()) {
451               printf("WRONG PROP on L%d, sens%d of %d: %.4f > %.4f\n",ila,isn,nsens,xs,seedT.GetX());
452               sens->Print();
453               seedT.Print("etp");           
454             }
455           }
456           if (!seedT.PropagateParamOnlyTo(xs,bz)) continue;
457         }
458         //      if (!seedT.PropagateToX(xs,bz)) continue;
459         //      if (!seedT.Rotate(sens->GetPhiTF())) continue;
460         if (!seedT.RotateToAlpha(sens->GetPhiTF())) continue;
461         //
462         int clID0 = sens->GetFirstClusterId();
463         for (int icl=ncl;icl--;) {
464           //      AliLog::SetClassDebugLevel("AliITSUTrackerGlo",10);
465           int res = CheckCluster(&seedT,ila,clID0+icl);
466           //      AliLog::SetClassDebugLevel("AliITSUTrackerGlo", 0);
467           //
468           if (res==kStopSearchOnSensor) break;     // stop looking on this sensor
469           if (res==kClusterNotMatching) continue;  // cluster does not match
470           // cluster is matching and it was added to the hypotheses tree
471         }
472       }
473       // cluster search is done. Do we need to have a version of this seed skipping current layer
474       if (!NeedToKill(&seedUC,kMissingCluster)) {
475         AliITSUSeed* seedSkp = NewSeedFromPool(&seedUC);
476         double penalty = -AliITSUReconstructor::GetRecoParam()->GetMissPenalty(ila);
477         // to do: make penalty to account for probability to miss the cluster for good reason
478         seedSkp->SetChi2Cl(penalty);
479         AddProlongationHypothesis(seedSkp,ila);      
480       }
481       // transfer the new branches of the seed to the hypothesis container
482       if (fNBranchesAdded) ValidateAllowedBranches(maxNBranches);
483       //
484     }
485     if (fNCandidatesAdded) ValidateAllowedCandidates(ila,maxNCandidates);
486     //    ((TObjArray*)fCurrHyp->GetLayerSeeds(ila))->Sort();
487     if (AliDebugLevelClass()>2) { //RS
488       printf(">>> All hypotheses on lr %d: \n",ila);
489       for (int ih=0;ih<fCurrHyp->GetNSeeds(ila);ih++) {printf(" #%3d ",ih); fCurrHyp->GetSeed(ila,ih)->Print();}
490     }
491     //
492     /*
493     for (int ih=0;ih<fCurrHyp->GetNSeeds(ila);ih++) {
494       if (ila!=0) continue;
495       double vecL[5] = {0};
496       double matL[15] = {0};
497       AliITSUSeed* sp = fCurrHyp->GetSeed(ila,ih);
498       while(sp->GetParent()) {
499         sp->Smooth(vecL,matL);
500         if (sp->GetLayerID()>=fITS->GetNLayersActive()-1) break;
501         sp = (AliITSUSeed*)sp->GetParent();
502       }
503       */
504   }
505   //
506   SaveCurrentTrackHypotheses();
507   //
508 }
509
510 //_________________________________________________________________________
511 Bool_t AliITSUTrackerGlo::InitHypothesis(AliESDtrack *esdTr, Int_t esdID)
512 {
513   // init prolongaion candidates finding for single seed
514   fCurrHyp = GetTrackHyp(esdID);
515   if (fCurrHyp) return kTRUE;
516   //
517   fCountProlongationTrials++;
518   //
519   fCurrMass = esdTr->GetMass();
520   if (fCurrMass<kPionMass*0.9) fCurrMass = kPionMass; // don't trust to mu, e identification from TPCin
521   //
522   fCurrHyp = new AliITSUTrackHyp(fITS->GetNLayersActive());
523   fCurrHyp->SetESDTrack(esdTr);
524   fCurrHyp->SetUniqueID(esdID);
525   fCurrHyp->SetMass(fCurrMass);
526   SetTrackHyp(fCurrHyp,esdID);
527   //
528   return kTRUE;
529   // TO DO
530 }
531
532 //_________________________________________________________________________
533 Bool_t AliITSUTrackerGlo::TransportToLayer(AliITSUSeed* seed, Int_t lFrom, Int_t lTo)
534 {
535   // transport seed from layerFrom to the entrance (along the direction of the track) of layerTo
536   //  
537   //
538   if (lTo==lFrom) AliFatal(Form("was called with lFrom=%d lTo=%d",lFrom,lTo));
539   //
540   int dir = lTo > lFrom ? 1:-1;
541   AliITSURecoLayer* lrFr = fITS->GetLayer(lFrom); // this can be 0 when extrapolation from TPC to ITS is requested
542   Bool_t checkFirst = kTRUE;
543   while(lFrom!=lTo) {
544     if (lrFr) {
545       if (!GoToExitFromLayer(seed,lrFr,dir,checkFirst)) {
546         //printf("FailHere0 Dir=%d\n",dir);
547         //seed->Print("etp");
548         return kFALSE; // go till the end of current layer
549       }
550       checkFirst = kFALSE;
551     }
552     AliITSURecoLayer* lrTo =  fITS->GetLayer( (lFrom+=dir) );
553     if (!lrTo) AliFatal(Form("Layer %d does not exist",lFrom));
554     //
555     // go the entrance of the layer, assuming no materials in between
556     double xToGo = lrTo->GetR(-dir);
557     //    double xts = xToGo;
558     if (!seed->GetXatLabR(xToGo,xToGo,GetBz(),dir)) {
559       //printf("FailHere1: %f %f %d\n",xts,xToGo,dir);
560       //seed->Print("etp");
561       //
562       
563       return kFALSE;
564     }
565     AliDebug(2,Form("go in dir=%d to R=%.4f(X:%.4f)",dir,lrTo->GetR(-dir), xToGo));
566     if (!PropagateSeed(seed,xToGo,fCurrMass,100, kFALSE )) {
567       //printf("FailHere2: %f %f %d\n",xts,xToGo,dir);
568       //seed->Print("etp");
569       return kFALSE;
570     }
571     lrFr = lrTo;
572   }
573   return kTRUE;
574   //
575 }
576
577 //_________________________________________________________________________
578 Bool_t AliITSUTrackerGlo::TransportToLayer(AliExternalTrackParam* seed, Int_t lFrom, Int_t lTo)
579 {
580   // transport track from layerFrom to the entrance of layerTo
581   //  
582   if (lTo==lFrom) AliFatal(Form("was called with lFrom=%d lTo=%d",lFrom,lTo));
583   //
584   int dir = lTo > lFrom ? 1:-1;
585   AliITSURecoLayer* lrFr = fITS->GetLayer(lFrom); // this can be 0 when extrapolation from TPC to ITS is requested
586   Bool_t checkFirst = kTRUE;
587   while(lFrom!=lTo) {
588     if (lrFr) {
589       if (!GoToExitFromLayer(seed,lrFr,dir,checkFirst)) return kFALSE; // go till the end of current layer
590       checkFirst = kFALSE;
591     }
592     AliITSURecoLayer* lrTo =  fITS->GetLayer( (lFrom+=dir) );
593     if (!lrTo) AliFatal(Form("Layer %d does not exist",lFrom));
594     //
595     // go the entrance of the layer, assuming no materials in between
596     double xToGo = lrTo->GetR(-dir);
597     //    double xts = xToGo;
598     if (!seed->GetXatLabR(xToGo,xToGo,GetBz(),dir)) {
599       //      printf("FailHere1: %f %f %d\n",xts,xToGo,dir);
600       //      seed->Print("etp");
601       return kFALSE;
602     }
603     AliDebug(2,Form("go in dir=%d to R=%.4f(X:%.4f)",dir,lrTo->GetR(-dir), xToGo));
604     if (!PropagateSeed(seed,xToGo,fCurrMass,100, kFALSE )) {
605       //printf("FailHere2: %f %f %d\n",xts,xToGo,dir);
606       //seed->Print("etp");
607       return kFALSE;
608     }
609     lrFr = lrTo;
610   }
611   return kTRUE;
612   //
613 }
614
615 //_________________________________________________________________________
616 Bool_t AliITSUTrackerGlo::TransportToLayerX(AliExternalTrackParam* seed, Int_t lFrom, Int_t lTo, Double_t xStop)
617 {
618   // transport track from layerFrom to the entrance of layerTo but do not pass control parameter X
619   //  
620   if (lTo==lFrom) AliFatal(Form("was called with lFrom=%d lTo=%d",lFrom,lTo));
621   //
622   int dir = lTo > lFrom ? 1:-1;
623   AliITSURecoLayer* lrFr = fITS->GetLayer(lFrom); // this can be 0 when extrapolation from TPC to ITS is requested
624   Bool_t checkFirst = kTRUE;
625   while(lFrom!=lTo) {
626     if (lrFr) {
627       if (!GoToExitFromLayer(seed,lrFr,dir,checkFirst)) return kFALSE; // go till the end of current layer
628       checkFirst = kFALSE;
629     }
630     AliITSURecoLayer* lrTo =  fITS->GetLayer( (lFrom+=dir) );
631     if (!lrTo) AliFatal(Form("Layer %d does not exist",lFrom));
632     //
633     // go the entrance of the layer, assuming no materials in between
634     double xToGo = lrTo->GetR(-dir); // R of the entrance to layer
635     //
636     //    double xts = xToGo;
637     if (!seed->GetXatLabR(xToGo,xToGo,GetBz(),dir)) {
638       //      printf("FailHere1: %f %f %d\n",xts,xToGo,dir);
639       //      seed->Print("etp");
640       return kFALSE;
641     }
642     if ( (dir>0&&xToGo>xStop) || (dir<0&&xToGo<xStop) ) xToGo = xStop;
643     //
644     AliDebug(2,Form("go in dir=%d to R=%.4f(X:%.4f)",dir,lrTo->GetR(-dir), xToGo));
645     if (!PropagateSeed(seed,xToGo,fCurrMass,100, kFALSE )) {
646       //printf("FailHere2: %f %f %d\n",xts,xToGo,dir);
647       //seed->Print("etp");
648       return kFALSE;
649     }
650     lrFr = lrTo;
651   }
652   return kTRUE;
653   //
654 }
655
656 //_________________________________________________________________________
657 Bool_t AliITSUTrackerGlo::GoToExitFromLayer(AliITSUSeed* seed, AliITSURecoLayer* lr, Int_t dir, Bool_t check)
658 {
659   // go to the exit from lr in direction dir, applying material corrections in steps specific for this layer
660   // If check is requested, do this only provided the track has not exited the layer already
661   double xToGo = lr->GetR(dir);
662   if (check) { // do we need to track till the surface of the current layer ?
663     double curR2 = seed->GetX()*seed->GetX() + seed->GetY()*seed->GetY(); // current radius
664     AliDebug(3,Form(" dir:%d Cur: %e Tgt: %e",dir,Sqrt(curR2),xToGo));
665     if      (dir>0) { if (curR2-xToGo*xToGo>-fgkToler) return kTRUE; } // on the surface or outside of the layer
666     else if (dir<0) { if (xToGo*xToGo-curR2>-fgkToler) return kTRUE; } // on the surface or outside of the layer
667   }
668   if (!seed->GetXatLabR(xToGo,xToGo,GetBz(),dir)) return kFALSE;
669   // go via layer to its boundary, applying material correction.
670   if (!PropagateSeed(seed,xToGo,fCurrMass, lr->GetMaxStep())) return kFALSE;
671   //
672   return kTRUE;
673   //
674 }
675
676 //_________________________________________________________________________
677 Bool_t AliITSUTrackerGlo::GoToExitFromLayer(AliExternalTrackParam* seed, AliITSURecoLayer* lr, Int_t dir, Bool_t check)
678 {
679   // go to the exit from lr in direction dir, applying material corrections in steps specific for this layer
680   // If check is requested, do this only provided the track has not exited the layer already
681   double xToGo = lr->GetR(dir);
682   if (check) { // do we need to track till the surface of the current layer ?
683     double curR2 = seed->GetX()*seed->GetX() + seed->GetY()*seed->GetY(); // current radius
684     if      (dir>0) { if (curR2-xToGo*xToGo>-fgkToler) return kTRUE; } // on the surface or outside of the layer
685     else if (dir<0) { if (xToGo*xToGo-curR2>-fgkToler) return kTRUE; } // on the surface or outside of the layer
686   }
687   AliDebug(2,Form(" dir=%d : from R=%.4f -> R=%.4f",dir,Sqrt(seed->GetX()*seed->GetX() + seed->GetY()*seed->GetY()), xToGo));
688   if (!seed->GetXatLabR(xToGo,xToGo,GetBz(),dir)) return kFALSE;
689   // go via layer to its boundary, applying material correction.
690   if (!PropagateSeed(seed,xToGo,fCurrMass, lr->GetMaxStep())) return kFALSE;
691   //
692   return kTRUE;
693   //
694 }
695
696
697 //_________________________________________________________________________
698 Bool_t AliITSUTrackerGlo::GoToEntranceToLayer(AliITSUSeed* seed, AliITSURecoLayer* lr, Int_t dir, Bool_t check)
699 {
700   // go to the entrance of lr in direction dir, w/o applying material corrections.
701   // If check is requested, do this only provided the track did not reach the layer already
702   double xToGo = lr->GetR(-dir);
703   if (check) { // do we need to track till the surface of the current layer ?
704     double curR2 = seed->GetX()*seed->GetX() + seed->GetY()*seed->GetY(); // current radius
705     if      (dir>0) { if (curR2-xToGo*xToGo>-fgkToler) return kTRUE; } // already passed
706     else if (dir<0) { if (xToGo*xToGo-curR2>-fgkToler) return kTRUE; } // already passed
707   }
708   if (!seed->GetXatLabR(xToGo,xToGo,GetBz(),dir)) return kFALSE;
709   // go via layer to its boundary, applying material correction.
710   if (!PropagateSeed(seed,xToGo,fCurrMass, 100, kFALSE)) return kFALSE;
711   return kTRUE;
712   //
713 }
714
715 //_________________________________________________________________________
716 Bool_t AliITSUTrackerGlo::GoToEntranceToLayer(AliExternalTrackParam* seed, AliITSURecoLayer* lr, Int_t dir, Bool_t check)
717 {
718   // go to the entrance of lr in direction dir, w/o applying material corrections.
719   // If check is requested, do this only provided the track did not reach the layer already
720   double xToGo = lr->GetR(-dir);
721   if (check) { // do we need to track till the surface of the current layer ?
722     double curR2 = seed->GetX()*seed->GetX() + seed->GetY()*seed->GetY(); // current radius
723     if      (dir>0) { if (curR2-xToGo*xToGo>-fgkToler) return kTRUE; } // already passed
724     else if (dir<0) { if (xToGo*xToGo-curR2>-fgkToler) return kTRUE; } // already passed
725   }
726   if (!seed->GetXatLabR(xToGo,xToGo,GetBz(),dir)) return kFALSE;
727   // go via layer to its boundary, applying material correction.
728   if (!PropagateSeed(seed,xToGo,fCurrMass, 100, kFALSE)) return kFALSE;
729   return kTRUE;
730   //
731 }
732
733 //_________________________________________________________________________
734 Bool_t AliITSUTrackerGlo::GetRoadWidth(AliITSUSeed* seed, int ilrA)
735 {
736   // calculate road width in terms of phi and z for the track which MUST be on the external radius of the layer
737   // as well as some aux info
738   double bz = GetBz();
739   AliITSURecoLayer* lrA = fITS->GetLayerActive(ilrA);
740   seed->GetXYZ(&fTrImpData[kTrXIn]);    // lab position at the entrance from above
741   static AliExternalTrackParam sc;   // seed copy for manipulations
742   sc = *seed;
743   //
744   fTrImpData[kTrPhiIn] = ATan2(fTrImpData[kTrYIn],fTrImpData[kTrXIn]);
745   if (!sc.Rotate(fTrImpData[kTrPhiIn])) return kFALSE; // go to the frame of the entry point into the layer
746   double dr  = lrA->GetDR();                              // approximate X dist at the inner radius
747   if (!sc.GetXYZAt(sc.GetX()-dr, bz, fTrImpData + kTrXOut)) {
748     // special case: track does not reach inner radius, might be tangential
749     double r = sc.GetD(0,0,bz);
750     double x;
751     if (!sc.GetXatLabR(r,x,bz,-1)) {
752       sc.Print();
753       AliFatal(Form("This should not happen: r=%f",r));
754     }
755     dr = Abs(sc.GetX() - x);
756     if (!sc.GetXYZAt(x, bz, fTrImpData + kTrXOut)) {
757       sc.Print();
758       AliFatal(Form("This should not happen: x=%f",x));
759     }
760   }
761   //
762   fTrImpData[kTrPhiOut] = ATan2(fTrImpData[kTrYOut],fTrImpData[kTrXOut]);
763   double sgy = sc.GetSigmaY2() + dr*dr*sc.GetSigmaSnp2() + AliITSUReconstructor::GetRecoParam()->GetSigmaY2(ilrA);
764   double sgz = sc.GetSigmaZ2() + dr*dr*sc.GetSigmaTgl2() + AliITSUReconstructor::GetRecoParam()->GetSigmaZ2(ilrA);
765   sgy = Sqrt(sgy)*AliITSUReconstructor::GetRecoParam()->GetNSigmaRoadY();
766   sgz = Sqrt(sgz)*AliITSUReconstructor::GetRecoParam()->GetNSigmaRoadZ();
767   fTrImpData[kTrPhi0] = 0.5*(fTrImpData[kTrPhiOut]+fTrImpData[kTrPhiIn]);
768   fTrImpData[kTrZ0]   = 0.5*(fTrImpData[kTrZOut]+fTrImpData[kTrZIn]);
769   fTrImpData[kTrDPhi] = 0.5*Abs(fTrImpData[kTrPhiOut]-fTrImpData[kTrPhiIn]) + sgy/lrA->GetR();
770   fTrImpData[kTrDZ]   = 0.5*Abs(fTrImpData[kTrZOut]-fTrImpData[kTrZIn])   + sgz;
771   //  
772   return kTRUE;
773 }
774
775 //________________________________________
776 void AliITSUTrackerGlo::ResetSeedsPool()
777 {
778   // mark all seeds in the pool as unused
779   AliDebug(-1,Form("CurrentSize: %d, BookedUpTo: %d, free: %d",fSeedsPool.GetSize(),fSeedsPool.GetEntriesFast(),fNFreeSeeds));
780   fNFreeSeeds = 0;
781   fSeedsPool.Clear(); // seeds don't allocate memory
782 }
783
784
785 //________________________________________
786 void AliITSUTrackerGlo::MarkSeedFree(AliITSUSeed *sd) 
787 {
788   // account that this seed is "deleted" 
789   int id = sd->GetPoolID();
790   if (id<0) {
791     AliError(Form("Freeing of seed %p NOT from the pool is requested",sd)); 
792     return;
793   }
794   //  AliInfo(Form("%d %p",id, seed));
795   fSeedsPool.RemoveAt(id);
796   if (fFreeSeedsID.GetSize()<=fNFreeSeeds) fFreeSeedsID.Set( 2*fNFreeSeeds + 100 );
797   fFreeSeedsID.GetArray()[fNFreeSeeds++] = id;
798 }
799
800 //_________________________________________________________________________
801 Int_t AliITSUTrackerGlo::CheckCluster(AliITSUSeed* track, Int_t lr, Int_t clID) 
802 {
803   // Check if the cluster (in tracking frame!) is matching to track. 
804   // The track must be already propagated to sensor tracking frame.
805   // Returns:  kStopSearchOnSensor if the search on given sensor should be stopped, 
806   //           kClusterMatching    if the cluster is matching
807   //           kClusterMatching    otherwise
808   //
809   const double kTolerX = 5e-4;
810   AliCluster *cl = fITS->GetLayerActive(lr)->GetCluster(clID);
811   //
812   Bool_t goodCl = kFALSE;
813   int currLabel = Abs(fCurrESDtrMClb);
814   //
815   if (cl->GetLabel(0)>=0) {
816     for (int i=0;i<3;i++) if (cl->GetLabel(i)>=0 && cl->GetLabel(i)==currLabel) {goodCl = kTRUE; break;}
817   }
818   Bool_t goodSeed = !track->ContainsFake();
819   //
820   if (TMath::Abs(cl->GetX())>kTolerX) { // if due to the misalingment X is large, propagate track only
821     if (!track->PropagateParamOnlyTo(track->GetX()+cl->GetX(),GetBz())) {
822       if (goodCl&&goodSeed && AliDebugLevelClass()>2 ) {
823         AliDebug(2,Form("Lost good cl on L:%d failed propagation. |ESDtrack#%d (MClb:%d)",lr,fCurrESDtrack->GetID(),fCurrESDtrMClb)); 
824         track->Print("etp");
825         cl->Print();
826       }
827       return kStopSearchOnSensor; // propagation failed, seedT is intact
828     }
829   }
830   double dy = cl->GetY()-track->GetY();
831   double dz = cl->GetZ()-track->GetZ();
832   //
833 #ifdef  _FILL_CONTROL_HISTOS_
834   int hcOffs = fTrackPhase*kHistosPhase + lr;
835   double htrPt=-1;
836   if (goodCl&&goodSeed && fCHistoArr /*&& track->GetChi2Penalty()<1e-5*/) {
837     htrPt = track->Pt();
838     ((TH2*)fCHistoArr->At(kHResY+hcOffs))->Fill(htrPt,dy);
839     ((TH2*)fCHistoArr->At(kHResZ+hcOffs))->Fill(htrPt,dz);
840     double errY = track->GetSigmaY2();
841     double errZ = track->GetSigmaZ2();
842     if (errY>0) ((TH2*)fCHistoArr->At(kHResYP+hcOffs))->Fill(htrPt,dy/Sqrt(errY));
843     if (errZ>0) ((TH2*)fCHistoArr->At(kHResZP+hcOffs))->Fill(htrPt,dz/Sqrt(errZ));
844   }
845 #endif  
846   //
847   double dy2 = dy*dy;
848   double tol2 = (track->GetSigmaY2() + AliITSUReconstructor::GetRecoParam()->GetSigmaY2(lr))*
849     AliITSUReconstructor::GetRecoParam()->GetNSigmaRoadY()*AliITSUReconstructor::GetRecoParam()->GetNSigmaRoadY(); // RS TOOPTIMIZE
850   if (dy2>tol2) {                          // the clusters are sorted in Z(col) then in Y(row). 
851     if (goodCl&&goodSeed && AliDebugLevelClass()>2) {    
852       AliDebug(2,Form("Lost good cl: dy2=%e > tol2=%e |ESDtrack#%d (MClb:%d)",dy2,tol2,fCurrESDtrack->GetID(),fCurrESDtrMClb)); 
853       track->Print("etp");
854       cl->Print();
855       PrintSeedClusters(track);
856     }
857     if (dy>0) return kStopSearchOnSensor;  // No chance that other cluster of this sensor will match (all Y's will be even larger)
858     else      return kClusterNotMatching;   // Other clusters may match
859   }
860   double dz2 = dz*dz;
861   tol2 = (track->GetSigmaZ2() + AliITSUReconstructor::GetRecoParam()->GetSigmaZ2(lr))*
862     AliITSUReconstructor::GetRecoParam()->GetNSigmaRoadZ()*AliITSUReconstructor::GetRecoParam()->GetNSigmaRoadZ(); // RS TOOPTIMIZE
863   if (dz2>tol2) {
864     if (goodCl&&goodSeed && AliDebugLevelClass()>2) {
865       AliDebug(2,Form("Lost good cl on L:%d : dz2=%e > tol2=%e |ESDtrack#%d (MClb:%d)",lr,dz2,tol2,fCurrESDtrack->GetID(),fCurrESDtrMClb)); 
866       track->Print("etp");
867       cl->Print();
868       PrintSeedClusters(track);
869     }
870     return kClusterNotMatching; // Other clusters may match
871   }
872   //
873   // check chi2
874   Double_t p[2]={cl->GetY(), cl->GetZ()};
875   Double_t cov[3]={cl->GetSigmaY2(), cl->GetSigmaYZ(), cl->GetSigmaZ2()};
876   double chi2 = track->GetPredictedChi2(p,cov);
877   //
878 #ifdef  _FILL_CONTROL_HISTOS_
879   if (htrPt>0) {
880     ((TH2*)fCHistoArr->At(kHChi2Cl+hcOffs))->Fill(htrPt,chi2);
881   }
882 #endif
883   //
884   if (chi2>AliITSUReconstructor::GetRecoParam()->GetMaxTr2ClChi2(lr)) {
885     if (goodCl&&goodSeed && AliDebugLevelClass()>2) {
886       AliDebug(2,Form("Lost good cl on L:%d : Chi2=%e > Chi2Max=%e |dy: %+.3e dz: %+.3e |ESDtrack#%d (MClb:%d)\n",
887                       lr,chi2,AliITSUReconstructor::GetRecoParam()->GetMaxTr2ClChi2(lr),dy,dz,fCurrESDtrack->GetID(),fCurrESDtrMClb)); 
888       track->Print("etp");
889       cl->Print("");
890       PrintSeedClusters(track);
891     }
892     return kClusterNotMatching;
893   }
894   //
895   track = NewSeedFromPool(track);  // input track will be reused, use its clone for updates
896   if (!track->Update()) {
897     if (goodCl&&goodSeed && AliDebugLevelClass()>2) {
898       AliDebug(2,Form("Lost good cluster on L:%d : failed to update",lr));
899       track->Print("etp");
900       cl->Print("");
901       PrintSeedClusters(track);
902     }
903     MarkSeedFree(track);
904     return kClusterNotMatching;
905   }
906   track->SetChi2Cl(chi2);
907   track->SetLrClusterID(lr,clID);
908   cl->IncreaseClusterUsage();
909   //
910   track->SetFake(!goodCl);
911   //
912   AliDebug(2,Form("AddCl(%d) Cl%d lr:%d: dY:%+8.4f dZ:%+8.4f (MC: %5d %5d %5d) |Chi2=%f(%c)| ",
913                goodCl,clID,lr,dy,dz2,cl->GetLabel(0),cl->GetLabel(1),cl->GetLabel(2), chi2, track->IsFake() ? '-':'+'));
914   //
915   AddSeedBranch(track);
916   //
917   return kClusterMatching;
918 }
919
920 //_________________________________________________________________________
921 Bool_t AliITSUTrackerGlo::NeedToKill(AliITSUSeed *seed, Int_t flag)
922 {
923   // check if the seed should not be discarded
924   const UShort_t kMask = 0xffff;
925   if (flag==kMissingCluster) {
926     int lastChecked = seed->GetLayerID();
927     UShort_t patt = seed->GetHitsPattern();
928     if (lastChecked) patt |= ~(kMask<<lastChecked); // not all layers were checked, complete unchecked once by potential hits
929     Bool_t seedOK = fCurrTrackCond->CheckPattern(patt);
930     return !seedOK;
931   }
932   return kTRUE;
933 }
934
935 //______________________________________________________________________________
936 Bool_t AliITSUTrackerGlo::PropagateSeed(AliITSUSeed *seed, Double_t xToGo, Double_t mass, Double_t maxStep, Bool_t matCorr) 
937 {
938   // propagate seed to given x applying material correction if requested
939   const Double_t kEpsilon = 1e-5;
940   Double_t xpos     = seed->GetX();
941   Int_t dir         = (xpos<xToGo) ? 1:-1;
942   Double_t xyz0[3],xyz1[3],param[7];
943   //
944   Bool_t updTime = dir>0 && seed->IsStartedTimeIntegral();
945   if (matCorr || updTime) seed->GetXYZ(xyz1);   //starting global position
946   while ( (xToGo-xpos)*dir > kEpsilon){
947     Double_t step = dir*TMath::Min(TMath::Abs(xToGo-xpos), maxStep);
948     Double_t x    = xpos+step;
949     Double_t bz=GetBz();   // getting the local Bz
950     if (!seed->PropagateToX(x,bz)) return kFALSE;
951     double ds = 0;
952     if (matCorr || updTime) {
953       xyz0[0]=xyz1[0]; // global pos at the beginning of step
954       xyz0[1]=xyz1[1];
955       xyz0[2]=xyz1[2];
956       seed->GetXYZ(xyz1);    //  // global pos at the end of step
957       if (matCorr) {
958         MeanMaterialBudget(xyz0,xyz1,param);    
959         Double_t xrho=param[0]*param[4], xx0=param[1];
960         if (dir>0) xrho = -xrho; // outward should be negative
961         if (!seed->ApplyMaterialCorrection(xx0,xrho,mass,kFALSE)) {AliInfo("Fail2"); seed->Print("etp"); return kFALSE;}
962         ds = param[4];
963       }
964        else { // matCorr is not requested but time integral is
965         double d0 = xyz1[0]-xyz0[0];
966         double d1 = xyz1[1]-xyz0[1];
967         double d2 = xyz1[2]-xyz0[2];    
968         ds = TMath::Sqrt(d0*d0+d1*d1+d2*d2);
969       }     
970     }
971     if (updTime) seed->AddTimeStep(ds);
972     xpos = seed->GetX();
973   }
974   return kTRUE;
975 }
976
977 //______________________________________________________________________________
978 Bool_t AliITSUTrackerGlo::PropagateSeed(AliExternalTrackParam *seed, Double_t xToGo, Double_t mass, Double_t maxStep, Bool_t matCorr) 
979 {
980   // propagate seed to given x applying material correction if requested
981   const Double_t kEpsilon = 1e-5;
982   Double_t xpos     = seed->GetX();
983   Int_t dir         = (xpos<xToGo) ? 1:-1;
984   Double_t xyz0[3],xyz1[3],param[7];
985   //
986   if (AliDebugLevelClass()>1) {
987     AliDebug(2,Form("Before Propagate to X=%f with M=%.3f MaxStep=%.4f MatCorr=%d",xToGo,mass,maxStep,matCorr));
988     seed->AliExternalTrackParam::Print();
989   }
990   Bool_t updTime = dir>0 && seed->IsStartedTimeIntegral();
991   if (matCorr || updTime) seed->GetXYZ(xyz1);   //starting global position
992   while ( (xToGo-xpos)*dir > kEpsilon){
993     Double_t step = dir*TMath::Min(TMath::Abs(xToGo-xpos), maxStep);
994     Double_t x    = xpos+step;
995     Double_t bz=GetBz();   // getting the local Bz
996     if (!seed->PropagateTo(x,bz))  return kFALSE;
997     double ds = 0;
998     if (matCorr || updTime) {
999       xyz0[0]=xyz1[0]; // global pos at the beginning of step
1000       xyz0[1]=xyz1[1];
1001       xyz0[2]=xyz1[2];
1002       seed->GetXYZ(xyz1);    //  // global pos at the end of step
1003       //
1004       if (matCorr) {
1005         MeanMaterialBudget(xyz0,xyz1,param);    
1006         Double_t xrho=param[0]*param[4], xx0=param[1];
1007         if (dir>0) xrho = -xrho; // outward should be negative
1008         if (!seed->CorrectForMeanMaterial(xx0,xrho,mass)) return kFALSE;
1009         ds = param[4];
1010       }
1011       else { // matCorr is not requested but time integral is
1012         double d0 = xyz1[0]-xyz0[0];
1013         double d1 = xyz1[1]-xyz0[1];
1014         double d2 = xyz1[2]-xyz0[2];    
1015         ds = TMath::Sqrt(d0*d0+d1*d1+d2*d2);
1016       }
1017     }
1018     if (updTime) seed->AddTimeStep(ds);
1019     //
1020     xpos = seed->GetX();
1021   }
1022   if (AliDebugLevelClass()>1) {
1023     AliDebug(2,Form("After Propagate to X=%f",xToGo));
1024     seed->AliExternalTrackParam::Print();
1025   }
1026   return kTRUE;
1027 }
1028
1029 //______________________________________________________________________________
1030 void AliITSUTrackerGlo::SaveCurrentTrackHypotheses()
1031 {
1032   // RS: shall we clean up killed seeds?
1033   ((TObjArray*)fCurrHyp->GetLayerSeeds(0))->Sort();
1034   fCurrHyp = 0;
1035   // TODO
1036   
1037 }
1038
1039 //______________________________________________________________________________
1040 void AliITSUTrackerGlo::FinalizeHypotheses()
1041 {
1042   // select winner for each hypothesis, remove cl. sharing conflicts
1043   AliDebug(2,"TODO");
1044   //
1045   int nh = fHypStore.GetEntriesFast();
1046   for (int ih=0;ih<nh;ih++) {
1047     AliITSUTrackHyp* hyp = (AliITSUTrackHyp*) fHypStore.UncheckedAt(ih); 
1048     if (!hyp || !hyp->DefineWinner()) continue; // TODO
1049     if (hyp->GetESDTrack()->IsOn(AliESDtrack::kITSin)) continue;
1050     fCountITSin++;
1051     CookMCLabel(hyp);
1052     UpdateESDTrack(hyp,AliESDtrack::kITSin);
1053   }
1054
1055 }
1056
1057 //______________________________________________________________________________
1058 void AliITSUTrackerGlo::UpdateESDTrack(AliITSUTrackHyp* hyp,Int_t flag)
1059 {
1060   // update ESD track with current best hypothesis
1061   AliESDtrack* esdTr = hyp->GetESDTrack();
1062   if (!esdTr) return;
1063   AliITSUSeed* win = hyp->GetWinner();
1064   if (!win) return;
1065   switch (flag) {
1066   case AliESDtrack::kITSin: 
1067     esdTr->UpdateTrackParams(hyp,flag); // update kinematics
1068     // TODO: set cluster info
1069     break;
1070     //
1071   case AliESDtrack::kITSout: 
1072     esdTr->UpdateTrackParams(hyp,flag); // update kinematics
1073     // TODO: avoid setting friend
1074     break;
1075     //
1076   case AliESDtrack::kITSrefit: 
1077     esdTr->UpdateTrackParams(hyp,flag); // update kinematics
1078     // TODO: avoid setting cluster info
1079     break;
1080   default:
1081     AliFatal(Form("Unknown flag %d",flag));
1082   }
1083   //
1084   // transfer module indices
1085   // TODO
1086 }
1087
1088 //______________________________________________________________________________
1089 Bool_t AliITSUTrackerGlo::RefitTrack(AliITSUTrackHyp* trc, Double_t rDest, Bool_t stopAtLastCl)
1090 {
1091   // refit track till radius rDest
1092   AliITSUTrackHyp tmpTr;
1093   //
1094   double rCurr = Sqrt(trc->GetX()*trc->GetX() + trc->GetY()*trc->GetY());
1095   int dir,lrStart,lrStop;
1096   //
1097   dir = rCurr<rDest ? 1 : -1;
1098   lrStart = fITS->FindFirstLayerID(rCurr,dir);
1099   lrStop  = fITS->FindLastLayerID(rDest,dir);
1100   if (AliDebugLevelClass()>2) {
1101     printf("Refit %d: Lr:%d (%f) -> Lr:%d (%f)\n",dir,lrStart,rCurr, lrStop,rDest);
1102     printf("Before refit: "); trc->AliExternalTrackParam::Print();
1103   }
1104   if (lrStop<0 || lrStart<0) AliFatal(Form("Failed to find start(%d) or last(%d) layers. Track from %.3f to %.3f",lrStart,lrStop,rCurr,rDest));
1105   //
1106   int ncl = trc->FetchClusterInfo(fClInfo);
1107   fCurrMass = trc->GetMass();
1108   tmpTr.AliKalmanTrack::operator=(*trc);
1109   tmpTr.SetChi2(0);
1110   int iclLr[2],nclLr,clCount=0;
1111   //
1112   for (int ilr=lrStart;ilr!=lrStop;ilr+=dir) {
1113     AliITSURecoLayer* lr = fITS->GetLayer(ilr);
1114     if ( dir*(rCurr-lr->GetR(dir))>0) continue; // this layer is already passed
1115     int ilrA2,ilrA = lr->GetActiveID();
1116     // passive layer or active w/o hits will be traversed on the way to next cluster
1117     if (!lr->IsActive() || fClInfo[ilrA2=(ilrA<<1)]<0) continue; 
1118     //
1119     // select the order in which possible 2 clusters (in case of the overlap) will be traversed and fitted
1120     nclLr=0;
1121     if (dir>0) { // clusters are stored in increasing radius order
1122       iclLr[nclLr++]=fClInfo[ilrA2++];
1123       if (fClInfo[ilrA2]>=0) iclLr[nclLr++]=fClInfo[ilrA2];
1124     }
1125     else {
1126       if ( fClInfo[ilrA2+1]>=0 ) iclLr[nclLr++]=fClInfo[ilrA2+1];
1127       iclLr[nclLr++]=fClInfo[ilrA2];
1128     }
1129     //
1130     Bool_t transportedToLayer = kFALSE;
1131     for (int icl=0;icl<nclLr;icl++) {
1132       AliITSUClusterPix* clus =  (AliITSUClusterPix*)lr->GetCluster(iclLr[icl]);
1133       AliITSURecoSens* sens = lr->GetSensorFromID(clus->GetVolumeId());
1134       if (!tmpTr.Rotate(sens->GetPhiTF())) {
1135         AliDebug(2,Form("Failed on rotate to %f | ESDtrack#%d (MClb:%d)",sens->GetPhiTF(),fCurrESDtrack->GetID(),fCurrESDtrMClb));
1136         return kFALSE;
1137       }
1138       //
1139       double xClus = sens->GetXTF()+clus->GetX();
1140       if (!transportedToLayer) {
1141         if (ilr!=lrStart && !TransportToLayerX(&tmpTr,lrStart,ilr,xClus)) {
1142           AliDebug(2,Form("Failed to transport %d -> %d | ESDtrack#%d (MClb:%d)\n",lrStart,ilr,fCurrESDtrack->GetID(),fCurrESDtrMClb));
1143           //tmpTr.AliExternalTrackParam::Print(); trc->GetWinner()->Print("etp");
1144           return kFALSE; // go to the entrance to the layer
1145         }
1146         lrStart = ilr;
1147         transportedToLayer = kTRUE;
1148       }
1149       //
1150       if (AliDebugLevelClass()>1) {
1151         AliDebug(2,Form("Propagate to cl:%d on lr %d Need to go %.4f -> %.4f",icl,ilrA,tmpTr.GetX(),xClus));
1152         //      printf("Before: "); tmpTr.AliExternalTrackParam::Print();
1153       }
1154       //
1155       if (!PropagateSeed(&tmpTr,xClus,fCurrMass)) {
1156         AliDebug(2,Form("Failed on propagate to %f (dir=%d) | ESDtrack#%d (MClb:%d)",xClus,dir,fCurrESDtrack->GetID(),fCurrESDtrMClb));
1157         //tmpTr.AliExternalTrackParam::Print(""); trc->GetWinner()->Print("etp");
1158         return kFALSE;
1159       }
1160       //
1161 #ifdef  _FILL_CONTROL_HISTOS_
1162       int hcOffs = fTrackPhase*kHistosPhase + ilrA;
1163       double htrPt=-1;
1164       if (fCHistoArr && trc->GetLabel()>=0/* && trc->Charge()>0*/) {
1165         htrPt = tmpTr.Pt();
1166         double dy = clus->GetY()-tmpTr.GetY();
1167         double dz = clus->GetZ()-tmpTr.GetZ();
1168         ((TH2*)fCHistoArr->At(kHResY+hcOffs))->Fill(htrPt,dy);
1169         ((TH2*)fCHistoArr->At(kHResZ+hcOffs))->Fill(htrPt,dz);
1170         double errY = tmpTr.GetSigmaY2();
1171         double errZ = tmpTr.GetSigmaZ2();
1172         if (errY>0) ((TH2*)fCHistoArr->At(kHResYP+hcOffs))->Fill(htrPt,dy/Sqrt(errY));
1173         if (errZ>0) ((TH2*)fCHistoArr->At(kHResZP+hcOffs))->Fill(htrPt,dz/Sqrt(errZ));
1174       }
1175 #endif  
1176       //
1177       double chi2;
1178       if ( (chi2=tmpTr.Update(clus))<0 ) {
1179         AliDebug(2,Form("Failed on Update | ESDtrack#%d (MClb:%d)",fCurrESDtrack->GetID(),fCurrESDtrMClb));             
1180         return kFALSE;
1181       }
1182 #ifdef  _FILL_CONTROL_HISTOS_
1183       if (htrPt>0) {
1184         ((TH2*)fCHistoArr->At(kHChi2Cl+hcOffs))->Fill(htrPt,chi2);
1185       }
1186 #endif 
1187       if (AliDebugLevelClass()>1) {
1188         printf("AfterRefit: "); tmpTr.AliExternalTrackParam::Print();
1189       }
1190       if (stopAtLastCl && ++clCount==ncl) return kTRUE; // it was requested to not propagate after last update
1191     }
1192     //
1193   }
1194   // All clusters were succesfully fitted. Even if the track does not reach rDest, this is enough to validate it.
1195   // Still, try to go as close as possible to rDest.
1196   //
1197   if (lrStart!=lrStop) {
1198     //printf("Going to last layer %d -> %d\n",lrStart,lrStop);
1199     if (!TransportToLayer(&tmpTr,lrStart,lrStop)) {
1200       AliDebug(1,Form("Failed on TransportToLayer %d->%d | ESDtrack#%d (MClb:%d)",lrStart,lrStop,fCurrESDtrack->GetID(),fCurrESDtrMClb));
1201       //tmpTr.AliExternalTrackParam::Print();
1202       //trc->GetWinner()->Print("etp");
1203       return kTRUE;
1204     }    
1205     if (!GoToExitFromLayer(&tmpTr,fITS->GetLayer(lrStop),dir)) {
1206       AliDebug(3,Form("Failed on GoToExitFromLayer %d | ESDtrack#%d (MClb:%d)",lrStop,fCurrESDtrack->GetID(),fCurrESDtrMClb));
1207       return kTRUE; // go till the exit from layer
1208     }
1209     //
1210     //printf("On exit from last layer\n");
1211     //tmpTr.AliExternalTrackParam::Print();
1212     // go to the destination radius
1213     if (!tmpTr.GetXatLabR(rDest,rDest,GetBz(),dir)) return kTRUE;
1214     if (!PropagateSeed(&tmpTr,rDest,fCurrMass, 100, kFALSE)) return kTRUE;
1215   }
1216   trc->AliKalmanTrack::operator=(tmpTr);
1217   if (AliDebugLevelClass()>2) {
1218     printf("After refit (now at lr %d): ",lrStop); trc->AliExternalTrackParam::Print();
1219   }
1220   return kTRUE;
1221 }
1222
1223 //__________________________________________________________________
1224 void AliITSUTrackerGlo::CookMCLabel(AliITSUTrackHyp* hyp) 
1225 {
1226   // build MC label
1227   //
1228   const int kMaxLbPerCl = 3;
1229   int lbID[kMaxLayers*6],lbStat[kMaxLayers*6];
1230   Int_t lr,nLab=0,nCl=0;
1231   AliITSUSeed *seed = hyp->GetWinner();
1232   while(seed) {
1233     int clID = seed->GetLrCluster(lr);
1234     if (clID>=0) {
1235       AliCluster *cl = fITS->GetLayerActive(lr)->GetCluster(clID);
1236       nCl++;
1237       for (int imc=0;imc<kMaxLbPerCl;imc++) { // labels within single cluster
1238         int trLb = cl->GetLabel(imc);
1239         if (trLb<0) break;
1240         // search this mc track in already accounted ones
1241         int iLab;
1242         for (iLab=0;iLab<nLab;iLab++) if (lbID[iLab]==trLb) break;
1243         if (iLab<nLab) lbStat[iLab]++;
1244         else {
1245           lbID[nLab] = trLb;
1246           lbStat[nLab++] = 1;
1247         }
1248       } // loop over given cluster's labels
1249     }
1250     seed = (AliITSUSeed*)seed->GetParent();
1251   } // loop over clusters
1252   // 
1253   if (nCl && nLab) {
1254     int maxLab=0,nTPCok=0;
1255     AliESDtrack* esdTr = hyp->GetESDTrack();
1256     int tpcLab = esdTr ? Abs(esdTr->GetTPCLabel()) : -kDummyLabel;
1257     for (int ilb=nLab;ilb--;) {
1258       int st = lbStat[ilb];
1259       if (lbStat[maxLab]<st) maxLab=ilb;
1260       if (tpcLab==lbID[ilb]) nTPCok += st;
1261     }
1262     hyp->SetFakeRatio(1.-float(nTPCok)/nCl);
1263     hyp->SetLabel( nTPCok==nCl ? tpcLab : -tpcLab);
1264     hyp->SetITSLabel( lbStat[maxLab]==nCl ? lbStat[maxLab] : -lbStat[maxLab]); // winner label
1265     return;
1266   }
1267   //
1268   hyp->SetFakeRatio(-1.);
1269   hyp->SetLabel( kDummyLabel );
1270   hyp->SetITSLabel( kDummyLabel );
1271 }
1272
1273 //__________________________________________________________________
1274 Bool_t AliITSUTrackerGlo::AddSeedBranch(AliITSUSeed* seed)
1275 {
1276   // add new prolongation branch for the seed to temporary array. The seeds are sorted according to Compare f-n
1277   if (fNCandidatesAdded+fNBranchesAdded>=AliITSUTrackCond::kMaxCandidates ) {
1278     AliError(Form("Number of candidates for current seed reached limit of AliITSUTrackCond::kMaxCandidates=%d, increase it",AliITSUTrackCond::kMaxCandidates));
1279     return kFALSE;
1280   }
1281   AliITSUSeed** branches = &fLayerCandidates[fNCandidatesAdded]; // note: fNCandidatesAdded is incremented after adding all branches of current seed
1282   int slot=fNBranchesAdded++;
1283   for (int slotF=slot;slotF--;) { // slotF is always slot-1
1284     AliITSUSeed* si = branches[slotF];
1285     if (si->Compare(seed)<0) break; // found the last seed with better quality
1286     // otherwise, shift the worse seed to the next slot
1287     branches[slot] = si;
1288     slot = slotF; // slot should be slotF+1
1289   }
1290   // if needed, move worse seeds
1291   branches[slot] = seed;
1292   return kTRUE;
1293   //
1294 }
1295
1296 //__________________________________________________________________
1297 void AliITSUTrackerGlo::ValidateAllowedBranches(Int_t acceptMax)
1298 {
1299   // keep allowed number of branches for current seed and disable extras
1300   int nb = Min(fNBranchesAdded,acceptMax);
1301   //  if (nb<fNBranchesAdded) printf("ValidateAllowedBranches: %d of %d (%d) on lr %d\n",nb,fNBranchesAdded,fNCandidatesAdded,ilr);
1302   // disable unused branches
1303   AliITSUSeed** branches = &fLayerCandidates[fNCandidatesAdded];
1304   for (int ib=nb;ib<fNBranchesAdded;ib++) {
1305     /*
1306     if (!branches[ib]->ContainsFake()) {
1307       printf("Suppress good branch as %d of %d |",ib,fNBranchesAdded); branches[ib]->Print();
1308       printf("Survivors : \n");
1309       for (int j=0;j<nb;j++) branches[j]->Print();
1310     }
1311     */
1312     MarkSeedFree(branches[ib]);
1313   }
1314   fNCandidatesAdded += nb; // update total candidates counter
1315   fNBranchesAdded = 0; // reset branches counter
1316   //
1317 }
1318
1319 //__________________________________________________________________
1320 void AliITSUTrackerGlo::ValidateAllowedCandidates(Int_t ilr, Int_t acceptMax)
1321 {
1322   // transfer allowed number of branches to hypothesis container
1323   //
1324   // sort candidates in increasing order of chi2
1325   Int_t index[AliITSUTrackCond::kMaxCandidates];
1326   Float_t chi2[AliITSUTrackCond::kMaxCandidates];
1327   for (int i=fNCandidatesAdded;i--;) chi2[i] = fLayerCandidates[i]->GetChi2GloNrm();
1328   Sort(fNCandidatesAdded,chi2,index,kFALSE);
1329   //
1330   int nb = Min(fNCandidatesAdded,acceptMax);
1331   //  if (nb<fNCandidatesAdded) printf("ValidateAllowedCandidates: %d of %d on lr %d\n",nb,fNCandidatesAdded,ilr);
1332   //
1333   for (int ib=0;ib<nb;ib++) AddProlongationHypothesis(fLayerCandidates[index[ib]],ilr);
1334   // disable unused candidates
1335   for (int ib=nb;ib<fNCandidatesAdded;ib++) {
1336     /*
1337     if (!fLayerCandidates[index[ib]]->ContainsFake()) {
1338       printf("Suppress good candidate as %d of %d |",index[ib],fNCandidatesAdded); fLayerCandidates[index[ib]]->Print();
1339     }
1340     */
1341     MarkSeedFree(fLayerCandidates[index[ib]]);    
1342   }
1343   fNCandidatesAdded = 0; // reset candidates counter
1344   //
1345 }
1346
1347 //__________________________________________________________________
1348 void AliITSUTrackerGlo::FlagSplitClusters()
1349 {
1350   // set special bit on split clusters using MC info
1351   for (int ilr=fITS->GetNLayersActive();ilr--;) {
1352     int nsplit=0;
1353     AliITSURecoLayer* lr = fITS->GetLayerActive(ilr);
1354     for (int isn=lr->GetNSensors();isn--;) {
1355       AliITSURecoSens* sens = lr->GetSensor(isn);
1356       int nCl = sens->GetNClusters();
1357       if (!nCl) continue;
1358       int cl0 = sens->GetFirstClusterId();
1359       for (int icl=nCl;icl--;) {
1360         AliITSUClusterPix *cl = (AliITSUClusterPix*)lr->GetCluster(cl0+icl);
1361         for (int icl1=icl;icl1--;) {
1362           AliITSUClusterPix *cl1 = (AliITSUClusterPix*)lr->GetCluster(cl0+icl1);
1363           if (cl->HasCommonTrack(cl1)) {
1364             if (!cl->IsSplit())  nsplit++;
1365             if (!cl1->IsSplit()) nsplit++;
1366             cl->SetSplit();
1367             cl1->SetSplit();
1368           }
1369         }
1370       }
1371     }
1372     AliInfo(Form("%4d out of %4d clusters are split",nsplit,lr->GetNClusters()));
1373   }
1374   //
1375 }
1376
1377 //__________________________________________________________________
1378 Bool_t AliITSUTrackerGlo::ContainsSplitCluster(const AliITSUSeed* seed, Int_t maxSize)
1379 {
1380   // check if the seed contains split cluster with size < maxSize
1381   int lrID,clID;
1382   if ( (clID=seed->GetLrCluster(lrID))>=0 ) {
1383     AliITSUClusterPix* cl = (AliITSUClusterPix*)fITS->GetLayerActive(lrID)->GetCluster(clID);
1384     if (cl->IsSplit() && cl->GetNPix()<maxSize ) return kTRUE;
1385   }
1386   return seed->GetParent() ? ContainsSplitCluster((AliITSUSeed*)seed->GetParent(),maxSize) : kFALSE;
1387   //
1388 }
1389
1390 //__________________________________________________________________
1391 void AliITSUTrackerGlo::PrintSeedClusters(const AliITSUSeed* seed, Option_t* option)
1392 {
1393   // print seeds clusters
1394   int lrID,clID;
1395   if ( (clID=seed->GetLrCluster(lrID))>=0 ) {
1396     AliITSUClusterPix* cl = (AliITSUClusterPix*)fITS->GetLayerActive(lrID)->GetCluster(clID);
1397     cl->Print(option);
1398   }
1399   if (seed->GetParent()) PrintSeedClusters((AliITSUSeed*)seed->GetParent(), option);
1400   //
1401 }
1402
1403 #ifdef  _FILL_CONTROL_HISTOS_
1404 //__________________________________________________________________
1405 void AliITSUTrackerGlo::BookControlHistos()
1406 {
1407   // book special control histos
1408   if (!fCHistoArr) { // create control histos
1409     const int kNResDef=7;
1410     const double kResDef[kNResDef]={0.05,0.05,0.3, 0.05,1,0.5,1.5};
1411     fCHistoArr = new TObjArray();
1412     fCHistoArr->SetOwner(kTRUE);
1413     const double ptMax=10;
1414     const double plMax=10;
1415     const double chiMax=100;
1416     const int nptbins=50;
1417     const int nresbins=400;
1418     const int nplbins=50;
1419     const int nchbins=200;
1420     int nblr = fITS->GetNLayersActive();
1421     TString ttl;
1422     for (int stp=0;stp<kNTrackingPhases;stp++) {
1423       for (int ilr=0;ilr<nblr;ilr++) {
1424         int hoffs = stp*kHistosPhase + ilr;
1425         double mxdf = ilr>=kNResDef ? kResDef[kNResDef-1] : kResDef[ilr];
1426         ttl = Form("S%d_residY%d",stp,ilr);
1427         TH2F* hdy = new TH2F(ttl.Data(),ttl.Data(),nptbins,0,ptMax,nresbins,-mxdf,mxdf);
1428         fCHistoArr->AddAtAndExpand(hdy,hoffs + kHResY);
1429         hdy->SetDirectory(0);
1430         //
1431         ttl = Form("S%d_residYPull%d",stp,ilr); 
1432         TH2F* hdyp = new TH2F(ttl.Data(),ttl.Data(),nptbins,0,ptMax,nplbins,-plMax,plMax);
1433         fCHistoArr->AddAtAndExpand(hdyp,hoffs + kHResYP);
1434         hdyp->SetDirectory(0);
1435         //
1436         ttl = Form("S%d_residZ%d",stp,ilr);     
1437         TH2F* hdz = new TH2F(ttl.Data(),ttl.Data(),nptbins,0,ptMax,nresbins,-mxdf,mxdf);
1438         fCHistoArr->AddAtAndExpand(hdz,hoffs + kHResZ);
1439         hdz->SetDirectory(0);
1440         //
1441         ttl = Form("S%d_residZPull%d",stp,ilr);         
1442         TH2F* hdzp = new TH2F(ttl.Data(),ttl.Data(),nptbins,0,ptMax,nplbins,-plMax,plMax);
1443         hdzp->SetDirectory(0);
1444         fCHistoArr->AddAtAndExpand(hdzp,hoffs + kHResZP);
1445         //
1446         ttl = Form("S%d_chi2Cl%d",stp,ilr);             
1447         TH2F* hchi = new TH2F(ttl.Data(),ttl.Data(),nptbins,0,ptMax, nchbins,0.,chiMax);
1448         hchi->SetDirectory(0);
1449         fCHistoArr->AddAtAndExpand(hchi,hoffs + kHChi2Cl);
1450       }
1451     }
1452   }
1453   //  
1454 }
1455 #endif