add "friendiness" to macro creation wizzard (Ben & Alex)
[u/mrichter/AliRoot.git] / EVE / EveDet / AliEveTRDTrackList.h
1 // Author: Benjamin Hess   25/09/2008
2
3 /*************************************************************************
4  * Copyright (C) 2008-2009, Alexandru Bercuci, Benjamin Hess.            *
5  * All rights reserved.                                                  *
6  *************************************************************************/
7
8 #ifndef AliEveTRDTrackList_H
9 #define AliEveTRDTrackList_H
10
11 //////////////////////////////////////////////////////////////////////////
12 //                                                                      //
13 // AliEveTRDTrackList                                                   //
14 //                                                                      //
15 // An AliEveTRDTrackList is, in principal, a TEveElementList with some  //
16 // sophisticated features. You can add macros to this list, which then  //
17 // can be applied to the list of tracks (these tracks can be added to   //
18 // the list in the same way as for the TEveElementList). In general,    //
19 // please use AddMacro(...) for this purpose.                           //
20 // Macros that are no longer needed can be removed from the list via    //
21 // RemoveSelectedMacros(...).This function takes an iterator of the     //
22 // list of macros that are to be removed.                               //
23 // be removed. An entry looks like:                                     //
24 // The data for each macro consists of path, name, type and the command //
25 // that will be used to apply the macro. This stuff is stored in a map  //
26 // which takes the macro name for the key and the above mentioned data  //
27 // in a TMacroData-object for the value.                                //
28 // You can get the macro type via GetMacroType(...).                    //
29 // With ApplySTSelectionMacros(...) or ApplyProcessMacros(...)          //
30 // respectively you can apply the macros to the track list via          //
31 // iterators (same style like for RemoveSelectedMacros(...)(cf. above)).//
32 // Selection macros (de-)select macros according to a selection rule    //
33 // by setting the rnr-state of the tracks.                              //
34 // If multiple selection macros are applied, a track is selected, if    //
35 // all selection macros select the track.                               //
36 // Process macros create data or histograms, which will be stored in    //
37 // a temporary file. The editor of this class will access this file     //
38 // and draw all the stuff within it's DrawHistos() function. The file   //
39 // will be deleted by the destructor.                                   //
40 //                                                                      //
41 // Currently, the following macro types are supported:                  //
42 // Selection macros:                                                    //
43 // Bool_t YourMacro(const AliTRDtrackV1*);                              //
44 // Bool_t YourMacro(const AliTRDtrackV1*, const AliTRDtrackV1*);        //
45 //                                                                      //
46 // Process macros:                                                      //
47 // void YourMacro(const AliTRDtrackV1*, Double_t*&, Int_t&);            //
48 // void YourMacro(const AliTRDtrackV1*, const AliTRDtrackV1*,           //
49 //                Double_t*&, Int_t&);                                  //
50 // TH1* YourMacro(const AliTRDtrackV1*);                                //
51 // TH1* YourMacro(const AliTRDtrackV1*, const AliTRDtrackV1*);          //
52 //                                                                      //
53 // The macros which take 2 tracks are applied to all track pairs        //
54 // (whereby BOTH tracks of the pair have to be selected by the single   //
55 // track selection macros and have to be unequal, otherwise they will   //
56 // be skipped) that have been selected by ALL correlated tracks         //
57 // selection macros. The selection macros with 2 tracks do NOT affect   //
58 // process macros that process only a single track!                     //
59 //////////////////////////////////////////////////////////////////////////
60
61
62 #include <TEveElement.h>
63 #include <EveDet/AliEveTRDData.h>
64
65 #define SIGNATURE_ERROR   -1
66 #define NOT_EXIST_ERROR   -2
67 #define ERROR            -3
68 #define WARNING           0
69 #define SUCCESS           1
70
71 #define MAX_MACRO_NAME_LENGTH     100
72 #define MAX_MACRO_PATH_LENGTH     300
73 #define MAX_APPLY_COMMAND_LENGTH  120
74
75 #define UNSETBIT(n,i)  ((n) &= ~BIT(i))
76
77 class AliEveTRDTrack;
78 class AliEveTRDTrackListEditor;
79 class AliTRDReconstructor;
80 class TFile;
81 class TFunction;
82 class TH1;
83 class TObjString;
84 class TList;
85 class TMap;
86 class TPair;
87 class TTreeSRedirector;
88
89 class AliEveTRDTrackList: public TEveElementList
90 {
91   friend class AliEveTRDTrackListEditor;
92
93 public:
94   
95   enum
96   {
97     // Maximum length (number of characters) for a macro name:
98     fkMaxMacroNameLength = MAX_MACRO_NAME_LENGTH,    
99     // Maximum length (number of characters) for a macro path:
100     fkMaxMacroPathLength = MAX_MACRO_PATH_LENGTH,    
101     // Maximum length (number of characters) for a macro pathname:
102     fkMaxMacroPathNameLength = MAX_MACRO_NAME_LENGTH + MAX_MACRO_PATH_LENGTH,  
103     // Maximum length (number of characters) for "apply macro" commands in addition to the length of the name, path... 
104     fkMaxApplyCommandLength = MAX_APPLY_COMMAND_LENGTH  
105   };
106
107   // Macro types
108   enum AliEveTRDTrackListMacroType
109   {
110     kUnknown = 0,
111     kSingleTrackSelect = 1,
112     kSingleTrackAnalyse = 2,
113     kSingleTrackHisto = 3,
114     kCorrelTrackSelect = 4,
115     kCorrelTrackAnalyse = 5,
116     kCorrelTrackHisto = 6
117   };
118   
119
120   AliEveTRDTrackList(const Text_t* n = "AliEveTRDTrackList", const Text_t* t = "", Bool_t doColor = kFALSE);
121   virtual ~AliEveTRDTrackList();
122
123   Int_t AddMacro(const Char_t* path, const Char_t* name, Bool_t forceReload = kFALSE);                      
124   Bool_t AddMacroFast(const Char_t* path, const Char_t* name, AliEveTRDTrackListMacroType type);        
125   virtual void AddStandardContent();                           
126   Bool_t ApplyProcessMacros(const TList* selIterator, const TList* procIterator);               
127   void ApplySTSelectionMacros(const TList* iterator);
128
129   // Returns the type of the macro of the corresponding entry (i.e. "macro.C (Path: path)"). 
130   // If you have only the name and the path, you can simply use MakeMacroEntry.
131   // If "UseList" is kTRUE, the type will be looked up in the internal list (very fast). But if this list
132   // does not exist, you have to use kFALSE for this parameter. Then the type will be determined by the
133   // prototype! NOTE: It is assumed that the macro has been compiled! If not, the return value is not
134   // predictable, but normally will be kUnknown.
135   // Note: AddMacro(Fast) will update the internal list and RemoveProcess(/Selection)Macros respectively.
136   AliEveTRDTrackListMacroType GetMacroType(const Char_t* name, Bool_t UseList = kTRUE) const; 
137   void RemoveSelectedMacros(const TList* iterator);                                    
138
139 protected:
140   AliEveTRDTrackListEditor* fEditor; // Pointer to the editor of this list             
141
142   TList* fDataFromMacroList;         // List of macros that currently have data for histograms
143
144   TMap*  fMacroList;                 // Stores the names, paths, types and commands of all macros added to this list
145
146   TTreeSRedirector *fDataTree;       // Tree containing data for histograms
147
148   Int_t fHistoDataSelected;          // Stores the selection for the data of the histograms
149   Int_t fMacroListSelected;          // Stores the selection of the macro list
150
151   Char_t fSelectedTab;               // Holds the index of the selected tab
152   UChar_t fSelectedStyle;            // Holds the selected track style
153
154   Char_t GetSelectedTab() const                          // Gets the selected tab
155     { return fSelectedTab;  }
156
157   UChar_t GetSelectedTrackStyle() const                  // Gets the selected track style
158     { return fSelectedStyle;  }
159
160   Bool_t HistoDataIsSelected(Int_t index) const          // Is entry in list selected?
161     { return TESTBIT(fHistoDataSelected, index);  }  
162    
163   Bool_t MacroListIsSelected(Int_t index) const          // Is entry in list selected?
164     { return TESTBIT(fMacroListSelected, index);  }     
165
166   void SetHistoDataSelection(Int_t index, Bool_t set)       // Set selection of entry in list
167     { if (set) SETBIT(fHistoDataSelected, index); else UNSETBIT(fHistoDataSelected, index);  }  
168
169   void SetMacroListSelection(Int_t index, Bool_t set)       // Set selection of entry in list
170     { if (set) SETBIT(fMacroListSelected, index); else UNSETBIT(fMacroListSelected, index);  }  
171     
172   void SetSelectedTab(Int_t index)                          // Sets the selected tab
173     { fSelectedTab = (Char_t)index; }  
174
175   void SetSelectedTrackStyle(UChar_t index)                 // Sets the selected track style
176     { fSelectedStyle = index;  }
177
178   void UpdateTrackStyle(AliEveTRDTrack::AliEveTRDTrackState s, UChar_t ss = 0);      
179
180 private:
181   AliEveTRDTrackList(const AliEveTRDTrackList&);            // Not implemented
182   AliEveTRDTrackList& operator=(const AliEveTRDTrackList&); // Not implemented             
183
184   ClassDef(AliEveTRDTrackList, 0);  // Class containing a list of tracks
185 };
186
187 //////////////////////////////////////////////////////////////////////////
188 //                                                                      //
189 // TMacroData                                                           //
190 //                                                                      //
191 // Stores macro data which will be used by AliEveTRDTrackList.          //
192 //                                                                      //
193 //////////////////////////////////////////////////////////////////////////
194
195 class TMacroData: public TObject
196 {
197 public:
198   TMacroData(const Char_t* name, const Char_t* path,                                                  // Constructor
199              AliEveTRDTrackList::AliEveTRDTrackListMacroType type = AliEveTRDTrackList::kUnknown):
200     TObject(),
201     fIsSelected(kFALSE),
202     fType(AliEveTRDTrackList::kUnknown)
203   {
204     // The command is automatically set via type.
205
206     SetName(name);
207     SetPath(path);
208     SetType(type);
209
210     // Register the commands for each type here
211     switch (type)
212     {
213       case AliEveTRDTrackList::kSingleTrackSelect:
214       case AliEveTRDTrackList::kSingleTrackHisto:
215         SetCmd(Form("%s(automaticTrackV1_1);", name));
216         break;
217
218       case AliEveTRDTrackList::kSingleTrackAnalyse:
219         SetCmd(Form("%s(automaticTrackV1_1, results, n);", name));
220         break;
221
222       case AliEveTRDTrackList::kCorrelTrackSelect:
223       case AliEveTRDTrackList::kCorrelTrackHisto:
224         SetCmd(Form("%s(automaticTrackV1_1, automaticTrackV1_2);", name));
225         break;
226
227       case AliEveTRDTrackList::kCorrelTrackAnalyse:
228         SetCmd(Form("%s(automaticTrackV1_1, automaticTrackV1_2, results, n);", name));
229         break;
230
231       default:
232         SetCmd("");
233         break;
234     }
235   }
236
237   const Char_t* GetCmd() const                // Returns the command that will be used to call this macro
238     { return fCmd;  }
239   const Char_t* GetName() const               // Returns the macro name (without ".C")
240     { return fName;  }
241   const Char_t* GetPath() const               // Returns the path of the macro
242     { return fPath;  }
243   AliEveTRDTrackList::AliEveTRDTrackListMacroType GetType() const   // Returns the type of the macro
244     { return fType;  }
245   Bool_t IsProcessMacro() const             // Returns whether the macro is a process type macro or not
246   {
247     switch (fType)
248     {
249       case AliEveTRDTrackList::kSingleTrackAnalyse:
250       case AliEveTRDTrackList::kSingleTrackHisto:
251       case AliEveTRDTrackList::kCorrelTrackAnalyse:
252       case AliEveTRDTrackList::kCorrelTrackHisto:
253         return kTRUE;
254         break;
255       default:
256         break;
257     }
258     
259     return kFALSE;
260   }
261
262   Bool_t IsSelected() const                   // Returns whether the macro is selected or not
263     { return fIsSelected; }
264   Bool_t IsSelectionMacro() const             // Returns whether the macro is a selection type macro or not
265   {
266     switch (fType)
267     {
268       case AliEveTRDTrackList::kSingleTrackSelect:
269       case AliEveTRDTrackList::kCorrelTrackSelect:
270         return kTRUE;
271         break;
272       default:
273         break;
274     }
275     
276     return kFALSE;
277   }
278
279   void SetCmd(const char* newCmd)             // Sets the command that will be used to call this macro
280   { 
281     memset(fCmd, '\0', sizeof(Char_t) * MAX_APPLY_COMMAND_LENGTH);
282     sprintf(fCmd, "%s", newCmd);
283   }
284   void SetName(const char* newName)           // Sets the macro name (please use without ".C")
285   { 
286     memset(fName, '\0', sizeof(Char_t) * MAX_MACRO_NAME_LENGTH);
287     sprintf(fName, "%s", newName);
288   }
289   void SetPath(const char* newPath)           // Sets the path of the macro
290   { 
291     memset(fPath, '\0', sizeof(Char_t) * MAX_MACRO_PATH_LENGTH);
292     sprintf(fPath, "%s", newPath);
293   }
294   void SetSelected(Bool_t selection)          // Sets whether the macro is selected or not
295   {
296     fIsSelected = selection;
297   }
298   void SetType(AliEveTRDTrackList::AliEveTRDTrackListMacroType newType)  // Sets the type of the macro
299   {
300     fType = newType;
301   }
302
303 private:
304   Char_t fCmd[MAX_APPLY_COMMAND_LENGTH];                  // Command that will be used to call this macro
305   Char_t fName[MAX_MACRO_NAME_LENGTH];                    // Macro name (without ".C"!)
306   Char_t fPath[MAX_MACRO_PATH_LENGTH];                    // Path of the macro
307   Bool_t fIsSelected;                                     // Is macro selected (e.g. in the editor's list)?
308   AliEveTRDTrackList::AliEveTRDTrackListMacroType fType;  // Type of the macro  
309 };
310
311 #endif