1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
17 // Apply cut steps to all tracks in one event and returns a list of
21 // Markus Fasel <M.Fasel@gsi.de>
26 #include "AliAnalysisCuts.h"
27 #include "AliCFContainer.h"
28 #include "AliCFParticleGenCuts.h"
29 #include "AliCFTrackKineCuts.h"
30 #include "AliCFTrackIsPrimaryCuts.h"
31 #include "AliCFTrackQualityCuts.h"
32 #include "AliMCEvent.h"
33 #include "AliVEvent.h"
34 #include "AliVTrack.h"
35 #include "AliVParticle.h"
37 #include "AliHFEcontainer.h"
38 #include "AliHFEcutStep.h"
39 #include "AliHFEextraCuts.h"
40 #include "AliHFEtrackFilter.h"
41 #include "AliHFEtools.h"
43 ClassImp(AliHFEtrackFilter)
45 //__________________________________________________________________
46 AliHFEtrackFilter::AliHFEtrackFilter() :
48 fFilteredTracks(NULL),
50 fEfficiencyContainers(NULL),
65 //__________________________________________________________________
66 AliHFEtrackFilter::AliHFEtrackFilter(const Char_t *name) :
68 fFilteredTracks(NULL),
70 fEfficiencyContainers(NULL),
83 fCutSteps = new TObjArray;
84 fFilteredTracks = new TObjArray;
85 fEfficiencyContainers = new TObjArray(4);
88 //__________________________________________________________________
89 AliHFEtrackFilter::AliHFEtrackFilter(const AliHFEtrackFilter &ref):
91 fFilteredTracks(NULL),
93 fEfficiencyContainers(NULL),
109 //__________________________________________________________________
110 AliHFEtrackFilter &AliHFEtrackFilter::operator=(const AliHFEtrackFilter &o){
112 // Assignment operator
120 //__________________________________________________________________
121 AliHFEtrackFilter::~AliHFEtrackFilter(){
126 // remove correction framework content
127 if(fPtBinning) delete fPtBinning;
128 if(fEtaBinning) delete fEtaBinning;
129 if(fPhiBinning) delete fPhiBinning;
130 if(TestBit(kOwnCFContainers))
131 fEfficiencyContainers->Delete();
132 delete fEfficiencyContainers;
133 // remove default content
134 delete fFilteredTracks;
138 //__________________________________________________________________
139 void AliHFEtrackFilter::Copy(TObject &o) const{
141 // Copy content into the object o
144 AliHFEtrackFilter &target = dynamic_cast<AliHFEtrackFilter &>(o);
147 target.fFilteredTracks = dynamic_cast<TObjArray *>(fFilteredTracks->Clone());
148 target.fCutSteps = dynamic_cast<TObjArray *>(fCutSteps->Clone());
149 target.fEfficiencyContainers = dynamic_cast<TObjArray *>(fEfficiencyContainers->Clone());
151 target.fMCsignal = dynamic_cast<AliHFEcutStep *>(fMCsignal->Clone());
153 target.fPtBins = fPtBins;
154 target.fEtaBins = fEtaBins;
155 target.fPhiBins = fPhiBins;
156 target.fPtBinning = new Double_t[fPtBins];
157 memcpy(target.fPtBinning, fPtBinning, sizeof(Double_t) * fPtBins);
158 target.fEtaBinning = new Double_t[fEtaBins];
159 memcpy(target.fEtaBinning, fEtaBinning, sizeof(Double_t) * fEtaBins);
160 target.fPhiBinning = new Double_t[fPhiBins];
161 memcpy(target.fPhiBinning, fPhiBinning, sizeof(Double_t) * fPhiBins);
164 //__________________________________________________________________
165 void AliHFEtrackFilter::InitCF(){
167 // Initialize correction framework container
168 // No HFE container given
169 // Only for testing purpose
171 const Char_t *cnames[4] = {"_container", "_container_signal", "_container_MC", "_container_signalMC"};
172 const Char_t *ctitlesAppends[4] = {"(All Rec)", "(All Signals)", "(All Rec (MC))", "(All Signals(MC))"};
174 // Create the binning if not done from outside
177 fPtBinning = AliHFEtools::MakeLogarithmicBinning(fPtBins, 0.1, 10);
181 fEtaBinning = AliHFEtools::MakeLinearBinning(fEtaBins, -0.9, 0.9);
185 fPhiBinning = AliHFEtools::MakeLinearBinning(fPhiBins, 0, 2*TMath::Pi());
187 Double_t chargeBins[3] = {-1.1, 0., 1.1};
188 Int_t nStep = fCutSteps->GetEntriesFast()+1;
189 Int_t nBins[4] = {fPtBins, fEtaBins, fPhiBins + 2};
190 AliCFContainer *ctmp = NULL;
191 for(Int_t icont = 0; icont < 4; icont++){
192 TString containername = GetName() + TString(cnames[icont]);
193 TString containertitle = TString("Container for filter ") + GetName() + TString(ctitlesAppends[icont]);
194 ctmp = new AliCFContainer(containername.Data(), containertitle.Data(), nStep, 4, nBins);
195 SetBit(kOwnCFContainers, kTRUE);
198 ctmp->SetBinLimits(0, fPtBinning);
199 ctmp->SetBinLimits(1, fEtaBinning);
200 ctmp->SetBinLimits(2, fPhiBinning);
201 ctmp->SetBinLimits(3, chargeBins);
203 // Label variable names
204 ctmp->SetVarTitle(0, "pt");
205 ctmp->SetVarTitle(1, "eta");
206 ctmp->SetVarTitle(2, "phi");
207 ctmp->SetVarTitle(3, "charge");
210 ctmp->SetStepTitle(0, "No Cuts");
211 AliHFEcutStep *cutStep = NULL;
212 for(Int_t istep = 0; istep < fCutSteps->GetEntriesFast(); istep++){
213 cutStep = dynamic_cast<AliHFEcutStep *>(fCutSteps->UncheckedAt(istep));
214 if(cutStep) ctmp->SetStepTitle(istep + 1, cutStep->GetName());
216 fEfficiencyContainers->AddAt(ctmp, 0);
221 //__________________________________________________________________
222 void AliHFEtrackFilter::InitCF(AliHFEcontainer *cont){
224 // Initialize Correction Framework container
225 // Use the given HFE container
226 // HFE standard way to use the correction Framework
229 const Char_t *cnames[4] = {"_container", "_container_signal", "_container_MC", "_container_signalMC"};
230 const Char_t *ctitlesAppends[4] = {"(All Rec)", "(All Signals)", "(All Rec (MC))", "(All Signals(MC))"};
231 Int_t nStep = fCutSteps->GetEntriesFast()+1;
232 AliCFContainer *ctmp = NULL;
233 for(Int_t icont = 0; icont < 4; icont++){
234 TString contname = GetName() + TString(cnames[icont]);
235 TString contTitle = TString("Container for filter ") + GetName() + TString(ctitlesAppends[icont]);
236 //printf("Adding container %s: %s\n", contname.Data(), contTitle.Data());
237 cont->CreateContainer(contname.Data(), contTitle.Data(), nStep);
238 fEfficiencyContainers->AddAt((ctmp = cont->GetCFContainer(contname.Data())), icont);
241 ctmp->SetStepTitle(0, "No Cuts");
242 AliHFEcutStep *cutStep = NULL;
243 for(Int_t istep = 0; istep < fCutSteps->GetEntriesFast(); istep++){
244 cutStep = dynamic_cast<AliHFEcutStep *>(fCutSteps->UncheckedAt(istep));
245 if(cutStep) ctmp->SetStepTitle(istep + 1, cutStep->GetName());
251 //__________________________________________________________________
252 void AliHFEtrackFilter::FilterTracks(const AliVEvent * const event){
254 // Perform track filtering
255 // Check each cut step one by one and select tracks which pass
256 // all cuts. If the correction framework is initialized, a correction#
257 // framework container will be filled for each cut step.
259 AliHFEcutStep *cutStep = NULL;
260 AliVTrack *track = NULL;
261 AliVParticle *mctrack = NULL;
262 Double_t cont[4] = {0., 0., 0., 0.}, contMC[4] = {0., 0., 0., 0.};
263 Bool_t goodTrack = kTRUE, signal = kFALSE;
264 Int_t nStep = fCutSteps->GetEntriesFast();
265 AliCFContainer *call = dynamic_cast<AliCFContainer *>(fEfficiencyContainers->At(0));
266 AliCFContainer *cSignal = dynamic_cast<AliCFContainer *>(fEfficiencyContainers->At(1));
267 AliCFContainer *callMC = dynamic_cast<AliCFContainer *>(fEfficiencyContainers->At(2));
268 AliCFContainer *cSignalMC = dynamic_cast<AliCFContainer *>(fEfficiencyContainers->At(3));
269 for(Int_t itrack = 0; itrack < event->GetNumberOfTracks(); itrack++){
271 track = static_cast<AliVTrack *>(event->GetTrack(itrack));
272 // check Monte-Carlo Information if available
274 mctrack = fMC->GetTrack(TMath::Abs(track->GetLabel()));
276 //AliMCParticle *mother = dynamic_cast<AliMCParticle *>(fMC->GetTrack(mctrack->Particle()->GetFirstMother()));
277 //AliInfo(Form("Label %d, Mother %d", track->GetLabel(), mother->Particle()->GetPdgCode()));
278 contMC[0] = mctrack->Pt();
279 contMC[1] = mctrack->Eta();
280 contMC[2] = mctrack->Phi();
281 contMC[3] = mctrack->Charge();
282 if(fMCsignal->IsSelected(mctrack)) signal = kTRUE;
283 //if(TMath::Abs(mother->Particle()->GetPdgCode()) != 443) signal = kFALSE;
284 //AliInfo(Form("Signal? %s", signal ? "Yes": "No"));
288 // Fill Array without cut
289 cont[0] = track->Pt();
290 cont[1] = track->Eta();
291 cont[2] = track->Phi();
292 cont[3] = track->Charge();
293 if(call) call->Fill(cont, 0);
294 if(callMC) callMC->Fill(contMC, 0);
296 if(cSignal) cSignal->Fill(cont, 0);
297 if(cSignalMC) cSignalMC->Fill(contMC, 0);
301 for(Int_t icut = 0; icut < nStep; icut++){
302 cutStep = dynamic_cast<AliHFEcutStep *>(fCutSteps->UncheckedAt(icut));
303 if(cutStep && (!cutStep->IsSelected(track))){
309 // Track survived cut step: Fill container
310 if(call) call->Fill(cont, icut + 1);
311 if(callMC) callMC->Fill(contMC, icut + 1);
313 if(cSignal) cSignal->Fill(cont, icut + 1);
314 if(cSignalMC) cSignalMC->Fill(contMC, icut + 1);
318 // Append track to the list of filtered tracks
319 if(goodTrack) fFilteredTracks->Add(track);
323 //__________________________________________________________________
324 void AliHFEtrackFilter::GenerateCutSteps(){
326 // Make the default cuts
328 MakeCutStepRecKineITSTPC();
329 MakeCutStepPrimary();
336 //__________________________________________________________________
337 void AliHFEtrackFilter::AddCutStep(AliHFEcutStep *step){
339 // Add new cut step to the filter
341 if(!fCutSteps->FindObject(step->GetName())) fCutSteps->Add(step);
344 //__________________________________________________________________
345 AliHFEcutStep *AliHFEtrackFilter::GetCutStep(Int_t istep){
347 // Getter for single cut step
349 return dynamic_cast<AliHFEcutStep *>(fCutSteps->At(istep));
352 //__________________________________________________________________
353 AliHFEcutStep *AliHFEtrackFilter::GetCutStep(const Char_t *name){
355 // Getter for single cut step (by step name)
357 return dynamic_cast<AliHFEcutStep *>(fCutSteps->FindObject(name));
360 //__________________________________________________________________
361 void AliHFEtrackFilter::Flush(){
363 // Empty track container
365 fFilteredTracks->Clear();
368 //__________________________________________________________________
369 void AliHFEtrackFilter::SetPtBins(Int_t nBins, Double_t *binning){
371 // User defined pt binning
374 fPtBinning = new Double_t[fPtBins + 1];
375 memcpy(fPtBinning, binning, sizeof(Double_t) * nBins);
378 //__________________________________________________________________
379 void AliHFEtrackFilter::SetEtaBins(Int_t nBins, Double_t *binning){
381 // User defined eta binning
384 fEtaBinning = new Double_t[fEtaBins + 1];
385 memcpy(fEtaBinning, binning, sizeof(Double_t) * nBins);
388 //__________________________________________________________________
389 void AliHFEtrackFilter::SetPhiBins(Int_t nBins, Double_t *binning){
391 // User defined phi binning
394 fPhiBinning = new Double_t[fPhiBins + 1];
395 memcpy(fPhiBinning, binning, sizeof(Double_t) * nBins);
398 //__________________________________________________________________
399 AliHFEcutStep *AliHFEtrackFilter::MakeCutStepRecKineITSTPC(){
401 // Make the cut step for Rec Kine
402 // Cut step is already included in the filter
404 AliHFEcutStep *fCutStep = new AliHFEcutStep("RecKineITSTPC");
406 AliCFTrackQualityCuts *trackQuality = new AliCFTrackQualityCuts((Char_t *)"QualityRec", (Char_t *)"REC Track Quality Cuts");
407 trackQuality->SetMinNClusterTPC(80);
408 trackQuality->SetMaxChi2PerClusterTPC(3.5);
409 trackQuality->SetStatus(AliVTrack::kTPCrefit | AliVTrack::kITSrefit);
410 trackQuality->SetMaxCovDiagonalElements(2., 2., 0.5, 0.5, 2);
411 fCutStep->AddCut(trackQuality);
413 AliHFEextraCuts *hfecuts = new AliHFEextraCuts("HFETPC","Extra cuts from the HFE group");
414 hfecuts->SetClusterRatioTPC(0.6, AliHFEextraCuts::kFoundOverCR);
415 fCutStep->AddCut(hfecuts);
417 AliCFTrackKineCuts *kineCuts = new AliCFTrackKineCuts((Char_t *)"RecKine", (Char_t *)"REC Kine Cuts");
418 kineCuts->SetPtRange(0.1, 20);
419 kineCuts->SetEtaRange(-0.8, 0.8);
420 fCutStep->AddCut(kineCuts);
422 AddCutStep(fCutStep);
426 //__________________________________________________________________
427 AliHFEcutStep *AliHFEtrackFilter::MakeCutStepPrimary(){
429 // Make cut on primaries
430 // Cut step is already included in the filter
432 AliHFEcutStep *fCutStep = new AliHFEcutStep("Primary");
434 AliCFTrackIsPrimaryCuts *primaryCut = new AliCFTrackIsPrimaryCuts((Char_t *)"PrimaryCuts", (Char_t *)"REC Primary Cuts");
435 primaryCut->SetMaxDCAToVertexXY(0.5);
436 primaryCut->SetMaxDCAToVertexZ(5.);
437 primaryCut->SetAcceptKinkDaughters(kFALSE);
438 fCutStep->AddCut(primaryCut);
440 AddCutStep(fCutStep);
444 //__________________________________________________________________
445 AliHFEcutStep *AliHFEtrackFilter::MakeCutStepHFEITS(){
447 // Add special ITS cuts
448 // Cut step is already included in the filter
450 AliHFEcutStep *fCutStep = new AliHFEcutStep("HFEITS");
452 AliHFEextraCuts *hfecuts = new AliHFEextraCuts((Char_t *)"HFEPixelsCuts",(Char_t *)"Extra cuts from the HFE group");
453 hfecuts->SetRequireITSpixel(AliHFEextraCuts::kFirst);
454 //hfecuts->SetCheckITSstatus(kTRUE);
455 fCutStep->AddCut(hfecuts);
457 AddCutStep(fCutStep);
461 //__________________________________________________________________
462 AliHFEcutStep *AliHFEtrackFilter::MakeCutStepHFETRD(){
464 // Add special TRD cut
465 // Cut step is already included in the filter
467 AliHFEcutStep *fCutStep = new AliHFEcutStep("HFETRD");
469 AliHFEextraCuts *hfecuts = new AliHFEextraCuts("HFETRDCuts","Extra cuts from the HFE group");
470 hfecuts->SetMinTrackletsTRD(0);
471 fCutStep->AddCut(hfecuts);
473 AddCutStep(fCutStep);
477 //__________________________________________________________________
478 AliHFEcutStep *AliHFEtrackFilter::MakeMCSignalCuts(){
481 // Cut step is already included in the filter
483 fMCsignal = new AliHFEcutStep("MCSignal");
484 AliCFParticleGenCuts *genCuts = new AliCFParticleGenCuts((Char_t *)"fCutsGenMC", (Char_t *)"Particle Generation Cuts");
485 genCuts->SetRequireIsCharged();
486 genCuts->SetRequireIsPrimary();
487 genCuts->SetProdVtxRange2D();
488 genCuts->SetProdVtxRangeX(0, 1);
489 genCuts->SetProdVtxRangeY(0, 1);
490 genCuts->SetRequirePdgCode(11, kTRUE);
491 fMCsignal->AddCut(genCuts);
493 AliCFTrackKineCuts *kineMCcuts = new AliCFTrackKineCuts((Char_t *)"fCutsKineMC",(Char_t *)"MC Kine Cuts");
494 kineMCcuts->SetPtRange(0.1, 20.);
495 kineMCcuts->SetEtaRange(-0.8, 0.8);
496 fMCsignal->AddCut(kineMCcuts);
501 //__________________________________________________________________
502 void AliHFEtrackFilter::SetMC(AliMCEvent * const mc){
504 // Publish MC event to the single cut steps
507 fMCsignal->SetMC(fMC);
508 AliHFEcutStep *cs = NULL;
509 for(Int_t icut = 0; icut < fCutSteps->GetEntriesFast(); icut++)
510 if((cs = dynamic_cast<AliHFEcutStep *>(fCutSteps->UncheckedAt(icut)))) cs->SetMC(fMC);
513 //__________________________________________________________________
514 void AliHFEtrackFilter::SetRecEvent(const AliVEvent *rec){
516 // Publish MC event to the single cut steps
518 AliHFEcutStep *cs = NULL;
519 for(Int_t icut = 0; icut < fCutSteps->GetEntriesFast(); icut++)
520 if((cs = dynamic_cast<AliHFEcutStep *>(fCutSteps->UncheckedAt(icut)))) cs->SetRecEvent(rec);
524 //__________________________________________________________________
525 AliCFContainer *AliHFEtrackFilter::GetEfficiencyContainer(Int_t icont){
527 // return EfficiencyContainer
529 if(icont >= 4 || icont < 0) return NULL;
530 return dynamic_cast<AliCFContainer *>(fEfficiencyContainers->At(icont));