ZDC/AliZDCQAChecker.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 // --- ROOT system ---
  18 #include <TH1F.h>
  19 #include <TIterator.h>
  20 #include <TString.h>
  21
  22 // --- Standard library ---
  23
  24 // --- AliRoot header files ---
  25 #include "AliLog.h"
  26 #include "AliZDCQAChecker.h"
  27
  28 ClassImp(AliZDCQAChecker)
  29
  30 //____________________________________________________________________________
  31 Double_t AliZDCQAChecker::Check(AliQA::ALITASK_t index, TObjArray * list)
  32 {
  33  // Checks the QA histograms on the input list:
  34  //
  35  Double_t test=0.;
  36  Int_t ntests=0;
  37  const char* taskName = AliQA::GetAliTaskName(index);
  38  //
  39  Int_t beamType=0; // 0 -> protons, 1 -> ions
  40
  41  // ====================================================================
  42  //     Checks for p-p events
  43  // ====================================================================
  44  if (beamType==0){
  45    // -------------------------------------------------------------------
  46   if(index == AliQA::kSIM){
  47
  48     if(list->GetEntries()==0){
  49       AliWarning("\tAliZDCQAChecker->The list to be checked is empty!");
  50       test = 1.; // nothing to check
  51       return test;
  52     }
  53     //printf("\n\tAliZDCQAChecker-> checking QA histograms for task %s\n\n",taskName);
  54
  55     TIter next(list);
  56     TH1 * hdata;
  57     //
  58     ntests = 0;
  59     //
  60     while((hdata = dynamic_cast<TH1 *>(next()))){
  61       if(hdata){
  62         //printf("\tAliZDCQAChecker-> checking histo %s",hdata->GetName());
  63         // Check DIGITS histos
  64         if(!(strncmp(hdata->GetName(),"hDig",4))){
  65           if(hdata->GetEntries()>0){
  66             test += 1.; ntests++;
  67           }
  68         }
  69         // Check HITS histos
  70         else{
  71           if(hdata->GetEntries()>0){
  72             test += 1.; ntests++;
  73           }
  74
  75         }
  76       }
  77       else{
  78         AliError("AliZDCQAChecker-> No histos!!!\n");
  79       }
  80     }
  81     if(ntests!=0) test = test/ntests;
  82     //printf("\n\tAliZDCQAChecker-> QA check result = %1.2f\n",test);
  83   }
  84
  85   // -------------------------------------------------------------------
  86   else if(index == AliQA::kRAW){
  87
  88     if(list->GetEntries()==0){
  89       AliWarning("\tAliZDCQAChecker->The list to be checked is empty!");
  90       test = 1.; // nothing to check
  91       return test;
  92     }
  93     printf("\n\tAliZDCQAChecker-> checking QA histograms for task %s\n\n",taskName);
  94
  95     TIter next(list);
  96     TH1 * hdata;
  97     ntests = 0;
  98     //
  99     while((hdata = dynamic_cast<TH1 *>(next()))){
 100       if(hdata){
 101         if(hdata->GetEntries()!=0){
 102           if(hdata->GetMean()>10.) test += 1.;
 103           else test = 0.5;
 104           ntests++;
 105         }
 106       }
 107       //
 108       //printf("\t %d performed tests, results %1.2f\n",ntests,test/ntests);
 109       else{
 110         AliError("\t AliZDCQAChecker->No histos!!!\n");
 111       }
 112     }
 113     if(ntests!=0) test = test/ntests;
 114     //printf("\n\tAliZDCQAChecker-> QA check result = %1.2f\n",test);
 115   }
 116
 117   // -------------------------------------------------------------------
 118   else if(index == AliQA::kESD){
 119
 120     if(list->GetEntries()==0){
 121       AliWarning("\tAliZDCQAChecker->The list to be checked is empty!");
 122       test = 1.; // nothing to check
 123       return test;
 124     }
 125     printf("\n\tAliZDCQAChecker-> checking QA histograms for task %s\n\n",taskName);
 126
 127     TIter next(list);
 128     TH1 * hdata;
 129     Int_t    esdInd=0;
 130     //
 131     ntests = 0;
 132     //
 133     while((hdata = dynamic_cast<TH1 *>(next()))){
 134       if(hdata){
 135          if(hdata->GetEntries()!=0){
 136            if(esdInd>1){
 137              if(hdata->GetMean()>10.) test += 1.;
 138              else test = 0.5;
 139              ntests++;
 140            }
 141          }
 142          //
 143          esdInd++;
 144       }
 145       else{
 146         AliError("AliZDCQAChecker-> No histos!!!\n");
 147       }
 148     }
 149     if(ntests!=0) test = test/ntests;
 150     //printf("\n\tAliZDCQAChecker-> QA check result = %1.2f\n\n",test);
 151   }
 152   else{
 153     AliWarning(Form("\n\t No ZDC QA for %s task\n",taskName));
 154     return 1.;
 155   }
 156  }
 157  // ====================================================================
 158  //     Checks for A-A events
 159  // ====================================================================
 160  else if (beamType==1){
 161   // -------------------------------------------------------------------
 162   if(index == AliQA::kSIM){
 163
 164     if(list->GetEntries()==0){
 165       AliWarning("\tAliZDCQAChecker->The list to be checked is empty!");
 166       test = 1.; // nothing to check
 167       return test;
 168     }
 169     //printf("\n\tAliZDCQAChecker-> checking QA histograms for task %s\n\n",taskName);
 170
 171     TIter next(list);
 172     TH1 * hdata;
 173     Double_t meanX=0., meanY=0.;
 174     Double_t meanZNA=0., rmsZNA=0., meanZNC=0.;
 175     Double_t meanZPA=0., rmsZPA=0., meanZPC=0.;
 176     Double_t pmCZNA=0., pmCZNC=0., pmCZPA=0., pmCZPC=0.;
 177     Double_t pmQZNA=0., pmQZNC=0., pmQZPA=0., pmQZPC=0.;
 178     Float_t  res=0.;
 179     Int_t    digInd=0, testgood=0;
 180     //
 181     ntests = 0;
 182     //
 183     while((hdata = dynamic_cast<TH1 *>(next()))){
 184       if(hdata){
 185         //printf("\tAliZDCQAChecker-> checking histo %s",hdata->GetName());
 186         // Check DIGITS histos
 187         if (!(strncmp(hdata->GetName(),"hDig",4))){
 188           // [1] check response of ZNC vs. ZNA
 189           if(digInd==0 || digInd==1){
 190              if(digInd==0){
 191                if(hdata->GetEntries() != 0.){
 192                  testgood=1;
 193                  meanZNA = hdata->GetMean();
 194                  rmsZNA = hdata->GetRMS();
 195                }
 196              }
 197              else{
 198                if(hdata->GetEntries() != 0.){
 199                  testgood=1;
 200                  meanZNC = hdata->GetMean();
 201                }
 202                else testgood=0;
 203                // check if the response m.v. of ZNA and ZNC are equal (@ 1sigma level)
 204                if(testgood==1){
 205                  if(TMath::Abs(meanZNA-meanZNC)<rmsZNA) res=1.;
 206                  else res=.5;
 207                  testgood=0;
 208                  test += res;
 209                  ntests++;
 210                  //
 211                  //printf("\t %d performed tests, results %1.2f\n",ntests,test/ntests);
 212                }
 213                else res=0.;
 214              }
 215           }
 216           // [2] check response of ZPC vs. ZPA
 217           else if(digInd==2 || digInd==3){
 218              if(digInd==2){
 219                if(hdata->GetEntries() != 0.){
 220                  testgood=1;
 221                  meanZPA = hdata->GetMean();
 222                  rmsZPA = hdata->GetRMS();
 223                }
 224              }
 225              else{
 226                if(hdata->GetEntries() != 0.){
 227                  testgood=1;
 228                  meanZPC = hdata->GetMean();
 229                }
 230                // check if the response m.v. of ZPA and ZPC are equal (@ 3sigma level)
 231                if(testgood==1){
 232                  if(TMath::Abs(meanZPA-meanZPC)<(3.*rmsZPA)) res=1.;
 233                  else res=.5;
 234                  test += res;
 235                  ntests++;
 236                  testgood=0;
 237                  //
 238                  //printf("\t %d performed tests, results %1.2f\n",ntests,test/ntests);
 239                }
 240                else res=0.;
 241              }
 242           }
 243           // [2] check PMC responses vs. summed PMQ responses
 244           else if(digInd>3 && digInd<12){
 245             if(digInd==4) pmQZNC = hdata->GetMean();
 246             else if(digInd==5) pmQZNA = hdata->GetMean();
 247             else if(digInd==6) pmQZPC = hdata->GetMean();
 248             else if(digInd==7) pmQZPA = hdata->GetMean();
 249             else if(digInd==8){
 250               pmCZNC = hdata->GetMean();
 251               if(TMath::Abs(pmQZNC-pmCZNC)<(0.1*(pmQZNC+pmCZNC)/2)) res=1.;
 252               else res=0.5;
 253               test += res;
 254               ntests++;
 255               //
 256               //printf("\t %d performed tests, results %1.2f\n",ntests,test/ntests);
 257             }
 258             else if(digInd==9){
 259               pmCZNA = hdata->GetMean();
 260               if(TMath::Abs(pmQZNA-pmCZNA)<(0.1*(pmQZNA+pmCZNA)/2)) res=1.;
 261               else res=0.5;
 262               test += res;
 263               ntests++;
 264               //
 265               //printf("\t %d performed tests, results %1.2f\n",ntests,test/ntests);
 266             }
 267             else if(digInd==10){
 268               pmCZPC = hdata->GetMean();
 269               if(TMath::Abs(pmQZPC-pmCZPC)<(0.1*(pmQZPC+pmCZPC)/2)) res=1.;
 270               else res=0.5;
 271               test += res;
 272               ntests++;
 273               //
 274               //printf("\t %d performed tests, results %1.2f\n",ntests,test/ntests);
 275             }
 276             else if(digInd==11){
 277               pmCZPA = hdata->GetMean();
 278               if(TMath::Abs(pmQZPA-pmCZPA)<(0.1*(pmQZPA+pmCZPA)/2)) res=1.;
 279               else res=0.5;
 280               test += res;
 281               ntests++;
 282               //
 283               //printf("\t %d performed tests, results %1.2f\n",ntests,test/ntests);
 284             }
 285           }
 286           //
 287           digInd++;
 288         }
 289         // Check HITS histos
 290         else{
 291           // hits histos
 292           meanX = hdata->GetMean(1);
 293           meanY = hdata->GetMean(2);
 294           // check if the spot is centered
 295           if((TMath::Abs(meanX)<0.2) && (TMath::Abs(meanY)<0.2)) res=1.;
 296           else res=0.5;
 297           test += res;
 298           ntests++;
 299           //
 300           //printf("\t %d performed tests, results %1.2f\n",ntests,test/ntests);
 301         }
 302       }
 303       else{
 304         AliError("AliZDCQAChecker-> No histos!!!\n");
 305       }
 306     }
 307     if(ntests!=0) test = test/ntests;
 308     printf("\n\tAliZDCQAChecker-> QA check result = %1.2f\n",test);
 309   }
 310
 311   // -------------------------------------------------------------------
 312   else if(index == AliQA::kRAW){
 313
 314     if(list->GetEntries()==0){
 315       AliWarning("\tAliZDCQAChecker->The list to be checked is empty!");
 316       test = 1.; // nothing to check
 317       return test;
 318     }
 319     printf("\n\tAliZDCQAChecker-> checking QA histograms for task %s\n\n",taskName);
 320
 321     TIter next(list);
 322     TH1 * hdata;
 323     Double_t meanZNA=0., rmsZNA=0., meanZNC=0.;
 324     Double_t meanZPA=0., rmsZPA=0., meanZPC=0.;
 325     Double_t pmCZNA=0., pmCZNC=0., pmCZPA=0., pmCZPC=0.;
 326     Double_t pmQZNA=0., pmQZNC=0., pmQZPA=0., pmQZPC=0.;
 327     Float_t  res=0.;
 328     Int_t    rawInd=0, testgood=0;
 329     ntests = 0;
 330     //
 331     while((hdata = dynamic_cast<TH1 *>(next()))){
 332       if(hdata){
 333           // [1] check response of ZNC vs. ZNA
 334           if(rawInd==0 || rawInd==1){
 335              if(rawInd==0){
 336                if(hdata->GetEntries() != 0.){
 337                  testgood=1;
 338                  meanZNA = hdata->GetMean();
 339                  rmsZNA = hdata->GetRMS();
 340                }
 341              }
 342              else{
 343                if(hdata->GetEntries() != 0.){
 344                  testgood=1;
 345                  meanZNC = hdata->GetMean();
 346                }
 347                else testgood=0;
 348                // check if the response m.v. of ZNA and ZNC are equal (@ 1sigma level)
 349                if(testgood==1){
 350                  if(TMath::Abs(meanZNA-meanZNC)<rmsZNA) res=1.;
 351                  else res=.5;
 352                  test += res;
 353                  ntests++;
 354                  testgood=0;
 355                }
 356                else res=0.;
 357              }
 358           }
 359           // [2] check response of ZPC vs. ZPA
 360           else if(rawInd==2 || rawInd==3){
 361              if(rawInd==2){
 362                if(hdata->GetEntries() != 0.){
 363                  testgood=1;
 364                  meanZPA = hdata->GetMean();
 365                  rmsZPA = hdata->GetRMS();
 366                }
 367              }
 368              else{
 369                if(hdata->GetEntries() != 0.){
 370                  testgood=1;
 371                  meanZPC = hdata->GetMean();
 372                }
 373                // check if the response m.v. of ZPA and ZPC are equal (@ 3sigma level)
 374                if(testgood==1){
 375                  if(TMath::Abs(meanZPA-meanZPC)<(3.*rmsZPA)) res=1.;
 376                  else res=.5;
 377                  test += res;
 378                  ntests++;
 379                  testgood=0;
 380                }
 381                else res=0.;
 382              }
 383           }
 384           // [2] check PMC responses vs. summed PMQ responses
 385           else if(rawInd>3 && rawInd<12){
 386             if(rawInd==4) pmQZNC = hdata->GetMean();
 387             else if(rawInd==5) pmQZNA = hdata->GetMean();
 388             else if(rawInd==6) pmQZPC = hdata->GetMean();
 389             else if(rawInd==7) pmQZPA = hdata->GetMean();
 390             else if(rawInd==8){
 391               pmCZNC = hdata->GetMean();
 392               if(TMath::Abs(pmQZNC-pmCZNC)<(0.1*(pmQZNC+pmCZNC)/2)) res=1.;
 393               else res=0.5;
 394               test += res;
 395               ntests++;
 396             }
 397             else if(rawInd==9){
 398               pmCZNA = hdata->GetMean();
 399               if(TMath::Abs(pmQZNA-pmCZNA)<(0.1*(pmQZNA+pmCZNA)/2)) res=1.;
 400               else res=0.5;
 401               test += res;
 402               ntests++;
 403             }
 404             else if(rawInd==10){
 405               pmCZPC = hdata->GetMean();
 406               if(TMath::Abs(pmQZPC-pmCZPC)<(0.1*(pmQZPC+pmCZPC)/2)) res=1.;
 407               else res=0.5;
 408               test += res;
 409               ntests++;
 410             }
 411             else if(rawInd==11){
 412               pmCZPA = hdata->GetMean();
 413               if(TMath::Abs(pmQZPA-pmCZPA)<(0.1*(pmQZPA+pmCZPA)/2)) res=1.;
 414               else res=0.5;
 415               test += res;
 416               ntests++;
 417             }
 418           }
 419           //
 420           rawInd++;
 421       }
 422       //
 423       //printf("\t %d performed tests, results %1.2f\n",ntests,test/ntests);
 424       else{
 425         AliError("\t AliZDCQAChecker->No histos!!!\n");
 426       }
 427     }
 428     if(ntests!=0) test = test/ntests;
 429     printf("\n\tAliZDCQAChecker-> QA check result = %1.2f\n",test);
 430   }
 431
 432   // -------------------------------------------------------------------
 433   else if(index == AliQA::kESD){
 434
 435     if(list->GetEntries()==0){
 436       AliWarning("\tAliZDCQAChecker->The list to be checked is empty!");
 437       test = 1.; // nothing to check
 438       return test;
 439     }
 440     printf("\n\tAliZDCQAChecker-> checking QA histograms for task %s\n\n",taskName);
 441
 442     TIter next(list);
 443     TH1 * hdata;
 444     Double_t meanX=0., meanY=0.;
 445     Double_t meanZNA=0., rmsZNA=0., meanZNC=0.;
 446     Double_t meanZPA=0., rmsZPA=0., meanZPC=0.;
 447     Double_t eneCZNA=0., eneCZNC=0., eneCZPA=0., eneCZPC=0.;
 448     Double_t eneQZNA=0., eneQZNC=0., eneQZPA=0., eneQZPC=0.;
 449     Float_t  res=0.;
 450     Int_t    esdInd=0, testgood=0;
 451     //
 452     ntests = 0;
 453     //
 454     while((hdata = dynamic_cast<TH1 *>(next()))){
 455       if(hdata){
 456         //printf("\tAliZDCQAChecker-> checking histo %s",hdata->GetName());
 457         if(esdInd<2){
 458           // hits histos
 459           meanX = hdata->GetMean(1);
 460           meanY = hdata->GetMean(2);
 461           // check if the spot is centered
 462           if((TMath::Abs(meanX)<0.2) && (TMath::Abs(meanY)<0.2)) res=1.;
 463           else res=0.5;
 464           test += res;
 465           ntests++;
 466         }
 467         //
 468         else{
 469           // [1] check response of ZNC vs. ZNA
 470           if(esdInd==0 || esdInd==1){
 471              if(esdInd==0){
 472                if(hdata->GetEntries() != 0.){
 473                  testgood=1;
 474                  meanZNA = hdata->GetMean();
 475                  rmsZNA = hdata->GetRMS();
 476                }
 477              }
 478              else{
 479                if(hdata->GetEntries() != 0.){
 480                  testgood=1;
 481                  meanZNC = hdata->GetMean();
 482                }
 483                else testgood=0;
 484                // check if the response m.v. of ZNA and ZNC are equal (@ 1sigma level)
 485                if(testgood==1){
 486                  if(TMath::Abs(meanZNA-meanZNC)<rmsZNA) res=1.;
 487                  else res=.5;
 488                  testgood=0;
 489                  test += res;
 490                  ntests++;
 491                }
 492                else res=0.;
 493              }
 494           }
 495           // [2] check response of ZPC vs. ZPA
 496           else if(esdInd==2 || esdInd==3){
 497              if(esdInd==2){
 498                if(hdata->GetEntries() != 0.){
 499                  testgood=1;
 500                  meanZPA = hdata->GetMean();
 501                  rmsZPA = hdata->GetRMS();
 502                }
 503              }
 504              else{
 505                if(hdata->GetEntries() != 0.){
 506                  testgood=1;
 507                  meanZPC = hdata->GetMean();
 508                }
 509                // check if the response m.v. of ZPA and ZPC are equal (@ 3sigma level)
 510                if(testgood==1){
 511                  if(TMath::Abs(meanZPA-meanZPC)<(3.*rmsZPA)) res=1.;
 512                  else res=.5;
 513                  test += res;
 514                  ntests++;
 515                  testgood=0;
 516                }
 517                else res=0.;
 518              }
 519           }
 520           // [2] check eneC responses vs. summed eneQ responses
 521           else if(esdInd>3 && esdInd<12){
 522             if(esdInd==4) eneQZNC = hdata->GetMean();
 523             else if(esdInd==5) eneQZNA = hdata->GetMean();
 524             else if(esdInd==6) eneQZPC = hdata->GetMean();
 525             else if(esdInd==7) eneQZPA = hdata->GetMean();
 526             else if(esdInd==8){
 527               eneCZNC = hdata->GetMean();
 528               if(TMath::Abs(eneQZNC-eneCZNC)<(0.1*(eneQZNC+eneCZNC)/2)) res=1.;
 529               else res=0.5;
 530               test += res;
 531               ntests++;
 532             }
 533             else if(esdInd==9){
 534               eneCZNA = hdata->GetMean();
 535               if(TMath::Abs(eneQZNA-eneCZNA)<(0.1*(eneQZNA+eneCZNA)/2)) res=1.;
 536               else res=0.5;
 537               test += res;
 538               ntests++;
 539             }
 540             else if(esdInd==10){
 541               eneCZPC = hdata->GetMean();
 542               if(TMath::Abs(eneQZPC-eneCZPC)<(0.1*(eneQZPC+eneCZPC)/2)) res=1.;
 543               else res=0.5;
 544               test += res;
 545               ntests++;
 546             }
 547             else if(esdInd==11){
 548               eneCZPA = hdata->GetMean();
 549               if(TMath::Abs(eneQZPA-eneCZPA)<(0.1*(eneQZPA+eneCZPA)/2)) res=1.;
 550               else res=0.5;
 551               test += res;
 552               ntests++;
 553             }
 554           }
 555           //
 556           esdInd++;
 557         }
 558         //
 559         //printf("\t %d performed tests, results %1.2f\n",ntests,test/ntests);
 560       }
 561       else{
 562         AliError("AliZDCQAChecker-> No histos!!!\n");
 563       }
 564     }
 565     if(ntests!=0) test = test/ntests;
 566     printf("\n\tAliZDCQAChecker-> QA check result = %1.2f\n\n",test);
 567   }
 568   else{
 569     AliWarning(Form("\n\t No ZDC QA for %s task\n",taskName));
 570     return 1.;
 571   }
 572  }
 573
 574  AliInfo(Form("Test Result = %f", test));
 575  return test;
 576 }