ITS/AliITSClusterFinder.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 // Base Class used to find
  17 // the reconstructed points for ITS
  18 // See also AliITSClusterFinderSPD, AliITSClusterFinderSDD,
  19 // AliITSClusterFinderSDD
  20 //
  21
  22 #include "AliITSClusterFinder.h"
  23 #include "AliITSdigitSPD.h"
  24 #include "AliITSdigitSDD.h"
  25 #include "AliITSdigitSSD.h"
  26 #include "AliITSMap.h"
  27 #include "AliRun.h"
  28 #include "AliITS.h"
  29
  30 ClassImp(AliITSClusterFinder)
  31
  32 //----------------------------------------------------------------------
  33 AliITSClusterFinder::AliITSClusterFinder():
  34 TObject(),
  35 fDebug(0),
  36 fModule(0),
  37 fDigits(0),
  38 fNdigits(0),
  39 fResponse(0),
  40 fSegmentation(0),
  41 fClusters(0),
  42 fNRawClusters(0),
  43 fMap(0),
  44 fNperMax(0),
  45 fDeclusterFlag(0),
  46 fClusterSize(0),
  47 fNPeaks(-1){
  48     // default cluster finder
  49     // Input:
  50     //   none.
  51     // Output:
  52     //   none.
  53     // Return:
  54     //   A default constructed AliITSCulsterFinder
  55 }
  56 //----------------------------------------------------------------------
  57 AliITSClusterFinder::AliITSClusterFinder(AliITSsegmentation *seg,
  58                                          AliITSresponse *res):
  59 TObject(),
  60 fDebug(0),
  61 fModule(0),
  62 fDigits(0),
  63 fNdigits(0),
  64 fResponse(res),
  65 fSegmentation(seg),
  66 fClusters(0),
  67 fNRawClusters(0),
  68 fMap(0),
  69 fNperMax(0),
  70 fDeclusterFlag(0),
  71 fClusterSize(0),
  72 fNPeaks(-1){
  73     // Standard constructor for cluster finder
  74     // Input:
  75     //   AliITSsegmentation *seg  The segmentation class to be used
  76     //   AliITSresponse     *res  The response class to be used
  77     // Output:
  78     //   none.
  79     // Return:
  80     //   A Standard constructed AliITSCulsterFinder
  81
  82     SetNperMax();
  83     SetClusterSize();
  84     SetDeclusterFlag();
  85 }
  86 //----------------------------------------------------------------------
  87 AliITSClusterFinder::AliITSClusterFinder(AliITSsegmentation *seg,
  88                                          AliITSresponse *response,
  89                                          TClonesArray *digits):
  90 TObject(),
  91 fDebug(0),
  92 fModule(0),
  93 fDigits(digits),
  94 fNdigits(0),
  95 fResponse(response),
  96 fSegmentation(seg),
  97 fClusters(0),
  98 fNRawClusters(0),
  99 fMap(0),
 100 fNperMax(0),
 101 fDeclusterFlag(0),
 102 fClusterSize(0),
 103 fNPeaks(-1){
 104     // Standard + cluster finder constructor
 105     // Input:
 106     //   AliITSsegmentation *seg  The segmentation class to be used
 107     //   AliITSresponse     *res  The response class to be used
 108     //   TClonesArray    *digits  Array of digits to be used
 109     // Output:
 110     //   none.
 111     // Return:
 112     //   A Standard constructed AliITSCulsterFinder
 113
 114     fNdigits = fDigits->GetEntriesFast();
 115     SetNperMax();
 116     SetClusterSize();
 117     SetDeclusterFlag();
 118 }
 119 //----------------------------------------------------------------------
 120 AliITSClusterFinder::~AliITSClusterFinder(){
 121     // destructor cluster finder
 122     // Input:
 123     //   none.
 124     // Output:
 125     //   none.
 126     // Return:
 127     //   none.
 128
 129     if(fMap) {delete fMap;}
 130     // Zero local pointers. Other classes own these pointers.
 131     fSegmentation = 0;
 132     fResponse     = 0;
 133     fMap          = 0;
 134     fDigits       = 0;
 135     fNdigits      = 0;
 136     fNRawClusters = 0;
 137     fNperMax      = 0;
 138     fDeclusterFlag= 0;
 139     fClusterSize  = 0;
 140     fNPeaks       = 0;
 141 }
 142 //__________________________________________________________________________
 143 AliITSClusterFinder::AliITSClusterFinder(const AliITSClusterFinder &source) :
 144     TObject(source){
 145     //     Copy Constructor
 146     // Input:
 147     //   AliITSClusterFinder &source  The class which will become a copy of
 148     //                                this class
 149     // Output:
 150     //   none.
 151     // Return:
 152     //   A copy of this class
 153
 154     if(&source == this) return;
 155     *this = source;
 156     return;
 157 }
 158 //______________________________________________________________________
 159 AliITSClusterFinder& AliITSClusterFinder::operator=(const AliITSClusterFinder
 160                                                     &source) {
 161     //    Assignment operator
 162     // Input:
 163     //   AliITSClusterFinder &source  The class which will become a copy of
 164     //                                this class
 165     // Output:
 166     //   none.
 167     // Return:
 168     //   A copy of this class
 169
 170     if(&source == this) return *this;
 171     this->fDigits = source.fDigits;
 172     this->fNdigits = source.fNdigits;
 173     this->fResponse = source.fResponse;
 174     this->fSegmentation = source.fSegmentation;
 175     this->fNRawClusters = source.fNRawClusters;
 176     this->fMap = source.fMap;
 177     this->fNperMax = source.fNperMax;
 178     this->fDeclusterFlag = source.fDeclusterFlag;
 179     this->fClusterSize = source.fClusterSize;
 180     this->fNPeaks = source.fNPeaks;
 181     return *this;
 182 }
 183 //----------------------------------------------------------------------
 184 void AliITSClusterFinder::AddCluster(Int_t branch, AliITSRawCluster *c){
 185     // Add a raw cluster copy to the list
 186     // Input:
 187     //   Int_t       branch  The branch to which the cluster is to be added to
 188     //   AliITSRawCluster *c The cluster to be added to the array of clusters
 189     // Output:
 190     //   none.
 191     // Return:
 192     //   none.
 193
 194     AliITS *iTS=(AliITS*)gAlice->GetModule("ITS");
 195     iTS->AddCluster(branch,c);
 196     fNRawClusters++;
 197 }
 198 //----------------------------------------------------------------------
 199 void AliITSClusterFinder::AddCluster(Int_t branch, AliITSRawCluster *c,
 200                                      AliITSRecPoint &rp){
 201     // Add a raw cluster copy to the list and the RecPoint
 202     // Input:
 203     //   Int_t       branch  The branch to which the cluster is to be added to
 204     //   AliITSRawCluster *c The cluster to be added to the array of clusters
 205     //   AliITSRecPoint  &rp The RecPoint to be added to the array of RecPoints
 206     // Output:
 207     //   none.
 208     // Return:
 209     //   none.
 210
 211     AliITS *iTS=(AliITS*)gAlice->GetModule("ITS");
 212     iTS->AddCluster(branch,c);
 213     fNRawClusters++;
 214     iTS->AddRecPoint(rp);
 215 }
 216 //______________________________________________________________________
 217 void AliITSClusterFinder::FindRawClusters(Int_t module){
 218     // Default Cluster finder.
 219     // Input:
 220     //   Int_t module   Module number for which culster are to be found.
 221     // Output:
 222     //   none.
 223     // Return:
 224     //   none.
 225     const Int_t kelms = 10;
 226     Int_t ndigits = fDigits->GetEntriesFast();
 227     TObjArray *digs = new TObjArray(ndigits);
 228     TObjArray *clusts = new TObjArray(ndigits); // max # cluster
 229     TObjArray *clust0=0; // A spacific cluster of digits
 230     TObjArray *clust1=0; // A spacific cluster of digits
 231     AliITSdigit *dig=0; // locat pointer to a digit
 232     Int_t i=0,nc=0,j[4],k,k2=0;
 233
 234     // Copy all digits for this module into a local TObjArray.
 235     for(i=0;i<ndigits;i++) digs->AddAt(new AliITSdigit(*(GetDigit(i))),i);
 236     digs->Sort();
 237     // First digit is a cluster.
 238     i  = 0;
 239     nc = 0;
 240     clusts->AddAt(new TObjArray(kelms),nc);
 241     clust0 = (TObjArray*)(clusts->At(nc));
 242     clust0->AddAtFree(digs->At(i)); // move owner ship from digs to clusts
 243     nc++;
 244     for(i=1;i<ndigits;i++){
 245         if(IsNeighbor(digs,i,j)){
 246             dig = (AliITSdigit*)(digs->At(j[0]));
 247             // Add to existing cluster. Find which cluster this digis
 248             for(k=0;k<nc;k++){
 249                 clust0 = ((TObjArray*)(clusts->At(k)));
 250                 if(clust0->IndexOf(dig)>=0) break;
 251             } // end for k
 252             if(k>=nc){
 253                 Fatal("FindRawClusters","Digit not found as expected");
 254             } // end if
 255             if(j[1]>=0){
 256                 dig = (AliITSdigit*)(digs->At(j[1]));
 257                 // Add to existing cluster. Find which cluster this digis
 258                 for(k2=0;k2<nc;k2++){
 259                     clust1 = ((TObjArray*)(clusts->At(k2)));
 260                     if(clust1->IndexOf(dig)>=0) break;
 261                 } // end for k2
 262                 if(k2>=nc){
 263                     Fatal("FindRawClusters","Digit not found as expected");
 264                 } // end if
 265             } // end if j[1]>=0
 266             // Found cluster with neighboring digits add this one to it.
 267             if(clust0==clust1){ // same cluster
 268                 clust0->AddAtFree(digs->At(i));
 269                 clust0 = 0; // finished with cluster. zero for safty
 270                 clust1 = 0; // finished wit hcluster. zero for safty
 271             }else{ // two different clusters which need to be merged.
 272                 clust0->AddAtFree(digs->At(i)); // Add digit to this cluster.
 273                 for(k=0;k<clust1->GetEntriesFast();k++){
 274                     // move clust1 into clust0
 275                     //move digit to this cluster
 276                     clust0->AddAtFree(clust1->At(k));
 277                     clust1->AddAt(0,k); // zero this one
 278                 } // end for k
 279                 delete clust1;
 280                 clusts->AddAt(0,k2); // zero array of clusters element clust1
 281                 clust0 = 0; // finished with cluster. zero for safty
 282                 clust1 = 0; // finished wit hcluster. zero for safty
 283             } // end if clust0==clust1
 284         }else{// New cluster
 285             clusts->AddAt(new TObjArray(kelms),nc);
 286             clust0 = ((TObjArray*)(clusts->At(nc)));
 287             // move owner ship from digs to clusts
 288             clust0->AddAtFree(digs->At(i));
 289             clust0 = 0; // finished with cluster. zero for safty
 290             nc++;
 291         } // End if IsNeighbor
 292     } // end for i
 293     // There are now nc clusters in clusts. Each element of clust is an
 294     // array of digits which are clustered together.
 295
 296     // For each cluster call detector specific CreateRecPoints
 297     for(i=0;i<nc;i++) CreateRecPoints((TObjArray*)(clusts->At(i)),module);
 298
 299     // clean up at the end.
 300     for(i=0;i<nc;i++){
 301         clust0 =(TObjArray*)(clusts->At(i));
 302         // Digits deleted below, so zero this TObjArray
 303         for(k=0;k<clust0->GetEntriesFast();k++) clust0->AddAt(0,k);
 304         delete clust0; // Delete this TObjArray
 305         clusts->AddAt(0,i); // Contents deleted above, so zero it.
 306     } // end for i
 307     delete clusts; // Delete this TObjArray/
 308     // Delete the digits then the TObjArray which containted them.
 309     for(i=0;i<ndigits;i++) delete ((AliITSdigit*)(digs->At(i)));
 310     delete digs;
 311 }
 312 //______________________________________________________________________
 313 Bool_t AliITSClusterFinder::IsNeighbor(TObjArray *digs,Int_t i,Int_t n[])const{
 314     // Locagical function which checks to see if digit i has a neighbor.
 315     // If so, then it returns kTRUE and its neighbor index j.
 316     // This routine checks if the digits are side by side or one before the
 317     // other. Requires that the array of digits be in proper order.
 318     // Returns kTRUE in the following cases.
 319     //                 ji   0j   if kdiagonal  j0    0i
 320     //                 00   0i   if kdiagonal  0i    j0
 321     // Inputs:
 322     //    TObjArray *digs   Array to search for neighbors in
 323     //    Int_t      i      Index of digit for which we are searching for
 324     //                      a neighbor of.
 325     // Output:
 326     //    Int_t      j[4]   Index of one or more of the digits which is a
 327     //                      neighbor of digit a index i.
 328     // Return:
 329     //    Bool_t            kTRUE if a neighbor was found kFALSE otherwise.
 330     Int_t ix,jx,iz,jz,j;
 331     const Bool_t kdiagonal=kFALSE;
 332     Bool_t nei[4];
 333
 334     // No neighbors found if array empty.
 335     if(digs->GetEntriesFast()<=0) return kFALSE;
 336     // can not be a digit with first element or elements out or range
 337     if(i<=0 || i>=digs->GetEntriesFast()) return kFALSE;
 338
 339     for(j=0;j<4;j++){n[j] = -1;nei[j]=kFALSE;}
 340     ix = ((AliITSdigit*)(digs->At(i)))->GetCoord1();
 341     iz = ((AliITSdigit*)(digs->At(i)))->GetCoord2();
 342     for(j=0;j<i;j++){
 343         jx = ((AliITSdigit*)(digs->At(j)))->GetCoord1();
 344         jz = ((AliITSdigit*)(digs->At(j)))->GetCoord2();
 345         if(jx+1==ix && jz  ==iz){n[0] = j;nei[0] = kTRUE;}
 346         if(jx  ==ix && jz+1==iz){n[1] = j;nei[1] = kTRUE;}
 347         if(jx+1==ix && jz+1==iz){n[2] = j;nei[2] = kTRUE;}
 348         if(jx+1==ix && jz-1==iz){n[3] = j;nei[3] = kTRUE;}
 349     } // end for k
 350     if(nei[0]||nei[1]) return kTRUE;
 351     if(kdiagonal&&(nei[2]||nei[3])) return kTRUE;
 352     // no Neighbors found.
 353     return kFALSE;
 354 }
 355
 356 //______________________________________________________________________
 357 void AliITSClusterFinder::Print(ostream *os){
 358     //Standard output format for this class
 359     // Inputs:
 360     //    ostream *os   Output stream
 361     // Output:
 362     //    ostream *os   Output stream
 363     // Return:
 364     //    none.
 365
 366     *os << fDebug<<",";
 367     *os << fModule<<",";
 368     *os << fNdigits<<",";
 369     *os << fNRawClusters<<",";
 370     *os << fNperMax<<",";
 371     *os << fDeclusterFlag<<",";
 372     *os << fClusterSize<<",";
 373     *os << fNPeaks<<endl;
 374 }
 375 //______________________________________________________________________
 376 void AliITSClusterFinder::Read(istream *is){
 377     //Standard input for this class
 378     // Inputs:
 379     //    istream *is   Input stream
 380     // Output:
 381     //    istream *is   Input stream
 382     // Return:
 383     //    none.
 384
 385     *is >> fDebug;
 386     *is >> fModule;
 387     *is >> fNdigits;
 388     *is >> fNRawClusters;
 389     *is >> fNperMax;
 390     *is >> fDeclusterFlag;
 391     *is >> fClusterSize;
 392     *is >> fNPeaks;
 393 }
 394 //______________________________________________________________________
 395 ostream &operator<<(ostream &os,AliITSClusterFinder &source){
 396     // Standard output streaming function.
 397     // Inputs:
 398     //    ostream             *os     Output stream
 399     //    AliITSClusterFinder &source Class to be printed
 400     // Output:
 401     //    ostream             *os     Output stream
 402     // Return:
 403     //    none.
 404
 405     source.Print(&os);
 406     return os;
 407 }
 408 //______________________________________________________________________
 409 istream &operator>>(istream &is,AliITSClusterFinder &source){
 410     // Standard output streaming function.
 411     // Inputs:
 412     //    istream              *is      Input stream
 413     //     AliITSClusterFinder &source  Class to be read in.
 414     // Output:
 415     //    istream              *is      Input stream
 416     // Return:
 417     //    none.
 418
 419     source.Read(&is);
 420     return is;
 421 }