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