TRD/AliTRDclusterizerV0.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 $Log$
  18 Revision 1.2  2000/05/08 16:17:27  cblume
  19 Merge TRD-develop
  20
  21 Revision 1.1.4.1  2000/05/08 15:08:41  cblume
  22 Replace AliTRDcluster by AliTRDrecPoint
  23
  24 Revision 1.1  2000/02/28 18:58:33  cblume
  25 Add new TRD classes
  26
  27 */
  28
  29 ///////////////////////////////////////////////////////////////////////////////
  30 //                                                                           //
  31 // TRD cluster finder for the fast simulator. It takes the hits from the     //
  32 // fast simulator (one hit per plane) and transforms them                    //
  33 // into cluster, by applying position smearing and merging                   //
  34 // of nearby cluster. The searing is done uniformly in z-direction           //
  35 // over the length of a readout pad. In rphi-direction a Gaussian            //
  36 // smearing is applied with a sigma given by fRphiSigma.                     //
  37 // Clusters are considered as overlapping when they are closer in            //
  38 // rphi-direction than the value defined in fRphiDist.                       //
  39 // Use the macro fastClusterCreate.C to create the cluster.                  //
  40 //                                                                           //
  41 ///////////////////////////////////////////////////////////////////////////////
  42
  43 #include <TRandom.h>
  44
  45 #include "AliTRDclusterizerV0.h"
  46 #include "AliTRDconst.h"
  47 #include "AliTRDgeometry.h"
  48 #include "AliTRDrecPoint.h"
  49
  50 ClassImp(AliTRDclusterizerV0)
  51
  52 //_____________________________________________________________________________
  53 AliTRDclusterizerV0::AliTRDclusterizerV0():AliTRDclusterizer()
  54 {
  55   //
  56   // AliTRDclusterizerV0 default constructor
  57   //
  58
  59 }
  60
  61 //_____________________________________________________________________________
  62 AliTRDclusterizerV0::AliTRDclusterizerV0(const Text_t* name, const Text_t* title)
  63                     :AliTRDclusterizer(name,title)
  64 {
  65   //
  66   // AliTRDclusterizerV0 default constructor
  67   //
  68
  69   Init();
  70
  71 }
  72
  73 //_____________________________________________________________________________
  74 AliTRDclusterizerV0::~AliTRDclusterizerV0()
  75 {
  76
  77 }
  78
  79 //_____________________________________________________________________________
  80 void AliTRDclusterizerV0::Init()
  81 {
  82   //
  83   // Initializes the cluster finder
  84   //
  85
  86   // Position resolution in rphi-direction
  87   fRphiSigma  = 0.02;
  88   // Minimum distance of non-overlapping cluster
  89   fRphiDist   = 1.0;
  90
  91 }
  92
  93 //_____________________________________________________________________________
  94 Bool_t AliTRDclusterizerV0::MakeCluster()
  95 {
  96   //
  97   // Generates the cluster
  98   //
  99
 100   // Get the pointer to the detector class and check for version 1
 101   AliTRD *TRD = (AliTRD*) gAlice->GetDetector("TRD");
 102   if (TRD->IsVersion() != 0) {
 103     printf("AliTRDclusterizerV0::MakeCluster -- ");
 104     printf("TRD must be version 0 (fast simulator).\n");
 105     return kFALSE;
 106   }
 107
 108   // Get the geometry
 109   AliTRDgeometry *Geo = TRD->GetGeometry();
 110
 111   printf("AliTRDclusterizerV0::MakeCluster -- ");
 112   printf("Start creating cluster.\n");
 113
 114   Int_t nBytes = 0;
 115
 116   AliTRDhit      *Hit;
 117
 118   // Get the pointer to the hit tree
 119   TTree *HitTree     = gAlice->TreeH();
 120   // Get the pointer to the reconstruction tree
 121   TTree *ClusterTree = gAlice->TreeR();
 122
 123   TObjArray *Chamber = new TObjArray();
 124
 125   // Get the number of entries in the hit tree
 126   // (Number of primary particles creating a hit somewhere)
 127   Int_t nTrack = (Int_t) HitTree->GetEntries();
 128
 129   // Loop through all the chambers
 130   for (Int_t icham = 0; icham < kNcham; icham++) {
 131     for (Int_t iplan = 0; iplan < kNplan; iplan++) {
 132       for (Int_t isect = 0; isect < kNsect; isect++) {
 133
 134         Int_t   nColMax     = Geo->GetColMax(iplan);
 135         Float_t row0        = Geo->GetRow0(iplan,icham,isect);
 136         Float_t col0        = Geo->GetCol0(iplan);
 137         Float_t time0       = Geo->GetTime0(iplan);
 138
 139         Float_t rowPadSize  = Geo->GetRowPadSize();
 140         Float_t colPadSize  = Geo->GetColPadSize();
 141         Float_t timeBinSize = Geo->GetTimeBinSize();
 142
 143         // Loop through all entries in the tree
 144         for (Int_t iTrack = 0; iTrack < nTrack; iTrack++) {
 145
 146           gAlice->ResetHits();
 147           nBytes += HitTree->GetEvent(iTrack);
 148
 149           // Get the number of hits in the TRD created by this particle
 150           Int_t nHit = TRD->Hits()->GetEntriesFast();
 151
 152           // Loop through the TRD hits
 153           for (Int_t iHit = 0; iHit < nHit; iHit++) {
 154
 155             if (!(Hit = (AliTRDhit *) TRD->Hits()->UncheckedAt(iHit)))
 156               continue;
 157
 158             Float_t pos[3];
 159                     pos[0]   = Hit->fX;
 160                     pos[1]   = Hit->fY;
 161                     pos[2]   = Hit->fZ;
 162             Int_t   track    = Hit->fTrack;
 163             Int_t   detector = Hit->fDetector;
 164             Int_t   plane    = Geo->GetPlane(detector);
 165             Int_t   sector   = Geo->GetSector(detector);
 166             Int_t   chamber  = Geo->GetChamber(detector);
 167
 168             if ((sector  != isect) ||
 169                 (plane   != iplan) ||
 170                 (chamber != icham))
 171               continue;
 172
 173             // Rotate the sectors on top of each other
 174             Float_t rot[3];
 175             Geo->Rotate(detector,pos,rot);
 176
 177             // Add this recPoint to the temporary array for this chamber
 178             AliTRDrecPoint *RecPoint = new AliTRDrecPoint();
 179             RecPoint->SetLocalRow(rot[2]);
 180             RecPoint->SetLocalCol(rot[1]);
 181             RecPoint->SetLocalTime(rot[0]);
 182             RecPoint->SetEnergy(0);
 183             RecPoint->SetDetector(detector);
 184             RecPoint->AddDigit(track);
 185             Chamber->Add(RecPoint);
 186
 187           }
 188
 189         }
 190
 191         // Loop through the temporary cluster-array
 192         for (Int_t iClus1 = 0; iClus1 < Chamber->GetEntries(); iClus1++) {
 193
 194           AliTRDrecPoint *RecPoint1 = (AliTRDrecPoint *) Chamber->UncheckedAt(iClus1);
 195           Float_t row1  = RecPoint1->GetLocalRow();
 196           Float_t col1  = RecPoint1->GetLocalCol();
 197           Float_t time1 = RecPoint1->GetLocalTime();
 198
 199           if (RecPoint1->GetEnergy() < 0) continue;        // Skip marked cluster
 200
 201           const Int_t nSave  = 5;
 202           Int_t idxSave[nSave];
 203           Int_t iSave = 0;
 204
 205           const Int_t nSaveTrack = 3;
 206           Int_t tracks[nSaveTrack];
 207           tracks[0] = RecPoint1->GetDigit(0);
 208
 209           // Check the other cluster to see, whether there are close ones
 210           for (Int_t iClus2 = iClus1 + 1; iClus2 < Chamber->GetEntries(); iClus2++) {
 211
 212             AliTRDrecPoint *RecPoint2 = (AliTRDrecPoint *) Chamber->UncheckedAt(iClus2);
 213             Float_t row2 = RecPoint2->GetLocalRow();
 214             Float_t col2 = RecPoint2->GetLocalCol();
 215
 216             if ((TMath::Abs(row1 - row2) < rowPadSize) ||
 217                 (TMath::Abs(col1 - col2) <  fRphiDist)) {
 218               if (iSave == nSave) {
 219                 printf("AliTRDclusterizerV0::MakeCluster -- ");
 220                 printf("Boundary error: iSave = %d, nSave = %d.\n"
 221                       ,iSave,nSave);
 222               }
 223               else {
 224                 idxSave[iSave]  = iClus2;
 225                 iSave++;
 226                 if (iSave < nSaveTrack) tracks[iSave] = RecPoint2->GetDigit(0);
 227               }
 228             }
 229           }
 230
 231           // Merge close cluster
 232           Float_t rowMerge = row1;
 233           Float_t colMerge = col1;
 234           if (iSave) {
 235             for (Int_t iMerge = 0; iMerge < iSave; iMerge++) {
 236               AliTRDrecPoint *RecPoint2 =
 237                 (AliTRDrecPoint *) Chamber->UncheckedAt(idxSave[iMerge]);
 238               rowMerge += RecPoint2->GetLocalRow();
 239               colMerge += RecPoint2->GetLocalCol();
 240               RecPoint2->SetEnergy(-1);     // Mark merged cluster
 241             }
 242             rowMerge /= (iSave + 1);
 243             colMerge /= (iSave + 1);
 244           }
 245
 246           Float_t smear[3];
 247
 248           // The position smearing in row-direction (uniform over pad width)
 249           Int_t row = (Int_t) ((rowMerge - row0) / rowPadSize);
 250           smear[0]  = (row + gRandom->Rndm()) * rowPadSize + row0;
 251
 252           // The position smearing in rphi-direction (Gaussian)
 253           smear[1] = 0;
 254           do
 255             smear[1] = gRandom->Gaus(colMerge,fRphiSigma);
 256           while ((smear[1] < col0                        ) ||
 257                  (smear[1] > col0 + nColMax * colPadSize));
 258
 259           // Time direction stays unchanged
 260           smear[2] = time1;
 261
 262           // Transform into local coordinates
 263           smear[0] = (Int_t) ((smear[0] -  row0) /  rowPadSize);
 264           smear[1] = (Int_t) ((smear[1] -  col0) /  colPadSize);
 265           smear[2] = (Int_t) ((smear[2] - time0) / timeBinSize);
 266
 267           // Add the smeared cluster to the output array
 268           Int_t detector  = RecPoint1->GetDetector();
 269           Int_t digits[3] = {0};
 270           TRD->AddRecPoint(smear,digits,detector,0.0);
 271
 272         }
 273
 274         // Clear the temporary cluster-array and delete the cluster
 275         Chamber->Delete();
 276
 277       }
 278     }
 279   }
 280
 281   printf("AliTRDclusterizerV0::MakeCluster -- ");
 282   printf("Found %d points.\n",TRD->RecPoints()->GetEntries());
 283   printf("AliTRDclusterizerV0::MakeCluster -- ");
 284   printf("Fill the cluster tree.\n");
 285   ClusterTree->Fill();
 286
 287   return kTRUE;
 288
 289 }