]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGDQ/dielectron/TakuAlberica/single/AliAnalysisTaskMultiDielectronNewTaku.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'feature-movesplit'
[u/mrichter/AliRoot.git] / PWGDQ / dielectron / TakuAlberica / single / AliAnalysisTaskMultiDielectronNewTaku.cxx
CommitLineData
06f630bb 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
64ClassImp(AliAnalysisTaskMultiDielectronNewTaku)
65
66//_________________________________________________________________________________
67AliAnalysisTaskMultiDielectronNewTaku::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//_________________________________________________________________________________
129AliAnalysisTaskMultiDielectronNewTaku::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//_________________________________________________________________________________
206void 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
da9ac610 298 fTPCcrossedRowsvsPt = new TH2D("fTTPCcrossedRowsvsPt","TPC crossed rows", 400, 0, 20, 160,0,160);
06f630bb 299 tQAElectron->Add(fTPCcrossedRowsvsPt);
da9ac610 300 fTPCchi2vsPt = new TH2D("fTTPCchi2RowsvsPt","TPC chi2", 400, 0, 20, 1000,0,200);
06f630bb 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//_________________________________________________________________________________
344void 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//_________________________________________________________________________________
728void 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//_________________________________________________________________________________
742void 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//_________________________________________________________________________________
804void 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//_________________________________________________________________________________
932void 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