KVSimDirGUI.h

 
#ifndef __KVSIMDIRGUI_H
#define __KVSIMDIRGUI_H
#include "TSystem.h"
#include "KVBase.h"
#include "KVList.h"
#include "TGListTree.h"
#include "TGFrame.h"
#include "TGTab.h"
#include "TEnv.h"
#include "KVDataSetManager.h"
#include "TGTextEntry.h"
#include "TGNumberEntry.h"
#include "TGButton.h"
#include "TGComboBox.h"
#include <TGLabel.h>
#include <TGMenu.h>
#include <TGStatusBar.h>
#include "RQ_OBJECT.h"
#include "TApplication.h"
#include "KVListView.h"
#include "KVSimDir.h"
#include "KVInputDialog.h"
#include "KVDataAnalyser.h"
#ifdef WITH_RSQLITE
#include "SQLiteDB.h"
#endif
class TChain;
 
class KVSimDirGUI : public KVBase {
   RQ_OBJECT("KVSimDirGUI")
 
   KVList fListOfDirs;
   KVSimDir* fSelectedSimDir;
 
   TGMainFrame* MainFrame;
   TGStatusBar* fStatusBar;
   /* picture buttons for managing directories */
   TGPictureButton* BaddDir;
   TGPictureButton* BimpSim;
   TGPictureButton* BremDir;
   TGPictureButton* BrefreshDir;
   /* list tree for managing directories */
   TGCanvas* fDirListCanvas;
   TGViewPort* fDirListViewPort;
   TGListTree* fDirListTree;
    const TGPicture* popen;
    const TGPicture* pclose;
   /* lists of data */
   KVListView* fLVsimData;
   KVListView* fLVfiltData;
   KVDataAnalyser::UserClass fAnalClass;
   TGCheckButton* fCBAllEvents;
   TGNumberEntry* fNENumberEvents;
   KVString fDataset;
   KVString fSystem, fReactionKinematics;
   Int_t fRun = 0;
   KVString fDataQualityAudit;
   KVString fExtensibleIDs;
   Bool_t fCustomKinematics = false;
   Bool_t fRandomPhi = false;
   Bool_t fGemDecay = false;
   Bool_t fGemAddRotEner = false;
   Int_t fGemDecayPerEvent = 1;
   enum {
      kFTGeo = 1,
      kFTSeuils,
      kFTFull
   };
   enum {
      kGTKaliVeda = 1,
      kGTROOT
   };
   enum {
      kKCM = 1,
      kKLab,
      kKProj
   };
   Int_t fFilterType;
   Int_t fGeoType;
   Int_t fKine;
   TGPictureButton* proof_analysis;
   TGPictureButton* proof_analysis_ana;
   TEnv fGuirc;
#ifdef WITH_RSQLITE
   KVSQLite::database fConfigDB;
#endif
    Bool_t fWithPROOF;
    Bool_t fCancelJob;
   Bool_t fFilterMode{false}, fAnalysisMode{true};
protected:
   void SetFilterOptions();
#ifdef WITH_RSQLITE
   TString AddTableForDataSet(KVSimDir* sd, int ds_table_number);
   void FillDataSetTableWithInfos(TString ds_table_name, KVSimDir* sd);
   void ReconstructSimDirsFromDB();
#endif
 
public:
   struct menu_struct {
      TGLayoutHints layout{kLHintsTop | kLHintsLeft, 4, 0, 0, 0};
      KVSimDirGUI* _parent_gui;
      menu_struct(KVSimDirGUI* s) : _parent_gui{s} {}
 
      TGMenuBar* menu_bar;
 
      struct mode_struct {
         KVSimDirGUI* _parent_gui;
         mode_struct(KVSimDirGUI* s) : _parent_gui{s} {}
         TString type = "mode_struct";
         TGPopupMenu* menu;
         enum items {
            analysis,
            filter
         };
         void handle_me(Int_t i)
         {
            switch (i) {
               case analysis:
                  if (!_parent_gui->IsAnalysisMode()) {
                     _parent_gui->SetAnalysisMode();
                     menu->RCheckEntry(analysis, analysis, filter);
                  }
                  break;
               case filter:
                  if (!_parent_gui->IsFilterMode()) {
                     _parent_gui->SetFilterMode();
                     menu->RCheckEntry(filter, analysis, filter);
                  }
            }
         }
      };
      mode_struct mode{_parent_gui};
 
      struct analysis_struct {
         KVSimDirGUI* _parent_gui;
         analysis_struct(KVSimDirGUI* s) : _parent_gui{s} {}
         TString type = "analysis_struct";
         TGPopupMenu* menu;
         TGPopupMenu* generate;
         enum items {
            select_analysis_class,
            generate_class_simulation_analysis,
            generate_class_filtered_analysis
         };
         void handle_me(Int_t i)
         {
            switch (i) {
               case select_analysis_class:
                  _parent_gui->SelectAnalysisClass();
                  break;
               case generate_class_filtered_analysis:
                  _parent_gui->NewFilteredAnalysisClass();
                  break;
               case generate_class_simulation_analysis:
                  _parent_gui->NewSimulatedAnalysisClass();
                  break;
            }
         }
      };
      analysis_struct analysis{_parent_gui};
 
      struct filter_struct {
         KVSimDirGUI* _parent_gui;
         filter_struct(KVSimDirGUI* s) : _parent_gui{s} {}
         TString type = "filter_struct";
         TGPopupMenu* menu;
         TGPopupMenu* geometry;
         TGPopupMenu* reaction;
         TGPopupMenu* run_number;
         TGPopupMenu* data_quality;
         TGPopupMenu* id_extension;
         TGPopupMenu* options;
         int ndatasets;
         int last_system;
         int last_run;
         int last_dqa = 0;
         struct DQA_entry {
            std::string name;
            TGPopupMenu* menu;
         };
 
         std::map<int, DQA_entry> DQA_map;
         enum items {
            geometric_filter,
            geo_thresh_filter,
            full_filter,
            kine_CM,
            kine_lab,
            kine_proj,
            random_phi,
            use_gemini,
            add_rot_energy,
            first_dataset = 50,
            ad_hoc_reaction = 100,
            data_quality_audits = 200,
            id_extensions = 1000,
            no_run_number = 2000
         };
         void handle_me(Int_t i)
         {
            static int last_checked_dqa = 0;
 
            if (i < first_dataset) {
               if (i >= geometric_filter && i <= full_filter) {
                  _parent_gui->FilterType(i - geometric_filter + 1);
                  options->RCheckEntry(i, geometric_filter, full_filter);
               }
               else if (i >= kine_CM && i <= kine_proj) {
                  _parent_gui->Kinematics(i - kine_CM + 1);
                  options->RCheckEntry(i, kine_CM, kine_proj);
               }
               else if (i == random_phi) {
                  if (options->IsEntryChecked(random_phi)) {
                     _parent_gui->SetRandomPhi(false);
                     options->UnCheckEntry(random_phi);
                  }
                  else {
                     _parent_gui->SetRandomPhi(true);
                     options->CheckEntry(random_phi);
                  }
               }
               else if (i == use_gemini) {
                  if (options->IsEntryChecked(use_gemini)) {
                     _parent_gui->SetGeminiDecay(false);
                     options->UnCheckEntry(use_gemini);
                     options->UnCheckEntry(add_rot_energy);
                     options->DisableEntry(add_rot_energy);
                  }
                  else {
                     _parent_gui->SetGeminiDecay(true);
                     options->CheckEntry(use_gemini);
                     options->EnableEntry(add_rot_energy);
                  }
               }
               else if (i == add_rot_energy) {
                  if (options->IsEntryChecked(add_rot_energy)) {
                     _parent_gui->SetGeminiDecayAddRotEnergy(false);
                     options->UnCheckEntry(add_rot_energy);
                  }
                  else {
                     _parent_gui->SetGeminiDecayAddRotEnergy(true);
                     options->CheckEntry(add_rot_energy);
                  }
               }
            }
            else if (i < ad_hoc_reaction) {
               geometry->RCheckEntry(i, first_dataset, first_dataset + ndatasets);
               gSystem->ProcessEvents();
               _parent_gui->SelectDataSet(gDataSetManager->GetDataSet(i - first_dataset)->GetName());
            }
            else if (i < data_quality_audits) {
               switch (i) {
                  case ad_hoc_reaction: {
                        bool ok_pressed = true;
                        TString answer = "[Projectile]+[Target]@[Energy]MeV/A";
                        new KVInputDialog(_parent_gui->MainFrame,
                                          "Enter ad hoc reaction:",
                                          &answer, &ok_pressed,
                                          "example: 129Xe+119Sn@50.0MeV/A");
                        if (ok_pressed) {
                           _parent_gui->SetCustomKinematics(true);
                           _parent_gui->fReactionKinematics = answer;
                           _parent_gui->SelectSystem("");
                        }
                        break;
                     }
                  default:
                     _parent_gui->SelectSystem(reaction->GetEntry(i)->GetName());
                     _parent_gui->fReactionKinematics = ""; //remove any previous ad hoc reaction kinematics
                     _parent_gui->SetCustomKinematics(false);
               }
               reaction->RCheckEntry(i, ad_hoc_reaction, last_system);
            }
            else if (i < id_extensions) {
               if (last_checked_dqa) DQA_map[last_checked_dqa].menu->UnCheckEntry(last_checked_dqa);
               DQA_map[i].menu->CheckEntry(i);
               last_checked_dqa = i;
               _parent_gui->fDataQualityAudit = DQA_map[i].name;
               _parent_gui->SelectDataQualityAudit();
            }
            else if (i < no_run_number) {
               if (id_extension->IsEntryChecked(i))
                  id_extension->UnCheckEntry(i);
               else
                  id_extension->CheckEntry(i);
            }
            else if (i >= no_run_number) { // run number
               _parent_gui->fRun = i - no_run_number;
               run_number->RCheckEntry(i, no_run_number, last_run);
            }
 
            _parent_gui->SetFilterStatusBar();
         }
      };
      filter_struct filter{_parent_gui};
 
      TGPopupMenu* add_popup(const char* name, TGPopupMenu* parent)
      {
         auto pop = new TGPopupMenu(gClient->GetDefaultRoot());
         parent->AddPopup(name, pop);
         return pop;
      }
      TGPopupMenu* add_popup(const char* name)
      {
         return menu_bar->AddPopup(name);
      }
      template<typename menu_type>
      void handle_menu(menu_type& m)
      {
         m.menu->Connect("Activated(Int_t)", Form("KVSimDirGUI::menu_struct::%s", m.type.Data()), &m, "handle_me(Int_t)");
      }
   };
   menu_struct menus;
   void SetFilterMode()
   {
      fFilterMode = true;
      fAnalysisMode = false;
      menus.menu_bar->RemovePopup("Analysis");
      menus.menu_bar->AddPopup("&Filtering", menus.filter.menu, &menus.layout);
      menus.menu_bar->Layout();
      SetFilterStatusBar();
   }
   bool IsFilterMode() const
   {
      return fFilterMode;
   }
   void SetAnalysisMode()
   {
      fFilterMode = false;
      fAnalysisMode = true;
      menus.menu_bar->RemovePopup("Filtering");
      menus.menu_bar->AddPopup("&Analysis", menus.analysis.menu, &menus.layout);
      menus.menu_bar->Layout();
      SetAnalysisStatusBar();
   }
   bool IsAnalysisMode() const
   {
      return fAnalysisMode;
   }
 
   KVSimDirGUI();
 
   void Exit()
   {
      gApplication->Terminate();
   }
 
   void AddSimDir();
   void RemSimDir();
   void RefreshSimDir();
   void FillTreeList();
   void EmptyTreeList();
   void SelectSimDir(TGListTreeItem*, Int_t);
 
   void EnableEventNumberEntry(Bool_t);
   void SelectAnalysisClass();
   void RunAnalysis(const TString& type);
 
   void SelectDataSet(const char*);
   void SelectSystem(const char*);
   void SelectDataQualityAudit();
   void UpdateSystemText(const char*);
   void FilterType(Int_t i)
   {
      fFilterType = i;
   }
   void GeoType(Int_t i)
   {
      fGeoType = i;
   }
   void Kinematics(Int_t i)
   {
      fKine = i;
   }
   void SetCustomKinematics(Bool_t on)
   {
      fCustomKinematics = on;
   }
   void SetRandomPhi(Bool_t on)
   {
      fRandomPhi = on;
   }
   void SetGeminiDecay(Bool_t on)
   {
      fGemDecay = on;
   }
   void SetGeminiDecayAddRotEnergy(Bool_t on)
   {
      fGemAddRotEner = on;
   }
   void SetGeminiDecayPerEvent(Int_t N)
   {
      fGemDecayPerEvent = N;
   }
 
   void Run();
   void EnableProof()
   {
      fWithPROOF = kTRUE;
      proof_analysis->SetDown(kTRUE);
   }
   void DisableProof()
   {
      fWithPROOF = kFALSE;
      proof_analysis->SetDown(kFALSE);
   }
 
   void ImportSimulation();
   void NewFilteredAnalysisClass();
   void NewSimulatedAnalysisClass();
   Bool_t WarningBox(const char* title, const char* msg, Bool_t confirm);
 
   void SetFilterStatusBar();
   void SetAnalysisStatusBar();
 
   ClassDefOverride(KVSimDirGUI, 0) //GUI for simulated data
   TString GetKinematicsString();
   TString GetFilterTypeString();
   void AddAuxDir(TGListTreeItem* simdir, Int_t);
private:
   void fill_dqa_menus_for_dataset(const KVDataSet* ds);
};
 
#endif