PWGDQ/dielectron/TakuAlberica/single/AliAnalysisTaskMultiDielectronNewTaku.cxx

   1 /*************************************************************************
   2 * Copyright(c) 1998-2009, 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 //                                                                       //
  18 //                        Basic Analysis Task                            //
  19 //                                                                       //
  20 ///////////////////////////////////////////////////////////////////////////
  21
  22 #include <TChain.h>
  23 #include <TH1D.h>
  24 #include <TH2D.h>
  25 #include "TVector2.h"
  26
  27
  28 #include <AliCFContainer.h>
  29 #include <AliInputEventHandler.h>
  30 #include <AliESDInputHandler.h>
  31 #include <AliAODInputHandler.h>
  32 #include <AliAnalysisManager.h>
  33 #include <AliVEvent.h>
  34 #include <AliTriggerAnalysis.h>
  35
  36
  37 #include <TGeoGlobalMagField.h>
  38 #include "TGeoManager.h"
  39 #include "AliGeomManager.h"
  40 #include <AliMagF.h>
  41
  42
  43 #include "AliDielectronTaku.h"
  44 #include "AliDielectronHistosTaku.h"
  45 #include "AliDielectronCF.h"
  46 #include "AliDielectronMC.h"
  47 #include "AliDielectronEventCuts.h"
  48
  49 #include "AliAnalysisTaskMultiDielectronNewTaku.h"
  50
  51 #include "AliESDEvent.h"
  52 #include "AliESDInputHandler.h"
  53 #include "AliESDv0.h"
  54 #include "AliESDtrack.h"
  55 #include "AliESDtrackCuts.h"
  56 #include "AliCentrality.h"
  57 #include "AliVVertex.h"
  58 #include "AliESDVZERO.h"
  59 #include "AliEMCALTrack.h"
  60 //#include "AliFlowEventSimple.h"
  61 //#include "AliFlowLYZEventPlane.h"
  62
  63
  64 ClassImp(AliAnalysisTaskMultiDielectronNewTaku)
  65
  66 //_________________________________________________________________________________
  67 AliAnalysisTaskMultiDielectronNewTaku::AliAnalysisTaskMultiDielectronNewTaku() :
  68   AliAnalysisTaskSE(),
  69   fListDielectron(),
  70   fListHistos(),
  71   fListTree(NULL),
  72   fListCF(),
  73   fTree(NULL),
  74   fSelectPhysics(kFALSE),
  75   fTriggerMask(AliVEvent::kMB),
  76   fTriggerOnV0AND(kFALSE),
  77   fRejectPileup(kFALSE),
  78   fTriggerAnalysis(0x0),
  79   fEventFilter(0x0),
  80   fCutsEvent(0x0),
  81   fCutsMother(0x0),
  82   fEventStat(0x0),
  83   fEvent(0x0),
  84   fdEdXvsPt(0x0),
  85   fdEdXnSigmaElecvsPt(0x0),
  86   fTOFbetavsPt(0x0),
  87   fTOFnSigmaElecvsPt(0x0),
  88   fTPCcrossedRowsvsPt(0x0),
  89   fTPCchi2vsPt(0x0),
  90   fNEvent(0),
  91   fkTriggerMask(0),
  92   fkTriggerCent(0),
  93   fkNCut(0),
  94   fkRunNumber(0),
  95   fkCentrality(0),
  96   fkXvPrim(0),
  97   fkYvPrim(0),
  98   fkZvPrim(0),
  99   fkXRes(0),
 100   fkYRes(0),
 101   fkZRes(0),
 102   fkNTrk(0),
 103   fkTracks(0),
 104   fkNacc(0),
 105   fkNaccTrcklts(0),
 106   fkNch(0),
 107   fkZDCN1E(0),
 108   fkZDCP1E(0),
 109   fkZDCN2E(0),
 110   fkZDCP2E(0),
 111   fkV0A(0),
 112   fkV0C(0),
 113   fkNPar(0),
 114   //  fFlowEvent(0),
 115   //  fLyzEp(0),
 116   fQsum(NULL),
 117   fQ2sum(0),
 118   fkTriggerInfo(0),
 119   fMag(0)
 120 {
 121   //
 122   // Constructor
 123   //
 124
 125
 126 }
 127
 128 //_________________________________________________________________________________
 129 AliAnalysisTaskMultiDielectronNewTaku::AliAnalysisTaskMultiDielectronNewTaku(const char *name,
 130                                                                      AliDielectronEventCuts* cutsEvent
 131                                                                      ) :
 132   AliAnalysisTaskSE(name),
 133   fListDielectron(),
 134   fListHistos(),
 135   fListTree(NULL),
 136   fListCF(),
 137   fTree(NULL),
 138   fSelectPhysics(kFALSE),
 139   fTriggerMask(AliVEvent::kMB),
 140   fTriggerOnV0AND(kFALSE),
 141   fRejectPileup(kFALSE),
 142   fTriggerAnalysis(0x0),
 143   fEventFilter(0x0),
 144   fCutsEvent(cutsEvent),
 145   fCutsMother(0x0),
 146   fEventStat(0x0),
 147   fEvent(0x0),
 148   fdEdXvsPt(0x0),
 149   fdEdXnSigmaElecvsPt(0x0),
 150   fTOFbetavsPt(0x0),
 151   fTOFnSigmaElecvsPt(0x0),
 152   fTPCcrossedRowsvsPt(0x0),
 153   fTPCchi2vsPt(0x0),
 154   fNEvent(0),
 155   fkTriggerMask(0),
 156   fkTriggerCent(0),
 157   fkNCut(0),
 158   fkRunNumber(0),
 159   fkCentrality(0),
 160   fkXvPrim(0),
 161   fkYvPrim(0),
 162   fkZvPrim(0),
 163   fkXRes(0),
 164   fkYRes(0),
 165   fkZRes(0),
 166   fkNTrk(0),
 167   fkTracks(0),
 168   fkNacc(0),
 169   fkNaccTrcklts(0),
 170   fkNch(0),
 171   fkZDCN1E(0),
 172   fkZDCP1E(0),
 173   fkZDCN2E(0),
 174   fkZDCP2E(0),
 175   fkV0A(0),
 176   fkV0C(0),
 177   fkNPar(0),
 178   //  fFlowEvent(0),
 179   //  fLyzEp(0),
 180   fQsum(NULL),
 181   fQ2sum(0),
 182   fkTriggerInfo(0),
 183   fMag(0)
 184 {
 185   //
 186   // Constructor
 187   //
 188   DefineInput(0,TChain::Class());
 189   DefineOutput(1, TList::Class());
 190   //DefineOutput(1, TTree::Class());
 191   DefineOutput(2, TList::Class());
 192   DefineOutput(3, TH1D::Class());
 193   DefineOutput(4, TTree::Class());
 194
 195   fName  = name;
 196   // Constructor.
 197   fQsum = new TVector2();        // flow vector sum
 198   fQ2sum = 0;
 199
 200
 201   cout<<" ************** AliAnalysisTaskMultiDielectron::AliAnalysisTaskMultiDielectron  ***********"<<endl;
 202 }
 203
 204
 205 //_________________________________________________________________________________
 206 void AliAnalysisTaskMultiDielectronNewTaku::UserCreateOutputObjects()
 207 {
 208   cout<<" ************** AliAnalysisTaskMultiDielectron::Start ***********"<<endl;
 209   fListHistos.SetName("Dielectron_Histos_Multi");
 210   fListTree.SetName("Dielectron_Trees_Multi");
 211   fListCF.SetName("Dielectron_CF_Multi");
 212   fListDielectron.SetOwner();
 213   fListHistos.SetOwner();
 214   fListTree.SetOwner();
 215   fListCF.SetOwner();
 216
 217   //
 218   // Add all histogram manager histogram lists to the output TList
 219   //
 220
 221   if (!fListHistos.IsEmpty()||!fListCF.IsEmpty()) return; //already initialised
 222
 223   AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
 224   Bool_t isESD=man->GetInputEventHandler()->IsA()==AliESDInputHandler::Class();
 225 //   Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class();
 226
 227   TIter nextDie(&fListDielectron);
 228   AliDielectronTaku *die=0;
 229   while ( (die=static_cast<AliDielectronTaku*>(nextDie())) ){
 230     die->Init();
 231     if (die->GetHistogramList()) fListHistos.Add(const_cast<THashList*>(die->GetHistogramList()));
 232     if (die->GetCFManagerPair()) fListCF.Add(const_cast<AliCFContainer*>(die->GetCFManagerPair()->GetContainer()));
 233     //if (die->GetTreeList()) fListTree.Add(const_cast<THashList*>(die->GetTreeList()));
 234     ///if (die->GetTreeList()) fTree = (TTree*)(die->GetTreeManager()->GetSingleTree());
 235   }
 236
 237   Int_t cuts=fListDielectron.GetEntries();
 238   Int_t nbins=kNbinsEvent+2*cuts;
 239   if (!fEventStat){
 240
 241     fEventStat=new TH1D(Form("hEventStat_%s",fName.Data()),"Event statistics",nbins,0,nbins);
 242     fEventStat->GetXaxis()->SetBinLabel(1,"Before Phys. Sel.");
 243     fEventStat->GetXaxis()->SetBinLabel(2,"After Phys. Sel.");
 244
 245     //default names
 246     fEventStat->GetXaxis()->SetBinLabel(3,"Bin3 not used");
 247     fEventStat->GetXaxis()->SetBinLabel(4,"Bin4 not used");
 248     fEventStat->GetXaxis()->SetBinLabel(5,"Bin5 not used");
 249
 250     if (fTriggerOnV0AND&&isESD) fEventStat->GetXaxis()->SetBinLabel(3,"V0and triggers");
 251     if (fEventFilter) fEventStat->GetXaxis()->SetBinLabel(4,"After Event Filter");
 252     if (fRejectPileup) fEventStat->GetXaxis()->SetBinLabel(5,"After Pileup rejection");
 253
 254     for (Int_t i=0; i<cuts; ++i){
 255       fEventStat->GetXaxis()->SetBinLabel((kNbinsEvent+1)+2*i,Form("#splitline{1 candidate}{%s}",fListDielectron.At(i)->GetName()));
 256       fEventStat->GetXaxis()->SetBinLabel((kNbinsEvent+2)+2*i,Form("#splitline{With >1 candidate}{%s}",fListDielectron.At(i)->GetName()));
 257     }
 258   }
 259
 260   if (!fTriggerAnalysis) fTriggerAnalysis=new AliTriggerAnalysis;
 261   fTriggerAnalysis->EnableHistograms();
 262   fTriggerAnalysis->SetAnalyzeMC(AliDielectronMC::Instance()->HasMC());
 263
 264
 265   //// this is just test
 266   //// I would like to see dE/dx, pT, and so on...
 267
 268   TList *tQAElectron = new TList();
 269   tQAElectron->SetName("QAElectron");
 270   tQAElectron->SetOwner();
 271
 272
 273   int nbinx=400;
 274   float max_x=20;
 275   float min_x=0.2;
 276   float binw = (TMath::Log(max_x)-TMath::Log(min_x))/nbinx;
 277   double xbin[401];
 278   for(int ii=0;ii<nbinx+1;ii++){
 279     xbin[ii] = TMath::Exp(TMath::Log(min_x) + 0.5*binw+binw*ii);
 280   }
 281
 282
 283   //// my histo
 284   fEvent = new TH1D("Event","Number of Events",   60,0,60);
 285   tQAElectron->Add(fEvent);
 286   //fdEdXvsPt = new TH2D("dEdXvsPt","dE/dX vs. PT of TPC", 400,0, 20, 2000,0,200);
 287   fdEdXvsPt = new TH2D("dEdXvsPt","dE/dX vs. PT of TPC", nbinx, xbin, 2000,0,200);
 288   tQAElectron->Add(fdEdXvsPt);
 289   fdEdXnSigmaElecvsPt = new TH2D("fdEdXnSigmaElecvsPt"," dE/dX normalized to electron vs. pT of TPC",
 290                                  //                              400, 0, 20, 2000, -10, 10);
 291                                  nbinx, xbin, 2000, -10, 10);
 292   tQAElectron->Add(fdEdXnSigmaElecvsPt);
 293   fTOFbetavsPt = new TH2D("fTOFbetavsPt","TOF beta vs. p", 400, 0, 20, 1200, 0, 1.2);
 294   tQAElectron->Add(fTOFbetavsPt);
 295   fTOFnSigmaElecvsPt = new TH2D("fTOFnSigmaElecvsPt","TOF nsigma for electron", 400, 0, 20, 2000, -10, 10);
 296   tQAElectron->Add(fTOFnSigmaElecvsPt);
 297
 298   fTPCcrossedRowsvsPt = new TH2D("fTTPCcrossedRowsvsPt","TPC crossed rows", 400, 0, 20, 160,0,160);
 299   tQAElectron->Add(fTPCcrossedRowsvsPt);
 300   fTPCchi2vsPt = new TH2D("fTTPCchi2RowsvsPt","TPC chi2", 400, 0, 20, 1000,0,200);
 301   tQAElectron->Add(fTPCchi2vsPt);
 302
 303
 304   fListHistos.Add(tQAElectron);
 305
 306   PostData(1, &fListHistos);
 307   PostData(2, &fListCF);
 308   PostData(3, fEventStat);
 309   //PostData(4, &fListTree);
 310
 311   //PostData(1,&fListTree);
 312   fTree = new TTree(Form("tree_%s",fName.Data()),"single");
 313   SetBranches(fTree);
 314
 315   PostData(4,fTree);
 316
 317
 318   ////// basic cuts
 319   fCutsMother = new AliESDtrackCuts;
 320   fCutsMother->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst);
 321   fCutsMother->SetRequireTPCRefit(kTRUE);
 322   fCutsMother->SetRequireITSRefit(kTRUE);
 323   fCutsMother->SetMaxDCAToVertexZ(3.0);
 324   fCutsMother->SetMaxDCAToVertexXY(1.0);
 325   fCutsMother->SetEtaRange( -0.9 , 0.9 );
 326   fCutsMother->SetAcceptKinkDaughters(kFALSE);
 327   fCutsMother->SetPtRange(0.2,10);
 328   fCutsMother->SetMinNClustersTPC(70);
 329   fCutsMother->SetMaxChi2PerClusterTPC(4);
 330
 331
 332   //lee yang zeros event plane
 333   //fLyzEp = new AliFlowLYZEventPlane() ;
 334   //fLyzEp-> Init();
 335
 336   fkTriggerInfo = new TObjArray(100);
 337
 338   fNEvent = 0;
 339   fkNPar=0;
 340   cout<<" ************** AliAnalysisTaskMultiDielectron::UserCreateOutputObjects End ***********"<<endl;
 341 }
 342
 343 //_________________________________________________________________________________
 344 void AliAnalysisTaskMultiDielectronNewTaku::UserExec(Option_t *)
 345 {
 346   //
 347   // Main loop. Called for every event
 348   //
 349   if(fNEvent%100==0){
 350     cout<<"Processing event "<<fNEvent<<endl;
 351   }
 352   fNEvent++;
 353
 354   //cout<<"Start UserExec"<<endl;
 355
 356   if (fListHistos.IsEmpty()&&fListCF.IsEmpty()) return;
 357
 358   AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
 359   Bool_t isESD=man->GetInputEventHandler()->IsA()==AliESDInputHandler::Class();
 360   Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class();
 361
 362   AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
 363   if (!inputHandler) return;
 364
 365   if ( inputHandler->GetPIDResponse() ){
 366     AliDielectronVarManager::SetPIDResponse( inputHandler->GetPIDResponse() );
 367   } else {
 368     //load esd pid bethe bloch parameters depending on the existance of the MC handler
 369     // yes: MC parameters
 370     // no:  data parameters
 371     //ESD case
 372     if (isESD){
 373       if (!AliDielectronVarManager::GetESDpid()){
 374         if (AliDielectronMC::Instance()->HasMC()) {
 375           AliDielectronVarManager::InitESDpid();
 376         } else {
 377           AliDielectronVarManager::InitESDpid(1);
 378           /*
 379           Double_t fAlephParam[5]={2.11543/50,
 380                                    20.3394,
 381                                    5.0411e-11,
 382                                    2.15543,
 383                                    2.88663};
 384           */
 385           Double_t fAlephParam[5]={2.11543/122,
 386                                    42.3394,
 387                                    2.0411e-22,
 388                                    2.25543,
 389                                    6.89
 390           };
 391
 392
 393
 394
 395
 396           AliESDpid *fESDpid = new AliESDpid();
 397           fESDpid->GetTPCResponse().SetBetheBlochParameters(fAlephParam[0],
 398                                                             fAlephParam[1],
 399                                                             fAlephParam[2],
 400                                                             fAlephParam[3],
 401                                                             fAlephParam[4]);
 402           AliDielectronVarManager::SetESDpid(fESDpid);
 403         }
 404       }
 405     }
 406     //AOD case
 407     if (isAOD){
 408       if (!AliDielectronVarManager::GetAODpidUtil()){
 409         if (AliDielectronMC::Instance()->HasMC()) {
 410           AliDielectronVarManager::InitAODpidUtil();
 411         } else {
 412           AliDielectronVarManager::InitAODpidUtil(1);
 413         }
 414       }
 415     }
 416   }
 417
 418
 419
 420   /*
 421   AliESDInputHandler *esdHandler=0x0;
 422   if ( (esdHandler=dynamic_cast<AliESDInputHandler*>(man->GetInputEventHandler())) && esdHandler->GetESDpid() ){
 423     AliDielectronVarManager::SetESDpid(esdHandler->GetESDpid());
 424   } else {
 425     //load esd pid bethe bloch parameters depending on the existance of the MC handler
 426     // yes: MC parameters
 427     // no:  data parameters
 428     if (!AliDielectronVarManager::GetESDpid()){
 429       if (AliDielectronMC::Instance()->HasMC()) {
 430         AliDielectronVarManager::InitESDpid();
 431       } else {
 432         AliDielectronVarManager::InitESDpid(1);
 433       }
 434     }
 435   }
 436   */
 437
 438   //////////////////////////////////////////
 439   /////////////////////////////////////////
 440   // just copy from hor
 441   AliESDEvent *fESD = dynamic_cast<AliESDEvent*>(InputEvent());
 442
 443   AliESDRun *fRun = (AliESDRun*)fESD->GetESDRun();
 444   fMag = fRun->GetMagneticField();
 445   if(fRun){
 446     for(int itr=0; itr<AliESDRun::kNTriggerClasses;itr++){
 447       fkTrigName = new TObjString();
 448       fkTrigName->SetString(fRun->GetTriggerClass(itr));
 449       //cout<<itr<<" "<<triggername[itr]<<endl;
 450       fkTriggerInfo->AddAt(fkTrigName, itr);
 451       fkTrigName->Clear();
 452     }
 453   }
 454
 455
 456
 457   //just dump the fired trigger class
 458   if(fESD){
 459     AliESDHeader* head = (AliESDHeader*)fESD->GetHeader();
 460     //cout<<" trigger "<<head->GetFiredTriggerInputs()<<" : "<<head->GetTriggerMask()<<" : "<<fESD->GetFiredTriggerClasses()<<" "<<endl;
 461     fkTriggerMask = head->GetTriggerMask();
 462
 463     for(int itr=0; itr<AliESDRun::kNTriggerClasses;itr++){
 464       if( (head->GetTriggerMask() >> itr) & 0x1 == 1 ){
 465         fEvent->Fill(10+itr);
 466       }
 467     }
 468   }
 469
 470   if(fESD) {
 471     fEvent->Fill(0);
 472     Bool_t  isEvT = kFALSE;
 473     /*
 474     isEvT = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected()
 475              & AliVEvent::kMB);
 476     */
 477     isEvT = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected()
 478              //& AliVEvent::kSemiCentral);
 479              & AliVEvent::kCentral);
 480
 481     //AliTriggerAnalysis *fTrigAna = new AliTriggerAnalysis();
 482     if (isEvT){
 483       fEvent->Fill(1);
 484       if(fCutsEvent->IsSelected(fESD)){
 485         fEvent->Fill(2);
 486         const AliESDVertex *vertex = fESD->GetPrimaryVertex();
 487         if((vertex->GetNContributors()>2)&&(TMath::Abs(vertex->GetZ())<7)) {
 488           fEvent->Fill(3);
 489         }
 490       }
 491     }
 492
 493     //////////////////////////////////////////
 494     //// fill the number of fired triggers for each trigger types
 495     /*
 496     isEvT = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected());
 497     //AliTriggerAnalysis *fTrigAna = new AliTriggerAnalysis();
 498     if (isEvT){
 499       if(isEvT & AliVEvent::kMB) fEvent->Fill(10);
 500       if(isEvT & AliVEvent::kINT7) fEvent->Fill(11);
 501       if(isEvT & AliVEvent::kMUON) fEvent->Fill(12);
 502       if(isEvT & AliVEvent::kHighMult) fEvent->Fill(13);
 503       if(isEvT & AliVEvent::kEMC1) fEvent->Fill(14);
 504       if(isEvT & AliVEvent::kCINT5) fEvent->Fill(15);
 505       if(isEvT & AliVEvent::kMUSPB) fEvent->Fill(16);
 506       if(isEvT & AliVEvent::kMUSHPB) fEvent->Fill(17);
 507       if(isEvT & AliVEvent::kMuonLikePB) fEvent->Fill(18);
 508       if(isEvT & AliVEvent::kMuonUnlikePB) fEvent->Fill(19);
 509       if(isEvT & AliVEvent::kEMC7) fEvent->Fill(20);
 510       if(isEvT & AliVEvent::kMUS7) fEvent->Fill(21);
 511       if(isEvT & AliVEvent::kPHI1) fEvent->Fill(22);
 512       if(isEvT & AliVEvent::kPHOSPb) fEvent->Fill(23);
 513       if(isEvT & AliVEvent::kEMCEJE) fEvent->Fill(24);
 514       if(isEvT & AliVEvent::kEMCEGA) fEvent->Fill(25);
 515       if(isEvT & AliVEvent::kCentral) fEvent->Fill(26);
 516       if(isEvT & AliVEvent::kSemiCentral) fEvent->Fill(27);
 517       if(isEvT & AliVEvent::kDG5) fEvent->Fill(28);
 518       if(isEvT & AliVEvent::kZED) fEvent->Fill(29);
 519       if(isEvT & AliVEvent::kAny) fEvent->Fill(30);
 520     }
 521     */
 522   }
 523   //////////////////////////////////////////
 524   //////////////////////////////////////////
 525
 526
 527   // Was event selected ?
 528   UInt_t isSelected = AliVEvent::kAny;
 529   if( fSelectPhysics && inputHandler && inputHandler->GetEventSelection() ) {
 530     isSelected = inputHandler->IsEventSelected();
 531     isSelected&=fTriggerMask;
 532   }
 533
 534   //Before physics selection
 535   fEventStat->Fill(kAllEvents);
 536   if (isSelected==0) {
 537     PostData(3,fEventStat);
 538     return;
 539   }
 540   //after physics selection
 541   fEventStat->Fill(kSelectedEvents);
 542
 543   //V0and
 544   if (fTriggerOnV0AND&&isESD){
 545     //if (!fTriggerAnalysis->IsOfflineTriggerFired(static_cast<AliESDEvent*>(InputEvent()), AliTriggerAnalysis::kV0AND)) return;
 546   }
 547   fEventStat->Fill(kV0andEvents);
 548
 549   //event filter
 550   if (fEventFilter) {
 551     //if (!fEventFilter->IsSelected(InputEvent())) return;
 552   }
 553   fEventStat->Fill(kFilteredEvents);
 554
 555   //pileup
 556   if (fRejectPileup){
 557     if (InputEvent()->IsPileupFromSPD(3,0.8,3.,2.,5.)) return;
 558   }
 559   fEventStat->Fill(kPileupEvents);
 560
 561
 562   Bool_t isEvT1 = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected()
 563                    & AliVEvent::kCentral);
 564
 565   Bool_t isEvT2 = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected()
 566                    & AliVEvent::kSemiCentral);
 567
 568
 569   Bool_t isEvT3 = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected()
 570                    & AliVEvent::kMB);
 571
 572   fkTriggerCent = 0;
 573   if(!isEvT1 && !isEvT2 && !isEvT3){
 574     return ;
 575   }else{
 576     if(isEvT1){
 577       fkTriggerCent += 100;
 578     }
 579     if(isEvT2){
 580       fkTriggerCent += 10;
 581     }
 582     if(isEvT3){
 583       fkTriggerCent += 1;
 584     }
 585   }
 586
 587   //bz for AliKF
 588   Double_t bz = InputEvent()->GetMagneticField();
 589   AliKFParticle::SetField( bz );
 590
 591   AliDielectronPID::SetCorrVal((Double_t)InputEvent()->GetRunNumber());
 592
 593   FillEvent(InputEvent());
 594   fkNPar = 0;
 595
 596   //Process event in all AliDielectron instances
 597   TIter nextDie(&fListDielectron);
 598   AliDielectronTaku *die=0;
 599   Int_t idie=0;
 600   while ( (die=static_cast<AliDielectronTaku*>(nextDie())) ){
 601     die->Process(InputEvent());
 602     if (die->HasCandidates()){
 603       Int_t ncandidates=die->GetPairArray(1)->GetEntriesFast();
 604       if (ncandidates==1) fEventStat->Fill((kNbinsEvent)+2*idie);
 605       else if (ncandidates>1) fEventStat->Fill((kNbinsEvent+1)+2*idie);
 606     }
 607     AliDielectronVarManager::Fill(InputEvent(), fgValues);
 608     //Fill track information, separately for the track array candidates
 609     for (Int_t ii=0; ii<2; ++ii){
 610       TObjArray *obj = (TObjArray*)die->GetTrackArray(ii);
 611       Int_t ntracks=obj->GetEntriesFast();
 612       for (Int_t itrack=0; itrack<ntracks; ++itrack){
 613         ////////////////////////////////////////////////////////////////////
 614         AliDielectronVarManager::Fill(obj->UncheckedAt(itrack), fgValues);
 615         ////////////////////////////////////////////////////////////////////
 616         AliVTrack *trk = static_cast<AliVTrack*>(obj->UncheckedAt(itrack));
 617         double par[3] ;
 618         MomentumEnergyMatch(trk, par);
 619         fgValues[AliDielectronVarManager::kE] = par[0];
 620         fgValues[AliDielectronVarManager::kDeltaEta] = par[1];
 621         fgValues[AliDielectronVarManager::kDeltaPhi] = par[2];
 622         /*
 623         if(par[0]<0){
 624           continue;
 625         }
 626         */
 627
 628         AliESDtrack *esdtrack = static_cast<AliESDtrack*>(obj->UncheckedAt(itrack));
 629         Double_t dca[2]={-999.,-999.};
 630         Double_t cov[3]={-999.,-999.,-999.};
 631         Double_t kBeampiperadius=3.;
 632         esdtrack->PropagateToDCA(InputEvent()->GetPrimaryVertex(),
 633                                  InputEvent()->GetMagneticField(), kBeampiperadius, dca, cov);
 634         fgValues[AliDielectronVarManager::kLegDist] = dca[1];
 635         fgValues[AliDielectronVarManager::kLegDistXY] = dca[0];
 636         fgValues[AliDielectronVarManager::kNclsTPC] = esdtrack->GetTPCCrossedRows();
 637
 638         /*
 639         ///// KF analysis
 640         AliKFParticle kfTrack = AliKFParticle(*trk, 11); //assuming electron //charge is from trk
 641         /// i would like to store
 642         /// X, Y, Z, Px, Py, Pz, S(decay length/mom), Chi2, NDF
 643         if(kfTrack.GetNDF()!=0) fgValues[AliDielectronVarManager::kChi2NDF] = kfTrack.GetChi2()/kfTrack.GetNDF();
 644         fgValues[AliDielectronVarManager::kDecayLength] = kfTrack.GetS();
 645         fgValues[AliDielectronVarManager::kR] = kfTrack.GetR();
 646         fgValues[AliDielectronVarManager::kThetaHE] = kfTrack.GetX();
 647         fgValues[AliDielectronVarManager::kPhiHE] = kfTrack.GetY();
 648         fgValues[AliDielectronVarManager::kThetaCS] = kfTrack.GetZ();
 649         fgValues[AliDielectronVarManager::kPhiCS] = kfTrack.GetPhi();
 650         fgValues[AliDielectronVarManager::kITSsignalSSD1] = kfTrack.GetPx();
 651         fgValues[AliDielectronVarManager::kITSsignalSSD2] = kfTrack.GetPy();
 652         fgValues[AliDielectronVarManager::kITSsignalSDD1] = kfTrack.GetPz();
 653         fgValues[AliDielectronVarManager::kITSsignalSDD2] = kfTrack.GetP();
 654         */
 655         ////////////////////////////////////////////////////////////////////
 656         for(int ich=0;ich<AliDielectronVarManager::kNMaxValues; ich++){
 657           fgData[ich][fkNPar] = fgValues[ich];
 658         }
 659         fkNPar++;
 660       }
 661     }
 662     fkNCut = idie;
 663     ++idie;
 664     fTree->Fill();
 665   }
 666
 667   //////////////////////////////////////////////////////////////////////////
 668   /////////////////////////////////////////////////////////////////////////
 669   //////////////////////////////////////////////////////////////////////////
 670
 671   //// fillback to single particle without trackcuts
 672   for (Int_t iTracks = 0; iTracks < fESD->GetNumberOfTracks(); iTracks++) {
 673     AliESDtrack* track = fESD->GetTrack(iTracks);
 674     if (!track) {
 675       Printf("ERROR: Could not receive track %d", iTracks);
 676       continue;
 677     }
 678     if(!fCutsMother->AcceptTrack(track)) continue;
 679     fdEdXvsPt->Fill(track->GetTPCmomentum(), track->GetTPCsignal());
 680     fdEdXnSigmaElecvsPt->Fill(track->GetTPCmomentum(),
 681                               AliDielectronVarManager::GetESDpid()->NumberOfSigmasTPC(track,
 682                                                                                       AliPID::kElectron)
 683                               -AliDielectronPID::GetCorrVal());
 684
 685     fTPCcrossedRowsvsPt->Fill(track->GetTPCmomentum(), track->GetTPCCrossedRows());
 686     fTPCchi2vsPt->Fill(track->GetTPCmomentum(), track->GetTPCchi2());
 687
 688     /// for beta caliculaton
 689     Double_t l = track->GetIntegratedLength();  // cm
 690     Double_t t = track->GetTOFsignal();
 691     Double_t t0 = AliDielectronVarManager::GetESDpid()->GetTOFResponse().GetTimeZero(); // ps
 692     Double_t beta = 0;
 693     if( (l < 360. || l > 800.) || (t <= 0.) || (t0 >999990.0) ) {
 694       beta;
 695     }
 696     else {
 697       t -= t0; // subtract the T0
 698       l *= 0.01;  // cm ->m
 699       t *= 1e-12; //ps -> s
 700
 701       Double_t v = l / t;
 702       beta = v / TMath::C();
 703     }
 704
 705     fTOFbetavsPt->Fill(track->GetTPCmomentum(), beta);
 706     //// electron cuts //////
 707     if(fabs(AliDielectronVarManager::GetESDpid()->NumberOfSigmasTPC(track,AliPID::kElectron)
 708             -AliDielectronPID::GetCorrVal())<3){
 709       fTOFnSigmaElecvsPt->Fill(track->GetTPCmomentum(),
 710                                AliDielectronVarManager::GetESDpid()->NumberOfSigmasTOF(track,
 711                                                                                        AliPID::kElectron));
 712     }
 713   }
 714
 715
 716
 717   //cout<<idie<<endl;
 718
 719   PostData(1, &fListHistos);
 720   PostData(2, &fListCF);
 721   PostData(3,fEventStat);
 722   //PostData(4, &fListTree);
 723   //PostData(1, &fListTree);
 724   PostData(4, fTree);
 725 }
 726
 727 //_________________________________________________________________________________
 728 void AliAnalysisTaskMultiDielectronNewTaku::FinishTaskOutput()
 729 {
 730   //
 731   // Write debug tree
 732   //
 733   cout<<" ******* AliAnalysisTaskMultiDielectronNewTaku::FinishTaskOutput() *****"<<endl;
 734   TIter nextDie(&fListDielectron);
 735   AliDielectronTaku *die=0;
 736   while ( (die=static_cast<AliDielectronTaku*>(nextDie())) ){
 737     die->SaveDebugTree();
 738   }
 739 }
 740
 741 //_________________________________________________________________________________
 742 void AliAnalysisTaskMultiDielectronNewTaku::MomentumEnergyMatch(const AliVParticle *track, double *par){
 743
 744   Float_t  clsPos[3];
 745   Double_t trkPos[3];
 746   Double_t matchclsE = -9999.9;
 747
 748   const AliESDtrack *esdtrack = dynamic_cast<const AliESDtrack *>(track);
 749   AliESDEvent *evt = (AliESDEvent*)esdtrack->GetESDEvent();
 750   Double_t  magF = evt->GetMagneticField();
 751   Double_t magSign = 1.0;
 752   if(magF<0)magSign = -1.0;
 753   if (!TGeoGlobalMagField::Instance()->GetField()) {
 754     printf("Loading field map...\n");
 755     //AliMagF* field = new AliMagF("Maps","Maps", 1., 1., AliMagF::k5kG);
 756     AliMagF* field = new AliMagF("Maps","Maps", magSign, magSign, AliMagF::k5kG); // for 10d
 757     TGeoGlobalMagField::Instance()->SetField(field);
 758   }
 759
 760   AliEMCALTrack *emctrack = new AliEMCALTrack(*esdtrack);
 761   Double_t fieldB[3];
 762   emctrack->GetBxByBz(fieldB);
 763   //printf("%g %g %g \n", fieldB[0], fieldB[1], fieldB[2]);
 764   double min_r=99999.0;
 765   double min_dphi=-9999.0;
 766   double min_deta=-9999.0;
 767
 768   for(Int_t icl=0; icl<evt->GetNumberOfCaloClusters(); icl++){
 769     AliVCluster *cluster = (AliVCluster*) evt->GetCaloCluster(icl);
 770     if(!cluster->IsEMCAL()) continue;
 771     cluster->GetPosition(clsPos);
 772     if(!emctrack->PropagateToGlobal(clsPos[0],clsPos[1],clsPos[2],0.,0.) )  continue;
 773     emctrack->GetXYZ(trkPos);
 774     TVector3 clsPosVec(clsPos[0],clsPos[1],clsPos[2]);
 775     TVector3 trkPosVec(trkPos[0],trkPos[1],trkPos[2]);
 776     Double_t delEmcphi = clsPosVec.Phi()-trkPosVec.Phi();  // track cluster matching
 777     Double_t delEmceta = clsPosVec.Eta()-trkPosVec.Eta();  // track cluster matching
 778     double rmatch = sqrt(pow(delEmcphi,2)+pow(delEmceta,2));
 779     /*
 780     if(rmatch<min_r){
 781       min_r = rmatch;
 782       min_dphi = delEmcphi;
 783       min_deta = delEmceta;
 784       matchclsE = cluster->E();
 785     }
 786     */
 787     if(rmatch<0.02 && rmatch<min_r){
 788       min_r = rmatch;
 789       min_dphi = delEmcphi;
 790       min_deta = delEmceta;
 791       matchclsE = cluster->E();
 792     }
 793   }
 794   delete emctrack;
 795
 796   par[0] = matchclsE;
 797   par[1] = min_dphi;
 798   par[2] = min_deta;
 799
 800 }
 801
 802
 803 //_________________________________________________________________________________
 804 void AliAnalysisTaskMultiDielectronNewTaku::FillEvent(AliVEvent * const ev){
 805
 806   //AliKFVertex *fgKFVertex = new fgKFVertex();
 807   //if (ev && ev->GetPrimaryVertex()) fgKFVertex=new AliKFVertex(*ev->GetPrimaryVertex());
 808
 809   if(ev){
 810     fkRunNumber = ev->GetRunNumber();
 811     fkXvPrim = ev->GetPrimaryVertex()->GetX();
 812     fkYvPrim = ev->GetPrimaryVertex()->GetY();
 813     fkZvPrim = ev->GetPrimaryVertex()->GetZ();
 814     fkNTrk = ev->GetNumberOfTracks();
 815     fkNacc = AliDielectronHelper::GetNacc(ev);
 816     fkNaccTrcklts = AliDielectronHelper::GetNaccTrcklts(ev);
 817
 818     fkZDCN1E = ev->GetZDCN1Energy();
 819     fkZDCP1E = ev->GetZDCP1Energy();
 820     fkZDCN2E = ev->GetZDCN2Energy();
 821     fkZDCP2E = ev->GetZDCP2Energy();
 822   }
 823   AliESDEvent *fESD = dynamic_cast<AliESDEvent*>(ev);
 824
 825   fkCentrality=-1;
 826   AliCentrality *esdCentrality = const_cast<AliESDEvent*>(fESD)->GetCentrality();
 827   if (esdCentrality) fkCentrality = esdCentrality->GetCentralityPercentile("V0M");
 828
 829   if(fESD->GetPrimaryVertex()){
 830     fkXRes = fESD->GetPrimaryVertex()->GetXRes();
 831     fkYRes = fESD->GetPrimaryVertex()->GetYRes();
 832     fkZRes = fESD->GetPrimaryVertex()->GetZRes();
 833   }
 834
 835   if(fESD->GetVZEROData()){
 836     fkV0A=0;
 837     fkV0C=0;
 838     for(int ich=0;ich<32;ich++){
 839       fkV0A += fESD->GetVZEROData()->GetMultiplicityV0A(ich);
 840       fkV0C += fESD->GetVZEROData()->GetMultiplicityV0C(ich);
 841     }
 842   }
 843
 844   ///////////////////////////////////////////////////////////////////////
 845   ///////////////////////////////////////////////////////////////////////
 846   /////////////// get event plane ///////////////////////////////////////
 847   ///////////////////////////////////////////////////////////////////////
 848   AliEventplane *fEventPlane = (AliEventplane*)fESD->GetEventplane();
 849   if (fEventPlane)
 850     fkRP = fEventPlane->GetEventplane("V0", fESD,2);
 851
 852   /*
 853   fkRP=-999; fkRPQx=-999; fkRPQy=-999;
 854   fkRPsub1=-999; fkRPsub1Qx=-999; fkRPsub1Qy=-999;
 855   fkRPsub2=-999; fkRPsub2Qx=-999; fkRPsub2Qy=-999;
 856
 857   if(fEventPlane){
 858
 859     fkRP = fEventPlane->GetEventplane("Q");
 860     if(fEventPlane->GetQVector()){
 861       fkRPQx = fEventPlane->GetQVector()->X();
 862       fkRPQy = fEventPlane->GetQVector()->Y();
 863     }
 864     if(fEventPlane->GetQsub1()){
 865       fkRPsub1 = fEventPlane->GetQsub1()->Phi()/2;
 866       fkRPsub1Qx = fEventPlane->GetQsub1()->X();
 867       fkRPsub1Qy = fEventPlane->GetQsub1()->Y();
 868     }
 869     if(fEventPlane->GetQsub2()){
 870       fkRPsub2 = fEventPlane->GetQsub2()->Phi()/2;
 871       fkRPsub2Qx = fEventPlane->GetQsub2()->X();
 872       fkRPsub2Qy = fEventPlane->GetQsub2()->Y();
 873     }
 874
 875     fkQsubRes = fEventPlane->GetQsubRes();
 876      cout<<fkRP<<" "<<fkRPQx<<" "<<fkRPQy<<" "<<fkRPsub1<<" "<<fkRPsub1Qx<<" "<<fkRPsub1Qy<<" "
 877         <<fkRPsub2<<" "<<fkRPsub2Qx<<" "<<fkRPsub2Qy<<endl;
 878
 879     cout<<fEventPlane->GetEventplane("Q")<<endl;
 880     TVector2 *vec2 = (TVector2*)fEventPlane->GetQVector();
 881     if(!vec2){ cout<<" no EP information "<<endl;}
 882     else{
 883       Double_t dRPEP = vec2->Phi()/2;
 884       cout<<dRPEP<<endl;
 885     }
 886
 887
 888   }
 889
 890   fFlowEvent = dynamic_cast<AliFlowEventSimple*>(GetInputData(0));
 891
 892   if (fFlowEvent) {
 893     //get the Q vector from the FlowEvent
 894     AliFlowVector vQ = fFlowEvent->GetQ();
 895     //if (vQ.X()== 0. && vQ.Y()== 0. ) { cout<<"Q vector is NULL!"<<endl; } //coding violation
 896     //Weight with the multiplicity
 897     Double_t dQX = 0.;
 898     Double_t dQY = 0.;
 899     if (TMath::AreEqualAbs(vQ.GetMult(),0.0,1e-10)) {
 900       dQX = vQ.X()/vQ.GetMult();
 901       dQY = vQ.Y()/vQ.GetMult();
 902     } else {cerr<<"vQ.GetMult() is zero!"<<endl; }
 903     vQ.Set(dQX,dQY);
 904     *fQsum += vQ;
 905     fQ2sum += vQ.Mod2();
 906     fLyzEp->CalculateRPandW(vQ);
 907     Double_t dWR = fLyzEp->GetWR();
 908
 909     Double_t dRP = fLyzEp->GetPsi();
 910     //plot difference between event plane from EP-method and LYZ-method
 911     Double_t dRPEP = vQ.Phi()/2;                              //gives distribution from (0 to pi)
 912     //Double_t dRPEP = 0.5*TMath::ATan2(vQ.Y(),vQ.X());       //gives distribution from (-pi/2 to pi/2)
 913
 914     Double_t dDeltaPhi = dRPEP - dRP;
 915     if (dDeltaPhi < 0.) { dDeltaPhi += TMath::Pi(); }        //to shift distribution from (-pi/2 to pi/2) to (0 to pi)
 916
 917     cout<<dRPEP<<" "<<dRP<<" "<<endl;
 918
 919   }else{
 920     cout<<" no fFlowEvent "<<endl;
 921   }
 922   */
 923
 924
 925
 926
 927
 928 }
 929
 930
 931 //_________________________________________________________________________________
 932 void AliAnalysisTaskMultiDielectronNewTaku::SetBranches(TTree *t){
 933
 934   t->Branch("kNEvent",&fNEvent,"kNEvent/I");
 935   t->Branch("kMag",&fMag,"kMag/D");
 936   t->Branch("fkTriggerInfo","TObjArray",&fkTriggerInfo);
 937   t->Branch("kTriggerMask",&fkTriggerMask,"kTriggerMask/D");
 938   t->Branch("kTriggerCent",&fkTriggerCent,"kTriggerCent/I");
 939   t->Branch("fkNCut", &fkNCut, "fkNCut/D");
 940   t->Branch("fkRunNumber", &fkRunNumber, "fkRunNumber/D");
 941   t->Branch("fkCentrality", &fkCentrality, "fkCentrality/D");
 942   t->Branch("fkXvPrim", &fkXvPrim, "fkXvPrim/D");
 943   t->Branch("fkYvPrim", &fkYvPrim, "fkYvPrim/D");
 944   t->Branch("fkZvPrim", &fkZvPrim, "fkZvPrim/D");
 945   t->Branch("fkXRes", &fkXRes, "fkXRes/D");
 946   t->Branch("fkYRes", &fkYRes, "fkYRes/D");
 947   t->Branch("fkZRes", &fkZRes, "fkZRes/D");
 948   t->Branch("fkNTrk", &fkNTrk, "fkNTrk/D");
 949   t->Branch("fkTracks", &fkTracks, "fkTracks/D");
 950   t->Branch("fkNacc", &fkNacc, "fkNacc/D");
 951   t->Branch("fkNaccTrcklts", &fkNaccTrcklts, "fkNaccTrcklts/D");
 952   t->Branch("fkNch", &fkNch, "fkNch/D");
 953   t->Branch("fkZDCN1E", &fkZDCN1E, "fkZDCN1E/D");
 954   t->Branch("fkZDCP1E", &fkZDCP1E, "fkZDCP1E/D");
 955   t->Branch("fkZDCN2E", &fkZDCN2E, "fkZDCN2E/D");
 956   t->Branch("fkZDCP2E", &fkZDCP2E, "fkZDCP2E/D");
 957   t->Branch("fkV0A", &fkV0A, "fkV0A/D");
 958   t->Branch("fkV0C", &fkV0C, "fkV0C/D");
 959
 960   t->Branch("fkRP",&fkRP,"fkRP/D");
 961   t->Branch("fkRPQx",&fkRPQx,"fkRPQx/D");
 962   t->Branch("fkRPQy",&fkRPQy,"fkRPQy/D");
 963   t->Branch("fkRPsub1",&fkRPsub1,"fkRPsub1/D");
 964   t->Branch("fkRPsub1Qx",&fkRPsub1Qx,"fkRPsub1Qx/D");
 965   t->Branch("fkRPsub1Qy",&fkRPsub1Qy,"fkRPsub1Qy/D");
 966   t->Branch("fkRPsub2",&fkRPsub2,"fkRPsub2/D");
 967   t->Branch("fkRPsub2Qx",&fkRPsub2Qx,"fkRPsub2Qx/D");
 968   t->Branch("fkRPsub2Qy",&fkRPsub2Qy,"fkRPsub2Qy/D");
 969   t->Branch("fkQsubRes",&fkQsubRes,"fkQsubRes/D");
 970
 971
 972   t->Branch("fkNPar", &fkNPar, "fkNPar/I");
 973   t->Branch("kPx",fgData[AliDielectronVarManager::kPx],"kPx[fkNPar]/D");
 974   t->Branch("kPy",fgData[AliDielectronVarManager::kPy],"kPy[fkNPar]/D");
 975   t->Branch("kPz",fgData[AliDielectronVarManager::kPz],"kPz[fkNPar]/D");
 976   t->Branch("kPt",fgData[AliDielectronVarManager::kPt],"kPt[fkNPar]/D");
 977   t->Branch("kP",fgData[AliDielectronVarManager::kP],"kP[fkNPar]/D");
 978   t->Branch("kXv",fgData[AliDielectronVarManager::kXv],"kXv[fkNPar]/D");
 979   t->Branch("kYv",fgData[AliDielectronVarManager::kYv],"kYv[fkNPar]/D");
 980   t->Branch("kZv",fgData[AliDielectronVarManager::kZv],"kZv[fkNPar]/D");
 981   t->Branch("kOneOverPt",fgData[AliDielectronVarManager::kOneOverPt],"kOneOverPt[fkNPar]/D");
 982   t->Branch("kPhi",fgData[AliDielectronVarManager::kPhi],"kPhi[fkNPar]/D");
 983   t->Branch("kTheta",fgData[AliDielectronVarManager::kTheta],"kTheta[fkNPar]/D");
 984   t->Branch("kEta",fgData[AliDielectronVarManager::kEta],"kEta[fkNPar]/D");
 985   t->Branch("kY",fgData[AliDielectronVarManager::kY],"kY[fkNPar]/D");
 986   t->Branch("kE",fgData[AliDielectronVarManager::kE],"kE[fkNPar]/D");
 987   t->Branch("kM",fgData[AliDielectronVarManager::kM],"kM[fkNPar]/D");
 988   t->Branch("kCharge",fgData[AliDielectronVarManager::kCharge],"kCharge[fkNPar]/D");
 989   t->Branch("kNclsITS",fgData[AliDielectronVarManager::kNclsITS],"kNclsITS[fkNPar]/D");
 990   t->Branch("kNclsTPC",fgData[AliDielectronVarManager::kNclsTPC],"kNclsTPC[fkNPar]/D");
 991   t->Branch("kNclsTPCiter1",fgData[AliDielectronVarManager::kNclsTPCiter1],"kNclsTPCiter1[fkNPar]/D");
 992   t->Branch("kNFclsTPC",fgData[AliDielectronVarManager::kNFclsTPC],"kNFclsTPC[fkNPar]/D");
 993   t->Branch("kNFclsTPCr",fgData[AliDielectronVarManager::kNFclsTPCr],"kNFclsTPCr[fkNPar]/D");
 994   t->Branch("kNFclsTPCrFrac",fgData[AliDielectronVarManager::kNFclsTPCrFrac],"kNFclsTPCrFrac[fkNPar]/D");
 995   t->Branch("kTPCsignalN",fgData[AliDielectronVarManager::kTPCsignalN],"kTPCsignalN[fkNPar]/D");
 996   t->Branch("kTPCsignalNfrac",fgData[AliDielectronVarManager::kTPCsignalNfrac],"kTPCsignalNfrac[fkNPar]/D");
 997   t->Branch("kTPCchi2Cl",fgData[AliDielectronVarManager::kTPCchi2Cl],"kTPCchi2Cl[fkNPar]/D");
 998   t->Branch("kTrackStatus",fgData[AliDielectronVarManager::kTrackStatus],"kTrackStatus[fkNPar]/D");
 999   t->Branch("kNclsTRD",fgData[AliDielectronVarManager::kNclsTRD],"kNclsTRD[fkNPar]/D");
1000   t->Branch("kTRDntracklets",fgData[AliDielectronVarManager::kTRDntracklets],"kTRDntracklets[fkNPar]/D");
1001   t->Branch("kTRDpidQuality",fgData[AliDielectronVarManager::kTRDpidQuality],"kTRDpidQuality[fkNPar]/D");
1002   t->Branch("kTRDprobEle",fgData[AliDielectronVarManager::kTRDprobEle],"kTRDprobEle[fkNPar]/D");
1003   t->Branch("kTRDprobPio",fgData[AliDielectronVarManager::kTRDprobPio],"kTRDprobPio[fkNPar]/D");
1004   t->Branch("kImpactParXY",fgData[AliDielectronVarManager::kImpactParXY],"kImpactParXY[fkNPar]/D");
1005   t->Branch("kImpactParZ",fgData[AliDielectronVarManager::kImpactParZ],"kImpactParZ[fkNPar]/D");
1006   t->Branch("kTrackLength",fgData[AliDielectronVarManager::kTrackLength],"kTrackLength[fkNPar]/D");
1007   t->Branch("kPdgCode",fgData[AliDielectronVarManager::kPdgCode],"kPdgCode[fkNPar]/D");
1008   t->Branch("kPdgCodeMother",fgData[AliDielectronVarManager::kPdgCodeMother],"kPdgCodeMother[fkNPar]/D");
1009   t->Branch("kPdgCodeGrandMother",fgData[AliDielectronVarManager::kPdgCodeGrandMother],"kPdgCodeGrandMother[fkNPar]/D");
1010   t->Branch("kNumberOfDaughters",fgData[AliDielectronVarManager::kNumberOfDaughters],"kNumberOfDaughters[fkNPar]/D");
1011   t->Branch("kHaveSameMother",fgData[AliDielectronVarManager::kHaveSameMother],"kHaveSameMother[fkNPar]/D");
1012   t->Branch("kIsJpsiPrimary",fgData[AliDielectronVarManager::kIsJpsiPrimary],"kIsJpsiPrimary[fkNPar]/D");
1013   t->Branch("kITSsignal",fgData[AliDielectronVarManager::kITSsignal],"kITSsignal[fkNPar]/D");
1014   t->Branch("kITSsignalSSD1",fgData[AliDielectronVarManager::kITSsignalSSD1],"kITSsignalSSD1[fkNPar]/D");
1015   t->Branch("kITSsignalSSD2",fgData[AliDielectronVarManager::kITSsignalSSD2],"kITSsignalSSD2[fkNPar]/D");
1016   t->Branch("kITSsignalSDD1",fgData[AliDielectronVarManager::kITSsignalSDD1],"kITSsignalSDD1[fkNPar]/D");
1017   t->Branch("kITSsignalSDD2",fgData[AliDielectronVarManager::kITSsignalSDD2],"kITSsignalSDD2[fkNPar]/D");
1018   t->Branch("kITSclusterMap",fgData[AliDielectronVarManager::kITSclusterMap],"kITSclusterMap[fkNPar]/D");
1019   t->Branch("kITSnSigmaEle",fgData[AliDielectronVarManager::kITSnSigmaEle],"kITSnSigmaEle[fkNPar]/D");
1020   t->Branch("kITSnSigmaPio",fgData[AliDielectronVarManager::kITSnSigmaPio],"kITSnSigmaPio[fkNPar]/D");
1021   t->Branch("kITSnSigmaMuo",fgData[AliDielectronVarManager::kITSnSigmaMuo],"kITSnSigmaMuo[fkNPar]/D");
1022   t->Branch("kITSnSigmaKao",fgData[AliDielectronVarManager::kITSnSigmaKao],"kITSnSigmaKao[fkNPar]/D");
1023   t->Branch("kITSnSigmaPro",fgData[AliDielectronVarManager::kITSnSigmaPro],"kITSnSigmaPro[fkNPar]/D");
1024   t->Branch("kPIn",fgData[AliDielectronVarManager::kPIn],"kPIn[fkNPar]/D");
1025   t->Branch("kTPCsignal",fgData[AliDielectronVarManager::kTPCsignal],"kTPCsignal[fkNPar]/D");
1026   t->Branch("kTOFsignal",fgData[AliDielectronVarManager::kTOFsignal],"kTOFsignal[fkNPar]/D");
1027   t->Branch("kTOFbeta",fgData[AliDielectronVarManager::kTOFbeta],"kTOFbeta[fkNPar]/D");
1028   t->Branch("kTPCnSigmaEle",fgData[AliDielectronVarManager::kTPCnSigmaEle],"kTPCnSigmaEle[fkNPar]/D");
1029   t->Branch("kTPCnSigmaPio",fgData[AliDielectronVarManager::kTPCnSigmaPio],"kTPCnSigmaPio[fkNPar]/D");
1030   t->Branch("kTPCnSigmaMuo",fgData[AliDielectronVarManager::kTPCnSigmaMuo],"kTPCnSigmaMuo[fkNPar]/D");
1031   t->Branch("kTPCnSigmaKao",fgData[AliDielectronVarManager::kTPCnSigmaKao],"kTPCnSigmaKao[fkNPar]/D");
1032   t->Branch("kTPCnSigmaPro",fgData[AliDielectronVarManager::kTPCnSigmaPro],"kTPCnSigmaPro[fkNPar]/D");
1033   t->Branch("kTOFnSigmaEle",fgData[AliDielectronVarManager::kTOFnSigmaEle],"kTOFnSigmaEle[fkNPar]/D");
1034   t->Branch("kTOFnSigmaPio",fgData[AliDielectronVarManager::kTOFnSigmaPio],"kTOFnSigmaPio[fkNPar]/D");
1035   t->Branch("kTOFnSigmaMuo",fgData[AliDielectronVarManager::kTOFnSigmaMuo],"kTOFnSigmaMuo[fkNPar]/D");
1036   t->Branch("kTOFnSigmaKao",fgData[AliDielectronVarManager::kTOFnSigmaKao],"kTOFnSigmaKao[fkNPar]/D");
1037   t->Branch("kTOFnSigmaPro",fgData[AliDielectronVarManager::kTOFnSigmaPro],"kTOFnSigmaPro[fkNPar]/D");
1038   t->Branch("kKinkIndex0",fgData[AliDielectronVarManager::kKinkIndex0],"kKinkIndex0[fkNPar]/D");
1039   t->Branch("kChi2NDF",fgData[AliDielectronVarManager::kChi2NDF],"kChi2NDF[fkNPar]/D");
1040   t->Branch("kDecayLength",fgData[AliDielectronVarManager::kDecayLength],"kDecayLength[fkNPar]/D");
1041   t->Branch("kR",fgData[AliDielectronVarManager::kR],"kR[fkNPar]/D");
1042   t->Branch("kOpeningAngle",fgData[AliDielectronVarManager::kOpeningAngle],"kOpeningAngle[fkNPar]/D");
1043   t->Branch("kThetaHE",fgData[AliDielectronVarManager::kThetaHE],"kThetaHE[fkNPar]/D");
1044   t->Branch("kPhiHE",fgData[AliDielectronVarManager::kPhiHE],"kPhiHE[fkNPar]/D");
1045   t->Branch("kThetaCS",fgData[AliDielectronVarManager::kThetaCS],"kThetaCS[fkNPar]/D");
1046   t->Branch("kPhiCS",fgData[AliDielectronVarManager::kPhiCS],"kPhiCS[fkNPar]/D");
1047   t->Branch("kLegDist",fgData[AliDielectronVarManager::kLegDist],"kLegDist[fkNPar]/D");
1048   t->Branch("kLegDistXY",fgData[AliDielectronVarManager::kLegDistXY],"kLegDistXY[fkNPar]/D");
1049   t->Branch("kDeltaEta",fgData[AliDielectronVarManager::kDeltaEta],"kDeltaEta[fkNPar]/D");
1050   t->Branch("kDeltaPhi",fgData[AliDielectronVarManager::kDeltaPhi],"kDeltaPhi[fkNPar]/D");
1051   t->Branch("kMerr",fgData[AliDielectronVarManager::kMerr],"kMerr[fkNPar]/D");
1052   t->Branch("kDCA",fgData[AliDielectronVarManager::kDCA],"kDCA[fkNPar]/D");
1053   t->Branch("kPairType",fgData[AliDielectronVarManager::kPairType],"kPairType[fkNPar]/D");
1054   t->Branch("kPseudoProperTime",fgData[AliDielectronVarManager::kPseudoProperTime],"kPseudoProperTime[fkNPar]/D");
1055   t->Branch("kXvPrim",fgData[AliDielectronVarManager::kXvPrim],"kXvPrim=kPairMax[fkNPar]/D");
1056   t->Branch("kYvPrim",fgData[AliDielectronVarManager::kYvPrim],"kYvPrim[fkNPar]/D");
1057   t->Branch("kZvPrim",fgData[AliDielectronVarManager::kZvPrim],"kZvPrim[fkNPar]/D");
1058   t->Branch("kXRes",fgData[AliDielectronVarManager::kXRes],"kXRes[fkNPar]/D");
1059   t->Branch("kYRes",fgData[AliDielectronVarManager::kYRes],"kYRes[fkNPar]/D");
1060   t->Branch("kZRes",fgData[AliDielectronVarManager::kZRes],"kZRes[fkNPar]/D");
1061   t->Branch("kNTrk",fgData[AliDielectronVarManager::kNTrk],"kNTrk[fkNPar]/D");
1062   t->Branch("kTracks",fgData[AliDielectronVarManager::kTracks],"kTracks[fkNPar]/D");
1063   t->Branch("kNacc",fgData[AliDielectronVarManager::kNacc],"kNacc[fkNPar]/D");
1064   t->Branch("kNaccTrcklts",fgData[AliDielectronVarManager::kNaccTrcklts],"kNaccTrcklts[fkNPar]/D");
1065   t->Branch("kNch",fgData[AliDielectronVarManager::kNch],"kNch[fkNPar]/D");
1066   t->Branch("kCentrality",fgData[AliDielectronVarManager::kCentrality],"kCentrality[fkNPar]/D");
1067   t->Branch("kNevents",fgData[AliDielectronVarManager::kNevents],"kNevents[fkNPar]/D");
1068
1069
1070 }
1071