KVTreeAnalyzer.h

 
#ifndef __KVTreeAnalyzer_H
#define __KVTreeAnalyzer_H
#ifndef ROOT_TGDockableFrame
#include "TGDockableFrame.h"
#endif
#ifndef ROOT_TGMenu
#include "TGMenu.h"
#endif
#ifndef ROOT_TGMdiDecorFrame
#include "TGMdiDecorFrame.h"
#endif
#ifndef ROOT_TG3DLine
#include "TG3DLine.h"
#endif
#ifndef ROOT_TGMdiFrame
#include "TGMdiFrame.h"
#endif
#ifndef ROOT_TGMdiMainFrame
#include "TGMdiMainFrame.h"
#endif
#ifndef ROOT_TGMdiMenu
#include "TGMdiMenu.h"
#endif
#ifndef ROOT_TGListBox
#include "TGListBox.h"
#endif
#ifndef ROOT_TGNumberEntry
#include "TGNumberEntry.h"
#endif
#ifndef ROOT_TGScrollBar
#include "TGScrollBar.h"
#endif
#ifndef ROOT_TGComboBox
#include "TGComboBox.h"
#endif
#ifndef ROOT_TRootBrowser
#include "TRootBrowser.h"
#endif
#ifndef ROOT_TGFrame
#include "TGFrame.h"
#endif
#ifndef ROOT_TGFileDialog
#include "TGFileDialog.h"
#endif
#ifndef ROOT_TGShutter
#include "TGShutter.h"
#endif
#ifndef ROOT_TGButtonGroup
#include "TGButtonGroup.h"
#endif
#ifndef ROOT_TGCommandPlugin
#include "TGCommandPlugin.h"
#endif
#ifndef ROOT_TGCanvas
#include "TGCanvas.h"
#endif
#ifndef ROOT_TGFSContainer
#include "TGFSContainer.h"
#endif
#ifndef ROOT_TGColorSelect
#include "TGColorSelect.h"
#endif
#ifndef ROOT_TGTextEdit
#include "TGTextEdit.h"
#endif
#ifndef ROOT_TGButton
#include "TGButton.h"
#endif
#ifndef ROOT_TGFSComboBox
#include "TGFSComboBox.h"
#endif
#ifndef ROOT_TGLabel
#include "TGLabel.h"
#endif
#ifndef ROOT_TGView
#include "TGView.h"
#endif
#ifndef ROOT_TGFileBrowser
#include "TGFileBrowser.h"
#endif
#ifndef ROOT_TGTab
#include "TGTab.h"
#endif
#ifndef ROOT_TGListView
#include "TGListView.h"
#endif
#ifndef ROOT_TGSplitter
#include "TGSplitter.h"
#endif
#ifndef ROOT_TGTextEditor
#include "TGTextEditor.h"
#endif
#ifndef ROOT_TRootCanvas
#include "TRootCanvas.h"
#endif
#ifndef ROOT_TGStatusBar
#include "TGStatusBar.h"
#endif
#ifndef ROOT_TGListTree
#include "TGListTree.h"
#endif
#ifndef ROOT_TGToolTip
#include "TGToolTip.h"
#endif
#ifndef ROOT_TGToolBar
#include "TGToolBar.h"
#endif
#ifndef ROOT_TGHtmlBrowser
#include "TGHtmlBrowser.h"
#endif
 
#include "TEnv.h"
#include "Riostream.h"
#include "KVListView.h"
#include "TChain.h"
#include "TCutG.h"
#include "TH1.h"
#include "TEntryList.h"
#include "KVUniqueNameList.h"
#include "TBrowser.h"
#include <KVUnownedList.h>
 
class KVHistogram;
 
class KVTreeAnalyzer : public TNamed {
private:
   const Char_t* get_leaf_type_name(const TNamed* l);
    static KVList* fgAnalyzerList;
 
   void init();
    Bool_t fDeletedByGUIClose;
 
    TTree* fTree;
    TChain* fChain;
    KVUniqueNameList fSelections;
 
    TString fSaveAnalysisFileName;
    Bool_t fAnalysisModifiedSinceLastSave;
 
   /* leaves */
    TGGroupFrame* fMain_leaflist;
    KVListView* G_leaflist;
    KVList fLeafList;
    TGLabel* G_leaf_expr;
    TGPictureButton* G_leaf_draw;
    TString fLeafExpr;
    KVList* fSelectedLeaves;
    TNamed* fXLeaf;
    TNamed* fYLeaf;
    TNamed* fZLeaf;
    TGTextEntry* G_alias_text;
    TGCheckButton* G_histo_prof;
    Bool_t fProfileHisto;
    TGCheckButton* G_histo_bin;
    Bool_t fUserBinning;
    TGCheckButton* G_histo_weight;
    Bool_t fUserWeight;
    TString fWeight;
 
    Int_t fNx, fNy;
    Double_t fXmin, fXmax, fYmin, fYmax;
    Int_t fNxF;
    Double_t fXminF, fXmaxF;
 
    Int_t fNxD, fNyD;
    bool fOrderedDalitz;
 
   /* histos */
    TGMainFrame* fMain_histolist;
   const TGMainFrame* GetMainWindow() const
   {
      return fMain_histolist;
   }
    TGPopupMenu* fMenuFile;
    TGPopupMenu* fMenuSelections;
    TGPopupMenu* fSelCombMenu;
    TGPopupMenu* fOptionMenu;
    TGPopupMenu* fSelGenerate;
   enum {
      MH_OPEN_FILE,
      MH_OPEN_CHAIN,
      MH_ADD_FRIEND,
      MH_SAVE_FILE,
      MH_SAVE,
      MH_CLOSE,
      MH_QUIT,
      OPT_PROOF,
      MH_APPLY_ANALYSIS,
      SEL_COMB_AND,
      SEL_COMB_OR,
      SEL_UPDATE,
      SEL_DELETE,
      SEL_GEN_CONST_XSEC
   };
   void HistoFileMenu_Open();
   void OpenChain();
   void HistoFileMenu_Save();
    TGLayoutHints* fMenuBarItemLayout;
    TGMenuBar* fMenuBar;
    KVListView* G_histolist;
    TGPictureButton* G_histo_del;
    TGPictureButton* G_histo_add;
    TGCheckButton* G_histo_same;
    TGCheckButton* G_histo_app_sel;
    TGCheckButton* G_histo_log;
    TGCheckButton* G_histo_new_can;
    TGCheckButton* G_histo_norm;
    TGCheckButton* G_histo_norm_events;
    TGCheckButton* G_histo_stats;
    TGCheckButton* G_histo_autosave;
    TGComboBox* G_histo_draw_option;
    TString fDrawOption;
    Bool_t fDrawSame;
    Int_t fSameColorIndex;
    Bool_t fDrawLog;
    Bool_t fApplySelection;
    Bool_t fNewCanvas;
    Bool_t fNormHisto;
    Bool_t fNormHistoEvents;
    Bool_t fStatsHisto;
    Bool_t fAutoSaveHisto;
    TString fAutoSaveDir;
    TString fAutoSaveType;
    TList* fSelectedHistos;
    TGTextButton* G_make_ip_scale;
    TGTextButton* G_fit1;
    TGTextButton* G_fit2;
    TGTextButton* G_fit3;
    TGTextButton* G_fitGG1;
    TGTextButton* G_fitGG2;
    TGTextButton* G_fitGG3;
    TGTextEntry* G_make_ip_selection;
    TGLabel* G_ip_histo;
 
   /* selections */
    TGGroupFrame* fMain_selectionlist;
    KVListView* G_selectionlist;
    TGStatusBar* G_selection_status;
    TGTextEntry* G_selection_text;
    TList* fSelectedSelections;
 
    KVList fHistolist;
    TString fTreeName;
    TString fTreeFileName;
    Int_t fHistoNumber;
    Int_t fSelectionNumber;
    Int_t fAliasNumber;
    KVList fAliasList;
    Bool_t fNoGui;
 
    Bool_t fMethodCalled;
 
    TH1* HistoToAdd1;
    TH1* HistoToAdd2;
    TH1* HistoAddResult;
 
    TString fRelativePathToAnalysisFile;
   void SetRelativePathToAnalysisFile(const Char_t* p)
   {
      fRelativePathToAnalysisFile = p;
   }
 
    TString fAnalysisSaveDir;
 
    Bool_t fPROOFEnabled;
 
   void ResetMethodCalled()
   {
      fMethodCalled = kFALSE;
   }
   Bool_t MethodNotCalled()
   {
      return !fMethodCalled;
   }
 
   void AddHisto(TH1*);
   void AddCut(TCutG*);
   void AddSelection(TEntryList*);
   void ReconnectTree();
 
   void GenerateHistoTitle(TString& title, const Char_t* exp, const Char_t* sel, const Char_t* weight = "");
   void FillLeafList();
 
   void AnalysisSaveCheck();
   void SetAnalysisModifiedSinceLastSave(Bool_t);
 
   void SetEntryList(TEntryList*);
 
   bool DefineWeight();
   bool DefineUserBinning();
   bool DefineUserBinning1F();
   bool DefineUserBinningD();
 
   double GetTreeMaximum(const TString& leafname);
   double GetTreeMinimum(const TString& leafname);
 
public:
   KVTreeAnalyzer(Bool_t nogui = kTRUE);
   KVTreeAnalyzer(TTree*, Bool_t nogui = kFALSE);
   virtual ~KVTreeAnalyzer();
   void DeleteThis()
   {
      delete this;
   }
 
   void Copy(TObject& obj) const;
 
   void SetTree(TTree* t);
   void OpenGUI();
   void GUIClosed();
   TH1* MakeHisto(const Char_t* expr, const Char_t* selection, Int_t nX, Int_t nY = 0, const Char_t* weight = "", Double_t xmin = -1, Double_t xmax = -1, Double_t ymin = -1, Double_t ymax = -1);
   TH1* RemakeHisto(TH1* h, const Char_t* expr, const Char_t* weight = "");
   TH1* MakeIntHisto(const Char_t* expr, const Char_t* selection, Int_t Xmin, Int_t Xmax, const Char_t* weight = "");
   const KVList* GetHistoList() const
   {
      return &fHistolist;
   }
   TH1* GetHistogram(const Char_t* name) const;
   TList* GetHistosByData(const Char_t* expr);
   TList* GetHistosBySelection(const Char_t* expr);
   TH1* GetHisto(const Char_t* expr, const Char_t* selection, const Char_t* weight = "");
   KVHistogram* GetHistoByTitle(const Char_t* title);
   void DeleteHisto(const Char_t* expr, const Char_t* selection, const Char_t* weight);
   void DeleteSelectedHisto();
   void AddSelectedHistos();
   void HistoAddition(Double_t c1 = 1, Double_t c2 = 1);
 
   Bool_t MakeSelection(const Char_t* selection);
   void UpdateEntryLists();
   void GenerateSelection();
   void CombineSelectionsAnd();
   void CombineSelectionsOr();
   void DeleteSelections();
   void SelectionChanged();
   void SetAlias(const Char_t* name, const Char_t* expr);
   void GenerateAlias();
   TNamed* GetAlias(const Char_t* expr)
   {
      return (TNamed*)fAliasList.FindObjectByType(expr);
   }
   void ShowSelections()
   {
      fSelections.ls();
   }
   void ShowVariables()
   {
      fTree->GetListOfLeaves()->ls();
   }
   void ShowAliases()
   {
      fAliasList.ls();
   }
   void ShowHistos()
   {
      fHistolist.ls();
   }
   void CurrentSelection();
   Bool_t IsCurrentSelection(const Char_t* sel);
   void SetSelection(TObject*);
   void SetSelection(const Char_t*);
   TEntryList* GetSelection(const Char_t*);
 
   void EnablePROOF(Bool_t yes = kTRUE);
   Bool_t IsPROOFEnabled() const
   {
      return fPROOFEnabled;
   }
   Bool_t IsPROOFEnabledForSelections() const
   {
      return (gEnv->GetValue("KVTreeAnalyzer.PROOFSelections", 0) && fPROOFEnabled);
   }
 
   static KVTreeAnalyzer* OpenFile(const Char_t* filename, Bool_t nogui = kFALSE);
   void ReadFromFile(const Char_t* filename);
   void ReadFromFile(TFile* f);
   void OpenAnyFile(const Char_t* filepath);
   void OpenChain(const TString& treename, const TString& treetitle, const TSeqCollection* files);
 
   void DrawHisto(TObject* o, Bool_t gen = kTRUE);
   void DrawHistogram(TH1* histo, Bool_t same = false, Bool_t logscale = false);
   void DrawCut(TCutG*);
   void DrawLeaf(TObject*);
   void DrawLeafExpr();
   void DrawAsDalitz();
   void SetUserBinning(Bool_t ub)
   {
      fUserBinning = ub;
   }
   void SetUserWeight(Bool_t uw)
   {
      fUserWeight = uw;
   }
 
   void SetAutoSaveHisto(Bool_t yes = kTRUE)
   {
      fAutoSaveHisto = yes;
      if (yes) SetUpHistoAutoSave();
   }
   void SetStatsHisto(Bool_t yes = kTRUE)
   {
      fStatsHisto = yes;
   }
   void SetNormHisto(Bool_t yes = kTRUE)
   {
      fNormHisto = yes;
      fNormHistoEvents = (yes ? kFALSE : fNormHistoEvents);
      G_histo_norm_events->SetState((EButtonState)fNormHistoEvents);
   }
   void SetNormHistoEvents(Bool_t yes = kTRUE)
   {
      fNormHistoEvents = yes;
      fNormHisto = (yes ? kFALSE : fNormHisto);
      G_histo_norm->SetState((EButtonState)fNormHisto);
   }
   void SetDrawOption(Option_t* option = "")
   {
      fDrawOption = option;
   }
 
   void SetNewCanvas(Bool_t yes = kTRUE)
   {
      fNewCanvas = yes;
      if (G_histo_same->IsOn()) {
         G_histo_same->SetState((EButtonState)kFALSE);
         fDrawSame = kFALSE;
      }
   }
   void SetDrawSame(Bool_t yes = kTRUE)
   {
      fSameColorIndex = 0;
      fDrawSame = yes;
      if (G_histo_new_can->IsOn()) {
         G_histo_new_can->SetState((EButtonState)kFALSE);
         fNewCanvas = kFALSE;
      }
   }
   void SetDrawLog(Bool_t yes = kTRUE)
   {
      fDrawLog = yes;
   }
   void SetApplySelection(Bool_t yes = kTRUE)
   {
      fApplySelection = yes;
   }
   void SetProfileHisto(Bool_t yes = kTRUE)
   {
      fProfileHisto = yes;
   }
   void LeafChanged();
   void HistoSelectionChanged();
   void Save();
   void SaveAs(const char* filename = "", Option_t* option = "") const;
 
   Int_t GetNx()
   {
      return fNx;
   }
   Int_t GetNy()
   {
      return fNy;
   }
   Double_t GetXmin()
   {
      return fXmin;
   }
   Double_t GetXmax()
   {
      return fXmax;
   }
   Double_t GetYmin()
   {
      return fYmin;
   }
   Double_t GetYmax()
   {
      return fYmax;
   }
 
   Int_t GetNxD()
   {
      return fNxD;
   }
   Int_t GetNyD()
   {
      return fNxD;
   }
   Bool_t GetOrderedDalitz()
   {
      return fOrderedDalitz;
   }
 
   Int_t GetNxF()
   {
      return fNxF;
   }
   Double_t GetXminF()
   {
      return fXminF;
   }
   Double_t GetXmaxF()
   {
      return fXmaxF;
   }
 
   const char* GetWeight()
   {
      return fWeight;
   }
 
   void SetUpHistoAutoSave();
 
   void HandleHistoFileMenu(Int_t);
   void HandleSelectionsMenu(Int_t);
   void AutoSaveHisto(TH1* h);
 
   void GenerateAllSelections(TCollection*);
   void GenerateAllHistograms(TCollection*);
   void GenerateAllAliases(TCollection* list);
   void HistoFileMenu_Apply();
   void ReapplyAnyFile(const Char_t* filepath);
   void SetTreeFileName(TTree* t);
 
   static KVList* GetListOfAnalyzers()
   {
      return fgAnalyzerList;
   }
   static KVTreeAnalyzer* GetAnalyzer(const Char_t* title)
   {
      return (KVTreeAnalyzer*)fgAnalyzerList->FindObjectByTitle(title);
   }
 
   void MakeAbsoluteIPScale(const char* name, Double_t sigmaTot);
   void GenerateConstantXSecSelections(const char* name, Double_t sigmaTot, Double_t sigmaBin);// *MENU*
 
   void HandleOptionsMenu(Int_t opt);
   void OpenAnyFriendFile(const Char_t* filepath);
   void HistoFileMenu_OpenFriend();
   Long64_t GetEntriesInCurrentSelection() const;
   ClassDef(KVTreeAnalyzer, 5) //KVTreeAnalyzer
   void OpenSingleFile(TFile* file);
 
   TChain* GetChain() const
   {
      return fChain;
   }
   void GetHistosFromFile(TFile* file, const KVUnownedList& keys);
};
R__EXTERN  KVTreeAnalyzer* gTreeAnalyzer;
 
#endif