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