Coverity
[u/mrichter/AliRoot.git] / EVE / EveDet / AliEveTRDTrackList.cxx
CommitLineData
c1869a7c 1// Author: Benjamin Hess 29/01/2010
2670605d 2
3/*************************************************************************
c1869a7c 4 * Copyright (C) 2009-2010, Alexandru Bercuci, Benjamin Hess. *
2670605d 5 * All rights reserved. *
6 *************************************************************************/
7
c1869a7c 8
16db6074 9//////////////////////////////////////////////////////////////////////////
10// //
2670605d 11// AliEveTRDTrackList //
12// //
16db6074 13// An AliEveTRDTrackList is, in principal, a TEveElementList with some //
14// sophisticated features. You can add macros to this list, which then //
15// can be applied to the list of tracks (these tracks can be added to //
16// the list in the same way as for the TEveElementList). In general, //
17// please use AddMacro(...) for this purpose. //
18// Macros that are no longer needed can be removed from the list via //
38a30030 19// RemoveSelectedMacros(...).This function takes an iterator of the //
20// list of macros that are to be removed. //
16db6074 21// be removed. An entry looks like: //
38a30030 22// The data for each macro consists of path, name, type and the command //
23// that will be used to apply the macro. This stuff is stored in a map //
24// which takes the macro name for the key and the above mentioned data //
25// in a TMacroData-object for the value. //
26// You can get the macro type via GetMacroType(...). //
2670605d 27// With ApplySTSelectionMacros(...) or ApplyProcessMacros(...) //
16db6074 28// respectively you can apply the macros to the track list via //
38a30030 29// iterators (same style like for RemoveSelectedMacros(...)(cf. above)).//
16db6074 30// Selection macros (de-)select macros according to a selection rule //
31// by setting the rnr-state of the tracks. //
32// If multiple selection macros are applied, a track is selected, if //
33// all selection macros select the track. //
34// Process macros create data or histograms, which will be stored in //
35// a temporary file. The editor of this class will access this file //
36// and draw all the stuff within it's DrawHistos() function. The file //
37// will be deleted by the destructor. //
38// //
39// Currently, the following macro types are supported: //
40// Selection macros: //
41// Bool_t YourMacro(const AliTRDtrackV1*); //
42// Bool_t YourMacro(const AliTRDtrackV1*, const AliTRDtrackV1*); //
43// //
44// Process macros: //
45// void YourMacro(const AliTRDtrackV1*, Double_t*&, Int_t&); //
46// void YourMacro(const AliTRDtrackV1*, const AliTRDtrackV1*, //
47// Double_t*&, Int_t&); //
48// TH1* YourMacro(const AliTRDtrackV1*); //
49// TH1* YourMacro(const AliTRDtrackV1*, const AliTRDtrackV1*); //
50// //
38a30030 51// The macros which take 2 tracks are applied to all track pairs //
52// (whereby BOTH tracks of the pair have to be selected by the single //
53// track selection macros and have to be unequal, otherwise they will //
54// be skipped) that have been selected by ALL correlated tracks //
55// selection macros. The selection macros with 2 tracks do NOT affect //
56// process macros that process only a single track! //
16db6074 57//////////////////////////////////////////////////////////////////////////
58
59
caaf90d2 60// Uncomment to display debugging infos
61//#define ALIEVETRDTRACKLIST_DEBUG
62
caaf90d2 63#include <TFile.h>
64#include <TFunction.h>
c413e8d4 65#include <TH1.h>
caaf90d2 66#include <TList.h>
8bdeb570 67#include <TMap.h>
caaf90d2 68#include <TObjString.h>
69#include <TROOT.h>
70#include <TSystem.h>
71#include <TTree.h>
72#include <TTreeStream.h>
db16b708 73#include <TMethodCall.h>
74
75#include <AliTRDReconstructor.h>
76
77#include <EveDet/AliEveTRDTrackList.h>
db16b708 78#include <EveDet/AliEveTRDTrackListEditor.h>
79
5964947f 80#include <../PWG1/TRD/AliTRDrecoTask.h>
99535225 81#include <../PWG1/TRD/AliTRDpwg1Helper.h>
ecbbe371 82
2ef0687e 83ClassImp(AliEveTRDTrackList)
84
85///////////////////////////////////////////////////////////
86///////////// AliEveTRDTrackList ////////////////////////
87///////////////////////////////////////////////////////////
8bdeb570 88AliEveTRDTrackList::AliEveTRDTrackList(const Text_t* n, const Text_t* t, Bool_t doColor):
89 TEveElementList(n, t, doColor),
1e536dd4 90 fEditor(0x0),
91 fDataFromMacroList(0x0),
92 fMacroList(0x0),
93 fDataTree(0x0),
8bdeb570 94 fHistoDataSelected(0),
95 fMacroListSelected(0),
8bdeb570 96 fSelectedTab(1), // Standard tab: "Apply macros" (index 1)
1e536dd4 97 fSelectedStyle(0)
2ef0687e 98{
16db6074 99 // Creates the AliEveTRDTrackList.
100
caaf90d2 101 // Only accept childs of type AliEveTRDTrack
2ef0687e 102 SetChildClass(AliEveTRDTrack::Class());
103
e007877e 104 // Allocate memory for the lists and declare them as owners of their contents
caaf90d2 105 fDataFromMacroList = new TList();
e007877e 106 fDataFromMacroList->TCollection::SetOwner(kTRUE);
caaf90d2 107
38a30030 108 fMacroList = new TMap();
e007877e 109 // Set map to owner of it's objects to delete them, if they are removed from the map
38a30030 110 fMacroList->SetOwnerKeyValue(kTRUE, kTRUE);
8bdeb570 111
ecbbe371 112 // Set the build directory for AClic
1e536dd4 113 if(gSystem->AccessPathName(Form("%s/.trdQArec" , gSystem->Getenv("HOME")))) gSystem->Exec("mkdir $HOME/.trdQArec");
114 gSystem->SetBuildDir(Form("%s/.trdQArec", gSystem->Getenv("HOME")));
caaf90d2 115
db16b708 116 AddStandardContent();
caaf90d2 117}
118
8e27fca1 119//______________________________________________________
caaf90d2 120AliEveTRDTrackList::~AliEveTRDTrackList()
121{
16db6074 122 // Frees allocated memory (lists etc.).
123
38a30030 124 // Let the editor know that the list will be destroyed -> The editor will save the data
125 if (fEditor != 0)
caaf90d2 126 {
38a30030 127 fEditor->SaveMacroList(fMacroList);
128 fEditor = 0;
caaf90d2 129 }
38a30030 130
caaf90d2 131 if (fDataFromMacroList != 0)
132 {
c413e8d4 133 fDataFromMacroList->Delete();
caaf90d2 134 delete fDataFromMacroList;
135 fDataFromMacroList = 0;
136 }
137 if (fDataTree != 0)
138 {
139 delete fDataTree;
140 fDataTree = 0;
141 }
38a30030 142 if (fMacroList != 0)
8bdeb570 143 {
38a30030 144 fMacroList->DeleteAll();
145 delete fMacroList;
146 fMacroList = 0;
8bdeb570 147 }
ecbbe371 148 // Note: gSystem->AccessPathName(...) returns kTRUE, if the access FAILED!
149 if(!gSystem->AccessPathName(Form("/tmp/TRD.TrackListMacroData_%s.root", gSystem->Getenv("USER"))))
150 gSystem->Exec(Form("rm /tmp/TRD.TrackListMacroData_%s.root", gSystem->Getenv("USER")));
caaf90d2 151}
152
8e27fca1 153//______________________________________________________
c413e8d4 154Int_t AliEveTRDTrackList::AddMacro(const Char_t* path, const Char_t* nameC, Bool_t forceReload)
caaf90d2 155{
16db6074 156 // Checks, if the file exists and if the signature is correct.
157 // If these criteria are fullfilled, the library for this macro is built
158 // and the macro is added to the corresponding list.
159 // Supported macro types:
160 // Selection macros:
161 // Bool_t YourMacro(const AliTRDtrackV1*)
162 // Bool_t YourMacro(const AliTRDtrackV1*, const AliTRDtrackV1*)
163 //
164 // Process macros:
165 // void YourMacro(const AliTRDtrackV1*, Double_t*&, Int_t&)
166 // void YourMacro(const AliTRDtrackV1*, const AliTRDtrackV1*,
167 // Double_t*&, Int_t&)
168 // TH1* YourMacro(const AliTRDtrackV1*)
38a30030 169 // TH1* YourMacro(const AliTRDtrackV1*, const AliTRDtrackV1*)
caaf90d2 170
4f6473f6 171 Char_t pathname[fkMaxMacroPathNameLength];
172 memset(pathname, '\0', sizeof(Char_t) * fkMaxMacroPathNameLength);
caaf90d2 173
174 // Expand the path and create the pathname
175 Char_t* systemPath = gSystem->ExpandPathName(path);
90ae0503 176 snprintf(pathname, fkMaxMacroPathNameLength, "%s/%s", systemPath, nameC);
caaf90d2 177 delete systemPath;
178 systemPath = 0;
179
180 // Delete ".C" from filename
4f6473f6 181 Char_t name[fkMaxMacroNameLength];
182 memset(name, '\0', sizeof(Char_t) * fkMaxMacroNameLength);
183
184 for (UInt_t ind = 0; ind < fkMaxMacroNameLength && ind < strlen(nameC) - 2; ind++) name[ind] = nameC[ind];
caaf90d2 185
186 // Check, if files exists
db16b708 187 FILE* fp = 0x0;
188 if((fp = fopen(pathname, "rb"))){
caaf90d2 189 fclose(fp);
db16b708 190 fp = 0x0;
191 } else return NOT_EXIST_ERROR;
38a30030 192
caaf90d2 193 // Clean up root, load the desired macro and then check the type of the macro
db16b708 194 // A.B. gROOT->Reset();
c413e8d4 195
db16b708 196 gROOT->ProcessLineSync(Form(".L %s+%c", pathname, forceReload ? '+' : ' '));
caaf90d2 197
00dc25ef 198 // We need this line... otherwise, in some cases, there will be problems concerning ACLIC
199 gROOT->ProcessLineSync(Form(".L %s", pathname));
200
38a30030 201 AliEveTRDTrackListMacroType type = GetMacroType(name, kFALSE);
caaf90d2 202
4f6473f6 203 // Clean up again
db16b708 204 // A.B. gROOT->Reset();
4f6473f6 205
caaf90d2 206 // Has not the correct signature!
38a30030 207 if (type == kUnknown) return SIGNATURE_ERROR;
caaf90d2 208
caaf90d2 209 // Only add macro, if it is not already in the list
db16b708 210 Int_t returnValue = WARNING;
211 if(fMacroList->GetValue(name) == 0) {
212 returnValue = AddMacroFast(path, name, type) ? SUCCESS : ERROR;
caaf90d2 213 }
caaf90d2 214 return returnValue;
215}
c413e8d4 216
217//______________________________________________________
38a30030 218Bool_t AliEveTRDTrackList::AddMacroFast(const Char_t* path, const Char_t* name, AliEveTRDTrackListMacroType type)
c413e8d4 219{
38a30030 220 // Adds a macro (path/name) to the corresponding list. No checks are performed (file exist,
221 // macro already in list/map, signature correct), no libraries are created!
222 // You can use this function only, if the macro has been added successfully before
223 // (and then maybe was removed). The function is very fast. On success kTRUE is returned, otherwise: kFALSE;
224
225 Bool_t success = kFALSE;
16db6074 226
8bdeb570 227 switch (type)
c413e8d4 228 {
e007877e 229 case kSingleTrackSelect:
230 case kCorrelTrackSelect:
e007877e 231 case kSingleTrackAnalyse:
232 case kSingleTrackHisto:
233 case kCorrelTrackAnalyse:
234 case kCorrelTrackHisto:
38a30030 235 fMacroList->Add(new TObjString(name), new TMacroData(name, path, type));
8bdeb570 236
237 // We do not know, where the element has been inserted - deselect this list
238 fMacroListSelected = 0;
38a30030 239
240 success = kTRUE;
241
242#ifdef ALIEVETRDTRACKLIST_DEBUG
243 // Successfull add will only be displayed in debug mode
244 printf("AliEveTRDTrackList::AddMacroFast: Added macro \"%s/%s\" to the corresponding list\n", path, name);
245#endif
246
8bdeb570 247 break;
c413e8d4 248
38a30030 249 default:
250 // Error will always be displayed
251 printf("AliEveTRDTrackList::AddMacroFast: ERROR: Could not add macro \"%s/%s\" to the corresponding list\n",
252 path, name);
16db6074 253
38a30030 254 success = kFALSE;
caaf90d2 255
38a30030 256 break;
c413e8d4 257 }
38a30030 258
259 return success;
caaf90d2 260}
c413e8d4 261
8e27fca1 262//______________________________________________________
db16b708 263void AliEveTRDTrackList::AddStandardContent()
caaf90d2 264{
38a30030 265 // Adds standard macros to the macro list.
16db6074 266
99535225 267 // Add your standard macros here, e.g.:
8bdeb570 268 // To add a macro use:
caaf90d2 269 // AddMacro("$(ALICE_ROOT)/myFolder", "myMacroName.C");
270 // -> If the file does not exist, nothing happens. So if you want to handle this,
271 // use the return value of AddMacro (NOT_EXIST_ERROR is returned, if file does not exist)
5715955a 272 // (-> You can also check for other return values (see AddMacro(...)))
db16b708 273
a6a6a16e 274 const Char_t *libs[] = {"libANALYSIS.so", "libANALYSISalice.so", "libTENDER.so", "libPWG1.so"};
22604c13 275 Int_t nlibs = static_cast<Int_t>(sizeof(libs)/sizeof(Char_t *));
276 for(Int_t ilib=0; ilib<nlibs; ilib++){
277 if(gSystem->Load(libs[ilib]) >= 0) continue;
278 AliError(Form("Fail loading %s.", libs[ilib]));
279 return;
280 }
281
99535225 282 const Char_t *fgkTRDPWG1taskClassName[AliTRDpwg1Helper::kNTRDQATASKS] = {
283 "AliTRDcheckESD"
284 ,"AliTRDinfoGen"
285 ,"AliTRDcheckDET"
286 ,"AliTRDefficiency"
287 ,"AliTRDresolution"
288 ,"AliTRDcheckPID"
289 ,"AliTRDv0Monitor"
290 };
291 AliTRDrecoTask *task(NULL);
292 TList *fPlots(NULL);
293 for(Int_t it=2; it<AliTRDpwg1Helper::kNTRDQATASKS; it++){
294 TClass c(fgkTRDPWG1taskClassName[it]);
db16b708 295 task = (AliTRDrecoTask*)c.New();
50db8cc0 296 task->SetMCdata(kFALSE);
db16b708 297 if(!(fPlots = task->GetPlotFunctors())){
50db8cc0 298 //AliWarning(Form("No Plot functors defined for task \"%s\"", fgkTRDtaskClassName[it]));
db16b708 299 delete task;
300 continue;
301 }
302 if(!(task->Histos())){
50db8cc0 303 //AliWarning(Form("No Ref Histograms defined for task \"%s\"", fgkTRDtaskClassName[it]));
db16b708 304 delete task;
305 continue;
306 }
307
308 // export task to CINT and add functions
99535225 309 gROOT->ProcessLine(Form("%s* %s = (%s*)%p;", fgkTRDPWG1taskClassName[it], task->GetName(), fgkTRDPWG1taskClassName[it], (void*)task));
db16b708 310 TIter iter(fPlots); TMethodCall *m = 0x0;
311 while((m = dynamic_cast<TMethodCall*>(iter()))){
312 AddMacroFast("", Form("%s->%s", task->GetName(), m->GetMethodName()), kSingleTrackHisto);
313 }
314 }
caaf90d2 315}
316
99535225 317
8e27fca1 318//______________________________________________________
2670605d 319Bool_t AliEveTRDTrackList::ApplyProcessMacros(const TList* selIterator, const TList* procIterator)
caaf90d2 320{
2670605d 321 // Uses the procIterator (for the selected process macros) to apply the selected macros to the data.
16db6074 322 // Returns kTRUE on success, otherwise kFALSE. If there no process macros selected, kTRUE is returned
323 // (this is no error!).
2670605d 324 // The single track process macros are applied to all selected tracks.
325 // The selIterator (for the selected selection macros) will be used to apply the correlated tracks selection
326 // macros to all track pairs (whereby BOTH tracks have to be selected, otherwise they will be skipped).
327 // All track pairs that have been selected by ALL correlated tracks selection macros will be processed by
328 // the correlated tracks process macros.
16db6074 329
ea24e1bc 330 // No process macros need to be processed
2670605d 331 if (procIterator->GetEntries() <= 0) return kTRUE;
ea24e1bc 332
333 // Clear root
db16b708 334 // A.B. gROOT->Reset();
ea24e1bc 335
336 // Clear old data and re-allocate
90ae0503 337 if (!fDataTree){
db16b708 338 TDirectory *cwd = gDirectory;
339 fDataTree = new TTreeSRedirector(Form("/tmp/TRD.TrackListMacroData_%s.root", gSystem->Getenv("USER")));
340 cwd->cd();
341 }
342 if (!fDataTree){
343 Error("Apply process macros", Form("File \"/tmp/TRD.TrackListMacroData_%s.root\" could not be accessed properly!", gSystem->Getenv("USER")));
ea24e1bc 344 return kFALSE;
345 }
346
db16b708 347 if (fDataFromMacroList != 0) {
e007877e 348 fDataFromMacroList->Delete();
349 delete fDataFromMacroList;
350 }
ea24e1bc 351 fDataFromMacroList = new TList();
e007877e 352 fDataFromMacroList->TCollection::SetOwner(kTRUE);
ea24e1bc 353
354 fHistoDataSelected = 0;
355
8e27fca1 356
38a30030 357 TMacroData* macro = 0;
358
90ae0503 359 TString* procCmds = new TString[procIterator->GetEntries()];
360 AliEveTRDTrackListMacroType* mProcType = new AliEveTRDTrackListMacroType[procIterator->GetEntries()];
2670605d 361
a0987c46 362 TString* selCmds(NULL);
90ae0503 363 AliEveTRDTrackListMacroType* mSelType(NULL);
db16b708 364 if (selIterator->GetEntries() > 0) {
d52fea52 365 selCmds = new TString[selIterator->GetEntries()];
38a30030 366 mSelType = new AliEveTRDTrackListMacroType[selIterator->GetEntries()];
367 }
368
2670605d 369 Bool_t selectedByCorrSelMacro = kFALSE;
c413e8d4 370
8bdeb570 371 AliEveTRDTrackListMacroType macroType = kUnknown;
c413e8d4 372 Int_t numHistoMacros = 0;
90ae0503 373 TH1** histos(NULL);
caaf90d2 374
a0987c46 375 AliEveTRDTrack* track1(NULL);
376 AliEveTRDTrack* track2(NULL);
caaf90d2 377
2670605d 378 // Collect the commands for each process macro and add them to "data-from-list"
db16b708 379 for (Int_t i = 0; i < procIterator->GetEntries(); i++){
38a30030 380 macro = (TMacroData*)fMacroList->GetValue(procIterator->At(i)->GetTitle());
e007877e 381
db16b708 382 if (!macro){
38a30030 383 Error("Apply process macros",
db16b708 384 Form("Macro list is corrupted: Macro \"%s\" is not registered!",
385 procIterator->At(i)->GetTitle()));
38a30030 386 continue;
e007877e 387 }
38a30030 388
389#ifdef ALIEVETRDTRACKLIST_DEBUG
390 printf("AliEveTRDTrackList: Checking process macro: %s\n", macro->GetName());
391#endif
392
393 // Find the type of the process macro
394 macroType = macro->GetType();
db16b708 395 if (macroType == kSingleTrackHisto || macroType == kCorrelTrackHisto){
2670605d 396 mProcType[i] = macroType;
8bdeb570 397 numHistoMacros++;
398 // Create the command
d52fea52 399 procCmds[i] = macro->GetCmd();
8bdeb570 400
401 // Add to "data-from-list" -> Mark as a histo macro with the substring "(histo macro)"
38a30030 402 fDataFromMacroList->Add(new TObjString(Form("%s (histo macro)", macro->GetName())));
db16b708 403 } else if (macroType == kSingleTrackAnalyse || macroType == kCorrelTrackAnalyse) {
2670605d 404 mProcType[i] = macroType;
c413e8d4 405 // Create the command
d52fea52 406 procCmds[i] = macro->GetCmd();
8bdeb570 407
408 // Add to "data-from-list"
38a30030 409 fDataFromMacroList->Add(new TObjString(macro->GetName()));
db16b708 410 } else {
8bdeb570 411 Error("Apply process macros",
db16b708 412 Form("Macro list corrupted: Macro \"%s/%s.C\" is not registered as a process macro!",
413 macro->GetPath(), macro->GetName()));
2670605d 414 mProcType[i] = kUnknown;
415 }
416 }
417
418 // Collect the commands for each selection macro and add them to "data-from-list"
db16b708 419 for (Int_t i = 0; i < selIterator->GetEntries(); i++){
38a30030 420 macro = (TMacroData*)fMacroList->GetValue(selIterator->At(i)->GetTitle());
421
db16b708 422 if (!macro){
38a30030 423 Error("Apply process macros",
db16b708 424 Form("Macro list is corrupted: Macro \"%s\" is not registered!",
425 selIterator->At(i)->GetTitle()));
38a30030 426 continue;
2670605d 427 }
38a30030 428
429#ifdef ALIEVETRDTRACKLIST_DEBUG
430 printf("AliEveTRDTrackList: Checking selection macro: %s\n", macro->GetName());
431#endif
2670605d 432
433 // Find the type of the process macro
38a30030 434 macroType = macro->GetType();
435
2670605d 436 // Single track select macro
db16b708 437 if (macroType == kSingleTrackSelect) {
2670605d 438 // Has already been processed by ApplySTSelectionMacros(...)
90ae0503 439 if(mSelType) mSelType[i] = macroType;
2670605d 440 }
441 // Correlated tracks select macro
db16b708 442 else if (macroType == kCorrelTrackSelect) {
90ae0503 443 if(mSelType) mSelType[i] = macroType;
2670605d 444
445 // Create the command
90ae0503 446 if(selCmds) selCmds[i] = macro->GetCmd();
db16b708 447 } else {
2670605d 448 Error("Apply process macros",
db16b708 449 Form("Macro list corrupted: Macro \"%s/%s.C\" is not registered as a selection macro!",
450 macro->GetPath(), macro->GetName()));
90ae0503 451 if(mSelType) mSelType[i] = kUnknown;
c413e8d4 452 }
8e27fca1 453 }
c413e8d4 454
455 // Allocate memory for the histograms
4b628e88 456 if (numHistoMacros > 0){
457 histos = new TH1*[numHistoMacros];
458 memset(histos, 0, numHistoMacros*sizeof(TH1*));
459 }
caaf90d2 460
db16b708 461 //////////////////////////////////
462 // WALK THROUGH THE LIST OF TRACKS
463 //////////////////////////////////
464 for (TEveElement::List_i iter = this->BeginChildren(); iter != this->EndChildren(); ++iter){
465 if(!(track1 = dynamic_cast<AliEveTRDTrack*>(*iter))) continue;
466
caaf90d2 467 // Skip tracks that have not been selected
e007877e 468 if (!track1->GetRnrState()) continue;
38a30030 469
caaf90d2 470 // Cast to AliTRDtrackV1
c51e9ba0 471 gROOT->ProcessLineSync(Form("AliEveTRDTrack *automaticTrack = (AliEveTRDTrack*)%p;", (void*)track1));
e007877e 472 gROOT->ProcessLineSync("AliTRDtrackV1* automaticTrackV1_1 = (AliTRDtrackV1*)automaticTrack->GetUserData();");
caaf90d2 473
474 // Collect data for each macro
db16b708 475 for (Int_t i = 0, histoIndex = 0; i < procIterator->GetEntries(); i++){
e007877e 476 // Single track histo
db16b708 477 if (mProcType[i] == kSingleTrackHisto){
90ae0503 478 if(histos) histos[histoIndex++] = (TH1*)gROOT->ProcessLineSync(procCmds[i]);
db16b708 479 // Correlated tracks histo
480 } else if (mProcType[i] == kCorrelTrackHisto) {
e007877e 481 // Loop over all pairs behind the current one - together with the other loop this will be a loop
482 // over all pairs. We have a pair of tracks, if and only if both tracks of the pair are selected (Rnr-state)
483 // and are not equal.
00dc25ef 484 // The correlated tracks process macro will be applied to all pairs that will be additionally selected by
2670605d 485 // all correlated tracks selection macros.
e007877e 486 TEveElement::List_i iter2 = iter;
487 iter2++;
488 for ( ; iter2 != this->EndChildren(); ++iter2)
489 {
db16b708 490 if(!(track2 = dynamic_cast<AliEveTRDTrack*>(*iter2))) continue;
e007877e 491
e007877e 492 // Skip tracks that have not been selected
493 if (!track2->GetRnrState()) continue;
494
e007877e 495 // Cast to AliTRDtrackV1
c51e9ba0 496 gROOT->ProcessLineSync(Form("AliEveTRDTrack *automaticTrack = (AliEveTRDTrack*)%p;", (void*)track2));
e007877e 497 gROOT->ProcessLineSync("AliTRDtrackV1* automaticTrackV1_2 = (AliTRDtrackV1*)automaticTrack->GetUserData();");
498
2670605d 499 // Select track by default (so it will be processed, if there are no correlated tracks selection macros!)
500 selectedByCorrSelMacro = kTRUE;
db16b708 501 for (Int_t j = 0; j < selIterator->GetEntries(); j++){
90ae0503 502 if (mSelType && mSelType[j] == kCorrelTrackSelect){
2670605d 503 selectedByCorrSelMacro = (Bool_t)gROOT->ProcessLineSync(selCmds[j]);
504 if (!selectedByCorrSelMacro) break;
505 }
506 }
507
508 // If the pair has not been selected by the correlated tracks selection macros, skip it!
509 if (!selectedByCorrSelMacro) continue;
510
90ae0503 511 if(histos) histos[histoIndex] = (TH1*)gROOT->ProcessLineSync(procCmds[i]);
e007877e 512 }
513 histoIndex++;
514 }
515 // Single track analyse
db16b708 516 else if (mProcType[i] == kSingleTrackAnalyse) {
c413e8d4 517 // Create data pointers in CINT, execute the macro and get the data
518 gROOT->ProcessLineSync("Double_t* results = 0;");
519 gROOT->ProcessLineSync("Int_t n = 0;");
2670605d 520 gROOT->ProcessLineSync(procCmds[i]);
c413e8d4 521 Double_t* results = (Double_t*)gROOT->ProcessLineSync("results;");
522 Int_t nResults = (Int_t)gROOT->ProcessLineSync("n;");
523
db16b708 524 if (results == 0) {
2670605d 525 Error("Apply macros", Form("Error reading data from macro \"%s\"", procIterator->At(i)->GetTitle()));
c413e8d4 526 continue;
527 }
db16b708 528 for (Int_t resInd = 0; resInd < nResults; resInd++){
c413e8d4 529 (*fDataTree) << Form("TrackData%d", i) << Form("Macro%d=", i) << results[resInd] << (Char_t*)"\n";
530 }
caaf90d2 531
c413e8d4 532 delete results;
533 results = 0;
534 }
e007877e 535 // Correlated tracks analyse
db16b708 536 else if (mProcType[i] == kCorrelTrackAnalyse){
e007877e 537 // Loop over all pairs behind the current one - together with the other loop this will be a loop
538 // over all pairs. We have a pair of tracks, if and only if both tracks of the pair are selected (Rnr-state)
539 // and are not equal.
00dc25ef 540 // The correlated tracks process macro will be applied to all pairs that will be additionally selected by
2670605d 541 // all correlated tracks selection macros.
e007877e 542 TEveElement::List_i iter2 = iter;
543 iter2++;
38a30030 544
db16b708 545 for ( ; iter2 != this->EndChildren(); ++iter2) {
546 if(!(track2 = dynamic_cast<AliEveTRDTrack*>(*iter2))) continue;
38a30030 547
e007877e 548 // Skip tracks that have not been selected
549 if (!track2->GetRnrState()) continue;
38a30030 550
e007877e 551 // Cast to AliTRDtrackV1
c51e9ba0 552 gROOT->ProcessLineSync(Form("AliEveTRDTrack *automaticTrack = (AliEveTRDTrack*)%p;", (void*)track2));
e007877e 553 gROOT->ProcessLineSync("AliTRDtrackV1* automaticTrackV1_2 = (AliTRDtrackV1*)automaticTrack->GetUserData();");
554
2670605d 555 // Select track by default (so it will be processed, if there are no correlated tracks selection macros!)
556 selectedByCorrSelMacro = kTRUE;
db16b708 557 for (Int_t j = 0; j < selIterator->GetEntries(); j++) {
90ae0503 558 if (mSelType && mSelType[j] == kCorrelTrackSelect) {
2670605d 559 selectedByCorrSelMacro = (Bool_t)gROOT->ProcessLineSync(selCmds[j]);
560 if (!selectedByCorrSelMacro) break;
561 }
562 }
563
564 // If the pair has not been selected by the correlated tracks selection macros, skip it!
565 if (!selectedByCorrSelMacro) continue;
566
e007877e 567 // Create data pointers in CINT, execute the macro and get the data
568 gROOT->ProcessLineSync("Double_t* results = 0;");
569 gROOT->ProcessLineSync("Int_t n = 0;");
2670605d 570 gROOT->ProcessLineSync(procCmds[i]);
e007877e 571 Double_t* results = (Double_t*)gROOT->ProcessLineSync("results;");
572 Int_t nResults = (Int_t)gROOT->ProcessLineSync("n;");
38a30030 573
db16b708 574 if (results == 0) {
2670605d 575 Error("Apply macros", Form("Error reading data from macro \"%s\"", procIterator->At(i)->GetTitle()));
e007877e 576 continue;
577 }
db16b708 578 for (Int_t resInd = 0; resInd < nResults; resInd++) {
e007877e 579 (*fDataTree) << Form("TrackData%d", i) << Form("Macro%d=", i) << results[resInd] << (Char_t*)"\n";
580 }
581
582 delete results;
583 results = 0;
584 }
585 }
caaf90d2 586 }
587 }
caaf90d2 588
db16b708 589 for (Int_t i = 0, histoIndex = 0; i < procIterator->GetEntries() && histoIndex < numHistoMacros; i++) {
590 if (mProcType[i] == kSingleTrackHisto || mProcType[i] == kCorrelTrackHisto) {
5715955a 591 // Might be empty (e.g. no tracks have been selected)!
db16b708 592 if (histos[histoIndex]) {
5715955a 593 (*fDataTree) << Form("TrackData%d", i) << Form("Macro%d=", i) << histos[histoIndex] << (Char_t*)"\n";
594 }
595 histoIndex++;
596 }
c413e8d4 597 }
598
90ae0503 599 if (fDataTree) delete fDataTree;
600 fDataTree = NULL;
caaf90d2 601
90ae0503 602 if (procCmds) delete [] procCmds;
603 procCmds = NULL;
604 if (mProcType) delete [] mProcType;
605 mProcType = NULL;
2670605d 606
90ae0503 607 if (selCmds) delete [] selCmds;
608 selCmds = NULL;
609 if (mSelType) delete [] mSelType;
610 mSelType = NULL;
c413e8d4 611
90ae0503 612 if (histos) delete [] histos;
613 histos = NULL;
8e27fca1 614
caaf90d2 615 // Clear root
db16b708 616 // A.B. gROOT->Reset();
caaf90d2 617
4f6473f6 618 // If there is data, select the first data set
2670605d 619 if (procIterator->GetEntries() > 0) SETBIT(fHistoDataSelected, 0);
4f6473f6 620
e007877e 621 // Now the data is stored in "/tmp/TRD.TrackListMacroData_$USER.root"
caaf90d2 622 // The editor will access this file to display the data
ea24e1bc 623 return kTRUE;
caaf90d2 624}
625
8e27fca1 626//______________________________________________________
2670605d 627void AliEveTRDTrackList::ApplySTSelectionMacros(const TList* iterator)
caaf90d2 628{
16db6074 629 // Uses the iterator (for the selected selection macros) to apply the selected macros to the data.
630 // The rnr-states of the tracks are set according to the result of the macro calls (kTRUE, if all
631 // macros return kTRUE for this track, otherwise: kFALSE).
2670605d 632 // "ST" stands for "single track". This means that only single track selection macros are applied.
633 // Correlated tracks selection macros will be used inside the call of ApplyProcessMacros(...)!
16db6074 634
38a30030 635 TMacroData* macro = 0;
e007877e 636 AliEveTRDTrackListMacroType macroType = kUnknown;
637 AliEveTRDTrack* track1 = 0;
caaf90d2 638 Bool_t selectedByMacro = kFALSE;
639
640 // Clear root
db16b708 641 // A.B. gROOT->Reset();
caaf90d2 642
00dc25ef 643 // Select all tracks at first. A track is then deselected, if at least one selection macro
644 // returns kFALSE for this track.
645 // Enable all tracks (Note: EnableListElements(..) will call "ElementChanged", which will cause unforeseen behaviour!)
db16b708 646 for (TEveElement::List_i iter = this->BeginChildren(); iter != this->EndChildren(); ++iter) ((TEveElement*)(*iter))->SetRnrState(kTRUE);
4f6473f6 647 SetRnrState(kTRUE);
648
db16b708 649 for (Int_t i = 0; i < iterator->GetEntries(); i++){
38a30030 650 macro = (TMacroData*)fMacroList->GetValue(iterator->At(i)->GetTitle());
4f6473f6 651
db16b708 652 if (!macro){
38a30030 653 Error("Apply selection macros",
654 Form("Macro list is corrupted: Macro \"%s\" is not registered!", iterator->At(i)->GetTitle()));
655 continue;
656 }
caaf90d2 657
658#ifdef ALIEVETRDTRACKLIST_DEBUG
38a30030 659 printf("AliEveTRDTrackList: Applying selection macro: %s\n", macro->GetName());
caaf90d2 660#endif
caaf90d2 661
e007877e 662 // Determine macro type
38a30030 663 macroType = macro->GetType();
caaf90d2 664
e007877e 665 // Single track select macro
db16b708 666 if (macroType == kSingleTrackSelect){
e007877e 667 // Walk through the list of tracks
668 for (TEveElement::List_i iter = this->BeginChildren(); iter != this->EndChildren(); ++iter)
669 {
670 track1 = dynamic_cast<AliEveTRDTrack*>(*iter);
671
672 if (!track1) continue;
673
674 // If the track has already been deselected, nothing is to do here
675 if (!track1->GetRnrState()) continue;
676
e007877e 677 // Cast to AliTRDtrackV1
c51e9ba0 678 gROOT->ProcessLineSync(Form("AliEveTRDTrack *automaticTrack = (AliEveTRDTrack*)%p;", (void*)track1));
38a30030 679 gROOT->ProcessLineSync("AliTRDtrackV1* automaticTrackV1_1 = (AliTRDtrackV1*)automaticTrack->GetUserData();");
680 selectedByMacro = (Bool_t)gROOT->ProcessLineSync(macro->GetCmd());
e007877e 681 track1->SetRnrState(selectedByMacro && track1->GetRnrState());
682 }
683 }
684 // Correlated tracks select macro
db16b708 685 else if (macroType == kCorrelTrackSelect){
2670605d 686 // Will be processed in ApplyProcessMacros(...)
687 continue;
db16b708 688 } else {
e007877e 689 Error("Apply selection macros",
db16b708 690 Form("Macro list corrupted: Macro \"%s/%s.C\" is not registered as a selection macro!",
691 macro->GetPath(), macro->GetName()));
e007877e 692 }
caaf90d2 693 }
694
695 // Clear root
db16b708 696 // A.B. gROOT->Reset();
caaf90d2 697}
698
8e27fca1 699//______________________________________________________
38a30030 700AliEveTRDTrackList::AliEveTRDTrackListMacroType AliEveTRDTrackList::GetMacroType(const Char_t* name, Bool_t UseList) const
8bdeb570 701{
38a30030 702 // Returns the type of the corresponding macro.
16db6074 703 // If "UseList" is kTRUE, the type will be looked up in the internal list (very fast). But if this list
704 // does not exist, you have to use kFALSE for this parameter. Then the type will be determined by the
705 // prototype! NOTE: It is assumed that the macro has been compiled! If not, the return value is not
706 // predictable, but normally will be kUnknown.
38a30030 707 // Note: AddMacro(Fast) will update the internal list and RemoveMacros respectively.
16db6074 708
8bdeb570 709 AliEveTRDTrackListMacroType type = kUnknown;
710
38a30030 711 // Re-do the check of the macro type
db16b708 712 if (!UseList){
e007877e 713 // Single track select macro or single track histo macro?
8bdeb570 714 TFunction* f = gROOT->GetGlobalFunctionWithPrototype(name, "const AliTRDtrackV1*", kTRUE);
715 if (f != 0x0)
716 {
717 // Some additional check (is the parameter EXACTLY of the desired type?)
718 if (strstr(f->GetMangledName(), "oPconstsPAliTRDtrackV1mUsP") != 0x0)
719 {
e007877e 720 // Single track select macro?
8bdeb570 721 if (!strcmp(f->GetReturnTypeName(), "Bool_t"))
722 {
e007877e 723 type = kSingleTrackSelect;
8bdeb570 724 }
e007877e 725 // single track histo macro?
8bdeb570 726 else if (!strcmp(f->GetReturnTypeName(), "TH1*"))
727 {
e007877e 728 type = kSingleTrackHisto;
8bdeb570 729 }
730 }
731 }
e007877e 732 // Single track analyse macro?
8bdeb570 733 else if ((f = gROOT->GetGlobalFunctionWithPrototype(name, "const AliTRDtrackV1*, Double_t*&, Int_t&", kTRUE))
734 != 0x0)
735 {
736 if (!strcmp(f->GetReturnTypeName(), "void"))
737 {
738 // Some additional check (are the parameters EXACTLY of the desired type?)
739 if (strstr(f->GetMangledName(), "oPconstsPAliTRDtrackV1mUsP") != 0x0 &&
740 strstr(f->GetMangledName(), "cODouble_tmUaNsP") != 0x0 &&
741 strstr(f->GetMangledName(), "cOInt_taNsP") != 0x0)
742 {
e007877e 743 type = kSingleTrackAnalyse;
744 }
745 }
746 }
747 // Correlated tracks select macro or correlated tracks histo macro?
748 else if ((f = gROOT->GetGlobalFunctionWithPrototype(name, "const AliTRDtrackV1*, const AliTRDtrackV1*", kTRUE))
749 != 0x0)
750 {
751 // Some additional check (is the parameter EXACTLY of the desired type?)
752 if (strstr(f->GetMangledName(), "oPconstsPAliTRDtrackV1mUsP") != 0x0 &&
753 strstr(f->GetMangledName(), "cOconstsPAliTRDtrackV1mUsP") != 0x0)
754 {
00dc25ef 755 // Correlated track select macro?
e007877e 756 if (!strcmp(f->GetReturnTypeName(), "Bool_t"))
757 {
758 type = kCorrelTrackSelect;
759 }
00dc25ef 760 // Correlated track histo macro?
e007877e 761 else if (!strcmp(f->GetReturnTypeName(), "TH1*"))
762 {
763 type = kCorrelTrackHisto;
764 }
765 }
766 }
767 // Correlated tracks analyse macro?
768 else if ((f = gROOT->GetGlobalFunctionWithPrototype(name,
769 "const AliTRDtrackV1*, const AliTRDtrackV1*, Double_t*&, Int_t&", kTRUE))
770 != 0x0)
771 {
772 if (!strcmp(f->GetReturnTypeName(), "void"))
773 {
774 // Some additional check (is the parameter EXACTLY of the desired type?)
775 if (strstr(f->GetMangledName(), "oPconstsPAliTRDtrackV1mUsP") != 0x0 &&
776 strstr(f->GetMangledName(), "cOconstsPAliTRDtrackV1mUsP") != 0x0 &&
777 strstr(f->GetMangledName(), "cODouble_tmUaNsP") != 0x0 &&
778 strstr(f->GetMangledName(), "cOInt_taNsP") != 0x0)
779 {
780 type = kCorrelTrackAnalyse;
8bdeb570 781 }
782 }
783 }
784 }
785 // Use list to look up the macro type
786 else
787 {
38a30030 788 TMacroData* macro = 0;
789 macro = (TMacroData*)fMacroList->GetValue(name);
790 if (macro == 0) return kUnknown;
8bdeb570 791
38a30030 792 type = macro->GetType();
8bdeb570 793 switch (type)
794 {
e007877e 795 case kSingleTrackSelect:
796 case kSingleTrackAnalyse:
797 case kSingleTrackHisto:
798 case kCorrelTrackSelect:
799 case kCorrelTrackAnalyse:
800 case kCorrelTrackHisto:
8bdeb570 801 break;
802 default:
803 type = kUnknown;
804 break;
805 }
806 }
807
808 return type;
809}
810
811//______________________________________________________
38a30030 812void AliEveTRDTrackList::RemoveSelectedMacros(const TList* iterator)
caaf90d2 813{
38a30030 814 // Uses the iterator (for the selected macros) to remove the selected macros from
16db6074 815 // the corresponding list.
816
38a30030 817 TObject* key = 0;
818 TPair* entry = 0;
caaf90d2 819 for (Int_t i = 0; i < iterator->GetEntries(); i++)
820 {
38a30030 821 entry = (TPair*)fMacroList->FindObject(iterator->At(i)->GetTitle());
8bdeb570 822
38a30030 823 if (entry == 0)
824 {
825 Error("AliEveTRDTrackList::RemoveSelectedMacros", Form("Macro \"%s\" not found in list!",
826 iterator->At(i)->GetTitle()));
827 continue;
828 }
829 key = entry->Key();
caaf90d2 830
38a30030 831 if (key == 0)
832 {
833 Error("AliEveTRDTrackList::RemoveSelectedMacros", Form("Key for macro \"%s\" not found in list!",
834 iterator->At(i)->GetTitle()));
835 continue;
836 }
837
838 // Key and value will be deleted, too, since fMacroList is the owner of them
839 Bool_t rem = fMacroList->DeleteEntry(key);
8bdeb570 840
38a30030 841 if (rem)
842 {
843#ifdef ALIEVETRDTRACKLIST_DEBUG
844 printf("AliEveTRDTrackList::RemoveSelectedMacros(): Removed macro: %s\n", iterator->At(i)->GetTitle());
845#endif
846 }
847 else
848 {
849 Error("AliEveTRDTrackList::RemoveSelectedMacros", Form("Macro \"%s\" could not be removed from the list!",
850 iterator->At(i)->GetTitle()));
851 }
caaf90d2 852 }
2ef0687e 853}
4f6473f6 854
ecbbe371 855//______________________________________________________
856void AliEveTRDTrackList::UpdateTrackStyle(AliEveTRDTrack::AliEveTRDTrackState s, UChar_t ss)
857{
16db6074 858 // Updates the track style and sets this style for each track.
859
8bdeb570 860 switch(s)
861 {
e007877e 862 case AliEveTRDTrack::kSource:
863 SETBIT(fSelectedStyle, AliEveTRDTrack::kSource);
864 break;
865 case AliEveTRDTrack::kPID:
866 CLRBIT(fSelectedStyle, AliEveTRDTrack::kSource);
867 switch(ss)
868 {
9443fb9d 869 case AliTRDpidUtil::kLQ:
e007877e 870 CLRBIT(fSelectedStyle, AliEveTRDTrack::kPID);
871 break;
9443fb9d 872 case AliTRDpidUtil::kNN:
e007877e 873 SETBIT(fSelectedStyle, AliEveTRDTrack::kPID);
874 break;
875 }
876 break;
877 case AliEveTRDTrack::kTrackCosmics:
878 SETBIT(fSelectedStyle, AliEveTRDTrack::kTrackCosmics);
879 break;
880 case AliEveTRDTrack::kTrackModel:
881 CLRBIT(fSelectedStyle, AliEveTRDTrack::kTrackCosmics);
882 switch(ss)
883 {
884 case AliEveTRDTrack::kRieman:
885 CLRBIT(fSelectedStyle, AliEveTRDTrack::kTrackModel);
886 break;
887 case AliEveTRDTrack::kKalman:
12896fe5 888 //AliWarning("Kalman fit under testing for the moment.");
889 SETBIT(fSelectedStyle, AliEveTRDTrack::kTrackModel);
e007877e 890 break;
891 }
892 break;
ecbbe371 893 }
894
895
ecbbe371 896 // Walk through the list of tracks
897 AliEveTRDTrack* track = 0x0;
8bdeb570 898 for (TEveElement::List_i iter = this->BeginChildren(); iter != this->EndChildren(); ++iter)
899 {
ecbbe371 900 if (!(track = dynamic_cast<AliEveTRDTrack*>(*iter))) continue;
901
902 track->SetStatus(fSelectedStyle);
903 }
904}