2 #include <AliRsnListOutput.h>
3 #include <AliRsnValuePair.h>
4 #include <AliRsnValueEvent.h>
5 #include <AliRsnMiniAnalysisTask.h>
8 void AddRsnPairsPhi(AliAnalysisTaskSE *task,
11 AliPID::EParticleType pType1,
13 AliPID::EParticleType pType2,
15 AliRsnCutSet *cutsEvent=0,
16 AliRsnCutSet *cutsPair=0,
20 Printf("id1=%d id2=%d",listID1,listID2);
22 // retrieve mass from PDG database
24 TDatabasePDG *db = TDatabasePDG::Instance();
25 TParticlePDG *part = db->GetParticle(pdg);
26 Double_t mass = part->Mass();
29 Int_t isRsnMini = AliRsnTrainManager::GetGlobalInt("IsRsnMini",valid);
32 AddPairOutputMiniPhi(task,isMC,isMixing,pType1,listID1,pType2,listID2,pdg,mass,cutsPair,suffix);
34 // this function is common and it is located in RsnConfig.C
35 // as ouptup AddPairOutputPhi from this macro will be taken
36 AddPair(task,isMC,isMixing,pType1,listID1,pType2,listID2,pdg,mass,cutsEvent,cutsPair,suffix);
39 void AddPairOutputPhi(AliRsnLoopPair *pair)
42 Int_t isFullOutput = AliRsnTrainManager::GetGlobalInt("RsnOutputFull",valid);
43 Int_t collisionType = AliRsnTrainManager::GetGlobalInt("IsCollisionType",valid);
44 Int_t useRapidity = AliRsnTrainManager::GetGlobalInt("RsnUseRapidity",valid);
47 AliRsnValuePair *axisIM = new AliRsnValuePair("IM", AliRsnValuePair::kInvMass);
48 AliRsnValuePair *axisPt = new AliRsnValuePair("PT", AliRsnValuePair::kPt);
49 AliRsnValuePair *axisEta = new AliRsnValuePair("ETA", AliRsnValuePair::kEta);
50 AliRsnValuePair *axisRapidity = new AliRsnValuePair("Y", AliRsnValuePair::kY);
52 AliRsnValueEvent *axisCentrality = 0;
53 if (collisionType == 1) axisCentrality = new AliRsnValueEvent("MULTI",AliRsnValueEvent::kCentralityV0);
56 axisIM ->SetBins(300, 0.9, 1.2);
57 // axisIM ->SetBins(600, 0.9, 1.2);
58 // axisIM ->SetBins(1000, 0.9, 1.9);
59 axisPt ->SetBins(120, 0.0, 12.0);
60 // axisEta ->SetBins(400, -2.0, 2.0);
61 axisEta ->SetBins(400, -0.5, 0.5);
62 axisRapidity ->SetBins(10, -0.5, 0.5);
64 if (axisCentrality) axisCentrality->SetBins(20,0,100);
66 // output: 2D histogram of inv. mass vs. pt
67 AliRsnListOutput *outPair = 0;
69 outPair = new AliRsnListOutput("pair", AliRsnListOutput::kHistoDefault);
70 outPair->AddValue(axisIM);
72 outPair = new AliRsnListOutput("pair", AliRsnListOutput::kHistoSparse);
73 outPair->AddValue(axisIM);
74 outPair->AddValue(axisPt);
75 if (useRapidity) outPair->AddValue(axisRapidity);
76 else outPair->AddValue(axisEta);
77 if (axisCentrality) outPair->AddValue(axisCentrality);
79 // add outputs to loop
80 pair->AddOutput(outPair);
83 void AddPairOutputMiniPhi(AliAnalysisTaskSE *task, Bool_t isMC,Bool_t isMixing, AliPID::EParticleType pType1,Int_t listID1, AliPID::EParticleType pType2,Int_t listID2, Int_t pdgMother,Double_t massMother, AliRsnCutSet *cutsPair=0,TString suffix = "")
87 Int_t isFullOutput = AliRsnTrainManager::GetGlobalInt("RsnOutputFull",valid);
88 Int_t useMixing = AliRsnTrainManager::GetGlobalInt("IsMixing",valid);
89 Int_t collisionType = AliRsnTrainManager::GetGlobalInt("IsCollisionType",valid);
91 Int_t useMixLike = AliRsnTrainManager::GetGlobalInt("RsnMixLike",valid);
92 Int_t useRapidity = AliRsnTrainManager::GetGlobalInt("RsnUseRapidity",valid);
94 Int_t useQA = AliRsnTrainManager::GetGlobalInt("RsnQA",valid);
96 AliRsnMiniAnalysisTask *taskRsnMini = (AliRsnMiniAnalysisTask *)task;
99 // retrieve mass from PDG database
101 TDatabasePDG *db = TDatabasePDG::Instance();
102 TParticlePDG *part = db->GetParticle(pdg);
104 // common definitions
105 TString outputType = "HIST";
106 if (isFullOutput) outputType = "SPARSE";
110 if (collisionType==0) taskRsnMini->UseMultiplicity("QUALITY");
112 taskRsnMini->UseCentrality("V0M");
113 Int_t multID = taskRsnMini->CreateValue(AliRsnMiniValue::kMult, kFALSE);
114 AliRsnMiniOutput *outMult = taskRsnMini->CreateOutput("eventMult", "HIST", "EVENT");
115 outMult->AddAxis(multID, 100, 0.0, 100.0);
116 Int_t paID = taskRsnMini->CreateValue(AliRsnMiniValue::kPlaneAngle, kFALSE);
117 AliRsnMiniOutput *outPa = taskRsnMini->CreateOutput("planeAngle", "HIST", "EVENT");
118 outPa->AddAxis(paID, 100, 0, TMath::Pi());
122 /* invariant mass */ Int_t imID = taskRsnMini->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
123 /* IM resolution */ Int_t resID = taskRsnMini->CreateValue(AliRsnMiniValue::kInvMassDiff, kTRUE);
124 /* transv. momentum */ Int_t ptID = taskRsnMini->CreateValue(AliRsnMiniValue::kPt, kFALSE);
125 /* centrality */ Int_t centID = taskRsnMini->CreateValue(AliRsnMiniValue::kMult, kFALSE);
126 /* eta */ Int_t etaID = taskRsnMini->CreateValue(AliRsnMiniValue::kEta, kFALSE);
127 /* rapidity */ Int_t yID = taskRsnMini->CreateValue(AliRsnMiniValue::kY, kFALSE);
130 // use an array for more compact writing, which are different on mixing and charges
136 // Bool_t useMixLike = kFALSE;
137 // useMixLike = kTRUE;
139 const Int_t numAxis = 7;
140 Bool_t use [numAxis] = { 1 , useMixing , 1 , 1 , isMC , useMixLike, useMixLike};
141 TString name [numAxis] = {"Unlike", "Mixing", "LikePP", "LikeMM", "Trues", "MixingPP", "MixingMM"};
142 TString comp [numAxis] = {"PAIR" , "MIX" , "PAIR" , "PAIR" , "TRUE" , "MIX" , "MIX" };
143 Char_t charge1 [numAxis] = {'+' , '+' , '+' , '-' , '+' , '+' , '-' };
144 Char_t charge2 [numAxis] = {'-' , '-' , '+' , '-' , '-' , '+' , '-' };
146 Int_t nIM = 215; Double_t minIM = 0.985, maxIM = 1.2;
147 // Int_t nEta = 400; Double_t minEta = -2.0, maxEta = 2.0;
148 Int_t nEta = 400; Double_t minEta = -0.5, maxEta = 0.5;
149 Int_t nY = 1; Double_t minY = -0.5, maxY = 0.5;
150 // Int_t nIM = 1000; Double_t minIM = 0.9, maxIM = 1.9;
151 Int_t nPt = 240; Double_t minPt = 0.0, maxPt = 24.0;
152 Int_t nCent = 20; Double_t minCent = 0.0, maxCent = 100.0;
153 Int_t nRes = 200; Double_t maxRes = 0.01;
156 if (collisionType==0) {
157 nIM = 150; minIM = 0.975; maxIM = 1.125;
158 nPt = 160; minPt = 0.0, maxPt = 8.0;
159 nEta = 30; minEta = -1.5; maxEta = 1.5;
160 nY = 3; minY = -1.5; maxY = 1.5;
163 Printf(suffix.Data());
164 // create standard outputs
165 for (Int_t i = 0; i < numAxis; i++) {
166 if (!use[i]) continue;
168 AliRsnMiniOutput *out = taskRsnMini->CreateOutput(Form("%s_%s", suffix.Data(),name[i].Data() ), outputType.Data(), comp[i].Data());
169 // selection settings
170 out->SetCutID(0, listID1);
171 out->SetCutID(1, listID1);
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(pdg);
177 out->SetMotherMass(part->Mass());
179 if (cutsPair) out->SetPairCuts(cutsPair);
181 out->AddAxis(imID, nIM, minIM, maxIM);
184 // axis Y: transverse momentum
185 out->AddAxis(ptID, nPt, minPt, maxPt);
187 if (useRapidity) out->AddAxis(yID, nY, minY, maxY);
188 if (collisionType==0) out->AddAxis(etaID, nEta, minEta, maxEta);
189 // axis Z: centrality
190 if (collisionType==1) out->AddAxis(centID, nCent, minCent, maxCent);
194 // add output for resolution
196 AliRsnMiniOutput *outRes = taskRsnMini->CreateOutput(Form("phi_Res%s", suffix.Data()), outputType.Data(), "TRUE");
197 // selection settings
198 outRes->SetCutID(0, listID1);
199 outRes->SetCutID(1, listID1);
200 outRes->SetDaughter(0, AliRsnDaughter::kKaon);
201 outRes->SetDaughter(1, AliRsnDaughter::kKaon);
202 outRes->SetCharge(0, '+');
203 outRes->SetCharge(1, '-');
204 outRes->SetMotherPDG(pdg);
205 outRes->SetMotherMass(part->Mass());
207 if (cutsPair) outRes->SetPairCuts(cutsPair);
208 // axis X: resolution
209 outRes->AddAxis(resID, nRes, -maxRes, maxRes);
212 // axis Y: transverse momentum
213 outRes->AddAxis(ptID, nPt, minPt, maxPt);
214 if (useRapidity) outRes->AddAxis(yID, nY, minY, maxY);
215 if (collisionType==0) outRes->AddAxis(etaID, nEta, minEta, maxEta);
217 // axis Z: centrality
218 if (collisionType==1) outRes->AddAxis(centID, nCent, minCent, maxCent);
223 // -- Create output for MC generated ------------------------------------------------------------
228 AliRsnMiniOutput *outMC = taskRsnMini->CreateOutput(Form("phi_MCGen%s", suffix.Data()), outputType.Data(), "MOTHER");
229 // selection settings
230 outMC->SetDaughter(0, AliRsnDaughter::kKaon);
231 outMC->SetDaughter(1, AliRsnDaughter::kKaon);
232 outMC->SetMotherPDG(pdg);
233 outMC->SetMotherMass(part->Mass());
235 if (cutsPair) outMC->SetPairCuts(cutsPair);
237 outMC->AddAxis(imID, nIM, minIM, maxIM);
239 // axis Y: transverse momentum
240 outMC->AddAxis(ptID, nPt, minPt, maxPt);
241 if (useRapidity) outMC->AddAxis(yID, nY, minY, maxY);
242 if (collisionType==0) outMC->AddAxis(etaID, nEta, minEta, maxEta);
243 // axis Z: centrality
244 if (collisionType==1) outMC->AddAxis(centID, nCent, minCent, maxCent);
249 /* invariant mass */ Int_t imID = taskRsnMini->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
250 /* transv. momentum */ Int_t ptID = taskRsnMini->CreateValue(AliRsnMiniValue::kPt, kFALSE);
251 /* rapidity */ Int_t yID = taskRsnMini->CreateValue(AliRsnMiniValue::kY, kFALSE);
253 const Int_t numAxis = 3;
254 Bool_t use [numAxis] = { 1 , 1 , 1 };
255 TString name [numAxis] = {"Unlike", "LikePP", "LikeMM" };
256 TString comp [numAxis] = {"PAIR" , "PAIR" , "PAIR" };
257 Char_t charge1 [numAxis] = {'+' , '+' , '-' };
258 Char_t charge2 [numAxis] = {'-' , '+' , '-' };
260 Int_t nIM = 215; Double_t minIM = 0.985, maxIM = 1.2;
261 Int_t nPt = 1; Double_t minPt = 0.5, maxPt = 1.5;
262 Int_t nY = 1; Double_t minY = -0.5, maxY = 0.5;
264 for (Int_t i = 0; i < numAxis; i++) {
265 if (!use[i]) continue;
267 AliRsnMiniOutput *out = taskRsnMini->CreateOutput(Form("%s_%s", suffix.Data(),name[i].Data() ), outputType.Data(), comp[i].Data());
268 // selection settings
269 out->SetCutID(0, listID1);
270 out->SetCutID(1, listID1);
271 out->SetDaughter(0, AliRsnDaughter::kKaon);
272 out->SetDaughter(1, AliRsnDaughter::kKaon);
273 out->SetCharge(0, charge1[i]);
274 out->SetCharge(1, charge2[i]);
275 out->SetMotherPDG(pdg);
276 out->SetMotherMass(part->Mass());
278 out->AddAxis(imID, nIM, minIM, maxIM);
279 out->AddAxis(ptID, nPt, minPt, maxPt);
280 out->AddAxis(yID, nY, minY, maxY);