PMD/AliPMDtracker.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 //           Date   : March 25 2004                    //
  19 //  This reads the file PMD.RecPoints.root(TreeR),     //
  20 //  calls the Clustering algorithm and stores the      //
  21 //  clustering output in PMD.RecPoints.root(TreeR)     //
  22 //                                                     //
  23 //-----------------------------------------------------//
  24
  25 #include <Riostream.h>
  26 #include <TMath.h>
  27 #include <TBRIK.h>
  28 #include <TNode.h>
  29 #include <TTree.h>
  30 #include <TGeometry.h>
  31 #include <TObjArray.h>
  32 #include <TClonesArray.h>
  33 #include <TFile.h>
  34 #include <TBranch.h>
  35 #include <TNtuple.h>
  36 #include <TParticle.h>
  37
  38 #include "AliPMDcluster.h"
  39 #include "AliPMDclupid.h"
  40 #include "AliPMDrecpoint1.h"
  41 #include "AliPMDUtility.h"
  42 #include "AliPMDDiscriminator.h"
  43 #include "AliPMDEmpDiscriminator.h"
  44 #include "AliPMDtracker.h"
  45
  46 #include "AliESDPmdTrack.h"
  47 #include "AliESD.h"
  48 #include "AliLog.h"
  49
  50 ClassImp(AliPMDtracker)
  51
  52 AliPMDtracker::AliPMDtracker():
  53   fTreeR(0),
  54   fRecpoints(new TClonesArray("AliPMDrecpoint1", 1000)),
  55   fPMDcontin(new TObjArray()),
  56   fPMDcontout(new TObjArray()),
  57   fPMDutil(new AliPMDUtility()),
  58   fPMDrecpoint(0),
  59   fPMDclin(0),
  60   fPMDclout(0),
  61   fXvertex(0.),
  62   fYvertex(0.),
  63   fZvertex(0.),
  64   fSigmaX(0.),
  65   fSigmaY(0.),
  66   fSigmaZ(0.)
  67 {
  68   //
  69   // Default Constructor
  70   //
  71 }
  72 //--------------------------------------------------------------------//
  73 AliPMDtracker:: AliPMDtracker(const AliPMDtracker & /* tracker */):
  74   TObject(/* tracker */),
  75   fTreeR(0),
  76   fRecpoints(NULL),
  77   fPMDcontin(NULL),
  78   fPMDcontout(NULL),
  79   fPMDutil(NULL),
  80   fPMDrecpoint(0),
  81   fPMDclin(0),
  82   fPMDclout(0),
  83   fXvertex(0.),
  84   fYvertex(0.),
  85   fZvertex(0.),
  86   fSigmaX(0.),
  87   fSigmaY(0.),
  88   fSigmaZ(0.)
  89 {
  90   // copy constructor
  91   AliError("Copy constructor not allowed");
  92 }
  93
  94 //--------------------------------------------------------------------//
  95 AliPMDtracker& AliPMDtracker::operator=(const AliPMDtracker & /* tracker */)
  96 {
  97  // assignment operator
  98   AliError("Assignment operator not allowed");
  99   return *this;
 100 }
 101
 102 //--------------------------------------------------------------------//
 103 AliPMDtracker::~AliPMDtracker()
 104 {
 105   // Destructor
 106   if (fRecpoints)
 107     {
 108       fRecpoints->Delete();
 109       delete fRecpoints;
 110       fRecpoints=0;
 111     }
 112   if (fPMDcontin)
 113     {
 114       fPMDcontin->Delete();
 115       delete fPMDcontin;
 116       fPMDcontin=0;
 117     }
 118   if (fPMDcontout)
 119     {
 120       fPMDcontout->Delete();
 121       delete fPMDcontout;
 122       fPMDcontout=0;
 123     }
 124 }
 125 //--------------------------------------------------------------------//
 126 void AliPMDtracker::LoadClusters(TTree *treein)
 127 {
 128   // Load the Reconstructed tree
 129   fTreeR = treein;
 130 }
 131 //--------------------------------------------------------------------//
 132 void AliPMDtracker::Clusters2Tracks(AliESD *event)
 133 {
 134   // Converts digits to recpoints after running clustering
 135   // algorithm on CPV plane and PREshower plane
 136   //
 137
 138   Int_t   idet;
 139   Int_t   ismn;
 140   Float_t clusdata[6];
 141
 142   TBranch *branch = fTreeR->GetBranch("PMDRecpoint");
 143   if (!branch)
 144     {
 145       AliError("PMDRecpoint branch not found");
 146       return;
 147     }
 148   branch->SetAddress(&fRecpoints);
 149
 150   Int_t   nmodules = (Int_t) branch->GetEntries();
 151
 152   AliDebug(1,Form("Number of modules filled in treeR = %d",nmodules));
 153   for (Int_t imodule = 0; imodule < nmodules; imodule++)
 154     {
 155       branch->GetEntry(imodule);
 156       Int_t nentries = fRecpoints->GetLast();
 157       AliDebug(2,Form("Number of clusters per modules filled in treeR = %d"
 158                       ,nentries));
 159       for(Int_t ient = 0; ient < nentries+1; ient++)
 160         {
 161           fPMDrecpoint = (AliPMDrecpoint1*)fRecpoints->UncheckedAt(ient);
 162           idet        = fPMDrecpoint->GetDetector();
 163           ismn        = fPMDrecpoint->GetSMNumber();
 164           clusdata[0] = fPMDrecpoint->GetClusX();
 165           clusdata[1] = fPMDrecpoint->GetClusY();
 166           clusdata[2] = fPMDrecpoint->GetClusADC();
 167           clusdata[3] = fPMDrecpoint->GetClusCells();
 168           clusdata[4] = fPMDrecpoint->GetClusSigmaX();
 169           clusdata[5] = fPMDrecpoint->GetClusSigmaY();
 170
 171           fPMDclin = new AliPMDrecpoint1(idet,ismn,clusdata);
 172           fPMDcontin->Add(fPMDclin);
 173         }
 174     }
 175
 176   AliPMDDiscriminator *pmddiscriminator = new AliPMDEmpDiscriminator();
 177   pmddiscriminator->Discrimination(fPMDcontin,fPMDcontout);
 178
 179   const Float_t kzpos = 361.5;    // middle of the PMD
 180
 181   Int_t   det,smn;
 182   Float_t xpos,ypos;
 183   Float_t adc, ncell, rad;
 184   Float_t xglobal = 0., yglobal = 0., zglobal = 0;
 185   Float_t pid;
 186
 187
 188   Int_t nentries2 = fPMDcontout->GetEntries();
 189   AliDebug(1,Form("Number of clusters coming after discrimination = %d"
 190                   ,nentries2));
 191   for (Int_t ient1 = 0; ient1 < nentries2; ient1++)
 192     {
 193       fPMDclout = (AliPMDclupid*)fPMDcontout->UncheckedAt(ient1);
 194
 195       det   = fPMDclout->GetDetector();
 196       smn   = fPMDclout->GetSMN();
 197       xpos  = fPMDclout->GetClusX();
 198       ypos  = fPMDclout->GetClusY();
 199       adc   = fPMDclout->GetClusADC();
 200       ncell = fPMDclout->GetClusCells();
 201       rad   = fPMDclout->GetClusRadius();
 202       pid   = fPMDclout->GetClusPID();
 203
 204       //
 205       /**********************************************************************
 206        *    det   : Detector, 0: PRE & 1:CPV                                *
 207        *    smn   : Serial Module Number 0 to 23 for each plane             *
 208        *    xpos  : x-position of the cluster                               *
 209        *    ypos  : y-position of the cluster                               *
 210        *            THESE xpos & ypos are not the true xpos and ypos        *
 211        *            for some of the unit modules. They are rotated.         *
 212        *    adc   : ADC contained in the cluster                            *
 213        *    ncell : Number of cells contained in the cluster                *
 214        *    rad   : radius of the cluster (1d fit)                          *
 215        **********************************************************************/
 216       //
 217
 218       fPMDutil->RectGeomCellPos(smn,xpos,ypos,xglobal,yglobal);
 219
 220       if (det == 0)
 221         {
 222           zglobal = kzpos + 1.6; // PREshower plane
 223         }
 224       else if (det == 1)
 225         {
 226           zglobal = kzpos - 1.7; // CPV plane
 227         }
 228
 229       // Fill ESD
 230
 231       AliESDPmdTrack *esdpmdtr = new  AliESDPmdTrack();
 232
 233       esdpmdtr->SetDetector(det);
 234       esdpmdtr->SetClusterX(xglobal);
 235       esdpmdtr->SetClusterY(yglobal);
 236       esdpmdtr->SetClusterZ(zglobal);
 237       esdpmdtr->SetClusterADC(adc);
 238       esdpmdtr->SetClusterCells(ncell);
 239       esdpmdtr->SetClusterPID(pid);
 240
 241       event->AddPmdTrack(esdpmdtr);
 242     }
 243 }
 244 //--------------------------------------------------------------------//
 245 void AliPMDtracker::SetVertex(Double_t vtx[3], Double_t evtx[3])
 246 {
 247   fXvertex = vtx[0];
 248   fYvertex = vtx[1];
 249   fZvertex = vtx[2];
 250   fSigmaX  = evtx[0];
 251   fSigmaY  = evtx[1];
 252   fSigmaZ  = evtx[2];
 253 }
 254 //--------------------------------------------------------------------//
 255 void AliPMDtracker::ResetClusters()
 256 {
 257   if (fRecpoints) fRecpoints->Clear();
 258 }
 259 //--------------------------------------------------------------------//