PWG/FLOW/Tasks/AliAnalysisTaskQAflow.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 // AliAnalysisTaskQAflow: some simple QA used in flow analysis
  17
  18 #include "TMath.h"
  19 #include "TH1D.h"
  20 #include "TH2D.h"
  21 #include "TSeqCollection.h"
  22 #include "TObjArray.h"
  23 #include "TObjArray.h"
  24 #include "TChain.h"
  25 #include "TMCProcess.h"
  26 #include "TLorentzVector.h"
  27 #include "TDirectory.h"
  28 #include "TROOT.h"
  29 #include "TNtuple.h"
  30
  31 #include "AliLog.h"
  32 #include "AliVParticle.h"
  33 #include "AliMCParticle.h"
  34 #include "AliStack.h"
  35 #include "AliVEvent.h"
  36 #include "AliESDEvent.h"
  37 #include "AliMCEvent.h"
  38 #include "AliESDVZERO.h"
  39 #include "AliESDZDC.h"
  40 #include "AliESDtrack.h"
  41 #include "AliFlowTrackCuts.h"
  42 #include "AliFlowEventCuts.h"
  43 #include "AliMultiplicity.h"
  44 #include "AliESDtrackCuts.h"
  45 #include "AliVertex.h"
  46 #include "AliFlowEventSimple.h"
  47 #include "AliFlowEvent.h"
  48 #include "AliFlowVector.h"
  49
  50 #include "AliAnalysisTaskSE.h"
  51 #include "AliAnalysisManager.h"
  52 #include "AliInputEventHandler.h"
  53
  54 #include "AliAnalysisTaskQAflow.h"
  55
  56 ClassImp(AliAnalysisTaskQAflow)
  57
  58 //________________________________________________________________________
  59 AliAnalysisTaskQAflow::AliAnalysisTaskQAflow()
  60   : AliAnalysisTaskSE(),
  61     fOutput(NULL),
  62     fFillNtuple(kFALSE),
  63     fDoCorrelations(kFALSE),
  64     fNtuple(NULL),
  65     fEventCuts(NULL),
  66     fTrackCuts(NULL)
  67 {
  68   // Default constructor
  69 }
  70
  71 //________________________________________________________________________
  72 AliAnalysisTaskQAflow::AliAnalysisTaskQAflow(const char* name)
  73   : AliAnalysisTaskSE(name),
  74     fOutput(NULL),
  75     fFillNtuple(kFALSE),
  76     fDoCorrelations(kFALSE),
  77     fNtuple(NULL),
  78     fEventCuts(NULL),
  79     fTrackCuts(NULL)
  80 {
  81   // Constructor
  82   DefineInput(1, AliFlowEventSimple::Class());
  83   DefineOutput(1, TObjArray::Class());
  84   DefineOutput(2,TNtuple::Class());
  85 }
  86
  87 //________________________________________________________________________
  88 void AliAnalysisTaskQAflow::UserCreateOutputObjects()
  89 {
  90   // Called once at the beginning
  91   fOutput=new TObjArray();
  92   fNtuple = new TNtuple("flowQAtree","flowQAtree","mpt:qx:qy:mul:rmul:phys:vtxtpcx:vtxtpcy:vtxtpcz:ntra:ntrc:mv0a:mv0c:zdcp1:zdcn1:zdcp2:zdcn2:zdcpart1:zdcpart2:t1:t2:t3:t4:t5:vtxspdx:vtxspdy:vtxspdz:vtxx:vtxy:vtxz:rawmeanpt:maxpt:qxp:qyp:qxn:qyn:qxa:qya:qxb:qyb:qm:qmp:qmn:qma:qmb");
  93   //TDirectory* before = gDirectory->mkdir("before cuts","before cuts");
  94   //TDirectory* after = gDirectory->mkdir("after cuts","after cuts");
  95   TObjArray* before = new TObjArray();
  96   TObjArray* after = new TObjArray();
  97   fOutput->Add(before);
  98   fOutput->Add(after);
  99
 100   //define histograms
 101
 102   TH1* hist;
 103   hist = new TH1I("all_tracklet_multiplicity","all tracklets",5000,0,5000);
 104   before->Add(hist); after->Add(hist->Clone()); //0
 105   hist = new TH1I("rptrack_multiplicity", "RP selection track multiplicity",5000,0,5000);
 106   before->Add(hist); after->Add(hist->Clone()); //1
 107   hist = new TH1I("rprefmult","RP selection refmult",30000, 0,30000);
 108   before->Add(hist); after->Add(hist->Clone()); //2
 109   hist = new TH1I("SPD_clusters","SPD clusters",10000,0,10000);
 110   before->Add(hist); after->Add(hist->Clone()); //3
 111   hist = new TH1D("primary_vertexZ","primary vertex z",1000,-20,20);
 112   before->Add(hist); after->Add(hist->Clone()); //4
 113   hist = new TH1I("ITS_clusters_on_track", "ITS clusters on track", 8, 0, 8);
 114   before->Add(hist); after->Add(hist->Clone()); //5
 115   hist = new TH1I("TPC_clusters_on_track", "TPC clusters on track", 159, 1, 160);
 116   before->Add(hist); after->Add(hist->Clone()); //6
 117   hist = new TH1D("TPC_chi2_per_cluster","TPC #chi^{2}/cluster",1000,0.0,5.0);
 118   before->Add(hist); after->Add(hist->Clone()); //7
 119   hist = new TH1D("DCA_xy","DCA xy", 1000, -5.0, 5.0 );
 120   before->Add(hist); after->Add(hist->Clone()); //8
 121   hist = new TH1D("DCA_z","DCA z", 1000, -5.0, 5.0 );
 122   before->Add(hist); after->Add(hist->Clone()); //9
 123   hist = new TH1D("phi_tracklets","#phi tracklets", 1000, 0.0, TMath::TwoPi() );
 124   before->Add(hist); after->Add(hist->Clone()); //10
 125   hist = new TH1D("phi_tracks","#phi tracks", 1000, 0.0, TMath::TwoPi() );
 126   before->Add(hist); after->Add(hist->Clone()); //11
 127   hist = new TH1D("eta_tracklets","#eta tracklets", 1000, -2.0, 2.0 );
 128   before->Add(hist); after->Add(hist->Clone()); //12
 129   hist = new TH1D("eta_tracks","#eta tracks", 1000, -2.0, 2.0 );
 130   before->Add(hist); after->Add(hist->Clone()); //13
 131   hist = new TH1D("TPC_vertex_z", "TPC vertex z", 1000,-20.0,20.0);
 132   before->Add(hist); after->Add(hist->Clone()); //14
 133   hist = new TH1D("ptyield", "p_{t} spectrum", 10000,0.0,10.0);
 134   before->Add(hist); after->Add(hist->Clone()); //15
 135   hist = new TH1D("ptyieldplus", "p_{t} spectrum +", 10000,0.0,10.0);
 136   before->Add(hist); after->Add(hist->Clone()); //16
 137   hist = new TH1D("ptyieldneg", "p_{t} spectrum -", 10000,0.0,10.0);
 138   before->Add(hist); after->Add(hist->Clone()); //17
 139   hist = new TH1D("charges", "charge distribution", 5,-2.5,2.5);
 140   before->Add(hist); after->Add(hist->Clone()); //18
 141   hist = new TH1D("dphivsdeta", "#Delta#phi separation", 10000,-TMath::PiOver2(),TMath::Pi()+TMath::PiOver2());
 142   before->Add(hist); after->Add(hist->Clone()); //19
 143   hist = new TH1I("standardTPC_multiplicity", "standard TPC track multiplicity",10000,0,10000);
 144   before->Add(hist); after->Add(hist->Clone()); //20
 145   hist = new TH1I("standardV0_multiplicity", "standard V0 multiplicity",30000,0,30000);
 146   before->Add(hist); after->Add(hist->Clone()); //21
 147   hist = new TH1I("standardSPD1clusters_multiplicity", "standard SPD1 clusters multiplicity",30000,0,30000);
 148   before->Add(hist); after->Add(hist->Clone()); //22
 149   hist = new TH1I("standardSPDtracklets_multiplicity", "standard SPD tracklets multiplicity",30000,0,30000);
 150   before->Add(hist); after->Add(hist->Clone()); //23
 151
 152   //post data here as it doesn't change anyway (the pointer to list anyway)
 153
 154   PostData(1, fOutput);
 155   PostData(2, fNtuple);
 156 }
 157
 158 //________________________________________________________________________
 159 void AliAnalysisTaskQAflow::UserExec(Option_t *)
 160 {
 161
 162   //get teh input data
 163   AliESDEvent* event = dynamic_cast<AliESDEvent*>(InputEvent());
 164   if (!event)
 165   {
 166     AliFatal("no ESD event");
 167     return;
 168   }
 169   fTrackCuts->SetEvent(event);
 170
 171   //TObjArray* before = ((TDirectory*)fOutput->At(0))->GetList();
 172   //TObjArray* after = ((TDirectory*)fOutput->At(1))->GetList();
 173   TObjArray* before = (TObjArray*)fOutput->At(0);
 174   TObjArray* after = (TObjArray*)fOutput->At(1);
 175   TH1* htrackletmultB = static_cast<TH1*>(before->At(0));
 176   TH1* htrackletmultA = static_cast<TH1*>(after->At(0));
 177   TH1* htrackmultB = static_cast<TH1*>(before->At(1));
 178   TH1* htrackmultA = static_cast<TH1*>(after->At(1));
 179   TH1* hrefmultB = static_cast<TH1*>(before->At(2));
 180   TH1* hrefmultA = static_cast<TH1*>(after->At(2));
 181   TH1* hspdclustersB = static_cast<TH1*>(before->At(3));
 182   TH1* hspdclustersA = static_cast<TH1*>(after->At(3));
 183   TH1* hprimvtxzB = static_cast<TH1*>(before->At(4));
 184   TH1* hprimvtxzA = static_cast<TH1*>(after->At(4));
 185
 186   TH1* hITSclsB = static_cast<TH1*>(before->At(5));
 187   TH1* hITSclsA = static_cast<TH1*>(after->At(5));
 188   TH1* hTPCclsB = static_cast<TH1*>(before->At(6));
 189   TH1* hTPCclsA = static_cast<TH1*>(after->At(6));
 190   TH1* hTPCchi2B = static_cast<TH1*>(before->At(7));
 191   TH1* hTPCchi2A = static_cast<TH1*>(after->At(7));
 192   TH1* hdcaxyB = static_cast<TH1*>(before->At(8));
 193   TH1* hdcaxyA = static_cast<TH1*>(after->At(8));
 194   TH1* hdcazB = static_cast<TH1*>(before->At(9));
 195   TH1* hdcazA = static_cast<TH1*>(after->At(9));
 196   TH1* hphitrackletsB = static_cast<TH1*>(before->At(10));
 197   TH1* hphitrackletsA = static_cast<TH1*>(after->At(10));
 198   TH1* hphitracksB = static_cast<TH1*>(before->At(11));
 199   TH1* hphitracksA = static_cast<TH1*>(after->At(11));
 200   TH1* hetatrackletsB = static_cast<TH1*>(before->At(12));
 201   TH1* hetatrackletsA = static_cast<TH1*>(after->At(12));
 202   TH1* hetatracksB = static_cast<TH1*>(before->At(13));
 203   TH1* hetatracksA = static_cast<TH1*>(after->At(13));
 204   TH1* hprimvtxzTPCB = static_cast<TH1*>(before->At(14));
 205   TH1* hprimvtxzTPCA = static_cast<TH1*>(after->At(14));
 206   TH1* hptyieldB = static_cast<TH1*>(before->At(15));
 207   TH1* hptyieldA = static_cast<TH1*>(after->At(15));
 208   TH1* hptyieldplusB = static_cast<TH1*>(before->At(16));
 209   TH1* hptyieldplusA = static_cast<TH1*>(after->At(16));
 210   TH1* hptyieldnegB = static_cast<TH1*>(before->At(17));
 211   TH1* hptyieldnegA = static_cast<TH1*>(after->At(17));
 212   TH1* hchargesB = static_cast<TH1*>(before->At(18));
 213   TH1* hchargesA = static_cast<TH1*>(after->At(18));
 214   TH1* hphisepB = static_cast<TH1*>(before->At(19));
 215   TH1* hphisepA = static_cast<TH1*>(after->At(19));
 216   TH1* hstdtpcmultB = static_cast<TH1*>(before->At(20));
 217   TH1* hstdtpcmultA = static_cast<TH1*>(after->At(20));
 218   TH1* hstdv0multB = static_cast<TH1*>(before->At(21));
 219   TH1* hstdv0multA = static_cast<TH1*>(after->At(21));
 220   TH1* hstdspd1clsmultB = static_cast<TH1*>(before->At(22));
 221   TH1* hstdspd1clsmultA = static_cast<TH1*>(after->At(22));
 222   TH1* hstdspdtrmultB = static_cast<TH1*>(before->At(23));
 223   TH1* hstdspdtrmultA = static_cast<TH1*>(after->At(23));
 224
 225   Bool_t passevent = fEventCuts->IsSelected(event,0x0);
 226   Bool_t isSelectedEventSelection = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kMB);
 227
 228   AliMultiplicity* tracklets = const_cast<AliMultiplicity*>(event->GetMultiplicity());
 229   Int_t ntracklets=0;
 230   Int_t nspdclusters=0;
 231   Int_t ntrackletsA=0;
 232   Int_t ntrackletsC=0;
 233   if (tracklets)
 234   {
 235     ntracklets = tracklets->GetNumberOfTracklets();
 236     nspdclusters = tracklets->GetNumberOfITSClusters(0,1);
 237     for (Int_t i=0; i<tracklets->GetNumberOfTracklets(); i++)
 238     {
 239       Bool_t pass=fTrackCuts->IsSelected(tracklets,i);
 240       Float_t phi=tracklets->GetPhi(i);
 241       Float_t eta=tracklets->GetEta(i);
 242       hphitrackletsB->Fill(phi); if (pass) hphitrackletsA->Fill(phi);
 243       hetatrackletsB->Fill(eta); if (pass) hetatrackletsA->Fill(eta);
 244       if (eta>0) ntrackletsC++;
 245       else ntrackletsA++;
 246     }
 247   }
 248
 249   AliFlowEventCuts stdtpcrefmultcuts;
 250   stdtpcrefmultcuts.SetRefMultMethod(AliFlowEventCuts::kTPConly);
 251   AliFlowEventCuts stdv0refmultcuts;
 252   stdv0refmultcuts.SetRefMultMethod(AliFlowEventCuts::kV0);
 253   AliFlowEventCuts stdspd1refmult;
 254   stdspd1refmult.SetRefMultMethod(AliFlowEventCuts::kSPD1clusters);
 255   AliFlowEventCuts stdspdrefmult;
 256   stdspdrefmult.SetRefMultMethod(AliFlowEventCuts::kSPDtracklets);
 257
 258   AliFlowEventSimple* flowevent=NULL;
 259   AliFlowEventSimple* floweventin = dynamic_cast<AliFlowEventSimple*>(GetInputData(1));
 260   if (!floweventin) flowevent = new AliFlowEvent(fTrackCuts,fTrackCuts);
 261   else flowevent = new AliFlowEventSimple(*floweventin);
 262
 263   Int_t rpmult = flowevent->GetReferenceMultiplicity();
 264   Int_t refmult = fEventCuts->RefMult(event);
 265   Int_t refmultv0 = stdv0refmultcuts.RefMult(event);
 266   Int_t refmulttpc = stdtpcrefmultcuts.RefMult(event);
 267   Int_t refmultspdtr = stdspdrefmult.RefMult(event);
 268   Int_t refmultspdcls = stdspd1refmult.RefMult(event);
 269
 270   htrackletmultB->Fill(ntracklets); if (passevent) htrackletmultA->Fill(ntracklets);
 271   htrackmultB->Fill(rpmult); if (passevent) htrackmultA->Fill(rpmult);
 272   hrefmultB->Fill(refmult); if (passevent) hrefmultA->Fill( refmult);
 273   hstdv0multB->Fill(refmultv0); if (passevent) hstdv0multA->Fill( refmultv0);
 274   hstdtpcmultB->Fill(refmulttpc); if (passevent) hstdtpcmultA->Fill( refmulttpc);
 275   hstdspd1clsmultB->Fill(refmultspdcls); if (passevent) hstdspd1clsmultA->Fill( refmultspdcls);
 276   hstdspdtrmultB->Fill(refmultspdtr); if (passevent) hstdspdtrmultA->Fill( refmultspdtr);
 277
 278   hspdclustersB->Fill(nspdclusters); if (passevent) hspdclustersA->Fill( nspdclusters);
 279   const AliVertex* vertex = event->GetPrimaryVertex();
 280   Float_t vtxz=0.0;
 281   Float_t vtxx=0.0;
 282   Float_t vtxy=0.0;
 283   if (vertex)
 284   {
 285     vtxz = vertex->GetZ();
 286     vtxx = vertex->GetX();
 287     vtxy = vertex->GetY();
 288     hprimvtxzB->Fill(vtxz); if (passevent) hprimvtxzA->Fill(vtxz);
 289   }
 290   const AliVertex* vertextpc = event->GetPrimaryVertexTPC();
 291   Float_t vtxTPCx=0.0;
 292   Float_t vtxTPCy=0.0;
 293   Float_t vtxTPCz=0.0;
 294   if (vertextpc)
 295   {
 296     vtxTPCx = vertextpc->GetX();
 297     vtxTPCy = vertextpc->GetY();
 298     vtxTPCz = vertextpc->GetZ();
 299     hprimvtxzTPCB->Fill(vtxTPCz); if (passevent) hprimvtxzTPCA->Fill(vtxTPCz);
 300   }
 301   const AliVertex* vertexspd = event->GetPrimaryVertexSPD();
 302   Float_t vtxSPDx=0.0;
 303   Float_t vtxSPDy=0.0;
 304   Float_t vtxSPDz=0.0;
 305   if (vertexspd)
 306   {
 307     vtxSPDx = vertexspd->GetX();
 308     vtxSPDy = vertexspd->GetY();
 309     vtxSPDz = vertexspd->GetZ();
 310   }
 311   AliESDVZERO* vzero=event->GetVZEROData();
 312   AliESDZDC* zdc=event->GetESDZDC();
 313   Float_t mv0a=vzero->GetMTotV0A();
 314   Float_t mv0c=vzero->GetMTotV0C();
 315   Float_t zdcp1=zdc->GetZDCP1Energy();
 316   Float_t zdcn1=zdc->GetZDCN1Energy();
 317   Float_t zdcp2=zdc->GetZDCP2Energy();
 318   Float_t zdcn2=zdc->GetZDCN2Energy();
 319   Float_t zdcpart1=zdc->GetZDCPartSideA();
 320   Float_t zdcpart2=zdc->GetZDCPartSideC();
 321   Float_t meanpt=0.;
 322   Float_t rawmeanpt=0.;
 323   Float_t maxpt=0.0;
 324   Int_t ntracks=fTrackCuts->GetNumberOfInputObjects();
 325   Int_t nselected=0;
 326   for (Int_t i=0; i<ntracks; i++)
 327   {
 328     TObject* obj = fTrackCuts->GetInputObject(i);
 329     if (!obj) continue;
 330     Bool_t pass = fTrackCuts->IsSelected(obj,i);
 331     if (pass) nselected++;
 332     Float_t dcaxy=0.0;
 333     Float_t dcaz=0.0;
 334     Float_t tpcchi2=0.0;
 335     Float_t tpcchi2percls=0.0;
 336     Int_t ntpccls=0;
 337     Int_t nitscls=0;
 338     Float_t eta=0.0;
 339     Float_t phi=0.0;
 340     Float_t pt=0.0;
 341     Short_t charge=0;
 342     AliESDtrack* track = dynamic_cast<AliESDtrack*>(fTrackCuts->GetTrack());
 343     if (track)
 344     {
 345       track->GetImpactParameters(dcaxy,dcaz);
 346       tpcchi2=track->GetTPCchi2();
 347       ntpccls=track->GetTPCNcls();
 348       eta=track->Eta();
 349       phi=track->Phi();
 350       pt=track->Pt();
 351       if (pt>maxpt) maxpt=pt;
 352       charge=track->Charge();
 353       rawmeanpt+=pt;
 354       if (pass) meanpt+=pt;
 355       tpcchi2percls= (ntpccls==0)?0.0:tpcchi2/ntpccls;
 356       nitscls = track->GetNcls(0);
 357       hITSclsB->Fill(nitscls); if (pass) hITSclsA->Fill( nitscls);
 358       hTPCclsB->Fill(ntpccls); if (pass) hTPCclsA->Fill( ntpccls);
 359       hTPCchi2B->Fill(tpcchi2percls); if (pass) hTPCchi2A->Fill( tpcchi2percls);
 360       hdcaxyB->Fill(dcaxy); if (pass) hdcaxyA->Fill( dcaxy);
 361       hdcazB->Fill(dcaz); if (pass) hdcazA->Fill(dcaz);
 362       hetatracksB->Fill(eta); if (pass) hetatracksA->Fill(eta);
 363       hphitracksB->Fill(phi); if (pass) hphitracksA->Fill(phi);
 364       hptyieldB->Fill(pt); if (pass) hptyieldA->Fill(pt);
 365       if (charge>0) {hptyieldplusB->Fill(pt); if (pass) hptyieldplusA->Fill(pt);}
 366       if (charge<0) {hptyieldnegB->Fill(pt); if (pass) hptyieldnegA->Fill(pt);}
 367       hchargesB->Fill(charge); if (pass) hchargesA->Fill(charge);
 368       /////////////////////////////////////////////////////////////////////////////
 369       ////  correlation part   ///////////////////////
 370       /////////////////////////////////////////
 371       if (fDoCorrelations)
 372       {
 373         for (Int_t j=i+1; j<ntracks; j++)
 374         {
 375           TObject* obj2 = fTrackCuts->GetInputObject(j);
 376           if (!obj2) continue;
 377           Bool_t pass2 = fTrackCuts->IsSelected(obj2,j);
 378           AliESDtrack* track2 = dynamic_cast<AliESDtrack*>(fTrackCuts->GetTrack());
 379           if (track2)
 380           {
 381             Double_t dphi = phi-track2->Phi();
 382             hphisepB->Fill(dphi); if (pass&&pass2) hphisepA->Fill(dphi);
 383           }
 384         }
 385       }//correlations
 386     }
 387   }
 388   if (nselected!=0) meanpt = meanpt/nselected;
 389   if (ntracks!=0) rawmeanpt = rawmeanpt/ntracks;
 390
 391   ///////////////////////////////////////////////////////////////////////
 392   if (fFillNtuple)
 393   {
 394     Double_t qx = 0.0;
 395     Double_t qy = 0.0;
 396     Double_t qm = 0.0;
 397     Double_t qxp = 0.0;
 398     Double_t qyp = 0.0;
 399     Double_t qmp = 0.0;
 400     Double_t qxn = 0.0;
 401     Double_t qyn = 0.0;
 402     Double_t qmn = 0.0;
 403     Double_t qxa = 0.0;
 404     Double_t qya = 0.0;
 405     Double_t qma = 0.0;
 406     Double_t qxb = 0.0;
 407     Double_t qyb = 0.0;
 408     Double_t qmb = 0.0;
 409
 410     AliFlowVector qvec[2];
 411
 412     qvec[0] = flowevent->GetQ(2);
 413     qx = qvec[0].X();
 414     qy = qvec[0].Y();
 415     qm = qvec[0].GetMult();
 416     flowevent->TagSubeventsByCharge();
 417     flowevent->Get2Qsub(qvec,2);
 418     qxp = qvec[0].X();
 419     qyp = qvec[0].Y();
 420     qmp = qvec[0].GetMult();
 421     qxn = qvec[1].X();
 422     qyn = qvec[1].Y();
 423     qmn = qvec[1].GetMult();
 424     flowevent->TagSubeventsInEta(-0.8,-0.1,0.1,0.8);
 425     flowevent->Get2Qsub(qvec,2);
 426     qxa = qvec[0].X();
 427     qya = qvec[0].Y();
 428     qma = qvec[0].GetMult();
 429     qxb = qvec[1].X();
 430     qyb = qvec[1].Y();
 431     qmb = qvec[1].GetMult();
 432
 433
 434     Float_t x[45];
 435     x[0]=meanpt; x[1]=qx; x[2]=qy; x[3]=rpmult; x[4]=refmult; x[5]=(isSelectedEventSelection)?1:0;
 436     x[6]=vtxTPCx; x[7]=vtxTPCy; x[8]=vtxTPCz; x[9]=ntrackletsA; x[10]=ntrackletsC;
 437     x[11]=mv0a; x[12]=mv0c; x[13]=zdcp1; x[14]=zdcn1; x[15]=zdcp2; x[16]=zdcn2;
 438     x[17]=zdcpart1; x[18]=zdcpart2;
 439     x[19]=0; if (event->IsTriggerClassFired("CMBAC-B-NOPF-ALL"))  x[19]=1;
 440     x[20]=0; if (event->IsTriggerClassFired("CMBS2C-B-NOPF-ALL")) x[20]=1;
 441     x[21]=0; if (event->IsTriggerClassFired("CMBS2A-B-NOPF-ALL")) x[21]=1;
 442     x[22]=0; if (event->IsTriggerClassFired("CMBAC-A-NOPF-ALL"))  x[22]=1;
 443     x[23]=0; if (event->IsTriggerClassFired("CMBAC-C-NOPF-ALL"))  x[23]=1;
 444     x[24]=vtxSPDx;
 445     x[25]=vtxSPDy;
 446     x[26]=vtxSPDz;
 447     x[27]=vtxx;
 448     x[28]=vtxy;
 449     x[29]=vtxz;
 450     x[30]=rawmeanpt;
 451     x[31]=maxpt;
 452     x[32]=qxp;
 453     x[33]=qyp;
 454     x[34]=qxn;
 455     x[35]=qyn;
 456     x[36]=qxa;
 457     x[37]=qya;
 458     x[38]=qxb;
 459     x[39]=qyb;
 460     x[40]=qm;
 461     x[41]=qmp;
 462     x[42]=qmn;
 463     x[43]=qma;
 464     x[44]=qmb;
 465     fNtuple->Fill(x);
 466   }//if flowevent
 467
 468   delete flowevent;
 469 }
 470
 471 //________________________________________________________________________
 472 void AliAnalysisTaskQAflow::Terminate(Option_t *)
 473 {
 474
 475 }
 476
 477 //________________________________________________________________________
 478 AliAnalysisTaskQAflow::~AliAnalysisTaskQAflow()
 479 {
 480   //dtor
 481   delete fTrackCuts;
 482   delete fEventCuts;
 483 }