From 06f630bb72609da3d6f73cf7ad69a8b13222892a Mon Sep 17 00:00:00 2001 From: atoia Date: Tue, 7 Feb 2012 15:50:56 +0000 Subject: [PATCH] initial commit --- PWGDQ/dielectron/TakuAlberica/pair/ana_sgl.C | 1498 ++ PWGDQ/dielectron/TakuAlberica/pair/ana_sgl.h | 884 + .../TakuAlberica/pair/ana_sglDict.C | 1385 ++ .../TakuAlberica/pair/ana_sglDict.h | 65 + .../TakuAlberica/pair/ana_sglLinkDef.h | 9 + .../TakuAlberica/pair/get_spectrum_dir2.C | 758 + PWGDQ/dielectron/TakuAlberica/pair/hadd.C | 167 + PWGDQ/dielectron/TakuAlberica/pair/makefig.C | 181 + PWGDQ/dielectron/TakuAlberica/pair/run_all.C | 108 + PWGDQ/dielectron/TakuAlberica/pair/tmp.C | 43 + .../TakuAlberica/single/000170088.xml | 19583 ++++++++++++++++ .../single/000170088_000170088.xml | 14688 ++++++++++++ .../TakuAlberica/single/AddRunsPbPb.C | 102 + .../single/AddTaskDielectronTaku.C | 165 + .../AliAnalysisTaskMultiDielectronNewTaku.cxx | 1071 + .../AliAnalysisTaskMultiDielectronNewTaku.h | 149 + ...liAnalysisTaskMultiDielectronNewTaku_cxx.d | 212 + .../single/AliDielectronDebugTreeTaku.cxx | 211 + .../single/AliDielectronDebugTreeTaku.h | 69 + .../single/AliDielectronDebugTreeTaku_cxx.d | 179 + .../single/AliDielectronHistosTaku.cxx | 1035 + .../single/AliDielectronHistosTaku.h | 145 + .../single/AliDielectronHistosTaku_cxx.d | 196 + .../TakuAlberica/single/AliDielectronTaku.cxx | 788 + .../TakuAlberica/single/AliDielectronTaku.h | 229 + .../single/AliDielectronTaku_cxx.d | 166 + .../single/ConfigJpsi2eeDataTaku.C | 411 + .../dielectron/TakuAlberica/single/get_dedx.C | 175 + .../dielectron/TakuAlberica/single/runTaku.C | 240 + .../TakuAlberica/single/runTakuMC.C | 171 + .../single/takuv2c123456_2012_TEST.C | 104 + .../single/takuv2c123456_2012_TEST.jdl | 60 + .../single/takuv2c123456_2012_TEST.root | Bin 0 -> 156072 bytes .../single/takuv2c123456_2012_TEST.sh | 40 + .../takuv2c123456_2012_TEST_validation.sh | 82 + 35 files changed, 45369 insertions(+) create mode 100644 PWGDQ/dielectron/TakuAlberica/pair/ana_sgl.C create mode 100644 PWGDQ/dielectron/TakuAlberica/pair/ana_sgl.h create mode 100644 PWGDQ/dielectron/TakuAlberica/pair/ana_sglDict.C create mode 100644 PWGDQ/dielectron/TakuAlberica/pair/ana_sglDict.h create mode 100644 PWGDQ/dielectron/TakuAlberica/pair/ana_sglLinkDef.h create mode 100644 PWGDQ/dielectron/TakuAlberica/pair/get_spectrum_dir2.C create mode 100644 PWGDQ/dielectron/TakuAlberica/pair/hadd.C create mode 100644 PWGDQ/dielectron/TakuAlberica/pair/makefig.C create mode 100644 PWGDQ/dielectron/TakuAlberica/pair/run_all.C create mode 100644 PWGDQ/dielectron/TakuAlberica/pair/tmp.C create mode 100644 PWGDQ/dielectron/TakuAlberica/single/000170088.xml create mode 100644 PWGDQ/dielectron/TakuAlberica/single/000170088_000170088.xml create mode 100644 PWGDQ/dielectron/TakuAlberica/single/AddRunsPbPb.C create mode 100644 PWGDQ/dielectron/TakuAlberica/single/AddTaskDielectronTaku.C create mode 100644 PWGDQ/dielectron/TakuAlberica/single/AliAnalysisTaskMultiDielectronNewTaku.cxx create mode 100644 PWGDQ/dielectron/TakuAlberica/single/AliAnalysisTaskMultiDielectronNewTaku.h create mode 100644 PWGDQ/dielectron/TakuAlberica/single/AliAnalysisTaskMultiDielectronNewTaku_cxx.d create mode 100644 PWGDQ/dielectron/TakuAlberica/single/AliDielectronDebugTreeTaku.cxx create mode 100644 PWGDQ/dielectron/TakuAlberica/single/AliDielectronDebugTreeTaku.h create mode 100644 PWGDQ/dielectron/TakuAlberica/single/AliDielectronDebugTreeTaku_cxx.d create mode 100644 PWGDQ/dielectron/TakuAlberica/single/AliDielectronHistosTaku.cxx create mode 100644 PWGDQ/dielectron/TakuAlberica/single/AliDielectronHistosTaku.h create mode 100644 PWGDQ/dielectron/TakuAlberica/single/AliDielectronHistosTaku_cxx.d create mode 100644 PWGDQ/dielectron/TakuAlberica/single/AliDielectronTaku.cxx create mode 100644 PWGDQ/dielectron/TakuAlberica/single/AliDielectronTaku.h create mode 100644 PWGDQ/dielectron/TakuAlberica/single/AliDielectronTaku_cxx.d create mode 100644 PWGDQ/dielectron/TakuAlberica/single/ConfigJpsi2eeDataTaku.C create mode 100644 PWGDQ/dielectron/TakuAlberica/single/get_dedx.C create mode 100644 PWGDQ/dielectron/TakuAlberica/single/runTaku.C create mode 100644 PWGDQ/dielectron/TakuAlberica/single/runTakuMC.C create mode 100644 PWGDQ/dielectron/TakuAlberica/single/takuv2c123456_2012_TEST.C create mode 100644 PWGDQ/dielectron/TakuAlberica/single/takuv2c123456_2012_TEST.jdl create mode 100644 PWGDQ/dielectron/TakuAlberica/single/takuv2c123456_2012_TEST.root create mode 100644 PWGDQ/dielectron/TakuAlberica/single/takuv2c123456_2012_TEST.sh create mode 100644 PWGDQ/dielectron/TakuAlberica/single/takuv2c123456_2012_TEST_validation.sh diff --git a/PWGDQ/dielectron/TakuAlberica/pair/ana_sgl.C b/PWGDQ/dielectron/TakuAlberica/pair/ana_sgl.C new file mode 100644 index 00000000000..bae7be06698 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/pair/ana_sgl.C @@ -0,0 +1,1498 @@ +#define ana_sgl_cxx +#include "ana_sgl.h" +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace std; + +using std::vector; + +class etrk; + +//Buffer for event mixing +static const int NBUF=100; //depth of buffer +static const int NMix=10; //# of events mixed (for +-) +//static const int NMix=2; //# of events mixed (for +-) + + +static const int NZBIN=10; +static const int NCENT=10; +int d_ibuf[NZBIN][NCENT]; +vector d_vep[NBUF][NZBIN][NCENT]; +vector d_vem[NBUF][NZBIN][NCENT]; + +static const unsigned int MAXPOOL=150; +//static const unsigned int MAXPOOL=50; +static const int MAX_TRY=3; +deque d_poolp[NZBIN][NCENT]; +deque d_poolm[NZBIN][NCENT]; + +void reshuffle_buffer(vector &ve, + deque &pool){ + //If there is not enough electron in the pool, give up + unsigned int ne = ve.size(); + unsigned int poolsize = pool.size(); + if(poolsize < ne) { + cout <<" pool size="< .L ana_sgl.C +// Root > ana_sgl t +// Root > t.GetEntry(12); // Fill t data members with entry number 12 +// Root > t.Show(); // Show values of entry 12 +// Root > t.Show(16); // Read and show values of entry 16 +// Root > t.Loop(); // Loop on all entries +// + +// This is the loop skeleton where: +// jentry is the global entry number in the chain +// ientry is the entry number in the current Tree +// Note that the argument to GetEntry must be: +// jentry for TChain::GetEntry +// ientry for TTree::GetEntry and TBranch::GetEntry +// +// To read only selected branches, Insert statements like: +// METHOD1: +// fChain->SetBranchStatus("*",0); // disable all branches +// fChain->SetBranchStatus("branchname",1); // activate branchname +// METHOD2: replace line +// fChain->GetEntry(jentry); //read all branches +//by b_branchname->GetEntry(ientry); //read only this branch + if (fChain == 0) return; + + Long64_t nentries = fChain->GetEntriesFast(); + + Long64_t nbytes = 0, nb = 0; + for (Long64_t jentry=0; jentryGetEntry(jentry); nbytes += nb; + ana_event(ientry, jentry); + // if (Cut(ientry) < 0) continue; + } +} + +//___________________________________________ + void ana_sgl::ana_init(char *outname){ + fout = new TFile(outname,"recreate"); + char name[100]; + + hdedx_pt = new TH2D("hdedx_pt","dedx vs. pT",100,0, 10, 100, 0, 200); + hdedx_tof_elec_pt = new TH2D("hdedx_tof_elec_pt","dedx vs. pT with tof veto",100,0, 10, 100, 0, 200); + hdedx_tof_all_pt = new TH2D("hdedx_tof_all_pt","dedx vs. pT with tof veto",100,0, 10, 100, 0, 200); + hdedx_tof_elec_emc_pt = new TH2D("hdedx_tof_elec_emc_pt","dedx vs. pT with tof veto and EMC",100,0, 10, 100, 0, 200); + hdedx_tof_all_emc_pt = new TH2D("hdedx_tof_all_emc_pt","dedx vs. pT with tof veto and EMC",100,0, 10, 100, 0, 200); + hdedx_emc_pt = new TH2D("hdedx_emc_pt","dedx vs. pT with EMC",100,0, 10, 100, 0, 200); + + + hbetatof_pt = new TH2D("hbetatof_pt","beta vs. pT",100,0, 10, 100, 0, 1); + hbetatof_tof_elec_pt = new TH2D("hbetatof_tof_elec_pt","beta vs. pT with tof cut",100,0, 10, 100, 0, 1); + hbetatof_tof_all_pt = new TH2D("hbetatof_tof_all_pt","beta vs. pT with tof cut",100,0, 10, 100, 0, 1); + hbetatof_tof_elec_emc_pt = new TH2D("hbetatof_tof_elec_emc_pt","beta vs. pT with tof cut",100,0, 10, 100, 0, 1); + hbetatof_tof_all_emc_pt = new TH2D("hbetatof_tof_all_emc_pt","beta vs. pT with tof cut and emc E/p",100,0, 10, 100, 0, 1); + hbetatof_emc_pt = new TH2D("hbetatof_emc_pt","dedx vs. pT with EMC",100,0, 10, 100, 0, 200); + + hCentrality = new TH1F("hCentrality","hCentrality",100,0,100); + hV0AC = new TH2F("hV0AC","V0AC",5000,0,15000,5000,0,15000); + hV0AC_Ntrk = new TH2F("hV0AC_Ntrk","V0AC vs. Ntrk",5000,0,30000,5000,0,15000); + hV0AC_NaccTrcklts = new TH2F("hV0AC_NaccTrcklts","V0AC vs. Ntrklets",5000,0,30000,2500,0,5000); + + + + fBinWidth = 0.05; + + nHistos = (int)(10/fBinWidth); + + for(int i=0;iBranch("evt", &d_evt, "evt/I"); + d_tree->Branch("cent", &d_cent, "cent/D"); + d_tree->Branch("ntrk", &d_ntrk, "ntrk/D"); + d_tree->Branch("xvprim", &d_xvprim, "xvprim/D"); + d_tree->Branch("yvprim", &d_yvprim, "yvprim/D"); + d_tree->Branch("zvprim", &d_zvprim, "zvprim/D"); + d_tree->Branch("nacctrklets", &d_nacctrklets, "nacctrklets/D"); + d_tree->Branch("xres", &d_xres, "xres/D"); + d_tree->Branch("yres", &d_yres, "yres/D"); + d_tree->Branch("zres", &d_zres, "zres/D"); + d_tree->Branch("nelc", &d_nelc, "nelc/I"); + d_tree->Branch("px", d_px, "px[nelc]/D"); + d_tree->Branch("py", d_py, "py[nelc]/D"); + d_tree->Branch("pz", d_pz, "pz[nelc]/D"); + d_tree->Branch("p", d_p, "p[nelc]/D"); + d_tree->Branch("pt", d_pt, "pt[nelc]/D"); + d_tree->Branch("xv", d_xv, "xv[nelc]/D"); + d_tree->Branch("yv", d_yv, "yv[nelc]/D"); + d_tree->Branch("zv", d_zv, "zv[nelc]/D"); + d_tree->Branch("phi", d_phi, "phi[nelc]/D"); + d_tree->Branch("theta", d_theta, "theta[nelc]/D"); + d_tree->Branch("eta", d_eta, "eta[nelc]/D"); + d_tree->Branch("c", d_c, "c[nelc]/D"); + d_tree->Branch("nclusITS", d_nclusITS, "nclusITS[nelc]/D"); + d_tree->Branch("nclusTPC", d_nclusTPC, "nclusTPC[nelc]/D"); + d_tree->Branch("nclusTPCiter", d_nclusTPCiter, "nclusTPCiter[nelc]/D"); + d_tree->Branch("nfclusTPC", d_nfclusTPC, "nfclusTPC[nelc]/D"); + d_tree->Branch("nfclusTPCr", d_nfclusTPCr, "nfclusTPCr[nelc]/D"); + d_tree->Branch("nfclusTPCrFrac", d_nfclusTPCrFrac, "nfclusTPCrFrac[nelc]/D"); + d_tree->Branch("TPCsignalN", d_TPCsignalN, "TPCsignalN[nelc]/D"); + d_tree->Branch("TPCsignalNfrac", d_TPCsignalNfrac, "TPCsignalNfrac[nelc]/D"); + d_tree->Branch("TPCchi2cl", d_TPCchi2cl, "TPCchi2cl[nelc]/D"); + d_tree->Branch("trkstat", d_trkstat, "trkstat[nelc]/D"); + d_tree->Branch("nclsTRD", d_nclsTRD, "nclsTRD[nelc]/D"); + d_tree->Branch("TRDntracklets", d_TRDntracklets, "TRDntracklets[nelc]/D"); + d_tree->Branch("TRDpidquality", d_TRDpidquality, "TRDpidquality[nelc]/D"); + d_tree->Branch("TRDprobEle", d_TRDprobEle, "TRDprobEle[nelc]/D"); + d_tree->Branch("TRDprobPio", d_TRDprobPio, "TRDprobPio[nelc]/D"); + d_tree->Branch("impactXY", d_impactXY, "impactXY[nelc]/D"); + d_tree->Branch("impactZ", d_impactZ, "impactZ[nelc]/D"); + d_tree->Branch("tracklength", d_tracklength, "tracklength[nelc]/D"); + d_tree->Branch("ITSsignal", d_ITSsignal, "ITSsignal[nelc]/D"); + d_tree->Branch("ITSnsigmaEle", d_ITSnsigmaEle, "ITSnsigmaEle[nelc]/D"); + d_tree->Branch("ITSnsigmaPio", d_ITSnsigmaPio, "ITSnsigmaPio[nelc]/D"); + d_tree->Branch("ITSnsigmaMuo", d_ITSnsigmaMuo, "ITSnsigmaMuo[nelc]/D"); + d_tree->Branch("ITSnsigmaKao", d_ITSnsigmaKao, "ITSnsigmaKao[nelc]/D"); + d_tree->Branch("ITSnsigmaPro", d_ITSnsigmaPro, "ITSnsigmaPro[nelc]/D"); + d_tree->Branch("PIn", d_PIn, "PIn[nelc]/D"); + d_tree->Branch("TPCsignal", d_TPCsignal, "TPCsignal[nelc]/D"); + d_tree->Branch("TOFsignal", d_TOFsignal, "TOFsignal[nelc]/D"); + d_tree->Branch("TOFbeta", d_TOFbeta, "TOFbeta[nelc]/D"); + d_tree->Branch("TPCnSigmaEle", d_TPCnSigmaEle, "TPCnSigmaEle[nelc]/D"); + d_tree->Branch("TPCnSigmaPio", d_TPCnSigmaPio, "TPCnSigmaPio[nelc]/D"); + d_tree->Branch("TPCnSigmaMuo", d_TPCnSigmaMuo, "TPCnSigmaMuo[nelc]/D"); + d_tree->Branch("TPCnSigmaKao", d_TPCnSigmaKao, "TPCnSigmaKao[nelc]/D"); + d_tree->Branch("TPCnSigmaPro", d_TPCnSigmaPro, "TPCnSigmaPro[nelc]/D"); + d_tree->Branch("TOFnSigmaEle", d_TOFnSigmaEle, "TOFnSigmaEle[nelc]/D"); + d_tree->Branch("TOFnSigmaPio", d_TOFnSigmaPio, "TOFnSigmaPio[nelc]/D"); + d_tree->Branch("TOFnSigmaMuo", d_TOFnSigmaMuo, "TOFnSigmaMuo[nelc]/D"); + d_tree->Branch("TOFnSigmaKao", d_TOFnSigmaKao, "TOFnSigmaKao[nelc]/D"); + d_tree->Branch("TOFnSigmaPro", d_TOFnSigmaPro, "TOFnSigmaPro[nelc]/D"); + d_tree->Branch("E", d_E, "E[nelc]/D"); + d_tree->Branch("dphi", d_phi, "dphi[nelc]/D"); + d_tree->Branch("deta", d_eta, "deta[nelc]/D"); + + d_tree->Branch("chi2ndf", d_chi2ndf, "chi2ndf[nelc]/D"); + + cout<<"aaaaaaaaaaa"<Branch("run", &d_run, "run/D"); + d_ntpair->Branch("event", &d_event, "event/I"); + d_ntpair->Branch("centrality",&d_centrality,"centrality/D"); + d_ntpair->Branch("prim_xv",&d_prim_xv,"prim_xv/D"); + d_ntpair->Branch("prim_yv",&d_prim_yv,"prim_yv/D"); + d_ntpair->Branch("prim_zv",&d_prim_zv,"prim_zv/D"); + d_ntpair->Branch("mass",&d_mass,"mass/D"); + d_ntpair->Branch("pxpair",&d_pxpair,"pxpair/D"); + d_ntpair->Branch("pypair",&d_pypair,"pypair/D"); + d_ntpair->Branch("pzpair",&d_pzpair,"pzpair/D"); + d_ntpair->Branch("ptpair",&d_ptpair,"ptpair/D"); + d_ntpair->Branch("epair",&d_epair,"epair/D"); + d_ntpair->Branch("eta",&d_etapair,"eta/D"); + d_ntpair->Branch("phi",&d_phipair,"phi/D"); + d_ntpair->Branch("cos",&d_cos,"cos/D"); + d_ntpair->Branch("phiv",&d_phiv,"phiv/D"); + d_ntpair->Branch("psi",&d_psi,"psi/D"); + d_ntpair->Branch("pairtype",&d_pairtype,"pairtype/I"); + d_ntpair->Branch("cent1",&d_cent1,"cent1/D"); + d_ntpair->Branch("xv1",&d_xv1,"xv1/D"); + d_ntpair->Branch("yv1",&d_yv1,"yv1/D"); + d_ntpair->Branch("zv1",&d_zv1,"zv1/D"); + d_ntpair->Branch("px1",&d_px1,"px1/D"); + d_ntpair->Branch("py1",&d_py1,"py1/D"); + d_ntpair->Branch("pz1",&d_pz1,"pz1/D"); + d_ntpair->Branch("pt1",&d_pt1,"pt1/D"); + d_ntpair->Branch("eta1",&d_eta1,"eta1/D"); + d_ntpair->Branch("phi1",&d_phi1,"phi1/D"); + d_ntpair->Branch("theta1",&d_theta1,"theta1/D"); + d_ntpair->Branch("tpc1",&d_tpc1,"tpc1/D"); + d_ntpair->Branch("ntpc_ele1",&d_ntpc_ele1,"ntpc_ele1/D"); + d_ntpair->Branch("ntpc_pio1",&d_ntpc_pio1,"ntpc_pio1/D"); + d_ntpair->Branch("ntpc_kao1",&d_ntpc_kao1,"ntpc_kao1/D"); + d_ntpair->Branch("ntpc_pro1",&d_ntpc_pro1,"ntpc_pro1/D"); + d_ntpair->Branch("beta1",&d_beta1,"beta1/D"); + d_ntpair->Branch("ntof_ele1",&d_ntof_ele1,"ntof_ele1/D"); + d_ntpair->Branch("ntof_pio1",&d_ntof_pio1,"ntof_pio1/D"); + d_ntpair->Branch("ntof_kao1",&d_ntof_kao1,"ntof_kao1/D"); + d_ntpair->Branch("ntof_pro1",&d_ntof_pro1,"ntof_pro1/D"); + d_ntpair->Branch("its1",&d_its1,"its1/D"); + d_ntpair->Branch("nits1",&d_nits1,"nits1/D"); + d_ntpair->Branch("ntpc1",&d_ntpc1,"ntpc1/D"); + d_ntpair->Branch("e1",&d_e1,"e1/D"); + d_ntpair->Branch("dphi1",&d_dphi1,"dphi1/D"); + d_ntpair->Branch("deta1",&d_deta1,"deta1/D"); + d_ntpair->Branch("dcaxy1",&d_dcaxy1,"dcaxy1/D"); + d_ntpair->Branch("dcaz1",&d_dcaz1,"dcaz1/D"); + d_ntpair->Branch("conv1",&d_conv1,"conv1/I"); + + + + + d_ntpair->Branch("cent2",&d_cent2,"cent2/D"); + d_ntpair->Branch("xv2",&d_xv2,"xv2/D"); + d_ntpair->Branch("yv2",&d_yv2,"yv2/D"); + d_ntpair->Branch("zv2",&d_zv2,"zv2/D"); + d_ntpair->Branch("px2",&d_px2,"px2/D"); + d_ntpair->Branch("py2",&d_py2,"py2/D"); + d_ntpair->Branch("pz2",&d_pz2,"pz2/D"); + d_ntpair->Branch("pt2",&d_pt2,"pt2/D"); + d_ntpair->Branch("eta2",&d_eta2,"eta2/D"); + d_ntpair->Branch("phi2",&d_phi2,"phi2/D"); + d_ntpair->Branch("theta2",&d_theta2,"theta2/D"); + d_ntpair->Branch("tpc2",&d_tpc2,"tpc2/D"); + d_ntpair->Branch("ntpc_ele2",&d_ntpc_ele2,"ntpc_ele2/D"); + d_ntpair->Branch("ntpc_pio2",&d_ntpc_pio2,"ntpc_pio2/D"); + d_ntpair->Branch("ntpc_kao2",&d_ntpc_kao2,"ntpc_kao2/D"); + d_ntpair->Branch("ntpc_pro2",&d_ntpc_pro2,"ntpc_pro2/D"); + d_ntpair->Branch("beta2",&d_beta2,"beta2/D"); + d_ntpair->Branch("ntof_ele2",&d_ntof_ele2,"ntof_ele2/D"); + d_ntpair->Branch("ntof_pio2",&d_ntof_pio2,"ntof_pio2/D"); + d_ntpair->Branch("ntof_kao2",&d_ntof_kao2,"ntof_kao2/D"); + d_ntpair->Branch("ntof_pro2",&d_ntof_pro2,"ntof_pro2/D"); + d_ntpair->Branch("its2",&d_its2,"its2/D"); + d_ntpair->Branch("nits2",&d_nits2,"nits2/D"); + d_ntpair->Branch("ntpc2",&d_ntpc2,"ntpc2/D"); + d_ntpair->Branch("e2",&d_e2,"e2/D"); + d_ntpair->Branch("dphi2",&d_dphi2,"dphi2/D"); + d_ntpair->Branch("deta2",&d_deta2,"deta2/D"); + d_ntpair->Branch("dcaxy2",&d_dcaxy2,"dcaxy2/D"); + d_ntpair->Branch("dcaz2",&d_dcaz2,"dcaz2/D"); + d_ntpair->Branch("conv2",&d_conv2,"conv2/I"); + + cout<<"aaaaaaaaaaa"<cd(); + /* + hdedx_pt->Write(); + hdedx_tof_elec_pt->Write(); + hdedx_tof_all_pt->Write(); + hdedx_tof_elec_emc_pt->Write(); + hdedx_tof_all_emc_pt->Write(); + hdedx_emc_pt->Write(); + + hbetatof_pt->Write(); + hbetatof_tof_elec_pt->Write(); + hbetatof_tof_all_pt->Write(); + hbetatof_tof_elec_emc_pt->Write(); + hbetatof_tof_all_emc_pt->Write(); + hbetatof_emc_pt->Write(); + + for(int i=0;iWrite(); + hdedx_tof_elec[i]->Write(); + hdedx_tof_all[i]->Write(); + hdedx_tof_elec_emc[i]->Write(); + hdedx_tof_all_emc[i]->Write(); + hdedx_emc[i]->Write(); + } + + */ + + if(simflag==false){ + fEventStat->Write(); + fEvent->Write(); + fdEdXvsPt->Write(); + fdEdXnSigmaElecvsPt->Write(); + fTOFbetavsPt->Write(); + fTOFnSigmaElecvsPt->Write(); + fdEdXvsPtWithCut->Write(); + fPtElec[0]->Write(); + fPtElec[1]->Write(); + } + fNelc_pos->Write(); + fNelc_all->Write(); + for(int i=0;i<10;i++){ + fNelc_pos_cent[i]->Write(); + fNelc_all_cent[i]->Write(); + } + fNelc_all_pT->Write(); + //d_tree->Write(); + hCentrality->Write(); + hV0AC->Write(); + hV0AC_Ntrk->Write(); + hV0AC_NaccTrcklts->Write(); + for(int j=0;j<11;j++){ + for(int i=0;i<7;i++){ + hmasspt[i][j]->Write(); + hmasspt_weight[i][j]->Write(); + } + } + + //d_ntpair->Write(); + fout->Close(); +} + +//____________________________________________ +void ana_sgl::loop_a_file(char *file){ + + TFile *treefile = TFile::Open(file); + TDirectory *d = (TDirectory*)treefile->Get("PWG3_dielectron"); + if(d==0){ + cout<<" PWG3_dielectron is not found "<Get("t"); + TTree *tree = (TTree*)d->Get("tree_MultiDie_CENT1"); + if(tree == 0) { + cout <<"tree is not found in "<Close(); + return; + } + cout << file <<" is opened"<Clear(); + d->Clear(); + tree->Delete(); + d->Delete(); + delete d; + treefile->Close(); + delete treefile; + + + + cout <<"one file processed"<138350){ + /* + if(kMag>0){ + magnetic_field_mm = false; + }else{ + magnetic_field_mm = true; + } + */ + if(fkRunNumber>169591){ + magnetic_field_mm = false; + }else{ + magnetic_field_mm = true; + } + + if(ientry%1000==0){ + cout<<" event processing "<Fill(fkCentrality); + hV0AC->Fill(fkV0C, fkV0A); + hV0AC_Ntrk->Fill(fkNTrk, fkV0C+fkV0A); + hV0AC_NaccTrcklts->Fill(fkNaccTrcklts, fkV0C+fkV0A); + fill_to_tree_variables(); + + for(int i=0;iFill(kPIn[i], kTPCsignal[i]); + + if(GlobalTrackcut(i)==false){ + continue; + } + fill_histograms(i); + } + + + fill_to_tree_track_variables(i); + + //if(PairTrackcut(i)==false){ + //continue; + //} + + if(fkCentrality>0 && fkCentrality<10){ + int iptbin = (int)(kP[i]/0.5); + if(iptbin>=10){ + iptbin=9; + } + nelec_pos[iptbin]++; + } + + if(kCharge[i]>0){ + etrk e = etrk( + fkCentrality, fkXvPrim, fkYvPrim, fkZvPrim, + kXv[i], kYv[i], kZv[i], + kPx[i], kPy[i], kPz[i], kPt[i], + kEta[i], kPhi[i], kTheta[i], + kTPCsignal[i], kTOFbeta[i], + kE[i], kDeltaPhi[i], kDeltaEta[i], + kTPCnSigmaEle[i], kTPCnSigmaPio[i], kTPCnSigmaKao[i], kTPCnSigmaPro[i], + kTOFnSigmaEle[i], kTOFnSigmaPio[i], kTOFnSigmaKao[i], kTOFnSigmaPro[i], + kITSsignal[i], kNclsITS[i], kNclsTPC[i], kLegDistXY[i], kLegDist[i] + ); + vep_tmp.push_back(e); + }else{ + etrk e = etrk( + fkCentrality, fkXvPrim, fkYvPrim, fkZvPrim, + kXv[i], kYv[i], kZv[i], + kPx[i], kPy[i], kPz[i], kPt[i], + kEta[i], kPhi[i], kTheta[i], + kTPCsignal[i], kTOFbeta[i], + kE[i], kDeltaPhi[i], kDeltaEta[i], + kTPCnSigmaEle[i], kTPCnSigmaPio[i], kTPCnSigmaKao[i], kTPCnSigmaPro[i], + kTOFnSigmaEle[i], kTOFnSigmaPio[i], kTOFnSigmaKao[i], kTOFnSigmaPro[i], + kITSsignal[i], kNclsITS[i], kNclsTPC[i], kLegDistXY[i], kLegDist[i] + ); + vem_tmp.push_back(e); + } + } + + //////// fill to the tree ////////////////// + //d_tree->Fill(); + + + + if(d_conv_flag==true){ + check_conversion_pairs(vep_tmp, vem_tmp); + } + + check_ghost_pairs(vep_tmp); + check_ghost_pairs(vem_tmp); + randomize_pool(vep_tmp, vem_tmp); + if(d_conv_flag==false){ + check_conversion_pairs(vep, vem); + } + + fNelc_pos->Fill(vep.size(), vem.size()); + fNelc_all->Fill(vep.size()+vem.size()); + + if(fkCentrality>0 && fkCentrality<10){ + for(int i=0;i<10;i++){ + fNelc_all_pT->Fill(0.25+0.5*i, nelec_pos[i]); + } + } + + + calc_pair(vep, vem); + + int icent = (int)(fkCentrality/10.0); + int izbin = (int)((fkZvPrim+10)/2.0); + if(icent<0) icent=0; + if(icent>=NCENT) icent=NCENT-1; + if(izbin<0) izbin=0; + if(izbin>=NZBIN) izbin=NZBIN-1; + + fNelc_pos_cent[icent]->Fill(vep.size(), vem.size()); + fNelc_all_cent[icent]->Fill(vep.size()+vem.size()); + + + + d_vep[d_ibuf[izbin][icent]][izbin][icent].clear(); + vector::iterator iep; + for(iep = vep.begin();iep != vep.end();++iep) { + d_vep[d_ibuf[izbin][icent]][izbin][icent].push_back(*iep); + d_poolp[izbin][icent].push_back(*iep); + if(d_poolp[izbin][icent].size()>MAXPOOL) { + d_poolp[izbin][icent].pop_front(); + } + } + d_vem[d_ibuf[izbin][icent]][izbin][icent].clear(); + vector::iterator iem; + for(iem = vem.begin();iem != vem.end();++iem) { + d_vem[d_ibuf[izbin][icent]][izbin][icent].push_back(*iem); + d_poolm[izbin][icent].push_back(*iem); + if(d_poolm[izbin][icent].size()>MAXPOOL) { + d_poolm[izbin][icent].pop_front(); + } + } + // Update the buffer pointer + d_ibuf[izbin][icent]++; + if(d_ibuf[izbin][icent]>= NBUF) d_ibuf[izbin][icent]=0; + + /////////////////////////////////////////// + vem.clear(); + vep.clear(); + vem_tmp.clear(); + vep_tmp.clear(); + d_evt ++; + d_event ++; + +} + + +//____________________________________________ +bool ana_sgl::kTOFcut(int itrk){ + + if(kTOFsignal[itrk]!=9999 && kTOFbeta[itrk]>0.3 && + (kTOFnSigmaEle[itrk]<3 && kTOFnSigmaEle[itrk]>-3) + /* + (kTOFnSigmaKao>3 || kTOFnSigmaKao<-3) && + (kTOFnSigmaPro>3 || kTOFnSigmaPro<-3) + */ + + ){ + + return true; + }else{ + return false; + } +} + +//____________________________________________ +bool ana_sgl::GlobalTrackcut(int itrk){ + + + if(( + (d_flag_kaon_veto == true && (kTPCnSigmaKao[itrk]d_dedx_kaon_veto_high)) || + (d_flag_kaon_veto == false) + ) + && ( + (d_flag_proton_veto == true && (kTPCnSigmaPro[itrk]d_dedx_proton_veto_high)) || + (d_flag_proton_veto == false) + ) + ){ + fdEdXvsPtWithCut->Fill(kPIn[itrk], kTPCsignal[itrk]); + } + + if( kNclsTPC[itrk]>120 + && kTPCsignal[itrk]>d_tpc_dedx_low && kTPCsignal[itrk]d_tof_low && kTOFnSigmaEle[itrk]d_pt_cut_low && kPt[itrk]d_dedx_kaon_veto_high)) || + (d_flag_kaon_veto == false) + ) + && ( + (d_flag_proton_veto == true && (kTPCnSigmaPro[itrk]d_dedx_proton_veto_high)) || + (d_flag_proton_veto == false) + ) + ){ + return true; + }else{ + return false; + } +} + +/* +//____________________________________________ +bool ana_sgl::PairTrackcut(int itrk){ + + if( (kTOFnSigmaEle[itrk]<3 && kTOFnSigmaEle[itrk]>-3) && + (kTOFnSigmaKao[itrk]>3||kTOFnSigmaKao[itrk]<-3) && + (kTOFnSigmaPro[itrk]>3||kTOFnSigmaPro[itrk]<-3) //&& + //(kTPCnSigmaEle[itrk]-1.65226*exp(-kPIn[itrk]*kPIn[itrk]*1.60890)+0.838)<1 && + //(kTPCnSigmaEle[itrk]-1.65226*exp(-kPIn[itrk]*kPIn[itrk]*1.60890)+0.838)>-1 + ){ + return true; + }else{ + return false; + } + + +// if( +// !(kTPCsignal>75-210*(kPIn-0.5) && +// kTPCsignal<100-190*(kPIn-0.5)) && +// !(kTPCsignal>130-120*(kPIn-0.5) && +// kTPCsignal<135-80*(kPIn-0.5)) && +// (kTPCnSigmaEle-1.65226*exp(-kPIn*kPIn*1.60890)+0.838)<1 && +// (kTPCnSigmaEle-1.65226*exp(-kPIn*kPIn*1.60890)+0.838)>-1 +// ){ +// return true; +// }else{ +// return false; +// } + + +} +*/ + +//____________________________________________ +void ana_sgl::fill_histograms(int itrk){ + /* + hdedx_pt->Fill(kPIn[itrk], kTPCsignal[itrk]); + hbetatof_pt->Fill(kPIn[itrk], kTOFbeta[itrk]); + + if(kTOFcut(itrk)==true){ + hdedx_tof_pt->Fill(kPIn[itrk], kTPCsignal[itrk]); + hbetatof_tof_pt->Fill(kPIn[itrk], kTOFbeta[itrk]); + } + + int iptbin = (int)((kPIn[itrk])/fBinWidth); + if(iptbin>=0 && iptbinFill(kTPCsignal[itrk]); + if(kTOFcut(itrk)==true)hdedx_tof[iptbin]->Fill(kTPCsignal[itrk]); + } + */ + + if(kCharge[itrk]>0){ + fPtElec[1]->Fill(kPIn[itrk]); + }else{ + fPtElec[0]->Fill(kPIn[itrk]); + } + + hdedx_pt->Fill(kPIn[itrk], kTPCsignal[itrk]); + hbetatof_pt->Fill(kPIn[itrk], kTOFbeta[itrk]); + + if(kTOFnSigmaEle[itrk]>-3 && kTOFnSigmaEle[itrk]<3){ + hdedx_tof_elec_pt->Fill(kPIn[itrk], kTPCsignal[itrk]); + hbetatof_tof_elec_pt->Fill(kPIn[itrk], kTOFbeta[itrk]); + + if(kE[itrk]/kPIn[itrk]>0.7 && kE[itrk]/kPIn[itrk]<1.3){ + hdedx_tof_elec_emc_pt->Fill(kPIn[itrk], kTPCsignal[itrk]); + hbetatof_emc_pt->Fill(kPIn[itrk], kTOFbeta[itrk]); + } + + if( (kTOFnSigmaKao[itrk]>3 || kTOFnSigmaKao[itrk]<-3) && + (kTOFnSigmaPro[itrk]>3 || kTOFnSigmaPro[itrk]<-3) + ){ + hdedx_tof_all_pt->Fill(kPIn[itrk], kTPCsignal[itrk]); + hbetatof_tof_all_pt->Fill(kPIn[itrk], kTPCsignal[itrk]); + if(kE[itrk]/kPIn[itrk]>0.7 && kE[itrk]/kPIn[itrk]<1.3){ + hdedx_tof_all_emc_pt->Fill(kPIn[itrk], kTPCsignal[itrk]); + hbetatof_tof_all_emc_pt->Fill(kPIn[itrk], kTPCsignal[itrk]); + } + } + } + + if(kE[itrk]/kPIn[itrk]>0.7 && kE[itrk]/kPIn[itrk]<1.3){ + hdedx_emc_pt->Fill(kPIn[itrk], kTPCsignal[itrk]); + hbetatof_emc_pt->Fill(kPIn[itrk], kTPCsignal[itrk]); + } + + + + + int iptbin = (int)((kPIn[itrk])/fBinWidth); + if(iptbin>=0 && iptbinFill(kTPCsignal[itrk]); + //if(kTOFcut(itrk)==true)hdedx_tof[iptbin]->Fill(kTPCsignal[itrk]); + + if(kTOFnSigmaEle[itrk]>-3 && kTOFnSigmaEle[itrk]<3){ + hdedx_tof_elec[iptbin]->Fill(kTPCsignal[itrk]); + + if(kE[itrk]/kPIn[itrk]>0.7 && kE[itrk]/kPIn[itrk]<1.3){ + hdedx_tof_elec_emc[iptbin]->Fill(kTPCsignal[itrk]); + } + if( (kTOFnSigmaKao[itrk]>3 || kTOFnSigmaKao[itrk]<-3) && + (kTOFnSigmaPro[itrk]>3 || kTOFnSigmaPro[itrk]<-3) + ){ + hdedx_tof_all[iptbin]->Fill(kTPCsignal[itrk]); + if(kE[itrk]/kPIn[itrk]>0.7 && kE[itrk]/kPIn[itrk]<1.3){ + hdedx_tof_all_emc[iptbin]->Fill(kTPCsignal[itrk]); + } + } + } + if(kE[itrk]/kPIn[itrk]>0.7 && kE[itrk]/kPIn[itrk]<1.3){ + hdedx_emc[iptbin]->Fill(kTPCsignal[itrk]); + } + } + +} + +//____________________________________________ +void ana_sgl::add_histograms(TFile *fin){ + + TDirectory *d = (TDirectory*)fin->Get("PWG3_dielectron"); + if(d==0){ + cout<<" PWG3_dielectron is not found "<Add((TH1D*)d->Get("hEventStat_MultiDie_CENT1")); + TList *list = (TList*)d->Get("jpsi_QA_CENT1"); + TList *listQA = (TList*)list->FindObject("QAElectron"); + fEvent->Add((TH1D*)listQA->FindObject("Event")); + fdEdXvsPt->Add((TH1D*)listQA->FindObject("dEdXvsPt")); + fdEdXnSigmaElecvsPt->Add((TH1D*)listQA->FindObject("fdEdXnSigmaElecvsPt")); + fTOFbetavsPt->Add((TH1D*)listQA->FindObject("fTOFbetavsPt")); + fTOFnSigmaElecvsPt->Add((TH1D*)listQA->FindObject("fTOFnSigmaElecvsPt")); + + cout<<" ana_sgl::add_histograms "<GetName()<<" done "< e1, vector e2){ + + int size1 = e1.size(); + int used_index[1000]; + for(int i=0;i<1000;i++){ + used_index[i] = -1; + } + for(int i=0;iUniform(0,size1)); + while(used_index[j]==1){ + j = (int)(gRandom->Uniform(0,size1)); + } + if( (e1[j].ghost_flag==1) && + ( + (d_conv_flag==true && e1[j].conv_flag==1) || + (d_conv_flag==false) + ) + ){ + vep.push_back(e1[j]); + } + used_index[j] = 1; + } + + + int size2 = e2.size(); + for(int i=0;i<1000;i++){ + used_index[i] = -1; + } + for(int i=0;iUniform(0,size2)); + while(used_index[j]==1){ + j = (int)(gRandom->Uniform(0,size2)); + } + if( (e2[j].ghost_flag==1) && + ( + (d_conv_flag==true && e2[j].conv_flag==1) || + (d_conv_flag==false) + ) + ){ + vem.push_back(e2[j]); + } + used_index[j] = 1; + } +} + +//____________________________________________________________________ +void ana_sgl::calc_pair(vector vep, vector vem){ + + //vector::iterator iep, iem; + + vector::iterator iep; + vector::iterator iem; + + //cout<::iterator iep2=iep; + ++iep2; + for(iem=iep2; iem!=vep.end(); ++iem){ + if(PairTrackcut(iep, iem)==false) continue; + fill_pair(iep, iem, 1); + } + } + + for(iep=vem.begin(); iep!=vem.end(); ++iep){ + vector::iterator iep2=iep; + ++iep2; + for(iem=iep2; iem!=vem.end(); ++iem){ + if(PairTrackcut(iep, iem)==false) continue; + fill_pair(iep, iem, 2); + } + } + + int icent = (int)(fkCentrality/10.0); + int izbin = (int)((fkZvPrim+10)/2.0); + if(icent<0) icent=0; + if(icent>=NCENT) icent=NCENT-1; + if(izbin<0) izbin=0; + if(izbin>=NZBIN) izbin=NZBIN-1; + + + int nmixed; + if(vep.size()>0) { + // + // Now mixed event for +- pairs + // + nmixed = 0; + for(int ibuf=0;(nmixed0) { + // + // Now mixed event for +- pairs + // + nmixed = 0; + for(int ibuf=0;(nmixed0) { + // + // Now mixed event for ++ pairs + // + nmixed = 0; + for(int ibuf=0;(nmixed0) { + // + // Now mixed event for +- pairs + // + nmixed = 0; + for(int ibuf=0;(nmixed::iterator iep, vector::iterator iem, int type){ + + + d_pairtype = type; + + calc_vars(iep, iem, d_mass, d_phiv, d_pxpair, d_pypair, d_pzpair, + d_ptpair, d_epair, d_phipair, d_etapair, d_cos, d_psi); + + if(type==0||type==1||type==2||type==3||type==5){ + d_centrality = iep->cent; + d_prim_xv = iep->pxv; + d_prim_yv = iep->pyv; + d_prim_zv = iep->pzv; + }else if(type==4 || type==6){ + d_centrality = iem->cent; + d_prim_xv = iem->pxv; + d_prim_yv = iem->pyv; + d_prim_zv = iem->pzv; + + } + + + //cout<px<<" "<px<<" "<cent; + d_xv1 = iep->xv; + d_yv1 = iep->yv; + d_zv1 = iep->zv; + d_px1 = iep->px; + d_py1 = iep->py; + d_pz1 = iep->pz; + d_pt1 = iep->pt; + d_eta1 = iep->eta; + d_phi1 = iep->phi; + d_theta1 = iep->theta; + d_tpc1 = iep->tpc; + d_ntpc_ele1 = iep->ntpc_ele; + d_ntpc_pio1 = iep->ntpc_pio; + d_ntpc_kao1 = iep->ntpc_kao; + d_ntpc_pro1 = iep->ntpc_pro; + d_ntof_ele1 = iep->ntof_ele; + d_ntof_pio1 = iep->ntof_pio; + d_ntof_kao1 = iep->ntof_kao; + d_ntof_pro1 = iep->ntof_pro; + d_its1 = iep->its; + d_nits1 = iep->nits; + d_ntpc1 = iep->ntpc; + d_e1 = iep->e; + d_dphi1 = iep->dphi; + d_deta1 = iep->deta; + d_dcaxy1 = iep->dcaxy; + d_dcaz1 = iep->dcaz; + d_conv1 = iep->conv_flag; + + d_cent2 = iem->cent; + d_xv2 = iem->xv; + d_yv2 = iem->yv; + d_zv2 = iem->zv; + d_px2 = iem->px; + d_py2 = iem->py; + d_pz2 = iem->pz; + d_pt2 = iem->pt; + d_eta2 = iem->eta; + d_phi2 = iem->phi; + d_theta2 = iem->theta; + d_tpc2 = iem->tpc; + d_ntpc_ele2 = iem->ntpc_ele; + d_ntpc_pio2 = iem->ntpc_pio; + d_ntpc_kao2 = iem->ntpc_kao; + d_ntpc_pro2 = iem->ntpc_pro; + d_ntof_ele2 = iem->ntof_ele; + d_ntof_pio2 = iem->ntof_pio; + d_ntof_kao2 = iem->ntof_kao; + d_ntof_pro2 = iem->ntof_pro; + d_its2 = iem->its; + d_nits2 = iem->nits; + d_ntpc2 = iem->ntpc; + d_e2 = iem->e; + d_dphi2 = iem->dphi; + d_deta2 = iem->deta; + d_dcaxy2 = iem->dcaxy; + d_dcaz2 = iem->dcaz; + d_conv2 = iem->conv_flag; + + d_run = fkRunNumber; + // d_event = d_evt; + + + int icent = (int)(fkCentrality/10.0); + if(icent<0) icent=0; + if(icent>=NCENT) icent=NCENT-1; + if(pair_cut()==true){ + hmasspt[type][icent]->Fill(d_mass, d_ptpair); + hmasspt[type][10]->Fill(d_mass, d_ptpair); + } + + ////////////// pt weighting for mixed event + float weight = 1; + float k = 10000; + if(type==0 || type==1 || type==2){ + weight = 1; + }else if(type==3 || type==5 || type==6){ + k = 18.7*exp(-2.4*d_pt2)+1.24; + weight = 1+1/k; + }else if(type==4){ + k = 18.7*exp(-2.4*d_pt1)+1.24; + weight = 1+1/k; + } + if(pair_cut()==true){ + hmasspt_weight[type][icent]->Fill(d_mass, d_ptpair, weight); + hmasspt_weight[type][10]->Fill(d_mass, d_ptpair, weight); + } + + + //d_ntpair->Fill(); + +} + +//____________________________________________ +bool ana_sgl::PairTrackcut(vector::iterator e1, vector::iterator e2){ + /* + double p1 = sqrt(pow(e1.px,2)+ + pow(e1.py,2)+ + pow(e1.pz,2)); + + double p2 = sqrt(pow(e2.px,2)+ + pow(e2.py,2)+ + pow(e2.pz,2)); + + if( + (e1.e/p1>0.7 && e1.e/p1<1.3) || + (e2.e/p1>0.7 && e2.e/p2<1.3) + ){ + return true; + }else{ + return false; + } +o */ + return true; + +} + +//____________________________________________ +void ana_sgl::check_conversion_pairs(vector &e1, vector &e2){ + vector::iterator iep; + vector::iterator iem; + bool reject = false; + if(e1.size()>0 && e2.size()>0){ + for(iep = e1.begin(); iep != e1.end(); ++iep){ + reject = false; + for(iem = e2.begin(); iem != e2.end(); ++iem){ + double mass, phiv, px, py, pz, pt, e, phi, eta, cos, psi; + calc_vars(iep, iem, mass, phiv, px, py, pz, pt, e, phi, eta, cos, psi); + if(magnetic_field_mm==true){ //pp + if(phiv<0.6 && iep->phi-iem->phi<0){ // this depends on the magntic field + reject = true; + iem->conv_flag = 0; + } + }else{ + if(phiv>acos(-1.0)-0.6 && iep->phi-iem->phi>0){ // this depends on the magntic field + reject = true; + iem->conv_flag = 0; + } + } + } + if(reject==true) iep->conv_flag=0; + } + } +} + +//____________________________________________ +void ana_sgl::check_ghost_pairs(vector &e1){ + vector::iterator iep; + vector::iterator iem; + bool reject = false; + if(e1.size()>1){ + for(iep = e1.begin(); iep != e1.end(); ++iep){ + reject = false; + vector::iterator iep2=iep; + ++iep2; + for(iem = iep2; iem != e1.end(); ++iem){ + double mass, phiv, px, py, pz, pt, e, phi, eta, cos, psi; + calc_vars(iep, iem, mass, phiv, px, py, pz, pt, e, phi, eta, cos, psi); + if(mass<0.01){ + reject = true; + iem->ghost_flag = 0; + } + } + if(reject==true) iep->ghost_flag=0; + } + } +} + +//____________________________________________ +//void ana_sgl::calc_vars(etrk iep, etrk iem, double &mass, double &phiv, double &px, double &py, double&pz, +void ana_sgl::calc_vars(vector::iterator iep, vector::iterator iem, double &mass, double &phiv, double &px, double &py, double&pz, + double &pt, double &e, double &phi, double &eta, double &cos, double &psi){ + + px = iep->px+iem->px; + py = iep->py+iem->py; + pz = iep->pz+iem->pz; + pt = sqrt(px*px+py*py); + double d_ppair = sqrt(pt*pt+pz*pz); + static const double me=0.0005109989; + e = sqrt(me*me+iep->px*iep->px+iep->py*iep->py+iep->pz*iep->pz) + + sqrt(me*me+iem->px*iem->px+iem->py*iem->py+iem->pz*iem->pz); + + mass = e*e-px*px-py*py-pz*pz; + if(mass<0){ + mass = mass; + }else{ + mass = sqrt(mass); + } + + + + phi = atan2(py, px); + eta = -0.5*TMath::Log((d_ppair+pz)/(d_ppair-pz)); + double p1 = sqrt(pow(iep->px,2)+pow(iep->py,2)+pow(iep->pz,2)); + double p2 = sqrt(pow(iem->px,2)+pow(iem->py,2)+pow(iem->pz,2)); + cos = acos((iep->px*iem->px+iep->py*iem->py+iep->pz*iem->pz)/(p1*p2)); + + + double dtheta = iep->theta-iem->theta; + psi = asin(dtheta/cos); + + + //unit vector of (pep+pem) + float pl = d_ppair; + float ux = px/pl; + float uy = py/pl; + float uz = pz/pl; + float ax = uy/sqrt(ux*ux+uy*uy); + float ay = -ux/sqrt(ux*ux+uy*uy); + + //momentum of e+ and e- in (ax,ay,az) axis. Note that az=0 by + //definition. + float ptep = iep->px*ax + iep->py*ay; + float ptem = iem->px*ax + iem->py*ay; + + float pxep = iep->px; + float pyep = iep->py; + float pzep = iep->pz; + float pxem = iem->px; + float pyem = iem->py; + float pzem = iem->pz; + + + //vector product of pep X pem + float vpx = pyep*pzem - pzep*pyem; + float vpy = pzep*pxem - pxep*pzem; + float vpz = pxep*pyem - pyep*pxem; + float vp = sqrt(vpx*vpx+vpy*vpy+vpz*vpz); + float thev = acos(vpz/vp); + + //unit vector of pep X pem + float vx = vpx/vp; + float vy = vpy/vp; + float vz = vpz/vp; + + //The third axis defined by vector product (ux,uy,uz)X(vx,vy,vz) + float wx = uy*vz - uz*vy; + float wy = uz*vx - ux*vz; + float wz = ux*vy - uy*vx; + float wl = sqrt(wx*wx+wy*wy+wz*wz); + // by construction, (wx,wy,wz) must be a unit vector. + if(fabs(wl - 1.0) > 0.00001) cout << "Calculation error in W vector"<169591 && d_phiv>acos(-1.0)-d_phiv_cut){ + ret = false; + } + if(d_run<169591 && d_phivd_emc_low && d_e1/d_pt1d_emc_low && d_e2/d_pt2d_pt_cut_low && d_pt2>d_pt_cut_low && + d_pt1 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace std; + + +class etrk; + +struct etrk{ + etrk(double Cent=0, double PXv=0, double PYv=0, double PZv=0, + double Xv=0, double Yv=0, double Zv=0, + double Px=0, double Py=0, double Pz=0, double Pt=0, + double Eta=0, double Phi=0, double Theta=0, double Tpc=0, double Beta=0, + double E=0, double dPhi=0, double dEta=0, + double Ntpc_ele1=0,double Ntpc_pio1=0,double Ntpc_kao1=0, double Ntpc_pro1=0, + double Ntof_ele1=0,double Ntof_pio1=0,double Ntof_kao1=0, double Ntof_pro1=0, + double Its=0, double Nits=0, double Ntpc=0, double Dcaxy=0, double Dcaz=0) + : + cent(Cent), pxv(PXv), pyv(PYv), pzv(PZv), + xv(Xv), yv(Yv), zv(Zv), + px(Px), py(Py), pz(Pz), pt(Pt), + eta(Eta), phi(Phi), theta(Theta), tpc(Tpc), beta(Beta), + e(E), dphi(dPhi), deta(dEta), + ntpc_ele(Ntpc_ele1), ntpc_pio(Ntpc_pio1), ntpc_kao(Ntpc_kao1), ntpc_pro(Ntpc_pro1), + ntof_ele(Ntof_ele1), ntof_pio(Ntof_pio1), ntof_kao(Ntof_kao1), ntof_pro(Ntof_pro1), + its(Its), nits(Nits), ntpc(Ntpc), dcaxy(Dcaxy), dcaz(Dcaz) + { + conv_flag = 1; + ghost_flag = 1; + } + + double E(void){TMath::Sqrt(me*me+px*px+py*py+pz*pz);} + double p(void){TMath::Sqrt(px*px+py*py+pz*pz);} + +private: + static const float me=0.000511; +public: + double cent; + double pxv; + double pyv; + double pzv; + double xv; + double yv; + double zv; + double px; + double py; + double pz; + double pt; + double eta; + double phi; + double theta; + double tpc; + double beta; + double e; + double dphi; + double deta; + double ntpc_ele; + double ntpc_pio; + double ntpc_kao; + double ntpc_pro; + double ntof_ele; + double ntof_pio; + double ntof_kao; + double ntof_pro; + double its; + double nits; + double ntpc; + double dcaxy; + double dcaz; + int conv_flag; + int ghost_flag; +}; + + +class ana_sgl { +public : + TTree *fChain; //!pointer to the analyzed TTree or TChain + Int_t fCurrent; //!current Tree number in a TChain + + // Declaration of leaf types + Int_t kNEvent; + Double_t kMag; + TObjArray *fkTriggerInfo; + Double_t kTriggerMask; + Int_t kTriggerCent; + Double_t fkNCut; + Double_t fkRunNumber; + Double_t fkCentrality; + Double_t fkXvPrim; + Double_t fkYvPrim; + Double_t fkZvPrim; + Double_t fkXRes; + Double_t fkYRes; + Double_t fkZRes; + Double_t fkNTrk; + Double_t fkTracks; + Double_t fkNacc; + Double_t fkNaccTrcklts; + Double_t fkNch; + Double_t fkZDCN1E; + Double_t fkZDCP1E; + Double_t fkZDCN2E; + Double_t fkZDCP2E; + Double_t fkV0A; + Double_t fkV0C; + Int_t fkNPar; + Double_t kPx[200]; //[fkNPar] + Double_t kPy[200]; //[fkNPar] + Double_t kPz[200]; //[fkNPar] + Double_t kPt[200]; //[fkNPar] + Double_t kP[200]; //[fkNPar] + Double_t kXv[200]; //[fkNPar] + Double_t kYv[200]; //[fkNPar] + Double_t kZv[200]; //[fkNPar] + Double_t kOneOverPt[200]; //[fkNPar] + Double_t kPhi[200]; //[fkNPar] + Double_t kTheta[200]; //[fkNPar] + Double_t kEta[200]; //[fkNPar] + Double_t kY[200]; //[fkNPar] + Double_t kE[200]; //[fkNPar] + Double_t kM[200]; //[fkNPar] + Double_t kCharge[200]; //[fkNPar] + Double_t kNclsITS[200]; //[fkNPar] + Double_t kNclsTPC[200]; //[fkNPar] + Double_t kNclsTPCiter1[200]; //[fkNPar] + Double_t kNFclsTPC[200]; //[fkNPar] + Double_t kNFclsTPCr[200]; //[fkNPar] + Double_t kNFclsTPCrFrac[200]; //[fkNPar] + Double_t kTPCsignalN[200]; //[fkNPar] + Double_t kTPCsignalNfrac[200]; //[fkNPar] + Double_t kTPCchi2Cl[200]; //[fkNPar] + Double_t kTrackStatus[200]; //[fkNPar] + Double_t kNclsTRD[200]; //[fkNPar] + Double_t kTRDntracklets[200]; //[fkNPar] + Double_t kTRDpidQuality[200]; //[fkNPar] + Double_t kTRDprobEle[200]; //[fkNPar] + Double_t kTRDprobPio[200]; //[fkNPar] + Double_t kImpactParXY[200]; //[fkNPar] + Double_t kImpactParZ[200]; //[fkNPar] + Double_t kTrackLength[200]; //[fkNPar] + Double_t kPdgCode[200]; //[fkNPar] + Double_t kPdgCodeMother[200]; //[fkNPar] + Double_t kPdgCodeGrandMother[200]; //[fkNPar] + Double_t kNumberOfDaughters[200]; //[fkNPar] + Double_t kHaveSameMother[200]; //[fkNPar] + Double_t kIsJpsiPrimary[200]; //[fkNPar] + Double_t kITSsignal[200]; //[fkNPar] + Double_t kITSsignalSSD1[200]; //[fkNPar] + Double_t kITSsignalSSD2[200]; //[fkNPar] + Double_t kITSsignalSDD1[200]; //[fkNPar] + Double_t kITSsignalSDD2[200]; //[fkNPar] + Double_t kITSclusterMap[200]; //[fkNPar] + Double_t kITSnSigmaEle[200]; //[fkNPar] + Double_t kITSnSigmaPio[200]; //[fkNPar] + Double_t kITSnSigmaMuo[200]; //[fkNPar] + Double_t kITSnSigmaKao[200]; //[fkNPar] + Double_t kITSnSigmaPro[200]; //[fkNPar] + Double_t kPIn[200]; //[fkNPar] + Double_t kTPCsignal[200]; //[fkNPar] + Double_t kTOFsignal[200]; //[fkNPar] + Double_t kTOFbeta[200]; //[fkNPar] + Double_t kTPCnSigmaEle[200]; //[fkNPar] + Double_t kTPCnSigmaPio[200]; //[fkNPar] + Double_t kTPCnSigmaMuo[200]; //[fkNPar] + Double_t kTPCnSigmaKao[200]; //[fkNPar] + Double_t kTPCnSigmaPro[200]; //[fkNPar] + Double_t kTOFnSigmaEle[200]; //[fkNPar] + Double_t kTOFnSigmaPio[200]; //[fkNPar] + Double_t kTOFnSigmaMuo[200]; //[fkNPar] + Double_t kTOFnSigmaKao[200]; //[fkNPar] + Double_t kTOFnSigmaPro[200]; //[fkNPar] + Double_t kKinkIndex0[200]; //[fkNPar] + Double_t kChi2NDF[200]; //[fkNPar] + Double_t kDecayLength[200]; //[fkNPar] + Double_t kR[200]; //[fkNPar] + Double_t kOpeningAngle[200]; //[fkNPar] + Double_t kThetaHE[200]; //[fkNPar] + Double_t kPhiHE[200]; //[fkNPar] + Double_t kThetaCS[200]; //[fkNPar] + Double_t kPhiCS[200]; //[fkNPar] + Double_t kLegDist[200]; //[fkNPar] + Double_t kLegDistXY[200]; //[fkNPar] + Double_t kDeltaEta[200]; //[fkNPar] + Double_t kDeltaPhi[200]; //[fkNPar] + Double_t kMerr[200]; //[fkNPar] + Double_t kDCA[200]; //[fkNPar] + Double_t kPairType[200]; //[fkNPar] + Double_t kPseudoProperTime[200]; //[fkNPar] + Double_t kXvPrim[200]; //[fkNPar] + Double_t kYvPrim[200]; //[fkNPar] + Double_t kZvPrim[200]; //[fkNPar] + Double_t kXRes[200]; //[fkNPar] + Double_t kYRes[200]; //[fkNPar] + Double_t kZRes[200]; //[fkNPar] + Double_t kNTrk[200]; //[fkNPar] + Double_t kTracks[200]; //[fkNPar] + Double_t kNacc[200]; //[fkNPar] + Double_t kNaccTrcklts[200]; //[fkNPar] + Double_t kNch[200]; //[fkNPar] + Double_t kCentrality[200]; //[fkNPar] + Double_t kNevents[200]; //[fkNPar] + + // List of branches + TBranch *b_kNEvent; //! + TBranch *b_kMag; //! + TBranch *b_fkTriggerInfo; //! + TBranch *b_kTriggerMask; //! + TBranch *b_kTriggerCent; //! + TBranch *b_fkNCut; //! + TBranch *b_fkRunNumber; //! + TBranch *b_fkCentrality; //! + TBranch *b_fkXvPrim; //! + TBranch *b_fkYvPrim; //! + TBranch *b_fkZvPrim; //! + TBranch *b_fkXRes; //! + TBranch *b_fkYRes; //! + TBranch *b_fkZRes; //! + TBranch *b_fkNTrk; //! + TBranch *b_fkTracks; //! + TBranch *b_fkNacc; //! + TBranch *b_fkNaccTrcklts; //! + TBranch *b_fkNch; //! + TBranch *b_fkZDCN1E; //! + TBranch *b_fkZDCP1E; //! + TBranch *b_fkZDCN2E; //! + TBranch *b_fkZDCP2E; //! + TBranch *b_fkV0A; //! + TBranch *b_fkV0C; //! + TBranch *b_fkNPar; //! + TBranch *b_kPx; //! + TBranch *b_kPy; //! + TBranch *b_kPz; //! + TBranch *b_kPt; //! + TBranch *b_kP; //! + TBranch *b_kXv; //! + TBranch *b_kYv; //! + TBranch *b_kZv; //! + TBranch *b_kOneOverPt; //! + TBranch *b_kPhi; //! + TBranch *b_kTheta; //! + TBranch *b_kEta; //! + TBranch *b_kY; //! + TBranch *b_kE; //! + TBranch *b_kM; //! + TBranch *b_kCharge; //! + TBranch *b_kNclsITS; //! + TBranch *b_kNclsTPC; //! + TBranch *b_kNclsTPCiter1; //! + TBranch *b_kNFclsTPC; //! + TBranch *b_kNFclsTPCr; //! + TBranch *b_kNFclsTPCrFrac; //! + TBranch *b_kTPCsignalN; //! + TBranch *b_kTPCsignalNfrac; //! + TBranch *b_kTPCchi2Cl; //! + TBranch *b_kTrackStatus; //! + TBranch *b_kNclsTRD; //! + TBranch *b_kTRDntracklets; //! + TBranch *b_kTRDpidQuality; //! + TBranch *b_kTRDprobEle; //! + TBranch *b_kTRDprobPio; //! + TBranch *b_kImpactParXY; //! + TBranch *b_kImpactParZ; //! + TBranch *b_kTrackLength; //! + TBranch *b_kPdgCode; //! + TBranch *b_kPdgCodeMother; //! + TBranch *b_kPdgCodeGrandMother; //! + TBranch *b_kNumberOfDaughters; //! + TBranch *b_kHaveSameMother; //! + TBranch *b_kIsJpsiPrimary; //! + TBranch *b_kITSsignal; //! + TBranch *b_kITSsignalSSD1; //! + TBranch *b_kITSsignalSSD2; //! + TBranch *b_kITSsignalSDD1; //! + TBranch *b_kITSsignalSDD2; //! + TBranch *b_kITSclusterMap; //! + TBranch *b_kITSnSigmaEle; //! + TBranch *b_kITSnSigmaPio; //! + TBranch *b_kITSnSigmaMuo; //! + TBranch *b_kITSnSigmaKao; //! + TBranch *b_kITSnSigmaPro; //! + TBranch *b_kPIn; //! + TBranch *b_kTPCsignal; //! + TBranch *b_kTOFsignal; //! + TBranch *b_kTOFbeta; //! + TBranch *b_kTPCnSigmaEle; //! + TBranch *b_kTPCnSigmaPio; //! + TBranch *b_kTPCnSigmaMuo; //! + TBranch *b_kTPCnSigmaKao; //! + TBranch *b_kTPCnSigmaPro; //! + TBranch *b_kTOFnSigmaEle; //! + TBranch *b_kTOFnSigmaPio; //! + TBranch *b_kTOFnSigmaMuo; //! + TBranch *b_kTOFnSigmaKao; //! + TBranch *b_kTOFnSigmaPro; //! + TBranch *b_kKinkIndex0; //! + TBranch *b_kChi2NDF; //! + TBranch *b_kDecayLength; //! + TBranch *b_kR; //! + TBranch *b_kOpeningAngle; //! + TBranch *b_kThetaHE; //! + TBranch *b_kPhiHE; //! + TBranch *b_kThetaCS; //! + TBranch *b_kPhiCS; //! + TBranch *b_kLegDist; //! + TBranch *b_kLegDistXY; //! + TBranch *b_kDeltaEta; //! + TBranch *b_kDeltaPhi; //! + TBranch *b_kMerr; //! + TBranch *b_kDCA; //! + TBranch *b_kPairType; //! + TBranch *b_kPseudoProperTime; //! + TBranch *b_kXvPrim; //! + TBranch *b_kYvPrim; //! + TBranch *b_kZvPrim; //! + TBranch *b_kXRes; //! + TBranch *b_kYRes; //! + TBranch *b_kZRes; //! + TBranch *b_kNTrk; //! + TBranch *b_kTracks; //! + TBranch *b_kNacc; //! + TBranch *b_kNaccTrcklts; //! + TBranch *b_kNch; //! + TBranch *b_kCentrality; //! + TBranch *b_kNevents; //! + + ana_sgl(TTree *tree=0); + virtual ~ana_sgl(); + virtual Int_t Cut(Long64_t entry); + virtual Int_t GetEntry(Long64_t entry); + virtual Long64_t LoadTree(Long64_t entry); + virtual void Init(TTree *tree); + virtual void Loop(); + virtual Bool_t Notify(); + virtual void Show(Long64_t entry = -1); + + + //////////my own function///////////////// + + TH2D *hdedx_pt; + TH2D *hdedx_tof_elec_pt; + TH2D *hdedx_tof_all_pt; + TH2D *hdedx_tof_elec_emc_pt; + TH2D *hdedx_tof_all_emc_pt; + TH2D *hdedx_emc_pt; + + TH2D *hbetatof_pt; + TH2D *hbetatof_tof_elec_pt; + TH2D *hbetatof_tof_all_pt; + TH2D *hbetatof_tof_elec_emc_pt; + TH2D *hbetatof_tof_all_emc_pt; + TH2D *hbetatof_emc_pt; + + TH1D *hdedx[1000]; + TH1D *hdedx_tof_elec[1000]; + TH1D *hdedx_tof_all[1000]; + TH1D *hdedx_tof_elec_emc[1000]; + TH1D *hdedx_tof_all_emc[1000]; + TH1D *hdedx_emc[1000]; + + + TH1D *fEventStat; //! Histogram with event statistics + TH1D *fEvent; + TH2D *fdEdXvsPt; + TH2D *fdEdXnSigmaElecvsPt; + TH2D *fTOFbetavsPt; + TH2D *fTOFnSigmaElecvsPt; + TH1F *hCentrality; + TH2F *hV0AC; + TH2F *hV0AC_Ntrk; + TH2F *hV0AC_NaccTrcklts; + + + + TH2D *fdEdXvsPtWithCut; + TH1D *fPtElec[2]; + + TH2D *fNelc_pos_cent[10]; + TH1D *fNelc_all_cent[10]; + + TH2D *fNelc_pos; + TH1D *fNelc_all; + TH2D *fNelc_all_pT; + + + //// pair tree + TH2D *hmasspt[7][11]; + TH2D *hmasspt_weight[7][11]; + + TFile *fout; + Float_t fBinWidth ; + Int_t nHistos ; + + void ana_init(char *filename); + void ana_event(int ientry, int jentry); + void ana_end(void); + void loop_a_file(char *filename); + void ana_set_simflag(bool a) { simflag = a;} + + bool kTOFcut(int itrk); + bool GlobalTrackcut(int itrk); + //bool PairTrackcut(int itrk); + void fill_histograms(int itrk); + void fill_to_tree_variables(void); + void fill_to_tree_track_variables(int itrk); + void add_histograms(TFile *fin); + void select_trigger(int trig){ sel_trigger = trig ; } + + + //// cut function + void set_tpc_dedx_cuts(double low, double high){ + d_tpc_dedx_low = low; + d_tpc_dedx_high = high; + }; + void set_tof_cuts(double low, double high){ + d_flag_tof_cut = true; + d_tof_low = low; + d_tof_high = high; + }; + + void set_veto_for_kaon(double low, double high){ + d_flag_kaon_veto = true; + d_dedx_kaon_veto_low = low; + d_dedx_kaon_veto_high = high; + } + + void set_veto_for_proton(double low, double high){ + d_flag_proton_veto = true; + d_dedx_proton_veto_low = low; + d_dedx_proton_veto_high = high; + } + + void enable_pair_emc_cut(double low, double high){ + d_flag_emc_cut = true; + d_emc_low = low; + d_emc_high = high; + }; + + void enable_pair_phiv_cut(double low){ + d_flag_phiv = true; + d_phiv_cut = low; + }; + + void enable_pait_pt_cut(double low, double high){ + d_flag_pt_cut = true; + d_pt_cut_low = low; + d_pt_cut_high = high; + }; + + void print_cuts(void); + + //// private functions + + void calc_pair(vector e1, vector e2); + void randomize_pool(vector e1, vector e2); + //void fill_pair(etrk *e1, etrk *e2, int type); + void fill_pair(vector::iterator e1, vector::iterator e2, int type); + bool PairTrackcut(vector::iterator e1, vector::iterator e2); + bool reject_conversion(bool val){d_conv_flag = val;} + void check_conversion_pairs(vector &e1, vector &e2); + void check_ghost_pairs(vector &e1); + void calc_vars(vector::iterator e1, vector::iterator e2, double &mass, double &phiv, double &px, double &py, double&pz, + double &pt, double &e, double &phi, double &eta, double &cos, double &psi); + bool pair_cut(void); + + TTree *d_tree; + TTree *d_ntpair; + bool simflag; + int sel_trigger; + + private: + bool d_flag_tof_cut; + bool d_flag_emc_cut; + bool d_flag_phiv; + bool d_flag_pt_cut; + bool d_flag_kaon_veto; + bool d_flag_proton_veto; + double d_tpc_dedx_low; + double d_tpc_dedx_high; + double d_tof_low; + double d_tof_high; + double d_emc_low; + double d_emc_high; + double d_phiv_cut; + double d_pt_cut_low ; + double d_pt_cut_high ; + double d_dedx_kaon_veto_low; + double d_dedx_kaon_veto_high; + double d_dedx_proton_veto_low; + double d_dedx_proton_veto_high; + + bool magnetic_field_mm ; + bool d_conv_flag; + Int_t d_evt; + Double_t d_cent; + Double_t d_ntrk; + Double_t d_xvprim; + Double_t d_yvprim; + Double_t d_zvprim; + Double_t d_nacctrklets; + Double_t d_xres; + Double_t d_yres; + Double_t d_zres; + Int_t d_nelc; + Double_t d_px[100]; + Double_t d_py[100]; + Double_t d_pz[100]; + Double_t d_p[100]; + Double_t d_pt[100]; + Double_t d_xv[100]; + Double_t d_yv[100]; + Double_t d_zv[100]; + Double_t d_phi[100]; + Double_t d_theta[100]; + Double_t d_eta[100]; + Double_t d_c[100]; + Double_t d_nclusITS[100]; + Double_t d_nclusTPC[100]; + Double_t d_nclusTPCiter[100]; + Double_t d_nfclusTPC[100]; + Double_t d_nfclusTPCr[100]; + Double_t d_nfclusTPCrFrac[100]; + Double_t d_TPCsignalN[100]; + Double_t d_TPCsignalNfrac[100]; + Double_t d_TPCchi2cl[100]; + Double_t d_trkstat[100]; + Double_t d_nclsTRD[100]; + Double_t d_TRDntracklets[100]; + Double_t d_TRDpidquality[100]; + Double_t d_TRDprobEle[100]; + Double_t d_TRDprobPio[100]; + Double_t d_impactXY[100]; + Double_t d_impactZ[100]; + Double_t d_tracklength[100]; + Double_t d_ITSsignal[100]; + Double_t d_ITSnsigmaEle[100]; + Double_t d_ITSnsigmaPio[100]; + Double_t d_ITSnsigmaMuo[100]; + Double_t d_ITSnsigmaKao[100]; + Double_t d_ITSnsigmaPro[100]; + Double_t d_PIn[100]; + Double_t d_TPCsignal[100]; + Double_t d_TOFsignal[100]; + Double_t d_TOFbeta[100]; + Double_t d_TPCnSigmaEle[100]; + Double_t d_TPCnSigmaPio[100]; + Double_t d_TPCnSigmaMuo[100]; + Double_t d_TPCnSigmaKao[100]; + Double_t d_TPCnSigmaPro[100]; + Double_t d_TOFnSigmaEle[100]; + Double_t d_TOFnSigmaPio[100]; + Double_t d_TOFnSigmaMuo[100]; + Double_t d_TOFnSigmaKao[100]; + Double_t d_TOFnSigmaPro[100]; + + Double_t d_chi2ndf[100]; + Double_t d_E[100]; + Double_t d_dphi[100]; + Double_t d_deta[100]; + + //////// pair variable + Double_t d_run; + Int_t d_event; + Double_t d_centrality; + Double_t d_prim_xv; + Double_t d_prim_yv; + Double_t d_prim_zv; + Double_t d_mass; + Double_t d_pxpair; + Double_t d_pypair; + Double_t d_pzpair; + Double_t d_ptpair; + Double_t d_epair; + Double_t d_etapair; + Double_t d_phipair; + Double_t d_cos; + Double_t d_phiv; + Double_t d_psi; + Int_t d_pairtype; + + ///////////////////////// + Double_t d_cent1; + Double_t d_xv1; + Double_t d_yv1; + Double_t d_zv1; + Double_t d_px1; + Double_t d_py1; + Double_t d_pz1; + Double_t d_pt1; + Double_t d_eta1; + Double_t d_phi1; + Double_t d_theta1; + Double_t d_tpc1; + Double_t d_ntpc_ele1; + Double_t d_ntpc_pio1; + Double_t d_ntpc_kao1; + Double_t d_ntpc_pro1; + Double_t d_beta1; + Double_t d_ntof_ele1; + Double_t d_ntof_pio1; + Double_t d_ntof_kao1; + Double_t d_ntof_pro1; + Double_t d_its1; + Double_t d_nits1; + Double_t d_ntpc1; + Double_t d_e1; + Double_t d_dphi1; + Double_t d_deta1; + Double_t d_dcaxy1; + Double_t d_dcaz1; + Int_t d_conv1; + + Double_t d_cent2; + Double_t d_xv2; + Double_t d_yv2; + Double_t d_zv2; + Double_t d_px2; + Double_t d_py2; + Double_t d_pz2; + Double_t d_pt2; + Double_t d_eta2; + Double_t d_phi2; + Double_t d_theta2; + Double_t d_tpc2; + Double_t d_ntpc_ele2; + Double_t d_ntpc_pio2; + Double_t d_ntpc_kao2; + Double_t d_ntpc_pro2; + Double_t d_beta2; + Double_t d_ntof_ele2; + Double_t d_ntof_pio2; + Double_t d_ntof_kao2; + Double_t d_ntof_pro2; + Double_t d_its2; + Double_t d_nits2; + Double_t d_ntpc2; + Double_t d_e2; + Double_t d_dphi2; + Double_t d_deta2; + Double_t d_dcaxy2; + Double_t d_dcaz2; + Int_t d_conv2; + + Int_t nelec_pos[10]; //pT bin; + + vector vem; + vector vep; + vector vem_tmp; + vector vep_tmp; + + +}; + +#endif + +#ifdef ana_sgl_cxx +ana_sgl::ana_sgl(TTree *tree) +{ +// if parameter tree is not specified (or zero), connect the file +// used to generate this class and read the Tree. + if (tree == 0) { + TFile *f = (TFile*)gROOT->GetListOfFiles()->FindObject("Resultstakuv2c123456AnalysisResults_t.root"); + if (!f) { + f = new TFile("Resultstakuv2c123456AnalysisResults_t.root"); + f->cd("Resultstakuv2c123456AnalysisResults_t.root:/PWG3_dielectron"); + } + tree = (TTree*)gDirectory->Get("tree_MultiDie_CENT1"); + + } + Init(tree); + d_conv_flag = false; +} + +ana_sgl::~ana_sgl() +{ + if (!fChain) return; + delete fChain->GetCurrentFile(); +} + +Int_t ana_sgl::GetEntry(Long64_t entry) +{ +// Read contents of entry. + if (!fChain) return 0; + return fChain->GetEntry(entry); +} +Long64_t ana_sgl::LoadTree(Long64_t entry) +{ +// Set the environment to read one entry + if (!fChain) return -5; + Long64_t centry = fChain->LoadTree(entry); + if (centry < 0) return centry; + if (!fChain->InheritsFrom(TChain::Class())) return centry; + TChain *chain = (TChain*)fChain; + if (chain->GetTreeNumber() != fCurrent) { + fCurrent = chain->GetTreeNumber(); + Notify(); + } + return centry; +} + +void ana_sgl::Init(TTree *tree) +{ + // The Init() function is called when the selector needs to initialize + // a new tree or chain. Typically here the branch addresses and branch + // pointers of the tree will be set. + // It is normally not necessary to make changes to the generated + // code, but the routine can be extended by the user if needed. + // Init() will be called many times when running on PROOF + // (once per file to be processed). + + // Set branch addresses and branch pointers + if (!tree) return; + fChain = tree; + fCurrent = -1; + fChain->SetMakeClass(1); + + fChain->SetBranchAddress("kNEvent", &kNEvent, &b_kNEvent); + fChain->SetBranchAddress("kMag", &kMag, &b_kMag); + fChain->SetBranchAddress("fkTriggerInfo", &fkTriggerInfo, &b_fkTriggerInfo); + fChain->SetBranchAddress("kTriggerMask", &kTriggerMask, &b_kTriggerMask); + fChain->SetBranchAddress("kTriggerCent", &kTriggerCent, &b_kTriggerCent); + fChain->SetBranchAddress("fkNCut", &fkNCut, &b_fkNCut); + fChain->SetBranchAddress("fkRunNumber", &fkRunNumber, &b_fkRunNumber); + fChain->SetBranchAddress("fkCentrality", &fkCentrality, &b_fkCentrality); + fChain->SetBranchAddress("fkXvPrim", &fkXvPrim, &b_fkXvPrim); + fChain->SetBranchAddress("fkYvPrim", &fkYvPrim, &b_fkYvPrim); + fChain->SetBranchAddress("fkZvPrim", &fkZvPrim, &b_fkZvPrim); + fChain->SetBranchAddress("fkXRes", &fkXRes, &b_fkXRes); + fChain->SetBranchAddress("fkYRes", &fkYRes, &b_fkYRes); + fChain->SetBranchAddress("fkZRes", &fkZRes, &b_fkZRes); + fChain->SetBranchAddress("fkNTrk", &fkNTrk, &b_fkNTrk); + fChain->SetBranchAddress("fkTracks", &fkTracks, &b_fkTracks); + fChain->SetBranchAddress("fkNacc", &fkNacc, &b_fkNacc); + fChain->SetBranchAddress("fkNaccTrcklts", &fkNaccTrcklts, &b_fkNaccTrcklts); + fChain->SetBranchAddress("fkNch", &fkNch, &b_fkNch); + fChain->SetBranchAddress("fkZDCN1E", &fkZDCN1E, &b_fkZDCN1E); + fChain->SetBranchAddress("fkZDCP1E", &fkZDCP1E, &b_fkZDCP1E); + fChain->SetBranchAddress("fkZDCN2E", &fkZDCN2E, &b_fkZDCN2E); + fChain->SetBranchAddress("fkZDCP2E", &fkZDCP2E, &b_fkZDCP2E); + fChain->SetBranchAddress("fkV0A", &fkV0A, &b_fkV0A); + fChain->SetBranchAddress("fkV0C", &fkV0C, &b_fkV0C); + fChain->SetBranchAddress("fkNPar", &fkNPar, &b_fkNPar); + fChain->SetBranchAddress("kPx", kPx, &b_kPx); + fChain->SetBranchAddress("kPy", kPy, &b_kPy); + fChain->SetBranchAddress("kPz", kPz, &b_kPz); + fChain->SetBranchAddress("kPt", kPt, &b_kPt); + fChain->SetBranchAddress("kP", kP, &b_kP); + fChain->SetBranchAddress("kXv", kXv, &b_kXv); + fChain->SetBranchAddress("kYv", kYv, &b_kYv); + fChain->SetBranchAddress("kZv", kZv, &b_kZv); + fChain->SetBranchAddress("kOneOverPt", kOneOverPt, &b_kOneOverPt); + fChain->SetBranchAddress("kPhi", kPhi, &b_kPhi); + fChain->SetBranchAddress("kTheta", kTheta, &b_kTheta); + fChain->SetBranchAddress("kEta", kEta, &b_kEta); + fChain->SetBranchAddress("kY", kY, &b_kY); + fChain->SetBranchAddress("kE", kE, &b_kE); + fChain->SetBranchAddress("kM", kM, &b_kM); + fChain->SetBranchAddress("kCharge", kCharge, &b_kCharge); + fChain->SetBranchAddress("kNclsITS", kNclsITS, &b_kNclsITS); + fChain->SetBranchAddress("kNclsTPC", kNclsTPC, &b_kNclsTPC); + fChain->SetBranchAddress("kNclsTPCiter1", kNclsTPCiter1, &b_kNclsTPCiter1); + fChain->SetBranchAddress("kNFclsTPC", kNFclsTPC, &b_kNFclsTPC); + fChain->SetBranchAddress("kNFclsTPCr", kNFclsTPCr, &b_kNFclsTPCr); + fChain->SetBranchAddress("kNFclsTPCrFrac", kNFclsTPCrFrac, &b_kNFclsTPCrFrac); + fChain->SetBranchAddress("kTPCsignalN", kTPCsignalN, &b_kTPCsignalN); + fChain->SetBranchAddress("kTPCsignalNfrac", kTPCsignalNfrac, &b_kTPCsignalNfrac); + fChain->SetBranchAddress("kTPCchi2Cl", kTPCchi2Cl, &b_kTPCchi2Cl); + fChain->SetBranchAddress("kTrackStatus", kTrackStatus, &b_kTrackStatus); + fChain->SetBranchAddress("kNclsTRD", kNclsTRD, &b_kNclsTRD); + fChain->SetBranchAddress("kTRDntracklets", kTRDntracklets, &b_kTRDntracklets); + fChain->SetBranchAddress("kTRDpidQuality", kTRDpidQuality, &b_kTRDpidQuality); + fChain->SetBranchAddress("kTRDprobEle", kTRDprobEle, &b_kTRDprobEle); + fChain->SetBranchAddress("kTRDprobPio", kTRDprobPio, &b_kTRDprobPio); + fChain->SetBranchAddress("kImpactParXY", kImpactParXY, &b_kImpactParXY); + fChain->SetBranchAddress("kImpactParZ", kImpactParZ, &b_kImpactParZ); + fChain->SetBranchAddress("kTrackLength", kTrackLength, &b_kTrackLength); + fChain->SetBranchAddress("kPdgCode", kPdgCode, &b_kPdgCode); + fChain->SetBranchAddress("kPdgCodeMother", kPdgCodeMother, &b_kPdgCodeMother); + fChain->SetBranchAddress("kPdgCodeGrandMother", kPdgCodeGrandMother, &b_kPdgCodeGrandMother); + fChain->SetBranchAddress("kNumberOfDaughters", kNumberOfDaughters, &b_kNumberOfDaughters); + fChain->SetBranchAddress("kHaveSameMother", kHaveSameMother, &b_kHaveSameMother); + fChain->SetBranchAddress("kIsJpsiPrimary", kIsJpsiPrimary, &b_kIsJpsiPrimary); + fChain->SetBranchAddress("kITSsignal", kITSsignal, &b_kITSsignal); + fChain->SetBranchAddress("kITSsignalSSD1", kITSsignalSSD1, &b_kITSsignalSSD1); + fChain->SetBranchAddress("kITSsignalSSD2", kITSsignalSSD2, &b_kITSsignalSSD2); + fChain->SetBranchAddress("kITSsignalSDD1", kITSsignalSDD1, &b_kITSsignalSDD1); + fChain->SetBranchAddress("kITSsignalSDD2", kITSsignalSDD2, &b_kITSsignalSDD2); + fChain->SetBranchAddress("kITSclusterMap", kITSclusterMap, &b_kITSclusterMap); + fChain->SetBranchAddress("kITSnSigmaEle", kITSnSigmaEle, &b_kITSnSigmaEle); + fChain->SetBranchAddress("kITSnSigmaPio", kITSnSigmaPio, &b_kITSnSigmaPio); + fChain->SetBranchAddress("kITSnSigmaMuo", kITSnSigmaMuo, &b_kITSnSigmaMuo); + fChain->SetBranchAddress("kITSnSigmaKao", kITSnSigmaKao, &b_kITSnSigmaKao); + fChain->SetBranchAddress("kITSnSigmaPro", kITSnSigmaPro, &b_kITSnSigmaPro); + fChain->SetBranchAddress("kPIn", kPIn, &b_kPIn); + fChain->SetBranchAddress("kTPCsignal", kTPCsignal, &b_kTPCsignal); + fChain->SetBranchAddress("kTOFsignal", kTOFsignal, &b_kTOFsignal); + fChain->SetBranchAddress("kTOFbeta", kTOFbeta, &b_kTOFbeta); + fChain->SetBranchAddress("kTPCnSigmaEle", kTPCnSigmaEle, &b_kTPCnSigmaEle); + fChain->SetBranchAddress("kTPCnSigmaPio", kTPCnSigmaPio, &b_kTPCnSigmaPio); + fChain->SetBranchAddress("kTPCnSigmaMuo", kTPCnSigmaMuo, &b_kTPCnSigmaMuo); + fChain->SetBranchAddress("kTPCnSigmaKao", kTPCnSigmaKao, &b_kTPCnSigmaKao); + fChain->SetBranchAddress("kTPCnSigmaPro", kTPCnSigmaPro, &b_kTPCnSigmaPro); + fChain->SetBranchAddress("kTOFnSigmaEle", kTOFnSigmaEle, &b_kTOFnSigmaEle); + fChain->SetBranchAddress("kTOFnSigmaPio", kTOFnSigmaPio, &b_kTOFnSigmaPio); + fChain->SetBranchAddress("kTOFnSigmaMuo", kTOFnSigmaMuo, &b_kTOFnSigmaMuo); + fChain->SetBranchAddress("kTOFnSigmaKao", kTOFnSigmaKao, &b_kTOFnSigmaKao); + fChain->SetBranchAddress("kTOFnSigmaPro", kTOFnSigmaPro, &b_kTOFnSigmaPro); + fChain->SetBranchAddress("kKinkIndex0", kKinkIndex0, &b_kKinkIndex0); + fChain->SetBranchAddress("kChi2NDF", kChi2NDF, &b_kChi2NDF); + fChain->SetBranchAddress("kDecayLength", kDecayLength, &b_kDecayLength); + fChain->SetBranchAddress("kR", kR, &b_kR); + fChain->SetBranchAddress("kOpeningAngle", kOpeningAngle, &b_kOpeningAngle); + fChain->SetBranchAddress("kThetaHE", kThetaHE, &b_kThetaHE); + fChain->SetBranchAddress("kPhiHE", kPhiHE, &b_kPhiHE); + fChain->SetBranchAddress("kThetaCS", kThetaCS, &b_kThetaCS); + fChain->SetBranchAddress("kPhiCS", kPhiCS, &b_kPhiCS); + fChain->SetBranchAddress("kLegDist", kLegDist, &b_kLegDist); + fChain->SetBranchAddress("kLegDistXY", kLegDistXY, &b_kLegDistXY); + fChain->SetBranchAddress("kDeltaEta", kDeltaEta, &b_kDeltaEta); + fChain->SetBranchAddress("kDeltaPhi", kDeltaPhi, &b_kDeltaPhi); + fChain->SetBranchAddress("kMerr", kMerr, &b_kMerr); + fChain->SetBranchAddress("kDCA", kDCA, &b_kDCA); + fChain->SetBranchAddress("kPairType", kPairType, &b_kPairType); + fChain->SetBranchAddress("kPseudoProperTime", kPseudoProperTime, &b_kPseudoProperTime); + fChain->SetBranchAddress("kXvPrim", kXvPrim, &b_kXvPrim); + fChain->SetBranchAddress("kYvPrim", kYvPrim, &b_kYvPrim); + fChain->SetBranchAddress("kZvPrim", kZvPrim, &b_kZvPrim); + fChain->SetBranchAddress("kXRes", kXRes, &b_kXRes); + fChain->SetBranchAddress("kYRes", kYRes, &b_kYRes); + fChain->SetBranchAddress("kZRes", kZRes, &b_kZRes); + fChain->SetBranchAddress("kNTrk", kNTrk, &b_kNTrk); + fChain->SetBranchAddress("kTracks", kTracks, &b_kTracks); + fChain->SetBranchAddress("kNacc", kNacc, &b_kNacc); + fChain->SetBranchAddress("kNaccTrcklts", kNaccTrcklts, &b_kNaccTrcklts); + fChain->SetBranchAddress("kNch", kNch, &b_kNch); + fChain->SetBranchAddress("kCentrality", kCentrality, &b_kCentrality); + fChain->SetBranchAddress("kNevents", kNevents, &b_kNevents); + Notify(); +} + +Bool_t ana_sgl::Notify() +{ + // The Notify() function is called when a new file is opened. This + // can be either for a new TTree in a TChain or when when a new TTree + // is started when using PROOF. It is normally not necessary to make changes + // to the generated code, but the routine can be extended by the + // user if needed. The return value is currently not used. + + return kTRUE; +} + +void ana_sgl::Show(Long64_t entry) +{ +// Print contents of entry. +// If entry is not specified, print current entry + if (!fChain) return; + fChain->Show(entry); +} +Int_t ana_sgl::Cut(Long64_t entry) +{ +// This function may be called from Loop. +// returns 1 if entry is accepted. +// returns -1 otherwise. + return 1; +} +#endif // #ifdef ana_sgl_cxx diff --git a/PWGDQ/dielectron/TakuAlberica/pair/ana_sglDict.C b/PWGDQ/dielectron/TakuAlberica/pair/ana_sglDict.C new file mode 100644 index 00000000000..63dd4865a86 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/pair/ana_sglDict.C @@ -0,0 +1,1385 @@ +// +// File generated by rootcint at Tue Jan 17 13:32:26 2012 + +// Do NOT change. Changes will be lost next time file is generated +// + +#define R__DICTIONARY_FILENAME ana_sglDict +#include "RConfig.h" //rootcint 4834 +#if !defined(R__ACCESS_IN_SYMBOL) +//Break the privacy of classes -- Disabled for the moment +#define private public +#define protected public +#endif + +// Since CINT ignores the std namespace, we need to do so in this file. +namespace std {} using namespace std; +#include "ana_sglDict.h" + +#include "TClass.h" +#include "TBuffer.h" +#include "TMemberInspector.h" +#include "TError.h" + +#ifndef G__ROOT +#define G__ROOT +#endif + +#include "RtypesImp.h" +#include "TIsAProxy.h" +#include "TFileMergeInfo.h" + +// START OF SHADOWS + +namespace ROOT { + namespace Shadow { + } // of namespace Shadow +} // of namespace ROOT +// END OF SHADOWS + +namespace ROOT { + void ana_sgl_ShowMembers(void *obj, TMemberInspector &R__insp); + static void ana_sgl_Dictionary(); + static void *new_ana_sgl(void *p = 0); + static void *newArray_ana_sgl(Long_t size, void *p); + static void delete_ana_sgl(void *p); + static void deleteArray_ana_sgl(void *p); + static void destruct_ana_sgl(void *p); + + // Function generating the singleton type initializer + static TGenericClassInfo *GenerateInitInstanceLocal(const ::ana_sgl*) + { + ::ana_sgl *ptr = 0; + static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ana_sgl),0); + static ::ROOT::TGenericClassInfo + instance("ana_sgl", "./ana_sgl.h", 94, + typeid(::ana_sgl), DefineBehavior(ptr, ptr), + 0, &ana_sgl_Dictionary, isa_proxy, 0, + sizeof(::ana_sgl) ); + instance.SetNew(&new_ana_sgl); + instance.SetNewArray(&newArray_ana_sgl); + instance.SetDelete(&delete_ana_sgl); + instance.SetDeleteArray(&deleteArray_ana_sgl); + instance.SetDestructor(&destruct_ana_sgl); + return &instance; + } + TGenericClassInfo *GenerateInitInstance(const ::ana_sgl*) + { + return GenerateInitInstanceLocal((::ana_sgl*)0); + } + // Static variable to force the class initialization + static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ana_sgl*)0x0); R__UseDummy(_R__UNIQUE_(Init)); + + // Dictionary for non-ClassDef classes + static void ana_sgl_Dictionary() { + ::ROOT::GenerateInitInstanceLocal((const ::ana_sgl*)0x0)->GetClass(); + } + +} // end of namespace ROOT + +namespace ROOT { + // Wrappers around operator new + static void *new_ana_sgl(void *p) { + return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ana_sgl : new ::ana_sgl; + } + static void *newArray_ana_sgl(Long_t nElements, void *p) { + return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ana_sgl[nElements] : new ::ana_sgl[nElements]; + } + // Wrapper around operator delete + static void delete_ana_sgl(void *p) { + delete ((::ana_sgl*)p); + } + static void deleteArray_ana_sgl(void *p) { + delete [] ((::ana_sgl*)p); + } + static void destruct_ana_sgl(void *p) { + typedef ::ana_sgl current_t; + ((current_t*)p)->~current_t(); + } +} // end of namespace ROOT for class ::ana_sgl + +/******************************************************** +* ana_sglDict.C +* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED +* FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX(). +* CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE. +********************************************************/ + +#ifdef G__MEMTEST +#undef malloc +#undef free +#endif + +#if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3)) +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif + +extern "C" void G__cpp_reset_tagtableana_sglDict(); + +extern "C" void G__set_cpp_environmentana_sglDict() { + G__add_compiledheader("TObject.h"); + G__add_compiledheader("TMemberInspector.h"); + G__add_compiledheader("ana_sgl.h"); + G__cpp_reset_tagtableana_sglDict(); +} +#include +extern "C" int G__cpp_dllrevana_sglDict() { return(30051515); } + +/********************************************************* +* Member function Interface Method +*********************************************************/ + +/* ana_sgl */ +static int G__ana_sglDict_580_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ana_sgl* p = NULL; + char* gvp = (char*) G__getgvp(); + switch (libp->paran) { + case 1: + //m: 1 + if ((gvp == (char*)G__PVOID) || (gvp == 0)) { + p = new ana_sgl((TTree*) G__int(libp->para[0])); + } else { + p = new((void*) gvp) ana_sgl((TTree*) G__int(libp->para[0])); + } + break; + case 0: + int n = G__getaryconstruct(); + if (n) { + if ((gvp == (char*)G__PVOID) || (gvp == 0)) { + p = new ana_sgl[n]; + } else { + p = new((void*) gvp) ana_sgl[n]; + } + } else { + if ((gvp == (char*)G__PVOID) || (gvp == 0)) { + p = new ana_sgl; + } else { + p = new((void*) gvp) ana_sgl; + } + } + break; + } + result7->obj.i = (long) p; + result7->ref = (long) p; + G__set_tagnum(result7,G__get_linked_tagnum(&G__ana_sglDictLN_ana_sgl)); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((ana_sgl*) G__getstructoffset())->Cut((Long64_t) G__Longlong(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((ana_sgl*) G__getstructoffset())->GetEntry((Long64_t) G__Longlong(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letLonglong(result7, 110, (G__int64) ((ana_sgl*) G__getstructoffset())->LoadTree((Long64_t) G__Longlong(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->Init((TTree*) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->Loop(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((ana_sgl*) G__getstructoffset())->Notify()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + switch (libp->paran) { + case 1: + ((ana_sgl*) G__getstructoffset())->Show((Long64_t) G__Longlong(libp->para[0])); + G__setnull(result7); + break; + case 0: + ((ana_sgl*) G__getstructoffset())->Show(); + G__setnull(result7); + break; + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->ana_init((char*) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->ana_event((int) G__int(libp->para[0]), (int) G__int(libp->para[1])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->ana_end(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->loop_a_file((char*) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->ana_set_simflag((bool) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((ana_sgl*) G__getstructoffset())->kTOFcut((int) G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((ana_sgl*) G__getstructoffset())->GlobalTrackcut((int) G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->fill_histograms((int) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->fill_to_tree_variables(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->fill_to_tree_track_variables((int) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->add_histograms((TFile*) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->select_trigger((int) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->set_tpc_dedx_cuts((double) G__double(libp->para[0]), (double) G__double(libp->para[1])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->set_tof_cuts((double) G__double(libp->para[0]), (double) G__double(libp->para[1])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->set_veto_for_kaon((double) G__double(libp->para[0]), (double) G__double(libp->para[1])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->set_veto_for_proton((double) G__double(libp->para[0]), (double) G__double(libp->para[1])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->enable_pair_emc_cut((double) G__double(libp->para[0]), (double) G__double(libp->para[1])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->enable_pair_phiv_cut((double) G__double(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->enable_pait_pt_cut((double) G__double(libp->para[0]), (double) G__double(libp->para[1])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->print_cuts(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->calc_pair(*((vector*) G__int(libp->para[0])), *((vector*) G__int(libp->para[1]))); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->randomize_pool(*((vector*) G__int(libp->para[0])), *((vector*) G__int(libp->para[1]))); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->fill_pair(*((vector >::iterator*) G__int(libp->para[0])), *((vector >::iterator*) G__int(libp->para[1])) +, (int) G__int(libp->para[2])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((ana_sgl*) G__getstructoffset())->PairTrackcut(*((vector >::iterator*) G__int(libp->para[0])), *((vector >::iterator*) G__int(libp->para[1])))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((ana_sgl*) G__getstructoffset())->reject_conversion((bool) G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->check_conversion_pairs(*(vector*) libp->para[0].ref, *(vector*) libp->para[1].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->check_ghost_pairs(*(vector*) libp->para[0].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((ana_sgl*) G__getstructoffset())->calc_vars( +*((vector >::iterator*) G__int(libp->para[0])), *((vector >::iterator*) G__int(libp->para[1])) +, *(double*) G__Doubleref(&libp->para[2]), *(double*) G__Doubleref(&libp->para[3]) +, *(double*) G__Doubleref(&libp->para[4]), *(double*) G__Doubleref(&libp->para[5]) +, *(double*) G__Doubleref(&libp->para[6]), *(double*) G__Doubleref(&libp->para[7]) +, *(double*) G__Doubleref(&libp->para[8]), *(double*) G__Doubleref(&libp->para[9]) +, *(double*) G__Doubleref(&libp->para[10]), *(double*) G__Doubleref(&libp->para[11]) +, *(double*) G__Doubleref(&libp->para[12])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__ana_sglDict_580_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 103, (long) ((ana_sgl*) G__getstructoffset())->pair_cut()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic copy constructor +static int G__ana_sglDict_580_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) + +{ + ana_sgl* p; + void* tmp = (void*) G__int(libp->para[0]); + p = new ana_sgl(*(ana_sgl*) tmp); + result7->obj.i = (long) p; + result7->ref = (long) p; + G__set_tagnum(result7,G__get_linked_tagnum(&G__ana_sglDictLN_ana_sgl)); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef ana_sgl G__Tana_sgl; +static int G__ana_sglDict_580_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + char* gvp = (char*) G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 0 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == (char*)G__PVOID) { + delete[] (ana_sgl*) soff; + } else { + G__setgvp((long) G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((ana_sgl*) (soff+(sizeof(ana_sgl)*i)))->~G__Tana_sgl(); + } + G__setgvp((long)gvp); + } + } else { + if (gvp == (char*)G__PVOID) { + delete (ana_sgl*) soff; + } else { + G__setgvp((long) G__PVOID); + ((ana_sgl*) (soff))->~G__Tana_sgl(); + G__setgvp((long)gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic assignment operator +static int G__ana_sglDict_580_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ana_sgl* dest = (ana_sgl*) G__getstructoffset(); + *dest = *(ana_sgl*) libp->para[0].ref; + const ana_sgl& obj = *dest; + result7->ref = (long) (&obj); + result7->obj.i = (long) (&obj); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* Setting up global function */ + +/********************************************************* +* Member function Stub +*********************************************************/ + +/* ana_sgl */ + +/********************************************************* +* Global function Stub +*********************************************************/ + +/********************************************************* +* Get size of pointer to member function +*********************************************************/ +class G__Sizep2memfuncana_sglDict { + public: + G__Sizep2memfuncana_sglDict(): p(&G__Sizep2memfuncana_sglDict::sizep2memfunc) {} + size_t sizep2memfunc() { return(sizeof(p)); } + private: + size_t (G__Sizep2memfuncana_sglDict::*p)(); +}; + +size_t G__get_sizep2memfuncana_sglDict() +{ + G__Sizep2memfuncana_sglDict a; + G__setsizep2memfunc((int)a.sizep2memfunc()); + return((size_t)a.sizep2memfunc()); +} + + +/********************************************************* +* virtual base class offset calculation interface +*********************************************************/ + + /* Setting up class inheritance */ + +/********************************************************* +* Inheritance information setup/ +*********************************************************/ +extern "C" void G__cpp_setup_inheritanceana_sglDict() { + + /* Setting up class inheritance */ +} + +/********************************************************* +* typedef information setup/ +*********************************************************/ +extern "C" void G__cpp_setup_typetableana_sglDict() { + + /* Setting up typedef entry */ + G__search_typename2("Int_t",105,-1,0,-1); + G__setnewtype(-1,"Signed integer 4 bytes (int)",0); + G__search_typename2("Bool_t",103,-1,0,-1); + G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0); + G__search_typename2("Long64_t",110,-1,0,-1); + G__setnewtype(-1,"Portable signed long integer 8 bytes",0); + G__search_typename2("vector",117,G__get_linked_tagnum(&G__ana_sglDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__ana_sglDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__ana_sglDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__ana_sglDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__ana_sglDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("vector",117,G__get_linked_tagnum(&G__ana_sglDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__ana_sglDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__ana_sglDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__ana_sglDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__ana_sglDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("iterator",117,G__get_linked_tagnum(&G__ana_sglDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("iterator",117,G__get_linked_tagnum(&G__ana_sglDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("iterator",117,G__get_linked_tagnum(&G__ana_sglDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("iterator",117,G__get_linked_tagnum(&G__ana_sglDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("map",117,G__get_linked_tagnum(&G__ana_sglDictLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("map",117,G__get_linked_tagnum(&G__ana_sglDictLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("map >",117,G__get_linked_tagnum(&G__ana_sglDictLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TVectorT",117,G__get_linked_tagnum(&G__ana_sglDictLN_TVectorTlEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TVectorT",117,G__get_linked_tagnum(&G__ana_sglDictLN_TVectorTlEdoublegR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTBase",117,G__get_linked_tagnum(&G__ana_sglDictLN_TMatrixTBaselEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTBase",117,G__get_linked_tagnum(&G__ana_sglDictLN_TMatrixTBaselEdoublegR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("vector",117,G__get_linked_tagnum(&G__ana_sglDictLN_vectorlEetrkcOallocatorlEetrkgRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__ana_sglDictLN_reverse_iteratorlEvectorlEetrkcOallocatorlEetrkgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__ana_sglDictLN_vectorlEetrkcOallocatorlEetrkgRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__ana_sglDictLN_reverse_iteratorlEvectorlEetrkcOallocatorlEetrkgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__ana_sglDictLN_vectorlEetrkcOallocatorlEetrkgRsPgR)); + G__setnewtype(-1,NULL,0); +} + +/********************************************************* +* Data Member information setup/ +*********************************************************/ + + /* Setting up class,struct,union tag member variable */ + + /* ana_sgl */ +static void G__setup_memvarana_sgl(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__ana_sglDictLN_ana_sgl)); + { ana_sgl *p; p=(ana_sgl*)0x1000; if (p) { } + G__memvar_setup((void*)((long)(&p->fChain)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TTree),-1,-1,1,"fChain=",0,"!pointer to the analyzed TTree or TChain"); + G__memvar_setup((void*)((long)(&p->fCurrent)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fCurrent=",0,"!current Tree number in a TChain"); + G__memvar_setup((void*)((long)(&p->kNEvent)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"kNEvent=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->kMag)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kMag=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkTriggerInfo)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TObjArray),-1,-1,1,"fkTriggerInfo=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->kTriggerMask)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTriggerMask=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->kTriggerCent)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"kTriggerCent=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkNCut)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkNCut=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkRunNumber)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkRunNumber=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkCentrality)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkCentrality=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkXvPrim)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkXvPrim=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkYvPrim)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkYvPrim=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkZvPrim)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkZvPrim=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkXRes)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkXRes=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkYRes)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkYRes=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkZRes)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkZRes=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkNTrk)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkNTrk=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkTracks)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkTracks=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkNacc)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkNacc=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkNaccTrcklts)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkNaccTrcklts=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkNch)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkNch=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkZDCN1E)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkZDCN1E=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkZDCP1E)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkZDCP1E=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkZDCN2E)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkZDCN2E=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkZDCP2E)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkZDCP2E=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkV0A)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkV0A=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkV0C)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fkV0C=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fkNPar)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fkNPar=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->kPx)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kPx[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kPy)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kPy[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kPz)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kPz[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kPt)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kPt[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kP)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kP[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kXv)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kXv[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kYv)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kYv[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kZv)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kZv[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kOneOverPt)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kOneOverPt[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kPhi)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kPhi[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTheta)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTheta[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kEta)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kEta[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kY)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kY[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kE)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kE[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kM)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kM[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kCharge)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kCharge[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kNclsITS)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kNclsITS[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kNclsTPC)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kNclsTPC[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kNclsTPCiter1)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kNclsTPCiter1[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kNFclsTPC)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kNFclsTPC[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kNFclsTPCr)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kNFclsTPCr[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kNFclsTPCrFrac)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kNFclsTPCrFrac[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTPCsignalN)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTPCsignalN[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTPCsignalNfrac)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTPCsignalNfrac[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTPCchi2Cl)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTPCchi2Cl[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTrackStatus)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTrackStatus[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kNclsTRD)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kNclsTRD[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTRDntracklets)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTRDntracklets[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTRDpidQuality)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTRDpidQuality[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTRDprobEle)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTRDprobEle[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTRDprobPio)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTRDprobPio[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kImpactParXY)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kImpactParXY[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kImpactParZ)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kImpactParZ[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTrackLength)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTrackLength[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kPdgCode)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kPdgCode[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kPdgCodeMother)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kPdgCodeMother[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kPdgCodeGrandMother)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kPdgCodeGrandMother[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kNumberOfDaughters)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kNumberOfDaughters[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kHaveSameMother)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kHaveSameMother[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kIsJpsiPrimary)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kIsJpsiPrimary[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kITSsignal)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kITSsignal[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kITSsignalSSD1)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kITSsignalSSD1[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kITSsignalSSD2)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kITSsignalSSD2[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kITSsignalSDD1)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kITSsignalSDD1[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kITSsignalSDD2)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kITSsignalSDD2[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kITSclusterMap)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kITSclusterMap[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kITSnSigmaEle)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kITSnSigmaEle[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kITSnSigmaPio)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kITSnSigmaPio[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kITSnSigmaMuo)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kITSnSigmaMuo[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kITSnSigmaKao)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kITSnSigmaKao[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kITSnSigmaPro)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kITSnSigmaPro[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kPIn)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kPIn[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTPCsignal)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTPCsignal[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTOFsignal)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTOFsignal[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTOFbeta)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTOFbeta[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTPCnSigmaEle)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTPCnSigmaEle[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTPCnSigmaPio)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTPCnSigmaPio[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTPCnSigmaMuo)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTPCnSigmaMuo[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTPCnSigmaKao)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTPCnSigmaKao[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTPCnSigmaPro)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTPCnSigmaPro[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTOFnSigmaEle)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTOFnSigmaEle[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTOFnSigmaPio)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTOFnSigmaPio[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTOFnSigmaMuo)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTOFnSigmaMuo[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTOFnSigmaKao)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTOFnSigmaKao[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTOFnSigmaPro)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTOFnSigmaPro[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kKinkIndex0)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kKinkIndex0[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kChi2NDF)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kChi2NDF[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kDecayLength)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kDecayLength[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kR)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kR[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kOpeningAngle)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kOpeningAngle[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kThetaHE)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kThetaHE[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kPhiHE)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kPhiHE[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kThetaCS)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kThetaCS[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kPhiCS)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kPhiCS[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kLegDist)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kLegDist[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kLegDistXY)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kLegDistXY[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kDeltaEta)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kDeltaEta[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kDeltaPhi)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kDeltaPhi[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kMerr)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kMerr[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kDCA)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kDCA[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kPairType)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kPairType[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kPseudoProperTime)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kPseudoProperTime[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kXvPrim)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kXvPrim[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kYvPrim)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kYvPrim[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kZvPrim)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kZvPrim[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kXRes)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kXRes[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kYRes)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kYRes[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kZRes)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kZRes[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kNTrk)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kNTrk[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kTracks)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kTracks[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kNacc)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kNacc[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kNaccTrcklts)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kNaccTrcklts[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kNch)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kNch[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kCentrality)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kCentrality[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->kNevents)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"kNevents[200]=",0,"[fkNPar]"); + G__memvar_setup((void*)((long)(&p->b_kNEvent)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kNEvent=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kMag)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kMag=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkTriggerInfo)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkTriggerInfo=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTriggerMask)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTriggerMask=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTriggerCent)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTriggerCent=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkNCut)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkNCut=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkRunNumber)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkRunNumber=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkCentrality)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkCentrality=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkXvPrim)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkXvPrim=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkYvPrim)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkYvPrim=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkZvPrim)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkZvPrim=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkXRes)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkXRes=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkYRes)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkYRes=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkZRes)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkZRes=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkNTrk)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkNTrk=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkTracks)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkTracks=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkNacc)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkNacc=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkNaccTrcklts)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkNaccTrcklts=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkNch)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkNch=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkZDCN1E)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkZDCN1E=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkZDCP1E)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkZDCP1E=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkZDCN2E)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkZDCN2E=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkZDCP2E)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkZDCP2E=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkV0A)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkV0A=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkV0C)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkV0C=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_fkNPar)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_fkNPar=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kPx)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kPx=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kPy)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kPy=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kPz)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kPz=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kPt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kPt=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kP)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kP=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kXv)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kXv=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kYv)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kYv=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kZv)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kZv=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kOneOverPt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kOneOverPt=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kPhi)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kPhi=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTheta)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTheta=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kEta)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kEta=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kY)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kY=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kE)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kE=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kM)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kM=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kCharge)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kCharge=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kNclsITS)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kNclsITS=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kNclsTPC)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kNclsTPC=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kNclsTPCiter1)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kNclsTPCiter1=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kNFclsTPC)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kNFclsTPC=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kNFclsTPCr)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kNFclsTPCr=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kNFclsTPCrFrac)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kNFclsTPCrFrac=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTPCsignalN)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTPCsignalN=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTPCsignalNfrac)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTPCsignalNfrac=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTPCchi2Cl)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTPCchi2Cl=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTrackStatus)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTrackStatus=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kNclsTRD)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kNclsTRD=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTRDntracklets)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTRDntracklets=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTRDpidQuality)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTRDpidQuality=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTRDprobEle)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTRDprobEle=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTRDprobPio)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTRDprobPio=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kImpactParXY)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kImpactParXY=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kImpactParZ)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kImpactParZ=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTrackLength)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTrackLength=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kPdgCode)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kPdgCode=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kPdgCodeMother)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kPdgCodeMother=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kPdgCodeGrandMother)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kPdgCodeGrandMother=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kNumberOfDaughters)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kNumberOfDaughters=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kHaveSameMother)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kHaveSameMother=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kIsJpsiPrimary)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kIsJpsiPrimary=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kITSsignal)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kITSsignal=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kITSsignalSSD1)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kITSsignalSSD1=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kITSsignalSSD2)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kITSsignalSSD2=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kITSsignalSDD1)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kITSsignalSDD1=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kITSsignalSDD2)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kITSsignalSDD2=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kITSclusterMap)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kITSclusterMap=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kITSnSigmaEle)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kITSnSigmaEle=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kITSnSigmaPio)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kITSnSigmaPio=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kITSnSigmaMuo)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kITSnSigmaMuo=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kITSnSigmaKao)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kITSnSigmaKao=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kITSnSigmaPro)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kITSnSigmaPro=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kPIn)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kPIn=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTPCsignal)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTPCsignal=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTOFsignal)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTOFsignal=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTOFbeta)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTOFbeta=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTPCnSigmaEle)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTPCnSigmaEle=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTPCnSigmaPio)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTPCnSigmaPio=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTPCnSigmaMuo)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTPCnSigmaMuo=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTPCnSigmaKao)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTPCnSigmaKao=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTPCnSigmaPro)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTPCnSigmaPro=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTOFnSigmaEle)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTOFnSigmaEle=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTOFnSigmaPio)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTOFnSigmaPio=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTOFnSigmaMuo)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTOFnSigmaMuo=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTOFnSigmaKao)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTOFnSigmaKao=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTOFnSigmaPro)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTOFnSigmaPro=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kKinkIndex0)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kKinkIndex0=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kChi2NDF)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kChi2NDF=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kDecayLength)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kDecayLength=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kR)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kR=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kOpeningAngle)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kOpeningAngle=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kThetaHE)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kThetaHE=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kPhiHE)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kPhiHE=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kThetaCS)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kThetaCS=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kPhiCS)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kPhiCS=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kLegDist)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kLegDist=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kLegDistXY)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kLegDistXY=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kDeltaEta)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kDeltaEta=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kDeltaPhi)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kDeltaPhi=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kMerr)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kMerr=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kDCA)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kDCA=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kPairType)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kPairType=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kPseudoProperTime)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kPseudoProperTime=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kXvPrim)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kXvPrim=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kYvPrim)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kYvPrim=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kZvPrim)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kZvPrim=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kXRes)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kXRes=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kYRes)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kYRes=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kZRes)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kZRes=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kNTrk)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kNTrk=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kTracks)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kTracks=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kNacc)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kNacc=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kNaccTrcklts)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kNaccTrcklts=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kNch)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kNch=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kCentrality)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kCentrality=",0,"!"); + G__memvar_setup((void*)((long)(&p->b_kNevents)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TBranch),-1,-1,1,"b_kNevents=",0,"!"); + G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hdedx_pt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"hdedx_pt=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hdedx_tof_elec_pt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"hdedx_tof_elec_pt=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hdedx_tof_all_pt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"hdedx_tof_all_pt=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hdedx_tof_elec_emc_pt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"hdedx_tof_elec_emc_pt=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hdedx_tof_all_emc_pt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"hdedx_tof_all_emc_pt=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hdedx_emc_pt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"hdedx_emc_pt=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hbetatof_pt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"hbetatof_pt=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hbetatof_tof_elec_pt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"hbetatof_tof_elec_pt=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hbetatof_tof_all_pt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"hbetatof_tof_all_pt=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hbetatof_tof_elec_emc_pt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"hbetatof_tof_elec_emc_pt=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hbetatof_tof_all_emc_pt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"hbetatof_tof_all_emc_pt=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hbetatof_emc_pt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"hbetatof_emc_pt=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hdedx)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH1D),-1,-1,1,"hdedx[1000]=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hdedx_tof_elec)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH1D),-1,-1,1,"hdedx_tof_elec[1000]=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hdedx_tof_all)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH1D),-1,-1,1,"hdedx_tof_all[1000]=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hdedx_tof_elec_emc)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH1D),-1,-1,1,"hdedx_tof_elec_emc[1000]=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hdedx_tof_all_emc)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH1D),-1,-1,1,"hdedx_tof_all_emc[1000]=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hdedx_emc)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH1D),-1,-1,1,"hdedx_emc[1000]=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fEventStat)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH1D),-1,-1,1,"fEventStat=",0,"! Histogram with event statistics"); + G__memvar_setup((void*)((long)(&p->fEvent)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH1D),-1,-1,1,"fEvent=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fdEdXvsPt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"fdEdXvsPt=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fdEdXnSigmaElecvsPt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"fdEdXnSigmaElecvsPt=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fTOFbetavsPt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"fTOFbetavsPt=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fTOFnSigmaElecvsPt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"fTOFnSigmaElecvsPt=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hCentrality)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH1F),-1,-1,1,"hCentrality=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hV0AC)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2F),-1,-1,1,"hV0AC=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hV0AC_Ntrk)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2F),-1,-1,1,"hV0AC_Ntrk=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hV0AC_NaccTrcklts)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2F),-1,-1,1,"hV0AC_NaccTrcklts=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fdEdXvsPtWithCut)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"fdEdXvsPtWithCut=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fPtElec)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH1D),-1,-1,1,"fPtElec[2]=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fNelc_pos_cent)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"fNelc_pos_cent[10]=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fNelc_all_cent)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH1D),-1,-1,1,"fNelc_all_cent[10]=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fNelc_pos)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"fNelc_pos=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fNelc_all)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH1D),-1,-1,1,"fNelc_all=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fNelc_all_pT)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"fNelc_all_pT=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hmasspt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"hmasspt[7][11]=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->hmasspt_weight)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TH2D),-1,-1,1,"hmasspt_weight[7][11]=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fout)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TFile),-1,-1,1,"fout=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->fBinWidth)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fBinWidth=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->nHistos)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"nHistos=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->d_tree)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TTree),-1,-1,1,"d_tree=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->d_ntpair)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_TTree),-1,-1,1,"d_ntpair=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->simflag)-(long)(p)),103,0,0,-1,-1,-1,1,"simflag=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->sel_trigger)-(long)(p)),105,0,0,-1,-1,-1,1,"sel_trigger=",0,(char*)NULL); + G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"d_flag_tof_cut=",0,(char*)NULL); + G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"d_flag_emc_cut=",0,(char*)NULL); + G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"d_flag_phiv=",0,(char*)NULL); + G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"d_flag_pt_cut=",0,(char*)NULL); + G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"d_flag_kaon_veto=",0,(char*)NULL); + G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"d_flag_proton_veto=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"d_tpc_dedx_low=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"d_tpc_dedx_high=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"d_tof_low=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"d_tof_high=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"d_emc_low=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"d_emc_high=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"d_phiv_cut=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"d_pt_cut_low=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"d_pt_cut_high=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"d_dedx_kaon_veto_low=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"d_dedx_kaon_veto_high=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"d_dedx_proton_veto_low=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"d_dedx_proton_veto_high=",0,(char*)NULL); + G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"magnetic_field_mm=",0,(char*)NULL); + G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"d_conv_flag=",0,(char*)NULL); + G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"d_evt=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_cent=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntrk=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_xvprim=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_yvprim=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_zvprim=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_nacctrklets=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_xres=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_yres=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_zres=",0,(char*)NULL); + G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"d_nelc=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_px[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_py[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_pz[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_p[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_pt[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_xv[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_yv[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_zv[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_phi[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_theta[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_eta[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_c[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_nclusITS[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_nclusTPC[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_nclusTPCiter[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_nfclusTPC[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_nfclusTPCr[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_nfclusTPCrFrac[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TPCsignalN[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TPCsignalNfrac[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TPCchi2cl[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_trkstat[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_nclsTRD[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TRDntracklets[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TRDpidquality[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TRDprobEle[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TRDprobPio[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_impactXY[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_impactZ[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_tracklength[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ITSsignal[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ITSnsigmaEle[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ITSnsigmaPio[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ITSnsigmaMuo[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ITSnsigmaKao[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ITSnsigmaPro[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_PIn[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TPCsignal[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TOFsignal[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TOFbeta[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TPCnSigmaEle[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TPCnSigmaPio[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TPCnSigmaMuo[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TPCnSigmaKao[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TPCnSigmaPro[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TOFnSigmaEle[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TOFnSigmaPio[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TOFnSigmaMuo[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TOFnSigmaKao[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_TOFnSigmaPro[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_chi2ndf[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_E[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_dphi[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_deta[100]=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_run=",0,(char*)NULL); + G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"d_event=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_centrality=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_prim_xv=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_prim_yv=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_prim_zv=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_mass=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_pxpair=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_pypair=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_pzpair=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ptpair=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_epair=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_etapair=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_phipair=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_cos=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_phiv=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_psi=",0,(char*)NULL); + G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"d_pairtype=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_cent1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_xv1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_yv1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_zv1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_px1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_py1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_pz1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_pt1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_eta1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_phi1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_theta1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_tpc1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntpc_ele1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntpc_pio1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntpc_kao1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntpc_pro1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_beta1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntof_ele1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntof_pio1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntof_kao1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntof_pro1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_its1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_nits1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntpc1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_e1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_dphi1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_deta1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_dcaxy1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_dcaz1=",0,(char*)NULL); + G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"d_conv1=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_cent2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_xv2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_yv2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_zv2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_px2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_py2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_pz2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_pt2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_eta2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_phi2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_theta2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_tpc2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntpc_ele2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntpc_pio2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntpc_kao2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntpc_pro2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_beta2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntof_ele2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntof_pio2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntof_kao2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntof_pro2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_its2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_nits2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_ntpc2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_e2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_dphi2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_deta2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_dcaxy2=",0,(char*)NULL); + G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"d_dcaz2=",0,(char*)NULL); + G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"d_conv2=",0,(char*)NULL); + G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"nelec_pos[10]=",0,"pT bin;"); + G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_vectorlEetrkcOallocatorlEetrkgRsPgR),G__defined_typename("vector"),-1,4,"vem=",0,(char*)NULL); + G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_vectorlEetrkcOallocatorlEetrkgRsPgR),G__defined_typename("vector"),-1,4,"vep=",0,(char*)NULL); + G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_vectorlEetrkcOallocatorlEetrkgRsPgR),G__defined_typename("vector"),-1,4,"vem_tmp=",0,(char*)NULL); + G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__ana_sglDictLN_vectorlEetrkcOallocatorlEetrkgRsPgR),G__defined_typename("vector"),-1,4,"vep_tmp=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + +extern "C" void G__cpp_setup_memvarana_sglDict() { +} +/*********************************************************** +************************************************************ +************************************************************ +************************************************************ +************************************************************ +************************************************************ +************************************************************ +***********************************************************/ + +/********************************************************* +* Member function information setup for each class +*********************************************************/ +static void G__setup_memfuncana_sgl(void) { + /* ana_sgl */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__ana_sglDictLN_ana_sgl)); + G__memfunc_setup("ana_sgl",725,G__ana_sglDict_580_0_1, 105, G__get_linked_tagnum(&G__ana_sglDictLN_ana_sgl), -1, 0, 1, 1, 1, 0, "U 'TTree' - 0 '0' tree", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("Cut",300,G__ana_sglDict_580_0_2, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1); + G__memfunc_setup("GetEntry",818,G__ana_sglDict_580_0_3, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1); + G__memfunc_setup("LoadTree",784,G__ana_sglDict_580_0_4, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1); + G__memfunc_setup("Init",404,G__ana_sglDict_580_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTree' - 0 - tree", (char*)NULL, (void*) NULL, 1); + G__memfunc_setup("Loop",410,G__ana_sglDict_580_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1); + G__memfunc_setup("Notify",633,G__ana_sglDict_580_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1); + G__memfunc_setup("Show",417,G__ana_sglDict_580_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 '-1' entry", (char*)NULL, (void*) NULL, 1); + G__memfunc_setup("ana_init",835,G__ana_sglDict_580_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 0 - filename", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ana_event",945,G__ana_sglDict_580_0_10, 121, -1, -1, 0, 2, 1, 1, 0, +"i - - 0 - ientry i - - 0 - jentry", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ana_end",710,G__ana_sglDict_580_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("loop_a_file",1145,G__ana_sglDict_580_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 0 - filename", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ana_set_simflag",1565,G__ana_sglDict_580_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - a", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("kTOFcut",672,G__ana_sglDict_580_0_14, 103, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - itrk", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("GlobalTrackcut",1426,G__ana_sglDict_580_0_15, 103, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - itrk", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("fill_histograms",1607,G__ana_sglDict_580_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - itrk", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("fill_to_tree_variables",2320,G__ana_sglDict_580_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("fill_to_tree_track_variables",2948,G__ana_sglDict_580_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - itrk", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("add_histograms",1481,G__ana_sglDict_580_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TFile' - 0 - fin", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("select_trigger",1491,G__ana_sglDict_580_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - trig", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("set_tpc_dedx_cuts",1812,G__ana_sglDict_580_0_21, 121, -1, -1, 0, 2, 1, 1, 0, +"d - - 0 - low d - - 0 - high", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("set_tof_cuts",1298,G__ana_sglDict_580_0_22, 121, -1, -1, 0, 2, 1, 1, 0, +"d - - 0 - low d - - 0 - high", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("set_veto_for_kaon",1815,G__ana_sglDict_580_0_23, 121, -1, -1, 0, 2, 1, 1, 0, +"d - - 0 - low d - - 0 - high", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("set_veto_for_proton",2064,G__ana_sglDict_580_0_24, 121, -1, -1, 0, 2, 1, 1, 0, +"d - - 0 - low d - - 0 - high", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("enable_pair_emc_cut",1969,G__ana_sglDict_580_0_25, 121, -1, -1, 0, 2, 1, 1, 0, +"d - - 0 - low d - - 0 - high", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("enable_pair_phiv_cut",2099,G__ana_sglDict_580_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - low", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("enable_pait_pt_cut",1890,G__ana_sglDict_580_0_27, 121, -1, -1, 0, 2, 1, 1, 0, +"d - - 0 - low d - - 0 - high", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("print_cuts",1099,G__ana_sglDict_580_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("calc_pair",926,G__ana_sglDict_580_0_29, 121, -1, -1, 0, 2, 1, 1, 0, +"u 'vector >' 'vector' 0 - e1 u 'vector >' 'vector' 0 - e2", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("randomize_pool",1506,G__ana_sglDict_580_0_30, 121, -1, -1, 0, 2, 1, 1, 0, +"u 'vector >' 'vector' 0 - e1 u 'vector >' 'vector' 0 - e2", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("fill_pair",946,G__ana_sglDict_580_0_31, 121, -1, -1, 0, 3, 1, 1, 0, +"u 'vector >::iterator' - 0 - e1 u 'vector >::iterator' - 0 - e2 " +"i - - 0 - type", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("PairTrackcut",1229,G__ana_sglDict_580_0_32, 103, -1, -1, 0, 2, 1, 1, 0, +"u 'vector >::iterator' - 0 - e1 u 'vector >::iterator' - 0 - e2", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("reject_conversion",1826,G__ana_sglDict_580_0_33, 103, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - val", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("check_conversion_pairs",2337,G__ana_sglDict_580_0_34, 121, -1, -1, 0, 2, 1, 1, 0, +"u 'vector >' 'vector' 1 - e1 u 'vector >' 'vector' 1 - e2", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("check_ghost_pairs",1792,G__ana_sglDict_580_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector >' 'vector' 1 - e1", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("calc_vars",942,G__ana_sglDict_580_0_36, 121, -1, -1, 0, 13, 1, 1, 0, +"u 'vector >::iterator' - 0 - e1 u 'vector >::iterator' - 0 - e2 " +"d - - 1 - mass d - - 1 - phiv " +"d - - 1 - px d - - 1 - py " +"d - - 1 - pz d - - 1 - pt " +"d - - 1 - e d - - 1 - phi " +"d - - 1 - eta d - - 1 - cos " +"d - - 1 - psi", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("pair_cut",855,G__ana_sglDict_580_0_37, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + // automatic copy constructor + G__memfunc_setup("ana_sgl", 725, G__ana_sglDict_580_0_38, (int) ('i'), G__get_linked_tagnum(&G__ana_sglDictLN_ana_sgl), -1, 0, 1, 1, 1, 0, "u 'ana_sgl' - 11 - -", (char*) NULL, (void*) NULL, 0); + // automatic destructor + G__memfunc_setup("~ana_sgl", 851, G__ana_sglDict_580_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1); + // automatic assignment operator + G__memfunc_setup("operator=", 937, G__ana_sglDict_580_0_40, (int) ('u'), G__get_linked_tagnum(&G__ana_sglDictLN_ana_sgl), -1, 1, 1, 1, 1, 0, "u 'ana_sgl' - 11 - -", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + + +/********************************************************* +* Member function information setup +*********************************************************/ +extern "C" void G__cpp_setup_memfuncana_sglDict() { +} + +/********************************************************* +* Global variable information setup for each class +*********************************************************/ +static void G__cpp_setup_global0() { + + /* Setting up global variables */ + G__resetplocal(); + +} + +static void G__cpp_setup_global1() { +} + +static void G__cpp_setup_global2() { +} + +static void G__cpp_setup_global3() { + + G__resetglobalenv(); +} +extern "C" void G__cpp_setup_globalana_sglDict() { + G__cpp_setup_global0(); + G__cpp_setup_global1(); + G__cpp_setup_global2(); + G__cpp_setup_global3(); +} + +/********************************************************* +* Global function information setup for each class +*********************************************************/ +static void G__cpp_setup_func0() { + G__lastifuncposition(); + +} + +static void G__cpp_setup_func1() { +} + +static void G__cpp_setup_func2() { +} + +static void G__cpp_setup_func3() { +} + +static void G__cpp_setup_func4() { +} + +static void G__cpp_setup_func5() { +} + +static void G__cpp_setup_func6() { +} + +static void G__cpp_setup_func7() { +} + +static void G__cpp_setup_func8() { +} + +static void G__cpp_setup_func9() { +} + +static void G__cpp_setup_func10() { +} + +static void G__cpp_setup_func11() { +} + +static void G__cpp_setup_func12() { +} + +static void G__cpp_setup_func13() { +} + +static void G__cpp_setup_func14() { +} + +static void G__cpp_setup_func15() { +} + +static void G__cpp_setup_func16() { +} + +static void G__cpp_setup_func17() { +} + +static void G__cpp_setup_func18() { +} + +static void G__cpp_setup_func19() { +} + +static void G__cpp_setup_func20() { +} + +static void G__cpp_setup_func21() { +} + +static void G__cpp_setup_func22() { + + G__resetifuncposition(); +} + +extern "C" void G__cpp_setup_funcana_sglDict() { + G__cpp_setup_func0(); + G__cpp_setup_func1(); + G__cpp_setup_func2(); + G__cpp_setup_func3(); + G__cpp_setup_func4(); + G__cpp_setup_func5(); + G__cpp_setup_func6(); + G__cpp_setup_func7(); + G__cpp_setup_func8(); + G__cpp_setup_func9(); + G__cpp_setup_func10(); + G__cpp_setup_func11(); + G__cpp_setup_func12(); + G__cpp_setup_func13(); + G__cpp_setup_func14(); + G__cpp_setup_func15(); + G__cpp_setup_func16(); + G__cpp_setup_func17(); + G__cpp_setup_func18(); + G__cpp_setup_func19(); + G__cpp_setup_func20(); + G__cpp_setup_func21(); + G__cpp_setup_func22(); +} + +/********************************************************* +* Class,struct,union,enum tag information setup +*********************************************************/ +/* Setup class/struct taginfo */ +G__linked_taginfo G__ana_sglDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector >" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator >::iterator>" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_TObjArray = { "TObjArray" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector >" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator >::iterator>" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator" , 115 , -1 }; +G__linked_taginfo G__ana_sglDictLN_TFile = { "TFile" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_TTree = { "TTree" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_TBranch = { "TBranch" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map,allocator > >" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_TVectorTlEfloatgR = { "TVectorT" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_TVectorTlEdoublegR = { "TVectorT" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_TH1D = { "TH1D" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_TH1F = { "TH1F" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_TMatrixTBaselEfloatgR = { "TMatrixTBase" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_TMatrixTBaselEdoublegR = { "TMatrixTBase" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_TH2F = { "TH2F" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_TH2D = { "TH2D" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_ana_sgl = { "ana_sgl" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_vectorlEetrkcOallocatorlEetrkgRsPgR = { "vector >" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_vectorlEetrkcOallocatorlEetrkgRsPgRcLcLiterator = { "vector >::iterator" , 99 , -1 }; +G__linked_taginfo G__ana_sglDictLN_reverse_iteratorlEvectorlEetrkcOallocatorlEetrkgRsPgRcLcLiteratorgR = { "reverse_iterator >::iterator>" , 99 , -1 }; + +/* Reset class/struct taginfo */ +extern "C" void G__cpp_reset_tagtableana_sglDict() { + G__ana_sglDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ; + G__ana_sglDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ; + G__ana_sglDictLN_TObjArray.tagnum = -1 ; + G__ana_sglDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ; + G__ana_sglDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ; + G__ana_sglDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ; + G__ana_sglDictLN_TFile.tagnum = -1 ; + G__ana_sglDictLN_TTree.tagnum = -1 ; + G__ana_sglDictLN_TBranch.tagnum = -1 ; + G__ana_sglDictLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ; + G__ana_sglDictLN_TVectorTlEfloatgR.tagnum = -1 ; + G__ana_sglDictLN_TVectorTlEdoublegR.tagnum = -1 ; + G__ana_sglDictLN_TH1D.tagnum = -1 ; + G__ana_sglDictLN_TH1F.tagnum = -1 ; + G__ana_sglDictLN_TMatrixTBaselEfloatgR.tagnum = -1 ; + G__ana_sglDictLN_TMatrixTBaselEdoublegR.tagnum = -1 ; + G__ana_sglDictLN_TH2F.tagnum = -1 ; + G__ana_sglDictLN_TH2D.tagnum = -1 ; + G__ana_sglDictLN_ana_sgl.tagnum = -1 ; + G__ana_sglDictLN_vectorlEetrkcOallocatorlEetrkgRsPgR.tagnum = -1 ; + G__ana_sglDictLN_vectorlEetrkcOallocatorlEetrkgRsPgRcLcLiterator.tagnum = -1 ; + G__ana_sglDictLN_reverse_iteratorlEvectorlEetrkcOallocatorlEetrkgRsPgRcLcLiteratorgR.tagnum = -1 ; +} + + +extern "C" void G__cpp_setup_tagtableana_sglDict() { + + /* Setting up class,struct,union tag entry */ + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_TObjArray); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_TFile); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_TTree); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_TBranch); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_TVectorTlEfloatgR); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_TVectorTlEdoublegR); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_TH1D); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_TH1F); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_TMatrixTBaselEfloatgR); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_TMatrixTBaselEdoublegR); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_TH2F); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_TH2D); + G__tagtable_setup(G__get_linked_tagnum_fwd(&G__ana_sglDictLN_ana_sgl),sizeof(ana_sgl),-1,1280,(char*)NULL,G__setup_memvarana_sgl,G__setup_memfuncana_sgl); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_vectorlEetrkcOallocatorlEetrkgRsPgR); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_vectorlEetrkcOallocatorlEetrkgRsPgRcLcLiterator); + G__get_linked_tagnum_fwd(&G__ana_sglDictLN_reverse_iteratorlEvectorlEetrkcOallocatorlEetrkgRsPgRcLcLiteratorgR); +} +extern "C" void G__cpp_setupana_sglDict(void) { + G__check_setup_version(30051515,"G__cpp_setupana_sglDict()"); + G__set_cpp_environmentana_sglDict(); + G__cpp_setup_tagtableana_sglDict(); + + G__cpp_setup_inheritanceana_sglDict(); + + G__cpp_setup_typetableana_sglDict(); + + G__cpp_setup_memvarana_sglDict(); + + G__cpp_setup_memfuncana_sglDict(); + G__cpp_setup_globalana_sglDict(); + G__cpp_setup_funcana_sglDict(); + + if(0==G__getsizep2memfunc()) G__get_sizep2memfuncana_sglDict(); + return; +} +class G__cpp_setup_initana_sglDict { + public: + G__cpp_setup_initana_sglDict() { G__add_setup_func("ana_sglDict",(G__incsetup)(&G__cpp_setupana_sglDict)); G__call_setup_funcs(); } + ~G__cpp_setup_initana_sglDict() { G__remove_setup_func("ana_sglDict"); } +}; +G__cpp_setup_initana_sglDict G__cpp_setup_initializerana_sglDict; + diff --git a/PWGDQ/dielectron/TakuAlberica/pair/ana_sglDict.h b/PWGDQ/dielectron/TakuAlberica/pair/ana_sglDict.h new file mode 100644 index 00000000000..e429b036c1a --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/pair/ana_sglDict.h @@ -0,0 +1,65 @@ +/******************************************************************** +* ana_sglDict.h +* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED +* FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX(). +* CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE. +********************************************************************/ +#ifdef __CINT__ +#error ana_sglDict.h/C is only for compilation. Abort cint. +#endif +#include +#include +#include +#include +#include +#define G__ANSIHEADER +#define G__DICTIONARY +#define G__PRIVATE_GVALUE +#include "G__ci.h" +#include "FastAllocString.h" +extern "C" { +extern void G__cpp_setup_tagtableana_sglDict(); +extern void G__cpp_setup_inheritanceana_sglDict(); +extern void G__cpp_setup_typetableana_sglDict(); +extern void G__cpp_setup_memvarana_sglDict(); +extern void G__cpp_setup_globalana_sglDict(); +extern void G__cpp_setup_memfuncana_sglDict(); +extern void G__cpp_setup_funcana_sglDict(); +extern void G__set_cpp_environmentana_sglDict(); +} + + +#include "TObject.h" +#include "TMemberInspector.h" +#include "ana_sgl.h" +#include +namespace std { } +using namespace std; + +#ifndef G__MEMFUNCBODY +#endif + +extern G__linked_taginfo G__ana_sglDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR; +extern G__linked_taginfo G__ana_sglDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR; +extern G__linked_taginfo G__ana_sglDictLN_TObjArray; +extern G__linked_taginfo G__ana_sglDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR; +extern G__linked_taginfo G__ana_sglDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR; +extern G__linked_taginfo G__ana_sglDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR; +extern G__linked_taginfo G__ana_sglDictLN_TFile; +extern G__linked_taginfo G__ana_sglDictLN_TTree; +extern G__linked_taginfo G__ana_sglDictLN_TBranch; +extern G__linked_taginfo G__ana_sglDictLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR; +extern G__linked_taginfo G__ana_sglDictLN_TVectorTlEfloatgR; +extern G__linked_taginfo G__ana_sglDictLN_TVectorTlEdoublegR; +extern G__linked_taginfo G__ana_sglDictLN_TH1D; +extern G__linked_taginfo G__ana_sglDictLN_TH1F; +extern G__linked_taginfo G__ana_sglDictLN_TMatrixTBaselEfloatgR; +extern G__linked_taginfo G__ana_sglDictLN_TMatrixTBaselEdoublegR; +extern G__linked_taginfo G__ana_sglDictLN_TH2F; +extern G__linked_taginfo G__ana_sglDictLN_TH2D; +extern G__linked_taginfo G__ana_sglDictLN_ana_sgl; +extern G__linked_taginfo G__ana_sglDictLN_vectorlEetrkcOallocatorlEetrkgRsPgR; +extern G__linked_taginfo G__ana_sglDictLN_vectorlEetrkcOallocatorlEetrkgRsPgRcLcLiterator; +extern G__linked_taginfo G__ana_sglDictLN_reverse_iteratorlEvectorlEetrkcOallocatorlEetrkgRsPgRcLcLiteratorgR; + +/* STUB derived class for protected member access */ diff --git a/PWGDQ/dielectron/TakuAlberica/pair/ana_sglLinkDef.h b/PWGDQ/dielectron/TakuAlberica/pair/ana_sglLinkDef.h new file mode 100644 index 00000000000..279c2b364e0 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/pair/ana_sglLinkDef.h @@ -0,0 +1,9 @@ +#ifdef __CINT__ + +#pragma link off all globals; +#pragma link off all classes; +#pragma link off all functions; + +#pragma link C++ class ana_sgl; + +#endif /* __CINT__ */ diff --git a/PWGDQ/dielectron/TakuAlberica/pair/get_spectrum_dir2.C b/PWGDQ/dielectron/TakuAlberica/pair/get_spectrum_dir2.C new file mode 100644 index 00000000000..6c5ba89a747 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/pair/get_spectrum_dir2.C @@ -0,0 +1,758 @@ +void get_spectrum_dir2(int icent=1){ + gStyle->SetPalette(1); + gStyle->SetOptStat(0); + gStyle->SetOptFit(111111); + //gStyle->SetOptFit(0); + gStyle->SetOptTitle(0); + //gStyle->SetFillColor(10); + gStyle->SetCanvasColor(10); + gStyle->SetFrameBorderMode(0); + gStyle->SetFrameFillColor(0); + gStyle->SetCanvasColor(0); + gStyle->SetPadBorderSize(0); + gStyle->SetCanvasBorderSize(0); + //gStyle->SetPadLeftMargin(0.15); + gStyle->SetPadLeftMargin(0.125); + gStyle->SetPadBottomMargin(0.125); + gStyle->SetPadTopMargin(0.1); + gStyle->SetTitleYOffset(1.3); + //gStyle->SetPadLeftMargin(0.1); + gStyle->SetTitleW(0.7); + gStyle->SetTitleH(0.1); + cout<<"physics is always fun! "<Get(name); + //cout<GetEntries()<ProjectionY("hpt"); + + TH1F *hstat = (TH1F*)fin->Get("hCentrality"); + float nevents = hstat->Integral(cent_low[icent], cent_high[icent]-1); + + cout<Sumw2(); + + sprintf(name,"hmass2_ls_w_pair%d_pt%d", i, j); + //sprintf(name,"hmass2_pair%d_pt%d", i, j); + hmasspt_ls[i][j] = new TH1D(name, name, 500, 0, 5); + hmasspt_ls[i][j]->Sumw2(); + } + } + + /// first [] + /// 0-->unlike + /// 1-->like + /// 2-->mixed unlike + /// 3-->mixed like + + /// second [] --> pt + /// third [] --> ee or pp + float npairs[4][nptbin][2]; + + for(int j=0;jFindBin(pt_low[j]); + int binh = hpt->FindBin(pt_high[j]); + + npairs[0][j][0]=0; npairs[0][j][1]=0; + npairs[1][j][0]=0; npairs[1][j][1]=0; + npairs[2][j][0]=0; npairs[2][j][1]=0; + npairs[3][j][0]=0; npairs[3][j][1]=0; + + + + for(int i=cent_low_bin[icent]; iAdd((TH1D*)hmasspt_inc[i][0]->ProjectionX(name,binl, binh-1)); + // npairs[0][j][0] += hmasspt_inc[i][0]->ProjectionX(name,binl, binh-1)->Integral(); + npairs[0][j][0] += hmasspt_inc[i][0]->Integral(); + + ///////////////////////////////////////// + //// pair2 (like sign) + //////////////////////////////////////// + sprintf(name,"hmass_%d_%d_1", i, j); + hmasspt[2][j]->Add((TH1D*)hmasspt_inc[i][1]->ProjectionX(name,binl, binh-1)); + hmasspt_ls[0][j]->Add((TH1D*)hmasspt_inc[i][1]->ProjectionX(name,binl, binh-1)); + //npairs[2][j][0] += hmasspt_inc[i][1]->ProjectionX(name,binl, binh-1)->Integral(); + npairs[2][j][0] += hmasspt_inc[i][1]->Integral(); + + sprintf(name,"hmass_%d_%d_2", i, j); + hmasspt[2][j]->Add((TH1D*)hmasspt_inc[i][2]->ProjectionX(name,binl, binh-1)); + //npairs[2][j][1] += hmasspt_inc[i][2]->ProjectionX(name,binl, binh-1)->Integral(); + hmasspt_ls[1][j]->Add((TH1D*)hmasspt_inc[i][2]->ProjectionX(name,binl, binh-1)); + npairs[2][j][1] += hmasspt_inc[i][2]->Integral(); + + ///////////////////////////////////////// + //// pair1 (mixed unlike sign) + ///////////////////////////////////////// + sprintf(name,"hmass_%d_%d_1", i, j); + hmasspt[1][j]->Add((TH1D*)hmasspt_inc[i][3]->ProjectionX(name,binl, binh-1)); + //npairs[1][j][0] += hmasspt_inc[i][3]->ProjectionX(name,binl, binh-1)->Integral(); + npairs[1][j][0] += hmasspt_inc[i][3]->Integral(); + + sprintf(name,"hmass_%d_%d_2", i, j); + hmasspt[1][j]->Add((TH1D*)hmasspt_inc[i][4]->ProjectionX(name,binl, binh-1)); + // npairs[1][j][0] += hmasspt_inc[i][4]->ProjectionX(name,binl, binh-1)->Integral(); + npairs[1][j][0] += hmasspt_inc[i][4]->Integral(); + + ///////////////////////////////////////// + //// pair3 (mixed like sign) + //////////////////////////////////////// + sprintf(name,"hmass_%d_%d_1", i, j); + // hmasspt[3][j]->Add((TH1D*)hmasspt_inc[i][5]->ProjectionX(name,binl, binh-1)); + hmasspt_ls[2][j]->Add((TH1D*)hmasspt_inc[i][5]->ProjectionX(name,binl, binh-1)); + //npairs[3][j][0] += hmasspt_inc[i][5]->ProjectionX(name,binl, binh-1)->Integral(); + npairs[3][j][0] += hmasspt_inc[i][5]->Integral(); + + sprintf(name,"hmass_%d_%d_2", i, j); + //hmasspt[3][j]->Add((TH1D*)hmasspt_inc[i][6]->ProjectionX(name,binl, binh-1)); + hmasspt_ls[3][j]->Add((TH1D*)hmasspt_inc[i][6]->ProjectionX(name,binl, binh-1)); + //npairs[3][j][1] += hmasspt_inc[i][6]->ProjectionX(name,binl, binh-1)->Integral(); + npairs[3][j][1] += hmasspt_inc[i][6]->Integral(); + + } + } + + /// for mixed like sign pairs + /// entry should be same as like sign pairs + /// re-add the hist for mixed like sign pairs using weights + for(int j=0;jAdd( hmasspt_ls[2][j], frac1); ///mixed like sign + hmasspt[3][j]->Add( hmasspt_ls[3][j], frac2); // mixed like sign + //hmasspt[3][j]->Add( hmasspt_ls[2][j], 1); + //hmasspt[3][j]->Add( hmasspt_ls[3][j], 1); + } + + + for(int i=0;i<4;i++){ + for(int j=0;jScale(1.0/nevents); + hmasspt_ls[i][j]->Scale(1.0/nevents); + cout<Integral()<Divide(3,1); + for(int iptbin=1;iptbincd(iptbin); + gPad->SetGrid(1); + gPad->SetLogy(); + hmasspt[0][iptbin]->SetXTitle("M_{ee}[GeV/c^{2}]"); + hmasspt[0][iptbin]->SetYTitle("N_{ee}/N_{evt}"); + hmasspt[0][iptbin]->Draw(); + } + + + TCanvas *c1 = new TCanvas("c1","c1",1500,1000); + c1->Divide(3,3); + + TF1 *f1 = new TF1("f1","pol0",0.05,2); + + double r[5]; + + for(int iptbin=1;iptbinSetXTitle("M_{ee}[GeV/c^{2}]"); + hdiv[iptbin]->SetYTitle("mixed unlike/mixed like"); + hdiv[iptbin]->Sumw2(); + //hmasspt[3][iptbin]->Scale(npairs[1][iptbin][0]/(npairs[3][iptbin][0]+npairs[3][iptbin][1])); + hdiv[iptbin]->Divide(hmasspt[1][iptbin], hmasspt[3][iptbin]); ///mixed unlike/mixed like + /* + for(int ii=0;iiGetNbinsX(); ii++){ + double vent1 = hmasspt[1][iptbin]->GetBinContent(ii+1); + double e_vent1 = hmasspt[1][iptbin]->GetBinError(ii+1); + + + double vent2 = hmasspt_ls[2][iptbin]->GetBinContent(ii+1); + double e_vent2 = hmasspt_ls[2][iptbin]->GetBinError(ii+1); + double vent3 = hmasspt_ls[3][iptbin]->GetBinContent(ii+1); + double e_vent3 = hmasspt_ls[3][iptbin]->GetBinError(ii+1); + + + + double val1 = vent1; + double val2 = 2*sqrt(vent2*vent3); + + if(val2>0){ + hdiv[iptbin]->SetBinContent(ii+1, val1/val2); + double e_val1 = e_vent1; + double e_val2 = val2/2*sqrt(pow(e_vent2/vent2,2)+pow(e_vent3/vent3,2)); + hdiv[iptbin]->SetBinError(ii+1, val1/val2*sqrt(pow(e_val1/val1,2)+pow(e_val2/val2,2))); + } + } + */ + + c1->cd(iptbin); + gPad->SetGrid(1); + hmasspt[1][iptbin]->SetXTitle("M_{ee}[GeV/c^{2}]"); + hmasspt[0][iptbin]->SetYTitle("N_{ee}/N_{evt}"); + hmasspt[1][iptbin]->Draw(); + hmasspt[3][iptbin]->SetLineColor(2); + hmasspt[3][iptbin]->Draw("same"); + + c1->cd(iptbin+3); + gPad->SetGrid(1); + //hdiv[iptbin]->Rebin(4); hdiv[iptbin]->Scale(1.0/4); + + hdiv[iptbin]->SetAxisRange(0,3); + hdiv[iptbin]->SetMinimum(0); + hdiv[iptbin]->SetMaximum(2); + hdiv[iptbin]->Draw(); + ///hdiv[iptbin]->Fit(f1,"R",""); + + //r[iptbin] = f1->GetParameter(0); + //int bin1 = hmasspt[2][iptbin]->FindBin(0.1); + //int bin2 = hmasspt[2][iptbin]->FindBin(1.0); + //r[iptbin] = hmasspt[2][iptbin]->Integral(bin1, bin2)/hmasspt[3][iptbin]->Integral(bin1, bin2); + //cout<<" normalization factor "<GetNbinsX();k++){ + float w = f1->Eval(hmasspt[1][iptbin]->GetBinCenter(k+1)); + float rr = hmasspt[1][iptbin]->GetBinContent(k+1); + float err = hmasspt[1][iptbin]->GetBinError(k+1); + hmasspt[1][iptbin]->SetBinContent(k+1, rr*w); + hmasspt[1][iptbin]->SetBinError(k+1, err*w); + } + */ + //hmasspt[1][iptbin]->Scale(r[iptbin]); + hmasspt[2][iptbin]->Multiply(hdiv[iptbin]); + //c/out<Integral()*nevents<Scale((2*sqrt(npairs[2][iptbin][0]*npairs[2][iptbin][1])/(npairs[2][iptbin][0]+npairs[2][iptbin][1]))); + //hmasspt[2][iptbin]->Scale(npairs[0][iptbin][0]/(2*sqrt(npairs[2][iptbin][0]*npairs[2][iptbin][1]))); + + + for(int ii=0;iiGetNbinsX(); ii++){ + double d_val1 = 2*sqrt(hmasspt_ls[0][iptbin]->GetBinContent(ii+1)*hmasspt_ls[1][iptbin]->GetBinContent(ii+1)); + if(d_val1>0){ + double d_eval1 = d_val1/2*sqrt(pow(hmasspt_ls[0][iptbin]->GetBinError(ii+1)/hmasspt_ls[0][iptbin]->GetBinContent(ii+1),2)+ + pow(hmasspt_ls[1][iptbin]->GetBinError(ii+1)/hmasspt_ls[1][iptbin]->GetBinContent(ii+1),2)); + // double accep = hdiv[iptbin]->GetBinContent(ii+1)-hdiv[iptbin]->GetBinError(ii+1); + double accep = hdiv[iptbin]->GetBinContent(ii+1); + hmasspt[2][iptbin]->SetBinContent(ii+1, d_val1*accep); + hmasspt[2][iptbin]->SetBinError(ii+1, d_eval1*accep); + } + } + + /* + double norm1=0; + double norm2=0; + for(int ii=0;iiGetNbinsX(); ii++){ + double d_bg1 = hmasspt[1][iptbin]->GetBinContent(ii+1); + double d_bg_pp = hmasspt_ls[2][iptbin]->GetBinContent(ii+1); + double d_bg_mm = hmasspt_ls[3][iptbin]->GetBinContent(ii+1); + double d_fg_pp = hmasspt_ls[0][iptbin]->GetBinContent(ii+1); + double d_fg_mm = hmasspt_ls[1][iptbin]->GetBinContent(ii+1); + double d_e_fg_pp = hmasspt_ls[0][iptbin]->GetBinError(ii+1); + double d_e_fg_mm = hmasspt_ls[1][iptbin]->GetBinError(ii+1); + + if(d_fg_pp>0 && d_fg_mm>0 && d_bg_pp>0 && d_bg_mm>0){ + //double d_val = 2*sqrt(d_fg_pp*d_fg_mm)*d_bg1/(2*sqrt(d_bg_pp*d_bg_mm)); + //double d_e_val = sqrt(d_fg_pp*d_fg_mm)*sqrt(pow(d_e_fg_pp/d_fg_pp,2)+pow(d_e_fg_mm/d_fg_mm,2))*d_bg1/(2*sqrt(d_bg_pp*d_bg_mm)); + double d_val = 2*(d_fg_pp*(0.5*d_bg1/d_bg_pp)*sqrt(npairs[2][iptbin][0])+d_fg_mm*(0.5*d_bg1/d_bg_mm)*sqrt(npairs[2][iptbin][1]))/(sqrt(npairs[2][iptbin][0])+sqrt(npairs[2][iptbin][1])); + double d_e_val = d_e_fg_pp*(0.5*d_bg1/d_bg_pp)+d_e_fg_mm*(0.5*d_bg1/d_bg_mm); + + hmasspt[2][iptbin]->SetBinContent(ii+1, d_val); + hmasspt[2][iptbin]->SetBinError(ii+1, d_e_val); + + } + } + */ + //hmasspt[2][iptbin]->Scale(hmasspt[0][iptbin]->Integral()/(2*sqrt(norm1*norm2))); + cout<<" entry ="<Integral()<<" "<Integral()<<" "<Integral()<<" "<Integral()<cd(iptbin+6); + hmasspt[0][iptbin]->Draw(); + hmasspt[2][iptbin]->SetLineColor(2); + hmasspt[2][iptbin]->Draw("same"); + } + + + const int nmassbin=8; + float mass_low[nmassbin] ={0, 0.05, 0.09, 0.14, 0.20, 0.30, 0.1, 0.09}; + float mass_high[nmassbin]={0.03, 0.09, 0.14, 0.20, 0.30, 0.40, 0.3, 0.30}; + float nsig[5][nmassbin]; + float nbg[5][nmassbin]; + float ensig[5][nmassbin]; + float enbg[5][nmassbin]; + + for(int ii=0;iiFindBin(mass_low[j]); + int binhigh = hmasspt[0][ii]->FindBin(mass_high[j]); + nsig[ii][j] = hmasspt[0][ii]->Integral(binlow, binhigh-1); + nbg[ii][j] = hmasspt[2][ii]->Integral(binlow, binhigh-1); + ensig[ii][j]=0; + enbg[ii][j]=0; + for(int ib=binlow; ibGetBinError(ib),2); + enbg[ii][j] += pow(hmasspt[2][ii]->GetBinError(ib),2); + } + + ensig[ii][j] = sqrt(ensig[ii][j]); + enbg[ii][j] = sqrt(enbg[ii][j]); + + + float r1 = nsig[ii][j]-nbg[ii][j]; + float r0 = nsig[ii][0]-nbg[ii][0]; + float er1 = sqrt(pow(ensig[ii][j],2)+pow(enbg[ii][j],2)); + float er0 = sqrt(pow(ensig[ii][0],2)+pow(enbg[ii][0],2)); + + + if(r0>0 && r1>0){ + cout<<" pt : "< Nsig = "< Nsig = "<FindBin(x[j]); + int binh = hmasspt[0][i]->FindBin(x[j+1]); + float dw = x[j+1]-x[j]; + + float ent = 0; + float e_ent = 0; + float sig = 0; + float bg = 0; + for(int k=binl; kGetBinContent(k); + bg += hmasspt[2][i]->GetBinContent(k); + ent += (hmasspt[0][i]->GetBinContent(k)-hmasspt[2][i]->GetBinContent(k)); + e_ent += (pow(hmasspt[0][i]->GetBinError(k),2)+ + pow(hmasspt[2][i]->GetBinError(k),2)); + } + e_ent = sqrt(e_ent); + hsub[i]->SetBinContent(j+1, ent/dw); + hsub[i]->SetBinError(j+1, e_ent/dw); + + if(sig0 && x[j]<0.5){ // calculate 90% confidence level + double conf90=0; + sig = sig*nevents; + bg = bg*nevents; + TH1F *htmp = new TH1F("htmp","htmp",1000,-2*bg, 2*bg); + for(int kk=0;kk<100000;kk++){ + double a1 = gRandom->PoissonD(sig); + double a2 = gRandom->PoissonD(bg); + htmp->Fill(a1-a2); + } + int bin0 = htmp->FindBin(0); + float ent0 = htmp->Integral(bin0, 1000); + htmp->Scale(1.0/ent0); + //htmp->Scale(1.0/100000); + int bincent=0; + for(int ib=bin0;ib<1000;ib++){ + if(htmp->Integral(bin0, ib)>0.9){ + bincent = ib; + break; + } + } + conf90 = htmp->GetBinCenter(bincent); + cout<GetBinCenter(j+1)<<" : 90% conf: "<GetBinCenter(j+1), 1.0e-07, hsub[i]->GetBinCenter(j+1), conf90/(dw*nevents),0.01,"<|"); + narrows[i]++; + htmp->Clear(); + }// calculate 90% confidence level + + } + } + + TH1D *hsub_clone[5]; + + TCanvas *c3 = new TCanvas("c3","c3",1200,600); + c3->Divide(4,1); + + c3->cd(1); + gPad->SetGrid(1); gPad->SetLogy(); + TH2F *hw = new TH2F("hw","hw",10,0,0.5,10,1.0e-07, 10); + hw->Draw(); + hw->SetXTitle("M_{ee} [GeV]"); + hw->SetYTitle("dN_{ee}/dM_{ee}"); + c3->cd(2); + gPad->SetGrid(1); gPad->SetLogy(); + hw->Draw(); + c3->cd(3); + gPad->SetGrid(1); gPad->SetLogy(); + hw->Draw(); + c3->cd(4); + gPad->SetGrid(1); gPad->SetLogy(); + hw->Draw(); + + for(int i=0; iClone(); + sprintf(name,"%s_cln",hsub[i]->GetName()); + hsub_clone[i]->SetName(name); + hsub_clone[i]->SetLineColor(i+1); + hsub_clone[i]->SetMarkerColor(i+1); + hsub_clone[i]->SetMarkerStyle(20); + } + + + // int bin = hsub_clone[1]->FindBin(0.03); + // float ent = hsub_clone[1]->Integral(0,bin); + for(int i=0; iIntegral(0,bin); + //hsub_clone[i]->Scale(ent/ent1); + c3->cd(i+1); + hsub_clone[i]->Draw("same"); + for(int k=0;kSetLineColor(i+1); + Arrow[i][k]->Draw(); + } + } + + TCanvas *c5 = new TCanvas("c5","c5",1200,600); + c5->Divide(3,1); + + c5->cd(1); + gPad->SetGrid(1); gPad->SetLogy(); + TH2F *hw2 = new TH2F("hw2","hw2",10,0,0.5,10,1.0e-07, 10); + hw2->Draw(); + hw2->SetXTitle("M_{ee} [GeV]"); + hw2->SetYTitle("1/N_{evt}dN_{ee}/dM_{ee}"); + c5->cd(2); + gPad->SetGrid(1); gPad->SetLogy(); + hw2->Draw(); + c5->cd(3); + gPad->SetGrid(1); gPad->SetLogy(); + hw2->Draw(); + + TH1D *hmass_bin[2][nptbin]; + for(int i=1; icd(i); + hmass_bin[0][i] = (TH1D*)hmasspt[0][i]->Clone(); + hmass_bin[1][i] = (TH1D*)hmasspt[2][i]->Clone(); + + + float binw = hmass_bin[0][i]->GetBinWidth(10); + hmass_bin[0][i]->Scale(1/binw); + hmass_bin[1][i]->Scale(1/binw); + + hmass_bin[1][i]->SetLineColor(2); + hmass_bin[0][i]->Draw("same"); + hmass_bin[1][i]->Draw("same"); + hsub_clone[i]->Draw("same"); + for(int k=0;kSetLineColor(i+1); + Arrow[i][k]->Draw(); + } + } + + + + + + + // TLegend *leg = new TLegend(0.5,0.7,0.875,0.875); + // leg->SetFillColor(10); + // if(nptbin==4){ + // leg->AddEntry(hsub_clone[0],"0.5AddEntry(hsub_clone[1],"1.0AddEntry(hsub_clone[2],"1.5AddEntry(hsub_clone[3],"2.0Draw("same"); + + /////draw the results + TH1D *hmass_cocktail[4]; + TH1D *hmass_cocktail_comp[4][6]; + TFile *fin1 = new TFile("../../ana2/cocktail/cocktail_allpt_pt04_no_smearing.root"); + fin1->cd(); + hmass_cocktail[0] = (TH1D*)fin1->Get("hmass_all"); + hmass_cocktail[0]->SetName("hmass_all_pt0"); + hmass_cocktail_comp[0][0] = (TH1D*)fin1->Get("hmass_3"); + hmass_cocktail_comp[0][0]->SetName("hmass_pt0_eta_prime"); + hmass_cocktail_comp[0][1] = (TH1D*)fin1->Get("hmass_4"); + hmass_cocktail_comp[0][1]->SetName("hmass_pt0_rho"); + hmass_cocktail_comp[0][2] = (TH1D*)fin1->Get("hmass_7"); + hmass_cocktail_comp[0][2]->SetName("hmass_pt0_pi0"); + hmass_cocktail_comp[0][3] = (TH1D*)fin1->Get("hmass_8"); + hmass_cocktail_comp[0][3]->SetName("hmass_pt0_eta"); + hmass_cocktail_comp[0][4] = (TH1D*)fin1->Get("hmass_9"); + hmass_cocktail_comp[0][4]->SetName("hmass_pt0_omega"); + hmass_cocktail_comp[0][5] = (TH1D*)fin1->Get("hmass_10"); + hmass_cocktail_comp[0][5]->SetName("hmass_pt0_phi"); + + + //TFile *fin2 = new TFile("./cocktail//cocktail_pt10_15.root"); + TFile *fin2 = new TFile("../../ana2/cocktail//cocktail_pt04_pairpt_10_15_no_smearing.root"); + fin2->cd(); + hmass_cocktail[1] = (TH1D*)fin2->Get("hmass_all"); + hmass_cocktail[1]->SetName("hmass_all_pt1"); + hmass_cocktail_comp[1][0] = (TH1D*)fin1->Get("hmass_3"); + hmass_cocktail_comp[1][0]->SetName("hmass_pt1_eta_prime"); + hmass_cocktail_comp[1][1] = (TH1D*)fin1->Get("hmass_4"); + hmass_cocktail_comp[1][1]->SetName("hmass_pt1_rho"); + hmass_cocktail_comp[1][2] = (TH1D*)fin1->Get("hmass_7"); + hmass_cocktail_comp[1][2]->SetName("hmass_pt1_pi0"); + hmass_cocktail_comp[1][3] = (TH1D*)fin1->Get("hmass_8"); + hmass_cocktail_comp[1][3]->SetName("hmass_pt1_eta"); + hmass_cocktail_comp[1][4] = (TH1D*)fin1->Get("hmass_9"); + hmass_cocktail_comp[1][4]->SetName("hmass_pt1_omega"); + hmass_cocktail_comp[1][5] = (TH1D*)fin1->Get("hmass_10"); + hmass_cocktail_comp[1][5]->SetName("hmass_pt1_phi"); + + + + //TFile *fin3 = new TFile("./cocktail//cocktail_pt15_20.root"); + //TFile *fin3 = new TFile("./cocktail//cocktail_pt15_20_no_smearing.root"); + TFile *fin3 = new TFile("../../ana2/cocktail//cocktail_pt04_pairpt_15_20_no_smearing.root"); + fin3->cd(); + hmass_cocktail[2] = (TH1D*)fin3->Get("hmass_all"); + hmass_cocktail[2]->SetName("hmass_all_pt2"); + hmass_cocktail_comp[2][0] = (TH1D*)fin1->Get("hmass_3"); + hmass_cocktail_comp[2][0]->SetName("hmass_pt2_eta_prime"); + hmass_cocktail_comp[2][1] = (TH1D*)fin1->Get("hmass_4"); + hmass_cocktail_comp[2][1]->SetName("hmass_pt2_rho"); + hmass_cocktail_comp[2][2] = (TH1D*)fin1->Get("hmass_7"); + hmass_cocktail_comp[2][2]->SetName("hmass_pt2_pi0"); + hmass_cocktail_comp[2][3] = (TH1D*)fin1->Get("hmass_8"); + hmass_cocktail_comp[2][3]->SetName("hmass_pt2_eta"); + hmass_cocktail_comp[2][4] = (TH1D*)fin1->Get("hmass_9"); + hmass_cocktail_comp[2][4]->SetName("hmass_pt2_omega"); + hmass_cocktail_comp[2][5] = (TH1D*)fin1->Get("hmass_10"); + hmass_cocktail_comp[2][5]->SetName("hmass_pt2_phi"); + + + + //TFile *fin4 = new TFile("./cocktail//cocktail_pt20_no_smearing.root"); + //TFile *fin4 = new TFile("./cocktail//cocktail_pt20.root"); +TFile *fin4 = new TFile("../../ana2/cocktail//cocktail_pt04_pairpt_20_no_smearing.root"); + fin4->cd(); + hmass_cocktail[3] = (TH1D*)fin4->Get("hmass_all"); + hmass_cocktail[3]->SetName("hmass_all_pt3"); + hmass_cocktail_comp[3][0] = (TH1D*)fin1->Get("hmass_3"); + hmass_cocktail_comp[3][0]->SetName("hmass_pt3_eta_prime"); + hmass_cocktail_comp[3][1] = (TH1D*)fin1->Get("hmass_4"); + hmass_cocktail_comp[3][1]->SetName("hmass_pt3_rho"); + hmass_cocktail_comp[3][2] = (TH1D*)fin1->Get("hmass_7"); + hmass_cocktail_comp[3][2]->SetName("hmass_pt3_pi0"); + hmass_cocktail_comp[3][3] = (TH1D*)fin1->Get("hmass_8"); + hmass_cocktail_comp[3][3]->SetName("hmass_pt3_eta"); + hmass_cocktail_comp[3][4] = (TH1D*)fin1->Get("hmass_9"); + hmass_cocktail_comp[3][4]->SetName("hmass_pt3_omega"); + hmass_cocktail_comp[3][5] = (TH1D*)fin1->Get("hmass_10"); + hmass_cocktail_comp[3][5]->SetName("hmass_pt3_phi"); + + + + for(int i=0;i<4;i++){ + hmass_cocktail[i]->Rebin(4); + float ent = 0; + for(int j=0;jGetNbinsX();j++){ + if(hsub_clone[i]->GetBinCenter(j+1)<0.03){ + ent += hsub_clone[i]->GetBinWidth(j+1)*hsub_clone[i]->GetBinContent(j+1); + } + } + float ent2=0; + for(int j=0;jGetNbinsX();j++){ + if(hmass_cocktail[i]->GetBinCenter(j+1)<0.03){ + ent2 += hmass_cocktail[i]->GetBinWidth(j+1)*hmass_cocktail[i]->GetBinContent(j+1); + } + } + hmass_cocktail[i]->Scale(ent/ent2); + hmass_cocktail[i]->SetLineColor(6); + hmass_cocktail[i]->SetLineWidth(2); + c3->cd(i+1); + hmass_cocktail[i]->Draw("same,l"); + if(i>=1){ + c5->cd(i); + hmass_cocktail[i]->Draw("same,l"); + } + + for(int j=0;j<6;j++){ + hmass_cocktail_comp[i][j]->Rebin(4); + hmass_cocktail_comp[i][j]->Scale(ent/ent2*0.2); + hmass_cocktail_comp[i][j]->SetLineColor(1); + //hmass_cocktail_comp[i][j]->Draw("same"); + } + } + + float r_cocktail[nptbin]; + cout<<" ***************** "<FindBin(0); + int bin2=hmass_cocktail[i]->FindBin(0.03); + float ent1 = hmass_cocktail[i]->Integral(bin1, bin2-1); + bin1=hmass_cocktail[i]->FindBin(mass_low[nmassbin-1]); + bin2=hmass_cocktail[i]->FindBin(mass_high[nmassbin-1]); + float ent2 = hmass_cocktail[i]->Integral(bin1, bin2-1); + cout<<" pt : "<FindBin((0.5*(pt_low[i]+pt_high[i]))); + hmass_r_ck->SetBinContent(bin, ent2/ent1); + hmass_r_ck->SetBinError(bin, ent2/ent1*0.05); + r_cocktail[i] = ent2/ent1; + } + + float r_dir = 0.37; // this is from 90-300MeV + + TH1F *hmass_r = new TH1F("hmass_r","mass ratio", nptbin+1, mass_r_ptbin); + TH1F *hrgamma = new TH1F("hrgamma","r gmamma", nptbin+1, mass_r_ptbin); + cout<<" ***************** "<FindBin((0.5*(pt_low[i]+pt_high[i]))); + float r_data = (nsig[i][nmassbin-1]-nbg[i][nmassbin-1])/(nsig[i][0]-nbg[i][0]); + float er_data = sqrt(pow(ensig[i][nmassbin-1],2)+pow(enbg[i][nmassbin-1],2))/(nsig[i][0]-nbg[i][0]); + + hmass_r->SetBinContent(bin, r_data); + hmass_r->SetBinError(bin, er_data); + + float r_gamma = (r_data-r_cocktail[i])/(r_dir - r_cocktail[i]); + float e_r_gamma = (er_data)/(r_dir - r_cocktail[i]); + hrgamma->SetBinContent(bin, r_gamma); + hrgamma->SetBinError(bin, e_r_gamma); + + } + + hrgamma->SetXTitle("p_{T} [GeV]"); + hrgamma->SetYTitle("R_{#gamma}^{0-30}"); + hrgamma->SetMarkerColor(icent+1); + hrgamma->SetLineColor(icent+1); + hrgamma->SetMarkerStyle(20); + hrgamma->SetMinimum(0); + hrgamma->SetMaximum(1); + + TCanvas *c4 = new TCanvas("c4","c4"); + gPad->SetGrid(1); + hmass_r->SetXTitle("p_{T} [GeV]"); + hmass_r->SetYTitle("R_{data}^{90-300}"); + hmass_r->SetMarkerColor(icent+1); + hmass_r->SetLineColor(icent+1); + hmass_r->SetMarkerStyle(20); + hmass_r->SetMinimum(0); + hmass_r->SetMaximum(0.5); + + hmass_r_ck->SetMarkerStyle(24); + hmass_r->Draw(); hmass_r_ck->Draw("same"); + + + + + + + TFile *fout = new TFile(outname,"recreate"); + hw->Write(); + for(int i=0; iWrite(); + hsub_clone[i]->Write(); + } + for(int j=0;j<4;j++){ + hmass_cocktail[j]->Write(); + for(int k=0;k<6;k++){ + hmass_cocktail_comp[j][k]->Write(); + } + } + hmass_r->Write(); + hmass_r_ck->Write(); + hrgamma->Write(); + +} + + + + + diff --git a/PWGDQ/dielectron/TakuAlberica/pair/hadd.C b/PWGDQ/dielectron/TakuAlberica/pair/hadd.C new file mode 100644 index 00000000000..3dbe20be5fe --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/pair/hadd.C @@ -0,0 +1,167 @@ +//macro to add histogram files +//NOTE: This macro is kept for back compatibility only. +//Use instead the executable $ROOTSYS/bin/hadd +// +//This macro will add histograms from a list of root files and write them +//to a target root file. The target file is newly created and must not be +//identical to one of the source files. +// +//Author: Sven A. Schmidt, sven.schmidt@cern.ch +//Date: 13.2.2001 + +//This code is based on the hadd.C example by Rene Brun and Dirk Geppert, +//which had a problem with directories more than one level deep. +//(see macro hadd_old.C for this previous implementation). +// +//The macro from Sven has been enhanced by +// Anne-Sylvie Nicollerat +// to automatically add Trees (via a chain of trees). +// +//To use this macro, modify the file names in function hadd. +// +//NB: This macro is provided as a tutorial. +// Use $ROOTSYS/bin/hadd to merge many histogram files + + + +#include +#include "TChain.h" +#include "TFile.h" +#include "TH1.h" +#include "TTree.h" +#include "TKey.h" +#include "Riostream.h" + +TList *FileList; +TFile *Target; + +void MergeRootfile( TDirectory *target, TList *sourcelist ); + + +void hadd(int itrig=0, int icut=0) { + // in an interactive ROOT session, edit the file names + // Target and FileList, then + // root > .L hadd.C + // root > hadd() + char outname[100]; + sprintf(outname,"result_trig%d_cut%d.root",itrig, icut); + Target = TFile::Open(outname, "RECREATE" ); + + char inname[100]; + FileList = new TList(); + for(int i=0;i<29;i++){ + sprintf(inname,"ntpair_rev2_0_seg%d_%d_cut%d_trig%d\_v2.root", + i*50, (i+1)*50, icut, itrig); + FileList->Add( TFile::Open(inname)); + } + + MergeRootfile( Target, FileList ); + +} + +void MergeRootfile( TDirectory *target, TList *sourcelist ) { + + // cout << "Target path: " << target->GetPath() << endl; + TString path( (char*)strstr( target->GetPath(), ":" ) ); + path.Remove( 0, 2 ); + + TFile *first_source = (TFile*)sourcelist->First(); + first_source->cd( path ); + TDirectory *current_sourcedir = gDirectory; + //gain time, do not add the objects in the list in memory + Bool_t status = TH1::AddDirectoryStatus(); + TH1::AddDirectory(kFALSE); + + // loop over all keys in this directory + TChain *globChain = 0; + TIter nextkey( current_sourcedir->GetListOfKeys() ); + TKey *key, *oldkey=0; + while ( (key = (TKey*)nextkey())) { + + //keep only the highest cycle number for each key + if (oldkey && !strcmp(oldkey->GetName(),key->GetName())) continue; + + // read object from first source file + first_source->cd( path ); + TObject *obj = key->ReadObj(); + + if ( obj->IsA()->InheritsFrom( TH1::Class() ) ) { + // descendant of TH1 -> merge it + + // cout << "Merging histogram " << obj->GetName() << endl; + TH1 *h1 = (TH1*)obj; + + // loop over all source files and add the content of the + // correspondant histogram to the one pointed to by "h1" + TFile *nextsource = (TFile*)sourcelist->After( first_source ); + while ( nextsource ) { + + // make sure we are at the correct directory level by cd'ing to path + nextsource->cd( path ); + TKey *key2 = (TKey*)gDirectory->GetListOfKeys()->FindObject(h1->GetName()); + if (key2) { + TH1 *h2 = (TH1*)key2->ReadObj(); + h1->Add( h2 ); + delete h2; + } + + nextsource = (TFile*)sourcelist->After( nextsource ); + } + } + else if ( obj->IsA()->InheritsFrom( TTree::Class() ) ) { + + // loop over all source files create a chain of Trees "globChain" + const char* obj_name= obj->GetName(); + + globChain = new TChain(obj_name); + globChain->Add(first_source->GetName()); + TFile *nextsource = (TFile*)sourcelist->After( first_source ); + // const char* file_name = nextsource->GetName(); + // cout << "file name " << file_name << endl; + while ( nextsource ) { + + globChain->Add(nextsource->GetName()); + nextsource = (TFile*)sourcelist->After( nextsource ); + } + + } else if ( obj->IsA()->InheritsFrom( TDirectory::Class() ) ) { + // it's a subdirectory + + cout << "Found subdirectory " << obj->GetName() << endl; + + // create a new subdir of same name and title in the target file + target->cd(); + TDirectory *newdir = target->mkdir( obj->GetName(), obj->GetTitle() ); + + // newdir is now the starting point of another round of merging + // newdir still knows its depth within the target file via + // GetPath(), so we can still figure out where we are in the recursion + MergeRootfile( newdir, sourcelist ); + + } else { + + // object is of no type that we know or can handle + cout << "Unknown object type, name: " + << obj->GetName() << " title: " << obj->GetTitle() << endl; + } + + // now write the merged histogram (which is "in" obj) to the target file + // note that this will just store obj in the current directory level, + // which is not persistent until the complete directory itself is stored + // by "target->Write()" below + if ( obj ) { + target->cd(); + + //!!if the object is a tree, it is stored in globChain... + if(obj->IsA()->InheritsFrom( TTree::Class() )) + globChain->Merge(target->GetFile(),0,"keep"); + else + obj->Write( key->GetName() ); + } + + } // while ( ( TKey *key = (TKey*)nextkey() ) ) + + // save modifications to target file + target->SaveSelf(kTRUE); + TH1::AddDirectory(status); +} diff --git a/PWGDQ/dielectron/TakuAlberica/pair/makefig.C b/PWGDQ/dielectron/TakuAlberica/pair/makefig.C new file mode 100644 index 00000000000..551c4fc192b --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/pair/makefig.C @@ -0,0 +1,181 @@ +void makefig(const int trig=0, const int icut=0, const int icent=0){ + + gStyle->SetPalette(1); + gStyle->SetOptStat(0); + gStyle->SetOptFit(111111); + gStyle->SetOptFit(0); + gStyle->SetOptTitle(0); + //gStyle->SetFillColor(10); + gStyle->SetCanvasColor(10); + gStyle->SetFrameBorderMode(0); + gStyle->SetFrameFillColor(0); + gStyle->SetCanvasColor(0); + gStyle->SetPadBorderSize(0); + gStyle->SetCanvasBorderSize(0); + //gStyle->SetPadLeftMargin(0.15); + gStyle->SetPadLeftMargin(0.125); + gStyle->SetPadBottomMargin(0.125); + gStyle->SetPadTopMargin(0.1); + gStyle->SetTitleYOffset(1.3); + //gStyle->SetPadLeftMargin(0.1); + gStyle->SetTitleW(0.7); + gStyle->SetTitleH(0.1); + cout<<"physics is always fun! "<Get(name); + hmasspt[i][10]->Add(hmasspt[i][j]); + } + } + + + TH1D *hpy = hmasspt[0][0]->ProjectionY("hpy"); + + ////// range of pT ///////////////////////////////// + int npt=3; + float low[4] ={0, 1, 2}; + float high[4]={1, 2, 4}; + + //// [pairtype][pt] ////////////////////////////// + TH1D *hmass[7][4]; ///sliced mass spectrum + for(int i=0;i<7;i++){ + for(int ipt=0;iptFindBin(low[ipt]); + int rangehigh = hpy->FindBin(high[ipt]); + sprintf(name,"hmass_tmp_pt%d_cent%d_%d",ipt, icent, i); + hmass[i][ipt] = (TH1D*)hmasspt[i][icent]->ProjectionX(name, rangelow, rangehigh-1); + } + } + + //////// another historgram to merge like sign/mixed like sign + //////// hmass_add will be scaled. + /////// hmass_org will be unchanged. + TH1D *hmass_add[4][4]; + TH1D *hmass_org[4][4]; + for(int i=0;i<4;i++){ + for(int ipt=0;iptSumw2(); + sprintf(name,"hmass_pt%d_cent%d_%d_org",ipt, j, i); + hmass_org[i][ipt] = new TH1D(name, name, 500, 0, 5); + hmass_org[i][ipt]->Sumw2(); + } + } + for(int ipt=0;iptAdd(hmass[0][ipt]); + hmass_add[1][ipt]->Add(hmass[1][ipt]); + hmass_add[1][ipt]->Add(hmass[2][ipt]); + hmass_add[2][ipt]->Add(hmass[3][ipt]); + hmass_add[2][ipt]->Add(hmass[4][ipt]); + hmass_add[3][ipt]->Add(hmass[5][ipt]); + hmass_add[3][ipt]->Add(hmass[6][ipt]); + + hmass_org[0][ipt]->Add(hmass[0][ipt]); + hmass_org[1][ipt]->Add(hmass[1][ipt]); + hmass_org[1][ipt]->Add(hmass[2][ipt]); + hmass_org[2][ipt]->Add(hmass[3][ipt]); + hmass_org[2][ipt]->Add(hmass[4][ipt]); + hmass_org[3][ipt]->Add(hmass[5][ipt]); + hmass_org[3][ipt]->Add(hmass[6][ipt]); + + + ///// scaling factor for like sign and mixed like sign + float scale1 = hmass_add[0][ipt]->GetEntries()/(2*sqrt(hmass[1][ipt]->GetEntries()*hmass[2][ipt]->GetEntries())); + float scale2 = hmass_add[2][ipt]->GetEntries()/(2*sqrt(hmass[5][ipt]->GetEntries()*hmass[6][ipt]->GetEntries())); + + hmass_add[1][ipt]->Scale(scale1); + hmass_add[3][ipt]->Scale(scale2); + hmass_org[1][ipt]->Scale(scale1); + hmass_org[3][ipt]->Scale(scale2); + } + + + ///// then take ratio of mixed unlike / mixed like + TH1F *hdiv[4]; + for(int ipt=0;iptSumw2(); + hdiv[ipt]->Divide(hmass_add[2][ipt], hmass_add[3][ipt]); + hdiv[ipt]->SetMaximum(2); + hdiv[ipt]->SetMinimum(0); + + //// multiply to like sign + hmass_add[1][ipt]->Multiply(hdiv[ipt]); + + } + + TCanvas *c0 = new TCanvas("c0","c0",1200,800); + c0->Divide(npt,2); + for(int ipt=0;iptcd(ipt+1); + gPad->SetLogy(); + gPad->SetGrid(1); + hmass_add[0][ipt]->SetXTitle("M_{ee} [GeV]"); + hmass_add[0][ipt]->SetYTitle("counts"); + hmass_add[0][ipt]->SetAxisRange(0,4); + hmass_add[0][ipt]->SetLineColor(1); + hmass_org[1][ipt]->SetLineColor(2); + hmass_add[0][ipt]->SetMinimum(1); + hmass_add[0][ipt]->Draw(); + hmass_org[1][ipt]->Draw("same"); + + c0->cd(ipt+1+npt); + gPad->SetLogy(); + gPad->SetGrid(1); + hmass_add[2][ipt]->SetXTitle("M_{ee} [GeV]"); + hmass_add[2][ipt]->SetYTitle("counts"); + hmass_add[2][ipt]->SetAxisRange(0,4); + hmass_add[2][ipt]->SetLineColor(4); + hmass_org[3][ipt]->SetLineColor(6); + hmass_add[2][ipt]->SetMinimum(1); + hmass_add[2][ipt]->Draw(); + hmass_org[3][ipt]->Draw("same"); + } + + + + + + TCanvas *c1 = new TCanvas("c1","c1",1200,800); + c1->Divide(npt,2); + for(int ipt=0;iptcd(ipt+1); + + gPad->SetGrid(1); + hdiv[ipt]->SetXTitle("M_{ee}"); + hdiv[ipt]->SetYTitle("R(Mixed unlike/Mixed like)"); + hdiv[ipt]->Draw(); + + c1->cd(ipt+1+npt); + + gPad->SetGrid(1); + gPad->SetLogy(); + hmass_add[0][ipt]->SetXTitle("M_{ee} [GeV]"); + hmass_add[0][ipt]->SetYTitle("counts"); + hmass_add[0][ipt]->SetAxisRange(0,4); + hmass_add[0][ipt]->SetLineColor(1); + hmass_add[1][ipt]->SetLineColor(2); + + hmass_add[0][ipt]->SetMinimum(1); + hmass_add[0][ipt]->Draw(); + hmass_add[1][ipt]->Draw("same"); + hmass_add[0][ipt]->Draw("same"); + } +} diff --git a/PWGDQ/dielectron/TakuAlberica/pair/run_all.C b/PWGDQ/dielectron/TakuAlberica/pair/run_all.C new file mode 100644 index 00000000000..d2eeaf60ab2 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/pair/run_all.C @@ -0,0 +1,108 @@ +void run_all(int id=0, int end=50, int pro=0, int icut=0, int itrig=0){ + + gStyle->SetPalette(1); + gStyle->SetOptStat(0); + gStyle->SetOptFit(111111); + gStyle->SetOptFit(0); + gStyle->SetOptTitle(0); + //gStyle->SetFillColor(10); + gStyle->SetCanvasColor(10); + gStyle->SetFrameBorderMode(0); + gStyle->SetFrameFillColor(0); + gStyle->SetCanvasColor(0); + gStyle->SetPadBorderSize(0); + gStyle->SetCanvasBorderSize(0); + //gStyle->SetPadLeftMargin(0.15); + gStyle->SetPadLeftMargin(0.125); + gStyle->SetPadBottomMargin(0.125); + gStyle->SetPadTopMargin(0.1); + gStyle->SetTitleYOffset(1.3); + //gStyle->SetPadLeftMargin(0.1); + cout<<"physics is always fun! "<Load("libCore");// no + gSystem->Load("libTree"); + gSystem->Load("libGeom"); + gSystem->Load("libVMC"); + gSystem->Load("libXMLIO");// no + gSystem->Load("libPhysics"); + gSystem->Load("libXMLParser"); + gSystem->Load("libProof"); + gSystem->Load("libMinuit"); + + + gSystem->Load("libana_sgl.so"); + ana_sgl *ana=new ana_sgl(); + + char outputname[100]; + sprintf(outputname,"ntpair_rev2_%d_seg%d_%d_cut%d_trig%d_v2.root", pro, id,end, icut, itrig); + + + ana->ana_init(outputname); + + //ana->set_tof_cuts(-3,3); + //ana->enable_pair_emc_cut(0.7, 1.3); + //ana->enable_pait_pt_cut(0.4, 20); + + if(pro==1){ + ana->set_veto_for_proton(-2, 3.5); + ana->set_veto_for_kaon(-2, 3.5); + } + + //0->MB, 1->SemiCent, 2-->Cent + if(itrig==0){ + ana->select_trigger(2); + }else if(itrig==1){ + ana->select_trigger(1); + } + + if(icut==0){ + ana->reject_conversion(true); + //ana->set_tpc_dedx_cuts(75, 90); + ana->set_tpc_dedx_cuts(65, 90); + ana->enable_pair_phiv_cut(0.6); + }else if(icut==1){ + //ana->reject_conversion(true); + //ana->set_tpc_dedx_cuts(80, 85); + //ana->set_tpc_dedx_cuts(68, 75); + ana->set_tpc_dedx_cuts(65, 90); + ana->enable_pair_phiv_cut(0.6); + }else if(icut==2){ + ana->reject_conversion(true); + ana->set_tpc_dedx_cuts(75, 90); + ana->enable_pair_phiv_cut(0.6); + }else if(icut==3){ + ana->reject_conversion(true); + ana->set_tpc_dedx_cuts(80, 85); + ana->enable_pair_phiv_cut(0.6); + } + + ana->print_cuts(); + + if(pro==0){ + ifstream f("list_rev1_0.all"); + int nline = 1418; + }else if(pro==1){ + ifstream f("list_rev2_6.all"); + int nline = 50; + }else if(pro==2){ + ifstream f("list_rev2_7.all"); + int nline = 50; + } + + + char inputfilename[100]; + for(int i=0;i> inputfilename; + if(i>=id && iloop_a_file(inputfilename); + cout<<" end of run : "<ana_end(); + +} + diff --git a/PWGDQ/dielectron/TakuAlberica/pair/tmp.C b/PWGDQ/dielectron/TakuAlberica/pair/tmp.C new file mode 100644 index 00000000000..6221269608d --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/pair/tmp.C @@ -0,0 +1,43 @@ +#define tmp_cxx +#include "tmp.h" +#include +#include +#include + +void tmp::Loop() +{ +// In a ROOT session, you can do: +// Root > .L tmp.C +// Root > tmp t +// Root > t.GetEntry(12); // Fill t data members with entry number 12 +// Root > t.Show(); // Show values of entry 12 +// Root > t.Show(16); // Read and show values of entry 16 +// Root > t.Loop(); // Loop on all entries +// + +// This is the loop skeleton where: +// jentry is the global entry number in the chain +// ientry is the entry number in the current Tree +// Note that the argument to GetEntry must be: +// jentry for TChain::GetEntry +// ientry for TTree::GetEntry and TBranch::GetEntry +// +// To read only selected branches, Insert statements like: +// METHOD1: +// fChain->SetBranchStatus("*",0); // disable all branches +// fChain->SetBranchStatus("branchname",1); // activate branchname +// METHOD2: replace line +// fChain->GetEntry(jentry); //read all branches +//by b_branchname->GetEntry(ientry); //read only this branch + if (fChain == 0) return; + + Long64_t nentries = fChain->GetEntriesFast(); + + Long64_t nbytes = 0, nb = 0; + for (Long64_t jentry=0; jentryGetEntry(jentry); nbytes += nb; + // if (Cut(ientry) < 0) continue; + } +} diff --git a/PWGDQ/dielectron/TakuAlberica/single/000170088.xml b/PWGDQ/dielectron/TakuAlberica/single/000170088.xml new file mode 100644 index 00000000000..a2cf28eef59 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/000170088.xml @@ -0,0 +1,19583 @@ +Feb 7 16:22:21 info AND THE OPTIONS ARE + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/PWGDQ/dielectron/TakuAlberica/single/000170088_000170088.xml b/PWGDQ/dielectron/TakuAlberica/single/000170088_000170088.xml new file mode 100644 index 00000000000..64e98c5aa06 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/000170088_000170088.xml @@ -0,0 +1,14688 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/PWGDQ/dielectron/TakuAlberica/single/AddRunsPbPb.C b/PWGDQ/dielectron/TakuAlberica/single/AddRunsPbPb.C new file mode 100644 index 00000000000..5de59c03792 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/AddRunsPbPb.C @@ -0,0 +1,102 @@ +class AliAnalysisAlien; + +void AddRunsPbPb(AliAnalysisAlien* plugin,bool onAOD=false) { + // plugin->SetGridDataDir("/alice/data/2010/LHC10h"); + plugin->SetGridDataDir("/alice/data/2011/LHC11h_2"); + if( onAOD ){ + plugin->SetDataPattern("*ESDs/pass1/AOD033/*/AliAOD.root"); + }else{ + // plugin->SetDataPattern("*ESDs/pass2/*/AliESDs.root"); + plugin->SetDataPattern("*ESDs/pass2/*/AliESDs.root"); + } + /* + int FieldMM[42] = { 169591, 169590, 169588, 169587, 169586, + 169584, 169557, 169555, 169554, 169553, + 169550, 169515, 169512, 169506, 169504, + 169498, 169475, 169420, 169419, 169418, + 169417, 169415, 169411, 169382, 169377, + 169238, 169236, 169167, 169160, 169156, + 169148, 169145, 169144, 169143, 169138, + 169099, 169094, 169091, 169045, 169044, + 169040, 169035 + }; + // for(int ir=10; ir!=42; ++ir){ + for(int ir=0; ir!=42; ++ir){ + plugin->AddRunNumber( FieldMM[ir] ); + } + */ + + /* + int FieldMM[46] = {168066, 168068, 168069, 168076, 168103, + 168104, 168105, 168107, 168108, 168115, + 168171, 168172, 168173, 168175, 168177, + 168181, 168203, 168206, 168207, 168208, + 168212, 168213, 168310, 168311, 168318, + 168322, 168325, 168341, 168342, 168356, + 168361, 168362, 168458, 168460, 168461, + 168464, 168467, 168511, 168512, 168514, + 168644, 168777, 168826, 168984, 168988, + 168992 + }; + + + // for(int ir=10; ir!=42; ++ir){ + for(int ir=0; ir!=46; ++ir){ + //if(FieldMM[ir]!=168177){ + if(FieldMM[ir]>=168213 && + FieldMM[ir]<=168361 + ){ + plugin->AddRunNumber( FieldMM[ir] ); + } + } + */ + /* + int FieldMM[23] = { + 167693, 167706, 167711, 167712, 167713, + 167806, 167807, 167814, 167818, 167841, + 167842, 167844, 167846, 167902, 167903, + 167909, 167915, 167920, 167921, 167985, + 167986, 167987, 167988 + }; + // for(int ir=10; ir!=42; ++ir){ + for(int ir=0; ir!=23; ++ir){ + plugin->AddRunNumber( FieldMM[ir] ); + } + */ + + /* + int FieldPP[22]={ + 169683, 169835, 169837, 169838, 169846, + 169855, 169858, 169859, 169914, 169918, + 169919, 169920, 169922, 169923, 169924, + 169926, 169956, 169961, 169965, 169969, + 169975, 169981 + }; + */ + + int FieldPP[44]={ + 170027, 170036, 170038, 170040, 170081, + 170083, 170084, 170085, 170088, 170089, + 170091, 170152, 170155, 170159, 170162, + 170163, 170193, 170195, 170203, 170204, + 170205, 170228, 170230, 170267, 170268, + 170269, 170270, 170306, 170308, 170309, + 170311, 170312, 170313, 170315, 170374, + 170387, 170388, 170389, 170390, 170546, + 170552, 170556, 170572, 170593 + }; + + // for(int ir=0; ir!=44; ++ir){ + // //this is rev1_6 + // // if(FieldPP[ir]>=170091 && + // // FieldPP[ir]<=170204){ + // if(FieldPP[ir]>=170552 && + // FieldPP[ir]<=170593){ + // plugin->AddRunNumber( FieldPP[ir] ); + // } + // } + plugin->AddRunNumber(170088); + plugin->SetNrunsPerMaster(10); + +} + diff --git a/PWGDQ/dielectron/TakuAlberica/single/AddTaskDielectronTaku.C b/PWGDQ/dielectron/TakuAlberica/single/AddTaskDielectronTaku.C new file mode 100644 index 00000000000..de3a14822fb --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/AddTaskDielectronTaku.C @@ -0,0 +1,165 @@ +AliAnalysisTask *AddTaskDielectronTaku(Float_t centrMin, Float_t centrMax, + TString fileName, TString suffixName="", + Bool_t hasMC_aod = kFALSE) +{ + //get the current analysis manager + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) { + ::Error("AddTaskDielectron", "No analysis manager found."); + return NULL; + } + if (!mgr->GetInputEventHandler()) { + ::Error("AddTaskDielectron", "This task requires an input event handler"); + return NULL; + } + + //Do we have an MC handler? + Bool_t hasMC=(mgr->GetMCtruthEventHandler()!=0x0); + /* + TString configFile("./ConfigJpsi2eeDataTaku.C"); + if (hasMC){ + configFile="$ALICE_ROOT/PWG3/dielectron/macros/ConfigJpsi2eeEff.C"; + } + */ + Bool_t isAOD=mgr->GetInputEventHandler()->IsA()==AliAODInputHandler::Class(); + + //Add event filter + AliDielectronEventCuts *eventCuts=new AliDielectronEventCuts( + Form("eventCuts_%s",suffixName.Data()), + "Vertex Track && |vtxZ|<10 && ncontrib>0" + ); + eventCuts->SetCentralityRange(centrMin,centrMax); + eventCuts->SetRequireVertex(); + eventCuts->SetMinVtxContributors(1); + eventCuts->SetVertexZ(-10.,10.); + + + + + + //create task and add it to the manager + //cout<<"AliAnalysisTaskMultiDielectron : "<SetCheckEventSelection(kFALSE); + //tender->SetDefaultCDBStorage("raw://"); + tender->SetDefaultCDBStorage("alien://folder=/alice/data/2011/OCDB"); + //========= Attach TOF supply ====== + AliTOFTenderSupply *TOFtender = new AliTOFTenderSupply("TOFtender"); + TOFtender->SetTOFres(80); + TOFtender->SetCorrectExpTimes(kFALSE); + //TOFtender->SetTheorExpTimes(kTRUE); + ///tender->AddSupply(TOFtender); + + //========= Attach TPC supply ====== + AliTPCTenderSupply *tpcSupply=new AliTPCTenderSupply("TPCtender"); + tpcSupply->SetDebugLevel(2); + //tpcSupply->SetMip(50.); + ///tender->AddSupply(tpcSupply); + + ///mgr->AddTask(tender); + + + //======== Event plane ============= + AliEPSelectionTask *eventplaneTask = new AliEPSelectionTask("EventplaneSelection"); + eventplaneTask->SelectCollisionCandidates(AliVEvent::kMB); + eventplaneTask->SetTrackType("TPC"); + eventplaneTask->SetUsePtWeight(); + ///mgr->AddTask(eventplaneTask); + + ///mgr->AddTask(task); + + //---------------------- + //create data containers + //---------------------- + //cout<<"----- "<GetCommonFileName()<<" + "<GetCommonFileName(); + containerName += ":PWG3_dielectron"; + + //create output container + + AliAnalysisDataContainer *cOutputHist1 = + mgr->CreateContainer(Form("jpsi_QA_%s",suffixName.Data()), TList::Class(), AliAnalysisManager::kOutputContainer, + containerName.Data()); + + AliAnalysisDataContainer *cOutputHist2 = + mgr->CreateContainer(Form("jpsi_CF_%s",suffixName.Data()), TList::Class(), AliAnalysisManager::kOutputContainer, + containerName.Data()); + + AliAnalysisDataContainer *cOutputHist3 = + mgr->CreateContainer(Form("jpsi_EventStat_%s",suffixName.Data()), + TH1D::Class(), + AliAnalysisManager::kOutputContainer, + containerName.Data()); + + AliAnalysisDataContainer *coutput1 = + mgr->CreateContainer(Form("single_tree_%s", suffixName.Data()), + //TList::Class(), + TTree::Class(), + AliAnalysisManager::kOutputContainer, + containerName.Data()); + + AliAnalysisDataContainer *coutput_ep1 = mgr->CreateContainer("EPStat", + TList::Class(), AliAnalysisManager::kOutputContainer, + "EventStat_temp.root"); + + + AliAnalysisDataContainer *coutput_td1 = + mgr->CreateContainer("tender_event", AliESDEvent::Class(), + AliAnalysisManager::kExchangeContainer,"default_tender"); + + + cout<<"containerName.Data = "<ConnectInput(eventplaneTask, 0, mgr->GetCommonInputContainer()); + //mgr->ConnectOutput(eventplaneTask,1,coutput_ep1); + + + // mgr->ConnectInput(tender, 0, mgr->GetCommonInputContainer()); + // mgr->ConnectOutput(tender,1,coutput_td1); + + + + + mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer()); + mgr->ConnectOutput(task, 1, cOutputHist1); + mgr->ConnectOutput(task, 2, cOutputHist2); + mgr->ConnectOutput(task, 3, cOutputHist3); + mgr->ConnectOutput(task, 4, coutput1); + + + + return task; +} diff --git a/PWGDQ/dielectron/TakuAlberica/single/AliAnalysisTaskMultiDielectronNewTaku.cxx b/PWGDQ/dielectron/TakuAlberica/single/AliAnalysisTaskMultiDielectronNewTaku.cxx new file mode 100644 index 00000000000..39be56d07dd --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/AliAnalysisTaskMultiDielectronNewTaku.cxx @@ -0,0 +1,1071 @@ +/************************************************************************* +* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. * +* * +* Author: The ALICE Off-line Project. * +* Contributors are mentioned in the code where appropriate. * +* * +* Permission to use, copy, modify and distribute this software and its * +* documentation strictly for non-commercial purposes is hereby granted * +* without fee, provided that the above copyright notice appears in all * +* copies and that both the copyright notice and this permission notice * +* appear in the supporting documentation. The authors make no claims * +* about the suitability of this software for any purpose. It is * +* provided "as is" without express or implied warranty. * +**************************************************************************/ + +/////////////////////////////////////////////////////////////////////////// +// // +// Basic Analysis Task // +// // +/////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include "TVector2.h" + + +#include +#include +#include +#include +#include +#include +#include + + +#include +#include "TGeoManager.h" +#include "AliGeomManager.h" +#include + + +#include "AliDielectronTaku.h" +#include "AliDielectronHistosTaku.h" +#include "AliDielectronCF.h" +#include "AliDielectronMC.h" +#include "AliDielectronEventCuts.h" + +#include "AliAnalysisTaskMultiDielectronNewTaku.h" + +#include "AliESDEvent.h" +#include "AliESDInputHandler.h" +#include "AliESDv0.h" +#include "AliESDtrack.h" +#include "AliESDtrackCuts.h" +#include "AliCentrality.h" +#include "AliVVertex.h" +#include "AliESDVZERO.h" +#include "AliEMCALTrack.h" +//#include "AliFlowEventSimple.h" +//#include "AliFlowLYZEventPlane.h" + + +ClassImp(AliAnalysisTaskMultiDielectronNewTaku) + +//_________________________________________________________________________________ +AliAnalysisTaskMultiDielectronNewTaku::AliAnalysisTaskMultiDielectronNewTaku() : + AliAnalysisTaskSE(), + fListDielectron(), + fListHistos(), + fListTree(NULL), + fListCF(), + fTree(NULL), + fSelectPhysics(kFALSE), + fTriggerMask(AliVEvent::kMB), + fTriggerOnV0AND(kFALSE), + fRejectPileup(kFALSE), + fTriggerAnalysis(0x0), + fEventFilter(0x0), + fCutsEvent(0x0), + fCutsMother(0x0), + fEventStat(0x0), + fEvent(0x0), + fdEdXvsPt(0x0), + fdEdXnSigmaElecvsPt(0x0), + fTOFbetavsPt(0x0), + fTOFnSigmaElecvsPt(0x0), + fTPCcrossedRowsvsPt(0x0), + fTPCchi2vsPt(0x0), + fNEvent(0), + fkTriggerMask(0), + fkTriggerCent(0), + fkNCut(0), + fkRunNumber(0), + fkCentrality(0), + fkXvPrim(0), + fkYvPrim(0), + fkZvPrim(0), + fkXRes(0), + fkYRes(0), + fkZRes(0), + fkNTrk(0), + fkTracks(0), + fkNacc(0), + fkNaccTrcklts(0), + fkNch(0), + fkZDCN1E(0), + fkZDCP1E(0), + fkZDCN2E(0), + fkZDCP2E(0), + fkV0A(0), + fkV0C(0), + fkNPar(0), + // fFlowEvent(0), + // fLyzEp(0), + fQsum(NULL), + fQ2sum(0), + fkTriggerInfo(0), + fMag(0) +{ + // + // Constructor + // + + +} + +//_________________________________________________________________________________ +AliAnalysisTaskMultiDielectronNewTaku::AliAnalysisTaskMultiDielectronNewTaku(const char *name, + AliDielectronEventCuts* cutsEvent + ) : + AliAnalysisTaskSE(name), + fListDielectron(), + fListHistos(), + fListTree(NULL), + fListCF(), + fTree(NULL), + fSelectPhysics(kFALSE), + fTriggerMask(AliVEvent::kMB), + fTriggerOnV0AND(kFALSE), + fRejectPileup(kFALSE), + fTriggerAnalysis(0x0), + fEventFilter(0x0), + fCutsEvent(cutsEvent), + fCutsMother(0x0), + fEventStat(0x0), + fEvent(0x0), + fdEdXvsPt(0x0), + fdEdXnSigmaElecvsPt(0x0), + fTOFbetavsPt(0x0), + fTOFnSigmaElecvsPt(0x0), + fTPCcrossedRowsvsPt(0x0), + fTPCchi2vsPt(0x0), + fNEvent(0), + fkTriggerMask(0), + fkTriggerCent(0), + fkNCut(0), + fkRunNumber(0), + fkCentrality(0), + fkXvPrim(0), + fkYvPrim(0), + fkZvPrim(0), + fkXRes(0), + fkYRes(0), + fkZRes(0), + fkNTrk(0), + fkTracks(0), + fkNacc(0), + fkNaccTrcklts(0), + fkNch(0), + fkZDCN1E(0), + fkZDCP1E(0), + fkZDCN2E(0), + fkZDCP2E(0), + fkV0A(0), + fkV0C(0), + fkNPar(0), + // fFlowEvent(0), + // fLyzEp(0), + fQsum(NULL), + fQ2sum(0), + fkTriggerInfo(0), + fMag(0) +{ + // + // Constructor + // + DefineInput(0,TChain::Class()); + DefineOutput(1, TList::Class()); + //DefineOutput(1, TTree::Class()); + DefineOutput(2, TList::Class()); + DefineOutput(3, TH1D::Class()); + DefineOutput(4, TTree::Class()); + + fName = name; + // Constructor. + fQsum = new TVector2(); // flow vector sum + fQ2sum = 0; + + + cout<<" ************** AliAnalysisTaskMultiDielectron::AliAnalysisTaskMultiDielectron ***********"<GetInputEventHandler()->IsA()==AliESDInputHandler::Class(); +// Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class(); + + TIter nextDie(&fListDielectron); + AliDielectronTaku *die=0; + while ( (die=static_cast(nextDie())) ){ + die->Init(); + if (die->GetHistogramList()) fListHistos.Add(const_cast(die->GetHistogramList())); + if (die->GetCFManagerPair()) fListCF.Add(const_cast(die->GetCFManagerPair()->GetContainer())); + //if (die->GetTreeList()) fListTree.Add(const_cast(die->GetTreeList())); + ///if (die->GetTreeList()) fTree = (TTree*)(die->GetTreeManager()->GetSingleTree()); + } + + Int_t cuts=fListDielectron.GetEntries(); + Int_t nbins=kNbinsEvent+2*cuts; + if (!fEventStat){ + + fEventStat=new TH1D(Form("hEventStat_%s",fName.Data()),"Event statistics",nbins,0,nbins); + fEventStat->GetXaxis()->SetBinLabel(1,"Before Phys. Sel."); + fEventStat->GetXaxis()->SetBinLabel(2,"After Phys. Sel."); + + //default names + fEventStat->GetXaxis()->SetBinLabel(3,"Bin3 not used"); + fEventStat->GetXaxis()->SetBinLabel(4,"Bin4 not used"); + fEventStat->GetXaxis()->SetBinLabel(5,"Bin5 not used"); + + if (fTriggerOnV0AND&&isESD) fEventStat->GetXaxis()->SetBinLabel(3,"V0and triggers"); + if (fEventFilter) fEventStat->GetXaxis()->SetBinLabel(4,"After Event Filter"); + if (fRejectPileup) fEventStat->GetXaxis()->SetBinLabel(5,"After Pileup rejection"); + + for (Int_t i=0; iGetXaxis()->SetBinLabel((kNbinsEvent+1)+2*i,Form("#splitline{1 candidate}{%s}",fListDielectron.At(i)->GetName())); + fEventStat->GetXaxis()->SetBinLabel((kNbinsEvent+2)+2*i,Form("#splitline{With >1 candidate}{%s}",fListDielectron.At(i)->GetName())); + } + } + + if (!fTriggerAnalysis) fTriggerAnalysis=new AliTriggerAnalysis; + fTriggerAnalysis->EnableHistograms(); + fTriggerAnalysis->SetAnalyzeMC(AliDielectronMC::Instance()->HasMC()); + + + //// this is just test + //// I would like to see dE/dx, pT, and so on... + + TList *tQAElectron = new TList(); + tQAElectron->SetName("QAElectron"); + tQAElectron->SetOwner(); + + + int nbinx=400; + float max_x=20; + float min_x=0.2; + float binw = (TMath::Log(max_x)-TMath::Log(min_x))/nbinx; + double xbin[401]; + for(int ii=0;iiAdd(fEvent); + //fdEdXvsPt = new TH2D("dEdXvsPt","dE/dX vs. PT of TPC", 400,0, 20, 2000,0,200); + fdEdXvsPt = new TH2D("dEdXvsPt","dE/dX vs. PT of TPC", nbinx, xbin, 2000,0,200); + tQAElectron->Add(fdEdXvsPt); + fdEdXnSigmaElecvsPt = new TH2D("fdEdXnSigmaElecvsPt"," dE/dX normalized to electron vs. pT of TPC", + // 400, 0, 20, 2000, -10, 10); + nbinx, xbin, 2000, -10, 10); + tQAElectron->Add(fdEdXnSigmaElecvsPt); + fTOFbetavsPt = new TH2D("fTOFbetavsPt","TOF beta vs. p", 400, 0, 20, 1200, 0, 1.2); + tQAElectron->Add(fTOFbetavsPt); + fTOFnSigmaElecvsPt = new TH2D("fTOFnSigmaElecvsPt","TOF nsigma for electron", 400, 0, 20, 2000, -10, 10); + tQAElectron->Add(fTOFnSigmaElecvsPt); + + fTPCcrossedRowsvsPt = new TH2D("fTTPCcrossedRowsvsPt","TPC crossed rows", 400, 0, 20, 1000,0,1000); + tQAElectron->Add(fTPCcrossedRowsvsPt); + fTPCchi2vsPt = new TH2D("fTTPCchi2RowsvsPt","TPC chi2", 400, 0, 20, 1000,0,100); + tQAElectron->Add(fTPCchi2vsPt); + + + fListHistos.Add(tQAElectron); + + PostData(1, &fListHistos); + PostData(2, &fListCF); + PostData(3, fEventStat); + //PostData(4, &fListTree); + + //PostData(1,&fListTree); + fTree = new TTree(Form("tree_%s",fName.Data()),"single"); + SetBranches(fTree); + + PostData(4,fTree); + + + ////// basic cuts + fCutsMother = new AliESDtrackCuts; + fCutsMother->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst); + fCutsMother->SetRequireTPCRefit(kTRUE); + fCutsMother->SetRequireITSRefit(kTRUE); + fCutsMother->SetMaxDCAToVertexZ(3.0); + fCutsMother->SetMaxDCAToVertexXY(1.0); + fCutsMother->SetEtaRange( -0.9 , 0.9 ); + fCutsMother->SetAcceptKinkDaughters(kFALSE); + fCutsMother->SetPtRange(0.2,10); + fCutsMother->SetMinNClustersTPC(70); + fCutsMother->SetMaxChi2PerClusterTPC(4); + + + //lee yang zeros event plane + //fLyzEp = new AliFlowLYZEventPlane() ; + //fLyzEp-> Init(); + + fkTriggerInfo = new TObjArray(100); + + fNEvent = 0; + fkNPar=0; + cout<<" ************** AliAnalysisTaskMultiDielectron::UserCreateOutputObjects End ***********"<GetInputEventHandler()->IsA()==AliESDInputHandler::Class(); + Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class(); + + AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler()); + if (!inputHandler) return; + + if ( inputHandler->GetPIDResponse() ){ + AliDielectronVarManager::SetPIDResponse( inputHandler->GetPIDResponse() ); + } else { + //load esd pid bethe bloch parameters depending on the existance of the MC handler + // yes: MC parameters + // no: data parameters + //ESD case + if (isESD){ + if (!AliDielectronVarManager::GetESDpid()){ + if (AliDielectronMC::Instance()->HasMC()) { + AliDielectronVarManager::InitESDpid(); + } else { + AliDielectronVarManager::InitESDpid(1); + /* + Double_t fAlephParam[5]={2.11543/50, + 20.3394, + 5.0411e-11, + 2.15543, + 2.88663}; + */ + Double_t fAlephParam[5]={2.11543/122, + 42.3394, + 2.0411e-22, + 2.25543, + 6.89 + }; + + + + + + AliESDpid *fESDpid = new AliESDpid(); + fESDpid->GetTPCResponse().SetBetheBlochParameters(fAlephParam[0], + fAlephParam[1], + fAlephParam[2], + fAlephParam[3], + fAlephParam[4]); + AliDielectronVarManager::SetESDpid(fESDpid); + } + } + } + //AOD case + if (isAOD){ + if (!AliDielectronVarManager::GetAODpidUtil()){ + if (AliDielectronMC::Instance()->HasMC()) { + AliDielectronVarManager::InitAODpidUtil(); + } else { + AliDielectronVarManager::InitAODpidUtil(1); + } + } + } + } + + + + /* + AliESDInputHandler *esdHandler=0x0; + if ( (esdHandler=dynamic_cast(man->GetInputEventHandler())) && esdHandler->GetESDpid() ){ + AliDielectronVarManager::SetESDpid(esdHandler->GetESDpid()); + } else { + //load esd pid bethe bloch parameters depending on the existance of the MC handler + // yes: MC parameters + // no: data parameters + if (!AliDielectronVarManager::GetESDpid()){ + if (AliDielectronMC::Instance()->HasMC()) { + AliDielectronVarManager::InitESDpid(); + } else { + AliDielectronVarManager::InitESDpid(1); + } + } + } + */ + + ////////////////////////////////////////// + ///////////////////////////////////////// + // just copy from hor + AliESDEvent *fESD = dynamic_cast(InputEvent()); + + AliESDRun *fRun = (AliESDRun*)fESD->GetESDRun(); + fMag = fRun->GetMagneticField(); + if(fRun){ + for(int itr=0; itrSetString(fRun->GetTriggerClass(itr)); + //cout<AddAt(fkTrigName, itr); + fkTrigName->Clear(); + } + } + + + + //just dump the fired trigger class + if(fESD){ + AliESDHeader* head = (AliESDHeader*)fESD->GetHeader(); + //cout<<" trigger "<GetFiredTriggerInputs()<<" : "<GetTriggerMask()<<" : "<GetFiredTriggerClasses()<<" "<GetTriggerMask(); + + for(int itr=0; itrGetTriggerMask() >> itr) & 0x1 == 1 ){ + fEvent->Fill(10+itr); + } + } + } + + if(fESD) { + fEvent->Fill(0); + Bool_t isEvT = kFALSE; + /* + isEvT = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() + & AliVEvent::kMB); + */ + isEvT = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() + //& AliVEvent::kSemiCentral); + & AliVEvent::kCentral); + + //AliTriggerAnalysis *fTrigAna = new AliTriggerAnalysis(); + if (isEvT){ + fEvent->Fill(1); + if(fCutsEvent->IsSelected(fESD)){ + fEvent->Fill(2); + const AliESDVertex *vertex = fESD->GetPrimaryVertex(); + if((vertex->GetNContributors()>2)&&(TMath::Abs(vertex->GetZ())<7)) { + fEvent->Fill(3); + } + } + } + + ////////////////////////////////////////// + //// fill the number of fired triggers for each trigger types + /* + isEvT = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected()); + //AliTriggerAnalysis *fTrigAna = new AliTriggerAnalysis(); + if (isEvT){ + if(isEvT & AliVEvent::kMB) fEvent->Fill(10); + if(isEvT & AliVEvent::kINT7) fEvent->Fill(11); + if(isEvT & AliVEvent::kMUON) fEvent->Fill(12); + if(isEvT & AliVEvent::kHighMult) fEvent->Fill(13); + if(isEvT & AliVEvent::kEMC1) fEvent->Fill(14); + if(isEvT & AliVEvent::kCINT5) fEvent->Fill(15); + if(isEvT & AliVEvent::kMUSPB) fEvent->Fill(16); + if(isEvT & AliVEvent::kMUSHPB) fEvent->Fill(17); + if(isEvT & AliVEvent::kMuonLikePB) fEvent->Fill(18); + if(isEvT & AliVEvent::kMuonUnlikePB) fEvent->Fill(19); + if(isEvT & AliVEvent::kEMC7) fEvent->Fill(20); + if(isEvT & AliVEvent::kMUS7) fEvent->Fill(21); + if(isEvT & AliVEvent::kPHI1) fEvent->Fill(22); + if(isEvT & AliVEvent::kPHOSPb) fEvent->Fill(23); + if(isEvT & AliVEvent::kEMCEJE) fEvent->Fill(24); + if(isEvT & AliVEvent::kEMCEGA) fEvent->Fill(25); + if(isEvT & AliVEvent::kCentral) fEvent->Fill(26); + if(isEvT & AliVEvent::kSemiCentral) fEvent->Fill(27); + if(isEvT & AliVEvent::kDG5) fEvent->Fill(28); + if(isEvT & AliVEvent::kZED) fEvent->Fill(29); + if(isEvT & AliVEvent::kAny) fEvent->Fill(30); + } + */ + } + ////////////////////////////////////////// + ////////////////////////////////////////// + + + // Was event selected ? + UInt_t isSelected = AliVEvent::kAny; + if( fSelectPhysics && inputHandler && inputHandler->GetEventSelection() ) { + isSelected = inputHandler->IsEventSelected(); + isSelected&=fTriggerMask; + } + + //Before physics selection + fEventStat->Fill(kAllEvents); + if (isSelected==0) { + PostData(3,fEventStat); + return; + } + //after physics selection + fEventStat->Fill(kSelectedEvents); + + //V0and + if (fTriggerOnV0AND&&isESD){ + //if (!fTriggerAnalysis->IsOfflineTriggerFired(static_cast(InputEvent()), AliTriggerAnalysis::kV0AND)) return; + } + fEventStat->Fill(kV0andEvents); + + //event filter + if (fEventFilter) { + //if (!fEventFilter->IsSelected(InputEvent())) return; + } + fEventStat->Fill(kFilteredEvents); + + //pileup + if (fRejectPileup){ + if (InputEvent()->IsPileupFromSPD(3,0.8,3.,2.,5.)) return; + } + fEventStat->Fill(kPileupEvents); + + + Bool_t isEvT1 = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() + & AliVEvent::kCentral); + + Bool_t isEvT2 = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() + & AliVEvent::kSemiCentral); + + + Bool_t isEvT3 = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() + & AliVEvent::kMB); + + fkTriggerCent = 0; + if(!isEvT1 && !isEvT2 && !isEvT3){ + return ; + }else{ + if(isEvT1){ + fkTriggerCent += 100; + } + if(isEvT2){ + fkTriggerCent += 10; + } + if(isEvT3){ + fkTriggerCent += 1; + } + } + + //bz for AliKF + Double_t bz = InputEvent()->GetMagneticField(); + AliKFParticle::SetField( bz ); + + AliDielectronPID::SetCorrVal((Double_t)InputEvent()->GetRunNumber()); + + FillEvent(InputEvent()); + fkNPar = 0; + + //Process event in all AliDielectron instances + TIter nextDie(&fListDielectron); + AliDielectronTaku *die=0; + Int_t idie=0; + while ( (die=static_cast(nextDie())) ){ + die->Process(InputEvent()); + if (die->HasCandidates()){ + Int_t ncandidates=die->GetPairArray(1)->GetEntriesFast(); + if (ncandidates==1) fEventStat->Fill((kNbinsEvent)+2*idie); + else if (ncandidates>1) fEventStat->Fill((kNbinsEvent+1)+2*idie); + } + AliDielectronVarManager::Fill(InputEvent(), fgValues); + //Fill track information, separately for the track array candidates + for (Int_t ii=0; ii<2; ++ii){ + TObjArray *obj = (TObjArray*)die->GetTrackArray(ii); + Int_t ntracks=obj->GetEntriesFast(); + for (Int_t itrack=0; itrackUncheckedAt(itrack), fgValues); + //////////////////////////////////////////////////////////////////// + AliVTrack *trk = static_cast(obj->UncheckedAt(itrack)); + double par[3] ; + MomentumEnergyMatch(trk, par); + fgValues[AliDielectronVarManager::kE] = par[0]; + fgValues[AliDielectronVarManager::kDeltaEta] = par[1]; + fgValues[AliDielectronVarManager::kDeltaPhi] = par[2]; + /* + if(par[0]<0){ + continue; + } + */ + + AliESDtrack *esdtrack = static_cast(obj->UncheckedAt(itrack)); + Double_t dca[2]={-999.,-999.}; + Double_t cov[3]={-999.,-999.,-999.}; + Double_t kBeampiperadius=3.; + esdtrack->PropagateToDCA(InputEvent()->GetPrimaryVertex(), + InputEvent()->GetMagneticField(), kBeampiperadius, dca, cov); + fgValues[AliDielectronVarManager::kLegDist] = dca[1]; + fgValues[AliDielectronVarManager::kLegDistXY] = dca[0]; + fgValues[AliDielectronVarManager::kNclsTPC] = esdtrack->GetTPCCrossedRows(); + + /* + ///// KF analysis + AliKFParticle kfTrack = AliKFParticle(*trk, 11); //assuming electron //charge is from trk + /// i would like to store + /// X, Y, Z, Px, Py, Pz, S(decay length/mom), Chi2, NDF + if(kfTrack.GetNDF()!=0) fgValues[AliDielectronVarManager::kChi2NDF] = kfTrack.GetChi2()/kfTrack.GetNDF(); + fgValues[AliDielectronVarManager::kDecayLength] = kfTrack.GetS(); + fgValues[AliDielectronVarManager::kR] = kfTrack.GetR(); + fgValues[AliDielectronVarManager::kThetaHE] = kfTrack.GetX(); + fgValues[AliDielectronVarManager::kPhiHE] = kfTrack.GetY(); + fgValues[AliDielectronVarManager::kThetaCS] = kfTrack.GetZ(); + fgValues[AliDielectronVarManager::kPhiCS] = kfTrack.GetPhi(); + fgValues[AliDielectronVarManager::kITSsignalSSD1] = kfTrack.GetPx(); + fgValues[AliDielectronVarManager::kITSsignalSSD2] = kfTrack.GetPy(); + fgValues[AliDielectronVarManager::kITSsignalSDD1] = kfTrack.GetPz(); + fgValues[AliDielectronVarManager::kITSsignalSDD2] = kfTrack.GetP(); + */ + //////////////////////////////////////////////////////////////////// + for(int ich=0;ichFill(); + } + + ////////////////////////////////////////////////////////////////////////// + ///////////////////////////////////////////////////////////////////////// + ////////////////////////////////////////////////////////////////////////// + + //// fillback to single particle without trackcuts + for (Int_t iTracks = 0; iTracks < fESD->GetNumberOfTracks(); iTracks++) { + AliESDtrack* track = fESD->GetTrack(iTracks); + if (!track) { + Printf("ERROR: Could not receive track %d", iTracks); + continue; + } + if(!fCutsMother->AcceptTrack(track)) continue; + fdEdXvsPt->Fill(track->GetTPCmomentum(), track->GetTPCsignal()); + fdEdXnSigmaElecvsPt->Fill(track->GetTPCmomentum(), + AliDielectronVarManager::GetESDpid()->NumberOfSigmasTPC(track, + AliPID::kElectron) + -AliDielectronPID::GetCorrVal()); + + fTPCcrossedRowsvsPt->Fill(track->GetTPCmomentum(), track->GetTPCCrossedRows()); + fTPCchi2vsPt->Fill(track->GetTPCmomentum(), track->GetTPCchi2()); + + /// for beta caliculaton + Double_t l = track->GetIntegratedLength(); // cm + Double_t t = track->GetTOFsignal(); + Double_t t0 = AliDielectronVarManager::GetESDpid()->GetTOFResponse().GetTimeZero(); // ps + Double_t beta = 0; + if( (l < 360. || l > 800.) || (t <= 0.) || (t0 >999990.0) ) { + beta; + } + else { + t -= t0; // subtract the T0 + l *= 0.01; // cm ->m + t *= 1e-12; //ps -> s + + Double_t v = l / t; + beta = v / TMath::C(); + } + + fTOFbetavsPt->Fill(track->GetTPCmomentum(), beta); + //// electron cuts ////// + if(fabs(AliDielectronVarManager::GetESDpid()->NumberOfSigmasTPC(track,AliPID::kElectron) + -AliDielectronPID::GetCorrVal())<3){ + fTOFnSigmaElecvsPt->Fill(track->GetTPCmomentum(), + AliDielectronVarManager::GetESDpid()->NumberOfSigmasTOF(track, + AliPID::kElectron)); + } + } + + + + //cout<(nextDie())) ){ + die->SaveDebugTree(); + } +} + +//_________________________________________________________________________________ +void AliAnalysisTaskMultiDielectronNewTaku::MomentumEnergyMatch(const AliVParticle *track, double *par){ + + Float_t clsPos[3]; + Double_t trkPos[3]; + Double_t matchclsE = -9999.9; + + const AliESDtrack *esdtrack = dynamic_cast(track); + AliESDEvent *evt = (AliESDEvent*)esdtrack->GetESDEvent(); + Double_t magF = evt->GetMagneticField(); + Double_t magSign = 1.0; + if(magF<0)magSign = -1.0; + if (!TGeoGlobalMagField::Instance()->GetField()) { + printf("Loading field map...\n"); + //AliMagF* field = new AliMagF("Maps","Maps", 1., 1., AliMagF::k5kG); + AliMagF* field = new AliMagF("Maps","Maps", magSign, magSign, AliMagF::k5kG); // for 10d + TGeoGlobalMagField::Instance()->SetField(field); + } + + AliEMCALTrack *emctrack = new AliEMCALTrack(*esdtrack); + Double_t fieldB[3]; + emctrack->GetBxByBz(fieldB); + //printf("%g %g %g \n", fieldB[0], fieldB[1], fieldB[2]); + double min_r=99999.0; + double min_dphi=-9999.0; + double min_deta=-9999.0; + + for(Int_t icl=0; iclGetNumberOfCaloClusters(); icl++){ + AliVCluster *cluster = (AliVCluster*) evt->GetCaloCluster(icl); + if(!cluster->IsEMCAL()) continue; + cluster->GetPosition(clsPos); + if(!emctrack->PropagateToGlobal(clsPos[0],clsPos[1],clsPos[2],0.,0.) ) continue; + emctrack->GetXYZ(trkPos); + TVector3 clsPosVec(clsPos[0],clsPos[1],clsPos[2]); + TVector3 trkPosVec(trkPos[0],trkPos[1],trkPos[2]); + Double_t delEmcphi = clsPosVec.Phi()-trkPosVec.Phi(); // track cluster matching + Double_t delEmceta = clsPosVec.Eta()-trkPosVec.Eta(); // track cluster matching + double rmatch = sqrt(pow(delEmcphi,2)+pow(delEmceta,2)); + /* + if(rmatchE(); + } + */ + if(rmatch<0.02 && rmatchE(); + } + } + delete emctrack; + + par[0] = matchclsE; + par[1] = min_dphi; + par[2] = min_deta; + +} + + +//_________________________________________________________________________________ +void AliAnalysisTaskMultiDielectronNewTaku::FillEvent(AliVEvent * const ev){ + + //AliKFVertex *fgKFVertex = new fgKFVertex(); + //if (ev && ev->GetPrimaryVertex()) fgKFVertex=new AliKFVertex(*ev->GetPrimaryVertex()); + + if(ev){ + fkRunNumber = ev->GetRunNumber(); + fkXvPrim = ev->GetPrimaryVertex()->GetX(); + fkYvPrim = ev->GetPrimaryVertex()->GetY(); + fkZvPrim = ev->GetPrimaryVertex()->GetZ(); + fkNTrk = ev->GetNumberOfTracks(); + fkNacc = AliDielectronHelper::GetNacc(ev); + fkNaccTrcklts = AliDielectronHelper::GetNaccTrcklts(ev); + + fkZDCN1E = ev->GetZDCN1Energy(); + fkZDCP1E = ev->GetZDCP1Energy(); + fkZDCN2E = ev->GetZDCN2Energy(); + fkZDCP2E = ev->GetZDCP2Energy(); + } + AliESDEvent *fESD = dynamic_cast(ev); + + fkCentrality=-1; + AliCentrality *esdCentrality = const_cast(fESD)->GetCentrality(); + if (esdCentrality) fkCentrality = esdCentrality->GetCentralityPercentile("V0M"); + + if(fESD->GetPrimaryVertex()){ + fkXRes = fESD->GetPrimaryVertex()->GetXRes(); + fkYRes = fESD->GetPrimaryVertex()->GetYRes(); + fkZRes = fESD->GetPrimaryVertex()->GetZRes(); + } + + if(fESD->GetVZEROData()){ + fkV0A=0; + fkV0C=0; + for(int ich=0;ich<32;ich++){ + fkV0A += fESD->GetVZEROData()->GetMultiplicityV0A(ich); + fkV0C += fESD->GetVZEROData()->GetMultiplicityV0C(ich); + } + } + + /////////////////////////////////////////////////////////////////////// + /////////////////////////////////////////////////////////////////////// + /////////////// get event plane /////////////////////////////////////// + /////////////////////////////////////////////////////////////////////// + AliEventplane *fEventPlane = (AliEventplane*)fESD->GetEventplane(); + if (fEventPlane) + fkRP = fEventPlane->GetEventplane("V0", fESD,2); + + /* + fkRP=-999; fkRPQx=-999; fkRPQy=-999; + fkRPsub1=-999; fkRPsub1Qx=-999; fkRPsub1Qy=-999; + fkRPsub2=-999; fkRPsub2Qx=-999; fkRPsub2Qy=-999; + + if(fEventPlane){ + + fkRP = fEventPlane->GetEventplane("Q"); + if(fEventPlane->GetQVector()){ + fkRPQx = fEventPlane->GetQVector()->X(); + fkRPQy = fEventPlane->GetQVector()->Y(); + } + if(fEventPlane->GetQsub1()){ + fkRPsub1 = fEventPlane->GetQsub1()->Phi()/2; + fkRPsub1Qx = fEventPlane->GetQsub1()->X(); + fkRPsub1Qy = fEventPlane->GetQsub1()->Y(); + } + if(fEventPlane->GetQsub2()){ + fkRPsub2 = fEventPlane->GetQsub2()->Phi()/2; + fkRPsub2Qx = fEventPlane->GetQsub2()->X(); + fkRPsub2Qy = fEventPlane->GetQsub2()->Y(); + } + + fkQsubRes = fEventPlane->GetQsubRes(); + cout<GetEventplane("Q")<GetQVector(); + if(!vec2){ cout<<" no EP information "<Phi()/2; + cout<(GetInputData(0)); + + if (fFlowEvent) { + //get the Q vector from the FlowEvent + AliFlowVector vQ = fFlowEvent->GetQ(); + //if (vQ.X()== 0. && vQ.Y()== 0. ) { cout<<"Q vector is NULL!"<CalculateRPandW(vQ); + Double_t dWR = fLyzEp->GetWR(); + + Double_t dRP = fLyzEp->GetPsi(); + //plot difference between event plane from EP-method and LYZ-method + Double_t dRPEP = vQ.Phi()/2; //gives distribution from (0 to pi) + //Double_t dRPEP = 0.5*TMath::ATan2(vQ.Y(),vQ.X()); //gives distribution from (-pi/2 to pi/2) + + Double_t dDeltaPhi = dRPEP - dRP; + if (dDeltaPhi < 0.) { dDeltaPhi += TMath::Pi(); } //to shift distribution from (-pi/2 to pi/2) to (0 to pi) + + cout<Branch("kNEvent",&fNEvent,"kNEvent/I"); + t->Branch("kMag",&fMag,"kMag/D"); + t->Branch("fkTriggerInfo","TObjArray",&fkTriggerInfo); + t->Branch("kTriggerMask",&fkTriggerMask,"kTriggerMask/D"); + t->Branch("kTriggerCent",&fkTriggerCent,"kTriggerCent/I"); + t->Branch("fkNCut", &fkNCut, "fkNCut/D"); + t->Branch("fkRunNumber", &fkRunNumber, "fkRunNumber/D"); + t->Branch("fkCentrality", &fkCentrality, "fkCentrality/D"); + t->Branch("fkXvPrim", &fkXvPrim, "fkXvPrim/D"); + t->Branch("fkYvPrim", &fkYvPrim, "fkYvPrim/D"); + t->Branch("fkZvPrim", &fkZvPrim, "fkZvPrim/D"); + t->Branch("fkXRes", &fkXRes, "fkXRes/D"); + t->Branch("fkYRes", &fkYRes, "fkYRes/D"); + t->Branch("fkZRes", &fkZRes, "fkZRes/D"); + t->Branch("fkNTrk", &fkNTrk, "fkNTrk/D"); + t->Branch("fkTracks", &fkTracks, "fkTracks/D"); + t->Branch("fkNacc", &fkNacc, "fkNacc/D"); + t->Branch("fkNaccTrcklts", &fkNaccTrcklts, "fkNaccTrcklts/D"); + t->Branch("fkNch", &fkNch, "fkNch/D"); + t->Branch("fkZDCN1E", &fkZDCN1E, "fkZDCN1E/D"); + t->Branch("fkZDCP1E", &fkZDCP1E, "fkZDCP1E/D"); + t->Branch("fkZDCN2E", &fkZDCN2E, "fkZDCN2E/D"); + t->Branch("fkZDCP2E", &fkZDCP2E, "fkZDCP2E/D"); + t->Branch("fkV0A", &fkV0A, "fkV0A/D"); + t->Branch("fkV0C", &fkV0C, "fkV0C/D"); + + t->Branch("fkRP",&fkRP,"fkRP/D"); + t->Branch("fkRPQx",&fkRPQx,"fkRPQx/D"); + t->Branch("fkRPQy",&fkRPQy,"fkRPQy/D"); + t->Branch("fkRPsub1",&fkRPsub1,"fkRPsub1/D"); + t->Branch("fkRPsub1Qx",&fkRPsub1Qx,"fkRPsub1Qx/D"); + t->Branch("fkRPsub1Qy",&fkRPsub1Qy,"fkRPsub1Qy/D"); + t->Branch("fkRPsub2",&fkRPsub2,"fkRPsub2/D"); + t->Branch("fkRPsub2Qx",&fkRPsub2Qx,"fkRPsub2Qx/D"); + t->Branch("fkRPsub2Qy",&fkRPsub2Qy,"fkRPsub2Qy/D"); + t->Branch("fkQsubRes",&fkQsubRes,"fkQsubRes/D"); + + + t->Branch("fkNPar", &fkNPar, "fkNPar/I"); + t->Branch("kPx",fgData[AliDielectronVarManager::kPx],"kPx[fkNPar]/D"); + t->Branch("kPy",fgData[AliDielectronVarManager::kPy],"kPy[fkNPar]/D"); + t->Branch("kPz",fgData[AliDielectronVarManager::kPz],"kPz[fkNPar]/D"); + t->Branch("kPt",fgData[AliDielectronVarManager::kPt],"kPt[fkNPar]/D"); + t->Branch("kP",fgData[AliDielectronVarManager::kP],"kP[fkNPar]/D"); + t->Branch("kXv",fgData[AliDielectronVarManager::kXv],"kXv[fkNPar]/D"); + t->Branch("kYv",fgData[AliDielectronVarManager::kYv],"kYv[fkNPar]/D"); + t->Branch("kZv",fgData[AliDielectronVarManager::kZv],"kZv[fkNPar]/D"); + t->Branch("kOneOverPt",fgData[AliDielectronVarManager::kOneOverPt],"kOneOverPt[fkNPar]/D"); + t->Branch("kPhi",fgData[AliDielectronVarManager::kPhi],"kPhi[fkNPar]/D"); + t->Branch("kTheta",fgData[AliDielectronVarManager::kTheta],"kTheta[fkNPar]/D"); + t->Branch("kEta",fgData[AliDielectronVarManager::kEta],"kEta[fkNPar]/D"); + t->Branch("kY",fgData[AliDielectronVarManager::kY],"kY[fkNPar]/D"); + t->Branch("kE",fgData[AliDielectronVarManager::kE],"kE[fkNPar]/D"); + t->Branch("kM",fgData[AliDielectronVarManager::kM],"kM[fkNPar]/D"); + t->Branch("kCharge",fgData[AliDielectronVarManager::kCharge],"kCharge[fkNPar]/D"); + t->Branch("kNclsITS",fgData[AliDielectronVarManager::kNclsITS],"kNclsITS[fkNPar]/D"); + t->Branch("kNclsTPC",fgData[AliDielectronVarManager::kNclsTPC],"kNclsTPC[fkNPar]/D"); + t->Branch("kNclsTPCiter1",fgData[AliDielectronVarManager::kNclsTPCiter1],"kNclsTPCiter1[fkNPar]/D"); + t->Branch("kNFclsTPC",fgData[AliDielectronVarManager::kNFclsTPC],"kNFclsTPC[fkNPar]/D"); + t->Branch("kNFclsTPCr",fgData[AliDielectronVarManager::kNFclsTPCr],"kNFclsTPCr[fkNPar]/D"); + t->Branch("kNFclsTPCrFrac",fgData[AliDielectronVarManager::kNFclsTPCrFrac],"kNFclsTPCrFrac[fkNPar]/D"); + t->Branch("kTPCsignalN",fgData[AliDielectronVarManager::kTPCsignalN],"kTPCsignalN[fkNPar]/D"); + t->Branch("kTPCsignalNfrac",fgData[AliDielectronVarManager::kTPCsignalNfrac],"kTPCsignalNfrac[fkNPar]/D"); + t->Branch("kTPCchi2Cl",fgData[AliDielectronVarManager::kTPCchi2Cl],"kTPCchi2Cl[fkNPar]/D"); + t->Branch("kTrackStatus",fgData[AliDielectronVarManager::kTrackStatus],"kTrackStatus[fkNPar]/D"); + t->Branch("kNclsTRD",fgData[AliDielectronVarManager::kNclsTRD],"kNclsTRD[fkNPar]/D"); + t->Branch("kTRDntracklets",fgData[AliDielectronVarManager::kTRDntracklets],"kTRDntracklets[fkNPar]/D"); + t->Branch("kTRDpidQuality",fgData[AliDielectronVarManager::kTRDpidQuality],"kTRDpidQuality[fkNPar]/D"); + t->Branch("kTRDprobEle",fgData[AliDielectronVarManager::kTRDprobEle],"kTRDprobEle[fkNPar]/D"); + t->Branch("kTRDprobPio",fgData[AliDielectronVarManager::kTRDprobPio],"kTRDprobPio[fkNPar]/D"); + t->Branch("kImpactParXY",fgData[AliDielectronVarManager::kImpactParXY],"kImpactParXY[fkNPar]/D"); + t->Branch("kImpactParZ",fgData[AliDielectronVarManager::kImpactParZ],"kImpactParZ[fkNPar]/D"); + t->Branch("kTrackLength",fgData[AliDielectronVarManager::kTrackLength],"kTrackLength[fkNPar]/D"); + t->Branch("kPdgCode",fgData[AliDielectronVarManager::kPdgCode],"kPdgCode[fkNPar]/D"); + t->Branch("kPdgCodeMother",fgData[AliDielectronVarManager::kPdgCodeMother],"kPdgCodeMother[fkNPar]/D"); + t->Branch("kPdgCodeGrandMother",fgData[AliDielectronVarManager::kPdgCodeGrandMother],"kPdgCodeGrandMother[fkNPar]/D"); + t->Branch("kNumberOfDaughters",fgData[AliDielectronVarManager::kNumberOfDaughters],"kNumberOfDaughters[fkNPar]/D"); + t->Branch("kHaveSameMother",fgData[AliDielectronVarManager::kHaveSameMother],"kHaveSameMother[fkNPar]/D"); + t->Branch("kIsJpsiPrimary",fgData[AliDielectronVarManager::kIsJpsiPrimary],"kIsJpsiPrimary[fkNPar]/D"); + t->Branch("kITSsignal",fgData[AliDielectronVarManager::kITSsignal],"kITSsignal[fkNPar]/D"); + t->Branch("kITSsignalSSD1",fgData[AliDielectronVarManager::kITSsignalSSD1],"kITSsignalSSD1[fkNPar]/D"); + t->Branch("kITSsignalSSD2",fgData[AliDielectronVarManager::kITSsignalSSD2],"kITSsignalSSD2[fkNPar]/D"); + t->Branch("kITSsignalSDD1",fgData[AliDielectronVarManager::kITSsignalSDD1],"kITSsignalSDD1[fkNPar]/D"); + t->Branch("kITSsignalSDD2",fgData[AliDielectronVarManager::kITSsignalSDD2],"kITSsignalSDD2[fkNPar]/D"); + t->Branch("kITSclusterMap",fgData[AliDielectronVarManager::kITSclusterMap],"kITSclusterMap[fkNPar]/D"); + t->Branch("kITSnSigmaEle",fgData[AliDielectronVarManager::kITSnSigmaEle],"kITSnSigmaEle[fkNPar]/D"); + t->Branch("kITSnSigmaPio",fgData[AliDielectronVarManager::kITSnSigmaPio],"kITSnSigmaPio[fkNPar]/D"); + t->Branch("kITSnSigmaMuo",fgData[AliDielectronVarManager::kITSnSigmaMuo],"kITSnSigmaMuo[fkNPar]/D"); + t->Branch("kITSnSigmaKao",fgData[AliDielectronVarManager::kITSnSigmaKao],"kITSnSigmaKao[fkNPar]/D"); + t->Branch("kITSnSigmaPro",fgData[AliDielectronVarManager::kITSnSigmaPro],"kITSnSigmaPro[fkNPar]/D"); + t->Branch("kPIn",fgData[AliDielectronVarManager::kPIn],"kPIn[fkNPar]/D"); + t->Branch("kTPCsignal",fgData[AliDielectronVarManager::kTPCsignal],"kTPCsignal[fkNPar]/D"); + t->Branch("kTOFsignal",fgData[AliDielectronVarManager::kTOFsignal],"kTOFsignal[fkNPar]/D"); + t->Branch("kTOFbeta",fgData[AliDielectronVarManager::kTOFbeta],"kTOFbeta[fkNPar]/D"); + t->Branch("kTPCnSigmaEle",fgData[AliDielectronVarManager::kTPCnSigmaEle],"kTPCnSigmaEle[fkNPar]/D"); + t->Branch("kTPCnSigmaPio",fgData[AliDielectronVarManager::kTPCnSigmaPio],"kTPCnSigmaPio[fkNPar]/D"); + t->Branch("kTPCnSigmaMuo",fgData[AliDielectronVarManager::kTPCnSigmaMuo],"kTPCnSigmaMuo[fkNPar]/D"); + t->Branch("kTPCnSigmaKao",fgData[AliDielectronVarManager::kTPCnSigmaKao],"kTPCnSigmaKao[fkNPar]/D"); + t->Branch("kTPCnSigmaPro",fgData[AliDielectronVarManager::kTPCnSigmaPro],"kTPCnSigmaPro[fkNPar]/D"); + t->Branch("kTOFnSigmaEle",fgData[AliDielectronVarManager::kTOFnSigmaEle],"kTOFnSigmaEle[fkNPar]/D"); + t->Branch("kTOFnSigmaPio",fgData[AliDielectronVarManager::kTOFnSigmaPio],"kTOFnSigmaPio[fkNPar]/D"); + t->Branch("kTOFnSigmaMuo",fgData[AliDielectronVarManager::kTOFnSigmaMuo],"kTOFnSigmaMuo[fkNPar]/D"); + t->Branch("kTOFnSigmaKao",fgData[AliDielectronVarManager::kTOFnSigmaKao],"kTOFnSigmaKao[fkNPar]/D"); + t->Branch("kTOFnSigmaPro",fgData[AliDielectronVarManager::kTOFnSigmaPro],"kTOFnSigmaPro[fkNPar]/D"); + t->Branch("kKinkIndex0",fgData[AliDielectronVarManager::kKinkIndex0],"kKinkIndex0[fkNPar]/D"); + t->Branch("kChi2NDF",fgData[AliDielectronVarManager::kChi2NDF],"kChi2NDF[fkNPar]/D"); + t->Branch("kDecayLength",fgData[AliDielectronVarManager::kDecayLength],"kDecayLength[fkNPar]/D"); + t->Branch("kR",fgData[AliDielectronVarManager::kR],"kR[fkNPar]/D"); + t->Branch("kOpeningAngle",fgData[AliDielectronVarManager::kOpeningAngle],"kOpeningAngle[fkNPar]/D"); + t->Branch("kThetaHE",fgData[AliDielectronVarManager::kThetaHE],"kThetaHE[fkNPar]/D"); + t->Branch("kPhiHE",fgData[AliDielectronVarManager::kPhiHE],"kPhiHE[fkNPar]/D"); + t->Branch("kThetaCS",fgData[AliDielectronVarManager::kThetaCS],"kThetaCS[fkNPar]/D"); + t->Branch("kPhiCS",fgData[AliDielectronVarManager::kPhiCS],"kPhiCS[fkNPar]/D"); + t->Branch("kLegDist",fgData[AliDielectronVarManager::kLegDist],"kLegDist[fkNPar]/D"); + t->Branch("kLegDistXY",fgData[AliDielectronVarManager::kLegDistXY],"kLegDistXY[fkNPar]/D"); + t->Branch("kDeltaEta",fgData[AliDielectronVarManager::kDeltaEta],"kDeltaEta[fkNPar]/D"); + t->Branch("kDeltaPhi",fgData[AliDielectronVarManager::kDeltaPhi],"kDeltaPhi[fkNPar]/D"); + t->Branch("kMerr",fgData[AliDielectronVarManager::kMerr],"kMerr[fkNPar]/D"); + t->Branch("kDCA",fgData[AliDielectronVarManager::kDCA],"kDCA[fkNPar]/D"); + t->Branch("kPairType",fgData[AliDielectronVarManager::kPairType],"kPairType[fkNPar]/D"); + t->Branch("kPseudoProperTime",fgData[AliDielectronVarManager::kPseudoProperTime],"kPseudoProperTime[fkNPar]/D"); + t->Branch("kXvPrim",fgData[AliDielectronVarManager::kXvPrim],"kXvPrim=kPairMax[fkNPar]/D"); + t->Branch("kYvPrim",fgData[AliDielectronVarManager::kYvPrim],"kYvPrim[fkNPar]/D"); + t->Branch("kZvPrim",fgData[AliDielectronVarManager::kZvPrim],"kZvPrim[fkNPar]/D"); + t->Branch("kXRes",fgData[AliDielectronVarManager::kXRes],"kXRes[fkNPar]/D"); + t->Branch("kYRes",fgData[AliDielectronVarManager::kYRes],"kYRes[fkNPar]/D"); + t->Branch("kZRes",fgData[AliDielectronVarManager::kZRes],"kZRes[fkNPar]/D"); + t->Branch("kNTrk",fgData[AliDielectronVarManager::kNTrk],"kNTrk[fkNPar]/D"); + t->Branch("kTracks",fgData[AliDielectronVarManager::kTracks],"kTracks[fkNPar]/D"); + t->Branch("kNacc",fgData[AliDielectronVarManager::kNacc],"kNacc[fkNPar]/D"); + t->Branch("kNaccTrcklts",fgData[AliDielectronVarManager::kNaccTrcklts],"kNaccTrcklts[fkNPar]/D"); + t->Branch("kNch",fgData[AliDielectronVarManager::kNch],"kNch[fkNPar]/D"); + t->Branch("kCentrality",fgData[AliDielectronVarManager::kCentrality],"kCentrality[fkNPar]/D"); + t->Branch("kNevents",fgData[AliDielectronVarManager::kNevents],"kNevents[fkNPar]/D"); + + +} + diff --git a/PWGDQ/dielectron/TakuAlberica/single/AliAnalysisTaskMultiDielectronNewTaku.h b/PWGDQ/dielectron/TakuAlberica/single/AliAnalysisTaskMultiDielectronNewTaku.h new file mode 100644 index 00000000000..add51cfbf17 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/AliAnalysisTaskMultiDielectronNewTaku.h @@ -0,0 +1,149 @@ +#ifndef ALIANALYSISTASKMULTIDIELECTRON_H +#define ALIANALYSISTASKMULTIDIELECTRON_H +/* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +//##################################################### +//# # +//# Basic Analysis task for Dielectron # +//# single event analysis # +//# # +//# by WooJin J. Park, GSI / W.J.Park@gsi.de # +//# Ionut C. Arsene, GSI / I.C.Arsene@gsi.de # +//# Magnus Mager, CERN / Magnus.Mager@cern.ch # +//# Jens Wiechula, Uni HD / Jens.Wiechula@cern.ch # +//# # +//##################################################### + +#include "TList.h" + +#include "AliAnalysisTaskSE.h" + +// #include "AliDielectronPID.h" + +//class AliDielectron; +class AliDielectronTaku; +class TH1D; +class TH2D; +class AliAnalysisCuts; +class AliTriggerAnalysis; +class AliDielectronEventCuts; +class AliDielectronVarManager; +class AliESDtrackCuts; + +//class AliFlowEventSimple; +//class AliFlowLYZEventPlane; + + +class AliAnalysisTaskMultiDielectronNewTaku : public AliAnalysisTaskSE { + +public: + AliAnalysisTaskMultiDielectronNewTaku(); + AliAnalysisTaskMultiDielectronNewTaku(const char *name, AliDielectronEventCuts *fCutsEvent); + virtual ~AliAnalysisTaskMultiDielectronNewTaku(){ } + + virtual void UserExec(Option_t *option); + virtual void UserCreateOutputObjects(); + virtual void FinishTaskOutput(); + //temporary +// virtual void NotifyRun(){AliDielectronPID::SetCorrVal((Double_t)fCurrentRunNumber);} + + void UsePhysicsSelection(Bool_t phy=kTRUE) {fSelectPhysics=phy;} + void SetTriggerMask(UInt_t mask) {fTriggerMask=mask;} + UInt_t GetTriggerMask() const { return fTriggerMask; } + + void SetEventFilter(AliAnalysisCuts * const filter) {fEventFilter=filter;} + void SetTriggerOnV0AND(Bool_t v0and=kTRUE) { fTriggerOnV0AND=v0and; } + void SetRejectPileup(Bool_t pileup=kTRUE) { fRejectPileup=pileup; } + void AddDielectron(AliDielectronTaku * const die) { fListDielectron.Add(die); } + void SetBranches(TTree *t); + void FillEvent(AliVEvent * const ev); + void MomentumEnergyMatch(const AliVParticle *track, double *par); + +protected: + enum {kAllEvents=0, kSelectedEvents, kV0andEvents, kFilteredEvents, kPileupEvents, kNbinsEvent}; + TList fListDielectron; // List of dielectron framework instances + TList fListHistos; //! List of histogram manager lists in the framework classes + TList fListTree; //! List of trees manager lists in the framework classes + TList fListCF; //! List with CF Managers + TTree *fTree; + + Bool_t fSelectPhysics; // Whether to use physics selection + UInt_t fTriggerMask; // Event trigger mask + Bool_t fTriggerOnV0AND; // if to trigger on V0and + Bool_t fRejectPileup; // pileup rejection wanted + + AliTriggerAnalysis *fTriggerAnalysis; //! trigger analysis class + + AliAnalysisCuts *fEventFilter; // event filter + AliDielectronEventCuts *fCutsEvent; + + AliESDtrackCuts *fCutsMother; + + TH1D *fEventStat; //! Histogram with event statistics + TH1D *fEvent; + TH2D *fdEdXvsPt; + TH2D *fdEdXnSigmaElecvsPt; + TH2D *fTOFbetavsPt; + TH2D *fTOFnSigmaElecvsPt; + TH2D *fTPCcrossedRowsvsPt; + TH2D *fTPCchi2vsPt; + + Double_t fgValues[AliDielectronVarManager::kNMaxValues]; + Double_t fgData[AliDielectronVarManager::kNMaxValues][1000]; + + AliAnalysisTaskMultiDielectronNewTaku(const AliAnalysisTaskMultiDielectronNewTaku &c); + AliAnalysisTaskMultiDielectronNewTaku& operator= (const AliAnalysisTaskMultiDielectronNewTaku &c); + + TString fName; + + Double_t fkTriggerMask; + Int_t fkTriggerCent; + Int_t fNEvent; + Double_t fkNCut; + Double_t fkRunNumber; + Double_t fkCentrality; + Double_t fkXvPrim; + Double_t fkYvPrim; + Double_t fkZvPrim; + Double_t fkXRes; + Double_t fkYRes; + Double_t fkZRes; + Double_t fkNTrk; + Double_t fkTracks; + Double_t fkNacc; + Double_t fkNaccTrcklts; + Double_t fkNch; + Double_t fkZDCN1E; + Double_t fkZDCP1E; + Double_t fkZDCN2E; + Double_t fkZDCP2E; + Double_t fkV0A; + Double_t fkV0C; + + Double_t fkRP; + Double_t fkRPQx; + Double_t fkRPQy; + Double_t fkRPsub1; + Double_t fkRPsub1Qx; + Double_t fkRPsub1Qy; + Double_t fkRPsub2; + Double_t fkRPsub2Qx; + Double_t fkRPsub2Qy; + Double_t fkQsubRes; + + TObjArray *fkTriggerInfo; + TObjString *fkTrigName; + + Int_t fkNPar ; + + // AliFlowEventSimple* fFlowEvent; // input event + // AliFlowLYZEventPlane* fLyzEp; //LYZ EP object + + TVector2 *fQsum; // flow vector sum + Double_t fQ2sum; // flow vector sum squared + Double_t fMag; + + ClassDef(AliAnalysisTaskMultiDielectronNewTaku, 1); //Analysis Task handling multiple instances of AliDielectron +}; +#endif diff --git a/PWGDQ/dielectron/TakuAlberica/single/AliAnalysisTaskMultiDielectronNewTaku_cxx.d b/PWGDQ/dielectron/TakuAlberica/single/AliAnalysisTaskMultiDielectronNewTaku_cxx.d new file mode 100644 index 00000000000..eab67964cb1 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/AliAnalysisTaskMultiDielectronNewTaku_cxx.d @@ -0,0 +1,212 @@ + +# DO NOT DELETE + +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TChain.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TTree.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TBranch.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TNamed.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TObject.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Rtypes.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/RConfig.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/RVersion.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/DllImport.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Rtypeinfo.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/snprintf.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/strlcpy.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGenericClassInfo.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TSchemaHelper.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TStorage.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVersionCheck.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Riosfwd.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TBuffer.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TString.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMathBase.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TObjArray.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TSeqCollection.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TCollection.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TIterator.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttFill.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TDataType.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TDictionary.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Property.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttLine.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttMarker.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayD.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArray.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayI.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TClass.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TObjString.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVirtualTreePlayer.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TH1D.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TH1.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAxis.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttAxis.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayC.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayS.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayF.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Foption.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVectorFfwd.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVectorDfwd.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TFitResultPtr.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TH2D.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TH2.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixFBasefwd.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDBasefwd.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVector2.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliCFContainer.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliCFFrame.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliCFGridSparse.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/THnSparse.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TExMap.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayL.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliLog.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliInputEventHandler.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVEventHandler.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDInputHandler.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDEvent.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TClonesArray.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVEvent.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGeoMatrix.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVHeader.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVParticle.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVVertex.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVCluster.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TLorentzVector.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMath.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TError.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVector3.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrix.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixF.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixT.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixTBase.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixTUtils.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixFfwd.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixFUtils.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixFUtilsfwd.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TRotation.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVCaloCells.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TRefArray.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TProcessID.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDCaloTrigger.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDRun.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDHeader.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTriggerScalersESD.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTriggerScalersRecordESD.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTimeStamp.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDTZERO.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDZDC.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVZDC.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDACORDE.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDtrack.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TBits.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliExternalTrackParam.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVTrack.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliPID.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDfriendTrack.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTPCdEdxInfo.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDVertex.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVertex.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDCaloCluster.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDCaloCells.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTOFHeader.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDVZERO.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVVZERO.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODInputHandler.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODEvent.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TList.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODHeader.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODVertex.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TRef.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODRedCov.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliCentrality.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliEventplane.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODTrack.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODPid.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODv0.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODRecoDecay.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODcascade.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODTracklets.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODJet.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODCaloCells.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODCaloCluster.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODCluster.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODCaloTrigger.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODPmdCluster.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODFmdCluster.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODDimuon.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODTZERO.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODVZERO.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODZDC.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliMCEvent.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliMCParticle.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TParticle.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAtt3D.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TParticlePDG.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTrackReference.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAnalysisManager.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/THashTable.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Riostream.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTriggerAnalysis.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGeoGlobalMagField.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVirtualMagField.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGeoManager.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGeoNavigator.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGeoCache.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGeoNode.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGeoAtt.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGeoVolume.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGeoMedium.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGeoMaterial.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGeoElement.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGeoShape.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGeoPatternFinder.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliGeomManager.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliMagF.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: AliDielectronTaku.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAnalysisFilter.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliKFParticle.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliKFParticleBase.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: AliDielectronHistosTaku.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/THashList.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronVarManager.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliKFVertex.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODMCParticle.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDpid.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliPIDResponse.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliITSPIDResponse.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTPCPIDResponse.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTRDPIDResponse.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTOFPIDResponse.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliEMCALPIDResponse.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVectorD.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVectorT.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixTSym.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixTSparse.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixD.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDfwd.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDUtils.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDUtilsfwd.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDSym.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDSymfwd.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDSparse.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDSparsefwd.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODpidUtil.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronPair.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronMC.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronSignalMC.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronPID.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAnalysisCuts.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVCuts.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronHelper.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronCF.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronEventCuts.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: AliAnalysisTaskMultiDielectronNewTaku.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAnalysisTaskSE.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAnalysisTask.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TTask.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDv0.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TPDGCode.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDtrackCuts.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliEMCALTrack.h +./AliAnalysisTaskMultiDielectronNewTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/cintdictversion.h /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/RVersion.h +AliAnalysisTaskMultiDielectronNewTaku_cxx__ROOTBUILDVERSION= 5.30/03 diff --git a/PWGDQ/dielectron/TakuAlberica/single/AliDielectronDebugTreeTaku.cxx b/PWGDQ/dielectron/TakuAlberica/single/AliDielectronDebugTreeTaku.cxx new file mode 100644 index 00000000000..aca43e9ab2a --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/AliDielectronDebugTreeTaku.cxx @@ -0,0 +1,211 @@ +/************************************************************************* +* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. * +* * +* Author: The ALICE Off-line Project. * +* Contributors are mentioned in the code where appropriate. * +* * +* Permission to use, copy, modify and distribute this software and its * +* documentation strictly for non-commercial purposes is hereby granted * +* without fee, provided that the above copyright notice appears in all * +* copies and that both the copyright notice and this permission notice * +* appear in the supporting documentation. The authors make no claims * +* about the suitability of this software for any purpose. It is * +* provided "as is" without express or implied warranty. * +**************************************************************************/ + +/////////////////////////////////////////////////////////////////////////// +// Dielectron DebugTree // +// // +// // +/* +register variables from the variable manager. The output will be written +to a tree + +NOTE: Please use with extream care! Only for debugging and test purposes!!! + +*/ +// // +/////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "AliDielectronTaku.h" +#include "AliDielectronMC.h" +#include "AliDielectronPair.h" + +#include "AliDielectronDebugTreeTaku.h" + +ClassImp(AliDielectronDebugTreeTaku) + +AliDielectronDebugTreeTaku::AliDielectronDebugTreeTaku() : + TNamed(), + fFileName("jpsi_debug.root"), + fNVars(0), + fNVarsLeg(0), + fStreamer(0x0), + fDielectron(0x0) +{ + // + // Default Constructor + // + for (Int_t i=0; iGetFile()->Write(); + delete fStreamer; + } +} + +//______________________________________________ +void AliDielectronDebugTreeTaku::Fill(AliDielectronPair *pair) +{ + // + // Fill configured variables to the tree + // + + //is there anything to fill + if (fNVars==0&&fNVarsLeg==0) return; + + //only in local mode!!! + AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager(); + if (!man) return; + if (man->GetAnalysisType()!=AliAnalysisManager::kLocalAnalysis) return; + + //Get File and event information + TObjString fileName; + Int_t eventInFile=-1; + Int_t runNumber=-1; + UInt_t eventTime=0; + + TTree *t=man->GetTree(); + if (t) { + TFile *file=t->GetCurrentFile(); + if (file) fileName.SetString(file->GetName()); + } + + AliESDInputHandler *han=dynamic_cast(man->GetInputEventHandler()); + if (han){ + AliESDEvent *ev=dynamic_cast(han->GetEvent()); + eventInFile=ev->GetEventNumberInFile(); + runNumber=ev->GetRunNumber(); + eventTime=ev->GetTimeStamp(); + } + + if (!fStreamer) fStreamer=new TTreeSRedirector(fFileName.Data()); + Int_t id1=static_cast(pair->GetFirstDaughter())->GetID(); + Int_t id2=static_cast(pair->GetSecondDaughter())->GetID(); + //Fill Event information + (*fStreamer) << "Pair" + << "File.=" << &fileName + << "EventInFile=" << eventInFile + << "Run=" << runNumber + << "Leg1_ID=" << id1 + << "Leg2_ID=" << id2 + << "EventTime=" << eventTime; + + //Fill MC information + Bool_t hasMC=AliDielectronMC::Instance()->HasMC(); + if (hasMC){ + Int_t pdg=443; + if (fDielectron) pdg=fDielectron->GetMotherPdg(); + Bool_t isMotherMC = AliDielectronMC::Instance()->IsMotherPdg(pair,pdg); + (*fStreamer) << "Pair" + << "mcTruth=" << isMotherMC; + } + + Int_t var=0; + Double_t values[AliDielectronVarManager::kNMaxValues]; + Double_t valuesLeg1[AliDielectronVarManager::kNMaxValues]; + Double_t valuesLeg2[AliDielectronVarManager::kNMaxValues]; +// fill pair values + if (fNVars>0){ + AliDielectronVarManager::Fill(pair,values); + + for (Int_t i=0; iGetFile()->Write(); +} diff --git a/PWGDQ/dielectron/TakuAlberica/single/AliDielectronDebugTreeTaku.h b/PWGDQ/dielectron/TakuAlberica/single/AliDielectronDebugTreeTaku.h new file mode 100644 index 00000000000..cd2a6a7abcd --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/AliDielectronDebugTreeTaku.h @@ -0,0 +1,69 @@ +#ifndef ALIDIELECTRONDEBUGTREE_H +#define ALIDIELECTRONDEBUGTREE_H + +/* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +//############################################################# +//# # +//# Class AliDielectronDebugTree # +//# # +//# Authors: # +//# Anton Andronic, GSI / A.Andronic@gsi.de # +//# Ionut C. Arsene, GSI / I.C.Arsene@gsi.de # +//# Julian Book, Uni Ffm / Julian.Book@cern.ch # +//# Frederick Kramer, Uni Ffm, / Frederick.Kramer@cern.ch # +//# Magnus Mager, CERN / Magnus.Mager@cern.ch # +//# WooJin J. Park, GSI / W.J.Park@gsi.de # +//# Jens Wiechula, Uni HD / Jens.Wiechula@cern.ch # +//# # +//############################################################# + +#include +#include + +#include "AliDielectronVarManager.h" + +class TTreeSRedirector; +class AliDielectronPair; +class AliDielectronTaku; + +class AliDielectronDebugTreeTaku : public TNamed { +public: + AliDielectronDebugTreeTaku(); + AliDielectronDebugTreeTaku(const char*name, const char* title); + + virtual ~AliDielectronDebugTreeTaku(); + + void SetOutputFileName(const char* file) { fFileName=file; } + + void AddPairVariable(AliDielectronVarManager::ValueTypes type) { fVariables[fNVars++]=(Int_t)type; } + void AddLegVariable(AliDielectronVarManager::ValueTypes type) { fVariablesLeg[fNVarsLeg++]=(Int_t)type; } + + void Fill(AliDielectronPair *pair); + + void SetDielectron(AliDielectronTaku * const dielectron) { fDielectron=dielectron; } + + void DeleteStreamer(); + void WriteTree(); +private: + TString fFileName; //output file name + + Int_t fNVars; //number of configured variables + Int_t fVariables[AliDielectronVarManager::kNMaxValues]; //configured variables + Int_t fNVarsLeg; //number of configured variables + Int_t fVariablesLeg[AliDielectronVarManager::kNMaxValues]; //configured variables for the legs + + TTreeSRedirector *fStreamer; //! Tree Redirector + AliDielectronTaku *fDielectron; //! pointer to mother dielectron manager + + AliDielectronDebugTreeTaku(const AliDielectronDebugTreeTaku &c); + AliDielectronDebugTreeTaku &operator=(const AliDielectronDebugTreeTaku &c); + + + ClassDef(AliDielectronDebugTreeTaku,1) // Dielectron DebugTree +}; + + + +#endif diff --git a/PWGDQ/dielectron/TakuAlberica/single/AliDielectronDebugTreeTaku_cxx.d b/PWGDQ/dielectron/TakuAlberica/single/AliDielectronDebugTreeTaku_cxx.d new file mode 100644 index 00000000000..104080097aa --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/AliDielectronDebugTreeTaku_cxx.d @@ -0,0 +1,179 @@ + +# DO NOT DELETE + +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TFile.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TDirectoryFile.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TDirectory.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TNamed.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TObject.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Rtypes.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/RConfig.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/RVersion.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/DllImport.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Rtypeinfo.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/snprintf.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/strlcpy.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGenericClassInfo.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TSchemaHelper.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TStorage.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVersionCheck.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Riosfwd.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TBuffer.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TString.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMathBase.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TList.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TSeqCollection.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TCollection.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TIterator.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TDatime.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TUUID.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TUrl.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMap.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/THashTable.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TTree.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TBranch.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TObjArray.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttFill.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TDataType.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TDictionary.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Property.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttLine.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttMarker.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayD.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArray.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayI.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TClass.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TObjString.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVirtualTreePlayer.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/TTreeStream.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAnalysisManager.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Riostream.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDInputHandler.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliInputEventHandler.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVEventHandler.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDEvent.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TClonesArray.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayF.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVEvent.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGeoMatrix.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVHeader.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVParticle.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVVertex.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVCluster.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TLorentzVector.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMath.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TError.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVector3.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVector2.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrix.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixF.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixT.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixTBase.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixFBasefwd.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDBasefwd.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVectorFfwd.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVectorDfwd.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixTUtils.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixFfwd.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixFUtils.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixFUtilsfwd.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TRotation.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVCaloCells.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TRefArray.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TProcessID.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDCaloTrigger.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDRun.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDHeader.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTriggerScalersESD.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTriggerScalersRecordESD.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTimeStamp.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDTZERO.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDZDC.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVZDC.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDACORDE.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDtrack.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TBits.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliExternalTrackParam.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVTrack.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliPID.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDfriendTrack.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTPCdEdxInfo.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDVertex.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVertex.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDCaloCluster.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayS.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliLog.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDCaloCells.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTOFHeader.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDVZERO.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVVZERO.h +./AliDielectronDebugTreeTaku_cxx.so: AliDielectronTaku.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAnalysisFilter.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliKFParticle.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliKFParticleBase.h +./AliDielectronDebugTreeTaku_cxx.so: AliDielectronHistosTaku.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/THashList.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronVarManager.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODEvent.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODHeader.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODVertex.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TRef.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODRedCov.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliCentrality.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliEventplane.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODTrack.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODPid.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODv0.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODRecoDecay.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODcascade.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODTracklets.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODJet.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODCaloCells.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODCaloCluster.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODCluster.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODCaloTrigger.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODPmdCluster.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODFmdCluster.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODDimuon.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODTZERO.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODVZERO.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODZDC.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliMCEvent.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliMCParticle.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TParticle.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAtt3D.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TParticlePDG.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTrackReference.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliKFVertex.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODMCParticle.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TExMap.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDpid.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliPIDResponse.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliITSPIDResponse.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTPCPIDResponse.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTRDPIDResponse.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTOFPIDResponse.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliEMCALPIDResponse.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVectorD.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVectorT.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixTSym.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixTSparse.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixD.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDfwd.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDUtils.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDUtilsfwd.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDSym.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDSymfwd.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDSparse.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDSparsefwd.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODpidUtil.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronPair.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronMC.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronSignalMC.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronPID.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAnalysisCuts.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVCuts.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronHelper.h +./AliDielectronDebugTreeTaku_cxx.so: AliDielectronDebugTreeTaku.h +./AliDielectronDebugTreeTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/cintdictversion.h /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/RVersion.h +AliDielectronDebugTreeTaku_cxx__ROOTBUILDVERSION= 5.30/03 diff --git a/PWGDQ/dielectron/TakuAlberica/single/AliDielectronHistosTaku.cxx b/PWGDQ/dielectron/TakuAlberica/single/AliDielectronHistosTaku.cxx new file mode 100644 index 00000000000..c23c7a9e17c --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/AliDielectronHistosTaku.cxx @@ -0,0 +1,1035 @@ +/************************************************************************* +* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. * +* * +* Author: The ALICE Off-line Project. * +* Contributors are mentioned in the code where appropriate. * +* * +* Permission to use, copy, modify and distribute this software and its * +* documentation strictly for non-commercial purposes is hereby granted * +* without fee, provided that the above copyright notice appears in all * +* copies and that both the copyright notice and this permission notice * +* appear in the supporting documentation. The authors make no claims * +* about the suitability of this software for any purpose. It is * +* provided "as is" without express or implied warranty. * +**************************************************************************/ + +// +// Generic Histogram container with support for groups and filling of groups by passing +// a vector of data +// +// Authors: +// Jens Wiechula +// + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "AliDielectronHelper.h" +#include "AliDielectronHistosTaku.h" +#include "AliDielectronVarManager.h" + +ClassImp(AliDielectronHistosTaku) + + +AliDielectronHistosTaku::AliDielectronHistosTaku() : +// TCollection(), + TNamed("AliDielectronHistosTaku","Dielectron Histogram Container"), + fHistoList(), + fTreeList(), + fList(0x0), + fTree(0x0), + fReservedWords(new TString) +{ + // + // Default constructor + // + fHistoList.SetOwner(kTRUE); + fHistoList.SetName("Dielectron_Histos"); + fTreeList.SetOwner(kTRUE); + fTreeList.SetName("Dielectron_Tree"); +} + +//_____________________________________________________________________________ +AliDielectronHistosTaku::AliDielectronHistosTaku(const char* name, const char* title) : +// TCollection(), + TNamed(name, title), + fHistoList(), + fTreeList(), + fList(0x0), + fTree(0x0), + fReservedWords(new TString) +{ + // + // TNamed constructor + // + fHistoList.SetOwner(kTRUE); + fHistoList.SetName(name); + fTreeList.SetOwner(kTRUE); + char tname[100]; + sprintf(tname,"%s_tree", name); + fTreeList.SetName(tname); +} + +//_____________________________________________________________________________ +AliDielectronHistosTaku::~AliDielectronHistosTaku() +{ + // + // Destructor + // + fHistoList.Clear(); + if (fList) fList->Clear(); + delete fReservedWords; + fTreeList.Clear(); + if (fTree) fTree->Clear(); +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::UserHistogram(const char* histClass,const char *name, const char* title, + Int_t nbinsX, Double_t xmin, Double_t xmax, + UInt_t valTypeX, Bool_t logBinX) +{ + // + // Default histogram creation 1D case + // + + TVectorD *binLimX=0x0; + + if (logBinX) { + binLimX=AliDielectronHelper::MakeLogBinning(nbinsX, xmin, xmax); + } else { + binLimX=AliDielectronHelper::MakeLinBinning(nbinsX, xmin, xmax); + } + + UserHistogram(histClass,name,title,binLimX,valTypeX); +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::UserHistogram(const char* histClass,const char *name, const char* title, + Int_t nbinsX, Double_t xmin, Double_t xmax, + Int_t nbinsY, Double_t ymin, Double_t ymax, + UInt_t valTypeX, UInt_t valTypeY, + Bool_t logBinX, Bool_t logBinY) +{ + // + // Default histogram creation 2D case + // + if (!IsHistogramOk(histClass,name)) return; + + TVectorD *binLimX=0x0; + TVectorD *binLimY=0x0; + + if (logBinX) { + binLimX=AliDielectronHelper::MakeLogBinning(nbinsX, xmin, xmax); + } else { + binLimX=AliDielectronHelper::MakeLinBinning(nbinsX, xmin, xmax); + } + if (logBinY) { + binLimY=AliDielectronHelper::MakeLogBinning(nbinsY, ymin, ymax); + } else { + binLimY=AliDielectronHelper::MakeLinBinning(nbinsY, ymin, ymax); + } + + UserHistogram(histClass,name,title,binLimX,binLimY,valTypeX,valTypeY); +} + + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::UserHistogram(const char* histClass,const char *name, const char* title, + Int_t nbinsX, Double_t xmin, Double_t xmax, + Int_t nbinsY, Double_t ymin, Double_t ymax, + Int_t nbinsZ, Double_t zmin, Double_t zmax, + UInt_t valTypeX, UInt_t valTypeY, UInt_t valTypeZ, + Bool_t logBinX, Bool_t logBinY, Bool_t logBinZ) +{ + // + // Default histogram creation 3D case + // + if (!IsHistogramOk(histClass,name)) return; + + TVectorD *binLimX=0x0; + TVectorD *binLimY=0x0; + TVectorD *binLimZ=0x0; + + if (logBinX) { + binLimX=AliDielectronHelper::MakeLogBinning(nbinsX, xmin, xmax); + } else { + binLimX=AliDielectronHelper::MakeLinBinning(nbinsX, xmin, xmax); + } + + if (logBinY) { + binLimY=AliDielectronHelper::MakeLogBinning(nbinsY, ymin, ymax); + } else { + binLimY=AliDielectronHelper::MakeLinBinning(nbinsY, ymin, ymax); + } + + if (logBinZ) { + binLimZ=AliDielectronHelper::MakeLogBinning(nbinsZ, zmin, zmax); + } else { + binLimZ=AliDielectronHelper::MakeLinBinning(nbinsZ, zmin, zmax); + } + + UserHistogram(histClass,name,title,binLimX,binLimY,binLimZ,valTypeX,valTypeY,valTypeZ); +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::UserHistogram(const char* histClass,const char *name, const char* title, + const char* binning, + UInt_t valTypeX) +{ + // + // Histogram creation 1D case with arbitraty binning + // + + TVectorD *binLimX=AliDielectronHelper::MakeArbitraryBinning(binning); + UserHistogram(histClass,name,title,binLimX,valTypeX); +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::UserHistogram(const char* histClass,const char *name, const char* title, + const TVectorD * const binsX, + UInt_t valTypeX/*=kNoAutoFill*/) +{ + // + // Histogram creation 1D case with arbitraty binning X + // the TVectorD is assumed to be surplus after the creation and will be deleted!!! + // + + Bool_t isOk=kTRUE; + isOk&=IsHistogramOk(histClass,name); + isOk&=(binsX!=0x0); + + if (isOk){ + TH1* hist=new TH1F(name,title,binsX->GetNrows()-1,binsX->GetMatrixArray()); + + Bool_t isReserved=fReservedWords->Contains(histClass); + if (isReserved) + UserHistogramReservedWords(histClass, hist, valTypeX); + else + UserHistogram(histClass, hist, valTypeX); + } + + delete binsX; +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::UserHistogram(const char* histClass,const char *name, const char* title, + const TVectorD * const binsX, const TVectorD * const binsY, + UInt_t valTypeX/*=kNoAutoFill*/, UInt_t valTypeY/*=0*/) +{ + // + // Histogram creation 1D case with arbitraty binning X + // the TVectorD is assumed to be surplus after the creation and will be deleted!!! + // + + Bool_t isOk=kTRUE; + isOk&=IsHistogramOk(histClass,name); + isOk&=(binsX!=0x0); + isOk&=(binsY!=0x0); + + if (isOk){ + TH1* hist=new TH2F(name,title, + binsX->GetNrows()-1,binsX->GetMatrixArray(), + binsY->GetNrows()-1,binsY->GetMatrixArray()); + + Bool_t isReserved=fReservedWords->Contains(histClass); + if (isReserved) + UserHistogramReservedWords(histClass, hist, valTypeX+100*valTypeY); + else + UserHistogram(histClass, hist, valTypeX+100*valTypeY); + } + + delete binsX; + delete binsY; + +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::UserHistogram(const char* histClass,const char *name, const char* title, + const TVectorD * const binsX, const TVectorD * const binsY, const TVectorD * const binsZ, + UInt_t valTypeX/*=kNoAutoFill*/, UInt_t valTypeY/*=0*/, UInt_t valTypeZ/*=0*/) +{ + // + // Histogram creation 1D case with arbitraty binning X + // the TVectorD is assumed to be surplus after the creation and will be deleted!!! + // + + Bool_t isOk=kTRUE; + isOk&=IsHistogramOk(histClass,name); + isOk&=(binsX!=0x0); + isOk&=(binsY!=0x0); + isOk&=(binsZ!=0x0); + + if (isOk){ + TH1* hist=new TH3F(name,title, + binsX->GetNrows()-1,binsX->GetMatrixArray(), + binsY->GetNrows()-1,binsY->GetMatrixArray(), + binsZ->GetNrows()-1,binsZ->GetMatrixArray()); + + Bool_t isReserved=fReservedWords->Contains(histClass); + if (isReserved) + UserHistogramReservedWords(histClass, hist, valTypeX+100*valTypeY+10000*valTypeZ); + else + UserHistogram(histClass, hist, valTypeX+100*valTypeY+10000*valTypeZ); + } + + delete binsX; + delete binsY; + delete binsZ; +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::UserHistogram(const char* histClass, TH1* hist, UInt_t valTypes) +{ + // + // Add any type of user histogram + // + + //special case for the calss Pair. where histograms will be created for all pair classes + Bool_t isReserved=fReservedWords->Contains(histClass); + if (isReserved) { + UserHistogramReservedWords(histClass, hist, valTypes); + return; + } + + if (!IsHistogramOk(histClass,hist->GetName())) return; + + THashList *classTable=(THashList*)fHistoList.FindObject(histClass); + hist->SetDirectory(0); + hist->SetUniqueID(valTypes); + classTable->Add(hist); +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::AddClass(const char* histClass) +{ + // + // Add a class of histograms + // Several classes can be added by separating them by a ';' e.g. 'class1;class2;class3' + // + TString hists(histClass); + TObjArray *arr=hists.Tokenize(";"); + TIter next(arr); + TObject *o=0; + while ( (o=next()) ){ + if (fHistoList.FindObject(o->GetName())){ + Warning("AddClass","Cannot create class '%s' it already exists.",histClass); + continue; + } + if (fReservedWords->Contains(o->GetName())){ + Error("AddClass","Pair is a reserved word, please use another name"); + continue; + } + THashList *table=new THashList; + table->SetOwner(kTRUE); + table->SetName(o->GetName()); + fHistoList.Add(table); + } + delete arr; +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::Fill(const char* histClass, const char* name, Double_t xval) +{ + // + // Fill function 1D case + // + THashList *classTable=(THashList*)fHistoList.FindObject(histClass); + TH1* hist=0; + if (!classTable || !(hist=(TH1*)classTable->FindObject(name)) ){ + Warning("Fill","Cannot fill histogram. Either class '%s' or histogram '%s' not existing.",histClass,name); + return; + } + hist->Fill(xval); +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::Fill(const char* histClass, const char* name, Double_t xval, Double_t yval) +{ + // + // Fill function 2D case + // + THashList *classTable=(THashList*)fHistoList.FindObject(histClass); + TH2* hist=0; + if (!classTable || !(hist=(TH2*)classTable->FindObject(name)) ){ + Warning("UserHistogram","Cannot fill histogram. Either class '%s' or histogram '%s' not existing.",histClass,name); + return; + } + hist->Fill(xval,yval); +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::Fill(const char* histClass, const char* name, Double_t xval, Double_t yval, Double_t zval) +{ + // + // Fill function 3D case + // + THashList *classTable=(THashList*)fHistoList.FindObject(histClass); + TH3* hist=0; + if (!classTable || !(hist=(TH3*)classTable->FindObject(name)) ){ + Warning("UserHistogram","Cannot fill histogram. Either class '%s' or histogram '%s' not existing.",histClass,name); + return; + } + hist->Fill(xval,yval,zval); +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::FillClass(const char* histClass, Int_t nValues, const Double_t *values) +{ + // + // Fill class 'histClass' (by name) + // + + THashList *classTable=(THashList*)fHistoList.FindObject(histClass); + if (!classTable){ + Warning("FillClass","Cannot fill class '%s' its not defined.",histClass); + return; + } + + TIter nextHist(classTable); + TH1 *hist=0; + while ( (hist=(TH1*)nextHist()) ){ + UInt_t valueTypes=hist->GetUniqueID(); + if (valueTypes==(UInt_t)kNoAutoFill) continue; + UInt_t value1=valueTypes%100; //last two digits + UInt_t value2=valueTypes/100%100; //second last two digits + UInt_t value3=valueTypes/10000%100; //third last two digits + if (value1>=(UInt_t)nValues||value2>=(UInt_t)nValues||value3>=(UInt_t)nValues) { + Warning("FillClass","One of the values is out of range. Not filling histogram '%s/%s'.", histClass, hist->GetName()); + continue; + } + switch (hist->GetDimension()){ + case 1: + hist->Fill(values[value1]); + break; + case 2: + ((TH2*)hist)->Fill(values[value1],values[value2]); + break; + case 3: + ((TH3*)hist)->Fill(values[value1],values[value2],values[value3]); + break; + } + } +} + +//_____________________________________________________________________________ +// void AliDielectronHistosTaku::FillClass(const char* histClass, const TVectorD &vals) +// { +// // +// // +// // +// FillClass(histClass, vals.GetNrows(), vals.GetMatrixArray()); +// } + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::UserHistogramReservedWords(const char* histClass, const TH1 *hist, UInt_t valTypes) +{ + // + // Creation of histogram for all pair types + // + TString title(hist->GetTitle()); + // Same Event Like Sign + TIter nextClass(&fHistoList); + THashList *l=0; + while ( (l=static_cast(nextClass())) ){ + TString name(l->GetName()); + if (name.Contains(histClass)){ + TH1 *h=static_cast(hist->Clone()); + h->SetDirectory(0); + h->SetTitle(Form("%s %s",title.Data(),l->GetName())); + UserHistogram(l->GetName(),h,valTypes); + } + } + delete hist; +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::DumpToFile(const char* file) +{ + // + // Dump the histogram list to a newly created root file + // + TFile f(file,"recreate"); + fHistoList.Write(fHistoList.GetName(),TObject::kSingleKey); + f.Close(); +} + +//_____________________________________________________________________________ +TH1* AliDielectronHistosTaku::GetHistogram(const char* histClass, const char* name) const +{ + // + // return histogram 'name' in 'histClass' + // + THashList *classTable=(THashList*)fHistoList.FindObject(histClass); + if (!classTable) return 0x0; + return (TH1*)classTable->FindObject(name); +} + +//_____________________________________________________________________________ +TH1* AliDielectronHistosTaku::GetHistogram(const char* cutClass, const char* histClass, const char* name) const +{ + // + // return histogram from list of list of histograms + // this function is thought for retrieving histograms if a list of AliDielectronHistosTaku is set + // + + if (!fList) return 0x0; + THashList *h=dynamic_cast(fList->FindObject(cutClass)); + if (!h)return 0x0; + THashList *classTable=dynamic_cast(h->FindObject(histClass)); + if (!classTable) return 0x0; + return (TH1*)classTable->FindObject(name); +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::Draw(const Option_t* option) +{ + // + // Draw histograms + // + + TString drawStr(option); + TObjArray *arr=drawStr.Tokenize(";"); + arr->SetOwner(); + TIter nextOpt(arr); + + TString drawClasses; + TObjString *ostr=0x0; + + TString currentOpt; + TString testOpt; + while ( (ostr=(TObjString*)nextOpt()) ){ + currentOpt=ostr->GetString(); + currentOpt.Remove(TString::kBoth,'\t'); + currentOpt.Remove(TString::kBoth,' '); + + testOpt="classes="; + if ( currentOpt.Contains(testOpt.Data()) ){ + drawClasses=currentOpt(testOpt.Length(),currentOpt.Length()); + } + } + + delete arr; + drawStr.ToLower(); + //optionsfList +// Bool_t same=drawOpt.Contains("same"); //FIXME not yet implemented + + TCanvas *c=0x0; + if (gVirtualPS) { + if (!gPad){ + Error("Draw","When writing to a file you have to create a canvas before opening the file!!!"); + return; + } + c=gPad->GetCanvas(); + c->cd(); +// c=new TCanvas; + } + + TIter nextClass(&fHistoList); + THashList *classTable=0; +// Bool_t first=kTRUE; + while ( (classTable=(THashList*)nextClass()) ){ + //test classes option + if (!drawClasses.IsNull() && !drawClasses.Contains(classTable->GetName())) continue; + //optimised division + Int_t nPads = classTable->GetEntries(); + Int_t nCols = (Int_t)TMath::Ceil( TMath::Sqrt(nPads) ); + Int_t nRows = (Int_t)TMath::Ceil( (Double_t)nPads/(Double_t)nCols ); + + //create canvas + if (!gVirtualPS){ + TString canvasName; + canvasName.Form("c%s_%s",GetName(),classTable->GetName()); + c=(TCanvas*)gROOT->FindObject(canvasName.Data()); + if (!c) c=new TCanvas(canvasName.Data(),Form("%s: %s",GetName(),classTable->GetName())); + c->Clear(); + } else { +// if (first){ +// first=kFALSE; +// if (nPads>1) gVirtualPS->NewPage(); +// } else { + if (nPads>1) c->Clear(); +// } + } + if (nCols>1||nRows>1) c->Divide(nCols,nRows); + + //loop over histograms and draw them + TIter nextHist(classTable); + Int_t iPad=0; + TH1 *h=0; + while ( (h=(TH1*)nextHist()) ){ + TString drawOpt; + if ( (h->InheritsFrom(TH2::Class())) ) drawOpt="colz"; + if (nCols>1||nRows>1) c->cd(++iPad); + if ( TMath::Abs(h->GetXaxis()->GetBinWidth(1)-h->GetXaxis()->GetBinWidth(2))>1e-10 ) gPad->SetLogx(); + if ( TMath::Abs(h->GetYaxis()->GetBinWidth(1)-h->GetYaxis()->GetBinWidth(2))>1e-10 ) gPad->SetLogy(); + if ( TMath::Abs(h->GetZaxis()->GetBinWidth(1)-h->GetZaxis()->GetBinWidth(2))>1e-10 ) gPad->SetLogz(); + TString histOpt=h->GetOption(); + histOpt.ToLower(); + if (histOpt.Contains("logx")) gPad->SetLogx(); + if (histOpt.Contains("logy")) gPad->SetLogy(); + if (histOpt.Contains("logz")) gPad->SetLogz(); + histOpt.ReplaceAll("logx",""); + histOpt.ReplaceAll("logy",""); + histOpt.ReplaceAll("logz",""); + h->Draw(drawOpt.Data()); + } + if (gVirtualPS) { + c->Update(); + } + + } +// if (gVirtualPS) delete c; +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::Print(const Option_t* option) const +{ + // + // Print classes and histograms + // + TString optString(option); + + if (optString.IsNull()) PrintStructure(); + + + +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::PrintStructure() const +{ + // + // Print classes and histograms in the class to stdout + // + if (!fList){ + TIter nextClass(&fHistoList); + THashList *classTable=0; + while ( (classTable=(THashList*)nextClass()) ){ + TIter nextHist(classTable); + TObject *o=0; + printf("+ %s\n",classTable->GetName()); + while ( (o=nextHist()) ) + printf("| ->%s\n",o->GetName()); + } + } else { + TIter nextCutClass(fList); + THashList *cutClass=0x0; + while ( (cutClass=(THashList*)nextCutClass()) ) { + printf("+ %s\n",cutClass->GetName()); + TIter nextClass(cutClass); + THashList *classTable=0; + while ( (classTable=(THashList*)nextClass()) ){ + TIter nextHist(classTable); + TObject *o=0; + printf("| + %s\n",classTable->GetName()); + while ( (o=nextHist()) ) + printf("| | ->%s\n",o->GetName()); + } + + } + } +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::SetHistogramList(THashList &list, Bool_t setOwner/*=kTRUE*/) +{ + // + // set histogram classes and histograms to this instance. It will take onwnership! + // + ResetHistogramList(); + TString name(GetName()); + if (name == "AliDielectronHistosTaku") SetName(list.GetName()); + TIter next(&list); + TObject *o; + while ( (o=next()) ){ + fHistoList.Add(o); + } + if (setOwner){ + list.SetOwner(kFALSE); + fHistoList.SetOwner(kTRUE); + } else { + fHistoList.SetOwner(kFALSE); + } +} + +//_____________________________________________________________________________ +Bool_t AliDielectronHistosTaku::SetCutClass(const char* cutClass) +{ + // + // Assign histogram list according to cutClass + // + + if (!fList) return kFALSE; + ResetHistogramList(); + THashList *h=dynamic_cast(fList->FindObject(cutClass)); + if (!h) { + Warning("SetCutClass","cutClass '%s' not found", cutClass); + return kFALSE; + } + SetHistogramList(*h,kFALSE); + return kTRUE; +} + +//_____________________________________________________________________________ +Bool_t AliDielectronHistosTaku::IsHistogramOk(const char* histClass, const char* name) +{ + // + // check whether the histogram class exists and the histogram itself does not exist yet + // + Bool_t isReserved=fReservedWords->Contains(histClass); + if (!fHistoList.FindObject(histClass)&&!isReserved){ + Warning("IsHistogramOk","Cannot create histogram. Class '%s' not defined. Please create it using AddClass before.",histClass); + return kFALSE; + } + if (GetHistogram(histClass,name)){ + Warning("IsHistogramOk","Cannot create histogram '%s' in class '%s': It already exists!",name,histClass); + return kFALSE; + } + return kTRUE; +} + +// //_____________________________________________________________________________ +// TIterator* AliDielectronHistosTaku::MakeIterator(Bool_t dir) const +// { +// // +// // +// // +// return new TListIter(&fHistoList, dir); +// } + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::ReadFromFile(const char* file) +{ + // + // Read histos from file + // + TFile f(file); + TIter nextKey(f.GetListOfKeys()); + TKey *key=0; + while ( (key=(TKey*)nextKey()) ){ + TObject *o=f.Get(key->GetName()); + THashList *list=dynamic_cast(o); + if (!list) continue; + SetHistogramList(*list); + break; + } + f.Close(); +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::DrawSame(const char* histName, const Option_t *opt) +{ + // + // Draw all histograms with the same name into one canvas + // if option contains 'leg' a legend will be created with the class name as caption + // if option contains 'can' a new canvas is created + // + + TString optString(opt); + optString.ToLower(); + Bool_t optLeg=optString.Contains("leg"); + Bool_t optCan=optString.Contains("can"); + + TLegend *leg=0; + TCanvas *c=0; + if (optCan){ + c=(TCanvas*)gROOT->FindObject(Form("c%s",histName)); + if (!c) c=new TCanvas(Form("c%s",histName),Form("All '%s' histograms",histName)); + c->Clear(); + c->cd(); + } + + if (optLeg) leg=new TLegend(.8,.3,.99,.9); + + Int_t i=0; + TIter next(&fHistoList); + THashList *classTable=0; + Double_t max=-1e10; + TH1 *hFirst=0x0; + while ( (classTable=(THashList*)next()) ){ + if ( TH1 *h=(TH1*)classTable->FindObject(histName) ){ + if (i==0) hFirst=h; + h->SetLineColor(i+1); + h->SetMarkerColor(i+1); + h->Draw(i>0?"same":""); + if (leg) leg->AddEntry(h,classTable->GetName(),"lp"); + ++i; + max=TMath::Max(max,h->GetMaximum()); + } + } + if (leg){ + leg->SetFillColor(10); + leg->SetY1(.9-i*.05); + leg->Draw(); + } + if (hFirst&&(hFirst->GetYaxis()->GetXmax()SetMaximum(max); + } +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::SetReservedWords(const char* words) +{ + // + // set reserved words + // + + (*fReservedWords)=words; +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::UserTree(const char* name, const char *title) +{ + fTree = new TTree(name, title); +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::SetReserveVariableInTree(UInt_t valTypes) +{ + switch(valTypes){ + case AliDielectronVarManager::kPx: + fTree->Branch("kPx",&fgData[AliDielectronVarManager::kPx],"kPx/D"); break; + case AliDielectronVarManager::kPy: + fTree->Branch("kPy",&fgData[AliDielectronVarManager::kPy],"kPy/D"); break; + case AliDielectronVarManager::kPz: + fTree->Branch("kPz",&fgData[AliDielectronVarManager::kPz],"kPz/D"); break; + case AliDielectronVarManager::kPt: + fTree->Branch("kPt",&fgData[AliDielectronVarManager::kPt],"kPt/D"); break; + case AliDielectronVarManager::kP: + fTree->Branch("kP",&fgData[AliDielectronVarManager::kP],"kP/D"); break; + case AliDielectronVarManager::kXv: + fTree->Branch("kXv",&fgData[AliDielectronVarManager::kXv],"kXv/D"); break; + case AliDielectronVarManager::kYv: + fTree->Branch("kYv",&fgData[AliDielectronVarManager::kYv],"kYv/D"); break; + case AliDielectronVarManager::kZv: + fTree->Branch("kZv",&fgData[AliDielectronVarManager::kZv],"kZv/D"); break; + case AliDielectronVarManager::kOneOverPt: + fTree->Branch("kOneOverPt",&fgData[AliDielectronVarManager::kOneOverPt],"kOneOverPt/D"); break; + case AliDielectronVarManager::kPhi: + fTree->Branch("kPhi",&fgData[AliDielectronVarManager::kPhi],"kPhi/D"); break; + case AliDielectronVarManager::kTheta: + fTree->Branch("kTheta",&fgData[AliDielectronVarManager::kTheta],"kTheta/D"); break; + case AliDielectronVarManager::kEta: + fTree->Branch("kEta",&fgData[AliDielectronVarManager::kEta],"kEta/D"); break; + case AliDielectronVarManager::kY: + fTree->Branch("kY",&fgData[AliDielectronVarManager::kY],"kY/D"); break; + case AliDielectronVarManager::kE: + fTree->Branch("kE",&fgData[AliDielectronVarManager::kE],"kE/D"); break; + case AliDielectronVarManager::kM: + fTree->Branch("kM",&fgData[AliDielectronVarManager::kM],"kM/D"); break; + case AliDielectronVarManager::kCharge: + fTree->Branch("kCharge",&fgData[AliDielectronVarManager::kCharge],"kCharge/D"); break; + case AliDielectronVarManager::kNclsITS: + fTree->Branch("kNclsITS",&fgData[AliDielectronVarManager::kNclsITS],"kNclsITS/D"); break; + case AliDielectronVarManager::kNclsTPC: + fTree->Branch("kNclsTPC",&fgData[AliDielectronVarManager::kNclsTPC],"kNclsTPC/D"); break; + case AliDielectronVarManager::kNclsTPCiter1: + fTree->Branch("kNclsTPCiter1",&fgData[AliDielectronVarManager::kNclsTPCiter1],"kNclsTPCiter1/D"); break; + case AliDielectronVarManager::kNFclsTPC: + fTree->Branch("kNFclsTPC",&fgData[AliDielectronVarManager::kNFclsTPC],"kNFclsTPC/D"); break; + case AliDielectronVarManager::kNFclsTPCr: + fTree->Branch("kNFclsTPCr",&fgData[AliDielectronVarManager::kNFclsTPCr],"kNFclsTPCr/D"); break; + case AliDielectronVarManager::kNFclsTPCrFrac: + fTree->Branch("kNFclsTPCrFrac",&fgData[AliDielectronVarManager::kNFclsTPCrFrac],"kNFclsTPCrFrac/D"); break; + case AliDielectronVarManager::kTPCsignalN: + fTree->Branch("kTPCsignalN",&fgData[AliDielectronVarManager::kTPCsignalN],"kTPCsignalN/D"); break; + case AliDielectronVarManager::kTPCsignalNfrac: + fTree->Branch("kTPCsignalNfrac",&fgData[AliDielectronVarManager::kTPCsignalNfrac],"kTPCsignalNfrac/D"); break; + case AliDielectronVarManager::kTPCchi2Cl: + fTree->Branch("kTPCchi2Cl",&fgData[AliDielectronVarManager::kTPCchi2Cl],"kTPCchi2Cl/D"); break; + case AliDielectronVarManager::kTrackStatus: + fTree->Branch("kTrackStatus",&fgData[AliDielectronVarManager::kTrackStatus],"kTrackStatus/D"); break; + case AliDielectronVarManager::kNclsTRD: + fTree->Branch("kNclsTRD",&fgData[AliDielectronVarManager::kNclsTRD],"kNclsTRD/D"); break; + case AliDielectronVarManager::kTRDntracklets: + fTree->Branch("kTRDntracklets",&fgData[AliDielectronVarManager::kTRDntracklets],"kTRDntracklets/D"); break; + case AliDielectronVarManager::kTRDpidQuality: + fTree->Branch("kTRDpidQuality",&fgData[AliDielectronVarManager::kTRDpidQuality],"kTRDpidQuality/D"); break; + case AliDielectronVarManager::kTRDprobEle: + fTree->Branch("kTRDprobEle",&fgData[AliDielectronVarManager::kTRDprobEle],"kTRDprobEle/D"); break; + case AliDielectronVarManager::kTRDprobPio: + fTree->Branch("kTRDprobPio",&fgData[AliDielectronVarManager::kTRDprobPio],"kTRDprobPio/D"); break; + case AliDielectronVarManager::kImpactParXY: + fTree->Branch("kImpactParXY",&fgData[AliDielectronVarManager::kImpactParXY],"kImpactParXY/D"); break; + case AliDielectronVarManager::kImpactParZ: + fTree->Branch("kImpactParZ",&fgData[AliDielectronVarManager::kImpactParZ],"kImpactParZ/D"); break; + case AliDielectronVarManager::kTrackLength: + fTree->Branch("kTrackLength",&fgData[AliDielectronVarManager::kTrackLength],"kTrackLength/D"); break; + case AliDielectronVarManager::kPdgCode: + fTree->Branch("kPdgCode",&fgData[AliDielectronVarManager::kPdgCode],"kPdgCode/D"); break; + case AliDielectronVarManager::kPdgCodeMother: + fTree->Branch("kPdgCodeMother",&fgData[AliDielectronVarManager::kPdgCodeMother],"kPdgCodeMother/D"); break; + case AliDielectronVarManager::kPdgCodeGrandMother: + fTree->Branch("kPdgCodeGrandMother",&fgData[AliDielectronVarManager::kPdgCodeGrandMother],"kPdgCodeGrandMother/D"); break; + case AliDielectronVarManager::kNumberOfDaughters: + fTree->Branch("kNumberOfDaughters",&fgData[AliDielectronVarManager::kNumberOfDaughters],"kNumberOfDaughters/D"); break; + case AliDielectronVarManager::kHaveSameMother: + fTree->Branch("kHaveSameMother",&fgData[AliDielectronVarManager::kHaveSameMother],"kHaveSameMother/D"); break; + case AliDielectronVarManager::kIsJpsiPrimary: + fTree->Branch("kIsJpsiPrimary",&fgData[AliDielectronVarManager::kIsJpsiPrimary],"kIsJpsiPrimary/D"); break; + case AliDielectronVarManager::kITSsignal: + fTree->Branch("kITSsignal",&fgData[AliDielectronVarManager::kITSsignal],"kITSsignal/D"); break; + case AliDielectronVarManager::kITSsignalSSD1: + fTree->Branch("kITSsignalSSD1",&fgData[AliDielectronVarManager::kITSsignalSSD1],"kITSsignalSSD1/D"); break; + case AliDielectronVarManager::kITSsignalSSD2: + fTree->Branch("kITSsignalSSD2",&fgData[AliDielectronVarManager::kITSsignalSSD2],"kITSsignalSSD2/D"); break; + case AliDielectronVarManager::kITSsignalSDD1: + fTree->Branch("kITSsignalSDD1",&fgData[AliDielectronVarManager::kITSsignalSDD1],"kITSsignalSDD1/D"); break; + case AliDielectronVarManager::kITSsignalSDD2: + fTree->Branch("kITSsignalSDD2",&fgData[AliDielectronVarManager::kITSsignalSDD2],"kITSsignalSDD2/D"); break; + case AliDielectronVarManager::kITSclusterMap: + fTree->Branch("kITSclusterMap",&fgData[AliDielectronVarManager::kITSclusterMap],"kITSclusterMap/D"); break; + case AliDielectronVarManager::kITSnSigmaEle: + fTree->Branch("kITSnSigmaEle",&fgData[AliDielectronVarManager::kITSnSigmaEle],"kITSnSigmaEle/D"); break; + case AliDielectronVarManager::kITSnSigmaPio: + fTree->Branch("kITSnSigmaPio",&fgData[AliDielectronVarManager::kITSnSigmaPio],"kITSnSigmaPio/D"); break; + case AliDielectronVarManager::kITSnSigmaMuo: + fTree->Branch("kITSnSigmaMuo",&fgData[AliDielectronVarManager::kITSnSigmaMuo],"kITSnSigmaMuo/D"); break; + case AliDielectronVarManager::kITSnSigmaKao: + fTree->Branch("kITSnSigmaKao",&fgData[AliDielectronVarManager::kITSnSigmaKao],"kITSnSigmaKao/D"); break; + case AliDielectronVarManager::kITSnSigmaPro: + fTree->Branch("kITSnSigmaPro",&fgData[AliDielectronVarManager::kITSnSigmaPro],"kITSnSigmaPro/D"); break; + case AliDielectronVarManager::kPIn: + fTree->Branch("kPIn",&fgData[AliDielectronVarManager::kPIn],"kPIn/D"); break; + case AliDielectronVarManager::kTPCsignal: + fTree->Branch("kTPCsignal",&fgData[AliDielectronVarManager::kTPCsignal],"kTPCsignal/D"); break; + case AliDielectronVarManager::kTOFsignal: + fTree->Branch("kTOFsignal",&fgData[AliDielectronVarManager::kTOFsignal],"kTOFsignal/D"); break; + case AliDielectronVarManager::kTOFbeta: + fTree->Branch("kTOFbeta",&fgData[AliDielectronVarManager::kTOFbeta],"kTOFbeta/D"); break; + case AliDielectronVarManager::kTPCnSigmaEle: + fTree->Branch("kTPCnSigmaEle",&fgData[AliDielectronVarManager::kTPCnSigmaEle],"kTPCnSigmaEle/D"); break; + case AliDielectronVarManager::kTPCnSigmaPio: + fTree->Branch("kTPCnSigmaPio",&fgData[AliDielectronVarManager::kTPCnSigmaPio],"kTPCnSigmaPio/D"); break; + case AliDielectronVarManager::kTPCnSigmaMuo: + fTree->Branch("kTPCnSigmaMuo",&fgData[AliDielectronVarManager::kTPCnSigmaMuo],"kTPCnSigmaMuo/D"); break; + case AliDielectronVarManager::kTPCnSigmaKao: + fTree->Branch("kTPCnSigmaKao",&fgData[AliDielectronVarManager::kTPCnSigmaKao],"kTPCnSigmaKao/D"); break; + case AliDielectronVarManager::kTPCnSigmaPro: + fTree->Branch("kTPCnSigmaPro",&fgData[AliDielectronVarManager::kTPCnSigmaPro],"kTPCnSigmaPro/D"); break; + case AliDielectronVarManager::kTOFnSigmaEle: + fTree->Branch("kTOFnSigmaEle",&fgData[AliDielectronVarManager::kTOFnSigmaEle],"kTOFnSigmaEle/D"); break; + case AliDielectronVarManager::kTOFnSigmaPio: + fTree->Branch("kTOFnSigmaPio",&fgData[AliDielectronVarManager::kTOFnSigmaPio],"kTOFnSigmaPio/D"); break; + case AliDielectronVarManager::kTOFnSigmaMuo: + fTree->Branch("kTOFnSigmaMuo",&fgData[AliDielectronVarManager::kTOFnSigmaMuo],"kTOFnSigmaMuo/D"); break; + case AliDielectronVarManager::kTOFnSigmaKao: + fTree->Branch("kTOFnSigmaKao",&fgData[AliDielectronVarManager::kTOFnSigmaKao],"kTOFnSigmaKao/D"); break; + case AliDielectronVarManager::kTOFnSigmaPro: + fTree->Branch("kTOFnSigmaPro",&fgData[AliDielectronVarManager::kTOFnSigmaPro],"kTOFnSigmaPro/D"); break; + case AliDielectronVarManager::kKinkIndex0: + fTree->Branch("kKinkIndex0",&fgData[AliDielectronVarManager::kKinkIndex0],"kKinkIndex0/D"); break; + case AliDielectronVarManager::kChi2NDF: + fTree->Branch("kChi2NDF",&fgData[AliDielectronVarManager::kChi2NDF],"kChi2NDF/D"); break; + case AliDielectronVarManager::kDecayLength: + fTree->Branch("kDecayLength",&fgData[AliDielectronVarManager::kDecayLength],"kDecayLength/D"); break; + case AliDielectronVarManager::kR: + fTree->Branch("kR",&fgData[AliDielectronVarManager::kR],"kR/D"); break; + case AliDielectronVarManager::kOpeningAngle: + fTree->Branch("kOpeningAngle",&fgData[AliDielectronVarManager::kOpeningAngle],"kOpeningAngle/D"); break; + case AliDielectronVarManager::kThetaHE: + fTree->Branch("kThetaHE",&fgData[AliDielectronVarManager::kThetaHE],"kThetaHE/D"); break; + case AliDielectronVarManager::kPhiHE: + fTree->Branch("kPhiHE",&fgData[AliDielectronVarManager::kPhiHE],"kPhiHE/D"); break; + case AliDielectronVarManager::kThetaCS: + fTree->Branch("kThetaCS",&fgData[AliDielectronVarManager::kThetaCS],"kThetaCS/D"); break; + case AliDielectronVarManager::kPhiCS: + fTree->Branch("kPhiCS",&fgData[AliDielectronVarManager::kPhiCS],"kPhiCS/D"); break; + case AliDielectronVarManager::kLegDist: + fTree->Branch("kLegDist",&fgData[AliDielectronVarManager::kLegDist],"kLegDist/D"); break; + case AliDielectronVarManager::kLegDistXY: + fTree->Branch("kLegDistXY",&fgData[AliDielectronVarManager::kLegDistXY],"kLegDistXY/D"); break; + case AliDielectronVarManager::kDeltaEta: + fTree->Branch("kDeltaEta",&fgData[AliDielectronVarManager::kDeltaEta],"kDeltaEta/D"); break; + case AliDielectronVarManager::kDeltaPhi: + fTree->Branch("kDeltaPhi",&fgData[AliDielectronVarManager::kDeltaPhi],"kDeltaPhi/D"); break; + case AliDielectronVarManager::kMerr: + fTree->Branch("kMerr",&fgData[AliDielectronVarManager::kMerr],"kMerr/D"); break; + case AliDielectronVarManager::kDCA: + fTree->Branch("kDCA",&fgData[AliDielectronVarManager::kDCA],"kDCA/D"); break; + case AliDielectronVarManager::kPairType: + fTree->Branch("kPairType",&fgData[AliDielectronVarManager::kPairType],"kPairType/D"); break; + case AliDielectronVarManager::kPseudoProperTime: + fTree->Branch("kPseudoProperTime",&fgData[AliDielectronVarManager::kPseudoProperTime],"kPseudoProperTime/D"); break; + case AliDielectronVarManager::kXvPrim: + fTree->Branch("kXvPrim",&fgData[AliDielectronVarManager::kXvPrim],"kXvPrim=kPairMax/D"); break; + case AliDielectronVarManager::kYvPrim: + fTree->Branch("kYvPrim",&fgData[AliDielectronVarManager::kYvPrim],"kYvPrim/D"); break; + case AliDielectronVarManager::kZvPrim: + fTree->Branch("kZvPrim",&fgData[AliDielectronVarManager::kZvPrim],"kZvPrim/D"); break; + case AliDielectronVarManager::kXRes: + fTree->Branch("kXRes",&fgData[AliDielectronVarManager::kXRes],"kXRes/D"); break; + case AliDielectronVarManager::kYRes: + fTree->Branch("kYRes",&fgData[AliDielectronVarManager::kYRes],"kYRes/D"); break; + case AliDielectronVarManager::kZRes: + fTree->Branch("kZRes",&fgData[AliDielectronVarManager::kZRes],"kZRes/D"); break; + case AliDielectronVarManager::kNTrk: + fTree->Branch("kNTrk",&fgData[AliDielectronVarManager::kNTrk],"kNTrk/D"); break; + case AliDielectronVarManager::kTracks: + fTree->Branch("kTracks",&fgData[AliDielectronVarManager::kTracks],"kTracks/D"); break; + case AliDielectronVarManager::kNacc: + fTree->Branch("kNacc",&fgData[AliDielectronVarManager::kNacc],"kNacc/D"); break; + case AliDielectronVarManager::kNaccTrcklts: + fTree->Branch("kNaccTrcklts",&fgData[AliDielectronVarManager::kNaccTrcklts],"kNaccTrcklts/D"); break; + case AliDielectronVarManager::kNch: + fTree->Branch("kNch",&fgData[AliDielectronVarManager::kNch],"kNch/D"); break; + case AliDielectronVarManager::kCentrality: + fTree->Branch("kCentrality",&fgData[AliDielectronVarManager::kCentrality],"kCentrality/D"); break; + case AliDielectronVarManager::kNevents: + fTree->Branch("kNevents",&fgData[AliDielectronVarManager::kNevents],"kNevents/D"); break; + } + fTreeList.Add(fTree); +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::FillTree(Int_t nValues, const Double_t *values) +{ + + for(int i=0;i "<Fill(); +} + +//_____________________________________________________________________________ +void AliDielectronHistosTaku::SetTreeList(THashList &list, Bool_t setOwner/*=kTRUE*/) +{ + // + // set histogram classes and histograms to this instance. It will take onwnership! + // + ResetHistogramList(); + TString name(GetName()); + if (name == "AliDielectronHistosTaku") SetName(list.GetName()); + TIter next(&list); + TObject *o; + while ( (o=next()) ){ + fTreeList.Add(o); + } + if (setOwner){ + list.SetOwner(kFALSE); + fTreeList.SetOwner(kTRUE); + } else { + fTreeList.SetOwner(kFALSE); + } +} diff --git a/PWGDQ/dielectron/TakuAlberica/single/AliDielectronHistosTaku.h b/PWGDQ/dielectron/TakuAlberica/single/AliDielectronHistosTaku.h new file mode 100644 index 00000000000..7b6e2397c7f --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/AliDielectronHistosTaku.h @@ -0,0 +1,145 @@ +#ifndef ALIDIELECTRONHISTOS_H +#define ALIDIELECTRONHISTOS_H +/* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +/////////////////////////////////////////////////////////////////////////////////////////// +// // +// Generic Histogram container with support for groups and filling of groups by passing // +// a vector of data // +// // +// Authors: // +// Jens Wiechula // +// // +/////////////////////////////////////////////////////////////////////////////////////////// + + +#include +// #include +#include +#include +#include "AliDielectronVarManager.h" + + +class TH1; +class TTree; +class TString; +class TList; +class AliDielectronVarManager; +// class TVectorT; + +class AliDielectronHistosTaku : public TNamed { +public: + AliDielectronHistosTaku(); + AliDielectronHistosTaku(const char* name, const char* title); + virtual ~AliDielectronHistosTaku(); + + + void UserHistogram(const char* histClass,const char *name, const char* title, + Int_t nbinsX, Double_t xmin, Double_t xmax, + UInt_t valTypeX=kNoAutoFill, Bool_t logBinX=kFALSE); + void UserHistogram(const char* histClass,const char *name, const char* title, + Int_t nbinsX, Double_t xmin, Double_t xmax, + Int_t nbinsY, Double_t ymin, Double_t ymax, + UInt_t valTypeX=kNoAutoFill, UInt_t valTypeY=0, + Bool_t logBinX=kFALSE, Bool_t logBinY=kFALSE); + void UserHistogram(const char* histClass,const char *name, const char* title, + Int_t nbinsX, Double_t xmin, Double_t xmax, + Int_t nbinsY, Double_t ymin, Double_t ymax, + Int_t nbinsZ, Double_t zmin, Double_t zmax, + UInt_t valTypeX=kNoAutoFill, UInt_t valTypeY=0, UInt_t valTypeZ=0, + Bool_t logBinX=kFALSE, Bool_t logBinY=kFALSE, Bool_t logBinZ=kFALSE); + + void UserHistogram(const char* histClass,const char *name, const char* title, + const char* binning, + UInt_t valTypeX=kNoAutoFill); + + void UserHistogram(const char* histClass,const char *name, const char* title, + const TVectorD * const binsX, + UInt_t valTypeX=kNoAutoFill); + void UserHistogram(const char* histClass,const char *name, const char* title, + const TVectorD * const binsX, const TVectorD * const binsY, + UInt_t valTypeX=kNoAutoFill, UInt_t valTypeY=0); + void UserHistogram(const char* histClass,const char *name, const char* title, + const TVectorD * const binsX, const TVectorD * const binsY, const TVectorD * const binsZ, + UInt_t valTypeX=kNoAutoFill, UInt_t valTypeY=0, UInt_t valTypeZ=0); + + void UserHistogram(const char* histClass, TH1* hist, UInt_t valTypes=kNoAutoFill); + + + void Fill(const char* histClass, const char* name, Double_t xval); + void Fill(const char* histClass, const char* name, Double_t xval, Double_t yval); + void Fill(const char* histClass, const char* name, Double_t xval, Double_t yval, Double_t zval); + +// void FillClass(const char* histClass, const TVectorD &vals); + void FillClass(const char* histClass, Int_t nValues, const Double_t *values); + + + + TH1* GetHistogram(const char* histClass, const char* name) const; + TH1* GetHistogram(const char* cutClass, const char* histClass, const char* name) const; + + void SetHistogramList(THashList &list, Bool_t setOwner=kTRUE); + void ResetHistogramList(){fHistoList.Clear();} + const THashList* GetHistogramList() const {return &fHistoList;} + + void SetList(TList * const list) { fList=list; } + TList *GetList() const { return fList; } + + void AddClass(const char* histClass); + + void DumpToFile(const char* file="histos.root"); + void ReadFromFile(const char* file="histos.root"); + + virtual void Print(const Option_t* option = "") const; + virtual void Draw(const Option_t* option = ""); + virtual void DrawSame(const char* histName, const Option_t *opt="leg can"); + + void SetReservedWords(const char* words); +// virtual void Add(TObject *obj) {}; +// virtual void Clear(Option_t *option="") {}; +// virtual void Delete(Option_t *option="") {}; +// virtual TObject **GetObjectRef(const TObject *obj) const { return 0; } +// virtual TIterator *MakeIterator(Bool_t dir = kIterForward) const ; +// virtual TObject *Remove(TObject *obj) { return 0; } + + Bool_t SetCutClass(const char* cutClass); + + void UserTree(const char *name, const char* title); + void SetReserveVariableInTree(UInt_t valTypes=kNoAutoFill); + void FillTree(Int_t nValues, const Double_t *values); + const THashList* GetTreeList() const {return &fTreeList;} + void SetTreeList(THashList &list, Bool_t setOwner=kTRUE); + void ResetTreeList(){fTreeList.Clear();} + TTree * GetSingleTree() const {return fTree;} + + Double_t fgData[AliDielectronVarManager::kNMaxValues]; + +private: + THashList fHistoList; //-> list of histograms + THashList fTreeList; //-> list of histograms + TList *fList; //! List of list of histograms + TTree *fTree; + + TString *fReservedWords; //! list of reserved words + void UserHistogramReservedWords(const char* histClass, const TH1 *hist, UInt_t valTypes); + void FillClass(THashTable *classTable, Int_t nValues, Double_t *values); + + void PrintPDF(Option_t* opt); + void PrintStructure() const; + + Bool_t IsHistogramOk(const char* classTable, const char* name); + + enum {kNoAutoFill=1000000000}; + + + + + AliDielectronHistosTaku(const AliDielectronHistosTaku &hist); + AliDielectronHistosTaku& operator = (const AliDielectronHistosTaku &hist); + + ClassDef(AliDielectronHistosTaku,2) +}; + +#endif + diff --git a/PWGDQ/dielectron/TakuAlberica/single/AliDielectronHistosTaku_cxx.d b/PWGDQ/dielectron/TakuAlberica/single/AliDielectronHistosTaku_cxx.d new file mode 100644 index 00000000000..da1ba3f3b0f --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/AliDielectronHistosTaku_cxx.d @@ -0,0 +1,196 @@ + +# DO NOT DELETE + +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TH1.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAxis.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TNamed.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TObject.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Rtypes.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/RConfig.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/RVersion.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/DllImport.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Rtypeinfo.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/snprintf.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/strlcpy.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGenericClassInfo.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TSchemaHelper.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TStorage.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVersionCheck.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Riosfwd.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TBuffer.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TString.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMathBase.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttAxis.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayD.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArray.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttLine.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttFill.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttMarker.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayC.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayS.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayI.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayF.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Foption.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVectorFfwd.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVectorDfwd.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TFitResultPtr.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TH1F.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TH2.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixFBasefwd.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDBasefwd.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TH3.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAtt3D.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TTree.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TBranch.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TObjArray.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TSeqCollection.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TCollection.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TIterator.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TDataType.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TDictionary.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Property.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TClass.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TObjString.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVirtualTreePlayer.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/THashList.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TList.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TFile.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TDirectoryFile.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TDirectory.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TDatime.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TUUID.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TUrl.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMap.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/THashTable.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TError.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TCanvas.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TPad.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVirtualPad.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttPad.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVirtualX.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttText.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/GuiTypes.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Buttons.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TQObject.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttCanvas.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TCanvasImp.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMath.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TROOT.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TLegend.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TPave.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TBox.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TKey.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVirtualPS.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVectorD.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVectorT.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixT.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixTBase.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixTUtils.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixTSym.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixTSparse.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixD.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDfwd.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDUtils.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDUtilsfwd.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDSym.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDSymfwd.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDSparse.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDSparsefwd.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronHelper.h +./AliDielectronHistosTaku_cxx.so: AliDielectronHistosTaku.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronVarManager.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVEvent.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGeoMatrix.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVHeader.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVParticle.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVVertex.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVCluster.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TLorentzVector.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVector3.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVector2.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrix.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixF.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixFfwd.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixFUtils.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixFUtilsfwd.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TRotation.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVCaloCells.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TRefArray.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TProcessID.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDEvent.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TClonesArray.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDCaloTrigger.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDRun.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDHeader.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTriggerScalersESD.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTriggerScalersRecordESD.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTimeStamp.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDTZERO.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDZDC.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVZDC.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDACORDE.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDtrack.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TBits.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliExternalTrackParam.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVTrack.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliPID.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDfriendTrack.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTPCdEdxInfo.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDVertex.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVertex.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDCaloCluster.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliLog.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDCaloCells.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTOFHeader.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDVZERO.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVVZERO.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODEvent.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODHeader.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODVertex.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TRef.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODRedCov.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliCentrality.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliEventplane.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODTrack.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODPid.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODv0.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODRecoDecay.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODcascade.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODTracklets.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODJet.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODCaloCells.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODCaloCluster.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODCluster.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODCaloTrigger.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODPmdCluster.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODFmdCluster.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODDimuon.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODTZERO.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODVZERO.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODZDC.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliMCEvent.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliMCParticle.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TParticle.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TParticlePDG.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTrackReference.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliKFParticle.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliKFParticleBase.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliKFVertex.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODMCParticle.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TExMap.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDpid.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliPIDResponse.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliITSPIDResponse.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTPCPIDResponse.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTRDPIDResponse.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTOFPIDResponse.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliEMCALPIDResponse.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODpidUtil.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronPair.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronMC.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronSignalMC.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronPID.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAnalysisCuts.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVCuts.h +./AliDielectronHistosTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/cintdictversion.h /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/RVersion.h +AliDielectronHistosTaku_cxx__ROOTBUILDVERSION= 5.30/03 diff --git a/PWGDQ/dielectron/TakuAlberica/single/AliDielectronTaku.cxx b/PWGDQ/dielectron/TakuAlberica/single/AliDielectronTaku.cxx new file mode 100644 index 00000000000..9b484daf3ca --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/AliDielectronTaku.cxx @@ -0,0 +1,788 @@ +/************************************************************************* +* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. * +* * +* Author: The ALICE Off-line Project. * +* Contributors are mentioned in the code where appropriate. * +* * +* Permission to use, copy, modify and distribute this software and its * +* documentation strictly for non-commercial purposes is hereby granted * +* without fee, provided that the above copyright notice appears in all * +* copies and that both the copyright notice and this permission notice * +* appear in the supporting documentation. The authors make no claims * +* about the suitability of this software for any purpose. It is * +* provided "as is" without express or implied warranty. * +**************************************************************************/ + +/////////////////////////////////////////////////////////////////////////// +// Dielectron Analysis Main class // +// // +/* +Framework to perform event selectoin, single track selection and track pair +selection. + +Convention for the signs of the pair in fPairCandidates: +The names are available via the function PairClassName(Int_t i) + +0: ev1+ ev1+ (same event like sign +) +1: ev1+ ev1- (same event unlike sign) +2: ev1- ev1- (same event like sign -) + +3: ev1+ ev2+ (mixed event like sign +) +4: ev1- ev2+ (mixed event unlike sign -+) +6: ev1+ ev2- (mixed event unlike sign +-) +7: ev1- ev2- (mixed event like sign -) + +5: ev2+ ev2+ (same event like sign +) +8: ev2+ ev2- (same event unlike sign) +9: ev2- ev2- (same event like sign -) + +10: ev1+ ev1- (same event track rotation) + +*/ +// // +/////////////////////////////////////////////////////////////////////////// + +#include +#include +#include + +#include +#include + +#include +#include +#include +#include "AliDielectronPair.h" +#include "AliDielectronHistosTaku.h" +#include "AliDielectronCF.h" +#include "AliDielectronMC.h" +#include "AliDielectronVarManager.h" +#include "AliDielectronTrackRotator.h" +#include "AliDielectronDebugTreeTaku.h" +#include "AliDielectronSignalMC.h" + +#include "AliDielectronTaku.h" + +#include +using namespace std; + +ClassImp(AliDielectronTaku) + +const char* AliDielectronTaku::fgkTrackClassNames[4] = { + "ev1+", + "ev1-", + "ev2+", + "ev2-" +}; + +const char* AliDielectronTaku::fgkPairClassNames[11] = { + "ev1+_ev1+", + "ev1+_ev1-", + "ev1-_ev1-", + "ev1+_ev2+", + "ev1-_ev2+", + "ev2+_ev2+", + "ev1+_ev2-", + "ev1-_ev2-", + "ev2+_ev2-", + "ev2-_ev2-", + "ev1+_ev1-_TR" +}; + +//________________________________________________________________ +AliDielectronTaku::AliDielectronTaku() : + TNamed("AliDielectronTaku","AliDielectronTaku"), + fEventFilter("EventFilter"), + fTrackFilter("TrackFilter"), + fPairPreFilter("PairPreFilter"), + fPairPreFilterLegs("PairPreFilterLegs"), + fPairFilter("PairFilter"), + fPdgMother(443), + fPdgLeg1(11), + fPdgLeg2(11), + fSignalsMC(0x0), + fNoPairing(kFALSE), + fHistos(0x0), + fTree(0x0), + fPairCandidates(new TObjArray(10)), + fCfManagerPair(0x0), + fTrackRotator(0x0), + fDebugTree(0x0), + fPreFilterUnlikeOnly(kFALSE), + fPreFilterAllSigns(kFALSE), + fHasMC(kFALSE) +{ + // + // Default constructor + // + +} + +//________________________________________________________________ +AliDielectronTaku::AliDielectronTaku(const char* name, const char* title) : + TNamed(name,title), + fEventFilter("EventFilter"), + fTrackFilter("TrackFilter"), + fPairPreFilter("PairPreFilter"), + fPairPreFilterLegs("PairPreFilterLegs"), + fPairFilter("PairFilter"), + fPdgMother(443), + fPdgLeg1(11), + fPdgLeg2(11), + fSignalsMC(0x0), + fNoPairing(kFALSE), + fHistos(0x0), + fTree(0x0), + fPairCandidates(new TObjArray(10)), + fCfManagerPair(0x0), + fTrackRotator(0x0), + fDebugTree(0x0), + fPreFilterUnlikeOnly(kFALSE), + fPreFilterAllSigns(kFALSE), + fHasMC(kFALSE) +{ + // + // Named constructor + // + +} + +//________________________________________________________________ +AliDielectronTaku::~AliDielectronTaku() +{ + // + // Default destructor + // + if (fHistos) delete fHistos; + if (fTree) delete fTree; + if (fPairCandidates) delete fPairCandidates; + if (fDebugTree) delete fDebugTree; + if (fSignalsMC) delete fSignalsMC; +} + +//________________________________________________________________ +void AliDielectronTaku::Init() +{ + // + // Initialise objects + // + + if(GetHasMC()) AliDielectronMC::Instance()->SetHasMC(GetHasMC()); + + if (fCfManagerPair) { + fCfManagerPair->SetSignalsMC(fSignalsMC); + fCfManagerPair->InitialiseContainer(fPairFilter); + } + if (fTrackRotator) { + fTrackRotator->SetTrackArrays(&fTracks[0],&fTracks[1]); + fTrackRotator->SetPdgLegs(fPdgLeg1,fPdgLeg2); + } + if (fDebugTree) fDebugTree->SetDielectron(this); +} + +//________________________________________________________________ +void AliDielectronTaku::Process(AliVEvent *ev1, AliVEvent *ev2) +{ + // + // Process the events + // + + //at least first event is needed! + if (!ev1){ + AliError("At least first event must be set!"); + return; + } + + AliDielectronVarManager::SetEvent(ev1); + + //in case we have MC load the MC event and process the MC particles + if (AliDielectronMC::Instance()->HasMC()) { + if (!AliDielectronMC::Instance()->ConnectMCEvent()){ + AliError("Could not properly connect the MC event, skipping this event!"); + return; + } + ProcessMC(); + } + + //if candidate array doesn't exist, create it + if (!fPairCandidates->UncheckedAt(0)) { + InitPairCandidateArrays(); + } else { + ClearArrays(); + } + + //mask used to require that all cuts are fulfilled + UInt_t selectedMask=(1<GetEntries())-1; + + //apply event cuts + if ((ev1&&fEventFilter.IsSelected(ev1)!=selectedMask) || + (ev2&&fEventFilter.IsSelected(ev2)!=selectedMask)) return; + + AliDielectronVarManager::SetEvent(ev1); + + //fill track arrays for the first event + if (ev1){ + FillTrackArrays(ev1); + if (((fPreFilterAllSigns)||(fPreFilterUnlikeOnly)) && ( fPairPreFilter.GetCuts()->GetEntries()>0 )) PairPreFilter(0, 1, fTracks[0], fTracks[1]); + if ((fPreFilterAllSigns) && ( fPairPreFilter.GetCuts()->GetEntries()>0 )) { + PairPreFilter(0, 0, fTracks[0], fTracks[0]); + PairPreFilter(1, 1, fTracks[1], fTracks[1]); + } + } + + + //fill track arrays for the second event + if (ev2) { + FillTrackArrays(ev2,1); + if (((fPreFilterAllSigns)||(fPreFilterUnlikeOnly)) && ( fPairPreFilter.GetCuts()->GetEntries()>0 )) PairPreFilter(2, 3, fTracks[2], fTracks[3]); + if ((fPreFilterAllSigns) && ( fPairPreFilter.GetCuts()->GetEntries()>0 )) { + PairPreFilter(2, 2, fTracks[2], fTracks[2]); + PairPreFilter(3, 3, fTracks[3], fTracks[3]); + } + } + /* + if (!fNoPairing){ + // create pairs and fill pair candidate arrays + for (Int_t itrackArr1=0; itrackArr1<4; ++itrackArr1){ + for (Int_t itrackArr2=itrackArr1; itrackArr2<4; ++itrackArr2){ + FillPairArrays(itrackArr1, itrackArr2); + } + } + + //track rotation + if (fTrackRotator) { + fTrackRotator->SetEvent(ev1); + FillPairArrayTR(); + } + } + */ + + //in case there is a histogram manager, fill the QA histograms + if (fHistos) FillHistograms(ev1); + if (fTree) FillTree(ev1); + + //fill debug tree if a manager is attached + if (fDebugTree) FillDebugTree(); +} + +//________________________________________________________________ +void AliDielectronTaku::ProcessMC() +{ + // + // Process the MC data + // + + AliDielectronMC *dieMC=AliDielectronMC::Instance(); + + if (fHistos) FillHistogramsMC(dieMC->GetMCEvent()); + + if(!fSignalsMC) return; + //loop over all MC data and Fill the CF container if it exist + if (!fCfManagerPair) return; + fCfManagerPair->SetPdgMother(fPdgMother); + if(!fCfManagerPair->GetStepForMCtruth()) return; + + // signals to be studied + Int_t nSignals = fSignalsMC->GetEntries(); + + // initialize 2D arrays of labels for particles from each MC signal + Int_t** labels1; // labels for particles satisfying branch 1 + Int_t** labels2; // labels for particles satisfying branch 2 + Int_t** labels12; // labels for particles satisfying both branches + labels1 = new Int_t*[nSignals]; + labels2 = new Int_t*[nSignals]; + labels12 = new Int_t*[nSignals]; + Int_t* indexes1=new Int_t[nSignals]; + Int_t* indexes2=new Int_t[nSignals]; + Int_t* indexes12=new Int_t[nSignals]; + for(Int_t isig=0;isigGetNMCTracks()]; + *(labels2+isig) = new Int_t[dieMC->GetNMCTracks()]; + *(labels12+isig) = new Int_t[dieMC->GetNMCTracks()]; + for(Int_t ip=0; ipGetNMCTracks();++ip) { + labels1[isig][ip] = -1; + labels2[isig][ip] = -1; + labels12[isig][ip] = -1; + } + indexes1[isig]=0; + indexes2[isig]=0; + indexes12[isig]=0; + } + + Bool_t truth1=kFALSE; + Bool_t truth2=kFALSE; + // loop over the MC tracks + for(Int_t ipart=0; ipartGetNMCTracks(); ++ipart) { + for(Int_t isig=0; isigAt(isig))->GetFillPureMCStep()) continue; + + truth1 = dieMC->IsMCTruth(ipart, (AliDielectronSignalMC*)fSignalsMC->At(isig), 1); + truth2 = dieMC->IsMCTruth(ipart, (AliDielectronSignalMC*)fSignalsMC->At(isig), 2); + + // particles satisfying both branches are treated separately to avoid double counting during pairing + if(truth1 && truth2) { + labels12[isig][indexes12[isig]] = ipart; + ++indexes12[isig]; + } + else { + if(truth1) { + labels1[isig][indexes1[isig]] = ipart; + ++indexes1[isig]; + } + if(truth2) { + labels2[isig][indexes2[isig]] = ipart; + ++indexes2[isig]; + } + } + } + } // end loop over MC particles + + // Do the pairing and fill the CF container with pure MC info + for(Int_t isig=0; isigFillMC(labels1[isig][i1], labels2[isig][i2], isig); + } + } + // mix the particles which satisfy both branches + for(Int_t i1=0;i1FillMC(labels12[isig][i1], labels12[isig][i2], isig); + } + } + } // end loop over signals + + // release the memory + for(Int_t isig=0;isigGetHistogramList()->FindObject(className.Data())) continue; + Int_t ntracks=tracks[i]->GetEntriesFast(); + for (Int_t itrack=0; itrackUncheckedAt(itrack), values); + fHistos->FillClass(className, AliDielectronVarManager::kNMaxValues, values); + } + } +} + + +//________________________________________________________________ +void AliDielectronTaku::FillHistogramsMC(const AliMCEvent *ev) +{ + // + // Fill Histogram information for MCEvents + // + + Double_t values[AliDielectronVarManager::kNMaxValues]; + // Fill event information + AliDielectronVarManager::Fill(ev, values); + if (fHistos->GetHistogramList()->FindObject("MCEvent")) + fHistos->FillClass("MCEvent", AliDielectronVarManager::kNMaxValues, values); +} + + +//________________________________________________________________ +void AliDielectronTaku::FillHistograms(const AliVEvent *ev) +{ + // + // Fill Histogram information for tracks and pairs + // + + TString className,className2; + Double_t values[AliDielectronVarManager::kNMaxValues]; + //Fill event information + AliDielectronVarManager::Fill(ev, values); + if (fHistos->GetHistogramList()->FindObject("Event")){ + fHistos->FillClass("Event", AliDielectronVarManager::kNMaxValues, values); + + } + + //Fill track information, separately for the track array candidates + for (Int_t i=0; i<4; ++i){ + className.Form("Track_%s",fgkTrackClassNames[i]); + if (!fHistos->GetHistogramList()->FindObject(className.Data())) continue; + Int_t ntracks=fTracks[i].GetEntriesFast(); + for (Int_t itrack=0; itrackFillClass(className, AliDielectronVarManager::kNMaxValues, values); + } + } + + //Fill Pair information, separately for all pair candidate arrays and the legs + TObjArray arrLegs(100); + for (Int_t i=0; i<10; ++i){ + className.Form("Pair_%s",fgkPairClassNames[i]); + className2.Form("Track_Legs_%s",fgkPairClassNames[i]); + Bool_t pairClass=fHistos->GetHistogramList()->FindObject(className.Data())!=0x0; + Bool_t legClass=fHistos->GetHistogramList()->FindObject(className2.Data())!=0x0; + if (!pairClass&&!legClass) continue; + Int_t ntracks=PairArray(i)->GetEntriesFast(); + for (Int_t ipair=0; ipair(PairArray(i)->UncheckedAt(ipair)); + + //fill pair information + if (pairClass){ + AliDielectronVarManager::Fill(pair, values); + fHistos->FillClass(className, AliDielectronVarManager::kNMaxValues, values); + } + + //fill leg information, don't fill the information twice + if (legClass){ + AliVParticle *d1=pair->GetFirstDaughter(); + AliVParticle *d2=pair->GetSecondDaughter(); + if (!arrLegs.FindObject(d1)){ + AliDielectronVarManager::Fill(d1, values); + fHistos->FillClass(className2, AliDielectronVarManager::kNMaxValues, values); + arrLegs.Add(d1); + } + if (!arrLegs.FindObject(d2)){ + AliDielectronVarManager::Fill(d2, values); + fHistos->FillClass(className2, AliDielectronVarManager::kNMaxValues, values); + arrLegs.Add(d2); + } + } + } + if (legClass) arrLegs.Clear(); + } + +} +//________________________________________________________________ +void AliDielectronTaku::FillHistogramsPair(AliDielectronPair *pair,Bool_t fromPreFilter/*=kFALSE*/) +{ + // + // Fill Histogram information for pairs and the track in the pair + // NOTE: in this funtion the leg information may be filled multiple + // times. This funtion is used in the track rotation pairing + // and those legs are not saved! + // + TString className,className2; + Double_t values[AliDielectronVarManager::kNMaxValues]; + + //Fill Pair information, separately for all pair candidate arrays and the legs + TObjArray arrLegs(100); + const Int_t type=pair->GetType(); + if (fromPreFilter) { + className.Form("RejPair_%s",fgkPairClassNames[type]); + className2.Form("RejTrack_%s",fgkPairClassNames[type]); + } else { + className.Form("Pair_%s",fgkPairClassNames[type]); + className2.Form("Track_Legs_%s",fgkPairClassNames[type]); + } + + Bool_t pairClass=fHistos->GetHistogramList()->FindObject(className.Data())!=0x0; + Bool_t legClass=fHistos->GetHistogramList()->FindObject(className2.Data())!=0x0; + + //fill pair information + if (pairClass){ + AliDielectronVarManager::Fill(pair, values); + fHistos->FillClass(className, AliDielectronVarManager::kNMaxValues, values); + } + + if (legClass){ + AliVParticle *d1=pair->GetFirstDaughter(); + AliDielectronVarManager::Fill(d1, values); + fHistos->FillClass(className2, AliDielectronVarManager::kNMaxValues, values); + + AliVParticle *d2=pair->GetSecondDaughter(); + AliDielectronVarManager::Fill(d2, values); + fHistos->FillClass(className2, AliDielectronVarManager::kNMaxValues, values); + } +} + +//________________________________________________________________ +void AliDielectronTaku::FillTrackArrays(AliVEvent * const ev, Int_t eventNr) +{ + // + // select tracks and fill track candidate arrays + // eventNr = 0: First event, use track arrays 0 and 1 + // eventNr = 1: Second event, use track arrays 2 and 3 + // + + Int_t ntracks=ev->GetNumberOfTracks(); + UInt_t selectedMask=(1<GetEntries())-1; + for (Int_t itrack=0; itrackGetTrack(itrack); + //TODO: temporary solution, perhaps think about a better implementation + // This is needed to use AliESDpidCuts, which relies on the ESD event + // is set as a AliESDtrack attribute... somehow ugly! + if (ev->IsA()==AliESDEvent::Class()){ + AliESDtrack *track=static_cast(particle); + track->SetESDEvent(static_cast(ev)); //only in trunk... + } + + //apply track cuts + if (fTrackFilter.IsSelected(particle)!=selectedMask) continue; + + //fill selected particle into the corresponding track arrays + Short_t charge=particle->Charge(); + if (charge>0){ + fTracks[eventNr*2].Add(particle); + }else if (charge<0){ + fTracks[eventNr*2+1].Add(particle); + } + } +} + +//________________________________________________________________ +void AliDielectronTaku::PairPreFilter(Int_t arr1, Int_t arr2, TObjArray &arrTracks1, TObjArray &arrTracks2) +{ + //cout<<"PairPreFilter"<GetEntries())-1; + UInt_t selectedMaskPair=(1<GetEntries())-1; + + for (Int_t itrack1=0; itrack1(arrTracks1.UncheckedAt(itrack1)); + AliVTrack *track2=static_cast(arrTracks2.UncheckedAt(itrack2)); + if (!track1 || !track2) continue; + //create the pair + candidate.SetTracks(track1, fPdgLeg1, + track2, fPdgLeg2); + candidate.SetType(pairIndex); + candidate.SetLabel(AliDielectronMC::Instance()->GetLabelMotherWithPdg(&candidate,fPdgMother)); + //relate to the production vertex + //if (AliDielectronVarManager::GetKFVertex()) candidate.SetProductionVertex(*AliDielectronVarManager::GetKFVertex()); + + //pair cuts + UInt_t cutMask=fPairPreFilter.IsSelected(&candidate); + //cout<Fill(selectedMaskPair+1 ,&candidate); + accepted=kTRUE; + if (fHistos) FillHistogramsPair(&candidate,kTRUE); + + ///////////////////////////////////////////////////////// + //remove the tracks from the Track arrays + arrTracks2.AddAt(0x0,itrack2); + //in case of like sign remove the track from both arrays! + if (arr1==arr2) arrTracks1.AddAt(0x0, itrack2); + } + if ( accepted ) arrTracks1.AddAt(0x0,itrack1); //kTRUE + } + + //compress the track arrays + arrTracks1.Compress(); + arrTracks2.Compress(); + + //apply leg cuts after the pre filter + if ( fPairPreFilterLegs.GetCuts()->GetEntries()>0 ) { + selectedMask=(1<GetEntries())-1; + //loop over tracks from array 1 + for (Int_t itrack=0; itrackGetEntries()>0 )) PairPreFilter(arr1, arr2, arrTracks1, arrTracks2); + + Int_t pairIndex=GetPairIndex(arr1,arr2); + + Int_t ntrack1=arrTracks1.GetEntriesFast(); + Int_t ntrack2=arrTracks2.GetEntriesFast(); + + AliDielectronPair *candidate=new AliDielectronPair; + + UInt_t selectedMask=(1<GetEntries())-1; + + for (Int_t itrack1=0; itrack1SetTracks(static_cast(arrTracks1.UncheckedAt(itrack1)), fPdgLeg1, + static_cast(arrTracks2.UncheckedAt(itrack2)), fPdgLeg2); + candidate->SetType(pairIndex); + candidate->SetLabel(AliDielectronMC::Instance()->GetLabelMotherWithPdg(candidate,fPdgMother)); + + //pair cuts + UInt_t cutMask=fPairFilter.IsSelected(candidate); + + //CF manager for the pair + if (fCfManagerPair) fCfManagerPair->Fill(cutMask,candidate); + + //apply cut + if (cutMask!=selectedMask) continue; + + //add the candidate to the candidate array + PairArray(pairIndex)->Add(candidate); + //get a new candidate + candidate=new AliDielectronPair; + } + } + //delete the surplus candidate + delete candidate; +} + +//________________________________________________________________ +void AliDielectronTaku::FillPairArrayTR() +{ + // + // select pairs and fill pair candidate arrays + // + UInt_t selectedMask=(1<GetEntries())-1; + + while ( fTrackRotator->NextCombination() ){ + AliDielectronPair candidate; + candidate.SetTracks(&fTrackRotator->GetKFTrackP(), &fTrackRotator->GetKFTrackN(), + fTrackRotator->GetVTrackP(),fTrackRotator->GetVTrackN()); + candidate.SetType(kEv1PMRot); + + //pair cuts + UInt_t cutMask=fPairFilter.IsSelected(&candidate); + + //CF manager for the pair + if (fCfManagerPair) fCfManagerPair->Fill(cutMask,&candidate); + + //apply cut + if (cutMask==selectedMask&&fHistos) FillHistogramsPair(&candidate); + } +} + +//________________________________________________________________ +void AliDielectronTaku::FillDebugTree() +{ + // + // Fill Histogram information for tracks and pairs + // + + //Fill Debug tree + for (Int_t i=0; i<10; ++i){ + Int_t ntracks=PairArray(i)->GetEntriesFast(); + for (Int_t ipair=0; ipairFill(static_cast(PairArray(i)->UncheckedAt(ipair))); + } + } +} + +//________________________________________________________________ +void AliDielectronTaku::SaveDebugTree() +{ + // + // delete the debug tree, this will also write the tree + // + if (fDebugTree) fDebugTree->DeleteStreamer(); +} + + +//__________________________________________________________________ +void AliDielectronTaku::AddSignalMC(AliDielectronSignalMC* signal) { + // + // Add an MC signal to the signals list + // + if(!fSignalsMC) { + fSignalsMC = new TObjArray(); + fSignalsMC->SetOwner(); + } + fSignalsMC->Add(signal); +} + +//________________________________________________________________ +void AliDielectronTaku::FillTree(const AliVEvent *ev) +{ + // + // Fill Histogram information for tracks and pairs + // + + Double_t values[AliDielectronVarManager::kNMaxValues]; + AliDielectronVarManager::Fill(ev, values); + //Fill track information, separately for the track array candidates + for (Int_t i=0; i<2; ++i){ //same event in different charge + Int_t ntracks=fTracks[i].GetEntriesFast(); + for (Int_t itrack=0; itrackFillTree(AliDielectronVarManager::kNMaxValues, values); + fTree->GetSingleTree()->Fill(); + } + } + + for(int i=0;i +#include + +#include +#include + +#include "AliDielectronHistosTaku.h" + +class AliVEvent; +class AliMCEvent; +class THashList; +class AliDielectronCF; +class AliDielectronDebugTreeTaku; +class AliDielectronTrackRotator; +class AliDielectronPair; +class AliDielectronSignalMC; + +//________________________________________________________________ +class AliDielectronTaku : public TNamed { + +public: + enum EPairType { kEv1PP=0, kEv1PM, kEv1MM, + kEv1PEv2P, kEv1MEv2P, kEv2PP, + kEv1PEv2M, kEv1MEv2M, kEv2PM, + kEv2MM, kEv1PMRot }; + enum ELegType { kEv1P, kEv1M, kEv2P, kEv2M }; + + AliDielectronTaku(); + AliDielectronTaku(const char* name, const char* title); + virtual ~AliDielectronTaku(); + + void Init(); + + void Process(AliVEvent *ev1, AliVEvent *ev2=0); + + const AliAnalysisFilter& GetEventFilter() const { return fEventFilter; } + const AliAnalysisFilter& GetTrackFilter() const { return fTrackFilter; } + const AliAnalysisFilter& GetPairFilter() const { return fPairFilter; } + + AliAnalysisFilter& GetEventFilter() { return fEventFilter; } + AliAnalysisFilter& GetTrackFilter() { return fTrackFilter; } + AliAnalysisFilter& GetPairFilter() { return fPairFilter; } + AliAnalysisFilter& GetPairPreFilter() { return fPairPreFilter; } + AliAnalysisFilter& GetPairPreFilterLegs() { return fPairPreFilterLegs; } + + void SetMotherPdg( Int_t pdgMother ) { fPdgMother=pdgMother; } + void SetLegPdg(Int_t pdgLeg1, Int_t pdgLeg2) { fPdgLeg1=pdgLeg1; fPdgLeg2=pdgLeg2; } + Int_t GetMotherPdg() const { return fPdgMother; } + Int_t GetLeg1Pdg() const { return fPdgLeg1; } + Int_t GetLeg2Pdg() const { return fPdgLeg2; } + + void SetNoPairing(Bool_t noPairing=kTRUE) { fNoPairing=noPairing; } + const TObjArray* GetTrackArray(Int_t i) const {return (i>=0&&i<4)?&fTracks[i]:0;} + const TObjArray* GetPairArray(Int_t i) const {return (i>=0&&i<10)? + static_cast(fPairCandidates->UncheckedAt(i)):0;} + + TObjArray** GetPairArraysPointer() { return &fPairCandidates; } + + void SetHistogramManager(AliDielectronHistosTaku * const histos) { fHistos=histos; } + void SetTreeManager(AliDielectronHistosTaku * const histos) { fTree=histos; } + AliDielectronHistosTaku* GetHistoManager() const { return fHistos; } + const THashList * GetHistogramList() const { return fHistos?fHistos->GetHistogramList():0x0; } + AliDielectronHistosTaku* GetTreeManager() const { return fTree; } + const THashList * GetTreeList() const { return fTree?fTree->GetTreeList():0x0; } + TTree *GetSingleTree(AliDielectronHistosTaku *fTreeHisto) const {return fTreeHisto->GetSingleTree();} + + Bool_t HasCandidates() const { return GetPairArray(1)?GetPairArray(1)->GetEntriesFast()>0:0; } + Bool_t HasCandidatesLikeSign() const { + return (GetPairArray(0)&&GetPairArray(2)) ? (GetPairArray(0)->GetEntriesFast()>0 || GetPairArray(2)->GetEntriesFast()>0) : 0; + } + + void SetCFManagerPair(AliDielectronCF * const cf) { fCfManagerPair=cf; } + AliDielectronCF* GetCFManagerPair() const { return fCfManagerPair; } + + void SetPreFilterUnlikeOnly(Bool_t setValue=kTRUE){fPreFilterUnlikeOnly=setValue;}; + void SetPreFilterAllSigns(Bool_t setValue=kTRUE){fPreFilterAllSigns=setValue;}; + + void SetTrackRotator(AliDielectronTrackRotator * const rot) { fTrackRotator=rot; } + AliDielectronTrackRotator* GetTrackRotator() const { return fTrackRotator; } + + void SetHasMC(Bool_t hasMC) { fHasMC = hasMC; } + Bool_t GetHasMC() const { return fHasMC; } + + void AddSignalMC(AliDielectronSignalMC* signal); + + void SetDebugTree(AliDielectronDebugTreeTaku * const tree) { fDebugTree=tree; } + + const TObjArray* GetMCSignals() const { return fSignalsMC; } + static const char* TrackClassName(Int_t i) { return (i>=0&&i<4)?fgkTrackClassNames[i]:""; } + static const char* PairClassName(Int_t i) { return (i>=0&&i<11)?fgkPairClassNames[i]:""; } + + void SaveDebugTree(); + + + Double_t GetVarManagerVariable(Int_t n) const {return fgData[n];} + +private: + + AliAnalysisFilter fEventFilter; // Event cuts + AliAnalysisFilter fTrackFilter; // leg cuts + AliAnalysisFilter fPairPreFilter; // pair prefilter cuts + AliAnalysisFilter fPairPreFilterLegs; // Leg filter after the pair prefilter cuts + AliAnalysisFilter fPairFilter; // pair cuts + + Int_t fPdgMother; // pdg code of mother tracks + Int_t fPdgLeg1; // pdg code leg1 + Int_t fPdgLeg2; // pdg code leg2 + + TObjArray* fSignalsMC; // array of AliDielectronSignalMC + + Bool_t fNoPairing; // if to skip pairing, can be used for track QA only + + AliDielectronHistosTaku *fHistos; // Histogram manager + // Streaming and merging should be handled + // by the analysis framework + + AliDielectronHistosTaku *fTree; // This is for tree + // Streaming and merging should be handled + // by the analysis framework + + + TObjArray fTracks[4]; //! Selected track candidates + // 0: Event1, positive particles + // 1: Event1, negative particles + // 2: Event2, positive particles + // 3: Event2, negative particles + + TObjArray *fPairCandidates; //! Pair candidate arrays + //TODO: better way to store it? TClonesArray? + + AliDielectronCF *fCfManagerPair;//Correction Framework Manager for the Pair + AliDielectronTrackRotator *fTrackRotator; //Track rotator + AliDielectronDebugTreeTaku *fDebugTree; // Debug tree output + + Bool_t fPreFilterUnlikeOnly; //Apply PreFilter either in +- or to ++/--/+- individually + Bool_t fPreFilterAllSigns; //Apply PreFilter find in ++/--/+- and remove from all + Bool_t fHasMC; //If we run with MC, at the moment only needed in AOD + + void FillTrackArrays(AliVEvent * const ev, Int_t eventNr=0); + void PairPreFilter(Int_t arr1, Int_t arr2, TObjArray &arrTracks1, TObjArray &arrTracks2); + void FillPairArrays(Int_t arr1, Int_t arr2); + void FillPairArrayTR(); + + Int_t GetPairIndex(Int_t arr1, Int_t arr2) const {return arr1>=arr2?arr1*(arr1+1)/2+arr2:arr2*(arr2+1)/2+arr1;} + + void InitPairCandidateArrays(); + void ClearArrays(); + + TObjArray* PairArray(Int_t i); + + static const char* fgkTrackClassNames[4]; //Names for track arrays + static const char* fgkPairClassNames[11]; //Names for pair arrays + + void ProcessMC(); + + void FillHistograms(const AliVEvent *ev); + void FillTree(const AliVEvent *ev); + void FillHistogramsMC(const AliMCEvent *ev); + void FillHistogramsPair(AliDielectronPair *pair,Bool_t fromPreFilter=kFALSE); + void FillHistogramsTracks(TObjArray **tracks); + + void FillDebugTree(); + + AliDielectronTaku(const AliDielectronTaku &c); + AliDielectronTaku &operator=(const AliDielectronTaku &c); + + Double_t fgData[AliDielectronVarManager::kNMaxValues]; + + + ClassDef(AliDielectronTaku,4); +}; + +inline void AliDielectronTaku::InitPairCandidateArrays() +{ + // + // initialise all pair candidate arrays + // + fPairCandidates->SetOwner(); + for (Int_t i=0;i<10;++i){ + TObjArray *arr=new TObjArray; + fPairCandidates->AddAt(arr,i); + arr->SetOwner(); + } +} + +inline TObjArray* AliDielectronTaku::PairArray(Int_t i) +{ + // + // for internal use only: unchecked return of track array for fast access + // + return static_cast(fPairCandidates->UncheckedAt(i)); +} + +inline void AliDielectronTaku::ClearArrays() +{ + // + // Reset the Arrays + // + for (Int_t i=0;i<4;++i){ + fTracks[i].Clear(); + } + for (Int_t i=0;i<10;++i){ + PairArray(i)->Delete(); + } + + + + +} + +#endif diff --git a/PWGDQ/dielectron/TakuAlberica/single/AliDielectronTaku_cxx.d b/PWGDQ/dielectron/TakuAlberica/single/AliDielectronTaku_cxx.d new file mode 100644 index 00000000000..01984257829 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/AliDielectronTaku_cxx.d @@ -0,0 +1,166 @@ + +# DO NOT DELETE + +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TString.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Riosfwd.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/RConfig.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/RVersion.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMathBase.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Rtypes.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/DllImport.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Rtypeinfo.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/snprintf.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/strlcpy.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGenericClassInfo.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TSchemaHelper.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TList.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TSeqCollection.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TCollection.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TObject.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TStorage.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVersionCheck.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TBuffer.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TIterator.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMath.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TError.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDEvent.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TClonesArray.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TObjArray.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TTree.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TBranch.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TNamed.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttFill.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TDataType.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TDictionary.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/Property.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttLine.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAttMarker.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayD.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArray.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayI.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TClass.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TObjString.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVirtualTreePlayer.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayF.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVEvent.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TGeoMatrix.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVHeader.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVParticle.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVVertex.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVCluster.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TLorentzVector.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVector3.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVector2.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrix.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixF.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixT.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixTBase.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixFBasefwd.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDBasefwd.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVectorFfwd.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVectorDfwd.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixTUtils.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixFfwd.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixFUtils.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixFUtilsfwd.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TRotation.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVCaloCells.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TRefArray.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TProcessID.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDCaloTrigger.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDRun.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDHeader.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTriggerScalersESD.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTriggerScalersRecordESD.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTimeStamp.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDTZERO.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDZDC.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVZDC.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDACORDE.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDtrack.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TBits.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliExternalTrackParam.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVTrack.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliPID.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDfriendTrack.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTPCdEdxInfo.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDVertex.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVertex.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDCaloCluster.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TArrayS.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliLog.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDCaloCells.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTOFHeader.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDVZERO.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVVZERO.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronPair.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TRef.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliKFParticle.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliKFParticleBase.h +./AliDielectronTaku_cxx.so: AliDielectronHistosTaku.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/THashList.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronVarManager.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODEvent.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODHeader.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODVertex.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODRedCov.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliCentrality.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliEventplane.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODTrack.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODPid.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODv0.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODRecoDecay.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODcascade.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODTracklets.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODJet.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODCaloCells.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODCaloCluster.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODCluster.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODCaloTrigger.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODPmdCluster.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODFmdCluster.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODDimuon.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODTZERO.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODVZERO.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODZDC.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliMCEvent.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliMCParticle.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TParticle.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TAtt3D.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TParticlePDG.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTrackReference.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliKFVertex.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODMCParticle.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TExMap.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliESDpid.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliPIDResponse.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliITSPIDResponse.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTPCPIDResponse.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTRDPIDResponse.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliTOFPIDResponse.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliEMCALPIDResponse.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVectorD.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TVectorT.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixTSym.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixTSparse.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixD.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDfwd.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDUtils.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDUtilsfwd.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDSym.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDSymfwd.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDSparse.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/TMatrixDSparsefwd.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAODpidUtil.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronMC.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronSignalMC.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronPID.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAnalysisCuts.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliVCuts.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronHelper.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronCF.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/PWG3/dielectron/AliDielectronTrackRotator.h +./AliDielectronTaku_cxx.so: AliDielectronDebugTreeTaku.h AliDielectronTaku.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/AliRoot/v5-02-16-AN/v5-02-16-AN/include/AliAnalysisFilter.h +./AliDielectronTaku_cxx.so: /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/cintdictversion.h /home/atoia/alice/packages/VO_ALICE/ROOT/v5-30-03-1/v5-30-03-1/include/RVersion.h +AliDielectronTaku_cxx__ROOTBUILDVERSION= 5.30/03 diff --git a/PWGDQ/dielectron/TakuAlberica/single/ConfigJpsi2eeDataTaku.C b/PWGDQ/dielectron/TakuAlberica/single/ConfigJpsi2eeDataTaku.C new file mode 100644 index 00000000000..356a1e60d53 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/ConfigJpsi2eeDataTaku.C @@ -0,0 +1,411 @@ +void SetupTrackCutsDieleData(AliDielectronTaku *diele, Int_t cutDefinition, Bool_t isAOD); +void SetupPairCutsDieleData(AliDielectronTaku *diele, Int_t cutDefinition, Bool_t isAOD); +void InitHistogramsDieleData(AliDielectronTaku *diele, Int_t cutDefinition, Bool_t isAOD); +void InitTreesDieleData(AliDielectronTaku *diele, Int_t cutDefinition, Bool_t isAOD); +void InitCFDieleData(AliDielectronTaku *diele, Int_t cutDefinition, Bool_t isAOD); + +AliESDtrackCuts *SetupESDtrackCutsDieleData(Int_t cutDefinition); + +//TString namesDieleData=("basicQ+SPDfirst+pt>1+PID; basicQ+SPDany+pt>1+PID"); +TString namesDieleData=("basicQ+SPDfirst+pt>1+PID"); + +TObjArray *arrNamesDieleData=namesDieleData.Tokenize("; "); + +const Int_t nDie=arrNamesDieleData->GetEntries(); + +AliDielectronTaku* ConfigJpsi2ee(Int_t cutDefinition, Bool_t isAOD=kFALSE) +{ + // + //cout<<" Setup the instance of AliDielectronTaku "<GetEntriesFast()){ + name=arrNamesDieleData->At(cutDefinition)->GetName(); + } + AliDielectronTaku *diele = new AliDielectronTaku(Form("%s",name.Data()), + Form("Track cuts: %s",name.Data())); + + // cut setup + SetupTrackCutsDieleData(diele, cutDefinition, isAOD); + SetupPairCutsDieleData(diele, cutDefinition, isAOD); + + // + // histogram setup + // only if an AliDielectronHistos object is attached to the + // dielelectron framework histograms will be filled + // + InitHistogramsDieleData(diele, cutDefinition, isAOD); + //InitTreesDieleData(diele, cutDefinition, isAOD); + + // the last definition uses no cuts and only the QA histograms should be filled! +// if (cutDefinitionSetConeAnglePhi(TMath::Pi()); + rot->SetIterations(10); + diele->SetTrackRotator(rot); + return diele; +} + +//______________________________________________________________________________________ +void SetupTrackCutsDieleData(AliDielectronTaku *diele, Int_t cutDefinition, Bool_t isAOD) +{ + // + // Setup the track cuts + // + cout<<" SetupTrackCutsDieleData "<GetTrackFilter().AddCuts(SetupESDtrackCutsDieleData(cutDefinition)); + } else { + AliDielectronTrackCuts *trackCuts=new AliDielectronTrackCuts("trackCuts","trackCuts"); + if (cutDefinition==0) + trackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst); + else if (cutDefinition==1) + trackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny); + trackCuts->SetRequireTPCRefit(kTRUE); + trackCuts->SetRequireITSRefit(kTRUE); + diele->GetTrackFilter().AddCuts(trackCuts); + } + + //Pt cut ---------------------------------------------------------- + + AliDielectronVarCuts *pt = new AliDielectronVarCuts("ptCut","pt cut"); + pt->AddCut(AliDielectronVarManager::kPt,0.2,10.); + pt->AddCut(AliDielectronVarManager::kKinkIndex0,0.); + + //AOD additions since there are no AliESDtrackCuts ----------------- + // + if (isAOD){ + // TPC #clusteres cut + pt->AddCut(AliDielectronVarManager::kNclsTPC,70.,160.); + pt->AddCut(AliDielectronVarManager::kEta,-0.9,0.9); + //TODO: DCA cuts to be investigated!!! +// pt->AddCut(AliDielectronVarManager::kImpactParXY,-1.,1.); +// pt->AddCut(AliDielectronVarManager::kImpactParZ,-3.,3.); + } + diele->GetTrackFilter().AddCuts(pt); + + // PID cuts -------------------------------------------------------- + + AliDielectronPID *pid = new AliDielectronPID("PID10","TPC nSigma |e|<3 + |Pi|>3 + |P|>3 + TOF nSigma |e|<3"); + pid->AddCut(AliDielectronPID::kTPC,AliPID::kElectron,-2.5,3.); + pid->AddCut(AliDielectronPID::kTOF,AliPID::kElectron,-3,3.); + + // pid->AddCut(AliDielectronPID::kTPC,AliPID::kKaon,-1.8.,1.8.,0.,0.,kTRUE); + // pid->AddCut(AliDielectronPID::kTPC,AliPID::kProton,-2.,2.0.,0.,0.,kTRUE); + + //pid->AddCut(AliDielectronPID::kTOF,AliPID::kKaon,-4.,4.,0.,0.,kTRUE); + //pid->AddCut(AliDielectronPID::kTOF,AliPID::kProton,-4.,4.,0.,0.,kTRUE); + + //pid->AddCut(AliDielectronPID::kTPC,AliPID::kPion,-3.,3.,0.,0.,kTRUE); + // pid->AddCut(AliDielectronPID::kTPC,AliPID::kKaon,-1.75.,1.8.,0.,0.,kTRUE); + //pid->AddCut(AliDielectronPID::kTPC,AliPID::kProton,-1.3.,2.0.,0.,0.,kTRUE); + + + + //pid->AddCut(AliDielectronPID::kTPC,AliPID::kPion,-3.,3.); + //pid->AddCut(AliDielectronPID::kTPC,AliPID::kKaon,-3.,3.); + //pid->AddCut(AliDielectronPID::kTPC,AliPID::kProton,-3.,3.); + + //pid->AddCut(AliDielectronPID::kTOF,AliPID::kElectron,-3.,3.); + + //pid->AddCut(AliDielectronPID::kTOF,AliPID::kPion,-3.,3.); + //pid->AddCut(AliDielectronPID::kTOF,AliPID::kKaon,-3.,3.); + //pid->AddCut(AliDielectronPID::kTOF,AliPID::kProton,-3.,3.); + + diele->GetTrackFilter().AddCuts(pid); + +} + +//______________________________________________________________________________________ +void SetupPairCutsDieleData(AliDielectronTaku *diele, Int_t cutDefinition, Bool_t isAOD) +{ + // + // Setup the pair cuts + // + + //Invariant mass and rapidity selection + AliDielectronVarCuts *pairCut=new AliDielectronVarCuts("2AddCut(AliDielectronVarManager::kM,2.,4.); + pairCut->AddCut(AliDielectronVarManager::kY,-0.9,0.9); + //pairCut->AddCut(AliDielectronVarManager::kOpeningAngle, 0, 0.1); + //diele->GetPairFilter().AddCuts(pairCut); + diele->GetPairPreFilter().AddCuts(pairCut); +} + +//______________________________________________________________________________________ +AliESDtrackCuts *SetupESDtrackCutsDieleData(Int_t cutDefinition) +{ + cout<<" SetupESDtrackCutsDieleData "<SetMaxDCAToVertexZ(3.0); + esdTrackCuts->SetMaxDCAToVertexXY(1.0); + + esdTrackCuts->SetEtaRange( -0.9 , 0.9 ); + + esdTrackCuts->SetAcceptKinkDaughters(kFALSE); + esdTrackCuts->SetRequireITSRefit(kTRUE); + esdTrackCuts->SetRequireTPCRefit(kTRUE); + + //esdTrackCuts->SetPtRange(.8,1e30); + esdTrackCuts->SetPtRange(0.2,10); + esdTrackCuts->SetPtRange(0.2,10); + + //esdTrackCuts->SetMinNClustersTPC(120); + esdTrackCuts->SetMinNCrossedRowsTPC(120); + esdTrackCuts->SetMaxChi2PerClusterTPC(4); + esdTrackCuts->SetRequireTPCRefit(kTRUE); + esdTrackCuts->SetRequireITSRefit(kTRUE); + + // default SPD any + esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny); + + if (cutDefinition==0) + esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst); + + return esdTrackCuts; +} + + +//______________________________________________________________________________________ +void InitHistogramsDieleData(AliDielectronTaku *diele, Int_t cutDefinition, Bool_t isAOD) +{ + // + // Initialise the histograms + // + + //Setup histogram Manager + AliDielectronHistosTaku *histos=new AliDielectronHistosTaku(diele->GetName(),diele->GetTitle()); + + //Initialise histogram classes + histos->SetReservedWords("Track;Pair"); + + //Track classes + //to fill also track info from 2nd event loop until 2 + for (Int_t i=0; i<2; ++i){ + histos->AddClass(Form("Track_%s",AliDielectron::TrackClassName(i))); + } + + //Pair classes + // to fill also mixed event histograms loop until 10 + for (Int_t i=0; i<3; ++i){ + histos->AddClass(Form("Pair_%s",AliDielectron::PairClassName(i))); + } + + //legs from pair + for (Int_t i=0; i<3; ++i){ + histos->AddClass(Form("Track_Legs_%s",AliDielectron::PairClassName(i))); + } + //track rotation +// histos->AddClass(Form("Pair_%s",PairClassName(AliDielectron::kEv1PMRot))); +// histos->AddClass(Form("Track_Legs_%s",PairClassName(AliDielectron::kEv1PMRot))); + + + //add histograms to event class + if (cutDefinition==0) { + histos->AddClass("Event"); + histos->UserHistogram("Event","VtxZ","Vertex Z;Z[cm]",300,-15.,15.,AliDielectronVarManager::kZvPrim); + } + + //add histograms to Track classes + histos->UserHistogram("Track","Pt","Pt;Pt [GeV];#tracks",400,0,20.,AliDielectronVarManager::kPt); + histos->UserHistogram("Track","TPCnCls","Number of Clusters TPC;TPC number clusteres;#tracks",160,-0.5,159.5,AliDielectronVarManager::kNclsTPC); + + histos->UserHistogram("Track","dXY","dXY;dXY [cm];#tracks",500,-1.,1.,AliDielectronVarManager::kImpactParXY); + histos->UserHistogram("Track","dZ","dZ;dZ [cm];#tracks",600,-3.,3.,AliDielectronVarManager::kImpactParZ); + histos->UserHistogram("Track","Eta_Phi","Eta Phi Map; Eta; Phi;#tracks", + 100,-1,1,144,0,6.285,AliDielectronVarManager::kEta,AliDielectronVarManager::kPhi); + + histos->UserHistogram("Track","dEdx_P","dEdx;P [GeV];TPC signal (arb units);#tracks", + 200,0.2,20.,100,0.,200.,AliDielectronVarManager::kPIn, + AliDielectronVarManager::kTPCsignal,kTRUE); + histos->UserHistogram("Track","TPCnSigmaEle_P","TPC number of sigmas Electrons;P [GeV];TPC number of sigmas Electrons;#tracks", + 200,0.2,20.,100,-10.,10.,AliDielectronVarManager::kPIn,AliDielectronVarManager::kTPCnSigmaEle,kTRUE); + + + histos->UserHistogram("Track","TOF_Beta_P","TOF beta;P [GeV];TOF beta;#tracks", + 200,0.2,20.,100,0.,1.2.,AliDielectronVarManager::kPIn,AliDielectronVarManager::kTOFbeta,kTRUE); + + + histos->UserHistogram("Track","TOFnSigmaPi_P","TOF nSigmaPi;P [GeV];TOF beta;#tracks", + 200,0.2,20.,100,-10.,10.,AliDielectronVarManager::kPIn,AliDielectronVarManager::kTOFnSigmaPio,kTRUE); + histos->UserHistogram("Track","TOFnSigmaK_P","TOF nSigmaK;P [GeV];TOF beta;#tracks", + 200,0.2,20.,100,-10.,10.,AliDielectronVarManager::kPIn,AliDielectronVarManager::kTOFnSigmaKao,kTRUE); + histos->UserHistogram("Track","TOFnSigmaPr_P","TOF nSigmaPr;P [GeV];TOF beta;#tracks", + 200,0.2,20.,100,-10.,10.,AliDielectronVarManager::kPIn,AliDielectronVarManager::kTOFnSigmaPro,kTRUE); + + + + //add histograms to Pair classes + histos->UserHistogram("Pair","InvMass","Inv.Mass;Inv. Mass [GeV];#pairs", + 201,-.01,4.01,AliDielectronVarManager::kM); + histos->UserHistogram("Pair","Rapidity","Rapidity;Rapidity;#pairs", + 100,-1.,1.,AliDielectronVarManager::kY); + histos->UserHistogram("Pair","OpeningAngle","Opening angle;angle", + 100,0.,3.15,AliDielectronVarManager::kOpeningAngle); + + diele->SetHistogramManager(histos); +} + + +void InitCFDieleData(AliDielectronTaku *diele, Int_t cutDefinition, Bool_t isAOD) +{ + // + // Setupd the CF Manager if needed + // + + AliDielectronCF *cf=new AliDielectronCF(diele->GetName(),diele->GetTitle()); + + //pair variables + cf->AddVariable(AliDielectronVarManager::kPt,"0.0, 1.0, 2.0, 3.0, 5., 7.0, 10.0, 100.0"); + + cf->AddVariable(AliDielectronVarManager::kY,"-5,-1,-0.9,-0.8,-0.7,-0.5,-0.3,0.3,0.5,0.7,0.8,0.9,1.0,5"); + cf->AddVariable(AliDielectronVarManager::kM,125,0.,125*.04); //40Mev Steps + cf->AddVariable(AliDielectronVarManager::kPairType,"-0.5,0.5,1.5,2.5"); + cf->AddVariable(AliDielectronVarManager::kThetaHE, "-2.0, -1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.75, 1.0, 2.0"); + cf->AddVariable(AliDielectronVarManager::kThetaCS, "-2.0, -1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.75, 1.0, 2.0"); + //leg variables + cf->AddVariable(AliDielectronVarManager::kPt,"0.0, 0.8, 0.9, 0.95, 1.0, 1.05, 1.1, 1.2, 100.0",kTRUE); + cf->AddVariable(AliDielectronVarManager::kNclsTPC,"0, 70, 75, 80, 85, 90, 100, 120, 160",kTRUE); + cf->AddVariable(AliDielectronVarManager::kEta,"-5,-1,-0.9,-0.85,-0.8,-0.75,0.75,0.8,0.85,0.9,1.0,5",kTRUE); + +// cf->AddVariable(AliDielectronVarManager::kTPCnSigmaEle,"-2.5,-2,-1.5,-1,-0.5,4.",kTRUE); + cf->AddVariable(AliDielectronVarManager::kTPCnSigmaPio,"3.,3.5,4.,100",kTRUE); + cf->AddVariable(AliDielectronVarManager::kTPCnSigmaPro,"3.,3.5,4.,100",kTRUE); + + //event variables + cf->AddVariable(AliDielectronVarManager::kNaccTrcklts,"0.0, 9.0, 17.0, 25.0, 36.0, 55.0, 500.0"); + + if (!isAOD){ + Bool_t hasMC=(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()!=0x0); + if (hasMC){ + cf->AddVariable(AliDielectronVarManager::kPdgCode,10000,-5000.5,4999.5,kTRUE); + cf->AddVariable(AliDielectronVarManager::kPdgCodeMother,10000,-5000.5,4999.5,kTRUE); + cf->AddVariable(AliDielectronVarManager::kPdgCodeGrandMother,10000,-5000.5,4999.5,kTRUE); + } + } + //only in this case write MC truth info + if (cutDefinition==0){ + cf->SetStepForMCtruth(); + } + + diele->SetCFManagerPair(cf); + +} + +//______________________________________________________________________________________ +void InitTreesDieleData(AliDielectronTaku *diele, Int_t cutDefinition, Bool_t isAOD) +{ + + //Setup histogram Manager + AliDielectronHistosTaku *histos=new AliDielectronHistosTaku(diele->GetName(),diele->GetTitle()); + histos->UserTree("tree","sinlge tree"); + + histos->SetReserveVariableInTree(AliDielectronVarManager::kPx); + histos->SetReserveVariableInTree(AliDielectronVarManager::kPy); + histos->SetReserveVariableInTree(AliDielectronVarManager::kPz); + histos->SetReserveVariableInTree(AliDielectronVarManager::kPt); + histos->SetReserveVariableInTree(AliDielectronVarManager::kP); + histos->SetReserveVariableInTree(AliDielectronVarManager::kXv); + histos->SetReserveVariableInTree(AliDielectronVarManager::kYv); + histos->SetReserveVariableInTree(AliDielectronVarManager::kZv); + histos->SetReserveVariableInTree(AliDielectronVarManager::kOneOverPt); + histos->SetReserveVariableInTree(AliDielectronVarManager::kPhi); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTheta); + histos->SetReserveVariableInTree(AliDielectronVarManager::kEta); + histos->SetReserveVariableInTree(AliDielectronVarManager::kY); + histos->SetReserveVariableInTree(AliDielectronVarManager::kE); + histos->SetReserveVariableInTree(AliDielectronVarManager::kM); + histos->SetReserveVariableInTree(AliDielectronVarManager::kCharge); + histos->SetReserveVariableInTree(AliDielectronVarManager::kNclsITS); + histos->SetReserveVariableInTree(AliDielectronVarManager::kNclsTPC); + histos->SetReserveVariableInTree(AliDielectronVarManager::kNclsTPCiter1); + histos->SetReserveVariableInTree(AliDielectronVarManager::kNFclsTPC); + histos->SetReserveVariableInTree(AliDielectronVarManager::kNFclsTPCr); + histos->SetReserveVariableInTree(AliDielectronVarManager::kNFclsTPCrFrac); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTPCsignalN); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTPCsignalNfrac); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTPCchi2Cl); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTrackStatus); + histos->SetReserveVariableInTree(AliDielectronVarManager::kNclsTRD); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTRDntracklets); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTRDpidQuality); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTRDprobEle); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTRDprobPio); + histos->SetReserveVariableInTree(AliDielectronVarManager::kImpactParXY); + histos->SetReserveVariableInTree(AliDielectronVarManager::kImpactParZ); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTrackLength); + histos->SetReserveVariableInTree(AliDielectronVarManager::kPdgCode); + histos->SetReserveVariableInTree(AliDielectronVarManager::kPdgCodeMother); + histos->SetReserveVariableInTree(AliDielectronVarManager::kPdgCodeGrandMother); + histos->SetReserveVariableInTree(AliDielectronVarManager::kNumberOfDaughters); + histos->SetReserveVariableInTree(AliDielectronVarManager::kHaveSameMother); + histos->SetReserveVariableInTree(AliDielectronVarManager::kIsJpsiPrimary); + histos->SetReserveVariableInTree(AliDielectronVarManager::kITSsignal); + histos->SetReserveVariableInTree(AliDielectronVarManager::kITSsignalSSD1); + histos->SetReserveVariableInTree(AliDielectronVarManager::kITSsignalSSD2); + histos->SetReserveVariableInTree(AliDielectronVarManager::kITSsignalSDD1); + histos->SetReserveVariableInTree(AliDielectronVarManager::kITSsignalSDD2); + histos->SetReserveVariableInTree(AliDielectronVarManager::kITSclusterMap); + histos->SetReserveVariableInTree(AliDielectronVarManager::kITSnSigmaEle); + histos->SetReserveVariableInTree(AliDielectronVarManager::kITSnSigmaPio); + histos->SetReserveVariableInTree(AliDielectronVarManager::kITSnSigmaMuo); + histos->SetReserveVariableInTree(AliDielectronVarManager::kITSnSigmaKao); + histos->SetReserveVariableInTree(AliDielectronVarManager::kITSnSigmaPro); + histos->SetReserveVariableInTree(AliDielectronVarManager::kPIn); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTPCsignal); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTOFsignal); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTOFbeta); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTPCnSigmaEle); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTPCnSigmaPio); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTPCnSigmaMuo); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTPCnSigmaKao); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTPCnSigmaPro); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTOFnSigmaEle); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTOFnSigmaPio); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTOFnSigmaMuo); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTOFnSigmaKao); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTOFnSigmaPro); + histos->SetReserveVariableInTree(AliDielectronVarManager::kKinkIndex0); + histos->SetReserveVariableInTree(AliDielectronVarManager::kChi2NDF); + histos->SetReserveVariableInTree(AliDielectronVarManager::kDecayLength); + histos->SetReserveVariableInTree(AliDielectronVarManager::kR); + histos->SetReserveVariableInTree(AliDielectronVarManager::kOpeningAngle); + histos->SetReserveVariableInTree(AliDielectronVarManager::kThetaHE); + histos->SetReserveVariableInTree(AliDielectronVarManager::kPhiHE); + histos->SetReserveVariableInTree(AliDielectronVarManager::kThetaCS); + histos->SetReserveVariableInTree(AliDielectronVarManager::kPhiCS); + histos->SetReserveVariableInTree(AliDielectronVarManager::kLegDist); + histos->SetReserveVariableInTree(AliDielectronVarManager::kLegDistXY); + histos->SetReserveVariableInTree(AliDielectronVarManager::kDeltaEta); + histos->SetReserveVariableInTree(AliDielectronVarManager::kDeltaPhi); + histos->SetReserveVariableInTree(AliDielectronVarManager::kMerr); + histos->SetReserveVariableInTree(AliDielectronVarManager::kDCA); + histos->SetReserveVariableInTree(AliDielectronVarManager::kPairType); + histos->SetReserveVariableInTree(AliDielectronVarManager::kPseudoProperTime); + histos->SetReserveVariableInTree(AliDielectronVarManager::kXvPrim); + histos->SetReserveVariableInTree(AliDielectronVarManager::kYvPrim); + histos->SetReserveVariableInTree(AliDielectronVarManager::kZvPrim); + histos->SetReserveVariableInTree(AliDielectronVarManager::kXRes); + histos->SetReserveVariableInTree(AliDielectronVarManager::kYRes); + histos->SetReserveVariableInTree(AliDielectronVarManager::kZRes); + histos->SetReserveVariableInTree(AliDielectronVarManager::kNTrk); + histos->SetReserveVariableInTree(AliDielectronVarManager::kTracks); + histos->SetReserveVariableInTree(AliDielectronVarManager::kNacc); + histos->SetReserveVariableInTree(AliDielectronVarManager::kNaccTrcklts); + histos->SetReserveVariableInTree(AliDielectronVarManager::kNch); + histos->SetReserveVariableInTree(AliDielectronVarManager::kCentrality); + histos->SetReserveVariableInTree(AliDielectronVarManager::kNevents); + + diele->SetTreeManager(histos); + +} diff --git a/PWGDQ/dielectron/TakuAlberica/single/get_dedx.C b/PWGDQ/dielectron/TakuAlberica/single/get_dedx.C new file mode 100644 index 00000000000..8fa9ddbabc2 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/get_dedx.C @@ -0,0 +1,175 @@ +void get_dedx(void){ + + gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT -I$ALICE_ROOT/build/include -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TPC -I$ALICE_ROOT/CONTAINERS -I$ALICE_ROOT/STEER -I$ALICE_ROOT/TRD -I$ALICE_ROOT/macros -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG2/FLOW/AliFlowCommon -I$ALICE_ROOT/PWG2/FLOW/AliFlowTasks -I$ALICE_ROOT/PWG3/dielectron/ -g"); + + gSystem->Load("libCore");// no + gSystem->Load("libTree"); + gSystem->Load("libGeom"); + gSystem->Load("libVMC"); + gSystem->Load("libXMLIO");// no + gSystem->Load("libPhysics"); + gSystem->Load("libXMLParser"); + gSystem->Load("libProof"); + gSystem->Load("libMinuit"); + + gSystem->Load("libSTEERBase"); + gSystem->Load("libCDB"); + gSystem->Load("libRAWDatabase"); + gSystem->Load("libRAWDatarec"); + gSystem->Load("libESD"); + gSystem->Load("libAOD"); + gSystem->Load("libSTEER"); + gSystem->Load("libANALYSIS"); + gSystem->Load("libANALYSISalice"); + gSystem->Load("libTOFbase"); + gSystem->Load("libTOFrec"); + gSystem->Load("libT0base"); + gSystem->Load("libT0rec"); + gSystem->Load("libPWG2flowCommon"); + gSystem->Load("libPWG2flowTasks"); + + gSystem->Load("libTENDER"); + gSystem->Load("libTENDERSupplies"); + + + + gSystem->Load("libCORRFW.so"); + gSystem->Load("libPWG3base.so"); + gSystem->Load("libPWG3dielectron.so"); + gSystem->Load("libPWG3hfe.so"); + + + TChain *chain = new TChain("esdTree"); + for(int i=1; i!=4; ++i) + chain->Add( Form("/home/gunji/softwares/dielectron/data/esd137549035/%d0/AliESDs.root",i) ); + + AliAnalysisManager *mgr = new AliAnalysisManager("DielectronAnalysisManager"); + AliESDInputHandler *esdH = new AliESDInputHandler(); + mgr->SetInputEventHandler(esdH); + gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C"); + AddTaskPhysicsSelection(kFALSE); + gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C"); + AliCentralitySelectionTask *taskCentrality =AddTaskCentrality(); + // taskCentrality->SetPass(2); + + /* gROOT->LoadMacro("AliDielectronDebugTreeTaku.cxx++"); + gROOT->LoadMacro("AliDielectronHistosTaku.cxx++"); + gROOT->LoadMacro("AliDielectronTaku.cxx++"); + gROOT->LoadMacro("AliAnalysisTaskMultiDielectronNewTaku.cxx++"); + */ + + gSystem->Load("./AliDielectronHistosTaku_cxx.so"); + gSystem->Load("./AliDielectronDebugTreeTaku_cxx.so"); + gSystem->Load("./AliDielectronTaku_cxx.so"); + + + float mom[5][200]; + float dedx[5][200]; + + + + /* + AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager(); + AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler()); + Bool_t isESD=man->GetInputEventHandler()->IsA()==AliESDInputHandler::Class(); + + if ( inputHandler->GetPIDResponse() ){ + AliDielectronVarManager::SetPIDResponse( inputHandler->GetPIDResponse() ); + } else { + if (isESD){ + if (!AliDielectronVarManager::GetESDpid()){ + if (AliDielectronMC::Instance()->HasMC()) { + AliDielectronVarManager::InitESDpid(); + } else { + cout<<" set pid as 1"<GetTPCResponse(); + + for (Int_t j=0; jGetExpectedSignal(p,j); + mom[j][ii] = p; + dedx[j][ii] = bethe; + + //cout<GetTPCResponse().SetBetheBlochParameters(fAlephParam[0], + fAlephParam[1], + fAlephParam[2], + fAlephParam[3], + fAlephParam[4]); + + + AliTPCPIDResponse *ff = (AliTPCPIDResponse*)fESDpid->GetTPCResponse(); + + for (Int_t j=0; jGetExpectedSignal(p,j); + mom[j][ii] = p; + dedx[j][ii] = bethe; + cout<SetName(name); + g[i]->SetLineColor(i+2); + } + /* + TFile *fin=new TFile("ana/tmp.root"); + fin->cd(); + hdedx_pt->SetAxisRange(0,4); + hdedx_pt->Draw(); + g[0]->Draw("pc"); + g[2]->Draw("pc"); + g[3]->Draw("pc"); + g[4]->Draw("pc"); + */ + TFile *fout = new TFile("dedx.root","recreate"); + fout->cd(); + for(int i=0;i<5;i++){ + g[i]->Write(); + } + + + +} + + + + diff --git a/PWGDQ/dielectron/TakuAlberica/single/runTaku.C b/PWGDQ/dielectron/TakuAlberica/single/runTaku.C new file mode 100644 index 00000000000..2d1b6dd1ee3 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/runTaku.C @@ -0,0 +1,240 @@ +//char *gridMode=""; +char *gridMode = "full"; // "" for local +char *workingDir = "takuv2c123456_2012_TEST"; +TString commonOutputFileName = Form("Results%s",workingDir); + +class AliAnalysisAlien; +class AliAnalysisGrid; +void runTaku() { + + + // gSystem->Setenv("alien_CLOSE_SE", "ALICE::GSI::SE"); + // cout << "alien_CLOSE_SE: " << gSystem->Getenv("alien_CLOSE_SE") << endl; + TGrid::Connect("alien://"); + + + TStopwatch timer; timer.Start(); + LoadLibraries(); + if(gridMode!="") + AliAnalysisGrid *alienHandler = CreateAlienHandler(); + else { + TChain *chain = new TChain("esdTree"); + /* + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169837060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169846080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169858040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169859060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169918060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169918080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169919060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169919080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169922040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169922080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169923040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169923060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169923080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169956040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169956060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169956080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169961040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169961060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169961080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169965040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169965080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169975040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169981040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169981060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000169981080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170027040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170027060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170027080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170036060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170036080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170038040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170038060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170081080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170083040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170084040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170085060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170085080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170088040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170088080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170089040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170089060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170089080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170091060.10.root")); + */ + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170152040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170152060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170152080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170155060.10.root")); + /* + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170155080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170163080.10.root")); + + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170193040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170193060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170193080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170195040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170195080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170204060.10.root")); + + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170205040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170205060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170205080.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170207040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170207060.10.root")); + + + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170208040.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170208060.10.root")); + chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170208080.10.root")); + */ + //chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170228060.10.root")); + + //chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170264040.10.root")); + //chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170264060.10.root")); + //chain->Add( Form("/home/gunji/softwares/data/2011/AliESDs_11000170264080.10.root")); + } + AliAnalysisManager *mgr = new AliAnalysisManager("DielectronAnalysisManager"); + AliESDInputHandler *esdH = new AliESDInputHandler(); + mgr->SetInputEventHandler(esdH); + if(gridMode!="") + mgr->SetGridHandler(alienHandler); + gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C"); + AddTaskPhysicsSelection(kFALSE); + gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C"); + AliCentralitySelectionTask *taskCentrality =AddTaskCentrality(); + //taskCentrality->SetPass(2); + + gROOT->LoadMacro("AliDielectronDebugTreeTaku.cxx++"); + gROOT->LoadMacro("AliDielectronHistosTaku.cxx++"); + gROOT->LoadMacro("AliDielectronTaku.cxx++"); + gROOT->LoadMacro("AliAnalysisTaskMultiDielectronNewTaku.cxx++"); + + LoadAddLibraries(); + + TString configFile("./ConfigJpsi2eeDataTaku.C"); + Bool_t hasMC=(mgr->GetMCtruthEventHandler()!=0x0); + if (hasMC){ + configFile="$ALICE_ROOT/PWG3/dielectron/macros/ConfigJpsi2eeEff.C"; + } + gROOT->LoadMacro(configFile.Data()); + + gROOT->LoadMacro("AddTaskDielectronTaku.C"); + + + + AddTaskDielectronTaku( 0, 99, commonOutputFileName.Data(), "CENT1" ); + /* + AddTaskDielectronTaku( 10, 20, commonOutputFileName.Data(), "CENT2" ); + AddTaskDielectronTaku( 20, 30, commonOutputFileName.Data(), "CENT3" ); + AddTaskDielectronTaku( 30, 40, commonOutputFileName.Data(), "CENT4" ); + AddTaskDielectronTaku( 40, 50, commonOutputFileName.Data(), "CENT5" ); + AddTaskDielectronTaku( 50, 60, commonOutputFileName.Data(), "CENT6" ); + AddTaskDielectronTaku( 60, 70, commonOutputFileName.Data(), "CENT7" ); + AddTaskDielectronTaku( 70, 80, commonOutputFileName.Data(), "CENT8" ); + AddTaskDielectronTaku( 80, 99, commonOutputFileName.Data(), "CENT9" ); + */ + + mgr->SetDebugLevel(2); + mgr->SetDebugLevel(0); + if(!mgr->InitAnalysis()) return; + mgr->PrintStatus(); + if(gridMode!="") + mgr->StartAnalysis("grid"); + else + mgr->StartAnalysis("local",chain); + timer.Stop(); + timer.Print(); + +} + +AliAnalysisGrid* CreateAlienHandler() { + AliAnalysisAlien *plugin = new AliAnalysisAlien(); + plugin->SetRunMode(gridMode); + plugin->SetNtestFiles(1); + plugin->SetAPIVersion("V1.1x"); + + // plugin->SetROOTVersion("v5-28-00d"); + // plugin->SetAliROOTVersion("v4-21-25-AN"); + plugin->SetROOTVersion("v5-30-03-1"); + plugin->SetAliROOTVersion("v5-01-Rev-19"); + plugin->SetRunPrefix("000"); + gROOT->LoadMacro("AddRunsPbPb.C"); + AddRunsPbPb(plugin); + //plugin->AddDataFile("/alice/cern.ch/user/t/tgunji/takuv2c123456_rev2_6/000169554_000169553.xml") + //plugin->AddDataFile("/alice/cern.ch/user/t/tgunji/takuv2c123456_rev2_6/000169557_000169555.xml") + plugin->SetOutputToRunNo(); + plugin->SetGridWorkingDir(workingDir); + plugin->SetGridOutputDir("output"); + plugin->AddIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TPC -I$ALICE_ROOT/CONTAINERS -I$ALICE_ROOT/STEER -I$ALICE_ROOT/TRD -I$ALICE_ROOT/macros -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG2/FLOW/AliFlowCommon -I$ALICE_ROOT/PWG2/FLOW/AliFlowTasks -I$ALICE_ROOT/PWG3/dielectron/ -g"); + plugin->SetAnalysisSource("AliDielectronHistosTaku.cxx AliDielectronDebugTreeTaku.cxx AliDielectronTaku.cxx AliAnalysisTaskMultiDielectronNewTaku.cxx"); + // plugin->SetAdditionalLibs("libCORRFW.so libPWG3base.so libPWG3dielectron.so libPWG3hfe.so libTENDER.so libTENDERSupplies.so AliAnalysisTaskMultiDielectronNew.h AliAnalysisTaskMultiDielectronNew.cxx"); + plugin->SetAdditionalLibs("libCORRFW.so libPWG3base.so libPWG3dielectron.so libPWG3hfe.so AliDielectronHistosTaku.h AliDielectronHistosTaku.cxx AliDielectronDebugTreeTaku.h AliDielectronDebugTreeTaku.cxx AliDielectronTaku.h AliDielectronTaku.cxx AliAnalysisTaskMultiDielectronNewTaku.h AliAnalysisTaskMultiDielectronNewTaku.cxx"); + plugin->SetDefaultOutputs(kTRUE); + plugin->SetAnalysisMacro(Form("%s.C",workingDir)); + plugin->SetExecutable(Form("%s.sh",workingDir)); + plugin->SetSplitMaxInputFileNumber(50); + plugin->SetOverwriteMode(kTRUE); + plugin->SetMaxInitFailed(20); + plugin->SetTTL(90000); + plugin->SetOutputToRunNo(kTRUE); + plugin->SetMasterResubmitThreshold(90); + plugin->SetInputFormat("xml-single"); + plugin->SetJDLName(Form("%s.jdl",workingDir)); + plugin->SetPrice(1); + plugin->SetSplitMode("se"); + plugin->SetKeepLogs(kTRUE); + plugin->SetExecutableCommand("aliroot -b -q "); + return plugin; +} + +void LoadLibraries() +{ + gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT -I$ALICE_ROOT/build/include -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TPC -I$ALICE_ROOT/CONTAINERS -I$ALICE_ROOT/STEER -I$ALICE_ROOT/TRD -I$ALICE_ROOT/macros -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG2/FLOW/AliFlowCommon -I$ALICE_ROOT/PWG2/FLOW/AliFlowTasks -I$ALICE_ROOT/PWG3/dielectron/ -g"); + gSystem->Load("libCore");// no + gSystem->Load("libTree"); + gSystem->Load("libGeom"); + gSystem->Load("libVMC"); + gSystem->Load("libXMLIO");// no + gSystem->Load("libPhysics"); + gSystem->Load("libXMLParser"); + gSystem->Load("libProof"); + gSystem->Load("libMinuit"); + + gSystem->Load("libSTEERBase"); + gSystem->Load("libCDB"); + gSystem->Load("libRAWDatabase"); + gSystem->Load("libRAWDatarec"); + gSystem->Load("libESD"); + gSystem->Load("libAOD"); + gSystem->Load("libSTEER"); + gSystem->Load("libANALYSIS"); + gSystem->Load("libANALYSISalice"); + gSystem->Load("libTOFbase"); + gSystem->Load("libTOFrec"); + gSystem->Load("libT0base"); + gSystem->Load("libT0rec"); + gSystem->Load("libPWG2flowCommon"); + gSystem->Load("libPWG2flowTasks"); + + gSystem->Load("libTENDER"); + gSystem->Load("libTENDERSupplies"); + + + + gSystem->Load("libCORRFW.so"); + gSystem->Load("libPWG3base.so"); + gSystem->Load("libPWG3dielectron.so"); + gSystem->Load("libPWG3hfe.so"); + +} + +void LoadAddLibraries(){ + gSystem->Load("./AliDielectronHistosTaku_cxx.so"); + gSystem->Load("./AliDielectronDebugTreeTaku_cxx.so"); + gSystem->Load("./AliDielectronTaku_cxx.so"); + + +} diff --git a/PWGDQ/dielectron/TakuAlberica/single/runTakuMC.C b/PWGDQ/dielectron/TakuAlberica/single/runTakuMC.C new file mode 100644 index 00000000000..ba5a488d355 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/runTakuMC.C @@ -0,0 +1,171 @@ +//char *gridMode=""; +char *gridMode = "full"; // "" for local +char *workingDir = "takuv2c123456_rev3_2_mc"; +TString commonOutputFileName = Form("Results%s",workingDir); + +class AliAnalysisAlien; +class AliAnalysisGrid; +void runTakuMC() { + + + gSystem->Setenv("alien_CLOSE_SE", "ALICE::GSI::SE"); + cout << "alien_CLOSE_SE: " << gSystem->Getenv("alien_CLOSE_SE") << endl; + TGrid::Connect("alien://"); + + + TStopwatch timer; timer.Start(); + LoadLibraries(); + if(gridMode!="") + AliAnalysisGrid *alienHandler = CreateAlienHandler(); + else { + TChain *chain = new TChain("esdTree"); + for(int i=1; i!=10; ++i) + chain->Add( Form("/home/gunji/softwares/dielectron/data/esd138740_mc/%d0/AliESDs.root",i) ); + } + AliAnalysisManager *mgr = new AliAnalysisManager("DielectronAnalysisManager"); + AliESDInputHandler *esdH = new AliESDInputHandler(); + mgr->SetInputEventHandler(esdH); + if(gridMode!="") + mgr->SetGridHandler(alienHandler); + + + AliMCEventHandler *MC = new AliMCEventHandler; + mgr->SetMCtruthEventHandler(MC); + + gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C"); + AliPhysicsSelectionTask* physicsSelTask = AddTaskPhysicsSelection(kTRUE); + physicsSelTask->GetPhysicsSelection()->SetAnalyzeMC(); + + + gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C"); + AliCentralitySelectionTask *taskCentrality =AddTaskCentrality(); + ///taskCentrality->SetPass(2); + taskCentrality->SetMCInput(); + + gROOT->LoadMacro("AliDielectronDebugTreeTaku.cxx++"); + gROOT->LoadMacro("AliDielectronHistosTaku.cxx++"); + gROOT->LoadMacro("AliDielectronTaku.cxx++"); + gROOT->LoadMacro("AliAnalysisTaskMultiDielectronNewTaku.cxx++"); + + LoadAddLibraries(); + + TString configFile("./ConfigJpsi2eeDataTaku.C"); + //Bool_t hasMC=(mgr->GetMCtruthEventHandler()!=0x0); + //if (hasMC){ + //configFile="$ALICE_ROOT/PWG3/dielectron/macros/ConfigJpsi2eeEff.C"; + //} + gROOT->LoadMacro(configFile.Data()); + + gROOT->LoadMacro("AddTaskDielectronTaku.C"); + + + + AddTaskDielectronTaku( 0, 99, commonOutputFileName.Data(), "CENT1" ); + /* + AddTaskDielectronTaku( 10, 20, commonOutputFileName.Data(), "CENT2" ); + AddTaskDielectronTaku( 20, 30, commonOutputFileName.Data(), "CENT3" ); + AddTaskDielectronTaku( 30, 40, commonOutputFileName.Data(), "CENT4" ); + AddTaskDielectronTaku( 40, 50, commonOutputFileName.Data(), "CENT5" ); + AddTaskDielectronTaku( 50, 60, commonOutputFileName.Data(), "CENT6" ); + AddTaskDielectronTaku( 60, 70, commonOutputFileName.Data(), "CENT7" ); + AddTaskDielectronTaku( 70, 80, commonOutputFileName.Data(), "CENT8" ); + AddTaskDielectronTaku( 80, 99, commonOutputFileName.Data(), "CENT9" ); + */ + + mgr->SetDebugLevel(2); + mgr->SetDebugLevel(0); + if(!mgr->InitAnalysis()) return; + mgr->PrintStatus(); + if(gridMode!="") + mgr->StartAnalysis("grid"); + else + mgr->StartAnalysis("local",chain); + timer.Stop(); + timer.Print(); + +} + +AliAnalysisGrid* CreateAlienHandler() { + AliAnalysisAlien *plugin = new AliAnalysisAlien(); + plugin->SetRunMode(gridMode); + plugin->SetNtestFiles(1); + plugin->SetAPIVersion("V1.1x"); + + plugin->SetROOTVersion("v5-28-00d"); + plugin->SetAliROOTVersion("v4-21-25-AN"); + // plugin->SetRunPrefix("000"); + gROOT->LoadMacro("AddRunsPbPbMC.C"); + AddRunsPbPbMC(plugin); + plugin->SetOutputToRunNo(); + plugin->SetGridWorkingDir(workingDir); + plugin->SetGridOutputDir("output"); + plugin->AddIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TPC -I$ALICE_ROOT/CONTAINERS -I$ALICE_ROOT/STEER -I$ALICE_ROOT/TRD -I$ALICE_ROOT/macros -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG2/FLOW/AliFlowCommon -I$ALICE_ROOT/PWG2/FLOW/AliFlowTasks -I$ALICE_ROOT/PWG3/dielectron/ -g"); + plugin->SetAnalysisSource("AliDielectronHistosTaku.cxx AliDielectronDebugTreeTaku.cxx AliDielectronTaku.cxx AliAnalysisTaskMultiDielectronNewTaku.cxx"); + // plugin->SetAdditionalLibs("libCORRFW.so libPWG3base.so libPWG3dielectron.so libPWG3hfe.so libTENDER.so libTENDERSupplies.so AliAnalysisTaskMultiDielectronNew.h AliAnalysisTaskMultiDielectronNew.cxx"); + plugin->SetAdditionalLibs("libCORRFW.so libPWG3base.so libPWG3dielectron.so libPWG3hfe.so libPWG2flowCommon.so libPWG2flowTasks.so AliDielectronHistosTaku.h AliDielectronHistosTaku.cxx AliDielectronDebugTreeTaku.h AliDielectronDebugTreeTaku.cxx AliDielectronTaku.h AliDielectronTaku.cxx AliAnalysisTaskMultiDielectronNewTaku.h AliAnalysisTaskMultiDielectronNewTaku.cxx"); + plugin->SetDefaultOutputs(kTRUE); + plugin->SetAnalysisMacro(Form("%s.C",workingDir)); + plugin->SetExecutable(Form("%s.sh",workingDir)); + plugin->SetSplitMaxInputFileNumber(100); + plugin->SetOverwriteMode(kTRUE); + plugin->SetMaxInitFailed(20); + plugin->SetTTL(90000); + plugin->SetOutputToRunNo(kTRUE); + plugin->SetMasterResubmitThreshold(90); + plugin->SetInputFormat("xml-single"); + plugin->SetJDLName(Form("%s.jdl",workingDir)); + plugin->SetPrice(1); + plugin->SetSplitMode("se"); + plugin->SetKeepLogs(kTRUE); + plugin->SetExecutableCommand("aliroot -b -q "); + return plugin; +} + +void LoadLibraries() +{ + gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT -I$ALICE_ROOT/build/include -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TPC -I$ALICE_ROOT/CONTAINERS -I$ALICE_ROOT/STEER -I$ALICE_ROOT/TRD -I$ALICE_ROOT/macros -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG2/FLOW/AliFlowCommon -I$ALICE_ROOT/PWG2/FLOW/AliFlowTasks -I$ALICE_ROOT/PWG3/dielectron/ -g"); + gSystem->Load("libCore");// no + gSystem->Load("libTree"); + gSystem->Load("libGeom"); + gSystem->Load("libVMC"); + gSystem->Load("libXMLIO");// no + gSystem->Load("libPhysics"); + gSystem->Load("libXMLParser"); + gSystem->Load("libProof"); + gSystem->Load("libMinuit"); + + gSystem->Load("libSTEERBase"); + gSystem->Load("libCDB"); + gSystem->Load("libRAWDatabase"); + gSystem->Load("libRAWDatarec"); + gSystem->Load("libESD"); + gSystem->Load("libAOD"); + gSystem->Load("libSTEER"); + gSystem->Load("libANALYSIS"); + gSystem->Load("libANALYSISalice"); + gSystem->Load("libTOFbase"); + gSystem->Load("libTOFrec"); + gSystem->Load("libT0base"); + gSystem->Load("libT0rec"); + gSystem->Load("libPWG2flowCommon"); + gSystem->Load("libPWG2flowTasks"); + + gSystem->Load("libTENDER"); + gSystem->Load("libTENDERSupplies"); + + + + gSystem->Load("libCORRFW.so"); + gSystem->Load("libPWG3base.so"); + gSystem->Load("libPWG3dielectron.so"); + gSystem->Load("libPWG3hfe.so"); + +} + +void LoadAddLibraries(){ + gSystem->Load("./AliDielectronHistosTaku_cxx.so"); + gSystem->Load("./AliDielectronDebugTreeTaku_cxx.so"); + gSystem->Load("./AliDielectronTaku_cxx.so"); + + +} diff --git a/PWGDQ/dielectron/TakuAlberica/single/takuv2c123456_2012_TEST.C b/PWGDQ/dielectron/TakuAlberica/single/takuv2c123456_2012_TEST.C new file mode 100644 index 00000000000..d708919b0a9 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/takuv2c123456_2012_TEST.C @@ -0,0 +1,104 @@ +const char *anatype = "ESD"; + +void takuv2c123456_2012_TEST() +{ +// Analysis using ESD data +// Automatically generated analysis steering macro executed in grid subjobs + + TStopwatch timer; + timer.Start(); + +// Set temporary merging directory to current one + gSystem->Setenv("TMPDIR", gSystem->pwd()); + +// Set temporary compilation directory to current one + gSystem->SetBuildDir(gSystem->pwd(), kTRUE); + +// Reset existing include path and add current directory first in the search + gSystem->SetIncludePath("-I."); +// Load analysis framework libraries + gSystem->Load("libANALYSIS"); + gSystem->Load("libOADB"); + gSystem->Load("libANALYSISalice"); + gSystem->Load("libCORRFW"); + +// include path + TString intPath = gInterpreter->GetIncludePath(); + TObjArray *listpaths = intPath.Tokenize(" "); + TIter nextpath(listpaths); + TObjString *pname; + while ((pname=(TObjString*)nextpath())) { + TString current = pname->GetName(); + if (current.Contains("AliRoot") || current.Contains("ALICE_ROOT")) continue; + gSystem->AddIncludePath(current); + } + if (listpaths) delete listpaths; + gSystem->AddIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TPC -I$ALICE_ROOT/CONTAINERS -I$ALICE_ROOT/STEER -I$ALICE_ROOT/TRD -I$ALICE_ROOT/macros -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG2/FLOW/AliFlowCommon -I$ALICE_ROOT/PWG2/FLOW/AliFlowTasks -I$ALICE_ROOT/PWG3/dielectron/ -g "); + gROOT->ProcessLine(".include $ALICE_ROOT/include"); + printf("Include path: %s\n", gSystem->GetIncludePath()); + +// Add aditional AliRoot libraries + gSystem->Load("libCORRFW.so"); + gSystem->Load("libPWG3base.so"); + gSystem->Load("libPWG3dielectron.so"); + gSystem->Load("libPWG3hfe.so"); + +// analysis source to be compiled at runtime (if any) + gROOT->ProcessLine(".L AliDielectronHistosTaku.cxx+g"); + gROOT->ProcessLine(".L AliDielectronDebugTreeTaku.cxx+g"); + gROOT->ProcessLine(".L AliDielectronTaku.cxx+g"); + gROOT->ProcessLine(".L AliAnalysisTaskMultiDielectronNewTaku.cxx+g"); + +// connect to AliEn and make the chain + if (!TGrid::Connect("alien://")) return; +// read the analysis manager from file + AliAnalysisManager *mgr = AliAnalysisAlien::LoadAnalysisManager("takuv2c123456_2012_TEST.root"); + if (!mgr) return; + mgr->PrintStatus(); + AliLog::SetGlobalLogLevel(AliLog::kError); + TChain *chain = CreateChain("wn.xml", anatype); + + mgr->StartAnalysis("localfile", chain); + timer.Stop(); + timer.Print(); +} + +//________________________________________________________________________________ +TChain* CreateChain(const char *xmlfile, const char *type="ESD") +{ +// Create a chain using url's from xml file + TString filename; + Int_t run = 0; + TString treename = type; + treename.ToLower(); + treename += "Tree"; + printf("***************************************\n"); + printf(" Getting chain of trees %s\n", treename.Data()); + printf("***************************************\n"); + TAlienCollection *coll = TAlienCollection::Open(xmlfile); + if (!coll) { + ::Error("CreateChain", "Cannot create an AliEn collection from %s", xmlfile); + return NULL; + } + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + TChain *chain = new TChain(treename); + coll->Reset(); + while (coll->Next()) { + filename = coll->GetTURL(); + if (mgr) { + Int_t nrun = AliAnalysisManager::GetRunFromAlienPath(filename); + if (nrun && nrun != run) { + printf("### Run number detected from chain: %d\n", nrun); + mgr->SetRunFromPath(nrun); + run = nrun; + } + } + chain->Add(filename); + } + if (!chain->GetNtrees()) { + ::Error("CreateChain", "No tree found from collection %s", xmlfile); + return NULL; + } + return chain; +} + diff --git a/PWGDQ/dielectron/TakuAlberica/single/takuv2c123456_2012_TEST.jdl b/PWGDQ/dielectron/TakuAlberica/single/takuv2c123456_2012_TEST.jdl new file mode 100644 index 00000000000..5877265dc34 --- /dev/null +++ b/PWGDQ/dielectron/TakuAlberica/single/takuv2c123456_2012_TEST.jdl @@ -0,0 +1,60 @@ +Jobtag = { + "comment:Automatically generated analysis JDL" +}; +# Input xml collections +InputDataCollection = { + "LF:/alice/cern.ch/user/a/atoia/takuv2c123456_2012_TEST/$1,nodownload" +}; +# Output directory +OutputDir = "/alice/cern.ch/user/a/atoia/takuv2c123456_2012_TEST/output/$2/#alien_counter_03i#"; +# List of requested packages +Packages = { + "VO_ALICE@AliRoot::v5-01-Rev-19", + "VO_ALICE@ROOT::v5-30-03-1", + "VO_ALICE@APISCONFIG::V1.1x" +}; +# List of input files to be uploaded to workers +InputFile = { + "LF:/alice/cern.ch/user/a/atoia/takuv2c123456_2012_TEST/takuv2c123456_2012_TEST.C", + "LF:/alice/cern.ch/user/a/atoia/takuv2c123456_2012_TEST/takuv2c123456_2012_TEST.root", + "LF:/alice/cern.ch/user/a/atoia/takuv2c123456_2012_TEST/AliDielectronHistosTaku.h", + "LF:/alice/cern.ch/user/a/atoia/takuv2c123456_2012_TEST/AliDielectronHistosTaku.cxx", + "LF:/alice/cern.ch/user/a/atoia/takuv2c123456_2012_TEST/AliDielectronDebugTreeTaku.h", + "LF:/alice/cern.ch/user/a/atoia/takuv2c123456_2012_TEST/AliDielectronDebugTreeTaku.cxx", + "LF:/alice/cern.ch/user/a/atoia/takuv2c123456_2012_TEST/AliDielectronTaku.h", + "LF:/alice/cern.ch/user/a/atoia/takuv2c123456_2012_TEST/AliDielectronTaku.cxx", + "LF:/alice/cern.ch/user/a/atoia/takuv2c123456_2012_TEST/AliAnalysisTaskMultiDielectronNewTaku.h", + "LF:/alice/cern.ch/user/a/atoia/takuv2c123456_2012_TEST/AliAnalysisTaskMultiDielectronNewTaku.cxx" +}; +# This is the startup script +Executable = "takuv2c123456_2012_TEST.sh"; +# We split per SE or file +Split = "se"; +# Time after which the job is killed (1500 min.) +TTL = "90000"; +# Resubmit failed jobs until DONE rate reaches this percentage +MasterResubmitThreshold = "90%"; +# Maximum number of input files to be processed per subjob +SplitMaxInputFileNumber = "50"; +# Format of input data +InputDataListFormat = "xml-single"; +# Collection name to be processed on each worker node +InputDataList = "wn.xml"; +# Files to be archived +OutputArchive = { + "log_archive.zip:std*@disk=1","root_archive.zip:EventStat_temp.root,Resultstakuv2c123456_2012_TESTAnalysisResults.root,*.stat@disk=2" +}; +# Maximum number of first failing jobs to abort the master job +MaxInitFailed = "20"; +# AliEn price for this job +Price = "1"; +# Validation script to be run for each subjob +Validationcommand = "/alice/cern.ch/user/a/atoia/takuv2c123456_2012_TEST/takuv2c123456_2012_TEST_validation.sh"; + +# JDL variables +JDLVariables = +{ + "Packages", + "OutputDir" +}; +Workdirectorysize = {"5000MB"}; diff --git a/PWGDQ/dielectron/TakuAlberica/single/takuv2c123456_2012_TEST.root b/PWGDQ/dielectron/TakuAlberica/single/takuv2c123456_2012_TEST.root new file mode 100644 index 0000000000000000000000000000000000000000..f14e66011d6c9d0b4dbd636500bd3437906ae5f2 GIT binary patch literal 156072 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 stdout +echo "* Automatically generated validation script *" >> stdout + +echo "* Time: $validatetime " >> stdout +echo "* Dir: $validateout" >> stdout +echo "* Workdir: $validateworkdir" >> stdout +echo "* ----------------------------------------------------*" >> stdout +ls -la ./ >> stdout +echo "* ----------------------------------------------------*" >> stdout + +################################################## + +if [ ! -f stderr ] ; then + error=1 + echo "* ########## Job not validated - no stderr ###" >> stdout + echo "Error = $error" >> stdout +fi +parArch=`grep -Ei "Cannot Build the PAR Archive" stderr` +segViol=`grep -Ei "Segmentation violation" stderr` +segFault=`grep -Ei "Segmentation fault" stderr` +glibcErr=`grep -Ei "*** glibc detected ***" stderr` + +if [ "$parArch" != "" ] ; then + error=1 + echo "* ########## Job not validated - PAR archive not built ###" >> stdout + echo "$parArch" >> stdout + echo "Error = $error" >> stdout +fi +if [ "$segViol" != "" ] ; then + error=1 + echo "* ########## Job not validated - Segment. violation ###" >> stdout + echo "$segViol" >> stdout + echo "Error = $error" >> stdout +fi +if [ "$segFault" != "" ] ; then + error=1 + echo "* ########## Job not validated - Segment. fault ###" >> stdout + echo "$segFault" >> stdout + echo "Error = $error" >> stdout +fi +if [ "$glibcErr" != "" ] ; then + error=1 + echo "* ########## Job not validated - *** glibc detected *** ###" >> stdout + echo "$glibcErr" >> stdout + echo "Error = $error" >> stdout +fi +if ! [ -f EventStat_temp.root ] ; then + error=1 + echo "Output file EventStat_temp.root not found. Job FAILED !" >> stdout + echo "Output file EventStat_temp.root not found. Job FAILED !" >> stderr +fi +if ! [ -f Resultstakuv2c123456_2012_TESTAnalysisResults.root ] ; then + error=1 + echo "Output file Resultstakuv2c123456_2012_TESTAnalysisResults.root not found. Job FAILED !" >> stdout + echo "Output file Resultstakuv2c123456_2012_TESTAnalysisResults.root not found. Job FAILED !" >> stderr +fi +if ! [ -f outputs_valid ] ; then + error=1 + echo "Output files were not validated by the analysis manager" >> stdout + echo "Output files were not validated by the analysis manager" >> stderr +fi +if [ $error = 0 ] ; then + echo "* ---------------- Job Validated ------------------*" >> stdout +fi +echo "* ----------------------------------------------------*" >> stdout +echo "*******************************************************" >> stdout +cd - +exit $error -- 2.43.0