MFT/AliMFTClusterFinder.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 //
  18 //      Class for finding and building the clusters of the ALICE Muon Forward Tracker
  19 //
  20 //      Contact author: antonio.uras@cern.ch
  21 //
  22 //====================================================================================================================================================
  23
  24 #include "AliLog.h"
  25 #include "TObjArray.h"
  26 #include "TClonesArray.h"
  27 #include "AliMFTDigit.h"
  28 #include "AliMFTCluster.h"
  29 #include "AliMFTSegmentation.h"
  30 #include "TTree.h"
  31 #include "TMath.h"
  32 #include "AliMFTConstants.h"
  33 #include "AliMFTClusterFinder.h"
  34 #include "TRandom.h"
  35
  36 const Double_t AliMFTClusterFinder::fCutForAvailableDigits = AliMFTConstants::fCutForAvailableDigits;
  37 const Double_t AliMFTClusterFinder::fCutForAttachingDigits = AliMFTConstants::fCutForAttachingDigits;
  38 const Double_t AliMFTClusterFinder::fMisalignmentMagnitude = AliMFTConstants::fMisalignmentMagnitude;
  39
  40 ClassImp(AliMFTClusterFinder)
  41
  42 //====================================================================================================================================================
  43
  44 AliMFTClusterFinder::AliMFTClusterFinder() :
  45   TObject(),
  46   fDigitsInCluster(0),
  47   fCurrentDigit(0),
  48   fCurrentCluster(0),
  49   fSegmentation(0),
  50   fNPlanes(0),
  51   fApplyMisalignment(kFALSE),
  52   fStopWatch(0)
  53 {
  54
  55   // Default constructor
  56
  57   for (Int_t iPlane=0; iPlane<fNMaxPlanes; iPlane++) fClustersPerPlane[iPlane] = NULL;
  58   fDigitsInCluster = new TClonesArray("AliMFTDigit", fNMaxDigitsPerCluster);
  59   fDigitsInCluster -> SetOwner(kTRUE);
  60   fStopWatch = new TStopwatch();
  61   fStopWatch -> Reset();
  62
  63 }
  64
  65 //====================================================================================================================================================
  66
  67 AliMFTClusterFinder::~AliMFTClusterFinder() {
  68
  69   AliDebug(1, "Deleting AliMFTClusterFinder...");
  70
  71   for (Int_t iPlane=0; iPlane<fNMaxPlanes; iPlane++) {
  72     if (fClustersPerPlane[iPlane]) fClustersPerPlane[iPlane]->Delete(); delete fClustersPerPlane[iPlane]; fClustersPerPlane[iPlane] = 0x0;
  73   }
  74   if (fDigitsInCluster) fDigitsInCluster->Delete(); delete fDigitsInCluster; fDigitsInCluster = NULL;
  75   delete fSegmentation; fSegmentation=NULL;
  76
  77   delete fStopWatch;
  78
  79   AliDebug(1, "... done!");
  80
  81 }
  82
  83 //====================================================================================================================================================
  84
  85 void AliMFTClusterFinder::Clear(const Option_t* /*opt*/) {
  86
  87   AliDebug(1, "Clearing AliMFTClusterFinder...");
  88
  89   for (Int_t iPlane=0; iPlane<fNMaxPlanes; iPlane++) {
  90     if(fClustersPerPlane[iPlane]) fClustersPerPlane[iPlane]->Clear("C");
  91   }
  92   if(fDigitsInCluster) fDigitsInCluster->Clear("C");
  93   fSegmentation->Clear("C");
  94
  95   AliDebug(1, "... done!");
  96
  97 }
  98
  99 //====================================================================================================================================================
 100
 101 void AliMFTClusterFinder::Init(const Char_t *nameGeomFile) {
 102
 103   fSegmentation = new AliMFTSegmentation(nameGeomFile);
 104   fNPlanes = fSegmentation -> GetNPlanes();
 105
 106 }
 107
 108 //====================================================================================================================================================
 109
 110 void AliMFTClusterFinder::StartEvent() {
 111
 112   // Cleaning up and preparation for the clustering procedure
 113
 114   AliDebug(1, "Starting Event...");
 115
 116   for (Int_t iPlane=0; iPlane<fNPlanes; iPlane++) {
 117     fClustersPerPlane[iPlane]->Delete();
 118   }
 119
 120   AliDebug(1, "... done!");
 121
 122 }
 123
 124 //====================================================================================================================================================
 125
 126 void AliMFTClusterFinder::DigitsToClusters(const TObjArray *pDigitList) {
 127
 128   // where the clusterization is performed
 129
 130   AliInfo("Starting Clusterization for MFT");
 131   AliDebug(1, Form("nPlanes = %d", fNPlanes));
 132
 133   if (!fStopWatch) fStopWatch = new TStopwatch();
 134   fStopWatch -> Reset();
 135
 136   StartEvent();
 137   Bool_t isDigAvailableForNewCluster = kTRUE;
 138
 139   TClonesArray *myDigitList = 0;
 140
 141   for (Int_t iPlane=0; iPlane<fNPlanes; iPlane++) {
 142
 143     AliDebug(1, Form("Plane %02d", iPlane));
 144
 145     Int_t nDetElem = fSegmentation->GetPlane(iPlane)->GetNActiveElements();
 146     TClonesArray *clustersPerDetElem[fNMaxDetElemPerPlane] = {0};
 147     for (Int_t iDetElem=0; iDetElem<nDetElem; iDetElem++) clustersPerDetElem[iDetElem] = new TClonesArray("AliMFTCluster");
 148
 149     myDigitList = (TClonesArray*) pDigitList->At(iPlane);
 150
 151     AliDebug(1, Form("myDigitList->GetEntries() = %d", myDigitList->GetEntries()));
 152
 153     Int_t cycleOverDigits = 0;
 154     Double_t myCutForAvailableDigits = 0;
 155
 156     Int_t currentDetElem = -1;
 157     Int_t currentDetElemLocal = -1;
 158     Bool_t areThereSkippedDigits = kFALSE;
 159
 160     fStopWatch -> Start();
 161
 162     while (myDigitList->GetEntries()) {
 163
 164       for (Int_t iDig=0; iDig<myDigitList->GetEntries(); iDig++) {
 165
 166         fCurrentDigit = (AliMFTDigit*) myDigitList->At(iDig);
 167
 168         if (!iDig) {
 169           if (fCurrentDigit->GetDetElemID() != currentDetElem) {
 170             // first iteration over the digits of a specific detection element
 171             currentDetElem = fCurrentDigit->GetDetElemID();
 172             currentDetElemLocal = fSegmentation->GetDetElemLocalID(currentDetElem);
 173             cycleOverDigits = 0;
 174             myCutForAvailableDigits = fCutForAvailableDigits;
 175           }
 176           else if (fCurrentDigit->GetDetElemID()==currentDetElem && areThereSkippedDigits) {
 177             // second (or further) iteration over the digits of a specific detection element
 178             cycleOverDigits++;
 179             myCutForAvailableDigits -= 0.5;
 180           }
 181           areThereSkippedDigits = kFALSE;
 182         }
 183         else {
 184           areThereSkippedDigits = kTRUE;
 185           if (fCurrentDigit->GetDetElemID() != currentDetElem) break;
 186         }
 187
 188         isDigAvailableForNewCluster = kTRUE;
 189
 190         for (Int_t iCluster=0; iCluster<clustersPerDetElem[currentDetElemLocal]->GetEntries(); iCluster++) {
 191           fCurrentCluster = (AliMFTCluster*) clustersPerDetElem[currentDetElemLocal]->At(iCluster);
 192           if (fCurrentCluster->GetDistanceFromPixel(fCurrentDigit) < fCutForAttachingDigits) {
 193             fCurrentCluster->AddPixel(fCurrentDigit);
 194             myDigitList->Remove(fCurrentDigit);
 195             myDigitList->Compress();
 196             iDig--;
 197             isDigAvailableForNewCluster = kFALSE;
 198             break;
 199           }
 200           if (fCurrentCluster->GetDistanceFromPixel(fCurrentDigit) < myCutForAvailableDigits) isDigAvailableForNewCluster=kFALSE;
 201         }
 202
 203         if (isDigAvailableForNewCluster) {
 204           AliMFTCluster *newCluster = new AliMFTCluster();
 205           newCluster->AddPixel(fCurrentDigit);
 206           myDigitList->Remove(fCurrentDigit);
 207           myDigitList->Compress();
 208           iDig--;
 209           new ((*clustersPerDetElem[currentDetElemLocal])[clustersPerDetElem[currentDetElemLocal]->GetEntries()]) AliMFTCluster(*newCluster);
 210           delete newCluster;
 211         }
 212
 213       }   // end of cycle over the digits
 214
 215     }   // no more digits to check in current plane!
 216
 217     fStopWatch -> Print("m");
 218
 219     printf("Plane %d: clusters found in %f seconds\n",iPlane,fStopWatch->CpuTime());
 220     fStopWatch->Start();
 221
 222     // Now we merge the cluster lists coming from each detection element, to build the cluster list of the plane
 223
 224     Double_t misalignmentPhi = 2.*TMath::Pi()*gRandom->Rndm();
 225     Double_t misalignmentX   = fMisalignmentMagnitude*TMath::Cos(misalignmentPhi);
 226     Double_t misalignmentY   = fMisalignmentMagnitude*TMath::Sin(misalignmentPhi);
 227
 228     AliMFTCluster *newCluster = NULL;
 229     for (Int_t iDetElem=0; iDetElem<nDetElem; iDetElem++) {
 230       for (Int_t iCluster=0; iCluster<clustersPerDetElem[iDetElem]->GetEntries(); iCluster++) {
 231         newCluster = (AliMFTCluster*) (clustersPerDetElem[iDetElem]->At(iCluster));
 232         newCluster -> TerminateCluster();
 233         if (fApplyMisalignment) {
 234           newCluster -> SetClusterEditable(kTRUE);
 235           newCluster -> SetX(newCluster->GetX()+misalignmentX);
 236           newCluster -> SetY(newCluster->GetY()+misalignmentY);
 237           newCluster -> SetClusterEditable(kFALSE);
 238         }
 239         new ((*fClustersPerPlane[iPlane])[fClustersPerPlane[iPlane]->GetEntries()]) AliMFTCluster(*newCluster);
 240       }
 241     }
 242
 243     printf("%d Clusters in plane %02d merged in %f seconds\n", fClustersPerPlane[iPlane]->GetEntries(), iPlane, fStopWatch->CpuTime());
 244
 245     for (Int_t iDetElem=0; iDetElem<nDetElem; iDetElem++) {
 246       clustersPerDetElem[iDetElem] -> Delete();
 247       delete clustersPerDetElem[iDetElem];
 248     }
 249
 250     myDigitList -> Delete();
 251
 252   }  // end of cycle over the planes
 253
 254 }
 255
 256 //====================================================================================================================================================
 257
 258 void AliMFTClusterFinder::MakeClusterBranch(TTree *treeCluster) {
 259
 260   // Creating the cluster branches, one for each plane (see AliMFTReconstructor::Reconstruct)
 261
 262   AliDebug(1, "Making Cluster Branch");
 263
 264   CreateClusters();
 265
 266   if (treeCluster) {
 267     for(Int_t iPlane=0; iPlane<fNPlanes; iPlane++) {
 268       AliDebug(1, Form("Setting Branch Plane_%02d for treeCluster",iPlane));
 269       if (treeCluster->GetBranch(Form("Plane_%02d",iPlane))) continue;
 270       AliDebug(1, Form("Branch Plane_%02d does not exist, creating!",iPlane));
 271       treeCluster->Branch(Form("Plane_%02d",iPlane), &(fClustersPerPlane[iPlane]));
 272     }
 273   }
 274
 275 }
 276
 277 //====================================================================================================================================================
 278
 279 void AliMFTClusterFinder::SetClusterTreeAddress(TTree *treeCluster) {
 280
 281   // Addressing the cluster branches, one for each plane (see AliMFTReconstructor::Reconstruct)
 282
 283   if (treeCluster && treeCluster->GetBranch("Plane_00")) {
 284     CreateClusters();
 285     for(Int_t iPlane=0; iPlane<fNPlanes; iPlane++) {
 286       if (treeCluster->GetBranch(Form("Plane_%02d",iPlane))) {
 287         treeCluster->SetBranchAddress(Form("Plane_%02d",iPlane), &(fClustersPerPlane[iPlane]));
 288       }
 289       else AliError(Form("No branch available with name Plane_%02d", iPlane));
 290     }
 291   }
 292
 293 }
 294
 295 //====================================================================================================================================================
 296
 297 void AliMFTClusterFinder::CreateClusters() {
 298
 299   // create cluster list
 300
 301   AliDebug(1, Form("Creating clusters list: nPlanes = %d",fNPlanes));
 302
 303   if (fClustersPerPlane[0]) return;
 304
 305   for(Int_t iPlane=0; iPlane<fNPlanes; iPlane++) {
 306     AliDebug(1, Form("plane %02d", iPlane));
 307     fClustersPerPlane[iPlane] = new TClonesArray("AliMFTCluster");
 308     fClustersPerPlane[iPlane] -> SetOwner(kTRUE);
 309
 310   }
 311
 312 }
 313
 314 //====================================================================================================================================================