EVE/EveDet/AliEveListAnalyser.h

   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 // AliEveListAnalyser                                                   //
  11 //                                                                      //
  12 // An AliEveListAnalyser is, in principal, a TEveElementList with some  //
  13 // sophisticated features. You can add macros to this list, which then  //
  14 // can be applied to the list of analysis objects (these objects can be //
  15 // added to the list in the same way as for the TEveElementList, but    //
  16 // also "by clicking" (cf. AliEveListAnaLyserEditor)).                  //
  17 // In general, 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 // 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 TGeneralMacroData-object for the value.                         //
  26 // You can get the macro type via GetMacroType(...).                    //
  27 // To find the type of objects the macro will deal with (corresponds to //
  28 // "YourObjectType" in the examples below) please use                   //
  29 // GetMacroObjectType(...).                                             //
  30 // With ApplySOSelectionMacros(...) or ApplyProcessMacros(...)          //
  31 // respectively you can apply the macros to the track list via          //
  32 // iterators (same style like for RemoveSelectedMacros(...)(cf. above)).//
  33 // Selection macros (de-)select macros according to a selection rule    //
  34 // by setting the rnr-state of the tracks.                              //
  35 // If multiple selection macros are applied, a track is selected, if    //
  36 // all selection macros select the track.                               //
  37 // Process macros create data or histograms, which will be stored in    //
  38 // a temporary file. The editor of this class will access this file     //
  39 // and draw all the stuff within it's DrawHistos() function. The file   //
  40 // will be deleted by the destructor.                                   //
  41 //                                                                      //
  42 // Currently, the following macro types are supported:                  //
  43 // Selection macros:                                                    //
  44 // Bool_t YourMacro(const YourObjectType*);                             //
  45 // Bool_t YourMacro(const YourObjectType*, const YourObjectType2*);     //
  46 //                                                                      //
  47 // Process macros:                                                      //
  48 // void YourMacro(const YourObjectType*, Double_t*&, Int_t&);           //
  49 // void YourMacro(const YourObjectType*, const YourObjectType2*,        //
  50 //                Double_t*&, Int_t&);                                  //
  51 // TH1* YourMacro(const YourObjectType*);                               //
  52 // TH1* YourMacro(const YourObjectType*, const YourObjectType2*);       //
  53 //                                                                      //
  54 // The macros which take 2 tracks are applied to all track pairs        //
  55 // (whereby BOTH tracks of the pair have to be selected by the single   //
  56 // track selection macros and have to be unequal, otherwise they will   //
  57 // be skipped) that have been selected by ALL correlated tracks         //
  58 // selection macros. The selection macros with 2 tracks do NOT affect   //
  59 // process macros that process only a single track!                     //
  60 //////////////////////////////////////////////////////////////////////////
  61
  62 #ifndef AliEveListAnalyser_H
  63 #define AliEveListAnalyser_H
  64
  65 #include <TClass.h>
  66 #include <TEveElement.h>
  67 #include <AliEveTRDData.h>
  68
  69 #define SIGNATURE_ERROR           -1
  70 #define NOT_EXIST_ERROR           -2
  71 #define ERROR                     -3
  72 #define UNKNOWN_OBJECT_TYPE_ERROR -4
  73 #define WARNING                   0
  74 #define SUCCESS                   1
  75
  76 #define MAX_MACRO_NAME_LENGTH     100
  77 #define MAX_MACRO_PATH_LENGTH     300
  78 #define MAX_APPLY_COMMAND_LENGTH  120
  79
  80 #define UNSETBIT(n,i)  ((n) &= ~BIT(i))
  81
  82
  83 class AliEveListAnalyserEditor;
  84 class AliTRDReconstructor;
  85 class TClass;
  86 class TEveManager;
  87 class TEveSelection;
  88 class TFile;
  89 class TFunction;
  90 class TH1;
  91 class TList;
  92 class TMap;
  93 class TObjString;
  94 class TPair;
  95 class TString;
  96 class TTreeSRedirector;
  97
  98 class AliEveListAnalyser: public TEveElementList
  99 {
 100   friend class AliEveListAnalyserEditor;
 101
 102 public:
 103
 104   enum
 105   {
 106     // Maximum length (number of characters) for a macro name:
 107     fkMaxMacroNameLength = MAX_MACRO_NAME_LENGTH,
 108     // Maximum length (number of characters) for a macro path:
 109     fkMaxMacroPathLength = MAX_MACRO_PATH_LENGTH,
 110     // Maximum length (number of characters) for a macro pathname:
 111     fkMaxMacroPathNameLength = MAX_MACRO_NAME_LENGTH + MAX_MACRO_PATH_LENGTH,
 112     // Maximum length (number of characters) for "apply macro" commands in addition to the length of the name, path...
 113     fkMaxApplyCommandLength = MAX_APPLY_COMMAND_LENGTH
 114   };
 115
 116   // Macro types
 117   enum AliEveListAnalyserMacroType
 118   {
 119     kUnknown = 0,
 120     kSingleObjectSelect = 1,
 121     kSingleObjectAnalyse = 2,
 122     kSingleObjectHisto = 3,
 123     kCorrelObjectSelect = 4,
 124     kCorrelObjectAnalyse = 5,
 125     kCorrelObjectHisto = 6
 126   };
 127
 128
 129   AliEveListAnalyser(const Text_t* n = "AliEveListAnalyser", const Text_t* t = "", Bool_t doColor = kFALSE);
 130   virtual ~AliEveListAnalyser();
 131
 132   Int_t AddMacro(const Char_t* path, const Char_t* name, Bool_t forceReload = kFALSE);
 133   Bool_t AddMacroFast(const Char_t* path, const Char_t* name, AliEveListAnalyserMacroType type, TClass* objectType, TClass* objectType2);
 134   Int_t AddPrimSelectedObject(TEveElement* el);
 135   //void AddPrimSelectedObjects();
 136   void AddSecSelectedSingleObjectToList(Int_t pointId);
 137   virtual void AddStandardContent();
 138   Bool_t ApplyProcessMacros(const TList* selIterator, const TList* procIterator);
 139   void ApplySOSelectionMacros(const TList* iterator);
 140   Bool_t GetConnected()             // Returns whether "adding objects by clicking" is enabled or not.
 141     { return fConnected;  };
 142   TClass* GetMacroObjectType(const Char_t* name, Int_t argNum = 1) const;
 143
 144   // Returns the type of the macro of the corresponding entry (i.e. "macro.C (Path: path)").
 145   // If you have only the name and the path, you can simply use MakeMacroEntry.
 146   // If "UseList" is kTRUE, the type will be looked up in the internal list (very fast). But if this list
 147   // does not exist, you have to use kFALSE for this parameter. Then the type will be determined by the
 148   // prototype! NOTE: It is assumed that the macro has been compiled! If not, the return value is not
 149   // predictable, but normally will be kUnknown.
 150   // "objectType" gives the class/"type of object" of the pointer(s), the macro accepts as a parametre.
 151   // Note: AddMacro(Fast) will update the internal list and RemoveProcess(/Selection)Macros respectively.
 152   AliEveListAnalyserMacroType GetMacroType(const Char_t* name, const Char_t* objectType = "TObject",
 153                                            const Char_t* objectType2 = "TObject", Bool_t UseList = kTRUE) const;
 154
 155   //void RemovePrimSelectedObjects();
 156   void RemoveSelectedMacros(const TList* iterator);
 157   void ResetObjectList();
 158   Bool_t StartAddingObjects();
 159   Bool_t StopAddingObjects();
 160
 161 protected:
 162   Bool_t fConnected;                 // Connection to the TEvePointSet signal
 163
 164   TList* fDataFromMacroList;         // List of macros that currently have data for histograms
 165
 166   AliEveListAnalyserEditor* fEditor; // Pointer to the editor of this list
 167
 168   TMap*  fMacroList;                 // Stores the names, paths, types and commands of all macros added to this list
 169
 170   TTreeSRedirector *fDataTree;       // Tree containing data for histograms
 171
 172   Int_t fHistoDataSelected;          // Stores the selection for the data of the histograms
 173   Int_t fMacroListSelected;          // Stores the selection of the macro list
 174
 175   Char_t fSelectedTab;               // Holds the index of the selected tab
 176
 177   Char_t GetSelectedTab() const                          // Gets the selected tab
 178     { return fSelectedTab;  }
 179
 180   Bool_t HistoDataIsSelected(Int_t index) const          // Is entry in list selected?
 181     { return TESTBIT(fHistoDataSelected, index);  }
 182
 183   Bool_t MacroListIsSelected(Int_t index) const          // Is entry in list selected?
 184     { return TESTBIT(fMacroListSelected, index);  }
 185
 186   void SetHistoDataSelection(Int_t index, Bool_t set)       // Set selection of entry in list
 187     { if (set) SETBIT(fHistoDataSelected, index); else UNSETBIT(fHistoDataSelected, index);  }
 188
 189   void SetMacroListSelection(Int_t index, Bool_t set)       // Set selection of entry in list
 190     { if (set) SETBIT(fMacroListSelected, index); else UNSETBIT(fMacroListSelected, index);  }
 191
 192   void SetSelectedTab(Int_t index)                          // Sets the selected tab
 193     { fSelectedTab = (Char_t)index; }
 194
 195 private:
 196   AliEveListAnalyser(const AliEveListAnalyser&);            // Not implemented
 197   AliEveListAnalyser& operator=(const AliEveListAnalyser&); // Not implemented
 198
 199   ClassDef(AliEveListAnalyser, 0);  // Class containing a list of analyse objects
 200 };
 201
 202 //////////////////////////////////////////////////////////////////////////
 203 //                                                                      //
 204 // TGeneralMacroData                                                    //
 205 //                                                                      //
 206 // Stores macro data which will be used by AliEveListAnalyser.          //
 207 //                                                                      //
 208 //////////////////////////////////////////////////////////////////////////
 209
 210 class TGeneralMacroData: public TObject
 211 {
 212 public:
 213   TGeneralMacroData(const Char_t* name, const Char_t* path,                                                        // Constructor
 214              AliEveListAnalyser::AliEveListAnalyserMacroType type = AliEveListAnalyser::kUnknown,
 215              TClass* objectType = TObject::Class(), TClass* objectType2 = TObject::Class()):
 216     TObject(),
 217     fObjectType(0x0),
 218     fObjectType2(0x0),
 219     fIsSelected(kFALSE),
 220     fType(AliEveListAnalyser::kUnknown)
 221
 222   {
 223     // The command is automatically set via type.
 224
 225     SetName(name);
 226     SetObjectType(objectType);
 227     SetObjectType2(objectType2);
 228     SetPath(path);
 229     SetType(type);
 230
 231     // Register the commands for each type here
 232     // Note: The framework will cast all data objects to "TObject*"
 233     // -> We need to cast to the correct type for the macro!
 234     switch (type)
 235     {
 236       case AliEveListAnalyser::kSingleObjectSelect:
 237       case AliEveListAnalyser::kSingleObjectHisto:
 238         SetCmd(Form("%s((%s*)automaticObject_1);", name, fObjectType->GetName()));
 239         break;
 240
 241       case AliEveListAnalyser::kSingleObjectAnalyse:
 242         SetCmd(Form("%s((%s*)automaticObject_1, results, n);", name, fObjectType->GetName()));
 243         break;
 244
 245       case AliEveListAnalyser::kCorrelObjectSelect:
 246       case AliEveListAnalyser::kCorrelObjectHisto:
 247         SetCmd(Form("%s((%s*)automaticObject_1, (%s*)automaticObject_2);", name, fObjectType->GetName(), fObjectType2->GetName()));
 248         break;
 249
 250       case AliEveListAnalyser::kCorrelObjectAnalyse:
 251         SetCmd(Form("%s((%s*)automaticObject_1, (%s*)automaticObject_2, results, n);", name, fObjectType->GetName(), fObjectType2->GetName()));
 252         break;
 253
 254       default:
 255         SetCmd("");
 256         break;
 257     }
 258   }
 259
 260   const Char_t* GetCmd() const                // Returns the command that will be used to call this macro
 261     { return fCmd;  }
 262   const Char_t* GetName() const               // Returns the macro name (without ".C")
 263     { return fName;  }
 264   TClass* GetObjectType() const               // Returns the object type of the macro parameter (1st pointer)
 265     { return fObjectType;  }
 266   TClass* GetObjectType2() const              // Returns the object type of the macro parameter (2nd pointer)
 267     { return fObjectType2;  }
 268   const Char_t* GetPath() const               // Returns the path of the macro
 269     { return fPath;  }
 270   AliEveListAnalyser::AliEveListAnalyserMacroType GetType() const   // Returns the type of the macro
 271     { return fType;  }
 272   Bool_t IsProcessMacro() const               // Returns whether the macro is a process type macro or not
 273   {
 274     switch (fType)
 275     {
 276       case AliEveListAnalyser::kSingleObjectAnalyse:
 277       case AliEveListAnalyser::kSingleObjectHisto:
 278       case AliEveListAnalyser::kCorrelObjectAnalyse:
 279       case AliEveListAnalyser::kCorrelObjectHisto:
 280         return kTRUE;
 281         break;
 282       default:
 283         break;
 284     }
 285
 286     return kFALSE;
 287   }
 288
 289   Bool_t IsSelected() const                   // Returns whether the macro is selected or not
 290     { return fIsSelected; }
 291   Bool_t IsSelectionMacro() const             // Returns whether the macro is a selection type macro or not
 292   {
 293     switch (fType)
 294     {
 295       case AliEveListAnalyser::kSingleObjectSelect:
 296       case AliEveListAnalyser::kCorrelObjectSelect:
 297         return kTRUE;
 298         break;
 299       default:
 300         break;
 301     }
 302
 303     return kFALSE;
 304   }
 305
 306   void SetCmd(const char* newCmd)               // Sets the command that will be used to call this macro
 307   {
 308     memset(fCmd, '\0', sizeof(Char_t) * MAX_APPLY_COMMAND_LENGTH);
 309     snprintf(fCmd, MAX_APPLY_COMMAND_LENGTH, "%s", newCmd);
 310   }
 311   void SetName(const char* newName)             // Sets the macro name (please use without ".C")
 312   {
 313     memset(fName, '\0', sizeof(Char_t) * MAX_MACRO_NAME_LENGTH);
 314     snprintf(fName, MAX_MACRO_NAME_LENGTH, "%s", newName);
 315   }
 316   void SetObjectType(TClass* newObjectType)     // Sets the object type of the macro parameter (1st pointer)
 317   {
 318     fObjectType = newObjectType;
 319   }
 320   void SetObjectType2(TClass* newObjectType2)   // Sets the object type of the macro parameter (2nd pointer)
 321   {
 322     fObjectType2 = newObjectType2;
 323   }
 324   void SetPath(const char* newPath)             // Sets the path of the macro
 325   {
 326     memset(fPath, '\0', sizeof(Char_t) * MAX_MACRO_PATH_LENGTH);
 327     snprintf(fPath, MAX_MACRO_PATH_LENGTH, "%s", newPath);
 328   }
 329   void SetSelected(Bool_t selection)            // Sets whether the macro is selected or not
 330   {
 331     fIsSelected = selection;
 332   }
 333   void SetType(AliEveListAnalyser::AliEveListAnalyserMacroType newType)  // Sets the type of the macro
 334   {
 335     fType = newType;
 336   }
 337
 338 private:
 339   TGeneralMacroData(const TGeneralMacroData&);            // Not implemented
 340   TGeneralMacroData& operator=(const TGeneralMacroData&); // Not implemented
 341
 342   Char_t fCmd[MAX_APPLY_COMMAND_LENGTH];                  // Command that will be used to call this macro
 343   Char_t fName[MAX_MACRO_NAME_LENGTH];                    // Macro name (without ".C"!)
 344   TClass* fObjectType;                                    // Type of object of the macro parameter (1st pointer)
 345   TClass* fObjectType2;                                   // Type of object of the macro parameter (2nd pointer)
 346   Char_t fPath[MAX_MACRO_PATH_LENGTH];                    // Path of the macro
 347   Bool_t fIsSelected;                                     // Is macro selected (e.g. in the editor's list)?
 348   AliEveListAnalyser::AliEveListAnalyserMacroType fType;  // Type of the macro
 349 };
 350
 351 #endif