MUON/AliMUONRawCluster.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 /* $Id$ */
  17
  18 // Class for the MUON RecPoint
  19 // It contains the properties of the physics cluters found in the tracking chambers
  20 // RawCluster contains also the information from the both cathode of the chambers.
  21 //
  22 //
  23
  24 #include <TArrayF.h>
  25
  26 #include "AliMUONRawCluster.h"
  27
  28 ClassImp(AliMUONRawCluster)
  29
  30
  31 AliMUONRawCluster::AliMUONRawCluster()
  32   : TObject()
  33 {
  34 // Constructor
  35     fTracks[0]=fTracks[1]=fTracks[2]=-1;
  36     for (int j=0;j<2;j++) {
  37         fQ[j]=0;
  38         fX[j]=0;
  39         fY[j]=0;
  40         fMultiplicity[j]=0;
  41         fPeakSignal[j]=-1;
  42         fChi2[j]=-1;
  43
  44         for (int k=0;k<50;k++) {
  45             fIndexMap[k][j]=-1;
  46             fOffsetMap[k][j]=0;
  47             fContMap[k][j]=0;
  48             fPhysicsMap[k]=-1;
  49         }
  50     }
  51     fNcluster[0]=fNcluster[1]=-1;
  52     fGhost=0;
  53     fDetElemId = 0;
  54 }
  55 //____________________________________________________
  56 Int_t AliMUONRawCluster::Compare(const TObject *obj) const
  57 {
  58   /*
  59          AliMUONRawCluster *raw=(AliMUONRawCluster *)obj;
  60          Float_t r=GetRadius();
  61          Float_t ro=raw->GetRadius();
  62          if (r>ro) return 1;
  63          else if (r<ro) return -1;
  64          else return 0;
  65   */
  66          AliMUONRawCluster *raw=(AliMUONRawCluster *)obj;
  67          Float_t y=fY[0];
  68          Float_t yo=raw->fY[0];
  69          if (y>yo) return 1;
  70          else if (y<yo) return -1;
  71          else return 0;
  72
  73 }
  74 //____________________________________________________
  75 Int_t AliMUONRawCluster::BinarySearch(Float_t y, TArrayF coord, Int_t from, Int_t upto)
  76 {
  77    // Find object using a binary search. Array must first have been sorted.
  78    // Search can be limited by setting upto to desired index.
  79
  80    Int_t low=from, high=upto-1, half;
  81    while(high-low>1) {
  82         half=(high+low)/2;
  83         if(y>coord[half]) low=half;
  84         else high=half;
  85    }
  86    return low;
  87 }
  88 //____________________________________________________
  89 void AliMUONRawCluster::SortMin(Int_t *idx,Float_t *xdarray,Float_t *xarray,Float_t *yarray,Float_t *qarray, Int_t ntr)
  90 {
  91   //
  92   // Get the 3 closest points(cog) one can find on the second cathode
  93   // starting from a given cog on first cathode
  94   //
  95
  96   //
  97   //  Loop over deltax, only 3 times
  98   //
  99
 100     Float_t xmin;
 101     Int_t jmin;
 102     Int_t id[3] = {-2,-2,-2};
 103     Float_t jx[3] = {0.,0.,0.};
 104     Float_t jy[3] = {0.,0.,0.};
 105     Float_t jq[3] = {0.,0.,0.};
 106     Int_t jid[3] = {-2,-2,-2};
 107     Int_t i,j,imax;
 108
 109     if (ntr<3) imax=ntr;
 110     else imax=3;
 111     for(i=0;i<imax;i++){
 112         xmin=1001.;
 113         jmin=0;
 114
 115         for(j=0;j<ntr;j++){
 116             if ((i == 1 && j == id[i-1])
 117                   ||(i == 2 && (j == id[i-1] || j == id[i-2]))) continue;
 118            if (TMath::Abs(xdarray[j]) < xmin) {
 119               xmin = TMath::Abs(xdarray[j]);
 120               jmin=j;
 121            }
 122         } // j
 123         if (xmin != 1001.) {
 124            id[i]=jmin;
 125            jx[i]=xarray[jmin];
 126            jy[i]=yarray[jmin];
 127            jq[i]=qarray[jmin];
 128            jid[i]=idx[jmin];
 129         }
 130
 131     }  // i
 132
 133     for (i=0;i<3;i++){
 134         if (jid[i] == -2) {
 135             xarray[i]=1001.;
 136             yarray[i]=1001.;
 137             qarray[i]=1001.;
 138             idx[i]=-1;
 139         } else {
 140             xarray[i]=jx[i];
 141             yarray[i]=jy[i];
 142             qarray[i]=jq[i];
 143             idx[i]=jid[i];
 144         }
 145     }
 146
 147 }
 148
 149 //____________________________________________________
 150 Int_t AliMUONRawCluster::PhysicsContribution() const
 151 {
 152 // Evaluate physics contribution to cluster
 153   Int_t iPhys=0;
 154   Int_t iBg=0;
 155   Int_t iMixed=0;
 156   for (Int_t i=0; i<fMultiplicity[0]; i++) {
 157     if (fPhysicsMap[i]==2) iPhys++;
 158     if (fPhysicsMap[i]==1) iMixed++;
 159     if (fPhysicsMap[i]==0) iBg++;
 160   }
 161   if (iMixed==0 && iBg==0) {
 162     return 2;
 163   } else if ((iPhys != 0 && iBg !=0) || iMixed != 0) {
 164     return 1;
 165   } else {
 166     return 0;
 167   }
 168 }
 169 //____________________________________________________
 170 void AliMUONRawCluster::DumpIndex(void)
 171 {
 172   // Dumping IdexMap of the cluster
 173     printf ("-----\n");
 174     for (Int_t icat=0;icat<2;icat++) {
 175         printf ("Mult %d\n",fMultiplicity[icat]);
 176         for (Int_t idig=0;idig<fMultiplicity[icat];idig++){
 177             printf("Index %d",fIndexMap[idig][icat]);
 178         }
 179         printf("\n");
 180     }
 181 }
 182 //____________________________________________________
 183 Int_t AliMUONRawCluster::AddCharge(Int_t i, Int_t Q)
 184 {
 185   // Adding Q to the fQ value
 186   if (i==0 || i==1) {
 187     fQ[i]+=Q;
 188     return 1;
 189   }
 190   else  return 0;
 191 }
 192 //____________________________________________________
 193 Int_t AliMUONRawCluster::AddX(Int_t i, Float_t X)
 194 {
 195   // Adding X to the fX value
 196   if (i==0 || i==1) {
 197     fX[i]+=X;
 198     return 1;
 199   }
 200   else  return 0;
 201 }
 202 //____________________________________________________
 203 Int_t AliMUONRawCluster::AddY(Int_t i, Float_t Y)
 204 {
 205   // Adding Y to the fY value
 206   if (i==0 || i==1) {
 207     fY[i]+=Y;
 208     return 1;
 209   }
 210   else return 0;
 211 }
 212 //____________________________________________________
 213 Int_t AliMUONRawCluster::AddZ(Int_t i, Float_t Z)
 214 {
 215   // Adding Z to the fZ value
 216   if (i==0 || i==1) {
 217     fZ[i]+=Z;
 218     return 1;
 219   }
 220   else return 0;
 221 }
 222 //____________________________________________________
 223 Int_t AliMUONRawCluster::GetCharge(Int_t i) const
 224 {
 225   // Getting the charge of the cluster
 226   if (i==0 || i==1) return fQ[i];
 227   else  return 99999;
 228 }
 229 //____________________________________________________
 230 Float_t AliMUONRawCluster::GetX(Int_t i)  const
 231 {
 232   // Getting X value of the cluster
 233   if (i==0 || i==1) return fX[i];
 234   else  return 99999.;
 235 }
 236 //____________________________________________________
 237 Float_t AliMUONRawCluster::GetY(Int_t i) const
 238 {
 239   // Getting Y value of the cluster
 240   if (i==0 || i==1) return fY[i];
 241   else  return 99999.;
 242 }
 243 //____________________________________________________
 244 Float_t AliMUONRawCluster::GetZ(Int_t i) const
 245 {
 246   // Getting Z value of the cluster
 247   if (i==0 || i==1) return fZ[i];
 248   else  return 99999.;
 249 }
 250 //____________________________________________________
 251 Int_t AliMUONRawCluster::GetTrack(Int_t i) const
 252 {
 253   // Getting track i contributing to the cluster
 254   if (i==0 || i==1 || i==2) return fTracks[i];
 255   else  return 99999;
 256 }
 257 //____________________________________________________
 258 Int_t AliMUONRawCluster::GetPeakSignal(Int_t i) const
 259 {
 260   // Getting cluster peaksignal
 261   if (i==0 || i==1 ) return fPeakSignal[i];
 262   else  return 99999;
 263 }
 264 //____________________________________________________
 265 Int_t AliMUONRawCluster::GetMultiplicity(Int_t i) const
 266 {
 267   // Getting cluster multiplicity
 268   if (i==0 || i==1 ) return fMultiplicity[i];
 269   else  return 99999;
 270 }
 271 //____________________________________________________
 272 Int_t AliMUONRawCluster::GetClusterType() const
 273 {
 274   // Getting Cluster Type
 275   return fClusterType;
 276 }
 277 //____________________________________________________
 278 Int_t AliMUONRawCluster::GetGhost() const
 279 {
 280   // Getting Ghost
 281   return fGhost;
 282 }
 283 //____________________________________________________
 284 Int_t AliMUONRawCluster::GetNcluster(Int_t i) const
 285 {
 286   // Getting number of clusters
 287   if (i==0 || i==1 ) return fNcluster[i];
 288   else  return 99999;
 289 }
 290 //____________________________________________________
 291 Float_t AliMUONRawCluster::GetChi2(Int_t i) const
 292 {
 293   // Getting chi2 value of the cluster
 294   if (i==0 || i==1) return fChi2[i];
 295   else  return 99999.;
 296 }
 297 //____________________________________________________
 298 Int_t AliMUONRawCluster::SetCharge(Int_t i, Int_t Q)
 299 {
 300   // Setting Charge of the cluster
 301   if (i==0 || i==1) {
 302     fQ[i]=Q;
 303     return 1;
 304   }
 305   else  return 0;
 306 }
 307 //____________________________________________________
 308 Int_t AliMUONRawCluster::SetX(Int_t i, Float_t X)
 309 {
 310   // Setting X value of the cluster
 311   if (i==0 || i==1) {
 312     fX[i]=X;
 313     return 1;
 314   }
 315   else  return 0;
 316 }
 317 //____________________________________________________
 318 Int_t AliMUONRawCluster::SetY(Int_t i, Float_t Y)
 319 {
 320   // Setting Y value of the cluster
 321   if (i==0 || i==1) {
 322     fY[i]=Y;
 323     return 1;
 324   }
 325   else return 0;
 326 }
 327 //____________________________________________________
 328 Int_t AliMUONRawCluster::SetZ(Int_t i, Float_t Z)
 329 {
 330   // Setting Z value of the cluste
 331   if (i==0 || i==1) {
 332     fZ[i]=Z;
 333     return 1;
 334   }
 335   else return 0;
 336 }
 337 //____________________________________________________
 338 Int_t AliMUONRawCluster::SetTrack(Int_t i, Int_t track)
 339 {
 340   // Setting tracks contributing to the cluster
 341   if (i==0 || i==1 || i==2) {
 342     fTracks[i]=track;
 343     return 1;
 344   }
 345   else return 0;
 346 }
 347 //____________________________________________________
 348 Int_t AliMUONRawCluster::SetPeakSignal(Int_t i, Int_t peaksignal)
 349 {
 350   // Setting PeakSignal of the cluster
 351   if (i==0 || i==1 ) {
 352     fPeakSignal[i]=peaksignal;
 353     return 1;
 354   }
 355   else return 0;
 356 }
 357 //____________________________________________________
 358 Int_t AliMUONRawCluster::SetMultiplicity(Int_t i, Int_t mul)
 359 {
 360   // Setting multiplicity of the cluster
 361   if (i==0 || i==1 ) {
 362     fMultiplicity[i]=mul;
 363     return 1;
 364   }
 365   else return 0;
 366 }
 367 //____________________________________________________
 368 Int_t AliMUONRawCluster::SetClusterType(Int_t type)
 369 {
 370   // Setting the cluster type
 371   fClusterType=type;
 372   return 1;
 373 }
 374 //____________________________________________________
 375 Int_t AliMUONRawCluster::SetGhost(Int_t ghost)
 376 {
 377   // Setting the ghost
 378   fGhost=ghost;
 379   return 1;
 380 }
 381 //____________________________________________________
 382 Int_t AliMUONRawCluster::SetNcluster(Int_t i, Int_t ncluster)
 383 {
 384   // Setting number the cluster
 385   if (i==0 || i==1 ) {
 386     fNcluster[i]=ncluster;
 387     return 1;
 388   }
 389   else return 0;
 390 }
 391 //____________________________________________________
 392 Int_t AliMUONRawCluster::SetChi2(Int_t i, Float_t chi2)
 393 {
 394   // Setting chi2 of the cluster
 395   if (i==0 || i==1) {
 396     fChi2[i]=chi2;
 397     return 1;
 398   }
 399   else return 0;
 400 }
 401