[u/mrichter/AliRoot.git] / PWGLF / RESONANCES / macros / mini / ConfigPhiRAApp.C

//
// *** Configuration script for phi->KK analysis with 2010 runs ***
//
// A configuration script for RSN package needs to define the followings:
//
// (1) decay tree of each resonance to be studied, which is needed to select
//     true pairs and to assign the right mass to all candidate daughters
// (2) cuts at all levels: single daughters, tracks, events
// (3) output objects: histograms or trees
//
Bool_t ConfigPhiRAApp
(
   AliRsnMiniAnalysisTask *task,
   Bool_t                  isMC,
   Bool_t                  isESD,
   const char             *suffix,
   AliRsnCutSet           *cutsPair
)
{
   // manage suffix
   if (strlen(suffix) > 0) suffix = Form("_%s", suffix);

   //
   // -- Define track cuts -------------------------------------------------------------------------
   //


   gROOT->LoadMacro("AliRsnCutPhiRAA.cxx++g");
   // standard kaon cut
   AliRsnCutPhiRAA *cut = new AliRsnCutPhiRAA("cut1");
   cut->SetMode(AliRsnCutPhiRAA::k2010);
   // TPC 2 sigma pid
   AliRsnCutPIDNSigma *cutKTPC2 = new AliRsnCutPIDNSigma("cut2SigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
   cutKTPC2->SinglePIDRange(2.0);
   // TPC 3 sigma pid
   AliRsnCutPIDNSigma *cutKTPC3 = new AliRsnCutPIDNSigma("cut3SigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
   cutKTPC3->SinglePIDRange(3.0);
   // TPC 4 sigma pid
   AliRsnCutPIDNSigma *cutKTPC4 = new AliRsnCutPIDNSigma("cut4SigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
   cutKTPC4->SinglePIDRange(4.0);
   // TPC 5 sigma pid
   AliRsnCutPIDNSigma *cutKTPC5 = new AliRsnCutPIDNSigma("cut5SigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
   cutKTPC5->SinglePIDRange(5.0);
   // TPC 6 sigma pid
   AliRsnCutPIDNSigma *cutKTPC6 = new AliRsnCutPIDNSigma("cut6SigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
   cutKTPC6->SinglePIDRange(6.0);

////////////////////////// Cut Sets ///////////////////////////////////////////////

   AliRsnCutSet *cutSet = new AliRsnCutSet("set_NoPID", AliRsnTarget::kDaughter);
   AliRsnCutSet *cutSet2 = new AliRsnCutSet("set_2sigmaTPC", AliRsnTarget::kDaughter);
   AliRsnCutSet *cutSet3 = new AliRsnCutSet("set_3sigmaTPC", AliRsnTarget::kDaughter);
   AliRsnCutSet *cutSet4 = new AliRsnCutSet("set_4sigmaTPC", AliRsnTarget::kDaughter);
   AliRsnCutSet *cutSet5 = new AliRsnCutSet("set_5sigmaTPC", AliRsnTarget::kDaughter);
   AliRsnCutSet *cutSet6 = new AliRsnCutSet("set_6sigmaTPC", AliRsnTarget::kDaughter);

////////////////////////////////////////////////////////////////////////////////////

   // no PID (only standard cuts)
   cutSet->AddCut(cut);
   cutSet->SetCutScheme(cut->GetName());

   // TPC 2 sigma cut
   cutSet2->AddCut(cut);
   cutSet2->AddCut(cutKTPC2);
   cutSet2->SetCutScheme("cut1&cut2SigmaTPCK");

   // TPC 3 sigma cut
   cutSet3->AddCut(cut);
   cutSet3->AddCut(cutKTPC3);
   cutSet3->SetCutScheme("cut1&cut3SigmaTPCK");

   // TPC 4 sigma cut
   cutSet4->AddCut(cut);
   cutSet4->AddCut(cutKTPC4);
   cutSet4->SetCutScheme("cut1&cut4SigmaTPCK");

   // TPC 5 sigma cut
   cutSet5->AddCut(cut);
   cutSet5->AddCut(cutKTPC5);
   cutSet5->SetCutScheme("cut1&cut5SigmaTPCK");

   // TPC 6 sigma cut
   cutSet6->AddCut(cut);
   cutSet6->AddCut(cutKTPC6);
   cutSet6->SetCutScheme("cut1&cut6SigmaTPCK");

//////////////////////////////////////////////////////////////////////////////
   // add to task
   Int_t icut = task->AddTrackCuts(cutSet);
   Int_t icut2 = task->AddTrackCuts(cutSet2);
   Int_t icut3 = task->AddTrackCuts(cutSet3);
   Int_t icut4 = task->AddTrackCuts(cutSet4);
   Int_t icut5 = task->AddTrackCuts(cutSet5);
   Int_t icut6 = task->AddTrackCuts(cutSet6);

   Printf("======== Monitoring cut AliRsnCutSetDaughterParticle enabled");
   gROOT->LoadMacro("$ALICE_ROOT/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C");
   AddMonitorOutput(isMC, cutSet->GetMonitorOutput());

   //
   // -- Values ------------------------------------------------------------------------------------
   //

   /* invariant mass   */ Int_t imID   = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
//   /* IM resolution    */ Int_t resID  = task->CreateValue(AliRsnMiniValue::kInvMassRes, kTRUE);
   /* IM resolution    */ Int_t resID  = task->CreateValue(AliRsnMiniValue::kInvMassRes, kFALSE);
   /* transv. momentum */ Int_t ptID   = task->CreateValue(AliRsnMiniValue::kPt, kFALSE);
   /* centrality       */ Int_t centID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE);

   //
   // -- Create all needed outputs -----------------------------------------------------------------
   //


   // use an array for more compact writing, which are different on mixing and charges
   // [0] = unlike
   // [1] = mixing
   // [2] = like ++
   // [3] = like --

/////////////////// NoPID ///////////////////////////////////////////////////////////////

   Bool_t  use     [4] = { 1           ,  1           ,  1           ,  1           };
   Bool_t  useIM   [4] = { 1           ,  1           ,  1           ,  1           };
   TString name    [4] = {"UnlikeNoPID", "MixingNoPID", "LikePPNoPID", "LikeMMNoPID"};
   TString comp    [4] = {"PAIR"       , "MIX"        , "PAIR"       , "PAIR"       };
   TString output  [4] = {"HIST"       , "HIST"       , "HIST"       , "HIST"       };
   Char_t  charge1 [4] = {'+'          , '+'          , '+'          , '-'          };
   Char_t  charge2 [4] = {'-'          , '-'          , '+'          , '-'          };
   Int_t   cutID   [4] = { icut        ,  icut        ,  icut        ,  icut        };

   for (Int_t i = 0; i < 4; i++) {
      if (!use[i]) continue;
      // create output
      AliRsnMiniOutput *out = task->CreateOutput(Form("phi_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data());
      // selection settings
      out->SetCutID(0, cutID[i]);
      out->SetCutID(1, cutID[i]);
      out->SetDaughter(0, AliRsnDaughter::kKaon);
      out->SetDaughter(1, AliRsnDaughter::kKaon);
      out->SetCharge(0, charge1[i]);
      out->SetCharge(1, charge2[i]);
      out->SetMotherPDG(333);
      out->SetMotherMass(1.019455);
      // pair cuts
      out->SetPairCuts(cutsPair);
      // axis X: invmass (or resolution)
      if (useIM)
         out->AddAxis(imID, 3000, 0.4,  7.0);
      else
         out->AddAxis(resID, 200, -0.02, 0.02);
      // axis Y: transverse momentum
      out->AddAxis(ptID, 400, 0.0, 40.0);
      // axis Z: centrality
//      out->AddAxis(centID, 100, 0.0, 100.0);
   }

////////////////////// 2 sigma cut TPC////////////////////////////////////////////////////////

   TString  name2   [4] = {"Unlike2sigmTPC", "Mixing2sigmTPC", "LikePP2sigmTPC", "LikeMM2sigmTPC"};
   Int_t    cutID2  [4] = { icut2       ,  icut2       ,  icut2       ,  icut2       };

   for (Int_t i = 0; i < 4; i++) {
      if (!use[i]) continue;
      // create output
      AliRsnMiniOutput *out = task->CreateOutput(Form("phi_%s%s", name2[i].Data(), suffix), output[i].Data(), comp[i].Data());
      // selection settings
      out->SetCutID(0, cutID2[i]);
      out->SetCutID(1, cutID2[i]);
      out->SetDaughter(0, AliRsnDaughter::kKaon);
      out->SetDaughter(1, AliRsnDaughter::kKaon);
      out->SetCharge(0, charge1[i]);
      out->SetCharge(1, charge2[i]);
      out->SetMotherPDG(333);
      out->SetMotherMass(1.019455);
      // pair cuts
      out->SetPairCuts(cutsPair);
      // axis X: invmass (or resolution)
      if (useIM)
         out->AddAxis(imID, 3000, 0.4,  7.0);
      else
         out->AddAxis(resID, 200, -0.02, 0.02);
      // axis Y: transverse momentum
      out->AddAxis(ptID, 400, 0.0, 40.0);
      // axis Z: centrality
//      out->AddAxis(centID, 100, 0.0, 100.0);
   }

////////////////////// 3 sigma cut TPC ////////////////////////////////////////////////////////

   TString  name3   [4] = {"Unlike3sigmTPC", "Mixing3sigmTPC", "LikePP3sigmTPC", "LikeMM3sigmTPC"};
   Int_t    cutID3  [4] = { icut3       ,  icut3       ,  icut3       ,  icut3       };

   for (Int_t i = 0; i < 4; i++) {
      if (!use[i]) continue;
      // create output
      AliRsnMiniOutput *out = task->CreateOutput(Form("phi_%s%s", name3[i].Data(), suffix), output[i].Data(), comp[i].Data());
      // selection settings
      out->SetCutID(0, cutID3[i]);
      out->SetCutID(1, cutID3[i]);
      out->SetDaughter(0, AliRsnDaughter::kKaon);
      out->SetDaughter(1, AliRsnDaughter::kKaon);
      out->SetCharge(0, charge1[i]);
      out->SetCharge(1, charge2[i]);
      out->SetMotherPDG(333);
      out->SetMotherMass(1.019455);
      // pair cuts
      out->SetPairCuts(cutsPair);
      // axis X: invmass (or resolution)
      if (useIM)
         out->AddAxis(imID, 3000, 0.4,  7.0);
      else
         out->AddAxis(resID, 200, -0.02, 0.02);
      // axis Y: transverse momentum
      out->AddAxis(ptID, 400, 0.0, 40.0);
      // axis Z: centrality
//      out->AddAxis(centID, 100, 0.0, 100.0);
   }

////////////////////// 4 sigma cut TPC ////////////////////////////////////////////////////////

   TString  name4   [4] = {"Unlike4sigmTPC", "Mixing4sigmTPC", "LikePP4sigmTPC", "LikeMM4sigmTPC"};
   Int_t    cutID4  [4] = { icut4       ,  icut4       ,  icut4       ,  icut4       };

   for (Int_t i = 0; i < 4; i++) {
      if (!use[i]) continue;
      // create output
      AliRsnMiniOutput *out = task->CreateOutput(Form("phi_%s%s", name4[i].Data(), suffix), output[i].Data(), comp[i].Data());
      // selection settings
      out->SetCutID(0, cutID4[i]);
      out->SetCutID(1, cutID4[i]);
      out->SetDaughter(0, AliRsnDaughter::kKaon);
      out->SetDaughter(1, AliRsnDaughter::kKaon);
      out->SetCharge(0, charge1[i]);
      out->SetCharge(1, charge2[i]);
      out->SetMotherPDG(333);
      out->SetMotherMass(1.019455);
      // pair cuts
      out->SetPairCuts(cutsPair);
      // axis X: invmass (or resolution)
      if (useIM)
         out->AddAxis(imID, 3000, 0.4,  7.0);
      else
         out->AddAxis(resID, 200, -0.02, 0.02);
      // axis Y: transverse momentum
      out->AddAxis(ptID, 400, 0.0, 40.0);
      // axis Z: centrality
//      out->AddAxis(centID, 100, 0.0, 100.0);
   }
////////////////////// 5s TPC  /////////////////////////////////////////////////
              TString  name5   [4] = {"Unlike5sigmTPC", "Mixing5sigmTPC", "LikePP5sigmTPC", "LikeMM5sigmTPC"};
              Int_t    cutID5  [4] = { icut5       ,  icut5       ,  icut5       ,  icut5       };

              for (Int_t i = 0; i < 4; i++) {
           	  if (!use[i]) continue;
                 // create output
                 AliRsnMiniOutput *out = task->CreateOutput(Form("phi_%s%s", name5[i].Data(), suffix), output[i].Data(), comp[i].Data());
                 // selection settings
                 out->SetCutID(0, cutID5[i]);
                 out->SetCutID(1, cutID5[i]);
                 out->SetDaughter(0, AliRsnDaughter::kKaon);
                 out->SetDaughter(1, AliRsnDaughter::kKaon);
                 out->SetCharge(0, charge1[i]);
                 out->SetCharge(1, charge2[i]);
                 out->SetMotherPDG(333);
                 out->SetMotherMass(1.019455);
                 // pair cuts
                 out->SetPairCuts(cutsPair);
                 // axis X: invmass (or resolution)
                 if (useIM)
                 out->AddAxis(imID, 3000, 0.4,  7.0);
                 else
                 out->AddAxis(resID, 200, -0.02, 0.02);
                 // axis Y: transverse momentum
                 out->AddAxis(ptID, 400, 0.0, 40.0);
                 // axis Z: centrality
                 //      out->AddAxis(centID, 100, 0.0, 100.0);
               }

////////////////////// 6s TPC  /////////////////////////////////////////////////

               TString  name6   [4] = {"Unlike6sigmTPC", "Mixing6sigmTPC", "LikePP6sigmTPC", "LikeMM6sigmTPC"};
               Int_t    cutID6  [4] = { icut6       ,  icut6       ,  icut6       ,  icut6       };

               for (Int_t i = 0; i < 4; i++) {
                 if (!use[i]) continue;
                 // create output
                 AliRsnMiniOutput *out = task->CreateOutput(Form("phi_%s%s", name6[i].Data(), suffix), output[i].Data(), comp[i].Data());
                 // selection settings
                 out->SetCutID(0, cutID6[i]);
                 out->SetCutID(1, cutID6[i]);
                 out->SetDaughter(0, AliRsnDaughter::kKaon);
                 out->SetDaughter(1, AliRsnDaughter::kKaon);
                 out->SetCharge(0, charge1[i]);
                 out->SetCharge(1, charge2[i]);
                 out->SetMotherPDG(333);
                 out->SetMotherMass(1.019455);
                 // pair cuts
                 out->SetPairCuts(cutsPair);
                 // axis X: invmass (or resolution)
                 if (useIM)
                 out->AddAxis(imID, 3000, 0.4,  7.0);
                 else
                 out->AddAxis(resID, 200, -0.02, 0.02);
                 // axis Y: transverse momentum
                 out->AddAxis(ptID, 400, 0.0, 40.0);
                 // axis Z: centrality
                 //      out->AddAxis(centID, 100, 0.0, 100.0);
               }

////////////////////// THE END! ////////////////////////////////////////////////////////


   return kTRUE;
}
Commit	Line	Data
4b2c784b	1	//
	2	// * Configuration script for phi->KK analysis with 2010 runs *
	3	//
	4	// A configuration script for RSN package needs to define the followings:
	5	//
	6	// (1) decay tree of each resonance to be studied, which is needed to select
	7	// true pairs and to assign the right mass to all candidate daughters
	8	// (2) cuts at all levels: single daughters, tracks, events
	9	// (3) output objects: histograms or trees
	10	//
	11	Bool_t ConfigPhiRAApp
	12	(
	13	AliRsnMiniAnalysisTask *task,
	14	Bool_t isMC,
	15	Bool_t isESD,
	16	const char *suffix,
	17	AliRsnCutSet *cutsPair
	18	)
	19	{
	20	// manage suffix
	21	if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
	22
	23	//
	24	// -- Define track cuts -------------------------------------------------------------------------
	25	//
	26
	27
	28
	29	gROOT->LoadMacro("AliRsnCutPhiRAA.cxx++g");
	30	// standard kaon cut
	31	AliRsnCutPhiRAA *cut = new AliRsnCutPhiRAA("cut1");
	32	cut->SetMode(AliRsnCutPhiRAA::k2010);
	33	// TPC 2 sigma pid
	34	AliRsnCutPIDNSigma *cutKTPC2 = new AliRsnCutPIDNSigma("cut2SigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
	35	cutKTPC2->SinglePIDRange(2.0);
	36	// TPC 3 sigma pid
	37	AliRsnCutPIDNSigma *cutKTPC3 = new AliRsnCutPIDNSigma("cut3SigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
	38	cutKTPC3->SinglePIDRange(3.0);
	39	// TPC 4 sigma pid
	40	AliRsnCutPIDNSigma *cutKTPC4 = new AliRsnCutPIDNSigma("cut4SigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
	41	cutKTPC4->SinglePIDRange(4.0);
	42	// TPC 5 sigma pid
	43	AliRsnCutPIDNSigma *cutKTPC5 = new AliRsnCutPIDNSigma("cut5SigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
	44	cutKTPC5->SinglePIDRange(5.0);
	45	// TPC 6 sigma pid
	46	AliRsnCutPIDNSigma *cutKTPC6 = new AliRsnCutPIDNSigma("cut6SigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
	47	cutKTPC6->SinglePIDRange(6.0);
	48
	49	////////////////////////// Cut Sets ///////////////////////////////////////////////
	50
	51	AliRsnCutSet *cutSet = new AliRsnCutSet("set_NoPID", AliRsnTarget::kDaughter);
	52	AliRsnCutSet *cutSet2 = new AliRsnCutSet("set_2sigmaTPC", AliRsnTarget::kDaughter);
	53	AliRsnCutSet *cutSet3 = new AliRsnCutSet("set_3sigmaTPC", AliRsnTarget::kDaughter);
	54	AliRsnCutSet *cutSet4 = new AliRsnCutSet("set_4sigmaTPC", AliRsnTarget::kDaughter);
	55	AliRsnCutSet *cutSet5 = new AliRsnCutSet("set_5sigmaTPC", AliRsnTarget::kDaughter);
	56	AliRsnCutSet *cutSet6 = new AliRsnCutSet("set_6sigmaTPC", AliRsnTarget::kDaughter);
	57
	58	////////////////////////////////////////////////////////////////////////////////////
	59
	60	// no PID (only standard cuts)
	61	cutSet->AddCut(cut);
	62	cutSet->SetCutScheme(cut->GetName());
	63
	64	// TPC 2 sigma cut
65	cutSet2->AddCut(cut);
66	cutSet2->AddCut(cutKTPC2);
67	cutSet2->SetCutScheme("cut1&cut2SigmaTPCK");
68
69	// TPC 3 sigma cut
70	cutSet3->AddCut(cut);
71	cutSet3->AddCut(cutKTPC3);
72	cutSet3->SetCutScheme("cut1&cut3SigmaTPCK");
73
74	// TPC 4 sigma cut
75	cutSet4->AddCut(cut);
76	cutSet4->AddCut(cutKTPC4);
77	cutSet4->SetCutScheme("cut1&cut4SigmaTPCK");
78
79	// TPC 5 sigma cut
80	cutSet5->AddCut(cut);
81	cutSet5->AddCut(cutKTPC5);
82	cutSet5->SetCutScheme("cut1&cut5SigmaTPCK");
83
84	// TPC 6 sigma cut
85	cutSet6->AddCut(cut);
86	cutSet6->AddCut(cutKTPC6);
87	cutSet6->SetCutScheme("cut1&cut6SigmaTPCK");
88
89	//////////////////////////////////////////////////////////////////////////////
90	// add to task
91	Int_t icut = task->AddTrackCuts(cutSet);
92	Int_t icut2 = task->AddTrackCuts(cutSet2);
93	Int_t icut3 = task->AddTrackCuts(cutSet3);
94	Int_t icut4 = task->AddTrackCuts(cutSet4);
95	Int_t icut5 = task->AddTrackCuts(cutSet5);
96	Int_t icut6 = task->AddTrackCuts(cutSet6);
97
98	Printf("======== Monitoring cut AliRsnCutSetDaughterParticle enabled");
99	gROOT->LoadMacro("$ALICE_ROOT/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C");
100	AddMonitorOutput(isMC, cutSet->GetMonitorOutput());
101
102	//
103	// -- Values ------------------------------------------------------------------------------------
104	//
105
106	/* invariant mass */ Int_t imID = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
107	// /* IM resolution */ Int_t resID = task->CreateValue(AliRsnMiniValue::kInvMassRes, kTRUE);
108	/* IM resolution */ Int_t resID = task->CreateValue(AliRsnMiniValue::kInvMassRes, kFALSE);
109	/* transv. momentum */ Int_t ptID = task->CreateValue(AliRsnMiniValue::kPt, kFALSE);
110	/* centrality */ Int_t centID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE);
111
112	//
113	// -- Create all needed outputs -----------------------------------------------------------------
114	//
115
116
117	// use an array for more compact writing, which are different on mixing and charges
118	// [0] = unlike
119	// [1] = mixing
120	// [2] = like ++
121	// [3] = like --
122
123	/////////////////// NoPID ///////////////////////////////////////////////////////////////
124
125	Bool_t use [4] = { 1 , 1 , 1 , 1 };
126	Bool_t useIM [4] = { 1 , 1 , 1 , 1 };
127	TString name [4] = {"UnlikeNoPID", "MixingNoPID", "LikePPNoPID", "LikeMMNoPID"};
128	TString comp [4] = {"PAIR" , "MIX" , "PAIR" , "PAIR" };
129	TString output [4] = {"HIST" , "HIST" , "HIST" , "HIST" };
130	Char_t charge1 [4] = {'+' , '+' , '+' , '-' };
131	Char_t charge2 [4] = {'-' , '-' , '+' , '-' };
132	Int_t cutID [4] = { icut , icut , icut , icut };
133
134	for (Int_t i = 0; i < 4; i++) {
135	if (!use[i]) continue;
136	// create output
137	AliRsnMiniOutput *out = task->CreateOutput(Form("phi_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data());
138	// selection settings
139	out->SetCutID(0, cutID[i]);
140	out->SetCutID(1, cutID[i]);
141	out->SetDaughter(0, AliRsnDaughter::kKaon);
142	out->SetDaughter(1, AliRsnDaughter::kKaon);
143	out->SetCharge(0, charge1[i]);
144	out->SetCharge(1, charge2[i]);
145	out->SetMotherPDG(333);
146	out->SetMotherMass(1.019455);
147	// pair cuts
148	out->SetPairCuts(cutsPair);
149	// axis X: invmass (or resolution)
150	if (useIM)
151	out->AddAxis(imID, 3000, 0.4, 7.0);
152	else
153	out->AddAxis(resID, 200, -0.02, 0.02);
154	// axis Y: transverse momentum
155	out->AddAxis(ptID, 400, 0.0, 40.0);
156	// axis Z: centrality
157	// out->AddAxis(centID, 100, 0.0, 100.0);
158	}
159
160	////////////////////// 2 sigma cut TPC////////////////////////////////////////////////////////
161
162	TString name2 [4] = {"Unlike2sigmTPC", "Mixing2sigmTPC", "LikePP2sigmTPC", "LikeMM2sigmTPC"};
163	Int_t cutID2 [4] = { icut2 , icut2 , icut2 , icut2 };
164
165	for (Int_t i = 0; i < 4; i++) {
166	if (!use[i]) continue;
167	// create output
168	AliRsnMiniOutput *out = task->CreateOutput(Form("phi_%s%s", name2[i].Data(), suffix), output[i].Data(), comp[i].Data());
169	// selection settings
170	out->SetCutID(0, cutID2[i]);
171	out->SetCutID(1, cutID2[i]);
172	out->SetDaughter(0, AliRsnDaughter::kKaon);
173	out->SetDaughter(1, AliRsnDaughter::kKaon);
174	out->SetCharge(0, charge1[i]);
175	out->SetCharge(1, charge2[i]);
176	out->SetMotherPDG(333);
177	out->SetMotherMass(1.019455);
178	// pair cuts
179	out->SetPairCuts(cutsPair);
180	// axis X: invmass (or resolution)
181	if (useIM)
182	out->AddAxis(imID, 3000, 0.4, 7.0);
183	else
184	out->AddAxis(resID, 200, -0.02, 0.02);
185	// axis Y: transverse momentum
186	out->AddAxis(ptID, 400, 0.0, 40.0);
187	// axis Z: centrality
188	// out->AddAxis(centID, 100, 0.0, 100.0);
189	}
190
191	////////////////////// 3 sigma cut TPC ////////////////////////////////////////////////////////
192
193	TString name3 [4] = {"Unlike3sigmTPC", "Mixing3sigmTPC", "LikePP3sigmTPC", "LikeMM3sigmTPC"};
194	Int_t cutID3 [4] = { icut3 , icut3 , icut3 , icut3 };
195
196	for (Int_t i = 0; i < 4; i++) {
197	if (!use[i]) continue;
198	// create output
199	AliRsnMiniOutput *out = task->CreateOutput(Form("phi_%s%s", name3[i].Data(), suffix), output[i].Data(), comp[i].Data());
200	// selection settings
201	out->SetCutID(0, cutID3[i]);
202	out->SetCutID(1, cutID3[i]);
203	out->SetDaughter(0, AliRsnDaughter::kKaon);
204	out->SetDaughter(1, AliRsnDaughter::kKaon);
205	out->SetCharge(0, charge1[i]);
206	out->SetCharge(1, charge2[i]);
207	out->SetMotherPDG(333);
208	out->SetMotherMass(1.019455);
209	// pair cuts
210	out->SetPairCuts(cutsPair);
211	// axis X: invmass (or resolution)
212	if (useIM)
213	out->AddAxis(imID, 3000, 0.4, 7.0);
214	else
215	out->AddAxis(resID, 200, -0.02, 0.02);
216	// axis Y: transverse momentum
217	out->AddAxis(ptID, 400, 0.0, 40.0);
218	// axis Z: centrality
219	// out->AddAxis(centID, 100, 0.0, 100.0);
220	}
221
222	////////////////////// 4 sigma cut TPC ////////////////////////////////////////////////////////
223
224	TString name4 [4] = {"Unlike4sigmTPC", "Mixing4sigmTPC", "LikePP4sigmTPC", "LikeMM4sigmTPC"};
225	Int_t cutID4 [4] = { icut4 , icut4 , icut4 , icut4 };
226
227	for (Int_t i = 0; i < 4; i++) {
228	if (!use[i]) continue;
229	// create output
230	AliRsnMiniOutput *out = task->CreateOutput(Form("phi_%s%s", name4[i].Data(), suffix), output[i].Data(), comp[i].Data());
231	// selection settings
232	out->SetCutID(0, cutID4[i]);
233	out->SetCutID(1, cutID4[i]);
234	out->SetDaughter(0, AliRsnDaughter::kKaon);
235	out->SetDaughter(1, AliRsnDaughter::kKaon);
236	out->SetCharge(0, charge1[i]);
237	out->SetCharge(1, charge2[i]);
238	out->SetMotherPDG(333);
239	out->SetMotherMass(1.019455);
240	// pair cuts
241	out->SetPairCuts(cutsPair);
242	// axis X: invmass (or resolution)
243	if (useIM)
244	out->AddAxis(imID, 3000, 0.4, 7.0);
245	else
246	out->AddAxis(resID, 200, -0.02, 0.02);
247	// axis Y: transverse momentum
248	out->AddAxis(ptID, 400, 0.0, 40.0);
249	// axis Z: centrality
250	// out->AddAxis(centID, 100, 0.0, 100.0);
251	}
252	////////////////////// 5s TPC /////////////////////////////////////////////////
253	TString name5 [4] = {"Unlike5sigmTPC", "Mixing5sigmTPC", "LikePP5sigmTPC", "LikeMM5sigmTPC"};
254	Int_t cutID5 [4] = { icut5 , icut5 , icut5 , icut5 };
255
256	for (Int_t i = 0; i < 4; i++) {
257	if (!use[i]) continue;
258	// create output
259	AliRsnMiniOutput *out = task->CreateOutput(Form("phi_%s%s", name5[i].Data(), suffix), output[i].Data(), comp[i].Data());
260	// selection settings
261	out->SetCutID(0, cutID5[i]);
262	out->SetCutID(1, cutID5[i]);
263	out->SetDaughter(0, AliRsnDaughter::kKaon);
264	out->SetDaughter(1, AliRsnDaughter::kKaon);
265	out->SetCharge(0, charge1[i]);
266	out->SetCharge(1, charge2[i]);
267	out->SetMotherPDG(333);
268	out->SetMotherMass(1.019455);
269	// pair cuts
270	out->SetPairCuts(cutsPair);
271	// axis X: invmass (or resolution)
272	if (useIM)
273	out->AddAxis(imID, 3000, 0.4, 7.0);
274	else
275	out->AddAxis(resID, 200, -0.02, 0.02);
276	// axis Y: transverse momentum
277	out->AddAxis(ptID, 400, 0.0, 40.0);
278	// axis Z: centrality
279	// out->AddAxis(centID, 100, 0.0, 100.0);
280	}
281
282	////////////////////// 6s TPC /////////////////////////////////////////////////
283
284	TString name6 [4] = {"Unlike6sigmTPC", "Mixing6sigmTPC", "LikePP6sigmTPC", "LikeMM6sigmTPC"};
285	Int_t cutID6 [4] = { icut6 , icut6 , icut6 , icut6 };
286
287	for (Int_t i = 0; i < 4; i++) {
288	if (!use[i]) continue;
289	// create output
290	AliRsnMiniOutput *out = task->CreateOutput(Form("phi_%s%s", name6[i].Data(), suffix), output[i].Data(), comp[i].Data());
291	// selection settings
292	out->SetCutID(0, cutID6[i]);
293	out->SetCutID(1, cutID6[i]);
294	out->SetDaughter(0, AliRsnDaughter::kKaon);
295	out->SetDaughter(1, AliRsnDaughter::kKaon);
296	out->SetCharge(0, charge1[i]);
297	out->SetCharge(1, charge2[i]);
298	out->SetMotherPDG(333);
299	out->SetMotherMass(1.019455);
300	// pair cuts
301	out->SetPairCuts(cutsPair);
302	// axis X: invmass (or resolution)
303	if (useIM)
304	out->AddAxis(imID, 3000, 0.4, 7.0);
305	else
306	out->AddAxis(resID, 200, -0.02, 0.02);
307	// axis Y: transverse momentum
308	out->AddAxis(ptID, 400, 0.0, 40.0);
309	// axis Z: centrality
310	// out->AddAxis(centID, 100, 0.0, 100.0);
311	}
312
313	////////////////////// THE END! ////////////////////////////////////////////////////////
314
315
316	return kTRUE;
317	}