RICH/AliRICHClusterFinder.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 #include "AliRICHClusterFinder.h"
  18 #include "AliRICHMap.h"
  19 #include <TMinuit.h>
  20 #include <TParticle.h>
  21 #include <TVector3.h>
  22 #include <AliLoader.h>
  23 #include <AliStack.h>
  24 #include <AliRun.h>
  25
  26 void RICHMinMathieson(Int_t &npar, Double_t *gin, Double_t &chi2, Double_t *par, Int_t iflag);
  27
  28 ClassImp(AliRICHClusterFinder)
  29 //__________________________________________________________________________________________________
  30 AliRICHClusterFinder::AliRICHClusterFinder(AliRICH *pRICH)
  31 {//main ctor
  32 //  Info("main ctor","Start.");
  33
  34   fRICH = pRICH;
  35
  36   fHitMap = 0;
  37   fRawCluster.Reset();
  38   fResolvedCluster.Reset();
  39
  40 }//main ctor
  41 //__________________________________________________________________________________________________
  42 void AliRICHClusterFinder::FindLocalMaxima()
  43 {
  44 //  Find number of local maxima in the cluster
  45 //  Info("FindLocalMaxima","Start.");
  46
  47   fNlocals = 0;
  48   for(Int_t iDig1=0;iDig1<fRawCluster.Size();iDig1++) {
  49     Int_t iNotMax = 0;
  50     AliRICHdigit *pDig1 = (AliRICHdigit *)fRawCluster.Digits()->At(iDig1);
  51     Int_t padX1 = pDig1->X();
  52     Int_t padY1 = pDig1->Y();
  53     Int_t padQ1 = (Int_t)(pDig1->Q()+0.1);
  54     Int_t padC1 = pDig1->CombiPid();
  55     for(Int_t iDig2=0;iDig2<fRawCluster.Size();iDig2++) {
  56       AliRICHdigit *pDig2 = (AliRICHdigit *)fRawCluster.Digits()->At(iDig2);
  57       Int_t padX2 = pDig2->X();
  58       Int_t padY2 = pDig2->Y();
  59       Int_t padQ2 = (Int_t)(pDig2->Q()+0.1);
  60       if(iDig1==iDig2) continue;
  61       Int_t diffx = TMath::Sign(padX1-padX2,1);
  62       Int_t diffy = TMath::Sign(padY1-padY2,1);
  63       if((diffx+diffy)<=1) {
  64          if(padQ2>=padQ1) iNotMax++;
  65       }
  66     }
  67     if(iNotMax==0) {
  68       TVector2 x2=AliRICHParam::Pad2Loc(padX1,padY1);
  69       fLocalX[fNlocals]=x2.X();fLocalY[fNlocals]=x2.Y();
  70       fLocalQ[fNlocals] = (Double_t)padQ1;
  71       fLocalC[fNlocals] = padC1;
  72       fNlocals++;
  73     }
  74   }
  75 }//FindLocalMaxima()
  76 //__________________________________________________________________________________________________
  77 void AliRICHClusterFinder::Exec()
  78 {
  79   Info("Exec","Start.");
  80
  81
  82   Rich()->GetLoader()->LoadDigits();
  83
  84   Rich()->GetLoader()->GetRunLoader()->LoadHeader();
  85   Rich()->GetLoader()->GetRunLoader()->LoadKinematics();
  86
  87   for(Int_t iEventN=0;iEventN<gAlice->GetEventsPerRun();iEventN++){//events loop
  88     Info("Exec","Event %i processed.",iEventN+1);
  89 //    gAlice->GetRunLoader()->GetEvent(iEventN);
  90     Rich()->GetLoader()->GetRunLoader()->GetEvent(iEventN);
  91
  92     Rich()->GetLoader()->MakeTree("R");  Rich()->MakeBranch("R");
  93     Rich()->ResetDigits();  Rich()->ResetClusters();
  94
  95     Rich()->GetLoader()->TreeD()->GetEntry(0);
  96     for(Int_t iChamber=1;iChamber<=kNCH;iChamber++){//chambers loop
  97       FindClusters(iChamber);
  98     }//chambers loop
  99     Rich()->GetLoader()->TreeR()->Fill();
 100     Rich()->GetLoader()->WriteRecPoints("OVERWRITE");
 101   }//events loop
 102   Rich()->GetLoader()->UnloadDigits(); Rich()->GetLoader()->UnloadRecPoints();
 103   Rich()->ResetDigits();  Rich()->ResetClusters();
 104
 105   Rich()->GetLoader()->GetRunLoader()->UnloadHeader();
 106   Rich()->GetLoader()->GetRunLoader()->UnloadKinematics();
 107
 108   Info("Exec","Stop.");
 109 }//Exec()
 110 //__________________________________________________________________________________________________
 111 void AliRICHClusterFinder::FindClusters(Int_t iChamber)
 112 {
 113   //finds neighbours and fill the tree with raw clusters
 114   Int_t nDigits=Rich()->Digits(iChamber)->GetEntriesFast();
 115 //  Info("FindClusters","Start for Chamber %i with %i digits.",iChamber,nDigits);
 116   if(nDigits==0)return;
 117
 118   fHitMap=new AliRICHMap(Rich()->Digits(iChamber));//create digit map for the given chamber
 119
 120   for(Int_t iDig=0;iDig<nDigits;iDig++){
 121     AliRICHdigit *dig=(AliRICHdigit*)Rich()->Digits(iChamber)->At(iDig);
 122     Int_t i=dig->X();   Int_t j=dig->Y();
 123     if(fHitMap->TestHit(i,j)==kUsed) continue;
 124
 125     FormRawCluster(i,j);
 126     FindLocalMaxima();
 127 //    cout << " fNlocals in FindCluster " << fNlocals << endl;
 128     fRawCluster.CoG(fNlocals); // first initial approxmation of the CoG...to start minimization.
 129
 130     if(AliRICHParam::IsResolveClusters()) {
 131       ResolveCluster(); // ResolveCluster serialization will happen inside
 132     } else {
 133       WriteRawCluster(); // simply output of the RawCluster found without deconvolution
 134     }
 135     fRawCluster.Reset();
 136     fResolvedCluster.Reset();
 137   }//digits loop
 138
 139   delete fHitMap;
 140 //  Info("FindClusters","Stop.");
 141
 142 }//FindClusters()
 143 //__________________________________________________________________________________________________
 144 void AliRICHClusterFinder::FindClusterContribs(AliRICHcluster *pCluster)
 145 {
 146 // finds CombiPid for a given cluster
 147 // Info("FindClusterContribs","Start");
 148
 149   TObjArray *pDigits = pCluster->Digits();
 150   Int_t iNmips=0,iNckovs=0,iNfeeds=0;
 151   TArrayI contribs(3*pCluster->Size());
 152   Int_t *pindex = new Int_t[3*pCluster->Size()];
 153   for(Int_t iDigN=0;iDigN<pCluster->Size();iDigN++) {//loop on digits of a given cluster
 154     contribs[3*iDigN]  =((AliRICHdigit*)pDigits->At(iDigN))->Tid(0);
 155     contribs[3*iDigN+1]=((AliRICHdigit*)pDigits->At(iDigN))->Tid(1);
 156     contribs[3*iDigN+2]=((AliRICHdigit*)pDigits->At(iDigN))->Tid(2);
 157   }//loop on digits of a given cluster
 158   TMath::Sort(contribs.GetSize(),contribs.GetArray(),pindex);
 159   for(Int_t iDigN=0;iDigN<3*pCluster->Size()-1;iDigN++) {//loop on digits to sort Tid
 160     if(contribs[pindex[iDigN]]!=contribs[pindex[iDigN+1]]) {
 161       Int_t code   = Rich()->GetLoader()->GetRunLoader()->Stack()->Particle(contribs[pindex[iDigN]])->GetPdgCode();
 162       Double_t charge = Rich()->GetLoader()->GetRunLoader()->Stack()->Particle(contribs[pindex[iDigN]])->GetPDG()->Charge();
 163
 164       if(code==50000050) iNckovs++;
 165       else if(code==50000051) iNfeeds++;
 166       else if(charge!=0) iNmips++;
 167       if (contribs[pindex[iDigN+1]]==kBad) break;
 168     }
 169   }//loop on digits to sort Tid
 170   pCluster->SetCombiPid(iNckovs,iNfeeds,iNmips);
 171 //  pCluster->Print();
 172   delete [] pindex;
 173 }//FindClusterContribs()
 174 //__________________________________________________________________________________________________
 175 void  AliRICHClusterFinder::FormRawCluster(Int_t i, Int_t j)
 176 {
 177 // Builder of the final Raw Cluster (before deconvolution)
 178   if(GetDebug()) Info("FormRawCluster","Start with digit(%i,%i)",i,j);
 179
 180   fRawCluster.AddDigit((AliRICHdigit*) fHitMap->GetHit(i,j));
 181   fHitMap->FlagHit(i,j);// Flag hit as taken
 182
 183   Int_t listX[4], listY[4];    //  Now look recursively for all neighbours
 184   for (Int_t iNeighbour=0;iNeighbour<Rich()->Param()->PadNeighbours(i,j,listX,listY);iNeighbour++)
 185     if(fHitMap->TestHit(listX[iNeighbour],listY[iNeighbour])==kUnused)
 186                       FormRawCluster(listX[iNeighbour],listY[iNeighbour]);
 187 }//FormRawCluster()
 188 //__________________________________________________________________________________________________
 189 void AliRICHClusterFinder::ResolveCluster()
 190 {// Decluster algorithm
 191   if(GetDebug()) {Info("ResolveCluster","Start."); fRawCluster.Print();}
 192
 193   switch (fRawCluster.Size()) {
 194
 195   case 1:                     // nothing to decluster: cluster size = 1
 196     WriteRawCluster();break;
 197   default:                     // cluster size > 1: if=2 FitCoG; if>2 Resolve and FitCoG
 198     FitCoG();break;
 199   }
 200 }//ResolveCluster()
 201 //__________________________________________________________________________________________________
 202 void AliRICHClusterFinder::WriteRawCluster()
 203 {
 204 // out the current raw cluster
 205 //  Info("WriteRawCluster","Start.");
 206
 207   FindClusterContribs(&fRawCluster);
 208   Rich()->AddCluster(fRawCluster);
 209 //  fRawCluster.Print();
 210 }//WriteRawCluster()
 211 //__________________________________________________________________________________________________
 212 void AliRICHClusterFinder::WriteResolvedCluster()
 213 {
 214 // out the current resolved cluster
 215 //  Info("WriteResolvedCluster","Start.");
 216
 217 //  FindClusterContribs(&fResolvedCluster);
 218   Rich()->AddCluster(fResolvedCluster);
 219
 220 }//WriteResolvedCluster()
 221 //__________________________________________________________________________________________________
 222 void AliRICHClusterFinder::FitCoG()
 223 {// Fit cluster size 2 by single Mathieson
 224   Info("FitCoG","Start with size %3i and local maxima %3i",fRawCluster.Size(),fNlocals);
 225
 226   Double_t arglist;
 227   Int_t ierflag = 0;
 228
 229 //  fRawCluster.Print();
 230   if(fNlocals==0) fRawCluster.Print();
 231   if(fNlocals==0||fNlocals>3) {WriteRawCluster();return;}
 232
 233   TMinuit *pMinuit = new TMinuit(3*fNlocals-1);
 234   pMinuit->mninit(5,10,7);
 235
 236   arglist = -1;
 237   pMinuit->mnexcm("SET PRI",&arglist, 1, ierflag);
 238
 239   TString chname;
 240   Int_t ierflg;
 241
 242   pMinuit->SetObjectFit((TObject*)this);
 243   pMinuit->SetFCN(RICHMinMathieson);
 244
 245   Double_t vstart,lower, upper;
 246   Double_t stepX= 0.001;
 247   Double_t stepY= 0.001;
 248   Double_t stepQ= 0.0001;
 249
 250   for(Int_t i=0;i<fNlocals;i++) {
 251     vstart   = fLocalX[i];
 252     lower    = vstart - 2*AliRICHParam::PadSizeX();
 253     upper    = vstart + 2*AliRICHParam::PadSizeX();
 254     pMinuit->mnparm(3*i  ,Form("xCoG  %i",i),vstart,stepX,lower,upper,ierflag);
 255 //    cout << Form("xCoG  %i",i) << "start " << vstart << "lower " << lower << "upper " << upper << endl;
 256     vstart   = fLocalY[i];
 257     lower    = vstart - 2*AliRICHParam::PadSizeY();
 258     upper    = vstart + 2*AliRICHParam::PadSizeY();
 259     pMinuit->mnparm(3*i+1,Form("yCoG  %i",i),vstart,stepY,lower,upper,ierflag);
 260 //    cout << Form("yCoG  %i",i) << "start " << vstart << "lower " << lower << "upper " << upper << endl;
 261     if(i==fNlocals-1) break;                    // last parameter is constrained
 262     vstart = fLocalQ[i]/fRawCluster.Q();
 263     lower  = 0;
 264     upper  = 1;
 265     pMinuit->mnparm(3*i+2,Form("qfrac %i",i),vstart,stepQ,lower,upper,ierflag);
 266 //    cout << Form("qCoG  %i",i) << "start " << vstart << "lower " << lower << "upper " << upper << endl;
 267
 268   }
 269
 270   arglist = -1;
 271
 272   pMinuit->mnexcm("SET NOGR",&arglist, 1, ierflag);
 273   pMinuit->mnexcm("SET NOW",&arglist, 1, ierflag);
 274   arglist = 1;
 275   pMinuit->mnexcm("SET ERR", &arglist, 1,ierflg);
 276   arglist = -1;
 277   pMinuit->mnexcm("SIMPLEX",&arglist, 0, ierflag);
 278   pMinuit->mnexcm("MIGRAD",&arglist, 0, ierflag);
 279   pMinuit->mnexcm("EXIT" ,&arglist, 0, ierflag);
 280
 281   Double_t xCoG[50],yCoG[50],qfracCoG[50];
 282   Double_t eps, b1, b2;
 283
 284   Double_t qfraclast=0;
 285   for(Int_t i=0;i<fNlocals;i++) {
 286     pMinuit->mnpout(3*i  ,chname,     xCoG[i], eps , b1, b2, ierflg);
 287     pMinuit->mnpout(3*i+1,chname,     yCoG[i], eps , b1, b2, ierflg);
 288     if(i==fNlocals-1) break;
 289     pMinuit->mnpout(3*i+2,chname, qfracCoG[i], eps , b1, b2, ierflg);
 290     qfraclast+=qfracCoG[i];
 291    }
 292   qfracCoG[fNlocals-1] = 1 - qfraclast;
 293   delete pMinuit;
 294
 295   for(Int_t i=0;i<fNlocals;i++) {
 296
 297     if(fNlocals==5) {
 298     cout << " Start writing  deconvolved cluster n." << i << endl;
 299     cout << " fRawCluster " << &fRawCluster << " xCoG " << xCoG[i] << " yCoG " << yCoG[i] << " qfrac " << qfracCoG[i] << endl;
 300     cout << " Combipid " << fLocalC[i] << " for maximum n. " << i << endl;
 301   }
 302     fResolvedCluster.Fill(&fRawCluster,xCoG[i],yCoG[i],qfracCoG[i],fLocalC[i]);
 303 //    fResolvedCluster.Print();
 304     WriteResolvedCluster();
 305   }
 306 if(fNlocals==5)  Info("CoG","Stop.");
 307 }
 308 //__________________________________________________________________________________________________
 309 void RICHMinMathieson(Int_t &npar, Double_t *, Double_t &chi2, Double_t *par, Int_t )
 310 {// Minimization function of Mathieson
 311
 312   AliRICHcluster *pRawCluster = ((AliRICHClusterFinder*)gMinuit->GetObjectFit())->GetRawCluster();
 313
 314   TVector2 centroid[50];
 315   Double_t q[50];
 316   Int_t nFunctions = (npar+1)/3;
 317   Double_t qfract = 0;
 318   for(Int_t i=0;i<nFunctions;i++) {
 319     centroid[i].Set(par[3*i],par[3*i+1]);
 320     if(i==nFunctions-1) break;
 321     q[i]=par[3*i+2];
 322     qfract+=q[i];
 323   }
 324   q[nFunctions-1] = 1 - qfract;
 325
 326   chi2 = 0;
 327   Int_t qtot = pRawCluster->Q();
 328   for(Int_t i=0;i<pRawCluster->Size();i++) {
 329     Int_t    padX = ((AliRICHdigit *)pRawCluster->Digits()->At(i))->X();
 330     Int_t    padY = ((AliRICHdigit *)pRawCluster->Digits()->At(i))->Y();
 331     Double_t padQ = ((AliRICHdigit *)pRawCluster->Digits()->At(i))->Q();
 332     Double_t qfracpar=0;
 333     for(Int_t j=0;j<nFunctions;j++) {
 334       qfracpar += q[j]*AliRICHParam::FracQdc(centroid[j],padX,padY);
 335 //      cout << " function n. " << j+1 << " q " << q[j] << " fracMat " << AliRICHParam::FracQdc(centroid[j],padX,padY)
 336 //           << " xpar " << centroid[j].X() << " ypar " << centroid[j].Y() << endl;
 337     }
 338     chi2 += TMath::Power((qtot*qfracpar-padQ),2)/padQ;
 339 //    cout << " chi2 " << chi2 << " pad n. " << i << " qfracpar " << qfracpar << endl;
 340   }
 341 //  if(iflag==3) {
 342 //    cout << " chi2 final " << chi2 << endl;
 343 //  }
 344 }//RICHMinMathieson()