Update from Prabhat and Debojit
authorsjena <sjena@cern.ch>
Mon, 10 Mar 2014 15:09:31 +0000 (16:09 +0100)
committermkrzewic <mikolaj.krzewicki@cern.ch>
Tue, 11 Mar 2014 20:32:34 +0000 (21:32 +0100)
PWGCF/Correlations/DPhi/AliAnalysisTaskDptDptQA.cxx [new file with mode: 0644]
PWGCF/Correlations/DPhi/AliAnalysisTaskDptDptQA.h [new file with mode: 0644]
PWGCF/Correlations/DPhi/TriggerPID/AliTwoParticlePIDCorr.cxx
PWGCF/Correlations/DPhi/TriggerPID/AliTwoParticlePIDCorr.h
PWGCF/Correlations/macros/dptdptcorrelations/AddTaskDptQA.C [new file with mode: 0644]

diff --git a/PWGCF/Correlations/DPhi/AliAnalysisTaskDptDptQA.cxx b/PWGCF/Correlations/DPhi/AliAnalysisTaskDptDptQA.cxx
new file mode 100644 (file)
index 0000000..dfe6198
--- /dev/null
@@ -0,0 +1,1578 @@
+#include "TChain.h"
+#include "TList.h"
+#include "TFile.h"
+#include "TTree.h"
+#include "TH1D.h"
+#include "TH2D.h"
+#include "TH3D.h"
+#include "THnSparse.h"
+#include "TCanvas.h"
+
+#include <TROOT.h>
+#include <TChain.h>
+#include <TFile.h>
+#include <TList.h>
+#include <TMath.h>
+#include <TTree.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TH3F.h>
+#include <TProfile.h>
+#include <TH1D.h>
+#include <TH2D.h>
+#include <TH3D.h>
+#include <TRandom.h>
+#include "AliAnalysisManager.h"
+
+#include "AliAODHandler.h"
+#include "AliAODInputHandler.h"
+#include "AliInputEventHandler.h"
+#include "AliLog.h"
+#include "AliESDEvent.h"
+#include "AliESDInputHandler.h"
+#include "AliMultiplicity.h"
+#include "AliCentrality.h"
+#include "AliAnalysisTaskDptDptQA.h"
+
+#include "AliPID.h"
+#include "AliPIDResponse.h"
+
+#include "AliESDVertex.h"
+#include "AliESDEvent.h"
+#include "AliESDInputHandler.h"
+#include "AliAODEvent.h"
+#include "AliAODTrack.h"
+#include "AliAODInputHandler.h"
+#include "AliESD.h"
+#include "AliESDEvent.h"
+#include "AliAODEvent.h"
+#include "AliStack.h"
+#include "AliESDtrackCuts.h"
+#include "AliAODMCHeader.h"
+
+
+#include "AliGenHijingEventHeader.h"
+#include "AliGenEventHeader.h"
+#include "AliPID.h"
+#include "AliAODPid.h"
+#include "AliPIDResponse.h"
+#include "AliAODpidUtil.h"
+#include "AliPIDCombined.h"
+
+
+
+ClassImp(AliAnalysisTaskDptDptQA)
+
+AliAnalysisTaskDptDptQA::AliAnalysisTaskDptDptQA()
+: AliAnalysisTaskSE(),
+fAODEvent(0), 
+fESDEvent(0),             //! ESD Event 
+fInputHandler(0),
+fPIDResponse(0x0),
+_outputHistoList(0),
+_twoPi         ( 2.0 * 3.1415927),
+_eventCount    ( 0), 
+_debugLevel    ( 0),
+_singlesOnly   ( 0), 
+_useWeights    ( 0), 
+_sameFilter    ( false),
+_rejectPileup  ( 1), 
+_rejectPairConversion ( 0), 
+_vertexZMin           ( -10), 
+_vertexZMax           (  10), 
+_vertexXYMin          ( -10),
+_vertexXYMax          (  10),
+_centralityMethod     (  4),
+_centralityMin        (  0.),
+_centralityMax        (  0.),
+_requestedCharge_1    (   1),
+_requestedCharge_2    (  -1),
+_dcaZMin              ( -3), 
+_dcaZMax              (  3.), 
+_dcaXYMin             ( -2.4), 
+_dcaXYMax             (  2.4),
+_dedxMin              ( 0),
+_dedxMax              ( 100000),
+_nClusterMin          ( 80), 
+_trackFilterBit       (0),
+fNSigmaCut            (3.),
+_field    ( 1.),
+_nTracks  ( 0 ),
+_mult0    ( 0 ),
+_mult1    ( 0 ),
+_mult2    ( 0 ),
+_mult3    ( 0 ),
+_mult4    ( 0 ),
+_mult4a    ( 0 ),
+_mult5    ( 0 ),
+_mult6    ( 0 ),
+arraySize ( 2000),
+_id_1(0),       
+_charge_1(0),    
+_iEtaPhi_1(0),    
+_iPt_1(0),     
+_pt_1(0),       
+_px_1(0),      
+_py_1(0),      
+_pz_1(0),      
+_correction_1(0),   
+_dedx_1(0),   
+_id_2(0),      
+_charge_2(0),    
+_iEtaPhi_2(0),    
+_iPt_2(0),     
+_pt_2(0),      
+_px_2(0),      
+_py_2(0),      
+_pz_2(0),      
+_correction_2(0),   
+_dedx_2(0),   
+_correctionWeight_1(0),   
+_correctionWeight_2(0),
+_nBins_M0(500),       _min_M0(0),        _max_M0(10000),          _width_M0(20),
+_nBins_M1(500),       _min_M1(0),        _max_M1(10000),          _width_M1(20),
+_nBins_M2(500),       _min_M2(0),        _max_M2(10000),          _width_M2(20),
+_nBins_M3(500),       _min_M3(0),        _max_M3(10000),          _width_M3(20),
+_nBins_M4(100),       _min_M4(0),        _max_M4(1),              _width_M4(0.01),
+_nBins_M5(100),       _min_M5(0),        _max_M5(1),              _width_M5(0.01),
+_nBins_M6(100),       _min_M6(0),        _max_M6(1),              _width_M6(0.01),
+_nBins_vertexZ(40),   _min_vertexZ(-10), _max_vertexZ(10),        _width_vertexZ(0.5),
+
+_nBins_pt_1(18),      _min_pt_1(0.2),    _max_pt_1(2.0),          _width_pt_1(0.1),
+_nBins_phi_1(72),     _min_phi_1(0),     _max_phi_1(2.*3.1415927),_width_phi_1(2.*3.1415927/72.),
+_nBins_eta_1(0),      _min_eta_1(0),  _max_eta_1(0),           _width_eta_1(0.1),
+
+_nBins_etaPhi_1(0), 
+_nBins_etaPhiPt_1(0),
+_nBins_zEtaPhiPt_1(0),
+
+_nBins_pt_2(18),     _min_pt_2(0.2),     _max_pt_2(2.0),          _width_pt_2(0.1),
+_nBins_phi_2(72),    _min_phi_2(0),      _max_phi_2(2.*3.1415927),_width_phi_2(2.*3.1415927/72),
+_nBins_eta_2(0),     _min_eta_2(0),     _max_eta_2(0),           _width_eta_2(0.1),
+
+_nBins_etaPhi_2(0), 
+_nBins_etaPhiPt_2(0),
+_nBins_zEtaPhiPt_2(0),
+_nBins_etaPhi_12(0),
+__n1_1(0),
+__n1_2(0),
+__n2_12(0),   
+__s1pt_1(0),
+__s1pt_2(0),
+__s2ptpt_12(0),
+__s2NPt_12(0),
+__s2PtN_12(0),
+__n1Nw_1(0),
+__n1Nw_2(0),
+__n2Nw_12(0),   
+__s1ptNw_1(0),
+__s1ptNw_2(0),
+__s2ptptNw_12(0),
+__s2NPtNw_12(0),
+__s2PtNNw_12(0),
+__n1_1_vsPt(0),
+__n1_1_vsEtaPhi(0), 
+__s1pt_1_vsEtaPhi(0),
+__n1_1_vsZEtaPhiPt(0),
+__n1_2_vsPt(0),
+__n1_2_vsEtaPhi(0), 
+__s1pt_2_vsEtaPhi(0),
+__n1_2_vsZEtaPhiPt(0),
+__n2_12_vsPtPt(0),
+__n2_12_vsEtaPhi(0),
+__s2ptpt_12_vsEtaPhi(0),
+__s2PtN_12_vsEtaPhi(0),
+__s2NPt_12_vsEtaPhi(0),
+_weight_1      ( 0    ),
+_weight_2      ( 0    ),
+_eventAccounting ( 0),
+_m0 ( 0),
+_m1 ( 0),
+_m2 ( 0),
+_m3 ( 0),
+_m4 ( 0),
+_m5 ( 0),
+_m6 ( 0),
+_vertexZ ( 0),
+  
+_Ncluster1  ( 0),
+_Ncluster2  ( 0),
+_etadis ( 0),
+_phidis ( 0),
+_dcaz   ( 0),
+_dcaxy  ( 0),
+_spectra  ( 0),
+_n1_1_vsPt         ( 0),         
+_n1_1_vsEtaVsPhi   ( 0),
+_s1pt_1_vsEtaVsPhi ( 0), 
+_n1_1_vsZVsEtaVsPhiVsPt ( 0),
+_n1_1_vsM          ( 0), 
+_s1pt_1_vsM        ( 0),
+_n1Nw_1_vsM        ( 0),
+_s1ptNw_1_vsM      ( 0),
+_dedxVsP_1         ( 0),
+_corrDedxVsP_1     ( 0),
+_betaVsP_1         ( 0),
+_n1_2_vsPt         ( 0),       
+_n1_2_vsEtaVsPhi   ( 0),
+_s1pt_2_vsEtaVsPhi ( 0),
+_n1_2_vsZVsEtaVsPhiVsPt ( 0), 
+_n1_2_vsM          ( 0),
+_s1pt_2_vsM        ( 0),
+_n1Nw_2_vsM        ( 0),
+_s1ptNw_2_vsM      ( 0),
+_dedxVsP_2         ( 0),
+_corrDedxVsP_2     ( 0),
+_betaVsP_2         ( 0),
+_n2_12_vsEtaPhi    ( 0),  
+_n2_12_vsPtVsPt    ( 0),
+_s2PtPt_12_vsEtaPhi( 0),    
+_s2PtN_12_vsEtaPhi ( 0),       
+_s2NPt_12_vsEtaPhi ( 0),     
+_n2_12_vsM         ( 0),        
+_s2PtPt_12_vsM     ( 0),    
+_s2PtN_12_vsM      ( 0),       
+_s2NPt_12_vsM      ( 0), 
+_n2Nw_12_vsM       ( 0),        
+_s2PtPtNw_12_vsM   ( 0),    
+_s2PtNNw_12_vsM    ( 0),       
+_s2NPtNw_12_vsM    ( 0), 
+_invMass           ( 0),
+n1Name("NA"),
+n1NwName("NA"),
+n2Name("NA"),
+n2NwName("NA"),
+n3Name("NA"),
+n1n1Name("NA"),
+n1n1n1Name("NA"),
+n2n1Name("NA"),
+r1Name("NA"),
+r2Name("NA"),
+r3Name("NA"),
+r2r1Name("NA"),
+c2Name("NA"),
+c3Name("NA"),
+d3Name("NA"),
+p3Name("NA"),
+cName("NA"),
+
+intR2Name("NA"),
+binCorrName("NA"),
+intBinCorrName("NA"),
+
+countsName("NA"),
+part_1_Name("NA"),
+part_2_Name("NA"),
+part_3_Name("NA"),
+pair_12_Name("NA"),
+pair_13_Name("NA"),
+pair_23_Name("NA"),
+tripletName("NA"),
+
+avg("NA"),
+avgName("NA"),
+sumName("NA"),
+s1ptName("NA"),
+s1ptNwName("NA"),
+s1DptName("NA"),
+
+s2PtPtName("NA"),
+s2NPtName("NA"),
+s2PtNName("NA"),
+s2DptDptName("NA"),
+
+s2PtPtNwName("NA"),
+s2NPtNwName("NA"),
+s2PtNNwName("NA"),
+
+ptName("NA"),
+ptptName("NA"),
+pt1pt1Name("NA"),
+DptName("NA"),
+DptDptName("NA"),
+RDptDptName("NA"),
+nPtName("NA"),
+ptNName("NA"),
+seanName("NA"),
+
+_title_counts("NA"),
+
+_title_m0("NA"),
+_title_m1("NA"),
+_title_m2("NA"),
+_title_m3("NA"),
+_title_m4("NA"),
+_title_m5("NA"),
+_title_m6("NA"),
+
+_title_eta_1("NA"),
+_title_phi_1("NA"),
+_title_pt_1("NA"),
+_title_etaPhi_1("NA"),
+_title_n_1("NA"),
+_title_SumPt_1("NA"),
+_title_AvgPt_1("NA"),
+_title_AvgN_1("NA"),
+_title_AvgSumPt_1("NA"),
+
+_title_eta_2("NA"),
+_title_phi_2("NA"),
+_title_pt_2("NA"),
+_title_etaPhi_2("NA"),
+_title_n_2("NA"),
+_title_SumPt_2("NA"),
+_title_AvgPt_2("NA"),
+_title_AvgN_2("NA"),
+_title_AvgSumPt_2("NA"),
+
+_title_etaPhi_12("NA"),
+
+_title_AvgN2_12("NA"),
+_title_AvgSumPtPt_12("NA"),
+_title_AvgSumPtN_12("NA"),
+_title_AvgNSumPt_12("NA"),
+
+vsZ("NA"),
+vsM("NA"),
+vsPt("NA"),
+vsPhi("NA"), 
+vsEta("NA"), 
+vsEtaPhi("NA"), 
+vsPtVsPt("NA")
+{
+  printf("Default constructor called \n");
+  
+  printf("passed \n ");
+  
+}
+
+AliAnalysisTaskDptDptQA::AliAnalysisTaskDptDptQA(const TString & name)
+: AliAnalysisTaskSE(name),
+fAODEvent(0), 
+fESDEvent(0),  
+fInputHandler(0),
+fPIDResponse(0),
+_outputHistoList(0),
+_twoPi         ( 2.0 * 3.1415927),
+_eventCount    ( 0), 
+_debugLevel    ( 0),
+_singlesOnly   ( 0), 
+_useWeights    ( 0), 
+_sameFilter    ( false),
+_rejectPileup  ( 1), 
+_rejectPairConversion ( 0), 
+_vertexZMin           ( -10.), 
+_vertexZMax           (  10.), 
+_vertexXYMin          ( -10.),
+_vertexXYMax          (  10.),
+_centralityMethod     (  4),
+_centralityMin        (  0.),
+_centralityMax        (  1.),
+_requestedCharge_1    (   1),
+_requestedCharge_2    (  -1),
+_dcaZMin              ( -3), 
+_dcaZMax              (  3.), 
+_dcaXYMin             ( -2.4), 
+_dcaXYMax             (  2.4),
+_dedxMin              ( 0),
+_dedxMax              ( 100000),
+_nClusterMin          ( 80), 
+_trackFilterBit       ( 0),
+fNSigmaCut            ( 3.),
+_field    ( 1.),
+_nTracks  ( 0 ),
+_mult0    ( 0 ),
+_mult1    ( 0 ),
+_mult2    ( 0 ),
+_mult3    ( 0 ),
+_mult4    ( 0 ),
+_mult4a    ( 0 ),
+_mult5    ( 0 ),
+_mult6    ( 0 ),
+arraySize ( 2000),
+_id_1(0),       
+_charge_1(0),    
+_iEtaPhi_1(0),    
+_iPt_1(0),     
+_pt_1(0),       
+_px_1(0),      
+_py_1(0),      
+_pz_1(0),      
+_correction_1(0),   
+_dedx_1(0),   
+_id_2(0),      
+_charge_2(0),    
+_iEtaPhi_2(0),    
+_iPt_2(0),     
+_pt_2(0),      
+_px_2(0),      
+_py_2(0),      
+_pz_2(0),      
+_correction_2(0),   
+_dedx_2(0),   
+_correctionWeight_1(0),   
+_correctionWeight_2(0),
+_nBins_M0(500),       _min_M0(0),        _max_M0(10000),          _width_M0(20),
+_nBins_M1(500),       _min_M1(0),        _max_M1(10000),          _width_M1(20),
+_nBins_M2(500),       _min_M2(0),        _max_M2(10000),          _width_M2(20),
+_nBins_M3(500),       _min_M3(0),        _max_M3(10000),          _width_M3(20),
+_nBins_M4(100),       _min_M4(0),        _max_M4(1),              _width_M4(0.01),
+_nBins_M5(100),       _min_M5(0),        _max_M5(1),              _width_M5(0.01),
+_nBins_M6(100),       _min_M6(0),        _max_M6(1),              _width_M6(0.01),
+_nBins_vertexZ(40),   _min_vertexZ(-10), _max_vertexZ(10),        _width_vertexZ(0.5),
+
+_nBins_pt_1(18),      _min_pt_1(0.2),    _max_pt_1(2.0),          _width_pt_1(0.1),
+_nBins_phi_1(72),     _min_phi_1(0),     _max_phi_1(2.*3.1415927),_width_phi_1(2.*3.1415927/72.),
+_nBins_eta_1(0),      _min_eta_1(0),    _max_eta_1(0),           _width_eta_1(0.1),
+
+_nBins_etaPhi_1(0), 
+_nBins_etaPhiPt_1(0),
+_nBins_zEtaPhiPt_1(0),
+
+_nBins_pt_2(18),     _min_pt_2(0.2),     _max_pt_2(2.0),          _width_pt_2(0.1),
+_nBins_phi_2(72),    _min_phi_2(0),      _max_phi_2(2.*3.1415927),_width_phi_2(2.*3.1415927/72),
+_nBins_eta_2(0),    _min_eta_2(0),     _max_eta_2(0),           _width_eta_2(0.1),
+
+_nBins_etaPhi_2(0), 
+_nBins_etaPhiPt_2(0),
+_nBins_zEtaPhiPt_2(0),
+_nBins_etaPhi_12(0),
+__n1_1(0),
+__n1_2(0),
+__n2_12(0),   
+__s1pt_1(0),
+__s1pt_2(0),
+__s2ptpt_12(0),
+__s2NPt_12(0),
+__s2PtN_12(0),
+__n1Nw_1(0),
+__n1Nw_2(0),
+__n2Nw_12(0),   
+__s1ptNw_1(0),
+__s1ptNw_2(0),
+__s2ptptNw_12(0),
+__s2NPtNw_12(0),
+__s2PtNNw_12(0),
+__n1_1_vsPt(0),
+__n1_1_vsEtaPhi(0), 
+__s1pt_1_vsEtaPhi(0),
+__n1_1_vsZEtaPhiPt(0),
+__n1_2_vsPt(0),
+__n1_2_vsEtaPhi(0), 
+__s1pt_2_vsEtaPhi(0),
+__n1_2_vsZEtaPhiPt(0),
+__n2_12_vsPtPt(0),
+__n2_12_vsEtaPhi(0),
+__s2ptpt_12_vsEtaPhi(0),
+__s2PtN_12_vsEtaPhi(0),
+__s2NPt_12_vsEtaPhi(0),
+_weight_1        ( 0    ),
+_weight_2        ( 0    ),
+_eventAccounting ( 0),
+_m0 ( 0),
+_m1 ( 0),
+_m2 ( 0),
+_m3 ( 0),
+_m4 ( 0),
+_m5 ( 0),
+_m6 ( 0),
+_vertexZ ( 0),
+_Ncluster1  ( 0),
+_Ncluster2  ( 0),
+_etadis ( 0),
+_phidis ( 0),
+
+_dcaz ( 0),
+_dcaxy ( 0),
+_spectra  ( 0),
+_n1_1_vsPt         ( 0),         
+_n1_1_vsEtaVsPhi   ( 0),
+_s1pt_1_vsEtaVsPhi ( 0), 
+_n1_1_vsZVsEtaVsPhiVsPt ( 0),
+_n1_1_vsM          ( 0), 
+_s1pt_1_vsM        ( 0),
+_n1Nw_1_vsM        ( 0), 
+_s1ptNw_1_vsM      ( 0),
+_dedxVsP_1         ( 0),
+_corrDedxVsP_1     ( 0),
+_betaVsP_1         ( 0),
+_n1_2_vsPt         ( 0),       
+_n1_2_vsEtaVsPhi   ( 0),
+_s1pt_2_vsEtaVsPhi ( 0),
+_n1_2_vsZVsEtaVsPhiVsPt ( 0), 
+_n1_2_vsM          ( 0),
+_s1pt_2_vsM        ( 0),
+_n1Nw_2_vsM        ( 0),
+_s1ptNw_2_vsM      ( 0),
+_dedxVsP_2         ( 0),
+_corrDedxVsP_2     ( 0),
+_betaVsP_2         ( 0),
+_n2_12_vsEtaPhi    ( 0),  
+_n2_12_vsPtVsPt    ( 0),
+_s2PtPt_12_vsEtaPhi( 0),    
+_s2PtN_12_vsEtaPhi ( 0),       
+_s2NPt_12_vsEtaPhi ( 0),     
+_n2_12_vsM         ( 0),        
+_s2PtPt_12_vsM     ( 0),    
+_s2PtN_12_vsM      ( 0),       
+_s2NPt_12_vsM      ( 0), 
+_n2Nw_12_vsM       ( 0),        
+_s2PtPtNw_12_vsM   ( 0),    
+_s2PtNNw_12_vsM    ( 0),       
+_s2NPtNw_12_vsM    ( 0), 
+_invMass           ( 0),
+n1Name("NA"),
+n1NwName("NA"),
+n2Name("NA"),
+n2NwName("NA"),
+n3Name("NA"),
+n1n1Name("NA"),
+n1n1n1Name("NA"),
+n2n1Name("NA"),
+r1Name("NA"),
+r2Name("NA"),
+r3Name("NA"),
+r2r1Name("NA"),
+c2Name("NA"),
+c3Name("NA"),
+d3Name("NA"),
+p3Name("NA"),
+cName("NA"),
+
+intR2Name("NA"),
+binCorrName("NA"),
+intBinCorrName("NA"),
+
+countsName("NA"),
+part_1_Name("NA"),
+part_2_Name("NA"),
+part_3_Name("NA"),
+pair_12_Name("NA"),
+pair_13_Name("NA"),
+pair_23_Name("NA"),
+tripletName("NA"),
+
+avg("NA"),
+avgName("NA"),
+sumName("NA"),
+s1ptName("NA"),
+s1ptNwName("NA"),
+s1DptName("NA"),
+
+s2PtPtName("NA"),
+s2NPtName("NA"),
+s2PtNName("NA"),
+s2DptDptName("NA"),
+
+s2PtPtNwName("NA"),
+s2NPtNwName("NA"),
+s2PtNNwName("NA"),
+
+ptName("NA"),
+ptptName("NA"),
+pt1pt1Name("NA"),
+DptName("NA"),
+DptDptName("NA"),
+RDptDptName("NA"),
+nPtName("NA"),
+ptNName("NA"),
+seanName("NA"),
+
+_title_counts("NA"),
+
+_title_m0("NA"),
+_title_m1("NA"),
+_title_m2("NA"),
+_title_m3("NA"),
+_title_m4("NA"),
+_title_m5("NA"),
+_title_m6("NA"),
+
+_title_eta_1("NA"),
+_title_phi_1("NA"),
+_title_pt_1("NA"),
+_title_etaPhi_1("NA"),
+_title_n_1("NA"),
+_title_SumPt_1("NA"),
+_title_AvgPt_1("NA"),
+_title_AvgN_1("NA"),
+_title_AvgSumPt_1("NA"),
+
+_title_eta_2("NA"),
+_title_phi_2("NA"),
+_title_pt_2("NA"),
+_title_etaPhi_2("NA"),
+_title_n_2("NA"),
+_title_SumPt_2("NA"),
+_title_AvgPt_2("NA"),
+_title_AvgN_2("NA"),
+_title_AvgSumPt_2("NA"),
+
+_title_etaPhi_12("NA"),
+
+_title_AvgN2_12("NA"),
+_title_AvgSumPtPt_12("NA"),
+_title_AvgSumPtN_12("NA"),
+_title_AvgNSumPt_12("NA"),
+
+vsZ("NA"),
+vsM("NA"),
+vsPt("NA"),
+vsPhi("NA"), 
+vsEta("NA"), 
+vsEtaPhi("NA"), 
+vsPtVsPt("NA")
+{
+  printf("2nd constructor called ");
+  
+  DefineOutput(0, TList::Class());
+  
+  printf("passed  ");
+  
+}
+
+AliAnalysisTaskDptDptQA::~AliAnalysisTaskDptDptQA()
+{
+  
+}
+
+void AliAnalysisTaskDptDptQA::UserCreateOutputObjects()
+{
+  OpenFile(0);
+  _outputHistoList = new TList();
+  _outputHistoList->SetOwner();
+  
+  _nBins_M0 = 500; _min_M0   = 0.;    _max_M0    = 5000.;  _width_M0 = (_max_M0-_min_M0)/_nBins_M0;
+  _nBins_M1 = 500; _min_M1   = 0.;    _max_M1    = 5000.;  _width_M1 = (_max_M1-_min_M1)/_nBins_M1;
+  _nBins_M2 = 500; _min_M2   = 0.;    _max_M2    = 5000.;  _width_M2 = (_max_M2-_min_M2)/_nBins_M2;
+  _nBins_M3 = 500; _min_M3   = 0.;    _max_M3    = 5000.;  _width_M3 = (_max_M3-_min_M3)/_nBins_M3;
+  _nBins_M4 = 100; _min_M4   = 0.;    _max_M4    = 100.;   _width_M4 = (_max_M4-_min_M4)/_nBins_M4;
+  _nBins_M5 = 100; _min_M5   = 0.;    _max_M5    = 100.;   _width_M5 = (_max_M5-_min_M5)/_nBins_M5;
+  _nBins_M6 = 100; _min_M6   = 0.;    _max_M6    = 100.;   _width_M6 = (_max_M6-_min_M6)/_nBins_M6;
+  
+  _min_vertexZ       = _vertexZMin;  
+  _max_vertexZ       = _vertexZMax;  
+  _width_vertexZ     = 0.5;
+  _nBins_vertexZ     = int(0.5+ (_max_vertexZ - _min_vertexZ)/_width_vertexZ); 
+  _nBins_pt_1        = int(0.5+ (_max_pt_1 -_min_pt_1 )/_width_pt_1); 
+  _nBins_eta_1       = int(0.5+ (_max_eta_1-_min_eta_1)/_width_eta_1);  
+  _width_phi_1       = (_max_phi_1  - _min_phi_1)  /_nBins_phi_1;
+  _nBins_etaPhi_1    = _nBins_phi_1    * _nBins_eta_1;
+  _nBins_etaPhiPt_1  = _nBins_etaPhi_1 * _nBins_pt_1;
+  _nBins_zEtaPhiPt_1 = _nBins_vertexZ  * _nBins_etaPhiPt_1;
+  
+  _nBins_pt_2        =  int(0.5+ (_max_pt_2 -_min_pt_2 )/_width_pt_2);  
+  _nBins_eta_2       = int(0.5+ (_max_eta_2-_min_eta_2)/_width_eta_2); 
+  _width_phi_2       = (_max_phi_2  - _min_phi_2)  /_nBins_phi_2;
+  _nBins_etaPhi_2    = _nBins_phi_2    * _nBins_eta_2;
+  _nBins_etaPhiPt_2  = _nBins_etaPhi_2 * _nBins_pt_2;
+  _nBins_zEtaPhiPt_2 = _nBins_vertexZ  * _nBins_etaPhiPt_2;
+  _nBins_etaPhi_12   = _nBins_etaPhi_1 * _nBins_etaPhi_2;
+    
+  _id_1       = new int[arraySize];   
+  _charge_1   = new int[arraySize]; 
+  _iEtaPhi_1  = new int[arraySize]; 
+  _iPt_1      = new int[arraySize];  
+  _pt_1       = new float[arraySize];    
+  _px_1       = new float[arraySize];   
+  _py_1       = new float[arraySize];   
+  _pz_1       = new float[arraySize];   
+  _correction_1 = new float[arraySize];
+    
+  __n1_1_vsPt              = getDoubleArray(_nBins_pt_1,        0.);
+  __n1_1_vsEtaPhi          = getDoubleArray(_nBins_etaPhi_1,    0.);
+  __s1pt_1_vsEtaPhi        = getDoubleArray(_nBins_etaPhi_1,    0.);
+  __n1_1_vsZEtaPhiPt       = getFloatArray(_nBins_zEtaPhiPt_1,  0.);
+  
+    
+  if (_requestedCharge_2!=_requestedCharge_1)
+    {
+      _sameFilter = 0;
+    //particle 2
+    _id_2       = new int[arraySize];   
+    _charge_2   = new int[arraySize]; 
+    _iEtaPhi_2  = new int[arraySize]; 
+    _iPt_2      = new int[arraySize];  
+    _pt_2       = new float[arraySize];   
+    _px_2       = new float[arraySize];   
+    _py_2       = new float[arraySize];   
+    _pz_2       = new float[arraySize];   
+    _correction_2 = new float[arraySize];
+        
+    __n1_2_vsPt              = getDoubleArray(_nBins_pt_2,        0.);
+    __n1_2_vsEtaPhi          = getDoubleArray(_nBins_etaPhi_2,    0.);
+    __s1pt_2_vsEtaPhi        = getDoubleArray(_nBins_etaPhi_2,    0.);
+    __n1_2_vsZEtaPhiPt       = getFloatArray(_nBins_zEtaPhiPt_2, 0.);
+    
+    }
+  
+  __n2_12_vsPtPt           = getDoubleArray(_nBins_pt_1*_nBins_pt_2,0.);
+  __n2_12_vsEtaPhi         = getFloatArray(_nBins_etaPhi_12,       0.);
+  __s2ptpt_12_vsEtaPhi     = getFloatArray(_nBins_etaPhi_12,       0.);
+  __s2PtN_12_vsEtaPhi      = getFloatArray(_nBins_etaPhi_12,       0.);
+  __s2NPt_12_vsEtaPhi      = getFloatArray(_nBins_etaPhi_12,       0.);
+  
+  // Setup all the labels needed.
+  
+  part_1_Name   = "_1";
+  part_2_Name   = "_2";
+  pair_12_Name  = "_12";
+  
+  n1Name     = "n1";
+  n2Name     = "n2";
+  n1NwName   = "n1Nw";
+  n2NwName   = "n2Nw";
+  r1Name     = "r1";
+  r2Name     = "r2";
+  r3Name     = "r3";
+  r2r1Name   = "r2r1";
+  c2Name     = "c2";
+  c3Name     = "c3";
+  d3Name     = "d3";
+  p3Name     = "p3";
+  cName      = "sean";
+  
+  intR2Name       = "intR2";
+  binCorrName     = "binCorr";
+  intBinCorrName  = "intBinCorr";
+  
+  avgName      = "avg";
+  sumName      = "sum";
+  s1ptName     = "sumPt";
+  s1ptNwName   = "sumPtNw";
+  s1DptName    = "sumDpt";
+  s2PtPtName   = "sumPtPt";
+  s2PtPtNwName = "sumPtPtNw";
+  s2DptDptName = "sumDptDpt";
+  s2NPtName    = "sumNPt";
+  s2NPtNwName  = "sumNPtNw";
+  s2PtNName    = "sumPtN";
+  s2NPtNwName  = "sumNPtNw";
+  s2PtNNwName  = "sumPtNNw";
+  ptName       = "avgPt";
+  ptptName     = "avgPtPt";
+  pt1pt1Name   = "avgPtavgPt";
+  DptName      = "avgDpt";
+  DptDptName   = "avgDptDpt";
+  RDptDptName  = "relDptDpt"; // ratio of avgDptDpt by avgPt*avgPt
+  nPtName      = "avgNpt";
+  ptNName      = "avgPtN";
+  seanName     = "seanC";
+  
+  _title_counts = "yield";
+  
+  _title_m0     = "M_{0}";
+  _title_m1     = "M_{1}";
+  _title_m2     = "M_{2}";
+  _title_m3     = "M_{3}";
+  _title_m4     = "V0Centrality";
+  _title_m5     = "TrkCentrality";
+  _title_m6     = "SpdCentrality";
+  
+  _title_eta_1       = "#eta_{1}";
+  _title_phi_1       = "#varphi_{1} (radian)";
+  _title_etaPhi_1    = "#eta_{1}#times#varphi_{1}";
+  _title_pt_1        = "p_{t,1} (GeV/c)";
+  _title_n_1         = "n_{1}";
+  _title_SumPt_1     = "#Sigma p_{t,1} (GeV/c)";
+  _title_AvgPt_1     = "#LT p_{t,1} #GT (GeV/c)";
+  _title_AvgN_1      = "#LT n_{1} #GT";
+  _title_AvgSumPt_1  = "#LT #Sigma p_{t,1} #GT (GeV/c)";
+  
+  _title_eta_2       = "#eta_{2}";
+  _title_phi_2       = "#varphi_{2} (radian)";
+  _title_etaPhi_2    = "#eta_{2}#times#varphi_{2}";
+  _title_pt_2        = "p_{t,2} (GeV/c)";
+  _title_n_2         = "n_{2}";
+  _title_SumPt_2     = "#Sigma p_{t,1} (GeV/c)";
+  _title_AvgPt_2     = "#LT p_{t,2} #GT (GeV/c)";
+  _title_AvgN_2      = "#LT n_{2} #GT";
+  _title_AvgSumPt_2  = "#LT #Sigma p_{t,2} #GT (GeV/c)";
+  
+  _title_etaPhi_12   = "#eta_{1}#times#varphi_{1}#times#eta_{2}#times#varphi_{2}";
+  
+  _title_AvgN2_12       = "#LT n_{2} #GT";;
+  _title_AvgSumPtPt_12  = "#LT #Sigma p_{t,1}p_{t,2} #GT";;
+  _title_AvgSumPtN_12   = "#LT #Sigma p_{t,1}N #GT";;
+  _title_AvgNSumPt_12   = "#LT N#Sigma p_{t,2} #GT";;
+  
+  
+  vsZ         = "_vsZ";
+  vsM         = "_vsM";
+  vsPt         = "_vsPt";
+  vsPhi        = "_vsPhi"; 
+  vsEta        = "_vsEta"; 
+  vsEtaPhi     = "_vsEtaPhi"; 
+  vsPtVsPt     = "_vsPtVsPt";
+  
+  
+  if (_useWeights)
+    {
+    int iZ, iEtaPhi, iPt;
+    int iZ1,iEtaPhi1,iPt1;
+    int a, b;
+    if (_weight_1)
+      {
+      _correctionWeight_1 = new float[_nBins_vertexZ*_nBins_etaPhi_1*_nBins_pt_1];
+      a = _nBins_pt_1;
+      b = _nBins_etaPhi_1*_nBins_pt_1;
+      for (iZ=0,iZ1=1; iZ<_nBins_vertexZ; iZ++, iZ1++)
+        {
+        for (iEtaPhi=0,iEtaPhi1=1; iEtaPhi<_nBins_etaPhi_1; iEtaPhi++, iEtaPhi1++)
+          {
+          for (iPt=0,iPt1=1; iPt<_nBins_pt_1; iPt++, iPt1++)
+            {
+            _correctionWeight_1[iZ*b+iEtaPhi*a+iPt] = _weight_1->GetBinContent(iZ1,iEtaPhi1,iPt1);
+            }      
+          }
+        }
+      } // _weight_1
+    else
+      {
+      AliError("AliAnalysisTaskDptDptQA:: _weight_1 is a null pointer.");
+      return;
+      }
+    if (!_sameFilter) 
+      {
+      if (_weight_2)
+        {
+        _correctionWeight_2 = new float[_nBins_vertexZ*_nBins_etaPhi_2*_nBins_pt_2];
+        a = _nBins_pt_2;
+        b = _nBins_etaPhi_2*_nBins_pt_2;
+        for (iZ=0,iZ1=1; iZ<_nBins_vertexZ; iZ++, iZ1++)
+          {
+          for (iEtaPhi=0,iEtaPhi1=1; iEtaPhi<_nBins_etaPhi_2; iEtaPhi++, iEtaPhi1++)
+            {
+            for (iPt=0,iPt1=1; iPt<_nBins_pt_2; iPt++, iPt1++)
+              {
+              _correctionWeight_2[iZ*b+iEtaPhi*a+iPt] = _weight_2->GetBinContent(iZ1,iEtaPhi1,iPt1);
+              }      
+            }
+          }
+        } // _weight_2
+      else
+        {
+        AliError("AliAnalysisTaskDptDptQA:: _weight_1 is a null pointer.");
+        return;
+        }
+      }
+    }
+  
+  createHistograms();
+  PostData(0,_outputHistoList);
+  
+  //cout<< "AliAnalysisTaskDptDptQA::CreateOutputObjects() DONE " << endl;
+  
+}
+
+void  AliAnalysisTaskDptDptQA::createHistograms()
+{
+  AliInfo(" AliAnalysisTaskDptDptQA::createHistoHistograms() Creating Event Histos");
+  TString name;
+  
+  name = "eventAccounting";
+  
+   _eventAccounting      = createHisto1D(name,name,10, -0.5, 9.5, "event Code", _title_counts);
+  
+  name = "m0"; _m0      = createHisto1D(name,name,_nBins_M1, _min_M1, _max_M1, _title_m0, _title_counts);
+  name = "m1"; _m1      = createHisto1D(name,name,_nBins_M1, _min_M1, _max_M1, _title_m1, _title_counts);
+  name = "m2"; _m2      = createHisto1D(name,name,_nBins_M2, _min_M2, _max_M2, _title_m2, _title_counts);
+  name = "m3"; _m3      = createHisto1D(name,name,_nBins_M3, _min_M3, _max_M3, _title_m3, _title_counts);
+  name = "m4"; _m4      = createHisto1D(name,name,_nBins_M4, _min_M4, _max_M4, _title_m4, _title_counts);
+  name = "m5"; _m5      = createHisto1D(name,name,_nBins_M5, _min_M5, _max_M5, _title_m5, _title_counts);
+  name = "m6"; _m6      = createHisto1D(name,name,_nBins_M6, _min_M6, _max_M6, _title_m6, _title_counts);
+  name = "zV"; _vertexZ = createHisto1D(name,name,100, -10, 10, "z-Vertex (cm)", _title_counts);
+  
+
+  name = "Eta";     _etadis   = createHisto1F(name,name, 200, -1.0, 1.0, "#eta","counts");
+  name = "Phi";     _phidis   = createHisto1F(name,name, 360, 0.0, 6.4, "#phi","counts");
+  name = "DCAz";    _dcaz     = createHisto1F(name,name, 500, -5.0, 5.0, "dcaZ","counts");
+  name = "DCAxy";   _dcaxy    = createHisto1F(name,name, 500, -5.0, 5.0, "dcaXY","counts");
+  name = "pTspectra";   _spectra    = createHisto1F(name,name, 300, 0.1, 2.5, "pT","counts");
+
+  //name = "Nclus1";   _Ncluster1    = createHisto1F(name,name, 200, 0, 200, "Ncluster1","counts");
+  //name = "Nclus2";   _Ncluster2    = createHisto1F(name,name, 200, 0, 200, "Ncluster2","counts");
+  
+  if (_singlesOnly)
+    {
+    name = n1Name+part_1_Name+vsPt;              _n1_1_vsPt              = createHisto1F(name,name, _nBins_pt_1,  _min_pt_1,  _max_pt_1,   _title_pt_1,  _title_AvgN_1);
+    name = n1Name+part_1_Name+vsZ+vsEtaPhi+vsPt; _n1_1_vsZVsEtaVsPhiVsPt = createHisto3F(name,name, _nBins_vertexZ,_min_vertexZ,_max_vertexZ, _nBins_etaPhi_1, 0., double(_nBins_etaPhi_1), _nBins_pt_1, _min_pt_1, _max_pt_1, "zVertex", _title_etaPhi_1,  _title_pt_1);
+
+    name = n1Name+part_2_Name+vsPt;              _n1_2_vsPt              = createHisto1F(name,name, _nBins_pt_2,  _min_pt_2,  _max_pt_2,   _title_pt_2,  _title_AvgN_2);
+    name = n1Name+part_2_Name+vsZ+vsEtaPhi+vsPt; _n1_2_vsZVsEtaVsPhiVsPt = createHisto3F(name,name, _nBins_vertexZ,_min_vertexZ,_max_vertexZ, _nBins_etaPhi_2, 0., double(_nBins_etaPhi_2), _nBins_pt_2, _min_pt_2, _max_pt_2, "zVertex", _title_etaPhi_2,  _title_pt_2);
+
+    }
+  else
+    {
+    name = n1Name+part_1_Name+vsEtaPhi;       _n1_1_vsEtaVsPhi      = createHisto2F(name,name, _nBins_eta_1, _min_eta_1, _max_eta_1,  _nBins_phi_1, _min_phi_1, _max_phi_1,  _title_eta_1,  _title_phi_1,  _title_AvgN_1);
+    name = s1ptName+part_1_Name+vsEtaPhi;     _s1pt_1_vsEtaVsPhi    = createHisto2F(name,name, _nBins_eta_1, _min_eta_1, _max_eta_1,  _nBins_phi_1, _min_phi_1, _max_phi_1,  _title_eta_1,  _title_phi_1,  _title_AvgSumPt_1);
+    name = n1Name+part_1_Name+vsM;            _n1_1_vsM             = createProfile(name,name, _nBins_M4, _min_M4, _max_M4, _title_m4, _title_AvgN_1);
+    name = s1ptName+part_1_Name+vsM;          _s1pt_1_vsM           = createProfile(name,name, _nBins_M4, _min_M4, _max_M4, _title_m4, _title_AvgSumPt_1);
+    name = n1NwName+part_1_Name+vsM;          _n1Nw_1_vsM           = createProfile(name,name, _nBins_M4, _min_M4, _max_M4, _title_m4, _title_AvgN_1);
+    name = s1ptNwName+part_1_Name+vsM;        _s1ptNw_1_vsM         = createProfile(name,name, _nBins_M4, _min_M4, _max_M4, _title_m4, _title_AvgSumPt_1);
+
+    name = n1Name+part_2_Name+vsEtaPhi;       _n1_2_vsEtaVsPhi      = createHisto2F(name,name, _nBins_eta_2, _min_eta_2, _max_eta_2,  _nBins_phi_2, _min_phi_2, _max_phi_2,  _title_eta_2,  _title_phi_2,  _title_AvgN_2);
+    name = s1ptName+part_2_Name+vsEtaPhi;     _s1pt_2_vsEtaVsPhi    = createHisto2F(name,name, _nBins_eta_2, _min_eta_2, _max_eta_2,  _nBins_phi_2, _min_phi_2, _max_phi_2,  _title_eta_2,  _title_phi_2,  _title_AvgSumPt_2);
+    name = n1Name+part_2_Name + vsM;          _n1_2_vsM             = createProfile(name,name, _nBins_M4, _min_M4, _max_M4, _title_m4, _title_AvgN_2);
+    name = s1ptName+part_2_Name + vsM;        _s1pt_2_vsM           = createProfile(name,name, _nBins_M4, _min_M4, _max_M4, _title_m4, _title_AvgSumPt_2);
+    name = n1NwName+part_2_Name+vsM;          _n1Nw_2_vsM           = createProfile(name,name, _nBins_M4, _min_M4, _max_M4, _title_m4, _title_AvgN_1);
+    name = s1ptNwName+part_2_Name+vsM;        _s1ptNw_2_vsM         = createProfile(name,name, _nBins_M4, _min_M4, _max_M4, _title_m4, _title_AvgSumPt_1);
+
+    name = n2Name+pair_12_Name+vsEtaPhi;      _n2_12_vsEtaPhi       = createHisto1F(name,name, _nBins_etaPhi_12, 0.,        double(_nBins_etaPhi_12), _title_etaPhi_12, _title_AvgN2_12);        
+    name = s2PtPtName+pair_12_Name + vsEtaPhi;_s2PtPt_12_vsEtaPhi   = createHisto1F(name,name, _nBins_etaPhi_12, 0.,        double(_nBins_etaPhi_12), _title_etaPhi_12,  _title_AvgSumPtPt_12);    
+    name = s2PtNName+pair_12_Name + vsEtaPhi; _s2PtN_12_vsEtaPhi    = createHisto1F(name,name, _nBins_etaPhi_12, 0.,        double(_nBins_etaPhi_12), _title_etaPhi_12,  _title_AvgSumPtN_12);    
+    name = s2NPtName+pair_12_Name + vsEtaPhi; _s2NPt_12_vsEtaPhi    = createHisto1F(name,name, _nBins_etaPhi_12, 0.,        double(_nBins_etaPhi_12), _title_etaPhi_12,  _title_AvgNSumPt_12);    
+    name = n2Name+pair_12_Name+vsPtVsPt;      _n2_12_vsPtVsPt       = createHisto2F(name,name, _nBins_pt_1, _min_pt_1, _max_pt_1, _nBins_pt_2, _min_pt_2, _max_pt_2, _title_pt_1, _title_pt_2, _title_AvgN2_12);        
+    
+    name = n2Name+pair_12_Name + vsM;         _n2_12_vsM            = createProfile(name,name, _nBins_M4, _min_M4, _max_M4, _title_m4, _title_AvgN2_12);        
+    name = s2PtPtName+pair_12_Name + vsM;     _s2PtPt_12_vsM        = createProfile(name,name, _nBins_M4, _min_M4, _max_M4, _title_m4, _title_AvgSumPtPt_12);    
+    name = s2PtNName+pair_12_Name + vsM;      _s2PtN_12_vsM         = createProfile(name,name, _nBins_M4, _min_M4, _max_M4, _title_m4, _title_AvgSumPtN_12);       
+    name = s2NPtName+pair_12_Name + vsM;      _s2NPt_12_vsM         = createProfile(name,name, _nBins_M4, _min_M4, _max_M4, _title_m4, _title_AvgNSumPt_12);     
+    
+    name = n2NwName+pair_12_Name + vsM;       _n2Nw_12_vsM          = createProfile(name,name, _nBins_M4, _min_M4, _max_M4, _title_m4, _title_AvgN2_12);        
+    name = s2PtPtNwName+pair_12_Name + vsM;   _s2PtPtNw_12_vsM      = createProfile(name,name, _nBins_M4, _min_M4, _max_M4, _title_m4, _title_AvgSumPtPt_12);    
+    name = s2PtNNwName+pair_12_Name + vsM;    _s2PtNNw_12_vsM       = createProfile(name,name, _nBins_M4, _min_M4, _max_M4, _title_m4, _title_AvgSumPtN_12);       
+    name = s2NPtNwName+pair_12_Name + vsM;    _s2NPtNw_12_vsM       = createProfile(name,name, _nBins_M4, _min_M4, _max_M4, _title_m4, _title_AvgNSumPt_12);     
+    
+    name = "mInv";     _invMass     = createHisto2F(name,name, 10, 0.0, 2.0, 200, 0.4, 0.6, "pT","InvMass","ptvsmass"); 
+    
+    }
+  
+  AliInfo(" AliAnalysisTaskDptDptQA::createHistoHistograms() All Done"); 
+}
+//-----------------------//
+
+void  AliAnalysisTaskDptDptQA::finalizeHistograms()
+{
+  
+  AliInfo("AliAnalysisTaskDptDptQA::finalizeHistograms() starting");
+  AliInfo(Form("CorrelationAnalyzers::finalizeHistograms()   _eventCount : %d",int(_eventCount)));
+  
+  AliInfo("AliAnalysisTaskDptDptQA::finalizeHistograms()  Done ");
+}
+//--------------//
+
+
+void  AliAnalysisTaskDptDptQA::UserExec(Option_t */*option*/)
+{
+  
+  int    k1,k2;
+  int  charge;
+  float  q, phi, pt, eta,  px, py, pz;
+  //int    ij;
+  //int    id_1, q_1, iPt_1;
+  //float  pt_1, px_1, py_1, pz_1, corr_1;
+  //int    id_2, q_2,  iPt_2;
+  //float  pt_2, px_2, py_2, pz_2, corr_2;
+  //float  ptpt;
+  int    iVertex, iVertexP1, iVertexP2;
+  //int    iZEtaPhiPt;
+  //float  massElecSq = 1.94797849000000016e-02;
+  //double b[2];
+  //double bCov[3];
+  const  AliAODVertex* vertex;
+  bool   bitOK;
+  
+  AliAnalysisManager* manager = AliAnalysisManager::GetAnalysisManager();
+  if (!manager) {
+    return;
+  }
+  AliAODInputHandler* inputHandler = dynamic_cast<AliAODInputHandler*> (manager->GetInputEventHandler());
+  if (!inputHandler) {
+    return;
+  }
+  
+  fAODEvent = dynamic_cast<AliAODEvent*>(InputEvent());
+  //AliAODEvent* fAODEvent = dynamic_cast<AliAODEvent*>(InputEvent());
+  
+  if (!fAODEvent)
+    {
+      return;
+    }
+  fPIDResponse =inputHandler->GetPIDResponse();
+  if (!fPIDResponse){
+    AliFatal("This Task needs the PID response attached to the inputHandler");
+    return;
+  }
+  
+  // count all events looked at here
+  _eventCount++;
+  
+  if (_eventAccounting)
+    {
+      _eventAccounting->Fill(0);// count all calls to this function
+    }
+  else 
+    {
+      
+      return;
+    }
+  
+  _eventAccounting->Fill(1);// count all calls to this function with a valid pointer
+  //reset single particle counters
+  k1 = k2 = 0;
+  __n1_1 = __n1_2 = __s1pt_1 = __s1pt_2 = __n1Nw_1 = __n1Nw_2 = __s1ptNw_1 = __s1ptNw_2 = 0;
+  
+  float v0Centr  = -999.;
+  float v0ACentr  = -999.;
+  float trkCentr = -999.;
+  float spdCentr = -999.;
+  
+  float vertexX  = -999;
+  float vertexY  = -999;
+  float vertexZ  = -999;
+  //float vertexXY = -999;
+  // float dcaZ     = -999;
+  //float dcaXY    = -999;
+  float centrality = -999;
+  
+  float Kaon1Charge[50000];
+  float Kaon1Px[50000];
+  float Kaon1Py[50000];
+  float Kaon1Pz[50000];
+  float Kaon2Charge[50000];
+  float Kaon2Px[50000];
+  float Kaon2Py[50000];
+  float Kaon2Pz[50000];
+
+  int nKaon1s = 0;
+  int nKaon2s = 0;
+
+  //k1Mass = 0.139570;
+  //kMass = 0.139570;
+  
+
+  if(fAODEvent)
+    {
+      //Centrality
+      AliCentrality* centralityObject =  fAODEvent->GetHeader()->GetCentralityP();
+      if (centralityObject)
+       {
+         //cout << "AliAnalysisTaskDptDptQA::UserExec(Option_t *option) - 6" << endl;
+         
+         v0Centr  = centralityObject->GetCentralityPercentile("V0M");
+         v0ACentr  = centralityObject->GetCentralityPercentile("V0A");
+         trkCentr = centralityObject->GetCentralityPercentile("TRK"); 
+         spdCentr = centralityObject->GetCentralityPercentile("CL1");
+         
+       }
+      
+      _nTracks  =fAODEvent->GetNumberOfTracks();//NEW Test
+      
+      _mult3    = _nTracks; 
+      _mult4    = v0Centr;
+      _mult4a    = v0ACentr;
+      _mult5    = trkCentr;
+      _mult6    = spdCentr;
+      _field    = fAODEvent->GetMagneticField(); 
+      
+      //_centralityMethod
+      switch (_centralityMethod)
+       {
+       case 0: centrality = _mult0; break;
+       case 1: centrality = _mult1; break;
+       case 2: centrality = _mult2; break;
+       case 3: centrality = _mult3; break;
+       case 4: centrality = _mult4; break;
+       case 5: centrality = _mult5; break;
+       case 6: centrality = _mult6; break;
+       case 7: centrality = _mult4a; break;
+       }
+      
+      
+      if ( centrality < _centralityMin ||  centrality > _centralityMax )
+       {
+         return;
+       }
+      _eventAccounting->Fill(2);// count all events with right centrality
+      
+      // filter on z and xy vertex
+      vertex = (AliAODVertex*) fAODEvent->GetPrimaryVertex();
+      // Double_t V[2];
+      //vertex->GetXYZ(V);      
+
+      if(vertex)
+       {
+         Double32_t fCov[6];
+         vertex->GetCovarianceMatrix(fCov);
+         if(vertex->GetNContributors() > 0)
+           {
+             if(fCov[5] != 0)
+               {
+                 vertexX = vertex->GetX();
+                 vertexY = vertex->GetY();
+                 vertexZ = vertex->GetZ();
+                 
+                 if(TMath::Abs(vertexZ) > 10)
+                   {
+                     return;
+                   } // Z-Vertex Cut  
+               }
+           }
+       }
+      
+      _vertexZ->Fill(vertexZ);
+      
+      iVertex = int((vertexZ-_min_vertexZ)/_width_vertexZ);
+      iVertexP1 = iVertex*_nBins_etaPhiPt_1;
+      iVertexP2 = iVertex*_nBins_etaPhiPt_2;
+      if (iVertex<0 || iVertex>=_nBins_vertexZ)
+       {
+         AliError("AliAnalysisTaskDptDptQA::Exec(Option_t *option) iVertex<0 || iVertex>=_nBins_vertexZ ");
+         return;
+       }
+      _eventAccounting->Fill(3);// count all calls to this function with a valid pointer
+      //====================== 
+      
+      //*********************************************************
+      TExMap *trackMap = new TExMap();//Mapping matrix----                                            
+      //1st loop track                                                                                
+      for(Int_t i = 0; i < _nTracks; i++)
+       {
+         AliAODTrack* aodTrack = dynamic_cast<AliAODTrack *>(fAODEvent->GetTrack(i));
+         if(!aodTrack) {
+           AliError(Form("ERROR: Could not retrieve AODtrack %d",i));
+           continue;
+         }
+         Int_t gID = aodTrack->GetID();
+         if (aodTrack->TestFilterBit(1)) trackMap->Add(gID, i);//Global tracks                       
+       }
+           
+      AliAODTrack* newAodTrack;
+      
+      //Track Loop starts here
+      for (int iTrack=0; iTrack< _nTracks; iTrack++)
+       {
+         AliAODTrack* t = dynamic_cast<AliAODTrack *>(fAODEvent->GetTrack(iTrack));
+         if (!t) {
+           AliError(Form("Could not receive track %d", iTrack));
+           continue;
+         }
+         
+         bitOK  = t->TestFilterBit(_trackFilterBit);
+         if (!bitOK) continue; //128bit or 272bit
+                 
+         Int_t gID = t->GetID();
+         newAodTrack = gID >= 0 ?t : fAODEvent->GetTrack(trackMap->GetValue(-1-gID));
+         
+         q      = t->Charge();
+         charge = int(q);
+         phi    = t->Phi();
+         pt     = t->Pt();
+         px     = t->Px();
+         py     = t->Py();
+         pz     = t->Pz();
+         eta    = t->Eta();
+         //dcaXY = t->DCA(); 
+         //dcaZ  = t->ZAtDCA();  
+
+         TVector3 mom(px, py, pz);
+
+         //Double_t nsigmaelectron = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(newAodTrack,(AliPID::EParticleType)AliPID::kElectron));
+         Double_t nsigmapion = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(newAodTrack,(AliPID::EParticleType)AliPID::kPion));
+         //Double_t nsigmakaon = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(newAodTrack,(AliPID::EParticleType)AliPID::kKaon));
+         //Double_t nsigmaproton = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(newAodTrack,(AliPID::EParticleType)AliPID::kProton));
+         
+         if(charge == 0) continue;
+         
+         // Kinematics cuts used                                                                                        
+         if( pt < _min_pt_1 || pt > _max_pt_1) continue;
+         if( eta < _min_eta_1 || eta > _max_eta_1) continue;
+
+         Double_t pos[3];
+         newAodTrack->GetXYZ(pos);
+
+         Double_t DCAX = pos[0] - vertexX;
+         Double_t DCAY = pos[1] - vertexY;
+         Double_t DCAZ = pos[2] - vertexZ;
+               
+         Double_t DCAXY = TMath::Sqrt((DCAX*DCAX) + (DCAY*DCAY));
+         
+         if (DCAZ     <  _dcaZMin || 
+             DCAZ     >  _dcaZMax ||
+             DCAXY    >  _dcaXYMax ) continue; 
+         
+         //==== QA ===========================
+         _dcaz->Fill(DCAZ);
+         _dcaxy->Fill(DCAXY);
+         _etadis->Fill(eta);
+         _phidis->Fill(phi);
+         _spectra->Fill(pt);
+         //===================================
+
+         if(TMath::Abs(nsigmapion) < fNSigmaCut && charge == -1) {
+           Kaon1Charge[nKaon1s] = q;
+           Kaon1Px[nKaon1s] = mom.X();
+           Kaon1Py[nKaon1s] = mom.Y();
+           Kaon1Pz[nKaon1s] = mom.Z();
+           nKaon1s++;
+
+         }
+         if(TMath::Abs(nsigmapion) < fNSigmaCut && charge == 1) {
+           Kaon2Charge[nKaon2s] = q;
+           Kaon2Px[nKaon1s] = mom.X();
+           Kaon2Py[nKaon1s] = mom.Y();
+           Kaon2Pz[nKaon1s] = mom.Z();
+           nKaon2s++;
+
+         }
+       
+         TLorentzVector pion1(0,0,0,0);
+         TLorentzVector pion2(0,0,0,0);
+         TLorentzVector Kaon(0,0,0,0);
+
+         for(int i=0; i<nKaon1s; i++)
+           {
+             pion1.SetXYZM(Kaon1Px[i],Kaon1Py[i],Kaon1Pz[i],0.139570);
+             for(int j=0; j<nKaon2s; j++)
+               {
+                 pion2.SetXYZM(Kaon2Px[j],Kaon2Py[j],Kaon2Pz[j],0.139570);
+                 Kaon = pion1 + pion2;
+                 float rapidity = Kaon.Rapidity();
+                 float pairpt = Kaon.Pt();
+                 if( rapidity < -0.50 || rapidity > 0.50 ) continue;
+                 _invMass->Fill(pairpt, Kaon.M());
+               }
+           }
+  
+         } //iTrack
+    } //aod 
+}
+
+void   AliAnalysisTaskDptDptQA::FinishTaskOutput()
+{
+  AliInfo("AliAnalysisTaskDptDptQA::FinishTaskOutput() Starting.");
+  Printf("= 0 ====================================================================");
+  finalizeHistograms();
+  AliInfo("= 1 ====================================================================");
+  PostData(0,_outputHistoList);
+  AliInfo("= 2 ====================================================================");
+  AliInfo("AliAnalysisTaskDptDptQA::FinishTaskOutput() Done.");
+}
+
+void   AliAnalysisTaskDptDptQA::Terminate(Option_t* /*option*/)
+{
+  AliInfo("AliAnalysisTaskDptDptQA::Terminate() Starting/Done.");
+}
+
+
+//Tools
+//===================================================================================================
+void  AliAnalysisTaskDptDptQA::fillHistoWithArray(TH1 * h, float * array, int size)
+{
+  int i, i1;
+  float v1, ev1, v2, ev2, sum, esum;
+  for (i=0, i1=1; i<size; ++i,++i1)
+    {
+    v1  = array[i]; ev1 = sqrt(v1);
+    v2  = h->GetBinContent(i1);
+    ev2 = h->GetBinError(i1);
+    sum = v1 + v2;
+    esum = sqrt(ev1*ev1+ev2*ev2);
+    h->SetBinContent(i1,sum);
+    h->SetBinError(i1,esum);
+    }
+}
+
+void  AliAnalysisTaskDptDptQA::fillHistoWithArray(TH2 * h, float * array, int size1, int size2)
+{
+  int i, i1;
+  int j, j1;
+  float v1, ev1, v2, ev2, sum, esum;
+  for (i=0, i1=1; i<size1; ++i,++i1)
+    {
+    for (j=0, j1=1; j<size2; ++j,++j1)
+      {
+      v1  = array[i*size2+j]; ev1 = sqrt(v1);
+      v2  = h->GetBinContent(i1,j1);
+      ev2 = h->GetBinError(i1,j1);
+      sum = v1 + v2;
+      esum = sqrt(ev1*ev1+ev2*ev2);
+      h->SetBinContent(i1,j1,sum);
+      h->SetBinError(i1,j1,esum);
+      }
+    }
+}
+
+void  AliAnalysisTaskDptDptQA::fillHistoWithArray(TH3 * h, float * array, int size1, int size2, int size3)
+{
+  int i, i1;
+  int j, j1;
+  int k, k1;
+  float v1, ev1, v2, ev2, sum, esum;
+  int size23 = size2*size3;
+  for (i=0, i1=1; i<size1; ++i,++i1)
+    {
+    for (j=0, j1=1; j<size2; ++j,++j1)
+      {
+      for (k=0, k1=1; k<size3; ++k,++k1)
+        {
+        v1  = array[i*size23+j*size3+k]; ev1 = sqrt(v1);
+        v2  = h->GetBinContent(i1,j1,k1);
+        ev2 = h->GetBinError(i1,j1,k1);
+        sum = v1 + v2;
+        esum = sqrt(ev1*ev1+ev2*ev2);
+        h->SetBinContent(i1,j1,k1,sum);
+        h->SetBinError(i1,j1,k1,esum);
+        }
+      }
+    }
+}
+
+void  AliAnalysisTaskDptDptQA::fillHistoWithArray(TH1 * h, double * array, int size)
+{
+  int i, i1;
+  double v1, ev1, v2, ev2, sum, esum;
+  for (i=0, i1=1; i<size; ++i,++i1)
+    {
+    v1  = array[i]; ev1 = sqrt(v1);
+    v2  = h->GetBinContent(i1);
+    ev2 = h->GetBinError(i1);
+    sum = v1 + v2;
+    esum = sqrt(ev1*ev1+ev2*ev2);
+    h->SetBinContent(i1,sum);
+    h->SetBinError(i1,esum);
+    }
+}
+
+void  AliAnalysisTaskDptDptQA::fillHistoWithArray(TH2 * h, double * array, int size1, int size2)
+{
+  int i, i1;
+  int j, j1;
+  double v1, ev1, v2, ev2, sum, esum;
+  for (i=0, i1=1; i<size1; ++i,++i1)
+    {
+    for (j=0, j1=1; j<size2; ++j,++j1)
+      {
+      v1  = array[i*size2+j]; ev1 = sqrt(v1);
+      v2  = h->GetBinContent(i1,j1);
+      ev2 = h->GetBinError(i1,j1);
+      sum = v1 + v2;
+      esum = sqrt(ev1*ev1+ev2*ev2);
+      h->SetBinContent(i1,j1,sum);
+      h->SetBinError(i1,j1,esum);
+      }
+    }
+}
+
+void  AliAnalysisTaskDptDptQA::fillHistoWithArray(TH3 * h, double * array, int size1, int size2, int size3)
+{
+  int i, i1;
+  int j, j1;
+  int k, k1;
+  double v1, ev1, v2, ev2, sum, esum;
+  int size23 = size2*size3;
+  for (i=0, i1=1; i<size1; ++i,++i1)
+    {
+    for (j=0, j1=1; j<size2; ++j,++j1)
+      {
+      for (k=0, k1=1; k<size3; ++k,++k1)
+        {
+        v1  = array[i*size23+j*size3+k]; ev1 = sqrt(v1);
+        v2  = h->GetBinContent(i1,j1,k1);
+        ev2 = h->GetBinError(i1,j1,k1);
+        sum = v1 + v2;
+        esum = sqrt(ev1*ev1+ev2*ev2);
+        h->SetBinContent(i1,j1,k1,sum);
+        h->SetBinError(i1,j1,k1,esum);
+        }
+      }
+    }
+}
+
+//________________________________________________________________________
+double *  AliAnalysisTaskDptDptQA::getDoubleArray(int size, double v)
+{
+  /// Allocate an array of type double with n values
+  /// Initialize the array to the given value
+  double * array = new double [size];
+  for (int i=0;i<size;++i) array[i]=v;
+  return array;
+}
+
+//________________________________________________________________________
+float *  AliAnalysisTaskDptDptQA::getFloatArray(int size, float v)
+{
+  /// Allocate an array of type float with n values
+  /// Initialize the array to the given value
+  float * array = new float [size];
+  for (int i=0;i<size;++i) array[i]=v;
+  return array;
+}
+
+
+//________________________________________________________________________
+TH1D * AliAnalysisTaskDptDptQA::createHisto1D(const TString &  name, const TString &  title, 
+                                                      int n, double xMin, double xMax, 
+                                                      const TString &  xTitle, const TString &  yTitle)
+{
+  //CreateHisto new 1D historgram
+  AliInfo(Form("createHisto 1D histo %s   nBins: %d  xMin: %f   xMax: %f",name.Data(),n,xMin,xMax));
+  TH1D * h = new TH1D(name,title,n,xMin,xMax);
+  h->GetXaxis()->SetTitle(xTitle);
+  h->GetYaxis()->SetTitle(yTitle);
+  addToList(h);
+  return h;
+}
+
+
+//________________________________________________________________________
+TH1D * AliAnalysisTaskDptDptQA::createHisto1D(const TString &  name, const TString &  title, 
+                                                      int n, double * bins, 
+                                                      const TString &  xTitle, const TString &  yTitle)
+{
+  AliInfo(Form("createHisto 1D histo %s   with %d non uniform nBins",name.Data(),n));
+  TH1D * h = new TH1D(name,title,n,bins);
+  h->GetXaxis()->SetTitle(xTitle);
+  h->GetYaxis()->SetTitle(yTitle);
+  addToList(h);
+  return h;
+}
+
+
+//________________________________________________________________________
+TH2D * AliAnalysisTaskDptDptQA::createHisto2D(const TString &  name, const TString &  title, 
+                                                      int nx, double xMin, double xMax, int ny, double yMin, double yMax, 
+                                                      const TString &  xTitle, const TString &  yTitle, const TString &  zTitle)
+{
+  AliInfo(Form("createHisto 2D histo %s  nx: %d  xMin: %f10.4 xMax: %f10.4  ny: %d   yMin: %f10.4 yMax: %f10.4",name.Data(),nx,xMin,xMax,ny,yMin,yMax));
+  TH2D * h = new TH2D(name,title,nx,xMin,xMax,ny,yMin,yMax);
+  h->GetXaxis()->SetTitle(xTitle);
+  h->GetYaxis()->SetTitle(yTitle);
+  h->GetZaxis()->SetTitle(zTitle);
+  addToList(h);
+  return h;
+}
+
+//________________________________________________________________________
+TH2D * AliAnalysisTaskDptDptQA::createHisto2D(const TString &  name, const TString &  title, 
+                                                      int nx, double* xbins, int ny, double yMin, double yMax, 
+                                                      const TString &  xTitle, const TString &  yTitle, const TString &  zTitle)
+{
+  AliInfo(Form("createHisto 2D histo %s   with %d non uniform nBins",name.Data(),nx));
+  TH2D * h;
+  h = new TH2D(name,title,nx,xbins,ny,yMin,yMax);
+  h->GetXaxis()->SetTitle(xTitle);
+  h->GetYaxis()->SetTitle(yTitle);
+  h->GetZaxis()->SetTitle(zTitle);
+  addToList(h);
+  return h;
+}
+
+//// F /////
+//________________________________________________________________________
+TH1F * AliAnalysisTaskDptDptQA::createHisto1F(const TString &  name, const TString &  title, 
+                                                        int n, double xMin, double xMax, 
+                                                        const TString &  xTitle, const TString &  yTitle)
+{
+  //CreateHisto new 1D historgram
+  AliInfo(Form("createHisto 1D histo %s   nBins: %d  xMin: %f   xMax: %f",name.Data(),n,xMin,xMax));
+  TH1F * h = new TH1F(name,title,n,xMin,xMax);
+  h->GetXaxis()->SetTitle(xTitle);
+  h->GetYaxis()->SetTitle(yTitle);
+  addToList(h);
+  return h;
+}
+
+
+//________________________________________________________________________
+TH1F * AliAnalysisTaskDptDptQA::createHisto1F(const TString &  name, const TString &  title, 
+                                                        int n, double * bins, 
+                                                        const TString &  xTitle, const TString &  yTitle)
+{
+  AliInfo(Form("createHisto 1D histo %s   with %d non uniform nBins",name.Data(),n));
+  TH1F * h = new TH1F(name,title,n,bins);
+  h->GetXaxis()->SetTitle(xTitle);
+  h->GetYaxis()->SetTitle(yTitle);
+  addToList(h);
+  return h;
+}
+
+
+//________________________________________________________________________
+TH2F * AliAnalysisTaskDptDptQA::createHisto2F(const TString &  name, const TString &  title, 
+                                                        int nx, double xMin, double xMax, int ny, double yMin, double yMax, 
+                                                        const TString &  xTitle, const TString &  yTitle, const TString &  zTitle)
+{
+  AliInfo(Form("createHisto 2D histo %s  nx: %d  xMin: %f10.4 xMax: %f10.4  ny: %d   yMin: %f10.4 yMax: %f10.4",name.Data(),nx,xMin,xMax,ny,yMin,yMax));
+  TH2F * h = new TH2F(name,title,nx,xMin,xMax,ny,yMin,yMax);
+  h->GetXaxis()->SetTitle(xTitle);
+  h->GetYaxis()->SetTitle(yTitle);
+  h->GetZaxis()->SetTitle(zTitle);
+  addToList(h);
+  return h;
+}
+
+//________________________________________________________________________
+TH2F * AliAnalysisTaskDptDptQA::createHisto2F(const TString &  name, const TString &  title, 
+                                                        int nx, double* xbins, int ny, double yMin, double yMax, 
+                                                        const TString &  xTitle, const TString &  yTitle, const TString &  zTitle)
+{
+  AliInfo(Form("createHisto 2D histo %s   with %d non uniform nBins",name.Data(),nx));
+  TH2F * h;
+  h = new TH2F(name,title,nx,xbins,ny,yMin,yMax);
+  h->GetXaxis()->SetTitle(xTitle);
+  h->GetYaxis()->SetTitle(yTitle);
+  h->GetZaxis()->SetTitle(zTitle);
+  addToList(h);
+  return h;
+}
+
+
+//________________________________________________________________________
+TH3F * AliAnalysisTaskDptDptQA::createHisto3F(const TString &  name, const TString &  title, 
+                                                      int nx, double xMin, double xMax, 
+                                                      int ny, double yMin, double yMax, 
+                                                      int nz, double zMin, double zMax, 
+                                                      const TString &  xTitle, const TString &  yTitle, const TString &  zTitle)
+{
+  AliInfo(Form("createHisto 2D histo %s  nx: %d  xMin: %f10.4 xMax: %f10.4  ny: %d   yMin: %f10.4 yMax: %f10.4 nz: %d   zMin: %f10.4 zMax: %f10.4",name.Data(),nx,xMin,xMax,ny,yMin,yMax,nz,zMin,zMax));
+  TH3F * h = new TH3F(name,title,nx,xMin,xMax,ny,yMin,yMax,nz,zMin,zMax);
+  h->GetXaxis()->SetTitle(xTitle);
+  h->GetYaxis()->SetTitle(yTitle);
+  h->GetZaxis()->SetTitle(zTitle);
+  addToList(h);
+  return h;
+}
+
+
+//________________________________________________________________________
+TProfile * AliAnalysisTaskDptDptQA::createProfile(const TString & name, const TString & description, 
+                                                            int nx,double xMin,double xMax,
+                                                            const TString &  xTitle, const TString &  yTitle)
+{
+  AliInfo(Form("createHisto 1D profile %s   nBins: %d  xMin: %f10.4 xMax: %f10.4",name.Data(),nx,xMin,xMax));
+  TProfile * h = new TProfile(name,description,nx,xMin,xMax);
+  h->GetXaxis()->SetTitle(xTitle);
+  h->GetYaxis()->SetTitle(yTitle);
+  addToList(h);
+  return h;  
+}
+
+//________________________________________________________________________
+TProfile * AliAnalysisTaskDptDptQA::createProfile(const TString &  name,const TString &  description, 
+                                                            int nx,  double* bins,
+                                                            const TString &  xTitle, const TString &  yTitle)
+{
+  AliInfo(Form("createHisto 1D profile %s  with %d non uniform bins",name.Data(),nx));
+  TProfile * h = new TProfile(name,description,nx,bins);
+  h->GetXaxis()->SetTitle(xTitle);
+  h->GetYaxis()->SetTitle(yTitle);
+  addToList(h);
+  return h;
+}
+
+
+void   AliAnalysisTaskDptDptQA::addToList(TH1 *h)
+{
+  if (_outputHistoList)
+    {
+    _outputHistoList->Add(h);
+    }
+  else
+    AliInfo("addToList(TH1 *h) _outputHistoList is null!!!!! Should abort ship");
+
+}
+
+
+
diff --git a/PWGCF/Correlations/DPhi/AliAnalysisTaskDptDptQA.h b/PWGCF/Correlations/DPhi/AliAnalysisTaskDptDptQA.h
new file mode 100644 (file)
index 0000000..0a5cdf6
--- /dev/null
@@ -0,0 +1,479 @@
+#ifndef AliAnalysisTaskDptDptQA_H_Included
+#define AliAnalysisTaskDptDptQA_H_Included
+
+#include "AliAnalysisTaskSE.h"
+#include "TString.h"
+#include "AliLog.h"
+
+#include "AliPID.h"
+#include "AliPIDResponse.h"
+
+class AliAODEvent;
+class AliESDEvent;
+class AliInputEventHandler;
+class TH1;
+class TH2;
+class TH2;
+class TH3;
+class TH1F;
+class TH2F;
+class TH2F;
+class TH3F;
+class TH1D;
+class TH2D;
+class TH2D;
+class TH3D;
+class TProfile;
+
+
+
+class AliAnalysisTaskDptDptQA : public AliAnalysisTaskSE
+{
+public:
+  AliAnalysisTaskDptDptQA();  
+  AliAnalysisTaskDptDptQA(const TString & name);
+  
+private:
+  AliAnalysisTaskDptDptQA(const  AliAnalysisTaskDptDptQA&);
+  const AliAnalysisTaskDptDptQA& operator=(const  AliAnalysisTaskDptDptQA&);
+
+public:
+  virtual ~AliAnalysisTaskDptDptQA();
+
+  // Implementation of interace methods
+  //virtual void   ConnectInputData(Option_t *);
+  virtual void   UserCreateOutputObjects();
+  virtual void   UserExec(Option_t *option);
+  virtual void   FinishTaskOutput();
+  virtual void   Terminate(Option_t* );   
+  virtual void   createHistograms();
+  virtual void   finalizeHistograms();
+  
+  virtual void   addToList(TH1 *h);
+
+  TH1D * createHisto1D(const TString &  name, const TString &  title,int n, double xmin, double xmax,const TString &  xTitle, const TString &  yTitle);
+  TH1D * createHisto1D(const TString &  name, const TString &  title,int n, double * bins,const TString &  xTitle, const TString &  yTitle);
+  TH2D * createHisto2D(const TString &  name, const TString &  title, 
+                       int nx, double xmin, double xmax, int ny, double ymin, double ymax, const TString &  xTitle, const TString &  yTitle, const TString &  zTitle);
+  TH2D * createHisto2D(const TString &  name, const TString &  title, int nx, double* xbins, int ny, double ymin, double ymax, 
+                       const TString &  xTitle, const TString &  yTitle, const TString &  zTitle);
+
+  TH1F * createHisto1F(const TString &  name, const TString &  title,int n, double xmin, double xmax,const TString &  xTitle, const TString &  yTitle);
+  TH1F * createHisto1F(const TString &  name, const TString &  title,int n, double * bins,const TString &  xTitle, const TString &  yTitle);
+  TH2F * createHisto2F(const TString &  name, const TString &  title, 
+                       int nx, double xmin, double xmax, int ny, double ymin, double ymax, const TString &  xTitle, const TString &  yTitle, const TString &  zTitle);
+  TH2F * createHisto2F(const TString &  name, const TString &  title, int nx, double* xbins, int ny, double ymin, double ymax, 
+                       const TString &  xTitle, const TString &  yTitle, const TString &  zTitle);
+  TH3F * createHisto3F(const TString &  name, const TString &  title, 
+                       int nx, double xmin, double xmax, int ny, double ymin, double ymax, int nz, double zmin, double zmax, 
+                       const TString &  xTitle, const TString &  yTitle, const TString &  zTitle);  
+  TProfile * createProfile(const TString &  title,const TString &  description, int n,  double xMin,double xMax,
+                           const TString &  xTitle, const TString &  yTitle);
+  TProfile * createProfile(const TString &  name,const TString &  description, 
+                           int nx,  double* bins,
+                           const TString &  xTitle, const TString &  yTitle);
+  
+  //________________________________________________________________________
+  
+  float  * getFloatArray(int size, float v);
+  double * getDoubleArray(int size, double v);
+  void fillHistoWithArray(TH1 * h, double * array, int size);
+  void fillHistoWithArray(TH2 * h, double * array, int size1, int size2);
+  void fillHistoWithArray(TH3 * h, double * array, int size1, int size2, int size3);
+  void fillHistoWithArray(TH1 * h, float * array, int size);
+  void fillHistoWithArray(TH2 * h, float * array, int size1, int size2);
+  void fillHistoWithArray(TH3 * h, float * array, int size1, int size2, int size3);
+
+
+
+  
+  virtual     void    SetDebugLevel( int v )              { _debugLevel   = v; }
+  virtual     void    SetSinglesOnly(int v)               { _singlesOnly  = v; } 
+  virtual     void    SetUseWeights(int v)                { _useWeights   = v; } 
+  virtual     void    SetSameFilter(int v)                { _sameFilter   = v; }
+  
+  virtual     void    SetRejectPileup(int v)              { _rejectPileup         = v; } 
+  virtual     void    SetRejectPairConversion(int v)      { _rejectPairConversion = v; } 
+  virtual     void    SetVertexZMin(double v)             { _vertexZMin           = v; } 
+  virtual     void    SetVertexZMax(double v)             { _vertexZMax           = v; } 
+  virtual     void    SetVertexXYMin(double v)            { _vertexXYMin          = v; } 
+  virtual     void    SetVertexXYMax(double v)            { _vertexXYMax          = v; } 
+  virtual     void    SetCentralityMethod(int v)          { _centralityMethod     = v; }
+  virtual     void    SetCentrality(double centralityMin, double centralityMax)
+  {
+    _centralityMin = centralityMin;
+    _centralityMax = centralityMax;
+  }
+  virtual     void    SetRequestedCharge_1(int v)     { _requestedCharge_1 = v; }
+  virtual     void    SetRequestedCharge_2(int v)     { _requestedCharge_2 = v; }
+  virtual     void    SetPtMin1( double v)            { _min_pt_1          = v; } 
+  virtual     void    SetPtMax1( double v)            { _max_pt_1          = v; } 
+  virtual     void    SetEtaMin1(double v)            { _min_eta_1         = v; } 
+  virtual     void    SetEtaMax1(double v)            { _max_eta_1         = v; } 
+  virtual     void    SetPtMin2( double v)            { _min_pt_2          = v; } 
+  virtual     void    SetPtMax2( double v)            { _max_pt_2          = v; } 
+  virtual     void    SetEtaMin2(double v)            { _min_eta_2         = v; } 
+  virtual     void    SetEtaMax2(double v)            { _max_eta_2         = v; } 
+  virtual     void    SetDcaZMin(double v)            { _dcaZMin           = v; } 
+  virtual     void    SetDcaZMax(double v)            { _dcaZMax           = v; } 
+  virtual     void    SetDcaXYMin(double v)           { _dcaXYMin          = v; } 
+  virtual     void    SetDcaXYMax(double v)           { _dcaXYMax          = v; }
+  virtual     void    SetTPCNclus(int v)              { _tpcnclus          = v; }
+  virtual     void    SetChi2PerNDF(double v)         { _chi2ndf           = v; }
+  virtual     void    SetDedxMin(double v)            { _dedxMin           = v; } 
+  virtual     void    SetDedxMax(double v)            { _dedxMax           = v; } 
+  virtual     void    SetNClusterMin(int v)           { _nClusterMin       = v; } 
+  virtual     void    SetTrackFilterBit(int v)        { _trackFilterBit    = v; }
+  virtual     void    SetWeigth_1(TH3F * v)           { _weight_1          = v; }
+  virtual     void    SetWeigth_2(TH3F * v)           { _weight_2          = v; }
+  
+  void SetNSigmaCut(Double_t nsigma){ fNSigmaCut = nsigma;}
+  
+protected:      
+  
+  // Handlers and events
+  AliAODEvent*             fAODEvent;             //! AOD Event 
+  AliESDEvent*             fESDEvent;             //! ESD Event 
+  AliInputEventHandler*    fInputHandler;    //! Generic InputEventHandler 
+  
+  AliPIDResponse*          fPIDResponse;
+
+  // Histogram settings
+  //TList*              _inputHistoList;
+  TList*              _outputHistoList;
+  //int _outputSlot;
+  
+  
+  double   _twoPi;
+  long     _eventCount;
+  
+  //configuration variables and filters
+  int      _debugLevel;
+  int      _singlesOnly; 
+  int      _useWeights; 
+  int      _sameFilter;
+  int      _rejectPileup; 
+  int      _rejectPairConversion; 
+  double   _vertexZMin; 
+  double   _vertexZMax; 
+  double   _vertexXYMin; 
+  double   _vertexXYMax; 
+  int      _centralityMethod;
+  double   _centralityMin;
+  double   _centralityMax;
+  int      _requestedCharge_1;
+  int      _requestedCharge_2;
+  double   _dcaZMin; 
+  double   _dcaZMax; 
+  double   _dcaXYMin; 
+  double   _dcaXYMax;
+  double   _dedxMin;
+  double   _dedxMax;
+  int      _nClusterMin; 
+  int      _trackFilterBit;
+  Double_t fNSigmaCut;  
+
+  int _tpcnclus;
+  double _chi2ndf;
+
+  //double _min_eta_1;
+  //double _max_eta_1;
+  //double _min_eta_2;
+  //double _max_eta_2;
+
+  // event and track wise variables
+  
+  double _field;
+  int    _nTracks;
+  double _mult0;
+  double _mult1;
+  double _mult2;
+  double _mult3;
+  double _mult4;
+  double _mult4a;
+  double _mult5;
+  double _mult6;
+  
+  //particle 1
+  int     arraySize;
+  int    *_id_1;               //!
+  int    *_charge_1;           //! 
+  //int  *  _iPhi_1;            //!
+  //int  *  _iEta_1;            //!
+  int    *_iEtaPhi_1;            //!
+  int    *_iPt_1;             //!
+  float  *_pt_1;               //!
+  float  *_px_1;              //!
+  float  *_py_1;              //!
+  float  *_pz_1;              //!
+ //float * _phi_1;             //!
+  //float*  _eta_1;             //!
+  float  *_correction_1;           //!
+  float  *_dedx_1;           //!
+  
+  //particle 2
+  int    *_id_2;              //!
+  int    *_charge_2;            //!
+  //int    *_iPhi_2;            //!
+  //int    *_iEta_2;            //!
+  int    *_iEtaPhi_2;            //!
+  int    *_iPt_2;             //!
+  float  *_pt_2;              //!
+  float  *_px_2;              //!
+  float  *_py_2;              //!
+  float  *_pz_2;              //!
+  //float  *_phi_2;             //!
+  //float  *_eta_2;             //!
+  float  *_correction_2;           //!
+  float  *_dedx_2;           //!
+  
+  float * _correctionWeight_1;           //!
+  float * _correctionWeight_2;           //!
+  
+  //histograming
+  int _nBins_M0;       double _min_M0;       double _max_M0;       double _width_M0;
+  int _nBins_M1;       double _min_M1;       double _max_M1;       double _width_M1;
+  int _nBins_M2;       double _min_M2;       double _max_M2;       double _width_M2;
+  int _nBins_M3;       double _min_M3;       double _max_M3;       double _width_M3;
+  int _nBins_M4;       double _min_M4;       double _max_M4;       double _width_M4;
+  int _nBins_M5;       double _min_M5;       double _max_M5;       double _width_M5;
+  int _nBins_M6;       double _min_M6;       double _max_M6;       double _width_M6;
+  
+  int _nBins_vertexZ;  double _min_vertexZ;  double _max_vertexZ;  double _width_vertexZ;
+  
+  int _nBins_pt_1;     double _min_pt_1;     double _max_pt_1;     double _width_pt_1;
+  int _nBins_phi_1;    double _min_phi_1;    double _max_phi_1;    double _width_phi_1;
+  int _nBins_eta_1;    double _min_eta_1;    double _max_eta_1;    double _width_eta_1;
+  int _nBins_etaPhi_1; 
+  int _nBins_etaPhiPt_1;
+  int _nBins_zEtaPhiPt_1;
+  
+  int _nBins_pt_2;     double _min_pt_2;     double _max_pt_2;     double _width_pt_2;
+  int _nBins_phi_2;    double _min_phi_2;    double _max_phi_2;    double _width_phi_2;
+  int _nBins_eta_2;    double _min_eta_2;    double _max_eta_2;    double _width_eta_2;
+  int _nBins_etaPhi_2; 
+  int _nBins_etaPhiPt_2;
+  int _nBins_zEtaPhiPt_2;
+  
+  int _nBins_etaPhi_12;
+    
+  double __n1_1;
+  double __n1_2;
+  double __n2_12;   
+  double __s1pt_1;
+  double __s1pt_2;
+  double __s2ptpt_12;
+  double __s2NPt_12;
+  double __s2PtN_12;
+  
+  double __n1Nw_1;
+  double __n1Nw_2;
+  double __n2Nw_12;   
+  double __s1ptNw_1;
+  double __s1ptNw_2;
+  double __s2ptptNw_12;
+  double __s2NPtNw_12;
+  double __s2PtNNw_12;
+  
+  double * __n1_1_vsPt;   //!
+  double * __n1_1_vsEtaPhi;     //! 
+  double * __s1pt_1_vsEtaPhi;    //!
+  float  * __n1_1_vsZEtaPhiPt;    //!
+    
+  double * __n1_2_vsPt;   //!
+  double * __n1_2_vsEtaPhi;     //! 
+  double * __s1pt_2_vsEtaPhi;    //!
+  float  * __n1_2_vsZEtaPhiPt;    //!
+  
+  //double * __n2_12_vsPtPt;
+  //double * __n2_12_vsEtaPhi;
+  //double * __s2ptpt_12_vsEtaPhi;
+  //double * __s2PtN_12_vsEtaPhi;
+  //double * __s2NPt_12_vsEtaPhi;
+  
+  double * __n2_12_vsPtPt;   //!
+  float  * __n2_12_vsEtaPhi;   //!
+  float  * __s2ptpt_12_vsEtaPhi;   //!
+  float  * __s2PtN_12_vsEtaPhi;   //!
+  float  * __s2NPt_12_vsEtaPhi;   //!
+  
+  TH3F * _weight_1;
+  TH3F * _weight_2;
+  TH1D * _eventAccounting;
+  TH1D * _m0;
+  TH1D * _m1;
+  TH1D * _m2;
+  TH1D * _m3;
+  TH1D * _m4;
+  TH1D * _m5;
+  TH1D * _m6;
+  TH1D * _vertexZ;
+
+  TH1F * _Ncluster1;
+  TH1F * _Ncluster2;
+  TH1F * _etadis;
+  TH1F * _phidis;
+  TH1F * _dcaz;
+  TH1F * _dcaxy;
+  TH1F * _spectra;
+  
+
+
+  // PARTICLE 1 (satisfies filter 1)
+  // Primary filled quantities
+  TH1F      *  _n1_1_vsPt;         
+  TH2F      *  _n1_1_vsEtaVsPhi;
+  TH2F      *  _s1pt_1_vsEtaVsPhi; 
+  TH3F      *  _n1_1_vsZVsEtaVsPhiVsPt;
+  TProfile *  _n1_1_vsM;  // w/ weight
+  TProfile *  _s1pt_1_vsM;
+  TProfile *  _n1Nw_1_vsM; // w/o weight
+  TProfile *  _s1ptNw_1_vsM;
+  TH2D      *  _dedxVsP_1;
+  TH2D      *  _corrDedxVsP_1;
+  TH2F      *  _betaVsP_1;
+  
+  // PARTICLE 2 (satisfies filter 2)
+  // Primary filled quantities
+  TH1F      *  _n1_2_vsPt;         
+  TH2F      *  _n1_2_vsEtaVsPhi;
+  TH2F      *  _s1pt_2_vsEtaVsPhi;
+  TH3F      *  _n1_2_vsZVsEtaVsPhiVsPt; 
+  TProfile *  _n1_2_vsM;
+  TProfile *  _s1pt_2_vsM;
+  TProfile *  _n1Nw_2_vsM; // w/o weight
+  TProfile *  _s1ptNw_2_vsM;
+  TH2D      *  _dedxVsP_2;
+  TH2D      *  _corrDedxVsP_2;
+  TH2F      *  _betaVsP_2;
+  
+  // Pairs 1 & 2  
+  TH1F      * _n2_12_vsEtaPhi;        
+  TH2F      * _n2_12_vsPtVsPt;
+  TH1F      * _s2PtPt_12_vsEtaPhi;    
+  TH1F      * _s2PtN_12_vsEtaPhi;       
+  TH1F      * _s2NPt_12_vsEtaPhi;     
+  
+  TProfile * _n2_12_vsM;        
+  TProfile * _s2PtPt_12_vsM;    
+  TProfile * _s2PtN_12_vsM;       
+  TProfile * _s2NPt_12_vsM; 
+  TProfile * _n2Nw_12_vsM;        
+  TProfile * _s2PtPtNw_12_vsM;    
+  TProfile * _s2PtNNw_12_vsM;       
+  TProfile * _s2NPtNw_12_vsM; 
+  
+  TH2F      * _invMass;
+    
+  TString n1Name;
+  TString n1NwName;
+  TString n2Name;
+  TString n2NwName;
+  TString n3Name;
+  TString n1n1Name;
+  TString n1n1n1Name;
+  TString n2n1Name;
+  TString r1Name;
+  TString r2Name;
+  TString r3Name;
+  TString r2r1Name;
+  TString c2Name;
+  TString c3Name;
+  TString d3Name;
+  TString p3Name;
+  TString cName;
+  
+  TString intR2Name;
+  TString binCorrName;
+  TString intBinCorrName;
+  
+  TString countsName;
+  TString part_1_Name;
+  TString part_2_Name;
+  TString part_3_Name;
+  TString pair_12_Name;
+  TString pair_13_Name;
+  TString pair_23_Name;
+  TString tripletName;
+  
+  TString avg;
+  TString avgName;
+  TString sumName;
+  TString s1ptName;
+  TString s1ptNwName;
+  TString s1DptName;
+  
+  TString s2PtPtName;
+  TString s2NPtName;
+  TString s2PtNName;
+  TString s2DptDptName;
+  TString s2PtPtNwName;
+  TString s2NPtNwName;
+  TString s2PtNNwName;
+  
+  TString ptName;
+  TString ptptName;
+  TString pt1pt1Name;
+  TString DptName;
+  TString DptDptName;
+  TString RDptDptName;
+  TString nPtName;
+  TString ptNName;
+  TString seanName;
+  
+  TString _title_counts;
+  
+  TString _title_m0;
+  TString _title_m1;
+  TString _title_m2;
+  TString _title_m3;
+  TString _title_m4;
+  TString _title_m5;
+  TString _title_m6;
+  
+  TString _title_eta_1;
+  TString _title_phi_1;
+  TString _title_pt_1;
+  TString _title_etaPhi_1;
+  TString _title_n_1;
+  TString _title_SumPt_1;
+  TString _title_AvgPt_1;
+  TString _title_AvgN_1;
+  TString _title_AvgSumPt_1;
+  
+  TString _title_eta_2;
+  TString _title_phi_2;
+  TString _title_pt_2;
+  TString _title_etaPhi_2;
+  TString _title_n_2;
+  TString _title_SumPt_2;
+  TString _title_AvgPt_2;
+  TString _title_AvgN_2;
+  TString _title_AvgSumPt_2;
+  
+  TString _title_etaPhi_12;
+  
+  TString _title_AvgN2_12;
+  TString _title_AvgSumPtPt_12;
+  TString _title_AvgSumPtN_12;
+  TString _title_AvgNSumPt_12;
+  
+  TString vsZ;
+  TString vsM;
+  TString vsPt;
+  TString vsPhi; 
+  TString vsEta; 
+  TString vsEtaPhi; 
+  TString vsPtVsPt;
+
+  
+  ClassDef(AliAnalysisTaskDptDptQA,1)
+}; 
+
+
+#endif
+
+
index b103b72..99d7414 100644 (file)
@@ -26,7 +26,6 @@
 #include "TFile.h"
 #include "TGrid.h"
 
-
 #include "AliCentrality.h"
 #include "Riostream.h"
 
@@ -84,6 +83,7 @@ const char * kParticleSpeciesName[]={"Pions","Kaons","Protons","Undefined"} ;
 AliTwoParticlePIDCorr::AliTwoParticlePIDCorr() // All data members should be initialised here
 :AliAnalysisTaskSE(),
   fOutput(0),
+   fOutputList(0),
   fCentralityMethod("V0A"),
   fSampleType("pPb"),
   fnTracksVertex(1),  // QA tracks pointing to principal vertex (= 3 default)
@@ -158,6 +158,7 @@ AliTwoParticlePIDCorr::AliTwoParticlePIDCorr() // All data members should be ini
   fEventnomeson(0),
  fhistJetTrigestimate(0),
   fCentralityCorrelation(0x0),
+ fControlConvResoncances(0),
   fHistoTPCdEdx(0x0),
   fHistoTOFbeta(0x0),
   fTPCTOFPion3d(0),
@@ -186,8 +187,8 @@ AliTwoParticlePIDCorr::AliTwoParticlePIDCorr() // All data members should be ini
   fArrayMC(0),
   fAnalysisType("AOD"), 
   fefffilename(""),
+ ftwoTrackEfficiencyCutDataReco(kTRUE),
   twoTrackEfficiencyCutValue(0.02),
-//fControlConvResoncances(0),
   fPID(NULL),
  eventno(0),
   fPtTOFPIDmin(0.6),
@@ -196,6 +197,8 @@ AliTwoParticlePIDCorr::AliTwoParticlePIDCorr() // All data members should be ini
   fPIDType(NSigmaTPCTOF),
  fFIllPIDQAHistos(kTRUE),
   fNSigmaPID(3),
+ fHighPtKaonNSigmaPID(-1),
+ fHighPtKaonSigma(3.5),
   fUseExclusiveNSigma(kFALSE),
   fRemoveTracksT0Fill(kFALSE),
 fSelectCharge(0),
@@ -241,6 +244,7 @@ fAnalysisUtils(0x0),
 AliTwoParticlePIDCorr::AliTwoParticlePIDCorr(const char *name) // All data members should be initialised here
   :AliAnalysisTaskSE(name),
  fOutput(0),
+   fOutputList(0),
  fCentralityMethod("V0A"),
   fSampleType("pPb"),
   fnTracksVertex(1),  // QA tracks pointing to principal vertex (= 3 default)
@@ -315,6 +319,7 @@ AliTwoParticlePIDCorr::AliTwoParticlePIDCorr(const char *name) // All data membe
   fEventnomeson(0),
    fhistJetTrigestimate(0),
   fCentralityCorrelation(0x0),
+  fControlConvResoncances(0), 
   fHistoTPCdEdx(0x0),
   fHistoTOFbeta(0x0),
   fTPCTOFPion3d(0),
@@ -342,9 +347,9 @@ AliTwoParticlePIDCorr::AliTwoParticlePIDCorr(const char *name) // All data membe
    fPoolMgr(0x0),
   fArrayMC(0),
   fAnalysisType("AOD"),
-   fefffilename(""), 
+   fefffilename(""),
+   ftwoTrackEfficiencyCutDataReco(kTRUE),
   twoTrackEfficiencyCutValue(0.02),
-//fControlConvResoncances(0),
   fPID(NULL),
  eventno(0),
  fPtTOFPIDmin(0.6),
@@ -353,6 +358,8 @@ AliTwoParticlePIDCorr::AliTwoParticlePIDCorr(const char *name) // All data membe
   fPIDType(NSigmaTPCTOF),
   fFIllPIDQAHistos(kTRUE),
   fNSigmaPID(3),
+fHighPtKaonNSigmaPID(-1),
+ fHighPtKaonSigma(3.5),
   fUseExclusiveNSigma(kFALSE),
   fRemoveTracksT0Fill(kFALSE),
 fSelectCharge(0),
@@ -491,13 +498,13 @@ void AliTwoParticlePIDCorr::UserCreateOutputObjects()
 fhistcentrality=new TH1F("fhistcentrality","fhistcentrality",centmultbins*4,centmultmin,centmultmax);
 fOutput->Add(fhistcentrality);
 
-  fEventCounter = new TH1F("fEventCounter","EventCounter", 10, 0.5,10.5);
+  fEventCounter = new TH1F("fEventCounter","EventCounter", 12, 0.5,12.5);
   fEventCounter->GetXaxis()->SetBinLabel(1,"Event Accesed");
-  fEventCounter->GetXaxis()->SetBinLabel(2,"NOT PileUP Event");
-  fEventCounter->GetXaxis()->SetBinLabel(3,"Have A Vertex");
-  fEventCounter->GetXaxis()->SetBinLabel(4,"After vertex Cut");
-  fEventCounter->GetXaxis()->SetBinLabel(5,"Within 0-100% centrality");
-  fEventCounter->GetXaxis()->SetBinLabel(6,"Event Analyzed");
+  fEventCounter->GetXaxis()->SetBinLabel(3,"After PileUP Cut");
+  fEventCounter->GetXaxis()->SetBinLabel(5,"Have A Vertex");
+  fEventCounter->GetXaxis()->SetBinLabel(7,"After vertex Cut");
+  fEventCounter->GetXaxis()->SetBinLabel(9,"Within 0-100% centrality");
+  fEventCounter->GetXaxis()->SetBinLabel(11,"Event Analyzed");
   //fEventCounter->GetXaxis()->SetBinLabel(8,"Event Analysis finished");
   fOutput->Add(fEventCounter);
   
@@ -511,6 +518,12 @@ fOutput->Add(fphiSpectraasso);
       fOutput->Add(fCentralityCorrelation);
  }
 
+if(fCutConversions || fCutResonances)
+    {
+fControlConvResoncances = new TH2F("fControlConvResoncances", ";id;delta mass", 3, -0.5, 2.5, 100, -0.1, 0.1);
+ fOutput->Add(fControlConvResoncances);
+    }
+
 fHistoTPCdEdx = new TH2F("hHistoTPCdEdx", ";p_{T} (GeV/c);dE/dx (au.)",200,0.0,10.0,500, 0., 500.);
 fOutputList->Add(fHistoTPCdEdx);
 fHistoTOFbeta = new TH2F(Form("hHistoTOFbeta"), ";p_{T} (GeV/c);v/c",100, 0., fmaxPt, 500, 0.1, 1.1);
@@ -937,13 +950,6 @@ fileT->Close();
 
    }
     
-//fControlConvResoncances = new TH2F("fControlConvResoncances", ";id;delta mass", 3, -0.5, 2.5, 100, -0.1, 0.1);
-// fOutput->Add(fControlConvResoncances);
-
-
-
-
   //*****************************************************PIDQA histos*****************************************************//
 
  
@@ -1207,7 +1213,7 @@ fHistQA[3]->Fill((trkVtx->GetX()));fHistQA[4]->Fill((trkVtx->GetY()));fHistQA[5]
 //now we have events passed physics trigger, centrality,eventzvtx cut 
 
 //count events after vertex cut
-  fEventCounter->Fill(4);
+  fEventCounter->Fill(5);
      
 if(!aod) return;  //for safety
 
@@ -1668,7 +1674,7 @@ if(trackscount>0.0)
  if (fSampleType=="pPb" || fSampleType=="PbPb") fCentralityCorrelation->Fill(cent_v0, trackscount);//only with unidentified tracks(i.e before PID selection);;;;;can be used to remove centrality outliers??????
 
 //count selected events having centrality betn 0-100%
- fEventCounter->Fill(5);
+ fEventCounter->Fill(9);
 
 //***************************************event no. counting
 Bool_t isbaryontrig=kFALSE;
@@ -1693,14 +1699,14 @@ for(Int_t i=0;i<tracksID->GetEntriesFast();i++)
  //same event delte-eta, delta-phi plot
 if(tracksUNID && tracksUNID->GetEntriesFast()>0)//hadron triggered correlation
   {//same event calculation starts
-    if(ffilltrigassoUNID) Fillcorrelation(tracksUNID,0,cent_v0,zvtx,weghtval,kFALSE,bSign,fPtOrderDataReco,kTRUE,kFALSE,"trigassoUNID");//mixcase=kFALSE (hadron-hadron correlation)
-    if(tracksID && tracksID->GetEntriesFast()>0 && ffilltrigUNIDassoID)  Fillcorrelation(tracksUNID,tracksID,cent_v0,zvtx,weghtval,kFALSE,bSign,fPtOrderDataReco,kTRUE,kFALSE,"trigUNIDassoID");//mixcase=kFALSE (hadron-ID correlation)
+    if(ffilltrigassoUNID) Fillcorrelation(tracksUNID,0,cent_v0,zvtx,weghtval,kFALSE,bSign,fPtOrderDataReco,ftwoTrackEfficiencyCutDataReco,kFALSE,"trigassoUNID");//mixcase=kFALSE (hadron-hadron correlation)
+    if(tracksID && tracksID->GetEntriesFast()>0 && ffilltrigUNIDassoID)  Fillcorrelation(tracksUNID,tracksID,cent_v0,zvtx,weghtval,kFALSE,bSign,fPtOrderDataReco,ftwoTrackEfficiencyCutDataReco,kFALSE,"trigUNIDassoID");//mixcase=kFALSE (hadron-ID correlation)
   }
 
 if(tracksID && tracksID->GetEntriesFast()>0)//ID triggered correlation
   {//same event calculation starts
-    if(tracksUNID && tracksUNID->GetEntriesFast()>0 && ffilltrigIDassoUNID)  Fillcorrelation(tracksID,tracksUNID,cent_v0,zvtx,weghtval,kFALSE,bSign,fPtOrderDataReco,kTRUE,kFALSE,"trigIDassoUNID");//mixcase=kFALSE (ID-hadron correlation)
-    if(ffilltrigIDassoID)   Fillcorrelation(tracksID,0,cent_v0,zvtx,weghtval,kFALSE,bSign,fPtOrderDataReco,kTRUE,kFALSE,"trigIDassoID");//mixcase=kFALSE (ID-ID correlation)
+    if(tracksUNID && tracksUNID->GetEntriesFast()>0 && ffilltrigIDassoUNID)  Fillcorrelation(tracksID,tracksUNID,cent_v0,zvtx,weghtval,kFALSE,bSign,fPtOrderDataReco,ftwoTrackEfficiencyCutDataReco,kFALSE,"trigIDassoUNID");//mixcase=kFALSE (ID-hadron correlation)
+    if(ffilltrigIDassoID)   Fillcorrelation(tracksID,0,cent_v0,zvtx,weghtval,kFALSE,bSign,fPtOrderDataReco,ftwoTrackEfficiencyCutDataReco,kFALSE,"trigIDassoID");//mixcase=kFALSE (ID-ID correlation)
   }
 
 //still in  main event loop
@@ -1715,9 +1721,9 @@ if (pool && pool->IsReady())
  TObjArray* bgTracks = pool->GetEvent(jMix);
   if(!bgTracks) continue;
   if(ffilltrigassoUNID && tracksUNID && tracksUNID->GetEntriesFast()>0)//*******************************hadron trggered mixing
-    Fillcorrelation(tracksUNID,bgTracks,cent_v0,zvtx,nmix1,(jMix == 0),bSign,fPtOrderDataReco,kTRUE,kTRUE,"trigassoUNID");//mixcase=kTRUE
+    Fillcorrelation(tracksUNID,bgTracks,cent_v0,zvtx,nmix1,(jMix == 0),bSign,fPtOrderDataReco,ftwoTrackEfficiencyCutDataReco,kTRUE,"trigassoUNID");//mixcase=kTRUE
  if(ffilltrigIDassoUNID && tracksID && tracksID->GetEntriesFast()>0)//***********************************ID trggered mixing
-   Fillcorrelation(tracksID,bgTracks,cent_v0,zvtx,nmix1,(jMix == 0),bSign,fPtOrderDataReco,kTRUE,kTRUE,"trigIDassoUNID");//mixcase=kTRUE 
+   Fillcorrelation(tracksID,bgTracks,cent_v0,zvtx,nmix1,(jMix == 0),bSign,fPtOrderDataReco,ftwoTrackEfficiencyCutDataReco,kTRUE,"trigIDassoUNID");//mixcase=kTRUE 
    }// pool event loop ends mixing case
 
 } //if pool->IsReady() condition ends mixing case
@@ -1737,9 +1743,9 @@ for (Int_t jMix=0; jMix<pool1->GetCurrentNEvents(); jMix++)
  TObjArray* bgTracks2 = pool1->GetEvent(jMix);
   if(!bgTracks2) continue;
 if(ffilltrigUNIDassoID && tracksUNID && tracksUNID->GetEntriesFast()>0)
-  Fillcorrelation(tracksUNID,bgTracks2,cent_v0,zvtx,nmix2,(jMix == 0),bSign,fPtOrderDataReco,kTRUE,kTRUE,"trigUNIDassoID");//mixcase=kTRUE  
+  Fillcorrelation(tracksUNID,bgTracks2,cent_v0,zvtx,nmix2,(jMix == 0),bSign,fPtOrderDataReco,ftwoTrackEfficiencyCutDataReco,kTRUE,"trigUNIDassoID");//mixcase=kTRUE  
 if(ffilltrigIDassoID && tracksID && tracksID->GetEntriesFast()>0)
-  Fillcorrelation(tracksID,bgTracks2,cent_v0,zvtx,nmix2,(jMix == 0),bSign,fPtOrderDataReco,kTRUE,kTRUE,"trigIDassoID");//mixcase=kTRUE
+  Fillcorrelation(tracksID,bgTracks2,cent_v0,zvtx,nmix2,(jMix == 0),bSign,fPtOrderDataReco,ftwoTrackEfficiencyCutDataReco,kTRUE,"trigIDassoID");//mixcase=kTRUE
 
    }// pool event loop ends mixing case
 } //if pool1->IsReady() condition ends mixing case
@@ -1751,7 +1757,7 @@ if(pool1)
  }//mixing with identified particles
 
   //no. of events analyzed
-fEventCounter->Fill(6);
+fEventCounter->Fill(11);
   }
 
 if(tracksUNID)  delete tracksUNID;
@@ -1808,7 +1814,7 @@ void AliTwoParticlePIDCorr::doAODevent()
   }
 
 //count events after PileUP cut
-   fEventCounter->Fill(2);
+   fEventCounter->Fill(3);
 
  if (!fPID) return;//this should be available with each event even if we don't do PID selection
   
@@ -1868,12 +1874,12 @@ void AliTwoParticlePIDCorr::doAODevent()
   fHistQA[0]->Fill((trkVtx->GetX()));fHistQA[1]->Fill((trkVtx->GetY()));fHistQA[2]->Fill((trkVtx->GetZ())); //for trkVtx only before vertex cut |zvtx|<10 cm
 
 //count events having a proper vertex
-   fEventCounter->Fill(3);
+   fEventCounter->Fill(5);
 
  if (TMath::Abs(zvtx) > fzvtxcut) return;
 
 //count events after vertex cut
-  fEventCounter->Fill(4);
+  fEventCounter->Fill(7);
 
 
  //if(!fAnalysisUtils->IsVertexSelected2013pA(aod)) return;
@@ -2026,7 +2032,7 @@ if(fSampleType=="pp")  cent_v0=trackscount;//multiplicity
 if(fSampleType=="pPb" || fSampleType=="PbPb") fCentralityCorrelation->Fill(cent_v0, trackscount);//only with unidentified tracks(i.e before PID selection);;;;;can be used to remove centrality outliers??????
 
 //count selected events having centrality betn 0-100%
- fEventCounter->Fill(5);
+ fEventCounter->Fill(9);
 
 //***************************************event no. counting
 Bool_t isbaryontrig=kFALSE;
@@ -2053,14 +2059,14 @@ for(Int_t i=0;i<tracksID->GetEntriesFast();i++)
 
 if(tracksUNID && tracksUNID->GetEntriesFast()>0)//hadron triggered correlation
   {//same event calculation starts
-    if(ffilltrigassoUNID) Fillcorrelation(tracksUNID,0,cent_v0,zvtx,weightval,kFALSE,bSign,fPtOrderDataReco,kTRUE,kFALSE,"trigassoUNID");//mixcase=kFALSE (hadron-hadron correlation)
-    if(tracksID && tracksID->GetEntriesFast()>0 && ffilltrigUNIDassoID)  Fillcorrelation(tracksUNID,tracksID,cent_v0,zvtx,weightval,kFALSE,bSign,fPtOrderDataReco,kTRUE,kFALSE,"trigUNIDassoID");//mixcase=kFALSE (hadron-ID correlation)
+    if(ffilltrigassoUNID) Fillcorrelation(tracksUNID,0,cent_v0,zvtx,weightval,kFALSE,bSign,fPtOrderDataReco,ftwoTrackEfficiencyCutDataReco,kFALSE,"trigassoUNID");//mixcase=kFALSE (hadron-hadron correlation)
+    if(tracksID && tracksID->GetEntriesFast()>0 && ffilltrigUNIDassoID)  Fillcorrelation(tracksUNID,tracksID,cent_v0,zvtx,weightval,kFALSE,bSign,fPtOrderDataReco,ftwoTrackEfficiencyCutDataReco,kFALSE,"trigUNIDassoID");//mixcase=kFALSE (hadron-ID correlation)
   }
 
 if(tracksID && tracksID->GetEntriesFast()>0)//ID triggered correlation
   {//same event calculation starts
-    if(tracksUNID && tracksUNID->GetEntriesFast()>0 && ffilltrigIDassoUNID)  Fillcorrelation(tracksID,tracksUNID,cent_v0,zvtx,weightval,kFALSE,bSign,fPtOrderDataReco,kTRUE,kFALSE,"trigIDassoUNID");//mixcase=kFALSE (ID-hadron correlation)
-    if(ffilltrigIDassoID)   Fillcorrelation(tracksID,0,cent_v0,zvtx,weightval,kFALSE,bSign,fPtOrderDataReco,kTRUE,kFALSE,"trigIDassoID");//mixcase=kFALSE (ID-ID correlation)
+    if(tracksUNID && tracksUNID->GetEntriesFast()>0 && ffilltrigIDassoUNID)  Fillcorrelation(tracksID,tracksUNID,cent_v0,zvtx,weightval,kFALSE,bSign,fPtOrderDataReco,ftwoTrackEfficiencyCutDataReco,kFALSE,"trigIDassoUNID");//mixcase=kFALSE (ID-hadron correlation)
+    if(ffilltrigIDassoID)   Fillcorrelation(tracksID,0,cent_v0,zvtx,weightval,kFALSE,bSign,fPtOrderDataReco,ftwoTrackEfficiencyCutDataReco,kFALSE,"trigIDassoID");//mixcase=kFALSE (ID-ID correlation)
   }
 
 //still in  main event loop
@@ -2077,9 +2083,9 @@ if (pool && pool->IsReady())
  TObjArray* bgTracks = pool->GetEvent(jMix);
   if(!bgTracks) continue;
   if(ffilltrigassoUNID && tracksUNID && tracksUNID->GetEntriesFast()>0)//*******************************hadron trggered mixing
-    Fillcorrelation(tracksUNID,bgTracks,cent_v0,zvtx,nmix1,(jMix == 0),bSign,fPtOrderDataReco,kTRUE,kTRUE,"trigassoUNID");//mixcase=kTRUE
+    Fillcorrelation(tracksUNID,bgTracks,cent_v0,zvtx,nmix1,(jMix == 0),bSign,fPtOrderDataReco,ftwoTrackEfficiencyCutDataReco,kTRUE,"trigassoUNID");//mixcase=kTRUE
  if(ffilltrigIDassoUNID && tracksID && tracksID->GetEntriesFast()>0)//***********************************ID trggered mixing
-   Fillcorrelation(tracksID,bgTracks,cent_v0,zvtx,nmix1,(jMix == 0),bSign,fPtOrderDataReco,kTRUE,kTRUE,"trigIDassoUNID");//mixcase=kTRUE 
+   Fillcorrelation(tracksID,bgTracks,cent_v0,zvtx,nmix1,(jMix == 0),bSign,fPtOrderDataReco,ftwoTrackEfficiencyCutDataReco,kTRUE,"trigIDassoUNID");//mixcase=kTRUE 
    }// pool event loop ends mixing case
 } //if pool->IsReady() condition ends mixing case
  if(tracksUNID) {
@@ -2099,9 +2105,9 @@ for (Int_t jMix=0; jMix<pool1->GetCurrentNEvents(); jMix++)
  TObjArray* bgTracks2 = pool1->GetEvent(jMix);
   if(!bgTracks2) continue;
 if(ffilltrigUNIDassoID && tracksUNID && tracksUNID->GetEntriesFast()>0)
-  Fillcorrelation(tracksUNID,bgTracks2,cent_v0,zvtx,nmix2,(jMix == 0),bSign,fPtOrderDataReco,kTRUE,kTRUE,"trigUNIDassoID");//mixcase=kTRUE  
+  Fillcorrelation(tracksUNID,bgTracks2,cent_v0,zvtx,nmix2,(jMix == 0),bSign,fPtOrderDataReco,ftwoTrackEfficiencyCutDataReco,kTRUE,"trigUNIDassoID");//mixcase=kTRUE  
 if(ffilltrigIDassoID && tracksID && tracksID->GetEntriesFast()>0)
-  Fillcorrelation(tracksID,bgTracks2,cent_v0,zvtx,nmix2,(jMix == 0),bSign,fPtOrderDataReco,kTRUE,kTRUE,"trigIDassoID");//mixcase=kTRUE
+  Fillcorrelation(tracksID,bgTracks2,cent_v0,zvtx,nmix2,(jMix == 0),bSign,fPtOrderDataReco,ftwoTrackEfficiencyCutDataReco,kTRUE,"trigIDassoID");//mixcase=kTRUE
 
    }// pool event loop ends mixing case
 } //if pool1->IsReady() condition ends mixing case
@@ -2114,7 +2120,7 @@ if(pool1)
 
 
   //no. of events analyzed
-fEventCounter->Fill(6);
+fEventCounter->Fill(11);
  
 //still in main event loop
 
@@ -2445,7 +2451,7 @@ if (fRejectResonanceDaughters > 0)
          {
            mass = GetInvMassSquared(trig->Pt(), trigeta, trig->Phi(), asso->Pt(), eta[j], asso->Phi(), 0.510e-3, 0.510e-3);
            
-           //fControlConvResoncances->Fill(0.0, mass);
+           fControlConvResoncances->Fill(0.0, mass);
 
            if (mass < 0.04*0.04) 
              continue;
@@ -2463,7 +2469,7 @@ if (fRejectResonanceDaughters > 0)
          {
            mass = GetInvMassSquared(trig->Pt(), trigeta, trig->Phi(), asso->Pt(),eta[j], asso->Phi(), 0.1396, 0.1396);
            
-           //fControlConvResoncances->Fill(1, mass - kK0smass*kK0smass);
+           fControlConvResoncances->Fill(1, mass - kK0smass*kK0smass);
 
            if (mass > (kK0smass-0.02)*(kK0smass-0.02) && mass < (kK0smass+0.02)*(kK0smass+0.02))
              continue;
@@ -2482,7 +2488,7 @@ if (fRejectResonanceDaughters > 0)
          {
            mass1 = GetInvMassSquared(trig->Pt(), trigeta, trig->Phi(), asso->Pt(),eta[j], asso->Phi(), 0.1396, 0.9383);
 
-           //fControlConvResoncances->Fill(2, mass1 - kLambdaMass*kLambdaMass);
+           fControlConvResoncances->Fill(2, mass1 - kLambdaMass*kLambdaMass);
            
            if (mass1 > (kLambdaMass-0.02)*(kLambdaMass-0.02) && mass1 < (kLambdaMass+0.02)*(kLambdaMass+0.02))
              continue;
@@ -2491,7 +2497,7 @@ if (fRejectResonanceDaughters > 0)
          {
            mass2 = GetInvMassSquared(trig->Pt(), trigeta, trig->Phi(), asso->Pt(),eta[j] , asso->Phi(), 0.9383, 0.1396);
 
-           //fControlConvResoncances->Fill(2, mass2 - kLambdaMass*kLambdaMass);
+           fControlConvResoncances->Fill(2, mass2 - kLambdaMass*kLambdaMass);
 
            if (mass2 > (kLambdaMass-0.02)*(kLambdaMass-0.02) && mass2 < (kLambdaMass+0.02)*(kLambdaMass+0.02))
              continue;
@@ -2841,10 +2847,12 @@ if(fRequestTOFPID && track->Pt()>fPtTOFPIDmin && track->Pt()<=fPtTOFPIDmax && (!
     break;
   }
 
-  if(track->Pt()<=fPtTOFPIDmax)  {
+  if(track->Pt()<=fPtTOFPIDmax)  {       //the range upto which combined TPC-TOF cut can be used(here 4.0 Gev/C)
  // guess the particle based on the smaller nsigma (within fNSigmaPID)
   if( ( nsigmaKaon==nsigmaPion ) && ( nsigmaKaon==nsigmaProton )) return SpUndefined;//it is the default value for the three
+
   if( ( nsigmaKaon   < nsigmaPion ) && ( nsigmaKaon < nsigmaProton ) && (nsigmaKaon < fNSigmaPID)){
+  if((fHighPtKaonNSigmaPID>0) && (track->Pt()>fHighPtKaonSigma) && (nsigmaKaon > fHighPtKaonNSigmaPID)) return SpUndefined;
 if(FillQAHistos){
       for(Int_t ipid=0;ipid<=NSigmaPIDType;ipid++){
        if((ipid!=NSigmaTPC) && (!HasTOFPID(track)) && (track->Pt()<fPtTOFPIDmin))continue;//not filling TOF and combined if no TOF PID
index bb45521..87ae719 100644 (file)
@@ -3,6 +3,7 @@
 
 #include "THn.h" // in cxx file causes .../THn.h:257: error: conflicting declaration ‘typedef class THnT<float> THnF’
 
+
 class TH1F;
 class TH2F;
 class TH3F;
@@ -97,8 +98,13 @@ class AliTwoParticlePIDCorr : public AliAnalysisTaskSE {
     virtual void    doAODevent();
     virtual void    doMCAODevent();
     virtual void     Terminate(Option_t *);
-  void          SetSharedClusterCut(Double_t value) { fSharedClusterCut = value; }
+  void    SetSharedClusterCut(Double_t value) { fSharedClusterCut = value; }
 
+  void SettwoTrackEfficiencyCutDataReco(Bool_t twoTrackEfficiencyCutDataReco,Float_t twoTrackEfficiencyCutValue1)
+  {
+    ftwoTrackEfficiencyCutDataReco=twoTrackEfficiencyCutDataReco;
+    twoTrackEfficiencyCutValue=twoTrackEfficiencyCutValue1;
+  }
   void SetVertextype(Int_t Vertextype){fVertextype=Vertextype;}                                                 //Check it every time
     void SetZvtxcut(Double_t zvtxcut) {fzvtxcut=zvtxcut;}
     void SetCustomBinning(TString receivedCustomBinning) { fCustomBinning = receivedCustomBinning; }
@@ -161,6 +167,11 @@ class AliTwoParticlePIDCorr : public AliAnalysisTaskSE {
   void Setselectprimarydatareco(Bool_t onlyprimarydatareco) {fonlyprimarydatareco=onlyprimarydatareco;}
   void SetselectprimaryTruth(Bool_t selectprimaryTruth) {fselectprimaryTruth=selectprimaryTruth;}
   void SetCombinedNSigmaCut(Double_t NSigmaPID) {fNSigmaPID=NSigmaPID;}
+  void SetHighPtKaonNSigmaPID(Float_t HighPtKaonSigma,Float_t HighPtKaonNSigmaPID)
+  {
+    fHighPtKaonSigma=HighPtKaonSigma;
+    fHighPtKaonNSigmaPID=HighPtKaonNSigmaPID;
+  }
   void IgnoreoverlappedTracks(Bool_t UseExclusiveNSigma){fUseExclusiveNSigma=UseExclusiveNSigma;}
   void SetRemoveTracksT0Fill( Bool_t RemoveTracksT0Fill){fRemoveTracksT0Fill=RemoveTracksT0Fill;}
   void SetPairSelectCharge(Int_t SelectCharge){fSelectCharge=SelectCharge;}
@@ -286,6 +297,7 @@ fPtTOFPIDmax=PtTOFPIDmax;
     TH2F *fhistJetTrigestimate;//!
 
     TH2D* fCentralityCorrelation;  //! centrality vs multiplicity
+    TH2F* fControlConvResoncances; //! control histograms for cuts on conversions and resonances
 
     TH2F *fHistoTPCdEdx;//!
     TH2F *fHistoTOFbeta;//!
@@ -322,7 +334,6 @@ fPtTOFPIDmax=PtTOFPIDmax;
    
     THnSparse *effcorection[6];//!
     // THnF *effmap[6];  
-    //TH2F* fControlConvResoncances; //! control histograms for cuts on conversions and resonances
 
     Int_t ClassifyTrack(AliAODTrack* track,AliAODVertex* vertex,Float_t magfield);
   Double_t* GetBinning(const char* configuration, const char* tag, Int_t& nBins);
@@ -351,7 +362,7 @@ fPtTOFPIDmax=PtTOFPIDmax;
  
      TH2F* GetHistogram2D(const char * name);//return histogram "name" from fOutputList
 
-          
+     Bool_t ftwoTrackEfficiencyCutDataReco;       
    Float_t twoTrackEfficiencyCutValue;
   //Pid objects
   AliPIDResponse *fPID; //! PID
@@ -362,6 +373,8 @@ fPtTOFPIDmax=PtTOFPIDmax;
   PIDType fPIDType; // PID type  Double_t fNSigmaPID; // number of sigma for PID cut
   Bool_t fFIllPIDQAHistos; //Switch for filling the nSigma histos
   Double_t fNSigmaPID; // number of sigma for PID cut
+  Float_t fHighPtKaonNSigmaPID;// number of sigma for PID cut for Kaons above fHighPtKaonSigma(-1 default, no cut applied)
+  Float_t fHighPtKaonSigma;//lower pt bound for the fHighPtKaonNSigmaPID to be set >0(i.e. to make it applicable)
   Bool_t fUseExclusiveNSigma;//if true returns the identity only if no double counting(i.e not in the overlap area)
   Bool_t fRemoveTracksT0Fill;//if true remove tracks for which only StartTime from To-Fill is available (worst resolution)
  Int_t fSelectCharge;           // (un)like sign selection when building correlations: 0: no selection; 1: unlike sign; 2: like sign
diff --git a/PWGCF/Correlations/macros/dptdptcorrelations/AddTaskDptQA.C b/PWGCF/Correlations/macros/dptdptcorrelations/AddTaskDptQA.C
new file mode 100644 (file)
index 0000000..063205f
--- /dev/null
@@ -0,0 +1,320 @@
+
+AliAnalysisTaskDptDptQA *AddTaskDptQA
+(int    system                 = 0,
+ int    singlesOnly            = 0,
+ int    useWeights             = 0,
+ int    centralityMethod       = 4,
+ int    chargeSet              = 1,
+ int    trackFilterBit         = 128,
+ int    nClusterMin            = 80, 
+ double etaMin                 = -0.8,
+ double etaMax                 = 0.8,
+ double dcaZMin                = -3.2,
+ double dcaZMax                =  3.2,
+ double dcaXYMin               = -2.4,
+ double dcaXYMax               =  2.4,
+ int nCentrality               =  3,
+ char *inputHistogramFileName  = "PbPb276Calibration_2010.root",
+ char *OutputFileName          = "DCA_KS"
+ )
+  
+{
+  // Set Default Configuration of this analysis
+  // ==========================================
+  int    debugLevel             = 0;
+  int    rejectPileup           = 1;
+  int    rejectPairConversion   = 1;
+  int    sameFilter             = 1;
+
+  
+  //int    nCentrality;
+  double minCentrality[10];
+  double maxCentrality[10];
+
+  if (system==0) // PbPb
+    {
+    if (centralityMethod == 4)
+      {
+
+       minCentrality[0] = 0.0; maxCentrality[0] = 10.0;
+       minCentrality[1] = 30.0; maxCentrality[1] = 40.;
+       minCentrality[2] = 60.0; maxCentrality[2] = 70.;
+       
+      }
+    else
+      {
+       //cout << "-F- AddTaskDptDptCorrelations() system:" << system << ". centralityMethod:" << centralityMethod << " Option NOT AVAILABLE. ABORT."
+      return 0;
+      }
+    }
+  else if (system==1) // pp
+    {
+    if (centralityMethod == 3)
+      {
+      nCentrality = 4;
+      minCentrality[0] = 2;   maxCentrality[0] = 100.0;
+      minCentrality[1] = 2;   maxCentrality[1] = 20.;
+      minCentrality[2] = 20.; maxCentrality[2] = 50.;
+      minCentrality[3] = 50.; maxCentrality[3] = 100.;
+      }
+    else
+      {
+       //cout << "-F- AddTaskDptDptCorrelations() system:" << system << ". centralityMethod:" << centralityMethod << " Option NOT AVAILABLE. ABORT."
+      return 0;
+      }
+    }
+  else
+    {
+      //cout << "-F- AddTaskDptDptCorrelations() system:" << system << ". Option NOT CURRENTLY AVAILABLE. ABORT."
+    return 0;
+    }
+
+  double zMin                   = -10.;
+  double zMax                   =  10.;
+  double ptMin                  =  0.2;
+  double ptMax                  =  2.0;
+  //double etaMin                 = -0.9;
+  //double etaMax                 =  0.9;
+  //double dcaZMin                = -3.0;
+  //double dcaZMax                =  3.0;
+  //double dcaXYMin               = -2.4;
+  //double dcaXYMax               =  2.4;
+  double dedxMin                =  0.0;
+  double dedxMax                =  20000.0;
+  //int    nClusterMin            =   80;
+  //int    trackFilterBit         =  128;//TPC only
+  //int    trackFilterBit         =  272; //Hybrid
+  
+  int    requestedCharge1       =  1; //default
+  int    requestedCharge2       = -1; //default
+  
+  
+  // Get the pointer to the existing analysis manager via the static access method.
+  // ==============================================================================
+  AliAnalysisManager *analysisManager = AliAnalysisManager::GetAnalysisManager();
+  
+  if (!analysisManager) 
+    {
+    ::Error("AddTaskDptDptCorrelations", "No analysis manager to connect to.");
+    return NULL;
+    }  
+  
+  TString part1Name;
+  TString part2Name;
+  TString eventName;
+  TString prefixName        = "Corr_";
+  TString pileupRejecSuffix = "_PileupRejec";
+  TString pairRejecSuffix   = "_PairRejec";
+  TString calibSuffix       = "_calib";
+  TString singlesOnlySuffix = "_SO";
+  TString suffix;
+  
+  TString inputPath         = ".";
+  TString outputPath        = ".";
+  TString baseName;
+  TString listName;
+  TString taskName;
+  //TString inputHistogramFileName;
+  TString outputHistogramFileName;
+  
+  // Create the task and add subtask.
+  // ===========================================================================
+  int iTask = 0; // task counter
+  AliAnalysisDataContainer *taskInputContainer;
+  AliAnalysisDataContainer *taskOutputContainer;
+  AliAnalysisTaskDptDptQA* task;
+  
+  for (int iCentrality=0; iCentrality < nCentrality; ++iCentrality)
+    {
+      switch (chargeSet)
+        {
+          case 0: part1Name = "P_"; part2Name = "P_"; requestedCharge1 =  1; requestedCharge2 =  1; sameFilter = 1; break;
+          case 1: part1Name = "P_"; part2Name = "M_"; requestedCharge1 =  1; requestedCharge2 = -1; sameFilter = 0;   break;
+          case 2: part1Name = "M_"; part2Name = "P_"; requestedCharge1 = -1; requestedCharge2 =  1; sameFilter = 0;   break;
+          case 3: part1Name = "M_"; part2Name = "M_"; requestedCharge1 = -1; requestedCharge2 = -1; sameFilter = 1;   break;
+        }
+      //part1Name += int(1000*etaMin);
+      part1Name += "eta";
+      part1Name += int(1000*etaMax);
+      part1Name += "_";
+      part1Name += int(1000*ptMin);
+      part1Name += "pt";
+      part1Name += int(1000*ptMax);
+      part1Name += "_";
+      //part2Name += int(1000*etaMin);
+      part2Name += "eta";
+      part2Name += int(1000*etaMax);
+      part2Name += "_";
+      part2Name += int(1000*ptMin);
+      part2Name += "pt";
+      part2Name += int(1000*ptMax);
+      part2Name += "_";
+      eventName =  "";
+      eventName += int(10.*minCentrality[iCentrality] );
+      eventName += "Vo";
+      eventName += int(10.*maxCentrality[iCentrality] );
+      //eventName += "_";
+      //eventName += int(10*zMin ); 
+      //eventName += "Z";
+      //eventName += int(10*zMax ); 
+      //if (rejectPileup)         eventName += pileupRejecSuffix;
+      //if (rejectPairConversion) eventName += pairRejecSuffix;
+      baseName     =   prefixName;
+      baseName     +=  part1Name;
+      baseName     +=  part2Name;
+      baseName     +=  eventName;
+      listName     =   baseName;
+      taskName     =   baseName;
+
+      
+      //inputHistogramFileName =  "alien:///alice/cern.ch/user/p/prabhat/CalibFiles/PbPbCalib_dca1.root";
+      //inputHistogramFileName =  "/Users/prabhat/dEdX/rootfile/272/before/PbPb276Calibration_2010.root";
+
+      outputHistogramFileName = baseName;
+      if (singlesOnly) outputHistogramFileName += singlesOnlySuffix;
+      outputHistogramFileName += ".root";
+      
+      /*cout << "============================================================" << endl;
+    cout << "                   iTask: " << iTask << endl;
+      cout << "               Task Name: " << taskName << endl;
+      cout << "               List Name: " << listName << endl;
+      cout << "  inputHistogramFileName: " << inputHistogramFileName  << endl;
+      cout << " outputHistogramFileName: " << outputHistogramFileName << endl;
+      cout << "                  system: " << system << endl;
+      cout << "             singlesOnly: " << singlesOnly << endl;
+      cout << "           using weights: " << useWeights << endl;
+      cout << "        centralityMethod: " << centralityMethod << endl;
+      cout << "               chargeSet: " << chargeSet    << endl;
+      cout << "              debugLevel: " << debugLevel   << endl;
+      cout << "            rejectPileup: " << rejectPileup << endl;
+      cout << "    rejectPairConversion: " << rejectPairConversion  << endl;
+      cout << "              sameFilter: " << sameFilter  << endl;
+      cout << "                    zMin: " << zMin        << endl;
+      cout << "                    zMax: " << zMax        << endl;
+      cout << "                   ptMin: " << ptMin       << endl;
+      cout << "                   ptMax: " << ptMax       << endl;
+      cout << "                  etaMin: " << etaMin   << endl;
+      cout << "                  etaMax: " << etaMax   << endl;
+      cout << "                 dcaZMin: " << dcaZMin  << endl;
+      cout << "                 dcaZMax: " << dcaZMax  << endl;
+      cout << "                dcaXYMin: " << dcaXYMin << endl;
+      cout << "                dcaXYMax: " << dcaXYMax << endl;
+      cout << "                 dedxMin: " << dedxMin  << endl;
+      cout << "                 dedxMax: " << dedxMax  << endl;
+      cout << "             nClusterMin: " << nClusterMin      << endl;
+      cout << "          trackFilterBit: " << trackFilterBit   << endl;
+      cout << "        requestedCharge1: " << requestedCharge1 << endl;
+      cout << "        requestedCharge2: " << requestedCharge2 << endl;
+    cout << "============================================================" << endl;
+      */
+    TFile  * inputFile  = 0;
+      TList  * histoList  = 0;
+      TH3F   * weight_1   = 0;
+      TH3F   * weight_2   = 0;
+      if (useWeights)
+        {
+        TGrid::Connect("alien:");
+        inputFile = TFile::Open(inputHistogramFileName,"OLD");
+        if (!inputFile)
+          {
+           //cout << "Requested file:" << inputHistogramFileName << " was not opened. ABORT." << endl;
+          return;
+          }
+        TString nameHistoBase = "correction_";
+        TString nameHisto;
+        nameHistoBase += eventName;
+        if (requestedCharge1 == 1)
+          {
+          nameHisto = nameHistoBase + "_p";
+          //cout << "Input Histogram named: " << nameHisto << endl;
+          weight_1 = (TH3F *) inputFile->Get(nameHisto);
+          }
+        else
+          {
+          nameHisto = nameHistoBase + "_m";
+          //cout << "Input Histogram named: " << nameHisto << endl;
+          weight_1 = (TH3F *) inputFile->Get(nameHisto);
+          }
+        if (!weight_1) 
+          {
+           //cout << "Requested histogram 'correction_p/m' was not found. ABORT." << endl;
+          return 0;
+          }
+        
+        if (!sameFilter)
+          {
+          weight_2 = 0;
+          if (requestedCharge2 == 1)
+            {
+            nameHisto = nameHistoBase + "_p";
+            //cout << "Input Histogram named: " << nameHisto << endl;
+            weight_2 = (TH3F *) inputFile->Get(nameHisto);
+            }
+          else
+            {
+            nameHisto = nameHistoBase + "_m";
+            //cout << "Input Histogram named: " << nameHisto << endl;
+            weight_2 = (TH3F *) inputFile->Get(nameHisto);
+            }
+          if (!weight_2) 
+            {
+             //cout << "Requested histogram 'correction_p/m' was not found. ABORT." << endl;
+            return 0;
+            }
+          }  
+        }
+      task = new  AliAnalysisTaskDptDptQA(taskName);
+      //configure my task
+      task->SetDebugLevel(          debugLevel      ); 
+      task->SetSameFilter(          sameFilter      );
+      task->SetSinglesOnly(         singlesOnly     ); 
+      task->SetUseWeights(          useWeights      ); 
+      task->SetRejectPileup(        rejectPileup    ); 
+      task->SetRejectPairConversion(rejectPairConversion); 
+      task->SetVertexZMin(          zMin            ); 
+      task->SetVertexZMax(          zMax            ); 
+      task->SetVertexXYMin(         -1.            ); 
+      task->SetVertexXYMax(          1.            ); 
+      task->SetCentralityMethod(    centralityMethod);
+      task->SetCentrality(          minCentrality[iCentrality], maxCentrality[iCentrality]);
+      task->SetPtMin1(              ptMin           ); 
+      task->SetPtMax1(              ptMax           ); 
+      task->SetEtaMin1(             etaMin          ); 
+      task->SetEtaMax1(             etaMax          ); 
+      task->SetPtMin2(              ptMin           ); 
+      task->SetPtMax2(              ptMax           ); 
+      task->SetEtaMin2(             etaMin          ); 
+      task->SetEtaMax2(             etaMax          ); 
+      task->SetDcaZMin(             dcaZMin         ); 
+      task->SetDcaZMax(             dcaZMax         ); 
+      task->SetDcaXYMin(            dcaXYMin        ); 
+      task->SetDcaXYMax(            dcaXYMax        ); //checking by prp
+      task->SetDedxMin(             dedxMin         ); 
+      task->SetDedxMax(             dedxMax         ); 
+      task->SetNClusterMin(         nClusterMin     ); 
+      task->SetTrackFilterBit(      trackFilterBit  );
+      task->SetRequestedCharge_1(   requestedCharge1); 
+      task->SetRequestedCharge_2(   requestedCharge2); 
+      task->SetWeigth_1(            weight_1        );
+      task->SetWeigth_2(            weight_2        );
+      
+      
+      //cout << "Creating task output container" << endl;
+      taskOutputContainer = analysisManager->CreateContainer(listName, 
+                                                             TList::Class(),    
+                                                             AliAnalysisManager::kOutputContainer, 
+                                                             Form("%s.root:Histos", OutputFileName));
+      //cout << "Add task to analysis manager and connect it to input and output containers" << endl;
+      analysisManager->AddTask(task);
+      analysisManager->ConnectInput( task,  0, analysisManager->GetCommonInputContainer());
+      analysisManager->ConnectOutput(task,  0, taskOutputContainer );
+      //cout << "Task added ...." << endl;
+      
+      iTask++;
+    
+    }
+  
+  
+  
+  return task;
+}