[u/mrichter/AliRoot.git] / PWGLF / RESONANCES / macros / mini / ConfigPhiRAAPbPb.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 ConfigPhiRAAPbPb
(
   AliRsnMiniAnalysisTask *task,
   Bool_t                  isMC,
   Bool_t                  isESD,
   const char             *suffix,
   AliRsnCutSet           *cutsPair,
   Int_t 				   centr
)
{
   // 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");
   if (centr == 1) {
	  cut->SetMode(AliRsnCutPhiRAA::k2011_1_075);
   }
   else {
	  cut->SetMode(AliRsnCutPhiRAA::k2011_1_05);
   }


   // 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 03 ///////////////////////////////////////////////////////////////

         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] = {"SPARSE"       , "SPARSE"       , "SPARSE"       , "SPARSE"       };
         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, 150, 0.9,  1.23);
            else
               out->AddAxis(resID, 200, -0.02, 0.02);
            // axis Y: transverse momentum
            out->AddAxis(ptID, 300, 0.0, 30.0);
            // axis Z: centrality
            out->AddAxis(centID, 100, 0.0, 100.0);
         }

////////////////////// 2s TPC 03 /////////////////////////////////////////////////

        TString  name2   [4] = {"Unlike2sigmaTPC", "Mixing2sigmaTPC", "LikePP2sigmaTPC", "LikeMM2sigmaTPC"};
        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, 150, 0.9,  1.23);
          else
             out->AddAxis(resID, 200, -0.02, 0.02);
          // axis Y: transverse momentum
          out->AddAxis(ptID, 300, 0.0, 30.0);
          // axis Z: centrality
          out->AddAxis(centID, 100, 0.0, 100.0);
        }

////////////////////// 3s TPC  03 //////////////////////////////////////////////////////////

       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, 150, 0.9,  1.23);
         else
            out->AddAxis(resID, 200, -0.02, 0.02);
         // axis Y: transverse momentum
         out->AddAxis(ptID, 300, 0.0, 30.0);
         // axis Z: centrality
         out->AddAxis(centID, 100, 0.0, 100.0);
       }

////////////////////// 4s TPC  03/////////////////////////////////////////////////

      TString  name4   [4] = {"Unlike4sigmaTPC", "Mixing4sigmaTPC", "LikePP4sigmaTPC", "LikeMM4sigmaTPC"};
      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, 150, 0.9,  1.23);
        else
           out->AddAxis(resID, 200, -0.02, 0.02);
        // axis Y: transverse momentum
        out->AddAxis(ptID, 300, 0.0, 30.0);
        // axis Z: centrality
        out->AddAxis(centID, 100, 0.0, 100.0);
      }

////////////////////// 5s TPC  03/////////////////////////////////////////////////

       TString  name5   [4] = {"Unlike5sigmaTPC", "Mixing5sigmaTPC", "LikePP5sigmaTPC", "LikeMM5sigmaTPC"};
       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, 150, 0.9,  1.23);
         else
            out->AddAxis(resID, 200, -0.02, 0.02);
         // axis Y: transverse momentum
         out->AddAxis(ptID, 300, 0.0, 30.0);
         // axis Z: centrality
         out->AddAxis(centID, 100, 0.0, 100.0);
       }

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

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