PWGLF/SPECTRA/PiKaPr/TestAOD/AliSpectraAODEventCuts.cxx

   1
   2 /**************************************************************************
   3  * Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
   4  *                                                                        *
   5  * Author: The ALICE Off-line Project.                                    *
   6  * Contributors are mentioned in the code where appropriate.              *
   7  *                                                                        *
   8  * Permission to use, copy, modify and distribute this software and its   *
   9  * documentation strictly for non-commercial purposes is hereby granted   *
  10  * without fee, provided that the above copyright notice appears in all   *
  11  * copies and that both the copyright notice and this permission notice   *
  12  * appear in the supporting documentation. The authors make no claims     *
  13  * about the suitability of this software for any purpose. It is          *
  14  * provided "as is" without express or implied warranty.                  *
  15  **************************************************************************/
  16
  17 //-----------------------------------------------------------------
  18 //         AliSpectraAODEventCuts class
  19 //-----------------------------------------------------------------
  20
  21 #include "TChain.h"
  22 #include "TTree.h"
  23 #include "TLegend.h"
  24 #include "TH1F.h"
  25 #include "TH1I.h"
  26 #include "TH2F.h"
  27 #include "TCanvas.h"
  28 #include "TProfile.h"
  29 #include "AliAnalysisTask.h"
  30 #include "AliAnalysisManager.h"
  31 #include "AliAODTrack.h"
  32 #include "AliAODMCParticle.h"
  33 #include "AliAODEvent.h"
  34 #include "AliAODInputHandler.h"
  35 #include "AliAnalysisTaskESDfilter.h"
  36 #include "AliAnalysisDataContainer.h"
  37 #include "AliESDVZERO.h"
  38 #include "AliAODVZERO.h"
  39 #include "AliSpectraAODEventCuts.h"
  40 #include "AliSpectraAODTrackCuts.h"
  41 #include <iostream>
  42
  43 using namespace std;
  44
  45 ClassImp(AliSpectraAODEventCuts)
  46
  47 AliSpectraAODEventCuts::AliSpectraAODEventCuts(const char *name) :
  48   TNamed(name, "AOD Event Cuts"),
  49   fAOD(0),
  50   fSelectBit(AliVEvent::kMB),
  51   fCentralityMethod("V0M"),
  52   fTrackBits(1),
  53   fIsMC(0),
  54   fIsLHC10h(1),
  55   fTrackCuts(0),
  56   fIsSelected(0),
  57   fCentralityCutMin(0.),
  58   fCentralityCutMax(999),
  59   fQVectorCutMin(-999.),
  60   fQVectorCutMax(999.),
  61   fVertexCutMin(-10.),
  62   fVertexCutMax(10.),
  63   fMultiplicityCutMin(-999.),
  64   fMultiplicityCutMax(99999.),
  65   fqV0C(-999.),
  66   fqV0A(-999.),
  67   fPsiV0C(-999.),
  68   fPsiV0A(-999.),
  69   fCent(-999.),
  70   fOutput(0),
  71   fCalib(0),
  72   fRun(-1),
  73   fMultV0(0),
  74   fV0Cpol1(-1),
  75   fV0Cpol2(-1),
  76   fV0Cpol3(-1),
  77   fV0Cpol4(-1),
  78   fV0Apol1(-1),
  79   fV0Apol2(-1),
  80   fV0Apol3(-1),
  81   fV0Apol4(-1)
  82 {
  83   // Constructor
  84   fOutput=new TList();
  85   fOutput->SetOwner();
  86   fOutput->SetName("fOutput");
  87
  88   fCalib=new TList();
  89   fCalib->SetOwner();
  90   fCalib->SetName("fCalib");
  91
  92   TH1I *fHistoCuts = new TH1I("fHistoCuts", "Event Cuts", kNVtxCuts, -0.5, kNVtxCuts - 0.5);
  93   TH1F *fHistoVtxBefSel = new TH1F("fHistoVtxBefSel", "Vtx distr before event selection;z (cm)",500,-15,15);
  94   TH1F *fHistoVtxAftSel = new TH1F("fHistoVtxAftSel", "Vtx distr after event selection;z (cm)",500,-15,15);
  95   TH1F *fHistoEtaBefSel = new TH1F("fHistoEtaBefSel", "Eta distr before event selection;eta",500,-2,2);
  96   TH1F *fHistoEtaAftSel = new TH1F("fHistoEtaAftSel", "Eta distr after event selection;eta",500,-2,2);
  97   TH1F *fHistoNChAftSel = new TH1F("fHistoNChAftSel", "NCh distr after event selection;Nch",2000,-0.5,1999.5);
  98   TH2F *fHistoQVector = new TH2F("fHistoQVector", "QVector with VZERO distribution;centrality;Q vector from EP task",20,0,100,100,0,10);
  99   TH2F *fHistoEP = new TH2F("fHistoEP", "EP with VZERO distribution;centrality;Psi_{EP} from EP task",20,0,100,100,-2,2);
 100   TH2F *fPsiACor = new TH2F("fPsiACor", "EP with VZERO A distribution;centrality;Psi_{EP} VZERO-A",20,0,100,100,-2,2);
 101   TH2F *fPsiCCor = new TH2F("fPsiCCor", "EP with VZERO C distribution;centrality;Psi_{EP} VZERO-C",20,0,100,100,-2,2);
 102   TH2F *fQVecACor = new TH2F("fQVecACor", "QVec VZERO A;centrality;Qvector VZERO-A",20,0,100,100,0,10);
 103   TH2F *fQVecCCor = new TH2F("fQVecCCor", "QVec VZERO C;centrality;Qvector VZERO-C",20,0,100,100,0,10);
 104   TH2F *fV0M = new TH2F("fV0M", "V0 Multiplicity, before correction;V0 sector",64,-.5,63.5,500,0,1000);
 105   TH2F *fV0MCor = new TH2F("fV0MCor", "V0 Multiplicity, after correction;V0 sector",64,-.5,63.5,500,0,1000);
 106
 107   fOutput->Add(fHistoCuts);
 108   fOutput->Add(fHistoVtxBefSel);
 109   fOutput->Add(fHistoVtxAftSel);
 110   fOutput->Add(fHistoEtaBefSel);
 111   fOutput->Add(fHistoEtaAftSel);
 112   fOutput->Add(fHistoNChAftSel);
 113   fOutput->Add(fHistoQVector);
 114   fOutput->Add(fHistoEP);
 115   fOutput->Add(fPsiACor);
 116   fOutput->Add(fPsiCCor);
 117   fOutput->Add(fQVecACor);
 118   fOutput->Add(fQVecCCor);
 119   fOutput->Add(fV0M);
 120   fOutput->Add(fV0MCor);
 121
 122   for (Int_t i = 0; i<10; i++){
 123     fMeanQxa2[i] = -1;
 124     fMeanQya2[i] = -1;
 125     fMeanQxc2[i] = -1;
 126     fMeanQyc2[i] = -1;
 127   }
 128 }
 129
 130 //______________________________________________________
 131 Bool_t AliSpectraAODEventCuts::IsSelected(AliAODEvent * aod,AliSpectraAODTrackCuts     *trackcuts)
 132 {
 133   // Returns true if Event Cuts are selected and applied
 134   fAOD = aod;
 135   fTrackCuts = trackcuts;
 136   ((TH1I*)fOutput->FindObject("fHistoCuts"))->Fill(kProcessedEvents);
 137   Bool_t IsPhysSel = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & fSelectBit);
 138   if(!IsPhysSel)return IsPhysSel;
 139   ((TH1I*)fOutput->FindObject("fHistoCuts"))->Fill(kPhysSelEvents);
 140   //loop on tracks, before event selection, filling QA histos
 141   AliAODVertex * vertex = fAOD->GetPrimaryVertex();//FIXME vertex is recreated
 142   if(vertex)((TH1F*)fOutput->FindObject("fHistoVtxBefSel"))->Fill(vertex->GetZ());
 143   fIsSelected =kFALSE;
 144   if(CheckVtxRange() && CheckCentralityCut() && CheckMultiplicityCut()){ //selection on vertex and Centrality
 145     fIsSelected=CheckQVectorCut(); // QVector is calculated only if the centrality and vertex are correct (performance)
 146   }
 147   if(fIsSelected){
 148     ((TH1I*)fOutput->FindObject("fHistoCuts"))->Fill(kAcceptedEvents);
 149     if(vertex)((TH1F*)fOutput->FindObject("fHistoVtxAftSel"))->Fill(vertex->GetZ());
 150   }
 151   Int_t Nch=0;
 152   for (Int_t iTracks = 0; iTracks < fAOD->GetNumberOfTracks(); iTracks++) {
 153     AliAODTrack* track = fAOD->GetTrack(iTracks);
 154     if (!fTrackCuts->IsSelected(track,kFALSE)) continue;
 155     ((TH1F*)fOutput->FindObject("fHistoEtaBefSel"))->Fill(track->Eta());
 156     if(fIsSelected){
 157       ((TH1F*)fOutput->FindObject("fHistoEtaAftSel"))->Fill(track->Eta());
 158       Nch++;
 159     }
 160   }
 161   if(fIsSelected)((TH1F*)fOutput->FindObject("fHistoNChAftSel"))->Fill(Nch);
 162   return fIsSelected;
 163 }
 164
 165 //______________________________________________________
 166 Bool_t AliSpectraAODEventCuts::CheckVtxRange()
 167 {
 168   // reject events outside of range
 169   AliAODVertex * vertex = fAOD->GetPrimaryVertex();
 170   //when moving to 2011 wìone has to add a cut using SPD vertex.
 171   //The point is that for events with |z|>20 the vertexer tracks is not working (only 2011!). One has to put a safety cut using SPD vertex large e.g. 15cm
 172   if (!vertex)
 173     {
 174       ((TH1I*)fOutput->FindObject("fHistoCuts"))->Fill(kVtxNoEvent);
 175       return kFALSE;
 176     }
 177   if (vertex->GetZ() > fVertexCutMin && vertex->GetZ() < fVertexCutMax)
 178     {
 179       return kTRUE;
 180     }
 181   ((TH1I*)fOutput->FindObject("fHistoCuts"))->Fill(kVtxRange);
 182   return kFALSE;
 183 }
 184
 185 //______________________________________________________
 186 Bool_t AliSpectraAODEventCuts::CheckCentralityCut()
 187 {
 188   // Check centrality cut
 189   fCent=-999.;
 190   fCent=fAOD->GetCentrality()->GetCentralityPercentile(fCentralityMethod.Data());
 191   if ( (fCent <= fCentralityCutMax)  &&  (fCent >= fCentralityCutMin) )  return kTRUE;
 192   ((TH1I*)fOutput->FindObject("fHistoCuts"))->Fill(kVtxCentral);
 193   return kFALSE;
 194 }
 195
 196 //______________________________________________________
 197 Bool_t AliSpectraAODEventCuts::CheckMultiplicityCut()
 198 {
 199   // Check multiplicity cut
 200   Int_t Ncharged=0;
 201   for (Int_t iTracks = 0; iTracks < fAOD->GetNumberOfTracks(); iTracks++){
 202     AliAODTrack* track = fAOD->GetTrack(iTracks);
 203     if (!fTrackCuts->IsSelected(track,kFALSE)) continue;
 204     Ncharged++;
 205   }
 206   if(Ncharged>fMultiplicityCutMin && Ncharged<fMultiplicityCutMax)return kTRUE;
 207
 208   return kFALSE;
 209 }
 210
 211 //______________________________________________________
 212 Bool_t AliSpectraAODEventCuts::CheckQVectorCut()
 213 {
 214   Double_t qxEPVZERO = -999., qyEPVZERO = -999.;
 215   Double_t qVZERO = -999.;
 216   Double_t psi=-999.;
 217
 218   if(fIsLHC10h){
 219     qVZERO=CalculateQVectorLHC10h();
 220     psi=fPsiV0A;
 221   }else{
 222     psi=fAOD->GetEventplane()->CalculateVZEROEventPlane(fAOD,10,2,qxEPVZERO,qyEPVZERO);//FIXME we can a flag for 2010 and 2011
 223     qVZERO= TMath::Sqrt(qxEPVZERO*qxEPVZERO + qyEPVZERO*qyEPVZERO);
 224   }
 225
 226   //cut on q vector
 227   if(qVZERO<fQVectorCutMin || qVZERO>fQVectorCutMax)return kFALSE;
 228   Double_t cent=fAOD->GetCentrality()->GetCentralityPercentile(fCentralityMethod.Data());
 229   ((TH2F*)fOutput->FindObject("fHistoQVector"))->Fill(cent,qVZERO);
 230   ((TH2F*)fOutput->FindObject("fHistoEP"))->Fill(cent,psi);
 231   ((TH1I*)fOutput->FindObject("fHistoCuts"))->Fill(kQVector);
 232
 233
 234   return kTRUE;
 235 }
 236
 237 //______________________________________________________
 238 Double_t AliSpectraAODEventCuts::CalculateQVectorLHC10h(){
 239
 240   Int_t run = fAOD->GetRunNumber();
 241   if(run != fRun){
 242     // Load the calibrations run dependent
 243     if(OpenInfoCalbration(run))fRun=run;
 244     else{
 245       fqV0C=-999.;
 246       fqV0A=-999.;
 247       return -999.;
 248     }
 249   }
 250
 251   //V0 info
 252   Double_t Qxa2 = 0, Qya2 = 0;
 253   Double_t Qxc2 = 0, Qyc2 = 0;
 254   Double_t sumMc = 0, sumMa = 0;
 255
 256   AliAODVZERO* aodV0 = fAOD->GetVZEROData();
 257
 258   for (Int_t iv0 = 0; iv0 < 64; iv0++) {
 259
 260     Double_t phiV0 = TMath::PiOver4()*(0.5 + iv0 % 8);
 261
 262     Float_t multv0 = aodV0->GetMultiplicity(iv0);
 263     ((TH2F*)fOutput->FindObject("fV0M"))->Fill(iv0,multv0);
 264
 265     if (iv0 < 32){
 266
 267       Double_t multCorC = -10;
 268
 269       if (iv0 < 8)
 270         multCorC = multv0*fV0Cpol1/fMultV0->GetBinContent(iv0+1);
 271       else if (iv0 >= 8 && iv0 < 16)
 272         multCorC = multv0*fV0Cpol2/fMultV0->GetBinContent(iv0+1);
 273       else if (iv0 >= 16 && iv0 < 24)
 274         multCorC = multv0*fV0Cpol3/fMultV0->GetBinContent(iv0+1);
 275       else if (iv0 >= 24 && iv0 < 32)
 276         multCorC = multv0*fV0Cpol4/fMultV0->GetBinContent(iv0+1);
 277
 278       if (multCorC < 0){
 279         cout<<"Problem with multiplicity in V0C"<<endl;
 280         fqV0C=-999.;
 281         fqV0A=-999.;
 282         return -999.;
 283       }
 284
 285       Qxc2 += TMath::Cos(2*phiV0) * multCorC;
 286       Qyc2 += TMath::Sin(2*phiV0) * multCorC;
 287
 288       sumMc += multCorC;
 289       ((TH2F*)fOutput->FindObject("fV0MCor"))->Fill(iv0,multCorC);
 290
 291     } else {
 292
 293       Double_t multCorA = -10;
 294
 295       if (iv0 >= 32 && iv0 < 40)
 296         multCorA = multv0*fV0Apol1/fMultV0->GetBinContent(iv0+1);
 297       else if (iv0 >= 40 && iv0 < 48)
 298         multCorA = multv0*fV0Apol2/fMultV0->GetBinContent(iv0+1);
 299       else if (iv0 >= 48 && iv0 < 56)
 300         multCorA = multv0*fV0Apol3/fMultV0->GetBinContent(iv0+1);
 301       else if (iv0 >= 56 && iv0 < 64)
 302         multCorA = multv0*fV0Apol4/fMultV0->GetBinContent(iv0+1);
 303
 304       if (multCorA < 0){
 305         cout<<"Problem with multiplicity in V0A"<<endl;
 306         fqV0C=-999.;
 307         fqV0A=-999.;
 308         return -999.;
 309       }
 310
 311       Qxa2 += TMath::Cos(2*phiV0) * multCorA;
 312       Qya2 += TMath::Sin(2*phiV0) * multCorA;
 313
 314       sumMa += multCorA;
 315       ((TH2F*)fOutput->FindObject("fV0MCor"))->Fill(iv0,multCorA);
 316     }
 317   }
 318
 319   Short_t centrV0  = GetCentrCode(fAOD);
 320
 321   Double_t Qxamean2 = 0.;
 322   Double_t Qyamean2 = 0.;
 323   Double_t Qxcmean2 = 0.;
 324   Double_t Qycmean2 = 0.;
 325
 326   if(centrV0!=-1){
 327     Qxamean2 = fMeanQxa2[centrV0];
 328     Qyamean2 = fMeanQya2[centrV0];
 329     Qxcmean2 = fMeanQxc2[centrV0];
 330     Qycmean2 = fMeanQyc2[centrV0];
 331   }
 332
 333   Double_t QxaCor2 = Qxa2 - Qxamean2*sumMa;
 334   Double_t QyaCor2 = Qya2 - Qyamean2*sumMa;
 335   Double_t QxcCor2 = Qxc2 - Qxcmean2*sumMc;
 336   Double_t QycCor2 = Qyc2 - Qycmean2*sumMc;
 337
 338   fPsiV0A = TMath::ATan2(QyaCor2, QxaCor2)/2.;
 339   fPsiV0C = TMath::ATan2(QycCor2, QxcCor2)/2.;
 340
 341   ((TH2F*)fOutput->FindObject("fPsiACor"))->Fill((Float_t)fAOD->GetCentrality()->GetCentralityPercentile("V0M"), fPsiV0A);
 342   ((TH2F*)fOutput->FindObject("fPsiCCor"))->Fill((Float_t)fAOD->GetCentrality()->GetCentralityPercentile("V0M"), fPsiV0C);
 343
 344   fqV0A = TMath::Sqrt((QxaCor2*QxaCor2 + QyaCor2*QyaCor2)/sumMa);
 345   fqV0C = TMath::Sqrt((QxcCor2*QxcCor2 + QycCor2*QycCor2)/sumMc);
 346
 347   ((TH2F*)fOutput->FindObject("fQVecACor"))->Fill((Float_t)fAOD->GetCentrality()->GetCentralityPercentile("V0M"), fqV0A);
 348   ((TH2F*)fOutput->FindObject("fQVecCCor"))->Fill((Float_t)fAOD->GetCentrality()->GetCentralityPercentile("V0M"), fqV0C);
 349
 350   return fqV0A; //FIXME we have to combine VZERO-A and C
 351 }
 352
 353 //______________________________________________________
 354 Short_t AliSpectraAODEventCuts::GetCentrCode(AliVEvent* ev)
 355 {
 356
 357   Short_t centrCode = -1;
 358
 359   AliCentrality* centrality = 0;
 360   AliAODEvent* aod = (AliAODEvent*)ev;
 361   centrality = aod->GetHeader()->GetCentralityP();
 362
 363   Float_t centV0 = centrality->GetCentralityPercentile("V0M");
 364   Float_t centTrk = centrality->GetCentralityPercentile("TRK");
 365
 366
 367   if (TMath::Abs(centV0 - centTrk) < 5.0 && centV0 <= 80 && centV0 > 0){
 368
 369      if ((centV0 > 0) && (centV0 <= 5.0))
 370        centrCode = 0;
 371      else if ((centV0 > 5.0) && (centV0 <= 10.0))
 372        centrCode = 1;
 373      else if ((centV0 > 10.0) && (centV0 <= 20.0))
 374        centrCode = 2;
 375      else if ((centV0 > 20.0) && (centV0 <= 30.0))
 376        centrCode = 3;
 377      else if ((centV0 > 30.0) && (centV0 <= 40.0))
 378        centrCode = 4;
 379      else if ((centV0 > 40.0) && (centV0 <= 50.0))
 380        centrCode = 5;
 381      else if ((centV0 > 50.0) && (centV0 <= 60.0))
 382        centrCode = 6;
 383      else if ((centV0 > 60.0) && (centV0 <= 70.0))
 384        centrCode = 7;
 385      else if ((centV0 > 70.0) && (centV0 <= 80.0))
 386        centrCode = 8;
 387   }
 388
 389   return centrCode;
 390
 391 }
 392
 393 //______________________________________________________
 394 void AliSpectraAODEventCuts::PrintCuts()
 395 {
 396   // print info about event cuts
 397   cout << "Event Stats" << endl;
 398   cout << " > Trigger Selection: " << fSelectBit << endl;
 399   cout << " > Centrality estimator: " << fCentralityMethod << endl;
 400   cout << " > Number of accepted events: " << NumberOfEvents() << endl;
 401   cout << " > Number of processed events: " << NumberOfProcessedEvents() << endl;
 402   cout << " > Number of PhysSel events: " <<  NumberOfPhysSelEvents()  << endl;
 403   cout << " > Vertex out of range: " << ((TH1I*)fOutput->FindObject("fHistoCuts"))->GetBinContent(kVtxRange + 1) << endl;
 404   cout << " > Events cut by centrality: " << ((TH1I*)fOutput->FindObject("fHistoCuts"))->GetBinContent(kVtxCentral + 1) << endl;
 405   cout << " > Events without vertex: " << ((TH1I*)fOutput->FindObject("fHistoCuts"))->GetBinContent(kVtxNoEvent + 1) << endl;
 406   cout << " > QVector cut: " << ((TH1I*)fOutput->FindObject("fHistoCuts"))->GetBinContent(kQVector + 1) << endl;
 407   cout << " > Track type used for the QVector calculation: " << fTrackBits << endl;
 408   cout << " > QRange: [" << fQVectorCutMin <<"," <<fQVectorCutMax<<"]"<< endl;
 409   cout << " > Vertex: [" << fVertexCutMin <<"," <<fVertexCutMax<<"]"<< endl;
 410   cout << " > Multiplicity: [" << fMultiplicityCutMin <<"," <<fMultiplicityCutMax<<"]"<< endl;
 411   cout << " > Centrality: [" << fCentralityCutMin <<"," <<fCentralityCutMax<<"]"<< endl;
 412 }
 413
 414 //_____________________________________________________________________________
 415 Bool_t AliSpectraAODEventCuts::OpenInfoCalbration(Int_t run)
 416 {
 417
 418   AliOADBContainer* cont = (AliOADBContainer*) fCalib->FindObject("hMultV0BefCorr");
 419   if(!cont){
 420     printf("OADB object hMultV0BefCorr is not available in the file\n");
 421     return 0;
 422   }
 423
 424   if(!(cont->GetObject(run))){
 425     printf("OADB object hMultV0BefCorr is not available for run %i\n",run);
 426     return 0;
 427   }
 428   fMultV0 = ((TH2F*) cont->GetObject(run))->ProfileX();
 429
 430   TF1* fpolc1 = new TF1("fpolc1","pol0", 0, 7);
 431   fMultV0->Fit(fpolc1, "RN");
 432   fV0Cpol1 = fpolc1->GetParameter(0);
 433
 434   TF1* fpolc2 = new TF1("fpolc2","pol0", 8, 15);
 435   fMultV0->Fit(fpolc2, "RN");
 436   fV0Cpol2 = fpolc2->GetParameter(0);
 437
 438   TF1* fpolc3 = new TF1("fpolc3","pol0", 16, 23);
 439   fMultV0->Fit(fpolc3, "RN");
 440   fV0Cpol3 = fpolc3->GetParameter(0);
 441
 442   TF1* fpolc4 = new TF1("fpolc4","pol0", 24, 31);
 443   fMultV0->Fit(fpolc4, "RN");
 444   fV0Cpol4 = fpolc4->GetParameter(0);
 445
 446   TF1* fpola1 = new TF1("fpola1","pol0", 32, 39);
 447   fMultV0->Fit(fpola1, "RN");
 448   fV0Apol1 = fpola1->GetParameter(0);
 449
 450   TF1* fpola2 = new TF1("fpola2","pol0", 40, 47);
 451   fMultV0->Fit(fpola2, "RN");
 452   fV0Apol2 = fpola2->GetParameter(0);
 453
 454   TF1* fpola3 = new TF1("fpola3","pol0", 48, 55);
 455   fMultV0->Fit(fpola3, "RN");
 456   fV0Apol3 = fpola3->GetParameter(0);
 457
 458   TF1* fpola4 = new TF1("fpola4","pol0", 56, 63);
 459   fMultV0->Fit(fpola4, "RN");
 460   fV0Apol4 = fpola4->GetParameter(0);
 461
 462   for(Int_t i=0; i < 10; i++){
 463
 464     char nameQxa2[100];
 465     snprintf(nameQxa2,100, "hQxa2m_%i", i);
 466
 467     char nameQya2[100];
 468     snprintf(nameQya2,100, "hQya2m_%i", i);
 469
 470     char nameQxc2[100];
 471     snprintf(nameQxc2,100, "hQxc2m_%i", i);
 472
 473     char nameQyc2[100];
 474     snprintf(nameQyc2,100, "hQyc2m_%i", i);
 475
 476     AliOADBContainer* contQxa2 = (AliOADBContainer*) fCalib->FindObject(nameQxa2);
 477     if(!contQxa2){
 478       printf("OADB object %s is not available in the file\n", nameQxa2);
 479       return 0;
 480     }
 481
 482     if(!(contQxa2->GetObject(run))){
 483       printf("OADB object %s is not available for run %i\n", nameQxa2, run);
 484       return 0;
 485     }
 486
 487     fMeanQxa2[i] = ((TH1F*) contQxa2->GetObject(run))->GetMean();
 488
 489
 490     AliOADBContainer* contQya2 = (AliOADBContainer*) fCalib->FindObject(nameQya2);
 491     if(!contQya2){
 492       printf("OADB object %s is not available in the file\n", nameQya2);
 493       return 0;
 494     }
 495
 496     if(!(contQya2->GetObject(run))){
 497       printf("OADB object %s is not available for run %i\n", nameQya2, run);
 498       return 0;
 499     }
 500
 501     fMeanQya2[i] = ((TH1F*) contQya2->GetObject(run))->GetMean();
 502
 503
 504     AliOADBContainer* contQxc2 = (AliOADBContainer*) fCalib->FindObject(nameQxc2);
 505     if(!contQxc2){
 506       printf("OADB object %s is not available in the file\n", nameQxc2);
 507       return 0;
 508     }
 509
 510     if(!(contQxc2->GetObject(run))){
 511       printf("OADB object %s is not available for run %i\n", nameQxc2, run);
 512       return 0;
 513     }
 514
 515     fMeanQxc2[i] = ((TH1F*) contQxc2->GetObject(run))->GetMean();
 516
 517
 518     AliOADBContainer* contQyc2 = (AliOADBContainer*) fCalib->FindObject(nameQyc2);
 519     if(!contQyc2){
 520       printf("OADB object %s is not available in the file\n", nameQyc2);
 521       return 0;
 522     }
 523
 524     if(!(contQyc2->GetObject(run))){
 525       printf("OADB object %s is not available for run %i\n", nameQyc2, run);
 526       return 0;
 527     }
 528
 529     fMeanQyc2[i] = ((TH1F*) contQyc2->GetObject(run))->GetMean();
 530
 531   }
 532   return 1;
 533 }
 534
 535 //______________________________________________________
 536
 537
 538 Long64_t AliSpectraAODEventCuts::Merge(TCollection* list)
 539 {
 540   // Merge a list of AliSpectraAODEventCuts objects with this.
 541   // Returns the number of merged objects (including this).
 542
 543   AliInfo("Merging");
 544
 545   if (!list)
 546     return 0;
 547
 548   if (list->IsEmpty())
 549     return 1;
 550
 551   TIterator* iter = list->MakeIterator();
 552   TObject* obj;
 553
 554   // collections of all histograms
 555   TList collections;
 556
 557   Int_t count = 0;
 558
 559   while ((obj = iter->Next())) {
 560     AliSpectraAODEventCuts* entry = dynamic_cast<AliSpectraAODEventCuts*> (obj);
 561     if (entry == 0)
 562       continue;
 563
 564     TList * l = entry->GetOutputList();
 565     collections.Add(l);
 566     count++;
 567   }
 568
 569   fOutput->Merge(&collections);
 570
 571   delete iter;
 572
 573   return count+1;
 574 }
 575