[u/mrichter/AliRoot.git] / PWGGA / GammaConv / macros / AddTask_GammaConvdPhi_pp.C

AliAnalysisTask *AddTask_GammaConvdPhi_pp(TString v0Cut = "0000011002093663003800000000",
					 TString pionCut = "01631031009000",
					 Bool_t pbpb = kFALSE) {

	////////////////////CURRENTLY NOT WORKING ///////////////////////////////
	
  // standard with task
  printf("========================================================================================\n");
  printf("dPhiAnalysis: Initialising AliAnalysisTaskdPhi\n");
  printf("========================================================================================\n");
  
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) {
    Error("AddTask_slindal_dPhi", "No analysis manager found.");
    return 0;
  }

  AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
  Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class();
  
  AliAnalysisTaskdPhi *task = new AliAnalysisTaskdPhi((TString("slindalTask_dPhi")+"_" + v0Cut));

  ///Axes for histrograms
  Double_t cptbins[9] = {0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0, 10};
  task->GetAxiscPt().Set(8, cptbins);

  Double_t tptbins[3] = {3.0, 5.0, 10.0};
  task->GetAxistPt().Set(2, tptbins);

  if(pbpb) {
    Double_t centBins[6] = {0, 5, 10, 30, 50, 60, 90};
    task->GetAxisCent().Set(5, centBins);
  } else {
    Double_t centBins[2] = {-9999, 9999};
    task->GetAxisCent().Set(1, centBins);
  }

  Double_t zbins[6] = { -10, -5, -1.5, 1.5, 5, 10};
  task->GetAxisZ().Set(5, zbins);

  Double_t mbins[17] = {0.07, 0.09, 0.1, 0.11, 0.12, 0.125, 0.1275, 0.13, 0.14, 0.1425, 0.145, 0.15, 0.16, 0.18, 0.2, 0.24, 0.26};
  task->GetAxisPiMass().Set(16, mbins);


  AliESDtrackCuts * trackCuts = new AliESDtrackCuts();
  TFormula *f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","70.+30./20.*x");
  trackCuts->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
  trackCuts->SetMaxChi2PerClusterTPC(4);
  trackCuts->SetRequireTPCStandAlone(kTRUE);
  trackCuts->SetAcceptKinkDaughters(kFALSE);
  trackCuts->SetRequireTPCRefit(kTRUE);
  trackCuts->SetMaxFractionSharedTPCClusters(0.4);

  trackCuts->SetMaxDCAToVertexXY(2.4);
  trackCuts->SetMaxDCAToVertexZ(3.2);
  trackCuts->SetDCAToVertex2D(kTRUE);

  trackCuts->SetMaxChi2PerClusterITS(36);
  trackCuts->SetMaxChi2TPCConstrainedGlobal(36);

  trackCuts->SetRequireSigmaToVertex(kFALSE);

  trackCuts->SetEtaRange(-0.9, 0.9);
  trackCuts->SetPtRange(cptbins[0], 1000000.0);

  trackCuts->SetRequireITSRefit(kFALSE);

  AliConversionTrackCuts* tc = new AliConversionTrackCuts();
  tc->SetEsdTrackCuts(trackCuts);
  task->SetTrackFilter(tc);


  ///open side nclusters graph
  AliESDtrackCuts * trackCuts2 = new AliESDtrackCuts();
  TFormula *f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","65.+30./20.*x");
  trackCuts2->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
  trackCuts2->SetMaxChi2PerClusterTPC(4);
  trackCuts2->SetRequireTPCStandAlone(kTRUE);
  trackCuts2->SetAcceptKinkDaughters(kFALSE);
  trackCuts2->SetRequireTPCRefit(kTRUE);
  trackCuts2->SetMaxFractionSharedTPCClusters(0.4);

  trackCuts2->SetMaxDCAToVertexXY(2.4);
  trackCuts2->SetMaxDCAToVertexZ(3.2);
  trackCuts2->SetDCAToVertex2D(kTRUE);

  trackCuts2->SetMaxChi2PerClusterITS(36);
  trackCuts2->SetMaxChi2TPCConstrainedGlobal(36);

  trackCuts2->SetRequireSigmaToVertex(kFALSE);

  trackCuts2->SetEtaRange(-0.9, 0.9);
  trackCuts2->SetPtRange(cptbins[0], 1000000.0);

  trackCuts2->SetRequireITSRefit(kFALSE);
  //task->AddTrackFilter(trackCuts2, kTRUE);

  AliConversionTrackCuts tc2 = new AliConversionTrackCuts();
  tc2->SetEsdTrackCuts(trackCuts2);
  task->AddTrackFilter(tc2, kTRUE);


  ///Tight side nclusters graphs
  AliESDtrackCuts * trackCuts3 = new AliESDtrackCuts();
  TFormula *f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","75.+30./20.*x");
  trackCuts3->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
  trackCuts3->SetMaxChi2PerClusterTPC(4);
  trackCuts3->SetRequireTPCStandAlone(kTRUE);
  trackCuts3->SetAcceptKinkDaughters(kFALSE);
  trackCuts3->SetRequireTPCRefit(kTRUE);
  trackCuts3->SetMaxFractionSharedTPCClusters(0.4);

  trackCuts3->SetMaxDCAToVertexXY(2.4);
  trackCuts3->SetMaxDCAToVertexZ(3.2);
  trackCuts3->SetDCAToVertex2D(kTRUE);

  trackCuts3->SetMaxChi2PerClusterITS(36);
  trackCuts3->SetMaxChi2TPCConstrainedGlobal(36);

  trackCuts3->SetRequireSigmaToVertex(kFALSE);

  trackCuts3->SetEtaRange(-0.9, 0.9);
  trackCuts3->SetPtRange(cptbins[0], 1000000.0);

  trackCuts3->SetRequireITSRefit(kFALSE);
  //task->AddTrackFilter(trackCuts3, kFALSE);

  AliConversionTrackCuts tc3 = new AliConversionTrackCuts();
  tc3->SetEsdTrackCuts(trackCuts3);
  task->AddTrackFilter(tc3, kFALSE);


  ////Tight xyz track cuts
  AliESDtrackCuts * trackCuts4 = new AliESDtrackCuts();
  TFormula *f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","70.+30./20.*x");
  trackCuts4->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
  trackCuts4->SetMaxChi2PerClusterTPC(4);
  trackCuts4->SetRequireTPCStandAlone(kTRUE);
  trackCuts4->SetAcceptKinkDaughters(kFALSE);
  trackCuts4->SetRequireTPCRefit(kTRUE);
  trackCuts4->SetMaxFractionSharedTPCClusters(0.4);

  trackCuts4->SetMaxDCAToVertexXY(2.2);
  trackCuts4->SetMaxDCAToVertexZ(3.0);
  trackCuts4->SetDCAToVertex2D(kTRUE);

  trackCuts4->SetMaxChi2PerClusterITS(36);
  trackCuts4->SetMaxChi2TPCConstrainedGlobal(36);

  trackCuts4->SetRequireSigmaToVertex(kFALSE);

  trackCuts4->SetEtaRange(-0.9, 0.9);
  trackCuts4->SetPtRange(cptbins[0], 1000000.0);

  trackCuts4->SetRequireITSRefit(kFALSE);
  //task->AddTrackFilter(trackCuts4, kFALSE);

  AliConversionTrackCuts tc4 = new AliConversionTrackCuts();
  tc4->SetEsdTrackCuts(trackCuts4);
  task->AddTrackFilter(tc4, kFALSE);


  ////lose xyz track cuts
  AliESDtrackCuts * trackCuts5 = new AliESDtrackCuts();
  TFormula *f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","70.+30./20.*x");
  trackCuts5->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
  trackCuts5->SetMaxChi2PerClusterTPC(4);
  trackCuts5->SetRequireTPCStandAlone(kTRUE);
  trackCuts5->SetAcceptKinkDaughters(kFALSE);
  trackCuts5->SetRequireTPCRefit(kTRUE);
  trackCuts5->SetMaxFractionSharedTPCClusters(0.4);

  trackCuts5->SetMaxDCAToVertexXY(2.6);
  trackCuts5->SetMaxDCAToVertexZ(3.6);
  trackCuts5->SetDCAToVertex2D(kTRUE);

  trackCuts5->SetMaxChi2PerClusterITS(36);
  trackCuts5->SetMaxChi2TPCConstrainedGlobal(36);

  trackCuts5->SetRequireSigmaToVertex(kFALSE);

  trackCuts5->SetEtaRange(-0.9, 0.9);
  trackCuts5->SetPtRange(cptbins[0], 1000000.0);

  trackCuts5->SetRequireITSRefit(kFALSE);
  //task->AddTrackFilter(trackCuts5);

  AliConversionTrackCuts tc5 = new AliConversionTrackCuts();
  tc5->SetEsdTrackCuts(trackCuts5);
  task->AddTrackFilter(tc5, kTRUE);


  ///open side shared tpt clusters
  AliESDtrackCuts * trackCuts6 = new AliESDtrackCuts();
  TFormula *f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","70.+30./20.*x");
  trackCuts6->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
  trackCuts6->SetMaxChi2PerClusterTPC(4);
  trackCuts6->SetRequireTPCStandAlone(kTRUE);
  trackCuts6->SetAcceptKinkDaughters(kFALSE);
  trackCuts6->SetRequireTPCRefit(kTRUE);
  trackCuts6->SetMaxFractionSharedTPCClusters(0.44);

  trackCuts6->SetMaxDCAToVertexXY(2.4);
  trackCuts6->SetMaxDCAToVertexZ(3.2);
  trackCuts6->SetDCAToVertex2D(kTRUE);

  trackCuts6->SetMaxChi2PerClusterITS(36);
  trackCuts6->SetMaxChi2TPCConstrainedGlobal(36);

  trackCuts6->SetRequireSigmaToVertex(kFALSE);

  trackCuts6->SetEtaRange(-0.9, 0.9);
  trackCuts6->SetPtRange(cptbins[0], 1000000.0);

  trackCuts6->SetRequireITSRefit(kFALSE);
  //task->AddTrackFilter(trackCuts6, kTRUE);

  AliConversionTrackCuts tc6 = new AliConversionTrackCuts();
  tc6->SetEsdTrackCuts(trackCuts6);
  task->AddTrackFilter(tc6, kTRUE);


  ///tight side shared tpt clusters
  AliESDtrackCuts * trackCuts7 = new AliESDtrackCuts();
  TFormula *f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","70.+30./20.*x");
  trackCuts7->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
  trackCuts7->SetMaxChi2PerClusterTPC(4);
  trackCuts7->SetRequireTPCStandAlone(kTRUE);
  trackCuts7->SetAcceptKinkDaughters(kFALSE);
  trackCuts7->SetRequireTPCRefit(kTRUE);
  trackCuts7->SetMaxFractionSharedTPCClusters(0.36);

  trackCuts7->SetMaxDCAToVertexXY(2.4);
  trackCuts7->SetMaxDCAToVertexZ(3.2);
  trackCuts7->SetDCAToVertex2D(kTRUE);

  trackCuts7->SetMaxChi2PerClusterITS(36);
  trackCuts7->SetMaxChi2TPCConstrainedGlobal(36);

  trackCuts7->SetRequireSigmaToVertex(kFALSE);

  trackCuts7->SetEtaRange(-0.9, 0.9);
  trackCuts7->SetPtRange(cptbins[0], 1000000.0);

  trackCuts7->SetRequireITSRefit(kFALSE);
  //task->AddTrackFilter(trackCuts7, kFALSE);
  
  AliConversionTrackCuts tc7 = new AliConversionTrackCuts();
  tc7->SetEsdTrackCuts(trackCuts7);
  task->AddTrackFilter(tc7, kFALSE);


  ///Pion cuts
  AliConversionMesonCuts * picuts = new AliConversionMesonCuts("dphi_pioncuts");
  picuts->InitializeCutsFromCutString(pionCut);
  task->SetMesonFilter(picuts);


  //================================================
  //              data containers
  //================================================
  //            find input container
  //below the trunk version
  AliAnalysisDataContainer *cinput  = mgr->GetCommonInputContainer();
  TString baseString("slindal_dPhi_");
  baseString += v0Cut + pionCut;

  //dumm output container
  AliAnalysisDataContainer *coutput0 =
	mgr->CreateContainer(baseString+"tree",
						 TTree::Class(),
						 AliAnalysisManager::kExchangeContainer,
						 "slindal_default");
  
  //define output containers, please use 'username'_'somename'
  AliAnalysisDataContainer *coutput1 = 
	mgr->CreateContainer(baseString+"me", TList::Class(),
						 AliAnalysisManager::kOutputContainer,baseString+"me.root");

  //define output containers, please use 'username'_'somename'
  
  
  //========= Add PID Reponse to ANALYSIS manager ====
  Bool_t isMC = kFALSE;
  if(!(AliPIDResponse*)mgr->GetTask("PIDResponseTask")){
    gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
    AddTaskPIDResponse(isMC);
  }
   
  //=========  Set Cutnumber for V0Reader ================================
  TString cutnumber = "000000000208400000220000000"; 

  //========= Add V0 Reader to  ANALYSIS manager if not yet existent =====
  AliV0ReaderV1 * fV0ReaderV1 = (AliV0ReaderV1*)mgr->GetTask("V0ReaderV1");
  if( !fV0ReaderV1 ){
    fV0ReaderV1 = new AliV0ReaderV1("V0ReaderV1");
      
    fV0ReaderV1->SetUseOwnXYZCalculation(kTRUE);
    fV0ReaderV1->SetCreateAODs(kFALSE);// AOD Output
    fV0ReaderV1->SetUseAODConversionPhoton(kTRUE);

    if (!mgr) {
      Error("AddTask_V0ReaderV1", "No analysis manager found.");
      return;
    }

    // Set AnalysisCut Number
    AliConversionCuts *fCuts=NULL;
    if(cutnumber!=""){
      fCuts= new AliConversionCuts(cutnumber.Data(),cutnumber.Data());
      fCuts->SetPreSelectionCutFlag(kTRUE);
      }
      if(fCuts->InitializeCutsFromCutString(cutnumber)){
	fV0ReaderV1->SetConversionCuts(fCuts);
      }
      
      fV0ReaderV1->Init();
      mgr->AddTask(fV0ReaderV1);
      mgr->ConnectInput(fV0ReaderV1,0,cinput);
      task->SaveReaderHists();
  }
 
  task->SetV0Reader(fV0ReaderV1);

  AliConversionCuts * v0cuts = new AliConversionCuts();
  v0cuts->InitializeCutsFromCutString(v0Cut);
  task->SetV0Filter(v0cuts);

  Int_t numberOfCuts = 7;
  TString *tcutarray  =new TString[7];
  TString *wcutarray = new TString[7];
  
  //"0000011002093663003800000000",
                // "0000011002093663003800000000"; // -4 5 sigma electron line
  tcutarray[0] = "0000011002092663003800000000"; // -3 5 sigma
  wcutarray[0] = "0000011002091663003800000000"; //dedex -5 -5 sigma

             // "0000011002093663003800000000"; // 663: 2 sigma low pt (0.25)  0.5 sigma: high pt (3.5)
  tcutarray[1] = "0000011002093863003800000000"; // 863  2                      1 
  wcutarray[1] = "0000011002093563003800000000"; // 563  2                      -10

  tcutarray[2] = "0000011002093663003800000000";
  wcutarray[2] = "0000011002093663003800000000";

  tcutarray[3] = "0000011002693663003800000000"; // single pt 6: 0.04 tight
  wcutarray[3] = "0000011002493663003800000000"; // single pt 4: 0.075 loose

                            //                 //tpc cluster cut 9 : 0.6 default
  tcutarray[4] = "0000011002063663003800000000"; //6 : > 0.7 tight 
  wcutarray[4] = "0000011002083663003800000000"; //8 : > 0.35 loose

                                   //          // qt max 3: 0.05 default
  tcutarray[5] = "0000011002093663004800000000"; //4 : < 0.03 tight
  wcutarray[5] = "0000011002093663002800000000"; //2 : < 0.07 loose 

                                    //         // chi2 8 default <20
  tcutarray[6] = "0000011002093663003900000000"; //9 : < 15 tight 
  wcutarray[6] = "0000011002093663003200000000"; //2 : < 30 loose


  ///Add the tight cuts
  for(Int_t i = 0; i < numberOfCuts; i++) {
    AliConversionCuts * v0cuts = new AliConversionCuts("aaa","aaa");
    v0cuts->SetPreSelectionCutFlag(kTRUE);
    if(v0cuts->InitializeCutsFromCutString(tcutarray[i].Data())){
      task->AddV0Filter(v0cuts, kFALSE);
      v0cuts->SetFillCutHistograms("aaa",kFALSE);
    }
  }

  ///Add the tight cuts
  for(Int_t i = 0; i < numberOfCuts; i++) {
    AliConversionCuts * v0cuts = new AliConversionCuts("aaa","aaa");
    v0cuts->SetPreSelectionCutFlag(kTRUE);
    if(v0cuts->InitializeCutsFromCutString(wcutarray[i].Data())){
      task->AddV0Filter(v0cuts, kTRUE);
      v0cuts->SetFillCutHistograms("aaa",kFALSE);
    }
  }

  mgr->AddTask(task);
  task->SelectCollisionCandidates(AliVEvent::kMB);
  mgr->ConnectInput  (task,  0, cinput );
  mgr->ConnectOutput (task,  0, coutput0);
  mgr->ConnectOutput (task,  1, coutput1);
  
  return task;
}
Commit	Line	Data
ae4f2cfb	1	AliAnalysisTask *AddTask_GammaConvdPhi_pp(TString v0Cut = "0000011002093663003800000000",
99d49b30	2	TString pionCut = "01631031009000",
	3	Bool_t pbpb = kFALSE) {
	4
344100c4	5	////////////////////CURRENTLY NOT WORKING ///////////////////////////////
344100c4	6
99d49b30	7	// standard with task
	8	printf("========================================================================================\n");
	9	printf("dPhiAnalysis: Initialising AliAnalysisTaskdPhi\n");
	10	printf("========================================================================================\n");
	11
	12	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
	13	if (!mgr) {
	14	Error("AddTask_slindal_dPhi", "No analysis manager found.");
	15	return 0;
	16	}
	17
	18	AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
	19	Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class();
	20
	21	AliAnalysisTaskdPhi *task = new AliAnalysisTaskdPhi((TString("slindalTask_dPhi")+"_" + v0Cut));
	22
	23	///Axes for histrograms
	24	Double_t cptbins[9] = {0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0, 10};
	25	task->GetAxiscPt().Set(8, cptbins);
	26
	27	Double_t tptbins[3] = {3.0, 5.0, 10.0};
	28	task->GetAxistPt().Set(2, tptbins);
	29
	30	if(pbpb) {
	31	Double_t centBins[6] = {0, 5, 10, 30, 50, 60, 90};
	32	task->GetAxisCent().Set(5, centBins);
	33	} else {
	34	Double_t centBins[2] = {-9999, 9999};
	35	task->GetAxisCent().Set(1, centBins);
	36	}
	37
	38	Double_t zbins[6] = { -10, -5, -1.5, 1.5, 5, 10};
	39	task->GetAxisZ().Set(5, zbins);
	40
	41	Double_t mbins[17] = {0.07, 0.09, 0.1, 0.11, 0.12, 0.125, 0.1275, 0.13, 0.14, 0.1425, 0.145, 0.15, 0.16, 0.18, 0.2, 0.24, 0.26};
	42	task->GetAxisPiMass().Set(16, mbins);
	43
	44
	45	AliESDtrackCuts * trackCuts = new AliESDtrackCuts();
	46	TFormula f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","70.+30./20.x");
	47	trackCuts->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
	48	trackCuts->SetMaxChi2PerClusterTPC(4);
	49	trackCuts->SetRequireTPCStandAlone(kTRUE);
	50	trackCuts->SetAcceptKinkDaughters(kFALSE);
	51	trackCuts->SetRequireTPCRefit(kTRUE);
	52	trackCuts->SetMaxFractionSharedTPCClusters(0.4);
	53
	54	trackCuts->SetMaxDCAToVertexXY(2.4);
	55	trackCuts->SetMaxDCAToVertexZ(3.2);
	56	trackCuts->SetDCAToVertex2D(kTRUE);
	57
	58	trackCuts->SetMaxChi2PerClusterITS(36);
	59	trackCuts->SetMaxChi2TPCConstrainedGlobal(36);
	60
	61	trackCuts->SetRequireSigmaToVertex(kFALSE);
	62
	63	trackCuts->SetEtaRange(-0.9, 0.9);
	64	trackCuts->SetPtRange(cptbins[0], 1000000.0);
	65
	66	trackCuts->SetRequireITSRefit(kFALSE);
	67
	68	AliConversionTrackCuts* tc = new AliConversionTrackCuts();
	69	tc->SetEsdTrackCuts(trackCuts);
	70	task->SetTrackFilter(tc);
71
72
73	///open side nclusters graph
74	AliESDtrackCuts * trackCuts2 = new AliESDtrackCuts();
75	TFormula f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","65.+30./20.x");
76	trackCuts2->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
77	trackCuts2->SetMaxChi2PerClusterTPC(4);
78	trackCuts2->SetRequireTPCStandAlone(kTRUE);
79	trackCuts2->SetAcceptKinkDaughters(kFALSE);
80	trackCuts2->SetRequireTPCRefit(kTRUE);
81	trackCuts2->SetMaxFractionSharedTPCClusters(0.4);
82
83	trackCuts2->SetMaxDCAToVertexXY(2.4);
84	trackCuts2->SetMaxDCAToVertexZ(3.2);
85	trackCuts2->SetDCAToVertex2D(kTRUE);
86
87	trackCuts2->SetMaxChi2PerClusterITS(36);
88	trackCuts2->SetMaxChi2TPCConstrainedGlobal(36);
89
90	trackCuts2->SetRequireSigmaToVertex(kFALSE);
91
92	trackCuts2->SetEtaRange(-0.9, 0.9);
93	trackCuts2->SetPtRange(cptbins[0], 1000000.0);
94
95	trackCuts2->SetRequireITSRefit(kFALSE);
96	//task->AddTrackFilter(trackCuts2, kTRUE);
97
98	AliConversionTrackCuts tc2 = new AliConversionTrackCuts();
99	tc2->SetEsdTrackCuts(trackCuts2);
100	task->AddTrackFilter(tc2, kTRUE);
101
102
103	///Tight side nclusters graphs
104	AliESDtrackCuts * trackCuts3 = new AliESDtrackCuts();
105	TFormula f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","75.+30./20.x");
106	trackCuts3->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
107	trackCuts3->SetMaxChi2PerClusterTPC(4);
108	trackCuts3->SetRequireTPCStandAlone(kTRUE);
109	trackCuts3->SetAcceptKinkDaughters(kFALSE);
110	trackCuts3->SetRequireTPCRefit(kTRUE);
111	trackCuts3->SetMaxFractionSharedTPCClusters(0.4);
112
113	trackCuts3->SetMaxDCAToVertexXY(2.4);
114	trackCuts3->SetMaxDCAToVertexZ(3.2);
115	trackCuts3->SetDCAToVertex2D(kTRUE);
116
117	trackCuts3->SetMaxChi2PerClusterITS(36);
118	trackCuts3->SetMaxChi2TPCConstrainedGlobal(36);
119
120	trackCuts3->SetRequireSigmaToVertex(kFALSE);
121
122	trackCuts3->SetEtaRange(-0.9, 0.9);
123	trackCuts3->SetPtRange(cptbins[0], 1000000.0);
124
125	trackCuts3->SetRequireITSRefit(kFALSE);
126	//task->AddTrackFilter(trackCuts3, kFALSE);
127
128	AliConversionTrackCuts tc3 = new AliConversionTrackCuts();
129	tc3->SetEsdTrackCuts(trackCuts3);
130	task->AddTrackFilter(tc3, kFALSE);
131
132
133
134	////Tight xyz track cuts
135	AliESDtrackCuts * trackCuts4 = new AliESDtrackCuts();
136	TFormula f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","70.+30./20.x");
137	trackCuts4->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
138	trackCuts4->SetMaxChi2PerClusterTPC(4);
139	trackCuts4->SetRequireTPCStandAlone(kTRUE);
140	trackCuts4->SetAcceptKinkDaughters(kFALSE);
141	trackCuts4->SetRequireTPCRefit(kTRUE);
142	trackCuts4->SetMaxFractionSharedTPCClusters(0.4);
143
144	trackCuts4->SetMaxDCAToVertexXY(2.2);
145	trackCuts4->SetMaxDCAToVertexZ(3.0);
146	trackCuts4->SetDCAToVertex2D(kTRUE);
147
148	trackCuts4->SetMaxChi2PerClusterITS(36);
149	trackCuts4->SetMaxChi2TPCConstrainedGlobal(36);
150
151	trackCuts4->SetRequireSigmaToVertex(kFALSE);
152
153	trackCuts4->SetEtaRange(-0.9, 0.9);
154	trackCuts4->SetPtRange(cptbins[0], 1000000.0);
155
156	trackCuts4->SetRequireITSRefit(kFALSE);
157	//task->AddTrackFilter(trackCuts4, kFALSE);
158
159	AliConversionTrackCuts tc4 = new AliConversionTrackCuts();
160	tc4->SetEsdTrackCuts(trackCuts4);
161	task->AddTrackFilter(tc4, kFALSE);
162
163
164	////lose xyz track cuts
165	AliESDtrackCuts * trackCuts5 = new AliESDtrackCuts();
166	TFormula f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","70.+30./20.x");
167	trackCuts5->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
168	trackCuts5->SetMaxChi2PerClusterTPC(4);
169	trackCuts5->SetRequireTPCStandAlone(kTRUE);
170	trackCuts5->SetAcceptKinkDaughters(kFALSE);
171	trackCuts5->SetRequireTPCRefit(kTRUE);
172	trackCuts5->SetMaxFractionSharedTPCClusters(0.4);
173
174	trackCuts5->SetMaxDCAToVertexXY(2.6);
175	trackCuts5->SetMaxDCAToVertexZ(3.6);
176	trackCuts5->SetDCAToVertex2D(kTRUE);
177
178	trackCuts5->SetMaxChi2PerClusterITS(36);
179	trackCuts5->SetMaxChi2TPCConstrainedGlobal(36);
180
181	trackCuts5->SetRequireSigmaToVertex(kFALSE);
182
183	trackCuts5->SetEtaRange(-0.9, 0.9);
184	trackCuts5->SetPtRange(cptbins[0], 1000000.0);
185
186	trackCuts5->SetRequireITSRefit(kFALSE);
187	//task->AddTrackFilter(trackCuts5);
188
189	AliConversionTrackCuts tc5 = new AliConversionTrackCuts();
190	tc5->SetEsdTrackCuts(trackCuts5);
191	task->AddTrackFilter(tc5, kTRUE);
192
193
194	///open side shared tpt clusters
195	AliESDtrackCuts * trackCuts6 = new AliESDtrackCuts();
196	TFormula f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","70.+30./20.x");
197	trackCuts6->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
198	trackCuts6->SetMaxChi2PerClusterTPC(4);
199	trackCuts6->SetRequireTPCStandAlone(kTRUE);
200	trackCuts6->SetAcceptKinkDaughters(kFALSE);
201	trackCuts6->SetRequireTPCRefit(kTRUE);
202	trackCuts6->SetMaxFractionSharedTPCClusters(0.44);
203
204	trackCuts6->SetMaxDCAToVertexXY(2.4);
205	trackCuts6->SetMaxDCAToVertexZ(3.2);
206	trackCuts6->SetDCAToVertex2D(kTRUE);
207
208	trackCuts6->SetMaxChi2PerClusterITS(36);
209	trackCuts6->SetMaxChi2TPCConstrainedGlobal(36);
210
211	trackCuts6->SetRequireSigmaToVertex(kFALSE);
212
213	trackCuts6->SetEtaRange(-0.9, 0.9);
214	trackCuts6->SetPtRange(cptbins[0], 1000000.0);
215
216	trackCuts6->SetRequireITSRefit(kFALSE);
217	//task->AddTrackFilter(trackCuts6, kTRUE);
218
219	AliConversionTrackCuts tc6 = new AliConversionTrackCuts();
220	tc6->SetEsdTrackCuts(trackCuts6);
221	task->AddTrackFilter(tc6, kTRUE);
222
223
224	///tight side shared tpt clusters
225	AliESDtrackCuts * trackCuts7 = new AliESDtrackCuts();
226	TFormula f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","70.+30./20.x");
227	trackCuts7->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
228	trackCuts7->SetMaxChi2PerClusterTPC(4);
229	trackCuts7->SetRequireTPCStandAlone(kTRUE);
230	trackCuts7->SetAcceptKinkDaughters(kFALSE);
231	trackCuts7->SetRequireTPCRefit(kTRUE);
232	trackCuts7->SetMaxFractionSharedTPCClusters(0.36);
233
234	trackCuts7->SetMaxDCAToVertexXY(2.4);
235	trackCuts7->SetMaxDCAToVertexZ(3.2);
236	trackCuts7->SetDCAToVertex2D(kTRUE);
237
238	trackCuts7->SetMaxChi2PerClusterITS(36);
239	trackCuts7->SetMaxChi2TPCConstrainedGlobal(36);
240
241	trackCuts7->SetRequireSigmaToVertex(kFALSE);
242
243	trackCuts7->SetEtaRange(-0.9, 0.9);
244	trackCuts7->SetPtRange(cptbins[0], 1000000.0);
245
246	trackCuts7->SetRequireITSRefit(kFALSE);
247	//task->AddTrackFilter(trackCuts7, kFALSE);
248
249	AliConversionTrackCuts tc7 = new AliConversionTrackCuts();
250	tc7->SetEsdTrackCuts(trackCuts7);
251	task->AddTrackFilter(tc7, kFALSE);
252
253
254	///Pion cuts
255	AliConversionMesonCuts * picuts = new AliConversionMesonCuts("dphi_pioncuts");
256	picuts->InitializeCutsFromCutString(pionCut);
257	task->SetMesonFilter(picuts);
258
259
260	//================================================
261	// data containers
262	//================================================
263	// find input container
264	//below the trunk version
265	AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
266	TString baseString("slindal_dPhi_");
267	baseString += v0Cut + pionCut;
268
269	//dumm output container
270	AliAnalysisDataContainer *coutput0 =
271	mgr->CreateContainer(baseString+"tree",
272	TTree::Class(),
273	AliAnalysisManager::kExchangeContainer,
274	"slindal_default");
275
276	//define output containers, please use 'username'_'somename'
277	AliAnalysisDataContainer *coutput1 =
278	mgr->CreateContainer(baseString+"me", TList::Class(),
279	AliAnalysisManager::kOutputContainer,baseString+"me.root");
280
281	//define output containers, please use 'username'_'somename'
282
283
284	//========= Add PID Reponse to ANALYSIS manager ====
285	Bool_t isMC = kFALSE;
286	if(!(AliPIDResponse*)mgr->GetTask("PIDResponseTask")){
287	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
288	AddTaskPIDResponse(isMC);
289	}
290
291	//========= Set Cutnumber for V0Reader ================================
292	TString cutnumber = "000000000208400000220000000";
293
294	//========= Add V0 Reader to ANALYSIS manager if not yet existent =====
295	AliV0ReaderV1 * fV0ReaderV1 = (AliV0ReaderV1*)mgr->GetTask("V0ReaderV1");
296	if( !fV0ReaderV1 ){
297	fV0ReaderV1 = new AliV0ReaderV1("V0ReaderV1");
298
299	fV0ReaderV1->SetUseOwnXYZCalculation(kTRUE);
300	fV0ReaderV1->SetCreateAODs(kFALSE);// AOD Output
301	fV0ReaderV1->SetUseAODConversionPhoton(kTRUE);
302
303	if (!mgr) {
304	Error("AddTask_V0ReaderV1", "No analysis manager found.");
305	return;
306	}
307
308	// Set AnalysisCut Number
309	AliConversionCuts *fCuts=NULL;
310	if(cutnumber!=""){
311	fCuts= new AliConversionCuts(cutnumber.Data(),cutnumber.Data());
312	fCuts->SetPreSelectionCutFlag(kTRUE);
313	}
314	if(fCuts->InitializeCutsFromCutString(cutnumber)){
315	fV0ReaderV1->SetConversionCuts(fCuts);
316	}
317
318	fV0ReaderV1->Init();
319	mgr->AddTask(fV0ReaderV1);
320	mgr->ConnectInput(fV0ReaderV1,0,cinput);
321	task->SaveReaderHists();
322	}
323
324	task->SetV0Reader(fV0ReaderV1);
325
326	AliConversionCuts * v0cuts = new AliConversionCuts();
327	v0cuts->InitializeCutsFromCutString(v0Cut);
328	task->SetV0Filter(v0cuts);
329
330	Int_t numberOfCuts = 7;
331	TString *tcutarray =new TString[7];
332	TString *wcutarray = new TString[7];
333
ae4f2cfb	334	//"0000011002093663003800000000",
	335	// "0000011002093663003800000000"; // -4 5 sigma electron line
	336	tcutarray[0] = "0000011002092663003800000000"; // -3 5 sigma
	337	wcutarray[0] = "0000011002091663003800000000"; //dedex -5 -5 sigma
99d49b30	338
ae4f2cfb	339	// "0000011002093663003800000000"; // 663: 2 sigma low pt (0.25) 0.5 sigma: high pt (3.5)
	340	tcutarray[1] = "0000011002093863003800000000"; // 863 2 1
	341	wcutarray[1] = "0000011002093563003800000000"; // 563 2 -10
99d49b30	342
ae4f2cfb	343	tcutarray[2] = "0000011002093663003800000000";
ae4f2cfb	344	wcutarray[2] = "0000011002093663003800000000";
99d49b30	345
ae4f2cfb	346	tcutarray[3] = "0000011002693663003800000000"; // single pt 6: 0.04 tight
ae4f2cfb	347	wcutarray[3] = "0000011002493663003800000000"; // single pt 4: 0.075 loose
99d49b30	348
99d49b30	349	// //tpc cluster cut 9 : 0.6 default
ae4f2cfb	350	tcutarray[4] = "0000011002063663003800000000"; //6 : > 0.7 tight
ae4f2cfb	351	wcutarray[4] = "0000011002083663003800000000"; //8 : > 0.35 loose
99d49b30	352
99d49b30	353	// // qt max 3: 0.05 default
ae4f2cfb	354	tcutarray[5] = "0000011002093663004800000000"; //4 : < 0.03 tight
ae4f2cfb	355	wcutarray[5] = "0000011002093663002800000000"; //2 : < 0.07 loose
99d49b30	356
99d49b30	357	// // chi2 8 default <20
ae4f2cfb	358	tcutarray[6] = "0000011002093663003900000000"; //9 : < 15 tight
ae4f2cfb	359	wcutarray[6] = "0000011002093663003200000000"; //2 : < 30 loose
99d49b30	360
	361
	362	///Add the tight cuts
	363	for(Int_t i = 0; i < numberOfCuts; i++) {
	364	AliConversionCuts * v0cuts = new AliConversionCuts("aaa","aaa");
	365	v0cuts->SetPreSelectionCutFlag(kTRUE);
	366	if(v0cuts->InitializeCutsFromCutString(tcutarray[i].Data())){
	367	task->AddV0Filter(v0cuts, kFALSE);
	368	v0cuts->SetFillCutHistograms("aaa",kFALSE);
	369	}
	370	}
	371
	372	///Add the tight cuts
	373	for(Int_t i = 0; i < numberOfCuts; i++) {
	374	AliConversionCuts * v0cuts = new AliConversionCuts("aaa","aaa");
	375	v0cuts->SetPreSelectionCutFlag(kTRUE);
	376	if(v0cuts->InitializeCutsFromCutString(wcutarray[i].Data())){
	377	task->AddV0Filter(v0cuts, kTRUE);
	378	v0cuts->SetFillCutHistograms("aaa",kFALSE);
	379	}
	380	}
	381
	382	mgr->AddTask(task);
	383	task->SelectCollisionCandidates(AliVEvent::kMB);
	384	mgr->ConnectInput (task, 0, cinput );
	385	mgr->ConnectOutput (task, 0, coutput0);
	386	mgr->ConnectOutput (task, 1, coutput1);
	387
	388	return task;
	389	}
	390
	391