KVSimDirGUI.cpp

//Created by KVClassFactory on Wed Jul 18 11:55:11 2012
//Author: John Frankland,,,
 
#include "KVUnownedList.h"
#include "KVSimDirGUI.h"
#include "KVDataSetManager.h"
#include "KVBatchSystemManager.h"
#include "KVDataSet.h"
#include "KVDBSystem.h"
#include "KVDBRun.h"
#include "KVSimFile.h"
#include "KVFileDialog.h"
#include "KVInputDialog.h"
#include "KV2Body.h"
#include "TGLabel.h"
#include "TGButtonGroup.h"
#include "TGMsgBox.h"
#include "TSystem.h"
#include <KVDataAnalyser.h>
#include <KVSimDirFilterAnalyser.h>
#include <KVSimReader.h>
#include <TG3DLine.h>
#include <iostream>
using namespace std;
 
#include "KVBatchSystemParametersGUI.h"
#include "KVDropDownDialog.h"
 
ClassImp(KVSimDirGUI)
 
#ifdef WITH_RSQLITE
 
 
TString KVSimDirGUI::AddTableForDataSet(KVSimDir* sd, int ds_table_number)
{
   // Add a new dataset table for the given KVSimDir object
 
   TString ds_table_name = Form("Table_%d", ds_table_number);
   KVSQLite::table DStable(ds_table_name);
   DStable.add_column("Id", KVSQLite::column_type::INTEGER);
   DStable.primary_key("Id");
   DStable.add_column("FileName", KVSQLite::column_type::TEXT);
   DStable.add_column("TreeInfo", KVSQLite::column_type::TEXT);
   DStable.add_column("AuxDir", KVSQLite::column_type::INTEGER);
   DStable.add_column("Filtered", KVSQLite::column_type::INTEGER);
   DStable.add_column("Events", KVSQLite::column_type::INTEGER);
   DStable.add_column("DataSet", KVSQLite::column_type::TEXT);
   DStable.add_column("System", KVSQLite::column_type::TEXT);
   DStable.add_column("Run", KVSQLite::column_type::INTEGER);
   DStable.add_column("TreeName", KVSQLite::column_type::TEXT);
   DStable.add_column("BranchName", KVSQLite::column_type::TEXT);
   DStable.add_column("OrigFile", KVSQLite::column_type::TEXT);
   DStable.add_column("FiltType", KVSQLite::column_type::TEXT);
   DStable.add_column("DataQualityAudit", KVSQLite::column_type::TEXT);
   DStable.add_column("Gemini", KVSQLite::column_type::INTEGER);
   DStable.add_column("GemDecayPerEvent", KVSQLite::column_type::INTEGER);
   fConfigDB.add_table(DStable);
   // update name of dataset table in main table
   fConfigDB["Datasets"]["Table"] = ds_table_name;
   fConfigDB.update("Datasets", "Table", Form("Name=\"%s\"", sd->GetName()));
   return ds_table_name;
}
 
 
 
 
void KVSimDirGUI::FillDataSetTableWithInfos(TString ds_table_name, KVSimDir* sd)
{
   // backwards-compatibility: add missing 'AuxDir' and 'DataQualityAudit' columns
   // to table for each dataset
   if(!fConfigDB[ds_table_name].has_column("AuxDir"))
      fConfigDB.add_column(ds_table_name, "AuxDir", "INTEGER");
   if(!fConfigDB[ds_table_name].has_column("DataQualityAudit"))
      fConfigDB.add_column(ds_table_name, "DataQualityAudit", "TEXT");
   fConfigDB.prepare_data_insertion(ds_table_name);
   KVSQLite::table& dstable = fConfigDB[ds_table_name];
   if (sd->GetSimDataList()->GetEntries()) {
      TIter it1(sd->GetSimDataList());
      KVSimFile* sf = nullptr;
      while ((sf = (KVSimFile*)it1())) {
         dstable["Id"].set_null();
         dstable["FileName"] = sf->GetName();
         dstable["TreeInfo"] = sf->GetTitle();
         dstable["AuxDir"] = (int)sd->IsFromAuxDirectory(sf);
         dstable["Filtered"] = 0;
         dstable["Events"] = (Int_t)sf->GetEvents();
         dstable["TreeName"] = sf->GetTreeName();
         dstable["BranchName"] = sf->GetBranchName();
         fConfigDB.insert_data_row();
      }
   }
   if (sd->GetFiltDataList()->GetEntries()) {
      TIter it1(sd->GetFiltDataList());
      KVSimFile* sf = nullptr;
      while ((sf = (KVSimFile*)it1())) {
         dstable["Id"].set_null();
         dstable["FileName"] = sf->GetName();
         dstable["TreeInfo"] = sf->GetTitle();
         dstable["AuxDir"] = (int)sd->IsFromAuxDirectory(sf);
         dstable["Filtered"] = 1;
         dstable["Events"] = (Int_t)sf->GetEvents();
         dstable["TreeName"] = sf->GetTreeName();
         dstable["BranchName"] = sf->GetBranchName();
         dstable["DataSet"] = sf->GetDataSet();
         dstable["System"] = sf->GetSystem();
         dstable["Run"] = sf->GetRun();
         dstable["FiltType"] = sf->GetFilterType();
         dstable["DataQualityAudit"] = sf->GetDataQualityAudit();
         dstable["OrigFile"] = sf->GetOriginalFile();
         dstable["Gemini"] = sf->IsGemini();
         dstable["GemDecayPerEvent"] = sf->GetGemDecayPerEvent();
         fConfigDB.insert_data_row();
      }
   }
   fConfigDB.end_data_insertion();
}
 
#endif
 
 
 
KVSimDirGUI::KVSimDirGUI()
   : fGuirc(".kvsimdirguirc")
#ifdef WITH_RSQLITE
   , fConfigDB(gSystem->ExpandPathName("$(HOME)/.kvsimdirguidb"))
#endif
   , menus {this}
{
   // Default constructor
   // main frame
 
   fSelectedSimDir = nullptr;
   fWithPROOF = kFALSE;
 
   // make Aclic create all *.so *.d files in separate temporary directories
   //this is to avoid problems with KVParticleCondition when using PROOF
   gSystem->SetBuildDir(gSystem->TempDirectory());
 
   MainFrame = new TGMainFrame(gClient->GetRoot(), 10, 10, kMainFrame | kVerticalFrame);
   MainFrame->SetName("KaliVedaSim GUI");
   MainFrame->SetWindowName("KaliVedaSim GUI");
   MainFrame->Connect("CloseWindow()", "KVSimDirGUI", this, "Exit()");
 
   // create menu bar
   menus.menu_bar = new TGMenuBar(MainFrame, 1, 1, kHorizontalFrame);
 
   // mode menu
   menus.mode.menu = menus.add_popup("&Mode");
   menus.mode.menu->AddEntry("Analysis", menus.mode.analysis);
   menus.mode.menu->AddEntry("Filter", menus.mode.filter);
   menus.mode.menu->RCheckEntry(menus.mode.analysis, menus.mode.analysis, menus.mode.filter);
   menus.handle_menu(menus.mode);
 
   // analysis menu
   menus.analysis.menu = menus.add_popup("&Analysis");
   menus.analysis.menu->AddEntry("Select analysis class", menus.analysis.select_analysis_class);
   menus.analysis.menu->AddSeparator();
   menus.analysis.generate = menus.add_popup("Generate analysis class...", menus.analysis.menu);
   menus.analysis.generate->AddEntry("simulation", menus.analysis.generate_class_simulation_analysis);
   menus.analysis.generate->AddEntry("filtered", menus.analysis.generate_class_filtered_analysis);
 
   menus.handle_menu(menus.analysis);
 
   // filtering menu
   menus.filter.menu = menus.add_popup("&Filtering");
   menus.filter.geometry = menus.add_popup("Detector geometry", menus.filter.menu);
   if (!gDataSetManager) {
      KVDataSetManager* dsm = new KVDataSetManager;
      dsm->Init();
   }
   // datasets have id = 100 + i where i can be given to gDataSetManager->GetDataSet(i)
   menus.filter.ndatasets = gDataSetManager->GetNtotal();
   for (int i = 0; i < menus.filter.ndatasets; i++)
      menus.filter.geometry->AddEntry(gDataSetManager->GetDataSet(i)->GetName(), menus.filter.first_dataset + i);
 
   menus.filter.reaction = menus.add_popup("Entrance channel", menus.filter.menu);
   menus.filter.reaction->AddEntry("Ad hoc...", menus.filter.ad_hoc_reaction);
 
   menus.filter.run_number = menus.add_popup("Run number", menus.filter.menu);
   menus.filter.run_number->AddEntry("[None]", menus.filter.no_run_number);
 
   menus.handle_menu(menus.filter);
 
   menus.filter.data_quality = menus.add_popup("Detector performances", menus.filter.menu);
   for(int i = 0; i<gDataSetManager->GetNtotal(); ++i)
      fill_dqa_menus_for_dataset(gDataSetManager->GetDataSet(i));
 
   menus.filter.id_extension = menus.add_popup("Extend ID range...", menus.filter.menu);
 
   menus.filter.options = menus.add_popup("Options", menus.filter.menu);
   menus.filter.options->AddLabel("Filter type");
   menus.filter.options->AddSeparator();
   menus.filter.options->AddEntry("Geometric", menus.filter.geometric_filter);
   menus.filter.options->AddEntry("Geo+Thresholds", menus.filter.geo_thresh_filter);
   //menus.filter.options->AddEntry("Full", menus.filter.full_filter);
   menus.filter.options->AddSeparator();
   menus.filter.options->AddLabel("Kinematics");
   menus.filter.options->AddSeparator();
   menus.filter.options->AddEntry("CM", menus.filter.kine_CM);
   menus.filter.options->AddEntry("Lab", menus.filter.kine_lab);
   menus.filter.options->AddEntry("Projectile", menus.filter.kine_proj);
   menus.filter.options->AddSeparator();
   menus.filter.options->AddLabel("Rotation");
   menus.filter.options->AddSeparator();
   menus.filter.options->AddEntry("Randomize phi", menus.filter.random_phi);
   menus.filter.options->AddSeparator();
   menus.filter.options->AddLabel("Secondary decay");
   menus.filter.options->AddSeparator();
   menus.filter.options->AddEntry("Use Gemini++", menus.filter.use_gemini);
   menus.filter.options->AddEntry("Add Erot to E*", menus.filter.add_rot_energy);
 
   // set default options
   FilterType(kFTSeuils);
   menus.filter.options->RCheckEntry(menus.filter.geo_thresh_filter, menus.filter.geometric_filter, menus.filter.full_filter);
   Kinematics(kKCM);
   menus.filter.options->RCheckEntry(menus.filter.kine_CM, menus.filter.kine_CM, menus.filter.kine_proj);
   SetRandomPhi(true);
   menus.filter.options->CheckEntry(menus.filter.random_phi);
   SetGeminiDecay(false);
   menus.filter.options->UnCheckEntry(menus.filter.use_gemini);
   menus.filter.options->DisableEntry(menus.filter.add_rot_energy);
 
   fFilterMode = false;
   fAnalysisMode = true;
   menus.menu_bar->RemovePopup("Filtering");
 
   // add menu bar to main frame
   MainFrame->AddFrame(menus.menu_bar);//, new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 0, 0, 1, 1));
   auto lh = new TGHorizontal3DLine(MainFrame);
   MainFrame->AddFrame(lh, new TGLayoutHints(kLHintsTop | kLHintsExpandX));
 
   // status bar
   fStatusBar = new TGStatusBar(MainFrame);
   MainFrame->AddFrame(fStatusBar, new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX));
 
   SetAnalysisStatusBar();
 
   TGHorizontalFrame* hftop = new TGHorizontalFrame(MainFrame, 10, 10, kHorizontalFrame);
 
   TGCompositeFrame* vf = new TGVerticalFrame(hftop, 200, 500, kVerticalFrame);
   // sim dir buttons
   TGCompositeFrame* hf = new TGHorizontalFrame(vf, 10, 10, kHorizontalFrame);
   BaddDir = new TGPictureButton(hf, gClient->GetPicture("package_add.xpm"));
   hf->AddFrame(BaddDir, new TGLayoutHints(kLHintsLeft | kLHintsTop, 3, 2, 2, 2));
   BaddDir->Resize(40, 40);
   BaddDir->SetToolTipText("Add dataset");
   BaddDir->Connect("Clicked()", "KVSimDirGUI", this, "AddSimDir()");
   BimpSim = new TGPictureButton(hf, gClient->GetPicture("bld_text.xpm"));
   hf->AddFrame(BimpSim, new TGLayoutHints(kLHintsLeft | kLHintsTop, 2, 2, 2, 2));
   BimpSim->Resize(40, 40);
   BimpSim->SetToolTipText("Import simulation");
   BimpSim->Connect("Clicked()", "KVSimDirGUI", this, "ImportSimulation()");
   BremDir = new TGPictureButton(hf, gClient->GetPicture("package_delete.xpm"));
   hf->AddFrame(BremDir, new TGLayoutHints(kLHintsLeft | kLHintsTop, 2, 2, 2, 2));
   BremDir->Resize(40, 40);
   BremDir->SetToolTipText("Remove dataset");
   BremDir->Connect("Clicked()", "KVSimDirGUI", this, "RemSimDir()");
   BrefreshDir = new TGPictureButton(hf, gClient->GetPicture("refresh2.xpm"));
   hf->AddFrame(BrefreshDir, new TGLayoutHints(kLHintsLeft | kLHintsTop, 2, 2, 2, 2));
   BrefreshDir->Resize(40, 40);
   BrefreshDir->SetToolTipText("Update");
   BrefreshDir->Connect("Clicked()", "KVSimDirGUI", this, "RefreshSimDir()");
   BimpSim->SetEnabled(kFALSE);
   BremDir->SetEnabled(kFALSE);
   BrefreshDir->SetEnabled(kFALSE);
 
   vf->AddFrame(hf, new TGLayoutHints(kLHintsTop | kLHintsLeft, 2, 2, 2, 2));
 
   // canvas widget
   fDirListCanvas = new TGCanvas(vf, 172, 400);
   // canvas viewport
   fDirListViewPort = fDirListCanvas->GetViewPort();
   // list tree
   fDirListTree = new TGListTree(fDirListCanvas, kHorizontalFrame);
 
   popen = gClient->GetPicture("package_add.xpm");
   pclose = gClient->GetPicture("package_add.xpm");
 
   fDirListViewPort->AddFrame(fDirListTree);
   fDirListTree->SetLayoutManager(new TGHorizontalLayout(fDirListTree));
   fDirListTree->MapSubwindows();
   fDirListTree->Connect("Clicked(TGListTreeItem*,Int_t)", "KVSimDirGUI", this, "SelectSimDir(TGListTreeItem*,Int_t)");
   fDirListTree->Connect("DoubleClicked(TGListTreeItem*,Int_t)", "KVSimDirGUI", this,  "AddAuxDir(TGListTreeItem*,Int_t)");
   fDirListCanvas->SetContainer(fDirListTree);
   fDirListCanvas->MapSubwindows();
   vf->AddFrame(fDirListCanvas, new TGLayoutHints(kLHintsTop | kLHintsExpandY, 5, 2, 2, 10));
 
   hftop->AddFrame(vf, new TGLayoutHints(kLHintsExpandY | kLHintsTop, 2, 2, 2, 2));
 
   /* lists of data in simdir */
   vf = new TGVerticalFrame(hftop, 600, 500, kVerticalFrame);
   TGGroupFrame* group = new TGGroupFrame(vf, "Simulations");
   fLVsimData = new KVListView(KVSimFile::Class(), group, 550, 200);
   fLVsimData->SetDataColumns(3);
   fLVsimData->SetDataColumn(0, "Name");
   fLVsimData->SetDataColumn(1, "Info", "GetTitle");
   fLVsimData->SetDataColumn(2, "Events");
   fLVsimData->ActivateSortButtons();
   fLVsimData->AllowContextMenu(kFALSE);
   group->AddFrame(fLVsimData, new TGLayoutHints(kLHintsTop | kLHintsExpandX | kLHintsExpandY, 5, 5, 10, 10));
   vf->AddFrame(group, new TGLayoutHints(kLHintsTop | kLHintsExpandX | kLHintsExpandY, 2, 2, 2, 2));
   group = new TGGroupFrame(vf, "Filtered Simulations");
   fLVfiltData = new KVListView(KVSimFile::Class(), group, 550, 200);
   fLVfiltData->SetDataColumns(9);
   fLVfiltData->SetDataColumn(0, "Simulation", "GetOriginalFile");
   fLVfiltData->SetDataColumn(1, "DataSet/Geometry", "GetDataSet");
   fLVfiltData->SetDataColumn(2, "System/Kinematics", "GetSystem");
   fLVfiltData->SetDataColumn(3, "Run");
   fLVfiltData->SetDataColumn(4, "FilterType");
   fLVfiltData->SetDataColumn(5, "Detector performances", "GetDataQualityAudit");
   fLVfiltData->SetDataColumn(6, "Gemini", "IsGemini");
   fLVfiltData->SetDataColumn(7, "Decay/event", "GetGemDecayPerEvent");
   fLVfiltData->SetDataColumn(8, "Events");
   fLVfiltData->ActivateSortButtons();
   fLVfiltData->AllowContextMenu(kFALSE);
   group->AddFrame(fLVfiltData, new TGLayoutHints(kLHintsTop | kLHintsExpandX | kLHintsExpandY, 5, 5, 10, 10));
   vf->AddFrame(group, new TGLayoutHints(kLHintsTop | kLHintsExpandX | kLHintsExpandY, 2, 2, 2, 2));
 
   hftop->AddFrame(vf, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10, 10, 10, 10));
   MainFrame->AddFrame(hftop, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 1, 1, 1, 1));
 
   vf = new TGVerticalFrame(MainFrame, 600, 200, kVerticalFrame);
   hf = new TGHorizontalFrame(vf, 600, 200, kHorizontalFrame);
 
   auto lab = new TGLabel(hf, "Events : ");
   hf->AddFrame(lab, new TGLayoutHints(kLHintsCenterY | kLHintsLeft, 2, 2, 2, 2));
   fCBAllEvents = new TGCheckButton(hf, "all");
   hf->AddFrame(fCBAllEvents, new TGLayoutHints(kLHintsCenterY | kLHintsLeft, 2, 2, 2, 2));
   fNENumberEvents = new TGNumberEntry(hf, 1, 10, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEAPositive, TGNumberFormat::kNELLimitMin, 1);
   hf->AddFrame(fNENumberEvents, new TGLayoutHints(kLHintsCenterY | kLHintsLeft, 2, 2, 2, 2));
   fCBAllEvents->Connect("Toggled(Bool_t)", "KVSimDirGUI", this, "EnableEventNumberEntry(Bool_t)");
   fCBAllEvents->SetState(kButtonDown, kTRUE);
 
   proof_analysis = new TGPictureButton(hf, gClient->GetPicture("proof_base.xpm"));
   proof_analysis->Connect("Pressed()", "KVSimDirGUI", this, "EnableProof()");
   proof_analysis->Connect("Released()", "KVSimDirGUI", this, "DisableProof()");
   if (!gBatchSystemManager) new KVBatchSystemManager;
   gBatchSystemManager->GetDefaultBatchSystem()->cd();
   proof_analysis->SetToolTipText(gBatchSystem->GetTitle());
   proof_analysis->Resize(40, 40);
   proof_analysis->AllowStayDown(kTRUE);
 
   TGPictureButton* launch_analysis = new TGPictureButton(hf, gClient->GetPicture("query_submit.xpm"));
   launch_analysis->Connect("Clicked()", "KVSimDirGUI", this, "Run()");
   launch_analysis->SetToolTipText("Run analysis/filter");
   launch_analysis->Resize(40, 40);
 
   hf->AddFrame(launch_analysis, new TGLayoutHints(kLHintsCenterY | kLHintsRight, 5, 2, 2, 2));
   hf->AddFrame(proof_analysis, new TGLayoutHints(kLHintsCenterY | kLHintsRight, 5, 2, 2, 2));
 
   vf->AddFrame(hf, new TGLayoutHints(kLHintsExpandX | kLHintsTop, 0, 0, 0, 0));
   MainFrame->AddFrame(vf, new TGLayoutHints(kLHintsExpandX | kLHintsTop, 10, 10, 15, 10));
 
 
   MainFrame->SetMWMHints(kMWMDecorAll,
                          kMWMFuncAll,
                          kMWMInputModeless);
   MainFrame->MapSubwindows();
 
   MainFrame->Resize(MainFrame->GetDefaultSize());
   MainFrame->MapWindow();
   // MainFrame->Resize(200,500);
#ifdef WITH_RSQLITE
   // define tables in DB if not already done
   bool sqlite_conversion = false;
   if (!fConfigDB.get_number_of_tables()) {
      sqlite_conversion = true;
      KVSQLite::table datasets("Datasets");
      datasets.add_column("Id", "INTEGER");
      datasets.primary_key("Id");
      datasets.add_column("Name", "TEXT");
      datasets.add_column("Directory", "TEXT");
      datasets.add_column("AuxDir", "TEXT");
      datasets.add_column("Table", "TEXT");
      fConfigDB.add_table(datasets);
   }
   if (!sqlite_conversion) {
      // check Datasets table has AuxDir column
      if (!fConfigDB["Datasets"].has_column("AuxDir"))
         fConfigDB.add_column("Datasets", "AuxDir", "TEXT");
      // use existing sqlite database to reconstruct simdirs
      ReconstructSimDirsFromDB();
      FillTreeList();
      return;
   }
#endif
   // use .guirc to fill the list of sim dirs
   KVString simdirs = fGuirc.GetValue("SimDirs", "");
   if (simdirs != "") {
#ifdef WITH_RSQLITE
      if (sqlite_conversion) {
         // we are converting from the old TEnv back end to sqlite
         // need to fill table of Datasets
         fConfigDB.prepare_data_insertion("Datasets");
      }
      int ds_table = 0;
#endif
      simdirs.Begin(" ");
      std::unordered_map<std::string,int> simdirs_to_remove;
      while (!simdirs.End()) {
         KVString simdir = simdirs.Next();
         KVString simdirectory = fGuirc.GetValue(Form("%s.Directory", simdir.Data()), "");
         // check for stale (removed) directories!
         if(gSystem->AccessPathName(simdirectory))
         {
            KVError::Warning(this, "KVSimDirGUI", "Dataset %s: directory %s no longer exists [CLEANUP]",
                             simdir.Data(), simdirectory.Data());
            ++simdirs_to_remove[simdir.Data()];
            remove_dataset_from_sqlitedb(simdir.Data());
            continue;
         }
         KVSimDir* sd = new KVSimDir(simdir, simdirectory);
#ifdef WITH_RSQLITE
         if (sqlite_conversion) {
            fConfigDB["Datasets"]["Name"] = simdir;
            fConfigDB["Datasets"]["Directory"] = simdirectory;
            fConfigDB["Datasets"]["AuxDir"].set_null();
            fConfigDB.insert_data_row();
         }
#endif
         sd->AnalyseDirectory();
         fListOfDirs.Add(sd);
      }
      if(simdirs_to_remove.size())
      {
         KVString new_sim_dirs;
         simdirs.Begin(" ");
         while(!simdirs.End())
         {
            auto simdirectory = simdirs.Next(kTRUE);
            if(auto search = simdirs_to_remove.find(simdirectory.Data()); search == simdirs_to_remove.end())
            {
               if(new_sim_dirs.Length())
                  new_sim_dirs.Append(" ");
               new_sim_dirs += simdirectory;
            }
            simdirs = new_sim_dirs;
            fGuirc.SetValue("SimDirs", simdirs);
            fGuirc.SaveLevel(kEnvUser);
         }
      }
#ifdef WITH_RSQLITE
      if (sqlite_conversion) {
         fConfigDB.end_data_insertion();
         TIter itdir(&fListOfDirs);
         KVSimDir* sd = nullptr;
         while ((sd = (KVSimDir*)itdir())) {
            // add table for dataset
            TString ds_table_name = AddTableForDataSet(sd, ds_table);
            // fill table with infos
            FillDataSetTableWithInfos(ds_table_name, sd);
            ++ds_table;
         }
      }
#endif
      FillTreeList();
   }
}
 
 
 
 
void KVSimDirGUI::FillTreeList()
{
   EmptyTreeList();
   TIter next(&fListOfDirs);
   TObject* o;
   while ((o = next())) {
      TGListTreeItem* item0 = fDirListTree->AddItem(NULL, o->GetName());
      item0->SetPictures(popen, pclose);
      fDirListTree->CloseItem(item0);
   }
}
 
 
 
 
void KVSimDirGUI::EmptyTreeList()
{
   TGListTreeItem* first = fDirListTree->GetFirstItem();
   while (first) {
      fDirListTree->DeleteItem(first);
      first = fDirListTree->GetFirstItem();
   }
   BremDir->SetEnabled(kFALSE);
   BimpSim->SetEnabled(kFALSE);
   BrefreshDir->SetEnabled(kFALSE);
}
 
 
 
 
void KVSimDirGUI::AddSimDir()
{
   static TString dir(".");
   TGFileInfo fi;
   fi.fIniDir = StrDup(dir);
   new KVFileDialog(gClient->GetDefaultRoot(), MainFrame, kKVFDDirectory, &fi);
   if (fi.fFilename) {
      TString simdirname;
      Bool_t ok;
      TString quest;
      quest.Form("Enter name for dataset %s", fi.fIniDir);
      new KVInputDialog(MainFrame, quest, &simdirname, &ok);
      simdirname.ReplaceAll(" ", "_"); //no spaces in name
      if (ok) {
         KVSimDir* sd = new KVSimDir(simdirname, fi.fIniDir);
         sd->AnalyseDirectory();
         fListOfDirs.Add(sd);
         FillTreeList();
         fLVsimData->Display(sd->GetSimDataList());
         fLVfiltData->Display(sd->GetFiltDataList());
         // add to guirc file
         TString simdirs = fGuirc.GetValue("SimDirs", "");
         if (simdirs != "") simdirs += " ";
         simdirs += simdirname;
         fGuirc.SetValue("SimDirs", simdirs);
         fGuirc.SetValue(Form("%s.Directory", simdirname.Data()), sd->GetDirectory());
         fGuirc.SaveLevel(kEnvUser);
#ifdef WITH_RSQLITE
         //update database
         int ds_table_num = 0;
         if (fConfigDB.count("Datasets")) {
            // get name/number of last dataset table
            KVNameValueList table_names = fConfigDB.get_name_value_list("Datasets", "Name", "Table");
            // don't assume tables are sorted according to table number!
            for(auto& par : table_names)
            {
               int tab_num = -1;
               if(sscanf(par.GetString(), "Table_%d", &tab_num)==1)
                  if(tab_num>ds_table_num) ds_table_num=tab_num;
            }
            ++ds_table_num;
         }
         fConfigDB.prepare_data_insertion("Datasets");
         fConfigDB["Datasets"]["Name"] = simdirname;
         fConfigDB["Datasets"]["Directory"] = sd->GetDirectory();
         fConfigDB["Datasets"]["AuxDir"].set_null();
         fConfigDB.insert_data_row();
         fConfigDB.end_data_insertion();
         TString table_name = AddTableForDataSet(sd, ds_table_num);
         FillDataSetTableWithInfos(table_name, sd);
#endif
      }
   }
   dir = fi.fIniDir;
}
 
 
 
 
void KVSimDirGUI::RefreshSimDir()
{
   if (!fSelectedSimDir) return;
   fSelectedSimDir->AnalyseDirectory();
   fLVsimData->Display(fSelectedSimDir->GetSimDataList());
   fLVfiltData->Display(fSelectedSimDir->GetFiltDataList());
#ifdef WITH_RSQLITE
   fConfigDB.select_data("Datasets", "Table", Form("Name=\"%s\"", fSelectedSimDir->GetName()));
   TString ds_table_name;
   while (fConfigDB.get_next_result()) ds_table_name = fConfigDB["Datasets"]["Table"].get_data<TString>();
   fConfigDB.clear_table(ds_table_name);
   FillDataSetTableWithInfos(ds_table_name, fSelectedSimDir);
#endif
}
 
 
 
 
void KVSimDirGUI::remove_dataset_from_sqlitedb(const Char_t* ds_name)
{
#ifdef WITH_RSQLITE
   fConfigDB.select_data("Datasets", "Table", Form("Name = '%s'", ds_name));
   TString ds_table_name;
   while (fConfigDB.get_next_result()) ds_table_name = fConfigDB["Datasets"]["Table"].get_data<TString>();
   fConfigDB.delete_rows_in_table("Datasets", Form("Name = '%s'", ds_name));
   // and delete table with dataset data
   fConfigDB.delete_table(ds_table_name);
#endif
}
 
 
 
 
void KVSimDirGUI::RemSimDir()
{
   if (!fSelectedSimDir) return;
   fListOfDirs.Remove(fSelectedSimDir);
   // there is no way of removing a name-value pair from a TEnv!!
   fGuirc.SetValue(Form("%s.Directory", fSelectedSimDir->GetName()), "");
 
   // remove from datasets table
   remove_dataset_from_sqlitedb(fSelectedSimDir->GetName());
 
   delete fSelectedSimDir;
   fSelectedSimDir = nullptr;
   FillTreeList();
   fLVsimData->RemoveAll();
   fLVfiltData->RemoveAll();
   // update guirc file
   TString simdirs = "";
   TIter next(&fListOfDirs);
   KVSimDir* togo;
   while ((togo = (KVSimDir*)next())) {
      if (simdirs != "") simdirs += " ";
      simdirs += togo->GetName();
      fGuirc.SetValue(Form("%s.Directory", togo->GetName()), togo->GetDirectory());
   }
   fGuirc.SetValue("SimDirs", simdirs);
   fGuirc.SaveLevel(kEnvUser);
}
 
 
 
 
void KVSimDirGUI::SelectSimDir(TGListTreeItem* simdir, Int_t)
{
   fSelectedSimDir = (KVSimDir*)fListOfDirs.FindObject(simdir->GetText());
   if (fSelectedSimDir) {
      fLVsimData->Display(fSelectedSimDir->GetSimDataList());
      fLVfiltData->Display(fSelectedSimDir->GetFiltDataList());
      BremDir->SetEnabled();
      BimpSim->SetEnabled();
      BrefreshDir->SetEnabled();
   }
   else {
      BremDir->SetEnabled(kFALSE);
      BimpSim->SetEnabled(kFALSE);
      BrefreshDir->SetEnabled(kFALSE);
   }
}
 
 
 
void KVSimDirGUI::AddAuxDir(TGListTreeItem* simdir, Int_t)
{
   fSelectedSimDir = (KVSimDir*)fListOfDirs.FindObject(simdir->GetText());
   if (fSelectedSimDir) {
      if (!fSelectedSimDir->HasAuxDirectory()) {
         TString dir(fSelectedSimDir->GetDirectory());
         TGFileInfo fi;
         fi.fIniDir = StrDup(dir);
         new KVFileDialog(gClient->GetDefaultRoot(), MainFrame, kKVFDDirectory, &fi);
         if (fi.fFilename && TString(fi.fIniDir) != fSelectedSimDir->GetDirectory()) {
            fSelectedSimDir->SetAuxDirectory(fi.fIniDir);
            // add info to dataset table in db for next time
#ifdef WITH_RSQLITE
            fConfigDB["Datasets"]["AuxDir"] = fi.fIniDir;
            fConfigDB.update("Datasets", "AuxDir", Form("Name = '%s'", fSelectedSimDir->GetName()));
#endif
            RefreshSimDir();
         }
      }
   }
}
 
 
 
 
void KVSimDirGUI::SelectAnalysisClass()
{
   static TString dir(gSystem->pwd());
   const char* filetypes[] = {
      "Class header files", "*.h",
      0, 0
   };
   TGFileInfo fi;
   fi.fIniDir = StrDup(dir);
   fi.fFileTypes = filetypes;
   new KVFileDialog(gClient->GetDefaultRoot(), MainFrame, kKVFDOpen, &fi);
   if (fi.fFilename) {
      fAnalClass.name = gSystem->BaseName(fi.fFilename);
      Int_t idot = fAnalClass.name.Index(".");
      if (idot < 0) return;
      fAnalClass.name.Remove(idot, 2);
      if (FindClassSourceFiles(fAnalClass.name, fAnalClass.imp_file, fAnalClass.dec_file, fi.fIniDir)) {
         fAnalClass.dir_name = fi.fIniDir;
         SetAnalysisStatusBar();
      }
   }
   dir = fi.fIniDir;
}
 
 
 
 
void KVSimDirGUI::EnableEventNumberEntry(Bool_t on)
{
   fNENumberEvents->SetState(!on);
}
 
 
 
 
void KVSimDirGUI::fill_dqa_menus_for_dataset(const KVDataSet* ds)
{
//   TIter itdqa(menus.filter.data_quality->GetListOfEntries());
//   while (auto entry = (TGMenuEntry*)itdqa()) {
//      if (entry->GetPopup())
//         delete entry->GetPopup();
//      menus.filter.data_quality->DeleteEntry(entry);
//   }
//   menus.filter.DQA_map.clear();
   // fill data quality menu
   if(!menus.filter.last_dqa)
   {
      menus.filter.last_dqa = menus.filter.data_quality_audits;
      menus.filter.DQA_map[menus.filter.last_dqa] = {"", menus.filter.data_quality};
      menus.filter.data_quality->AddEntry("[none]", menus.filter.last_dqa++);
      menus.filter.DQA_map[menus.filter.last_dqa] = {"file", menus.filter.data_quality};
      menus.filter.data_quality->AddEntry("From file...", menus.filter.last_dqa++);
 
   }
   if (ds->FindDataSetFile("DataQualityAudit.root")) {
      Info("KVSimDirGUI", "Adding data quality audits for dataset %s...", ds->GetName());
      std::unique_ptr<TFile> dqaf(TFile::Open(ds->GetFullPathToDataSetFile("DataQualityAudit.root")));
      // add pop-up with name of dataset
      auto ds_popup = menus.add_popup(ds->GetName(), menus.filter.data_quality);
      std::unordered_map<std::string, TGPopupMenu*> DQA_system_popups;
      menus.filter.DQA_map[menus.filter.last_dqa] = {ds->GetName(), ds_popup/*menus.filter.data_quality*/};
      ds_popup/*menus.filter.data_quality*/->AddEntry("all reactions", menus.filter.last_dqa++);
      auto systems = ds->GetDataBase("minimal")->GetSystems();
      TIter next(systems);
      KVDBSystem* sys;
      while ((sys = (KVDBSystem*)next())) {
         if (sys->IsCollision()) {
            if (dqaf->FindKey(sys->GetBatchNameWithoutEnergy())) {
               if (DQA_system_popups.find(sys->GetBatchNameWithoutEnergy().Data()) == DQA_system_popups.end()) {
                  DQA_system_popups[sys->GetBatchNameWithoutEnergy().Data()] =
                        menus.add_popup(sys->GetReactionNameWithoutEnergy(), ds_popup /*menus.filter.data_quality*/);
                  menus.filter.DQA_map[menus.filter.last_dqa] = {Form("%s/%s", ds->GetName(), sys->GetBatchNameWithoutEnergy().Data()),
                                                                 DQA_system_popups[sys->GetBatchNameWithoutEnergy().Data()]};
                  DQA_system_popups[sys->GetBatchNameWithoutEnergy().Data()]->AddEntry("all energies", menus.filter.last_dqa++);
               }
               if (dqaf->FindKey(sys->GetBatchName())) {
                  menus.filter.DQA_map[menus.filter.last_dqa] = {Form("%s/%s", ds->GetName(), sys->GetBatchName().Data()),
                                                                 DQA_system_popups[sys->GetBatchNameWithoutEnergy().Data()]};
                  DQA_system_popups[sys->GetBatchNameWithoutEnergy().Data()]->AddEntry(sys->GetReactionEnergyWithoutName(), menus.filter.last_dqa++);
               }
            }
         }
      }
   }
}
 
 
 
 
void KVSimDirGUI::SelectDataSet(const char* name)
{
   KVDataSet* ds = gDataSetManager->GetDataSet(name);
   if (ds) {
      fDataset = name;
      fSystem = "";
      fRun = 0;
      GeoType(kGTROOT);
      auto systems = ds->GetDataBase("minimal")->GetSystems();
      TIter it(menus.filter.reaction->GetListOfEntries());
      while (auto me = (TGMenuEntry*)it()) {
         if (me->GetEntryId() != menus.filter.ad_hoc_reaction) menus.filter.reaction->DeleteEntry(me);
      }
      menus.filter.last_system = menus.filter.ad_hoc_reaction;
      if (systems) {
         TIter next(systems);
         KVDBSystem* sys;
         int i = menus.filter.ad_hoc_reaction;
         while ((sys = (KVDBSystem*)next())) {
            if (sys->IsCollision()) menus.filter.reaction->AddEntry(sys->GetName(), ++i);
         }
         menus.filter.last_system = i;
      }
   }
   else
      fDataset="";
   // update list of extendible identification telescopes
   SelectDataQualityAudit();
}
 
 
 
 
void KVSimDirGUI::SelectDataQualityAudit()
{
   // Called when a data quality audit is selected in the list.
   //
   // The name of the audit is in fDataQualityAudit: "[dataset]/[system]" or "[dataset]"
   // (if fDataQualityAudit="" this means no data quality audit, i.e. "[none]" was selected)
 
   fDataQualityAudit.Begin("/");
   auto DQA_dataset = fDataQualityAudit.Next();
 
   // remove any existing entries in 'extensible id' list
   TIter it(menus.filter.id_extension->GetListOfEntries());
   while (auto me = (TGMenuEntry*)it()) {
      menus.filter.id_extension->DeleteEntry(me);
   }
 
   // no DQA required or no dataset selected: nothing to do
   if(DQA_dataset.IsNull() || fDataset.IsNull()) return;
 
   if(DQA_dataset=="file")
   {
      // use audit in file
      static TString audit_dir(gSystem->pwd());
      const char* filetypes[] = {
         "ROOT files", "*.root",
         0, 0
      };
      TGFileInfo fi;
      fi.fIniDir = StrDup(audit_dir);
      fi.fFileTypes = filetypes;
      new KVFileDialog(gClient->GetDefaultRoot(), MainFrame, kKVFDOpen, &fi);
      if (fi.fFilename) {
         fDataQualityAudit = Form("file:%s",fi.fFilename);
         Info("SelectDataQualityAudit","path:%s",fDataQualityAudit.Data());
      }
      audit_dir = fi.fIniDir;
   }
 
   KVString arrays_with_exId = gEnv->GetValue("FilterGroupReconstructor.HasExtendibleIdentifications", "");
   if(arrays_with_exId.IsNull()) return;
 
   // we deduce the names of the arrays from the name of the dataset chosen
   // to define the detector geometry used to filter the data
   arrays_with_exId.Begin(" ");
   int i = menus.filter.id_extensions;
   while(!arrays_with_exId.End())
   {
      auto array = arrays_with_exId.Next(kTRUE);
      if(fDataset.Contains(array))
      {
         KVString exId_for_array = gEnv->GetValue(Form("%s.ExtendibleIdentifications",array.Data()),"");
         if(!exId_for_array.IsNull())
         {
            exId_for_array.Begin(" ");
            while(!exId_for_array.End())
            {
               menus.filter.id_extension->AddEntry(exId_for_array.Next(true), i++);
            }
         }
      }
   }
}
 
 
 
 
void KVSimDirGUI::SelectSystem(const char* sysname)
{
   TIter it(menus.filter.run_number->GetListOfEntries());
   while (auto me = (TGMenuEntry*)it()) {
      if (me->GetEntryId() != menus.filter.no_run_number) menus.filter.run_number->DeleteEntry(me);
   }
   menus.filter.last_run = menus.filter.no_run_number;
   fRun = 0;
   fSystem = sysname;
   KVDBSystem* sys = gDataSetManager->GetDataSet(fDataset)->GetDataBase("minimal")->GetSystem(sysname);
   if (sys) {
      for(auto p_dbr : sys->GetRuns())
      {
         auto dbr = dynamic_cast<KVDBRun*>(p_dbr);
         menus.filter.run_number->AddEntry(Form("%d", dbr->GetNumber()), dbr->GetNumber() + menus.filter.no_run_number);
         menus.filter.last_run = dbr->GetNumber() + menus.filter.no_run_number;
      }
   }
}
 
 
 
 
void KVSimDirGUI::Run()
{
   // Called when "Process" button is pressed to launch the analysis
 
   if (fAnalysisMode)
      RunAnalysis("tree");
   else if (fFilterMode) {
      if (fDataset == "") { // Make sure a dataset has been chosen
         new TGMsgBox(gClient->GetRoot(), MainFrame, "KVSimDirGUI::Run", "First choose the dataset which describes the geometry!", kMBIconExclamation);
         return;
      }
      RunAnalysis("filter");
   }
}
 
 
 
 
void KVSimDirGUI::RunAnalysis(const TString& type)
{
   auto selected_sim_runs = fLVsimData->GetSelectedObjects();
   auto selected_filt_runs = fLVfiltData->GetSelectedObjects();
   KVUnownedList runs_to_analyse, aux_runs_to_analyse;
   TString analysis_task;
   if (type == "tree") { // analysis of simulated or filtered events
      if (!selected_sim_runs.GetEntries() && !selected_filt_runs.GetEntries()) {
         new TGMsgBox(gClient->GetRoot(), MainFrame, "KVSimDirGUI::RunAnalysis", "Choose one or more simulated or filtered data files!", kMBIconExclamation);
         return;
      }
      //      if (selected_sim_runs->GetEntries() && selected_filt_runs->GetEntries()) {
      //         new TGMsgBox(gClient->GetRoot(), MainFrame, "KVSimDirGUI::RunAnalysis", "Choose EITHER simulated or filtered data files!", kMBIconExclamation);
      //         return;
      //      }
      if (!fAnalClass.with_files()) {
         new TGMsgBox(gClient->GetRoot(), MainFrame, "KVSimDirGUI::RunAnalysis", "Choose a valid analysis class!", kMBIconExclamation);
         return;
      }
      if (selected_sim_runs.GetEntries()) {
         if (selected_filt_runs.GetEntries()) {
            // if both simulated & filtered events are selected, we assume the user wants to analyse filtered
            // data while having access to the original non-filtered data as an auxiliary/"friend" tree
            runs_to_analyse = selected_filt_runs;
            analysis_task = "analysis filtered";
            aux_runs_to_analyse = selected_sim_runs;
         }
         else {
            runs_to_analyse = selected_sim_runs;
            analysis_task = "analysis simulated";
         }
      }
      else {
         runs_to_analyse = selected_filt_runs;
         analysis_task = "analysis filtered";
      }
   }
   else {
      // filtering
      if (selected_filt_runs.GetEntries()) {
         new TGMsgBox(gClient->GetRoot(), MainFrame, "KVSimDirGUI::RunFilter", "Only simulated events can be filtered!", kMBIconExclamation);
         return;
      }
      if (!selected_sim_runs.GetEntries()) {
         new TGMsgBox(gClient->GetRoot(), MainFrame, "KVSimDirGUI::RunFilter", "Choose a simulated data file to filter!", kMBIconExclamation);
         return;
      }
      runs_to_analyse = selected_sim_runs;
      analysis_task = "filter simulated";
      // if working directory is outside of the default directory of the current KVSimDir
      // set auxiliary directory to current working directory (where filter should output any new files)
      fSelectedSimDir = dynamic_cast<KVSimFile*>(runs_to_analyse.First())->GetSimDir();
      if (!fSelectedSimDir->HasAuxDirectory() && TString(gSystem->pwd())!=TString(fSelectedSimDir->GetDirectory())) {
         fSelectedSimDir->SetAuxDirectory(gSystem->pwd());
#ifdef WITH_RSQLITE
         // add info to dataset table in db for next time
         fConfigDB["Datasets"]["AuxDir"] = gSystem->pwd();
         fConfigDB.update("Datasets", "AuxDir", Form("Name = '%s'", fSelectedSimDir->GetName()));
#endif
      }
   }
   KVDataAnalysisTask* anTask = gDataSetManager->GetAnalysisTaskAny(analysis_task);
   gDataAnalyser = KVDataAnalyser::GetAnalyser(anTask->GetDataAnalyser());
   gDataAnalyser->SetAnalysisTask(anTask);
   gDataAnalyser->SetFileList(runs_to_analyse);
   if (aux_runs_to_analyse.GetEntries()) gDataAnalyser->SetAuxFileList(aux_runs_to_analyse);
   if (anTask->WithUserClass()) {
      gDataAnalyser->SetUserClass(fAnalClass);
      if (!gDataAnalyser->IsUserClassValid()) {
         new TGMsgBox(gClient->GetRoot(), MainFrame, "KVSimDirGUI::RunAnalysis", "Compilation failed. Correct mistakes and try again!", kMBIconExclamation);
      }
   }
   else if (strcmp(anTask->GetUserBaseClass(), ""))
      gDataAnalyser->SetUserClass(KVDataAnalyser::UserClass{anTask->GetUserBaseClass()}, kFALSE);//task with default "user" class
   Bool_t all_events = fCBAllEvents->IsDown();
   if (!all_events)
      gDataAnalyser->SetNbEventToRead((Long64_t)fNENumberEvents->GetNumber());
   else
      gDataAnalyser->SetNbEventToRead(0);
   fCancelJob = kFALSE;
   if (type == "filter") {
      // set extra infos in kvsimdiranalyser for auto jobname
      if (fCustomKinematics) {
         // if an ad hoc system is used for the kinematics, we have to use it instead of fSystem,
         // but only after first checking if it is legit
         KV2Body cd(fReactionKinematics);
         // check valid ad hoc system given by user
         if (cd.IsZombie()) {
            KVError::Error(this, "SetFilterOptions", "Please check the format of the ad hoc system name you gave");
            WarningBox("Bad System", "Please check the format of the ad hoc system name you gave", kFALSE);
            fCancelJob = kTRUE;
         }
         else {
            cd.CalculateKinematics();
            cd.Print();
            fSystem = fReactionKinematics;
         }
      }
 
      KVSimDirAnalyser* simda = dynamic_cast<KVSimDirAnalyser*>(gDataAnalyser);
      simda->SetDataSetForFilter(fDataset);
      simda->SetSystemForFilter(fSystem);
   }
   Bool_t cancel_batch_job = kFALSE;
   if (fWithPROOF) {
      gBatchSystem->Clear();
      KVNameValueList batchParams;
      gBatchSystem->GetBatchSystemParameterList(batchParams);
      new KVBatchSystemParametersGUI(MainFrame, &batchParams, gDataAnalyser, &cancel_batch_job);
      if (!cancel_batch_job) {
         gBatchSystem->SetBatchSystemParameters(batchParams);
         gDataAnalyser->SetBatchSystem(gBatchSystem);
      }
   }
   if (!cancel_batch_job && !fCancelJob) {
      if (type == "filter")
         SetFilterOptions(); // this may yet set fCancelJob=true...
      if (!fCancelJob) {
         if(type == "filter")
         {
            // at this point it is best to make sure the full database has been built and is available for the dataset
            // we may have only built a minimal db with runs&systems. we don't want every prooflite/batch job to try
            // to build the database at the same time
            Info("RunAnalysis", "Forcing rebuild of complete dataset for %s if necessary", fDataset.Data());
            gDataSetManager->GetDataSet(fDataset)->cd();
         }
         gDataAnalyser->Run();
      }
   }
   if(!fWithPROOF || (fWithPROOF && gBatchSystem->IsCalled("PROOFLite")))
       RefreshSimDir();
}
 
 
 
 
TString KVSimDirGUI::GetKinematicsString()
{
   TString kinema;
   if (fKine == kKCM) kinema = "cm";
   else if (fKine == kKProj) kinema = "proj";
   else kinema = "lab";
 
   return kinema;
}
 
 
 
 
TString KVSimDirGUI::GetFilterTypeString()
{
   TString filter;
   switch (fFilterType) {
      case kFTGeo:
         filter = "Geo";
         break;
      case kFTSeuils:
         filter = "GeoThresh";
         break;
      case kFTFull:
         filter = "Full";
   }
 
   return filter;
}
 
 
 
 
void KVSimDirGUI::SetFilterOptions()
{
   TString kinema = GetKinematicsString();
   TString filter = GetFilterTypeString();
 
   TString options;
   options = Form("Dataset=%s,", fDataset.Data());
   if (fSystem != "") options += Form("System=%s,", fSystem.Data());
   else if (kinema != "lab") {
      // a kinematical frame transform is required, but no system is given!
      new TGMsgBox(gClient->GetRoot(), MainFrame,
                   "KVSimDirGUI::SetFilterOptions",
                   Form("Cannot transform kinematics from %s to lab without a defined reaction (system)!", kinema.Data()),
                   kMBIconExclamation);
      fCancelJob = true;
      return;
   }
   options += Form("Filter=%s,", filter.Data());
   options += Form("Kinematics=%s", kinema.Data());
   if (fDataQualityAudit != "") {
      options += Form(",DataQualityAudit=%s", fDataQualityAudit.Data());
      // add list of any extensible IDs given
      fExtensibleIDs="";
      TIter it(menus.filter.id_extension->GetListOfEntries());
      while (auto me = (TGMenuEntry*)it())
      {
         if(menus.filter.id_extension->IsEntryChecked(me->GetEntryId()))
         {
            if(fExtensibleIDs.Length())
               fExtensibleIDs+="|";
            fExtensibleIDs+=me->GetName();
         }
      }
      if(fExtensibleIDs.Length())
         options += Form(",ExtensibleID=%s",fExtensibleIDs.Data());
   }
   if (fRun != 0) {
      TString r;
      r.Form(",Run=%d", fRun);
      options += r;
   }
   else if (filter == "Full" && (fCustomKinematics || fSystem == "")) {
      // "Full" filter requires run number to work: either given explicitly or taken from first run of database system (not ad hoc)
      new TGMsgBox(gClient->GetRoot(), MainFrame,
                   "KVSimDirGUI::SetFilterOptions",
                   Form("To use 'FULL' (run-dependent) filter requires either a run number or a system from the dataset!"),
                   kMBIconExclamation);
      fCancelJob = true;
      return;
   }
   if (!fRandomPhi) options += ",PhiRot=no";
   if (fGemDecay) {
      options += ",Gemini=yes";
      options += Form(",GemDecayPerEvent=%d", fGemDecayPerEvent);
      if (fGemAddRotEner) options += Form(",GemAddRotEner=yes");
   }
 
   gDataAnalyser->SetUserClassOptions(options);
 
   std::cout << options << std::endl;
}
 
 
 
 
void KVSimDirGUI::ImportSimulation()
{
   // Import simulation data from currently selected directory
 
   const char* filetypes[] = {
      "All files", "*.*",
      0, 0
   };
   TGFileInfo fi;
   fi.fIniDir = StrDup(fSelectedSimDir->GetDirectory());
   fi.fFileTypes = filetypes;
   fi.SetMultipleSelection(true);
 
   new KVFileDialog(gClient->GetDefaultRoot(), MainFrame, kKVFDOpen, &fi);
 
   bool one_file = (!fi.fMultipleSelection && fi.fFilename);
   bool many_files = (fi.fMultipleSelection && fi.fFileNamesList);//may only be one
   if (one_file || many_files) {
      // set up list of KVSimReader plugins
      KVString plugins = KVBase::GetListOfPlugins("KVSimReader");
      KVString choices;
      plugins.Begin(" ");
      while (!plugins.End()) {
         // get URI corresponding to plugin
         KVString uri = KVBase::GetPluginURI("KVSimReader", plugins.Next());
         if (choices.Length()) choices += " ";
         choices += uri;
      }
      // get model from user
      TString model;
      Bool_t ok;
      new KVDropDownDialog(MainFrame, "Choose the simulation model and type of events", choices, 0, &model, &ok);
      if (ok) {
 
         if (one_file) {
            unique_ptr<KVSimReader> SR(KVSimReader::MakeSimReader(model));
            SR->SetOutputDirectory(fSelectedSimDir->GetDirectory());
            SR->ConvertAndSaveEventsInFile(fi.fFilename);
         }
         else {
            if (fi.fFileNamesList->GetEntries() == 1) {
               unique_ptr<KVSimReader> SR(KVSimReader::MakeSimReader(model));
               SR->SetOutputDirectory(fSelectedSimDir->GetDirectory());
               SR->ConvertAndSaveEventsInFile(fi.fFileNamesList->First()->GetName());
            }
            else {
               TIter it(fi.fFileNamesList);
               TObject* o;
               int i = 1;
               while ((o = it())) {
                  unique_ptr<KVSimReader> SR(KVSimReader::MakeSimReader(model));
                  SR->SetMultiFiles();
                  SR->SetFileIndex(i++);
                  SR->SetOutputDirectory(fSelectedSimDir->GetDirectory());
                  SR->ConvertAndSaveEventsInFile(o->GetName());
               }
            }
         }
 
         RefreshSimDir();
      }
   }
   else if (fi.fMultipleSelection && fi.fFileNamesList) {
      fi.fFileNamesList->ls();
   }
}
 
 
 
 
void KVSimDirGUI::NewFilteredAnalysisClass()
{
   // Get name of new class
   TString classname;
   Bool_t ok;
   new KVInputDialog(MainFrame, "Enter name of new analysis class", &classname, &ok, "Enter name of new analysis class");
   // check new classname is not name of existing class
   KVString impfile, decfile;
   if (KVBase::FindClassSourceFiles(classname, impfile, decfile)) {
      ok = ok && WarningBox("Replacing existing class",
                            Form("%s is the name of an existing class defined in [%s,%s].\nDo you want to overwrite this class?\n(All existing code will be lost)",
                                 classname.Data(), decfile.Data(), impfile.Data()),
                            kTRUE);
   }
   if (ok) {
      KVSimDirFilterAnalyser::Make(classname);
      fStatusBar->SetText(Form("Generated new filtered analysis class %s", classname.Data()), 1);
   }
}
 
 
 
 
void KVSimDirGUI::NewSimulatedAnalysisClass()
{
   // Get name of new class
   TString classname;
   Bool_t ok;
   new KVInputDialog(MainFrame, "Enter name of new analysis class", &classname, &ok, "Enter name of new analysis class");
   // check new classname is not name of existing class
   KVString impfile, decfile;
   if (KVBase::FindClassSourceFiles(classname, impfile, decfile)) {
      ok = ok && WarningBox("Replacing existing class",
                            Form("%s is the name of an existing class defined in [%s,%s].\nDo you want to overwrite this class?\n(All existing code will be lost)",
                                 classname.Data(), decfile.Data(), impfile.Data()),
                            kTRUE);
   }
   if (ok) {
      KVSimDirAnalyser::Make(classname);
      fStatusBar->SetText(Form("Generated new simulated analysis class %s", classname.Data()), 1);
   }
}
 
 
 
 
Bool_t KVSimDirGUI::WarningBox(const char* title, const char* msg, Bool_t confirm)
{
   // Warning box in case of problems
   // if confirm=kTRUE we ask for a yes/no answer from the user:
   //     if 'yes' is pressed, we return kTRUE, if 'no', kFALSE.
   // by default, only a 'dismiss' button is shown, and this method always returns kTRUE.
 
   Bool_t reply = kTRUE;
   if (!confirm)
      new TGMsgBox(gClient->GetRoot(), MainFrame, title, msg, kMBIconExclamation);
   else {
      Int_t ret_code = 0;
      new TGMsgBox(gClient->GetRoot(), MainFrame, title, msg, kMBIconExclamation, kMBYes | kMBNo, &ret_code);
      reply = (ret_code & kMBYes);
   }
   return reply;
}
 
 
 
 
void KVSimDirGUI::SetFilterStatusBar()
{
   int parts[] = {14, 25, 10, 14, 9, 7, 10};
   fStatusBar->SetParts(parts, 7);
   fStatusBar->SetText(fDataset.Data(), 0);
   fStatusBar->SetText(fCustomKinematics ? fReactionKinematics.Data() : fSystem.Data(), 1);
   fStatusBar->SetText(Form("Run: %d", fRun), 2);
   fStatusBar->SetText(Form("Audit: %s", fDataQualityAudit.Data()), 3);
   fStatusBar->SetText(GetFilterTypeString().Data(), 4);
   fStatusBar->SetText(GetKinematicsString().Data(), 5);
   TString gemphi;
   if (fGemDecay) {
      gemphi = Form("Gem++, %d/ev.", fGemDecayPerEvent);
      if (fGemAddRotEner) gemphi += " +Erot";
   }
   if (fRandomPhi) {
      if (gemphi.Length()) gemphi += "; ";
      gemphi += "phi RNDM";
   }
   fStatusBar->SetText(gemphi, 6);
}
 
 
 
 
void KVSimDirGUI::SetAnalysisStatusBar()
{
   fStatusBar->SetParts(2);
   if (!fAnalClass.name.IsNull()) {
      fStatusBar->SetText(Form("Analysis class: %s", fAnalClass.name.Data()), 0);
      fStatusBar->SetText(Form("Found header file %s and implementation file %s", fAnalClass.dec_file.Data(), fAnalClass.imp_file.Data()), 1);
   }
   else
      fStatusBar->SetText("Analysis class:", 0);
}
 
 
#ifdef WITH_RSQLITE
 
 
void KVSimDirGUI::ReconstructSimDirsFromDB()
{
   // Rebuild all KVSimDir/KVSimFile objects from information in sqlite DB
 
   // backwards-compatility: add any missing columns to dataset tables
   fConfigDB.select_data("Datasets");
   KVNameValueList tables;
   while (fConfigDB.get_next_result()) {
      // make sure the directory associated with each dataset still exists!
      auto dataset_dir = fConfigDB["Datasets"]["Directory"].get_data<TString>();
      if(gSystem->AccessPathName(dataset_dir))
         continue;
      auto sd = new KVSimDir(fConfigDB["Datasets"]["Name"].get_data<TString>(),
                             dataset_dir);
      if (!fConfigDB["Datasets"]["AuxDir"].is_null())
      {
         // make sure the auxiliary directory associated with each dataset still exists!
         auto aux_dir = fConfigDB["Datasets"]["AuxDir"].get_data<TString>();
         if(!gSystem->AccessPathName(aux_dir))
            sd->SetAuxDirectory(aux_dir);
      }
      fListOfDirs.Add(sd);
      tables.SetValue(fConfigDB["Datasets"]["Name"].get_data<TString>(),
                      fConfigDB["Datasets"]["Table"].get_data<TString>());
   }
   for (int i = 0; i < tables.GetNpar(); ++i)
   {
      auto tab = tables.GetValue<TString>(i);
      if(!fConfigDB[tab].has_column("AuxDir"))
         fConfigDB.add_column(tab, "AuxDir", "INTEGER");
      if(!fConfigDB[tab].has_column("DataQualityAudit"))
         fConfigDB.add_column(tab, "DataQualityAudit", "TEXT");
   }
   for (int i = 0; i < tables.GetNpar(); ++i) {
      KVSimDir* sd = (KVSimDir*)fListOfDirs.FindObject(tables.GetParameter(i)->GetName());
      fConfigDB.select_data(tables.GetValue<TString>(i));
      KVSQLite::table& dstable = fConfigDB[tables.GetValue<TString>(i)];
      while (fConfigDB.get_next_result()) {
         bool from_aux_dir = !dstable["AuxDir"].is_null() ? dstable["AuxDir"].get_data<int>() : false;
         if (dstable["Filtered"].get_data<int>()) {
            // filtered/reconstructed data
            TString dqa;
            if (!dstable["DataQualityAudit"].is_null())
               dqa = dstable["DataQualityAudit"].get_data<TString>();
            KVSimFile* f = new KVSimFile(
               nullptr,
               dstable["FileName"].get_data<TString>(), dstable["TreeInfo"].get_data<TString>(),
               dstable["Events"].get_data<int>(), dstable["TreeName"].get_data<TString>(),
               dstable["BranchName"].get_data<TString>(), dstable["DataSet"].get_data<TString>(),
               dstable["System"].get_data<TString>(), dstable["Run"].get_data<int>(),
               dstable["OrigFile"].get_data<TString>(),
               dstable["FiltType"].get_data<TString>(),
               dqa
            );
            f->SetGemini(dstable["Gemini"].get_data<bool>());
            if (f->IsGemini()) f->SetGemDecayPerEvent(dstable["GemDecayPerEvent"].get_data<int>());
            sd->AddFiltData(f, from_aux_dir);
         }
         else {
            // simulation data
            KVSimFile* f = new KVSimFile(
               nullptr,
               dstable["FileName"].get_data<TString>(), dstable["TreeInfo"].get_data<TString>(),
               dstable["Events"].get_data<int>(), dstable["TreeName"].get_data<TString>(),
               dstable["BranchName"].get_data<TString>());
            sd->AddSimData(f, from_aux_dir);
         }
      }
   }
}
 
#endif