RICH/RICHpadtest.C

   1 void RICHpadtest (Int_t diaglevel,Int_t evNumber1=0,Int_t evNumber2=0)
   2 {
   3
   4 // Diaglevel
   5 // 1-> Single Ring Hits
   6 // 2-> Single Ring Spectra
   7 // 3-> Single Ring Statistics
   8 // 4-> Single Ring Reconstruction
   9 // 5-> Full Event Hits
  10
  11 /////////////////////////////////////////////////////////////////////////
  12 //   This macro is a small example of a ROOT macro
  13 //   illustrating how to read the output of GALICE
  14 //   and do some analysis.
  15 //
  16 /////////////////////////////////////////////////////////////////////////
  17
  18     gClassTable->GetID("AliRun");
  19
  20
  21 // Dynamically link some shared libs
  22
  23     if (gClassTable->GetID("AliRun") < 0) {
  24       gROOT->LoadMacro("loadlibs.C");
  25       loadlibs();
  26     }else {
  27       delete gAlice;
  28       gAlice = 0;
  29    }
  30
  31     gAlice=0;
  32
  33 // Connect the Root Galice file containing Geometry, Kine and Hits
  34
  35     TFile *file = (TFile*)gROOT->GetListOfFiles()->FindObject("galice.root");
  36     if (!file) file = new TFile("galice.root","UPDATE");
  37
  38 // Get AliRun object from file or create it if not on file
  39
  40     if (!gAlice) {
  41       gAlice = (AliRun*)file->Get("gAlice");
  42       if (gAlice) printf("AliRun object found on file\n");
  43       if (!gAlice) gAlice = new AliRun("gAlice","Alice test program");
  44     }
  45     else {
  46       delete gAlice;
  47       gAlice = (AliRun*)file->Get("gAlice");
  48       if (gAlice) printf("AliRun object found on file\n");
  49       if (!gAlice) gAlice = new AliRun("gAlice","Alice test program");
  50     }
  51
  52     AliRICH *RICH  = (AliRICH*)gAlice->GetDetector("RICH");
  53
  54     RICH->DiagnosticsSE(diaglevel,evNumber1,evNumber2);
  55
  56     file->Write();
  57
  58
  59 //  Create some histograms
  60
  61 /*   AliRICH *RICH  = (AliRICH*)gAlice->GetDetector("RICH");
  62    AliRICHSegmentationV0*  segmentation;
  63    AliRICHChamber*       chamber;
  64
  65    chamber = &(RICH->Chamber(0));
  66    segmentation=(AliRICHSegmentationV0*) chamber->GetSegmentationModel(0);
  67
  68    Int_t NpadX = segmentation->Npx();                 // number of pads on X
  69    Int_t NpadY = segmentation->Npy();                 // number of pads on Y
  70
  71    Int_t Pad[144][160];
  72    //for (Int_t i=0;i<NpadX;i++) {
  73    //for (Int_t j=0;j<NpadY;j++) {
  74    //Pad[i][j]=0;
  75    //}
  76    //}
  77
  78
  79    Int_t xmin= -NpadX/2;
  80    Int_t xmax=  NpadX/2;
  81    Int_t ymin= -NpadY/2;
  82    Int_t ymax=  NpadY/2;
  83
  84    TH2F *hc0 = new TH2F("hc0","Zoom on center of central chamber",150,-30,30,150,-50,10);
  85
  86    if (diaglevel == 1)
  87
  88      {
  89        printf("Single Ring Hits\n");
  90        TH2F *feedback = new TH2F("feedback","Feedback hit distribution",150,-30,30,150,-50,10);
  91        TH2F *mip = new TH2F("mip","Mip hit distribution",150,-30,30,150,-50,10);
  92        TH2F *cerenkov = new TH2F("cerenkov","Cerenkov hit distribution",150,-30,30,150,-50,10);
  93        TH2F *h = new TH2F("h","Detector hit distribution",150,-30,30,150,-50,10);
  94        TH1F *hitsX = new TH1F("hitsX","Distribution of hits along x-axis",150,-30,30);
  95        TH1F *hitsY = new TH1F("hitsY","Distribution of hits along z-axis",150,-50,10);
  96      }
  97    else
  98      {
  99        printf("Full Event Hits\n");
 100
 101        TH2F *feedback = new TH2F("feedback","Feedback hit distribution",150,-300,300,150,-300,300);
 102        TH2F *mip = new TH2F("mip","Mip hit distribution",150,-300,300,150,-300,300);
 103        TH2F *cerenkov = new TH2F("cerenkov","Cerenkov hit distribution",150,-300,300,150,-300,300);
 104        TH2F *h = new TH2F("h","Detector hit distribution",150,-300,300,150,-300,300);
 105        TH1F *hitsX = new TH1F("digitsX","Distribution of hits along x-axis",200,-300,300);
 106        TH1F *hitsY = new TH1F("digitsY","Distribution of hits along z-axis",200,-300,300);
 107      }
 108
 109
 110
 111    TH2F *hc1 = new TH2F("hc1","Chamber 1 signal distribution",NpadX,xmin,xmax,NpadY,ymin,ymax);
 112    TH2F *hc2 = new TH2F("hc2","Chamber 2 signal distribution",NpadX,xmin,xmax,NpadY,ymin,ymax);
 113    TH2F *hc3 = new TH2F("hc3","Chamber 3 signal distribution",NpadX,xmin,xmax,NpadY,ymin,ymax);
 114    TH2F *hc4 = new TH2F("hc4","Chamber 4 signal distribution",NpadX,xmin,xmax,NpadY,ymin,ymax);
 115    TH2F *hc5 = new TH2F("hc5","Chamber 5 signal distribution",NpadX,xmin,xmax,NpadY,ymin,ymax);
 116    TH2F *hc6 = new TH2F("hc6","Chamber 6 signal distribution",NpadX,xmin,xmax,NpadY,ymin,ymax);
 117    TH2F *hc7 = new TH2F("hc7","Chamber 7 signal distribution",NpadX,xmin,xmax,NpadY,ymin,ymax);
 118
 119    TH1F *Clcharge = new TH1F("Clcharge","Cluster Charge Distribution",500,0.,500.);
 120    TH1F *ckovangle = new TH1F("ckovangle","Cerenkov angle per photon",200,.5,1);
 121    TH1F *hckphi = new TH1F("hckphi","Cerenkov phi angle per photon",620,-3.1,3.1);
 122    TH1F *mother = new TH1F("mother","Cerenkovs per Mip",75,0.,75.);
 123    TH1F *radius = new TH1F("radius","Mean distance to Mip",100,0.,20.);
 124    TH1F *phspectra1 = new TH1F("phspectra1","Detected Photon Spectra",200,5.,10.);
 125    TH1F *phspectra2 = new TH1F("phspectra2","Produced Photon Spectra",200,5.,10.);
 126    TH1F *totalphotonstrack = new TH1F("totalphotonstrack","Produced Photons per Mip",100,200,700.);
 127    TH1F *totalphotonsevent = new TH1F("totalphotonsevent","Produced Photons per Mip",100,200,700.);
 128    TH1F *feedbacks = new TH1F("feedbacks","Produced Feedbacks per Mip",50,0.5,50.);
 129    TH1F *padnumber = new TH1F("padnumber","Number of pads per cluster",50,-0.5,50.);
 130    TH1F *padsev = new TH1F("padsev","Number of pads hit per MIP",50,0.5,100.);
 131    TH1F *clusev = new TH1F("clusev","Number of clusters per MIP",50,0.5,50.);
 132    TH1F *photev = new TH1F("photev","Number of detected photons per MIP",50,0.5,50.);
 133    TH1F *feedev = new TH1F("feedev","Number of feedbacks per MIP",50,0.5,50.);
 134    TH1F *padsmip = new TH1F("padsmip","Number of pads per event inside MIP region",50,0.5,50.);
 135    TH1F *padscl = new TH1F("padscl","Number of pads per event from cluster count",50,0.5,100.);
 136    TH1F *pionspectra = new TH1F("pionspectra","Pion Spectra",200,.5,10.);
 137    TH1F *protonspectra = new TH1F("protonspectra","Proton Spectra",200,.5,10.);
 138    TH1F *kaonspectra = new TH1F("kaonspectra","Kaon Spectra",100,.5,10.);
 139    TH1F *kaonspectra = new TH1F("kaonspectra","Kaon Spectra",100,.5,10.);
 140    TH1F *chargedspectra = new TH1F("chargedspectra","Charged particles above 1 GeV Spectra",100,.5,10.);
 141    TH1F *hitsPhi = new TH1F("hitsPhi","Distribution of phi angle of incidence",100,-180,180);
 142    TH1F *hitsTheta = new TH1F("hitsTheta","Distribution of Theta angle of incidence",100,0,15);
 143    TH1F *Omega1D = new TH1F("omega","Reconstructed Cerenkov angle per track",200,.5,1);
 144    TH1F *Theta = new TH1F("theta","Reconstructed theta incidence angle per track",200,0,15);
 145    TH1F *Phi = new TH1F("phi","Reconstructed phi incidence per track",200,-180,180);
 146    TH1F *Omega3D = new TH1F("omega","Reconstructed Cerenkov angle per track",200,.5,1);
 147    TH1F *PhotonCer = new TH1F("photoncer","Reconstructed Cerenkov angle per photon",200,.5,1);
 148    TH2F *PadsUsed = new TH2F("padsused","Pads Used for Reconstruction",100,-30,30,100,-30,30);
 149
 150 //   Start loop over events
 151
 152    Int_t Nh=0;
 153    Int_t pads=0;
 154    Int_t Nh1=0;
 155    Int_t mothers[80000];
 156    Int_t mothers2[80000];
 157    Float_t mom[3];
 158    Int_t nraw=0;
 159    Int_t phot=0;
 160    Int_t feed=0;
 161    Int_t padmip=0;
 162    for (Int_t i=0;i<100;i++) mothers[i]=0;
 163    for (int nev=0; nev<= evNumber2; nev++) {
 164        Int_t nparticles = gAlice->GetEvent(nev);
 165
 166
 167        //cout<<"nev  "<<nev<<endl;
 168        printf ("\n**********************************\nProcessing Event: %d\n",nev);
 169        //cout<<"nparticles  "<<nparticles<<endl;
 170        printf ("Particles       : %d\n\n",nparticles);
 171        if (nev < evNumber1) continue;
 172        if (nparticles <= 0) return;
 173
 174 // Get pointers to RICH detector and Hits containers
 175
 176
 177        if(gAlice->TreeR())
 178          {
 179            Int_t nent=(Int_t)gAlice->TreeR()->GetEntries();
 180            gAlice->TreeR()->GetEvent(nent-1);
 181            TClonesArray *Rawclusters = RICH->RawClustAddress(2);    //  Raw clusters branch
 182            //printf ("Rawclusters:%p",Rawclusters);
 183            Int_t nrawclusters = Rawclusters->GetEntriesFast();
 184            //printf (" nrawclusters:%d\n",nrawclusters);
 185            gAlice->TreeR()->GetEvent(nent-1);
 186            TClonesArray *RecHits1D = RICH->RecHitsAddress1D(2);
 187            Int_t nrechits1D = RecHits1D->GetEntriesFast();
 188            //printf (" nrechits:%d\n",nrechits);
 189            TClonesArray *RecHits3D = RICH->RecHitsAddress3D(2);
 190            Int_t nrechits3D = RecHits3D->GetEntriesFast();
 191            //printf (" nrechits:%d\n",nrechits);
 192          }
 193        else
 194          printf("No TreeR found on file.\n");
 195        TTree *TH = gAlice->TreeH();
 196        Int_t ntracks = TH->GetEntries();
 197
 198        gAlice->ResetDigits();
 199        Int_t nent=(Int_t)gAlice->TreeD()->GetEntries();
 200        gAlice->TreeD()->GetEvent(0);
 201
 202
 203
 204        // Start loop on tracks in the hits containers
 205        Int_t Nc=0;
 206        for (Int_t track=0; track<ntracks;track++) {
 207            printf ("\nProcessing Track: %d\n",track);
 208            gAlice->ResetHits();
 209            Int_t nbytes += TH->GetEvent(track);
 210            if (RICH)  {
 211                //RICH->ResetRawClusters();
 212                TClonesArray *SDigits = RICH->SDigits();      // Cluster branch
 213                TClonesArray *Hits = RICH->Hits();            // Hits branch
 214                TClonesArray *Cerenkovs = RICH->Cerenkovs();  // Cerenkovs branch
 215            }
 216            //see hits distribution
 217
 218
 219            Int_t nhits = Hits->GetEntriesFast();
 220            if (nhits) Nh+=nhits;
 221            printf("Hits            : %d\n",nhits);
 222            for (Int_t hit=0;hit<nhits;hit++) {
 223               mHit = (AliRICHHit*) Hits->UncheckedAt(hit);
 224               Int_t nch  = mHit->fChamber;              // chamber number
 225               Float_t x  = mHit->X();                    // x-pos of hit
 226               Float_t y  = mHit->Z();                    // y-pos
 227               Float_t phi = mHit->fPhi;                 //Phi angle of incidence
 228               Float_t theta = mHit->fTheta;             //Theta angle of incidence
 229               Int_t index = mHit->Track();
 230               Int_t particle = mHit->fParticle;
 231               Int_t freon = mHit->fLoss;
 232
 233               hitsX->Fill(x,(float) 1);
 234               hitsY->Fill(y,(float) 1);
 235
 236               //printf("Particle:%9d\n",particle);
 237
 238               TParticle *current = (TParticle*)gAlice->Particle(index);
 239               //printf("Particle type: %d\n",sizeoff(Particles));
 240
 241               hitsTheta->Fill(theta,(float) 1);
 242               if (RICH->GetDebugLevel() == -1)
 243                   //printf("Theta:%f, Phi:%f\n",theta,phi);
 244
 245               //printf("Debug Level:%d\n",RICH->GetDebugLevel());
 246
 247               if (TMath::Abs(particle) < 10000000)
 248                 {
 249                   mip->Fill(x,y,(float) 1);
 250                   //printf("adding mip\n");
 251                   if (current->Energy() - current->GetCalcMass()>1 && freon==1)
 252                     {
 253                       hitsPhi->Fill(phi,(float) 1);
 254                       //hitsTheta->Fill(theta,(float) 1);
 255                       //printf("Theta:%f, Phi:%f\n",theta,phi);
 256                     }
 257                 }
 258
 259               if (TMath::Abs(particle)==211 || TMath::Abs(particle)==111)
 260                 {
 261                   pionspectra->Fill(current->Energy() - current->GetCalcMass(),(float) 1);
 262                 }
 263               if (TMath::Abs(particle)==2212)
 264                 {
 265                   protonspectra->Fill(current->Energy() - current->GetCalcMass(),(float) 1);
 266                 }
 267               if (TMath::Abs(particle)==321 || TMath::Abs(particle)==130 || TMath::Abs(particle)==310
 268                   || TMath::Abs(particle)==311)
 269                 {
 270                   kaonspectra->Fill(current->Energy() - current->GetCalcMass(),(float) 1);
 271                 }
 272               if(TMath::Abs(particle)==211 || TMath::Abs(particle)==2212 || TMath::Abs(particle)==321)
 273                 {
 274                   if (current->Energy() - current->GetCalcMass()>1)
 275                     chargedspectra->Fill(current->Energy() - current->GetCalcMass(),(float) 1);
 276                 }
 277               //printf("Hits:%d\n",hit);
 278               //printf ("Chamber number:%d x:%f y:%f\n",nch,x,y);
 279               // Fill the histograms
 280               Nh1+=nhits;
 281               h->Fill(x,y,(float) 1);
 282                   //}
 283               //}
 284           }
 285
 286            Int_t ncerenkovs = Cerenkovs->GetEntriesFast();
 287            //if (current->GetPdgCode() < 50000051 && current->GetPdgCode() > 50000040)
 288            //totalphotonsevent->Fill(ncerenkovs,(float) 1);
 289
 290            if (ncerenkovs) {
 291              printf("Cerenkovs       : %d\n",ncerenkovs);
 292              totalphotonsevent->Fill(ncerenkovs,(float) 1);
 293              for (Int_t hit=0;hit<ncerenkovs;hit++) {
 294                    cHit = (AliRICHCerenkov*) Cerenkovs->UncheckedAt(hit);
 295                    Int_t nchamber = cHit->fChamber;     // chamber number
 296                    Int_t index =    cHit->Track();
 297                    Int_t pindex =   cHit->fIndex;
 298                    Float_t cx  =      cHit->X();                // x-position
 299                    Float_t cy  =      cHit->Z();                // y-position
 300                    Int_t cmother =  cHit->fCMother;      // Index of mother particle
 301                    Int_t closs =    cHit->fLoss;           // How did the particle get lost?
 302                    //printf ("Cerenkov hit number %d/%d, X:%d, Y:%d\n",hit,ncerenkovs,cx,cy);
 303
 304                    //printf("Particle:%9d\n",current->GetPdgCode());
 305
 306                    TParticle *current = (TParticle*)gAlice->Particle(index);
 307                    Float_t energyckov = current->Energy();
 308
 309                    if (current->GetPdgCode() == 50000051)
 310                      {
 311                        if (closs==4)
 312                          {
 313                            feedback->Fill(cx,cy,(float) 1);
 314                            feed++;
 315                          }
 316                      }
 317                    if (current->GetPdgCode() == 50000050)
 318                      {
 319
 320                        if (closs !=4)
 321                          {
 322                            phspectra2->Fill(energyckov*1e9,(float) 1);
 323                          }
 324
 325                        if (closs==4)
 326                          {
 327                            cerenkov->Fill(cx,cy,(float) 1);
 328
 329                            printf ("Cerenkov hit number %d/%d, X:%d, Y:%d\n",hit,ncerenkovs,cx,cy);
 330
 331                          TParticle *MIP = (TParticle*)gAlice->Particle(cmother);
 332                          mipHit = (AliRICHHit*) Hits->UncheckedAt(0);
 333                          mom[0] = current->Px();
 334                          mom[1] = current->Py();
 335                          mom[2] = current->Pz();
 336                          //mom[0] = cHit->fMomX;
 337                           // mom[1] = cHit->fMomZ;
 338                            //mom[2] = cHit->fMomY;
 339                          Float_t energymip = MIP->Energy();
 340                          Float_t Mip_px = mipHit->fMomFreoX;
 341                          Float_t Mip_py = mipHit->fMomFreoY;
 342                          Float_t Mip_pz = mipHit->fMomFreoZ;
 343                          //Float_t Mip_px = MIP->Px();
 344                            //Float_t Mip_py = MIP->Py();
 345                            //Float_t Mip_pz = MIP->Pz();
 346
 347
 348
 349                          Float_t r = mom[0]*mom[0] + mom[1]*mom[1] + mom[2]*mom[2];
 350                          Float_t rt = TMath::Sqrt(r);
 351                          Float_t Mip_r = Mip_px*Mip_px + Mip_py*Mip_py + Mip_pz*Mip_pz;
 352                          Float_t Mip_rt = TMath::Sqrt(Mip_r);
 353                          Float_t coscerenkov = (mom[0]*Mip_px + mom[1]*Mip_py + mom[2]*Mip_pz)/(rt*Mip_rt+0.0000001);
 354                          Float_t cherenkov = TMath::ACos(coscerenkov);
 355                          ckovangle->Fill(cherenkov,(float) 1);                           //Cerenkov angle calculus
 356                          //printf("Cherenkov: %f\n",cherenkov);
 357                          Float_t ckphi=TMath::ATan2(mom[0], mom[2]);
 358                          hckphi->Fill(ckphi,(float) 1);
 359
 360
 361                          Float_t mix = MIP->Vx();
 362                          Float_t miy = MIP->Vy();
 363                          Float_t mx = mipHit->X();
 364                          Float_t my = mipHit->Z();
 365                          //printf("FX %e, FY %e, VX %e, VY %e\n",cx,cy,mx,my);
 366                          Float_t dx = cx - mx;
 367                          Float_t dy = cy - my;
 368                          //printf("Dx:%f, Dy:%f\n",dx,dy);
 369                          Float_t final_radius = TMath::Sqrt(dx*dx+dy*dy);
 370                          //printf("Final radius:%f\n",final_radius);
 371                          radius->Fill(final_radius,(float) 1);
 372
 373                          phspectra1->Fill(energyckov*1e9,(float) 1);
 374                          phot++;
 375                        }
 376                      for (Int_t nmothers=0;nmothers<=ntracks;nmothers++){
 377                        if (cmother == nmothers){
 378                          if (closs == 4)
 379                            mothers2[cmother]++;
 380                          mothers[cmother]++;
 381                        }
 382                      }
 383                    }
 384                }
 385            }
 386
 387            if (nrawclusters) {
 388              printf("Raw Clusters    : %d\n",nrawclusters);
 389                for (Int_t hit=0;hit<nrawclusters;hit++) {
 390                    rcHit = (AliRICHRawCluster*) Rawclusters->UncheckedAt(hit);
 391                    //Int_t nchamber = rcHit->fChamber;     // chamber number
 392                    //Int_t nhit = cHit->fHitNumber;        // hit number
 393                    Int_t qtot = rcHit->fQ;                 // charge
 394                    Int_t fx  =  rcHit->fX;                 // x-position
 395                    Int_t fy  =  rcHit->fY;                 // y-position
 396                    Int_t type = rcHit->fCtype;             // cluster type ?
 397                    Int_t mult = rcHit->fMultiplicity;      // How many pads form the cluster
 398                    pads += mult;
 399                    if (qtot > 0) {
 400                      //printf ("fx: %d, fy: %d\n",fx,fy);
 401                      if (fx>(x-4) && fx<(x+4)  && fy>(y-4) && fy<(y+4)) {
 402                        //printf("There %d \n",mult);
 403                        padmip+=mult;
 404                      } else {
 405                        padnumber->Fill(mult,(float) 1);
 406                        nraw++;
 407                        if (mult<4) Clcharge->Fill(qtot,(float) 1);
 408                      }
 409
 410                    }
 411                }
 412            }
 413
 414            if(nrechits1D)
 415              {
 416                for (Int_t hit=0;hit<nrechits1D;hit++) {
 417                  recHit1D = (AliRICHRecHit1D*) RecHits1D->UncheckedAt(hit);
 418                  Float_t r_omega = recHit1D->fOmega;                  // Cerenkov angle
 419                  Float_t *cer_pho = recHit1D->fCerPerPhoton;        // Cerenkov angle per photon
 420                  Int_t *padsx = recHit1D->fPadsUsedX;           // Pads Used fo reconstruction (x)
 421                  Int_t *padsy = recHit1D->fPadsUsedY;           // Pads Used fo reconstruction (y)
 422                  Int_t goodPhotons = recHit1D->fGoodPhotons;    // Number of pads used for reconstruction
 423
 424                  Omega1D->Fill(r_omega,(float) 1);
 425
 426                  for (Int_t i=0; i<goodPhotons; i++)
 427                    {
 428                      PhotonCer->Fill(cer_pho[i],(float) 1);
 429                      PadsUsed->Fill(padsx[i],padsy[i],1);
 430                      //printf("Angle:%f, pad: %d %d\n",cer_pho[i],padsx[i],padsy[i]);
 431                    }
 432
 433                  //printf("Omega: %f, Theta: %f, Phi: %f\n",r_omega,r_theta,r_phi);
 434                }
 435              }
 436
 437            if(nrechits3D)
 438              {
 439                for (Int_t hit=0;hit<nrechits3D;hit++) {
 440                  recHit3D = (AliRICHRecHit3D*) RecHits3D->UncheckedAt(hit);
 441                  Float_t r_omega = recHit3D->fOmega;                  // Cerenkov angle
 442                  Float_t r_theta = recHit3D->fTheta;                  // Theta angle of incidence
 443                  Float_t r_phi   = recHit3D->fPhi;                    // Phi angle if incidence
 444
 445
 446                  Omega3D->Fill(r_omega,(float) 1);
 447                  Theta->Fill(r_theta*180/TMath::Pi(),(float) 1);
 448                  Phi->Fill(r_phi*180/TMath::Pi(),(float) 1);
 449
 450                }
 451              }
 452        }
 453
 454        for (Int_t nmothers=0;nmothers<ntracks;nmothers++){
 455            totalphotonstrack->Fill(mothers[nmothers],(float) 1);
 456            mother->Fill(mothers2[nmothers],(float) 1);
 457            //printf ("Entries in %d : %d\n",nmothers, mothers[nmothers]);
 458        }
 459
 460        clusev->Fill(nraw,(float) 1);
 461        photev->Fill(phot,(float) 1);
 462        feedev->Fill(feed,(float) 1);
 463        padsmip->Fill(padmip,(float) 1);
 464        padscl->Fill(pads,(float) 1);
 465        //printf("Photons:%d\n",phot);
 466        phot = 0;
 467        feed = 0;
 468        pads = 0;
 469        nraw=0;
 470        padmip=0;
 471
 472        if (diaglevel < 4)
 473          {
 474
 475
 476            TClonesArray *Digits  = RICH->DigitsAddress(2);
 477            Int_t ndigits = Digits->GetEntriesFast();
 478            printf("Digits          : %d\n",ndigits);
 479            padsev->Fill(ndigits,(float) 1);
 480            for (Int_t hit=0;hit<ndigits;hit++) {
 481              dHit = (AliRICHDigit*) Digits->UncheckedAt(hit);
 482              Int_t qtot = dHit->fSignal;                // charge
 483              Int_t ipx  = dHit->fPadX;               // pad number on X
 484              Int_t ipy  = dHit->fPadY;               // pad number on Y
 485              //printf("%d, %d\n",ipx,ipy);
 486              if( ipx<=100 && ipy <=100) hc0->Fill(ipx,ipy,(float) qtot);
 487            }
 488          }
 489
 490        if (diaglevel == 5)
 491          {
 492            for (Int_t ich=0;ich<7;ich++)
 493              {
 494                TClonesArray *Digits = RICH->DigitsAddress(ich);    //  Raw clusters branch
 495                Int_t ndigits = Digits->GetEntriesFast();
 496                //printf("Digits:%d\n",ndigits);
 497                padsev->Fill(ndigits,(float) 1);
 498                if (ndigits) {
 499                  for (Int_t hit=0;hit<ndigits;hit++) {
 500                    dHit = (AliRICHDigit*) Digits->UncheckedAt(hit);
 501                    //Int_t nchamber = dHit->fChamber;     // chamber number
 502                    //Int_t nhit = dHit->fHitNumber;          // hit number
 503                    Int_t qtot = dHit->fSignal;                // charge
 504                    Int_t ipx  = dHit->fPadX;               // pad number on X
 505                    Int_t ipy  = dHit->fPadY;               // pad number on Y
 506                    //Int_t iqpad  = dHit->fQpad;           // charge per pad
 507                    //Int_t rpad  = dHit->fRSec;            // R-position of pad
 508                    //printf ("Pad hit, PadX:%d, PadY:%d\n",ipx,ipy);
 509                    if( ipx<=100 && ipy <=100 && ich==2) hc0->Fill(ipx,ipy,(float) qtot);
 510                    if( ipx<=162 && ipy <=162 && ich==0) hc1->Fill(ipx,ipy,(float) qtot);
 511                    if( ipx<=162 && ipy <=162 && ich==1) hc2->Fill(ipx,ipy,(float) qtot);
 512                    if( ipx<=162 && ipy <=162 && ich==2) hc3->Fill(ipx,ipy,(float) qtot);
 513                    if( ipx<=162 && ipy <=162 && ich==3) hc4->Fill(ipx,ipy,(float) qtot);
 514                    if( ipx<=162 && ipy <=162 && ich==4) hc5->Fill(ipx,ipy,(float) qtot);
 515                    if( ipx<=162 && ipy <=162 && ich==5) hc6->Fill(ipx,ipy,(float) qtot);
 516                    if( ipx<=162 && ipy <=162 && ich==6) hc7->Fill(ipx,ipy,(float) qtot);
 517                  }
 518                }
 519              }
 520          }
 521    }
 522
 523
 524    //Create canvases, set the view range, show histograms
 525
 526   switch(diaglevel)
 527      {
 528      case 1:
 529
 530        TCanvas *c1 = new TCanvas("c1","Alice RICH digits",50,50,300,350);
 531        hc0->SetXTitle("ix (npads)");
 532        hc0->Draw("box");
 533
 534 //
 535        TCanvas *c4 = new TCanvas("c4","Hits per type",100,100,600,700);
 536        c4->Divide(2,2);
 537        //c4->SetFillColor(42);
 538
 539        c4->cd(1);
 540        feedback->SetXTitle("x (cm)");
 541        feedback->SetYTitle("y (cm)");
 542        feedback->Draw();
 543
 544        c4->cd(2);
 545        //mip->SetFillColor(5);
 546        mip->SetXTitle("x (cm)");
 547        mip->SetYTitle("y (cm)");
 548        mip->Draw();
 549
 550        c4->cd(3);
 551        //cerenkov->SetFillColor(5);
 552        cerenkov->SetXTitle("x (cm)");
 553        cerenkov->SetYTitle("y (cm)");
 554        cerenkov->Draw();
 555
 556        c4->cd(4);
 557        //h->SetFillColor(5);
 558        h->SetXTitle("x (cm)");
 559        h->SetYTitle("y (cm)");
 560        h->Draw();
 561
 562        TCanvas *c10 = new TCanvas("c10","Hits distribution",150,150,600,350);
 563        c10->Divide(2,1);
 564        //c10->SetFillColor(42);
 565
 566        c10->cd(1);
 567        hitsX->SetFillColor(5);
 568        hitsX->SetXTitle("(cm)");
 569        hitsX->Draw();
 570
 571        c10->cd(2);
 572        hitsY->SetFillColor(5);
 573        hitsY->SetXTitle("(cm)");
 574        hitsY->Draw();
 575
 576
 577        break;
 578 //
 579      case 2:
 580
 581        TCanvas *c6 = new TCanvas("c6","Photon Spectra",50,50,600,350);
 582        c6->Divide(2,1);
 583        //c6->SetFillColor(42);
 584
 585        c6->cd(1);
 586        phspectra2->SetFillColor(5);
 587        phspectra2->SetXTitle("energy (eV)");
 588        phspectra2->Draw();
 589        c6->cd(2);
 590        phspectra1->SetFillColor(5);
 591        phspectra1->SetXTitle("energy (eV)");
 592        phspectra1->Draw();
 593
 594        TCanvas *c9 = new TCanvas("c9","Particles Spectra",100,100,600,700);
 595        c9->Divide(2,2);
 596        //c9->SetFillColor(42);
 597
 598        c9->cd(1);
 599        pionspectra->SetFillColor(5);
 600        pionspectra->SetXTitle("(GeV)");
 601        pionspectra->Draw();
 602
 603        c9->cd(2);
 604        protonspectra->SetFillColor(5);
 605        protonspectra->SetXTitle("(GeV)");
 606        protonspectra->Draw();
 607
 608        c9->cd(3);
 609        kaonspectra->SetFillColor(5);
 610        kaonspectra->SetXTitle("(GeV)");
 611        kaonspectra->Draw();
 612
 613        c9->cd(4);
 614        chargedspectra->SetFillColor(5);
 615        chargedspectra->SetXTitle("(GeV)");
 616        chargedspectra->Draw();
 617
 618        break;
 619
 620      case 3:
 621
 622        if (nrawclusters) {
 623          TCanvas *c3=new TCanvas("c3","Clusters Statistics",50,50,600,700);
 624          c3->Divide(2,2);
 625          //c3->SetFillColor(42);
 626
 627          c3->cd(1);
 628          c3_1->SetLogy();
 629          Clcharge->SetFillColor(5);
 630          Clcharge->SetXTitle("ADC counts");
 631          if (evNumber2>10)
 632            {
 633              Clcharge->Fit("expo");
 634              expo->SetLineColor(2);
 635              expo->SetLineWidth(3);
 636            }
 637          Clcharge->Draw();
 638
 639          c3->cd(2);
 640          padnumber->SetFillColor(5);
 641          padnumber->SetXTitle("(counts)");
 642          padnumber->Draw();
 643
 644          c3->cd(3);
 645          clusev->SetFillColor(5);
 646          clusev->SetXTitle("(counts)");
 647          if (evNumber2>10)
 648            {
 649              clusev->Fit("gaus");
 650              gaus->SetLineColor(2);
 651              gaus->SetLineWidth(3);
 652            }
 653          clusev->Draw();
 654
 655          c3->cd(4);
 656          padsmip->SetFillColor(5);
 657          padsmip->SetXTitle("(counts)");
 658          padsmip->Draw();
 659        }
 660
 661        if (nev<1)
 662          {
 663            TCanvas *c11 = new TCanvas("c11","Cherenkov per Mip",400,10,600,700);
 664            mother->SetFillColor(5);
 665            mother->SetXTitle("counts");
 666            mother->Draw();
 667          }
 668
 669        TCanvas *c7 = new TCanvas("c7","Production Statistics",100,100,600,700);
 670        c7->Divide(2,2);
 671        //c7->SetFillColor(42);
 672
 673        c7->cd(1);
 674        totalphotonsevent->SetFillColor(5);
 675        totalphotonsevent->SetXTitle("Photons (counts)");
 676        if (evNumber2>10)
 677            {
 678              totalphotonsevent->Fit("gaus");
 679              gaus->SetLineColor(2);
 680              gaus->SetLineWidth(3);
 681            }
 682        totalphotonsevent->Draw();
 683
 684        c7->cd(2);
 685        photev->SetFillColor(5);
 686        photev->SetXTitle("(counts)");
 687        if (evNumber2>10)
 688          {
 689            photev->Fit("gaus");
 690            gaus->SetLineColor(2);
 691            gaus->SetLineWidth(3);
 692          }
 693        photev->Draw();
 694
 695        c7->cd(3);
 696        feedev->SetFillColor(5);
 697        feedev->SetXTitle("(counts)");
 698        if (evNumber2>10)
 699          {
 700            feedev->Fit("gaus");
 701            gaus->SetLineColor(2);
 702            gaus->SetLineWidth(3);
 703          }
 704        feedev->Draw();
 705
 706        c7->cd(4);
 707        padsev->SetFillColor(5);
 708        padsev->SetXTitle("(counts)");
 709        if (evNumber2>10)
 710          {
 711            padsev->Fit("gaus");
 712            gaus->SetLineColor(2);
 713            gaus->SetLineWidth(3);
 714          }
 715        padsev->Draw();
 716
 717        break;
 718
 719      case 4:
 720
 721        TCanvas *c2 = new TCanvas("c2","Angles of incidence",50,50,600,700);
 722        c2->Divide(2,2);
 723        //c2->SetFillColor(42);
 724
 725        c2->cd(1);
 726        hitsPhi->SetFillColor(5);
 727        hitsPhi->Draw();
 728        c2->cd(2);
 729        hitsTheta->SetFillColor(5);
 730        hitsTheta->Draw();
 731        c2->cd(3);
 732        Phi->SetFillColor(5);
 733        Phi->Draw();
 734        c2->cd(4);
 735        Theta->SetFillColor(5);
 736        Theta->Draw();
 737
 738
 739        TCanvas *c5 = new TCanvas("c5","Ring Reconstruction",100,100,900,700);
 740        c5->Divide(3,3);
 741        //c5->SetFillColor(42);
 742
 743        c5->cd(1);
 744        ckovangle->SetFillColor(5);
 745        ckovangle->SetXTitle("angle (radians)");
 746        ckovangle->Draw();
 747
 748        c5->cd(2);
 749        radius->SetFillColor(5);
 750        radius->SetXTitle("radius (cm)");
 751        radius->Draw();
 752
 753        c5->cd(3);
 754        hc0->SetXTitle("pads");
 755        hc0->Draw("box");
 756
 757        c5->cd(5);
 758        Omega1D->SetFillColor(5);
 759        Omega1D->SetXTitle("angle (radians)");
 760        Omega1D->Draw();
 761
 762        c5->cd(4);
 763        PhotonCer->SetFillColor(5);
 764        PhotonCer->SetXTitle("angle (radians)");
 765        PhotonCer->Draw();
 766
 767        c5->cd(6);
 768        PadsUsed->SetXTitle("pads");
 769        PadsUsed->Draw("box");
 770
 771        c5->cd(7);
 772        Omega3D->SetFillColor(5);
 773        Omega3D->SetXTitle("angle (radians)");
 774        Omega3D->Draw();
 775
 776        break;
 777
 778      case 5:
 779
 780        printf("Drawing histograms.../n");
 781
 782        //if (ndigits)
 783          //{
 784        TCanvas *c1 = new TCanvas("c1","Alice RICH digits",50,50,1200,700);
 785        c1->Divide(4,2);
 786        //c1->SetFillColor(42);
 787
 788        c1->cd(1);
 789        hc1->SetXTitle("ix (npads)");
 790        hc1->Draw("box");
 791        c1->cd(2);
 792        hc2->SetXTitle("ix (npads)");
 793        hc2->Draw("box");
 794        c1->cd(3);
 795        hc3->SetXTitle("ix (npads)");
 796        hc3->Draw("box");
 797        c1->cd(4);
 798        hc4->SetXTitle("ix (npads)");
 799        hc4->Draw("box");
 800        c1->cd(5);
 801        hc5->SetXTitle("ix (npads)");
 802        hc5->Draw("box");
 803        c1->cd(6);
 804        hc6->SetXTitle("ix (npads)");
 805        hc6->Draw("box");
 806        c1->cd(7);
 807        hc7->SetXTitle("ix (npads)");
 808        hc7->Draw("box");
 809        c1->cd(8);
 810        hc0->SetXTitle("ix (npads)");
 811        hc0->Draw("box");
 812          //}
 813 //
 814        TCanvas *c4 = new TCanvas("c4","Hits per type",100,100,600,700);
 815        c4->Divide(2,2);
 816        //c4->SetFillColor(42);
 817
 818        c4->cd(1);
 819        feedback->SetXTitle("x (cm)");
 820        feedback->SetYTitle("y (cm)");
 821        feedback->Draw();
 822
 823        c4->cd(2);
 824        //mip->SetFillColor(5);
 825        mip->SetXTitle("x (cm)");
 826        mip->SetYTitle("y (cm)");
 827        mip->Draw();
 828
 829        c4->cd(3);
 830        //cerenkov->SetFillColor(5);
 831        cerenkov->SetXTitle("x (cm)");
 832        cerenkov->SetYTitle("y (cm)");
 833        cerenkov->Draw();
 834
 835        c4->cd(4);
 836        //h->SetFillColor(5);
 837        h->SetXTitle("x (cm)");
 838        h->SetYTitle("y (cm)");
 839        h->Draw();
 840
 841        TCanvas *c10 = new TCanvas("c10","Hits distribution",150,150,600,350);
 842        c10->Divide(2,1);
 843        //c10->SetFillColor(42);
 844
 845        c10->cd(1);
 846        hitsX->SetFillColor(5);
 847        hitsX->SetXTitle("(cm)");
 848        hitsX->Draw();
 849
 850        c10->cd(2);
 851        hitsY->SetFillColor(5);
 852        hitsY->SetXTitle("(cm)");
 853        hitsY->Draw();
 854
 855        break;
 856
 857      }
 858
 859
 860    // calculate the number of pads which give a signal
 861
 862
 863    Int_t Np=0;
 864    //for (Int_t i=0;i< NpadX;i++) {
 865        //for (Int_t j=0;j< NpadY;j++) {
 866            //if (Pad[i][j]>=6){
 867                //Np+=1;
 868            //}
 869        //}
 870    //}
 871    //printf("The total number of pads which give a signal: %d %d\n",Nh,Nh1);
 872    printf("\nEnd of macro\n");
 873    printf("**********************************\n");*/
 874 }
 875
 876