1)Added used cluster flagging.
authorshahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 25 Apr 2013 18:24:42 +0000 (18:24 +0000)
committershahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 25 Apr 2013 18:24:42 +0000 (18:24 +0000)
2)Seed with missed layer added with the same criteria as other seeds (before: unconditionally)

ITS/UPGRADE/AliITSURecoLayer.cxx
ITS/UPGRADE/AliITSUTrackCond.cxx
ITS/UPGRADE/AliITSUTrackCond.h
ITS/UPGRADE/AliITSUTrackHyp.cxx
ITS/UPGRADE/AliITSUTrackHyp.h
ITS/UPGRADE/AliITSUTrackerGlo.cxx
ITS/UPGRADE/AliITSUTrackerGlo.h

index 56a6410..68f3917 100644 (file)
@@ -220,7 +220,7 @@ void AliITSURecoLayer::Build()
   } // ladders
   //
 }
-
+///*
 //______________________________________________________
 Int_t AliITSURecoLayer::FindSensors(const double* impPar, AliITSURecoSens *sensors[AliITSURecoSens::kNNeighbors])
 {
@@ -274,7 +274,7 @@ Int_t AliITSURecoLayer::FindSensors(const double* impPar, AliITSURecoSens *senso
   //
   return nsens;
 }
-
+//*/
 /*
 Int_t AliITSURecoLayer::FindSensors(const double* impPar, AliITSURecoSens *sensors[AliITSURecoSens::kNNeighbors],int mcLab)
 {
index 31926b6..db0eee1 100644 (file)
@@ -6,6 +6,7 @@
 using namespace AliITSUAux;
 using namespace TMath;
 
+Char_t    AliITSUTrackCond::fgkClSharing = 0;
 Int_t     AliITSUTrackCond::fgkMaxBranches = 50;
 Int_t     AliITSUTrackCond::fgkMaxCandidates = 500;
 Float_t   AliITSUTrackCond::fgkMaxTr2ClChi2  = 50.;
@@ -15,6 +16,7 @@ Float_t   AliITSUTrackCond::fgkMissPenalty  = 2.;
 AliITSUTrackCond::AliITSUTrackCond(int nLayers)
   :fInitDone(kFALSE)
   ,fNLayers(0)
+  ,fClSharing(0)
   ,fMaxBranches(0)
   ,fMaxCandidates(0)
   ,fMaxTr2ClChi2(0)
@@ -34,6 +36,7 @@ AliITSUTrackCond::AliITSUTrackCond(const AliITSUTrackCond& src)
   :TObject(src)
   ,fInitDone(src.fInitDone)
   ,fNLayers(0)
+  ,fClSharing(0)
   ,fMaxBranches(0)
   ,fMaxCandidates(0)
   ,fMaxTr2ClChi2(0)
@@ -53,6 +56,7 @@ AliITSUTrackCond::AliITSUTrackCond(const AliITSUTrackCond& src)
     SetMissPenalty(i,src.GetMissPenalty(i));
     SetNSigmaRoadY(i,src.GetNSigmaRoadY(i));
     SetNSigmaRoadZ(i,src.GetNSigmaRoadZ(i));
+    SetClSharing(i,src.GetClSharing(i));
   }
 }
 
@@ -74,6 +78,7 @@ AliITSUTrackCond& AliITSUTrackCond::operator=(const AliITSUTrackCond& src)
       SetMissPenalty(i,src.GetMissPenalty(i));
       SetNSigmaRoadY(i,src.GetNSigmaRoadY(i));
       SetNSigmaRoadZ(i,src.GetNSigmaRoadZ(i));
+      SetClSharing(i,src.GetClSharing(i));
     }
     fAuxData = src.fAuxData;
   }
@@ -86,6 +91,7 @@ void AliITSUTrackCond::SetNLayers(int nLayers)
   // set number of layers
   fInitDone = kFALSE;
   if (fNLayers) {
+    delete fClSharing;
     delete fMaxBranches;
     delete fMaxCandidates;
     delete fMaxTr2ClChi2;
@@ -96,13 +102,15 @@ void AliITSUTrackCond::SetNLayers(int nLayers)
   fNLayers = nLayers;
   //
   if (fNLayers>0) {
-    fMaxBranches = new Short_t[fNLayers];
+    fClSharing     = new Char_t[fNLayers];
+    fMaxBranches   = new Short_t[fNLayers];
     fMaxCandidates = new Short_t[fNLayers];
     fMaxTr2ClChi2  = new Float_t[fNLayers];
     fMissPenalty   = new Float_t[fNLayers];
     fNSigmaRoadY   = new Float_t[fNLayers];
     fNSigmaRoadZ   = new Float_t[fNLayers];
     for (int i=fNLayers;i--;) {
+      SetClSharing(i,fgkClSharing);
       SetMaxBranches(i,fgkMaxBranches);
       SetMaxCandidates(i,fgkMaxCandidates);
       SetMaxTr2ClChi2(i,fgkMaxTr2ClChi2);
@@ -112,6 +120,7 @@ void AliITSUTrackCond::SetNLayers(int nLayers)
     }
   }
   else {
+    fClSharing     = 0;
     fMaxBranches   = 0;
     fMaxCandidates = 0;
     fMaxTr2ClChi2  = 0;
@@ -185,10 +194,10 @@ void AliITSUTrackCond::Print(Option_t*) const
     printf("\n");
     cntCond += kNAuxSz;
   }
-  printf("Cuts:\t%8s\t%8s\t%8s\t%8s\t%8s\t%8s\n", "MaxBrn","MaxCand","Chi2Cl","Mis.Pen.","NSig.Y","NSig.Z");
+  printf("Cuts:\t%6s\t%6s\t%4s\t%8s\t%8s\t%8s\t%8s\n", "MaxBrn","MaxCnd","ClSh","Chi2Cl","Mis.Pen.","NSig.Y","NSig.Z");
   for (int i=0;i<fNLayers;i++) {
-    printf("Lr%2d:\t%8d\t%8d\t%8.1f\t%8.2f\t%8.2f\t%8.2f\n",i,
-          fMaxBranches[i],fMaxCandidates[i],fMaxTr2ClChi2[i],fMissPenalty[i],fNSigmaRoadY[i],fNSigmaRoadZ[i]);
+    printf("Lr%2d:\t%6d\t%6d\t%4d\t%8.1f\t%8.2f\t%8.2f\t%8.2f\n",i,
+          fMaxBranches[i],fMaxCandidates[i],fClSharing[i],fMaxTr2ClChi2[i],fMissPenalty[i],fNSigmaRoadY[i],fNSigmaRoadZ[i]);
   }
   //
 }
index d5fbd42..240b158 100644 (file)
@@ -34,6 +34,7 @@ class AliITSUTrackCond : public TObject
   ~AliITSUTrackCond() {}
   
   void        SetNLayers(Int_t nl);
+  void        SetClSharing(Int_t lr, Char_t v=0)   {fClSharing[lr] = v;}
   void        SetMaxBranches(Int_t lr, Int_t mb)   {fMaxBranches[lr] = mb;}
   void        SetMaxCandidates(Int_t lr, Int_t nc) {fMaxCandidates[lr] = nc;}
   void        SetID(Int_t id)                      {SetUniqueID(id);}
@@ -54,6 +55,7 @@ class AliITSUTrackCond : public TObject
   void        SetNSigmaRoadY(Int_t lr,  Float_t v)           {fNSigmaRoadY[lr] = v;}
   void        SetNSigmaRoadZ(Int_t lr,  Float_t v)           {fNSigmaRoadZ[lr] = v;}
   //
+  Char_t      GetClSharing(Int_t lr)                   const {return fClSharing[lr];}
   Float_t     GetMissPenalty(Int_t lr)                 const {return fMissPenalty[lr];}
   Float_t     GetMaxTr2ClChi2(Int_t lr)                const {return fMaxTr2ClChi2[lr];}
   Float_t     GetNSigmaRoadY(Int_t lr)                 const {return fNSigmaRoadY[lr];}
@@ -67,6 +69,7 @@ class AliITSUTrackCond : public TObject
   //
   Bool_t      fInitDone;                 // initialization flag
   Int_t       fNLayers;                  // total number of layers
+  Char_t*     fClSharing;                // [fNLayers] is cluster sharing allowed
   Short_t*    fMaxBranches;              // [fNLayers] max allowed branches per seed on each layer
   Short_t*    fMaxCandidates;            // [fNLayers] max allowed candidates per TPC seed on each layer
   Float_t*    fMaxTr2ClChi2;             // [fNLayers] max track-to-cluster chi2
@@ -78,6 +81,7 @@ class AliITSUTrackCond : public TObject
   TArrayS     fConditions;               // fNConditions  set of conditions
   TArrayS     fAuxData;                  // condition beginning (1st group), n groups, min clus
   //
+  static Char_t  fgkClSharing;           // def cl.sharing allowed level
   static Int_t   fgkMaxBranches;          // def max number of branches per seed on current layer 
   static Int_t   fgkMaxCandidates;        // def max number of total candidates on current layer 
   static Float_t fgkMaxTr2ClChi2;         // def track-to-cluster chi2 cut
index aa8db93..55154e6 100644 (file)
@@ -12,6 +12,7 @@ AliITSUTrackHyp::AliITSUTrackHyp(Int_t nlr)
 : fNLayers(nlr)
   ,fITSLabel(0)
   ,fESDTrack(0)
+  ,fWinner(0)
   ,fLayerSeeds(0)
 {
   // def. c-tor
@@ -31,9 +32,10 @@ AliITSUTrackHyp::AliITSUTrackHyp(const AliITSUTrackHyp &src)
   , fNLayers(src.fNLayers)
   , fITSLabel(src.fITSLabel)
   , fESDTrack(src.fESDTrack)
+  , fWinner(0)
   , fLayerSeeds(0)
 {
-  // copy c-tor
+  // copy c-tor. Note: it is shallow
   if (fNLayers>0) {
     fLayerSeeds = new TObjArray[fNLayers];
     for (int ilr=fNLayers;ilr--;) {
@@ -44,6 +46,7 @@ AliITSUTrackHyp::AliITSUTrackHyp(const AliITSUTrackHyp &src)
        AddSeed(sd,ilr);
       }      
     }
+    fWinner = src.fWinner;
   }
   //
 }
@@ -70,7 +73,7 @@ void AliITSUTrackHyp::Print(Option_t* ) const
 AliITSUSeed* AliITSUTrackHyp::GetWinner() const
 {
   // Get best candidate. TODO
-  return fLayerSeeds[0].GetEntriesFast()>0 ? GetSeed(0,0) : 0;
+  return fWinner;
 }
 
 //__________________________________________________________________
@@ -78,11 +81,11 @@ AliITSUSeed* AliITSUTrackHyp::DefineWinner(int lr, int id)
 {
   // assign best candidate
   if (GetNSeeds(lr)<=id) return 0;
-  AliITSUSeed* winner = GetSeed(lr,id);
-  this->AliExternalTrackParam::operator=(*winner);
-  SetChi2(winner->GetChi2GloNrm());
-  SetNumberOfClusters(winner->GetNLayersHit());
-  return winner;
+  fWinner = GetSeed(lr,id);
+  this->AliExternalTrackParam::operator=(*fWinner);
+  SetChi2(fWinner->GetChi2GloNrm());
+  SetNumberOfClusters(fWinner->GetNLayersHit());
+  return fWinner;
 }
 
 //__________________________________________________________________
index 15edd9f..617ded3 100644 (file)
@@ -48,6 +48,7 @@ class AliITSUTrackHyp: public AliKalmanTrack
   UChar_t          fNLayers;               // number of layers
   Int_t            fITSLabel;              // ITS MC Label, the global one (wrt TPC) is fLab
   AliESDtrack*     fESDTrack;              // reference esd track
+  AliITSUSeed*     fWinner;                // winner seed
   TObjArray*       fLayerSeeds;            // seeds of given layer
   //
   ClassDef(AliITSUTrackHyp,1)
index 9142c21..052efda 100644 (file)
@@ -69,6 +69,8 @@ AliITSUTrackerGlo::AliITSUTrackerGlo(AliITSUReconstructor* rec)
   ,fLastSeedID(0)
   ,fDefTrackConds(0)
   ,fCurrTrackCond(0)
+  ,fCurrActLrID(-1)
+  ,fCurrLayer(0)
   ,fTrackPhase(-1)
   ,fClInfo(0)
 #ifdef  _FILL_CONTROL_HISTOS_
@@ -147,7 +149,7 @@ Int_t AliITSUTrackerGlo::Clusters2Tracks(AliESDEvent *esdEv)
 #ifdef  _FILL_CONTROL_HISTOS_
   if (!fCHistoArr) BookControlHistos();
 #endif
-
+  static int evID = 0;
   TObjArray *trackConds = 0;
   //
   fCountProlongationTrials = 0;
@@ -190,7 +192,24 @@ Int_t AliITSUTrackerGlo::Clusters2Tracks(AliESDEvent *esdEv)
       fCurrESDtrMClb = fCurrESDtrack->GetLabel();
       //
       if (!NeedToProlong(fCurrESDtrack)) continue;  // are we interested in this track?
-      AliDebug(+1,Form("Processing track %d | M=%.3f Pt=%.3f | MCLabel: %d",itr,fCurrESDtrack->GetMass(kTRUE),fCurrESDtrack->Pt(),fCurrESDtrMClb));//RS
+      /*
+       // if speceific tracks should be checked, create a global array int wtc[] = {evITS*10000+trID, ...};
+      Bool_t dbg = kFALSE;
+      int nwtc = sizeof(wtc)/sizeof(int);
+
+      for (int k=0;k<nwtc;k++) {
+       if (wtc[k]==evID*10000+itr) {
+         dbg = kTRUE;
+         printf("\n\n\n\n\n\n\n");
+         printf("At esdTr: %d MC: %d\n",wtc[k],fCurrESDtrMClb);
+         printf("\n\n\n\n\n\n\n");
+         break;
+       }
+      }
+      AliLog::SetClassDebugLevel("AliITSUTrackerGlo",dbg ? 10:0);
+      */
+
+      AliDebug(1,Form("Processing track %d | M=%.3f Pt=%.3f | MCLabel: %d",itr,fCurrESDtrack->GetMass(kTRUE),fCurrESDtrack->Pt(),fCurrESDtrMClb));//RS
       FindTrack(fCurrESDtrack, itr);
     }   
     //
@@ -199,9 +218,12 @@ Int_t AliITSUTrackerGlo::Clusters2Tracks(AliESDEvent *esdEv)
       fHypStore.Print();
     }
     FinalizeHypotheses();
+    //
+    //AliLog::SetClassDebugLevel("AliITSUTrackerGlo",0);     // in case wtc array was defined, uncomment this
   }
   //
   AliInfo(Form("%d ITSin for %d tried TPC seeds out of %d ESD tracks\n",fCountITSin,fCountProlongationTrials,nTrESD));
+  evID++;
   return 0;
 }
 
@@ -391,6 +413,9 @@ void AliITSUTrackerGlo::FindTrack(AliESDtrack* esdTr, Int_t esdID)
   //
   int nLrActive = fITS->GetNLayersActive();
   for (int ila=nLrActive;ila--;) {
+    fCurrActLrID = ila;
+    fCurrLayer = fITS->GetLayerActive(ila);
+    Bool_t noClSharing = fCurrTrackCond->GetClSharing(ila)==0;
     int ilaUp = ila+1;                         // prolong seeds from layer above
     //
     // for the outermost layer the seed is created from the ESD track
@@ -406,6 +431,7 @@ void AliITSUTrackerGlo::FindTrack(AliESDtrack* esdTr, Int_t esdID)
       }
       else {
        seedU = fCurrHyp->GetSeed(ilaUp,isd);  // seed on prev.active layer to prolong  
+       if (seedU->IsKilled()) continue;
        seedUC = *seedU;                       // its copy will be prolonged
        seedUC.SetParent(seedU);        
       }
@@ -419,7 +445,6 @@ void AliITSUTrackerGlo::FindTrack(AliESDtrack* esdTr, Int_t esdID)
        if (NeedToKill(&seedUC,kTransportFailed) && seedU) KillSeed(seedU,kTRUE);
        continue; // RS TODO: decide what to do with tracks stopped on higher layers w/o killing
       }
-      AliITSURecoLayer* lrA = fITS->GetLayerActive(ila);
       if (!GetRoadWidth(&seedUC, ila)) { // failed to find road width on the layer
        if (NeedToKill(&seedUC,kRWCheckFailed) && seedU) KillSeed(seedU,kTRUE);
        continue;
@@ -427,15 +452,15 @@ void AliITSUTrackerGlo::FindTrack(AliESDtrack* esdTr, Int_t esdID)
       /*
       //RS toremove
       int mcquest = -1;
-      if (!seedUC.ContainsFake()) {
+      if (!seedUC.ContainsFake() && AliDebugLevelClass()>2) {
        mcquest = fCurrESDtrMClb;
        seedUC.Print("etp");
        printf("FSParams: "); for (int ip=0;ip<kNTrImpData;ip++) printf("%+e ",fTrImpData[ip]); printf("\n");
       }
       //
-      int nsens = lrA->FindSensors(&fTrImpData[kTrPhi0], hitSens, mcquest);  // find detectors which may be hit by the track
+      int nsens = fCurrLayer->FindSensors(&fTrImpData[kTrPhi0], hitSens, mcquest);  // find detectors which may be hit by the track
       */
-      int nsens = lrA->FindSensors(&fTrImpData[kTrPhi0], hitSens);  // find detectors which may be hit by the track
+      int nsens = fCurrLayer->FindSensors(&fTrImpData[kTrPhi0], hitSens);  // find detectors which may be hit by the track
       AliDebug(2,Form("Will check %d sensors on lr:%d | esdID=%d (MClb:%d)",nsens,ila,esdID,fCurrESDtrMClb));
       //
       seedUC.SetLr(ila);
@@ -447,7 +472,7 @@ void AliITSUTrackerGlo::FindTrack(AliESDtrack* esdTr, Int_t esdID)
        if (!ncl) continue;
        seedT = seedUC;
        //
-       // We need to propagate the seed to sensor on lrA staying in the frame of the sensor from prev.layer,
+       // We need to propagate the seed to sensor on fCurrLayer staying in the frame of the sensor from prev.layer,
        // since the transport matrix should be defined in this frame.
        double xs; // X in the TF of current seed, corresponding to intersection with sensor plane
        if (!seedT.GetTrackingXAtXAlpha(sens->GetXTF(),sens->GetPhiTF(),bz, xs)) {
@@ -476,9 +501,11 @@ void AliITSUTrackerGlo::FindTrack(AliESDtrack* esdTr, Int_t esdID)
        //
        int clID0 = sens->GetFirstClusterId();
        for (int icl=ncl;icl--;) { // don't change the order, clusters are sorted
-         //      AliLog::SetClassDebugLevel("AliITSUTrackerGlo",10);
+         //AliLog::SetClassDebugLevel("AliITSUTrackerGlo",10);
+         int clID = clID0 + icl;
+         if (noClSharing && fCurrLayer->GetCluster(clID)->IsClusterUsed()) continue;
          int res = CheckCluster(&seedT,ila,clID0+icl);
-         //      AliLog::SetClassDebugLevel("AliITSUTrackerGlo", 0);
+         //AliLog::SetClassDebugLevel("AliITSUTrackerGlo", 0);
          //
          if (res==kStopSearchOnSensor) break;     // stop looking on this sensor
          if (res==kClusterNotMatching) continue;  // cluster does not match
@@ -491,7 +518,8 @@ void AliITSUTrackerGlo::FindTrack(AliESDtrack* esdTr, Int_t esdID)
        double penalty = -fCurrTrackCond->GetMissPenalty(ila);
        // to do: make penalty to account for probability to miss the cluster for good reason
        seedSkp->SetChi2Cl(penalty);
-       AddProlongationHypothesis(seedSkp,ila);      
+       AddSeedBranch(seedSkp);
+       //      AddProlongationHypothesis(seedSkp,ila);      
       }
       // transfer the new branches of the seed to the hypothesis container
       if (fNBranchesAdded) ValidateAllowedBranches(maxNBranches);
@@ -830,7 +858,8 @@ Int_t AliITSUTrackerGlo::CheckCluster(AliITSUSeed* track, Int_t lr, Int_t clID)
   //           kClusterMatching    otherwise
   //
   const double kTolerX = 5e-4;
-  AliCluster *cl = fITS->GetLayerActive(lr)->GetCluster(clID);
+  //  AliCluster *cl = fITS->GetLayerActive(lr)->GetCluster(clID);
+  AliCluster *cl = fCurrLayer->GetCluster(clID);
   //
   Bool_t goodCl = kFALSE;
   int currLabel = Abs(fCurrESDtrMClb);
@@ -930,7 +959,7 @@ Int_t AliITSUTrackerGlo::CheckCluster(AliITSUSeed* track, Int_t lr, Int_t clID)
   }
   track->SetChi2Cl(chi2);
   track->SetLrClusterID(lr,clID);
-  cl->IncreaseClusterUsage();
+  //  cl->IncreaseClusterUsage(); // do this only for winners
   //
   track->SetFake(!goodCl);
   //
@@ -938,6 +967,11 @@ Int_t AliITSUTrackerGlo::CheckCluster(AliITSUSeed* track, Int_t lr, Int_t clID)
               goodCl,clID,lr,dy,dz2,cl->GetLabel(0),cl->GetLabel(1),cl->GetLabel(2), chi2, track->IsFake() ? '-':'+'));
   //
   AddSeedBranch(track);
+#ifdef  _FILL_CONTROL_HISTOS_
+  if (htrPt>0) {
+    ((TH2*)fCHistoArr->At(kHChi2Nrm+hcOffs))->Fill(htrPt,track->GetChi2GloNrm());
+  }
+#endif
   //
   return kClusterMatching;
 }
@@ -950,7 +984,7 @@ Bool_t AliITSUTrackerGlo::NeedToKill(AliITSUSeed *seed, Int_t flag)
   if (flag==kMissingCluster) {
     int lastChecked = seed->GetLayerID();
     UShort_t patt = seed->GetHitsPattern();
-    if (lastChecked) patt |= ~(kMask<<lastChecked); // not all layers were checked, complete unchecked once by potential hits
+    if (lastChecked) patt |= ~(kMask<<lastChecked); // not all layers were checked, complete unchecked ones by potential hits
     Bool_t seedOK = fCurrTrackCond->CheckPattern(patt);
     return !seedOK;
   }
@@ -1068,15 +1102,19 @@ void AliITSUTrackerGlo::FinalizeHypotheses()
   AliDebug(2,"TODO");
   //
   int nh = fHypStore.GetEntriesFast();
+  AliITSUSeed* winner = 0;
   for (int ih=0;ih<nh;ih++) {
     AliITSUTrackHyp* hyp = (AliITSUTrackHyp*) fHypStore.UncheckedAt(ih); 
-    if (!hyp || !hyp->DefineWinner()) continue; // TODO
-    if (hyp->GetESDTrack()->IsOn(AliESDtrack::kITSin)) continue;
+    if (!hyp) continue; // removed
+    if (hyp->GetESDTrack()->IsOn(AliESDtrack::kITSin)) continue; // winner already defined
+    //
+    if (!(winner=hyp->DefineWinner())) continue;   // failed to find winner
+    FlagSeedClusters(winner,kTRUE);
     fCountITSin++;
     CookMCLabel(hyp);
     UpdateESDTrack(hyp,AliESDtrack::kITSin);
   }
-
+  //
 }
 
 //______________________________________________________________________________
@@ -1326,9 +1364,20 @@ void AliITSUTrackerGlo::ValidateAllowedBranches(Int_t acceptMax)
   //  if (nb<fNBranchesAdded) printf("ValidateAllowedBranches: %d of %d (%d) on lr %d\n",nb,fNBranchesAdded,fNCandidatesAdded,ilr);
   // disable unused branches
   AliITSUSeed** branches = &fLayerCandidates[fNCandidatesAdded];
+#ifdef  _FILL_CONTROL_HISTOS_
+  int bestID = -1;
+  for (int ib=0;ib<fNBranchesAdded;ib++) {
+    AliITSUSeed* sd = branches[ib];
+    if (!sd->ContainsFake() && (bestID<0 || sd->Compare(branches[bestID])<0) ) bestID = ib;
+  }
+  if (bestID>=0) {
+    TH2* hb = (TH2*)fCHistoArr->At(kHBestInBranch + fTrackPhase*kHistosPhase + fCurrActLrID);
+    if (hb) hb->Fill(branches[bestID]->Pt(), bestID);
+  }
+#endif
   for (int ib=nb;ib<fNBranchesAdded;ib++) {
     /*
-    if (!branches[ib]->ContainsFake()) {
+    if (AliDebugLevelClass()>+2 && !branches[ib]->ContainsFake()) {
       printf("Suppress good branch as %d of %d |",ib,fNBranchesAdded); branches[ib]->Print();
       printf("Survivors : \n");
       for (int j=0;j<nb;j++) branches[j]->Print();
@@ -1352,14 +1401,25 @@ void AliITSUTrackerGlo::ValidateAllowedCandidates(Int_t ilr, Int_t acceptMax)
   for (int i=fNCandidatesAdded;i--;) chi2[i] = fLayerCandidates[i]->GetChi2GloNrm();
   Sort(fNCandidatesAdded,chi2,index,kFALSE);
   //
+#ifdef  _FILL_CONTROL_HISTOS_
+  int bestID = -1;
+  for (int ib=0;ib<fNCandidatesAdded;ib++) {
+    AliITSUSeed* sd = fLayerCandidates[index[ib]];
+    if (!sd->ContainsFake() && (bestID<0 || sd->Compare(fLayerCandidates[index[bestID]])<0) ) bestID = ib;
+  }
+  if (bestID>=0) {
+    TH2* hb = (TH2*)fCHistoArr->At(kHBestInCand + fTrackPhase*kHistosPhase + fCurrActLrID);
+    if (hb) hb->Fill(fLayerCandidates[index[bestID]]->Pt(), bestID);
+  }
+#endif
+  //
   int nb = Min(fNCandidatesAdded,acceptMax);
-  //  if (nb<fNCandidatesAdded) printf("ValidateAllowedCandidates: %d of %d on lr %d\n",nb,fNCandidatesAdded,ilr);
   //
   for (int ib=0;ib<nb;ib++) AddProlongationHypothesis(fLayerCandidates[index[ib]],ilr);
   // disable unused candidates
   for (int ib=nb;ib<fNCandidatesAdded;ib++) {
     /*
-    if (!fLayerCandidates[index[ib]]->ContainsFake()) {
+    if (AliDebugLevelClass()>+2 && !fLayerCandidates[index[ib]]->ContainsFake()) {
       printf("Suppress good candidate as %d of %d |",index[ib],fNCandidatesAdded); fLayerCandidates[index[ib]]->Print();
     }
     */
@@ -1425,6 +1485,20 @@ void AliITSUTrackerGlo::PrintSeedClusters(const AliITSUSeed* seed, Option_t* opt
   //
 }
 
+//__________________________________________________________________
+void AliITSUTrackerGlo::FlagSeedClusters(const AliITSUSeed* seed, Bool_t flg)
+{
+  // mark used clusters
+  int lrID,clID;
+  while (seed) {
+    if ( (clID=seed->GetLrCluster(lrID))>=0 ) fITS->GetLayerActive(lrID)->GetCluster(clID)->SetBit(AliCluster::kUsed,flg);
+    seed = (AliITSUSeed*)seed->GetParent();
+  }
+  //
+}
+
+
+
 #ifdef  _FILL_CONTROL_HISTOS_
 //__________________________________________________________________
 void AliITSUTrackerGlo::BookControlHistos()
@@ -1442,6 +1516,8 @@ void AliITSUTrackerGlo::BookControlHistos()
     const int nresbins=400;
     const int nplbins=50;
     const int nchbins=200;
+    const int maxBr  = 15;
+    const int maxCand = 200;
     int nblr = fITS->GetNLayersActive();
     TString ttl;
     for (int stp=0;stp<kNTrackingPhases;stp++) {
@@ -1472,6 +1548,24 @@ void AliITSUTrackerGlo::BookControlHistos()
        TH2F* hchi = new TH2F(ttl.Data(),ttl.Data(),nptbins,0,ptMax, nchbins,0.,chiMax);
        hchi->SetDirectory(0);
        fCHistoArr->AddAtAndExpand(hchi,hoffs + kHChi2Cl);
+       //
+       ttl = Form("S%d_chi2Nrm%d",stp,ilr);            
+       TH2F* hchiN = new TH2F(ttl.Data(),ttl.Data(),nptbins,0,ptMax, nchbins,0.,chiMax);
+       hchiN->SetDirectory(0);
+       fCHistoArr->AddAtAndExpand(hchiN,hoffs + kHChi2Nrm);
+       //
+       if (stp==0) { // these histos make sense only for clusters2tracks stage
+         ttl = Form("S%d_bestInBranch%d",stp,ilr);             
+         TH2* hnbr = new TH2F(ttl.Data(),ttl.Data(),nptbins,0,ptMax, maxBr,-0.5,maxBr-0.5);
+         hnbr->SetDirectory(0);
+         fCHistoArr->AddAtAndExpand(hnbr,hoffs + kHBestInBranch);
+         //
+         ttl = Form("S%d_bestInCands%d",stp,ilr);              
+         TH2* hncn = new TH2F(ttl.Data(),ttl.Data(),nptbins,0,ptMax, maxCand,-0.5,maxCand-0.5);
+         hncn->SetDirectory(0);
+         fCHistoArr->AddAtAndExpand(hncn,hoffs + kHBestInCand);
+         //
+       }
       }
     }
   }
index 166428d..54583b8 100644 (file)
@@ -90,6 +90,7 @@ class AliITSUTrackerGlo : public AliTracker {
   Bool_t                 AddSeedBranch(AliITSUSeed* seed);
   void                   ValidateAllowedBranches(Int_t accMax);
   void                   ValidateAllowedCandidates(Int_t ilr, Int_t accMax);
+  void                   FlagSeedClusters(const AliITSUSeed* seed, Bool_t flg);
   //
   AliITSUSeed*           NewSeedFromPool(const AliITSUSeed* src=0);
   void                   ResetSeedsPool();
@@ -137,8 +138,10 @@ class AliITSUTrackerGlo : public AliTracker {
   Int_t                           fLastSeedID;     //! id of the pool seed on which is returned by the NextFreeSeed method
   //
   TObjArray                       fDefTrackConds;  //! default tracking conditions
-  AliITSUTrackCond*               fCurrTrackCond;  // current tracking condition
-  Int_t                           fTrackPhase;     // tracking phase
+  AliITSUTrackCond*               fCurrTrackCond;  //! current tracking condition
+  Int_t                           fCurrActLrID;    //! current active layer ID being processed (set only when needed, not guaranteed)
+  AliITSURecoLayer*               fCurrLayer;      //! current layer being processed  (set only when needed, not guaranteed)
+  Int_t                           fTrackPhase;     //! tracking phase
   Int_t*                          fClInfo;         //! auxiliary track cluster info
   //
   static const Double_t           fgkToler;        // tracking tolerance
@@ -147,7 +150,7 @@ class AliITSUTrackerGlo : public AliTracker {
   // this code is only for special histos needed to extract some control parameters
   void BookControlHistos();
   TObjArray* fCHistoArr;
-  enum {kHResY=0,kHResYP=10,kHResZ=20,kHResZP=30,kHChi2Cl=40};
+  enum {kHResY=0,kHResYP=10,kHResZ=20,kHResZP=30,kHChi2Cl=40,kHChi2Nrm=50,kHBestInBranch=60,kHBestInCand=70};
   enum {kHistosPhase=100};
   //
 #endif