GUI/TFndEvd.h

// @(#)fROOT/GUI:$Name:  $:$Id: TFndEvd.h,v 1.28 2007/09/07 14:05:24 Diego_Faso Exp $
// Author: Diego Faso <mailto:faso@to.infn.it>, 2006/07/31

#ifndef FROOT_TFndEvd
#define FROOT_TFndEvd

#ifndef ROOT_Gtypes
#include "Gtypes.h"
#endif

#include "TInterpreter.h"
// --- root GUI
#include <TGWindow.h>
#include <TGFrame.h>
#include <TGFileDialog.h>
#include <TGMenu.h>
#include <TGButton.h>
#include <TGClient.h>
#include <TGTextEntry.h>
#include <TGNumberEntry.h>
#include <TGListBox.h>

#include "TGLSAFrame.h"

#include "TGLabel.h"
#include "TRootEmbeddedCanvas.h"
#include "TGSlider.h"

#include "TGLSAViewer.h"

#include "TPolyLine3D.h"
#include "TClonesArray.h"
#include "TPolyMarker3D.h"

#include "TFile.h"
#include "TTree.h"

#include "TTimer.h"
#include "TASImage.h"

#include "TFndGeometry.h"
#include "TFndHdt.h"
#include "TFndEvdTrack.h"
#include "FIN_PHYS.h"

#ifdef FNDEVD_USE_PREAN
#include "TFndPrean.h"
#endif

//#include "gif_lib.h"

using namespace FIN_PHYS;

class TFndEvdWireHit: public TObject {
 public:
  
  enum E_EvtWireHitAttr // used to set different attributes depending on the detector
    {
      K_EvtWHit_Lmd = 0,
      K_EvtWHit_Stb = 1 
    };
  enum E_EvtWireHitMode
    { 
      K_EvtWHit_NoObject = 0,
      K_EvtWHit_LineOnly,
      K_EvtWHit_E_MarksOnly,
      K_EvtWHit_P_MarksOnly,
      K_EvtWHit_MarksOnly,
      // 7 modes still free (for further developments)
      K_EvtWHit_Complete = 10
    };
  
 
private:
  TPolyLine3D *fLine;
  TPolyMarker3D *fEdgeMarkers;
  E_EvtWireHitMode f_hit_mode;

 public:
    
  TFndEvdWireHit(E_EvtWireHitMode hit_mode=K_EvtWHit_Complete); // default ctor will draw line and edge-markers
  virtual ~TFndEvdWireHit();
  
  void SetAttributes(E_EvtWireHitAttr attr);
  void SetEdges(Double_t x1, Double_t y1, Double_t z1,Double_t x2, Double_t y2, Double_t z2)
    {
      if(fLine){
        fLine->SetPoint(FROOT::E_FIN_SIDE_E,x1,y1,z1);
        fLine->SetPoint(FROOT::E_FIN_SIDE_P,x2,y2,z2);
      }
      if(fEdgeMarkers){
        if (f_hit_mode != K_EvtWHit_P_MarksOnly) fEdgeMarkers->SetPoint(FROOT::E_FIN_SIDE_E,x1,y1,z1);
        if (f_hit_mode != K_EvtWHit_E_MarksOnly) fEdgeMarkers->SetPoint(FROOT::E_FIN_SIDE_P,x2,y2,z2);
      }
    }
  
  void DrawWireHit(Bool_t also_edges=kTRUE);
  
  ClassDef(TFndEvdWireHit,0)
};

//                                                                        //
// TFndEvd                                                                //
//                                                                        //
//                                                                        //

#include "Gui.h"
using namespace Gui;

class TFndEvd: public TFndGeometry {

 public:
  enum { K_FinEvd_NmaxLines = 1200 };

  enum EFndEvdView { FinEvdView_START = 0, 
                     FinEvdView_Perp_VERT,
                     FinEvdView_Orth_VERT
  };
  
  enum E_EvdDets { // local management of detectors
    E_EvdDet_Tofino = 0,
    E_EvdDet_Sil = 1,
    E_EvdDet_Lmd = 2,
    E_EvdDet_Tofone = 3,
    E_EvdDet_End = 4 // Not used: needed by arrays
  };

  enum E_EvdSelHitOper { // logic operation to be performed
    E_Evd_SelOper_AND_sel = 0, // will not consider not selected entries
    E_Evd_SelOper_AND_all = 1, // will consider not selected entries as "not"
    E_Evd_SelOper_End = 2 // Not used: needed by arrays
  };


  enum E_EvdSelHitMode_Sil {
    E_EvdSelMod_SelSil_Clean = 0,
    E_EvdSelMod_SelSil_End = 1
  };

  enum E_EvdSelHitMode {
    E_EvdSelMod_AdcE = 0,
    E_EvdSelMod_AdcP = 1,
    E_EvdSelMod_TdcE_Low = 2,
    E_EvdSelMod_TdcP_Low = 3,
    E_EvdSelMod_Mt_Low = 4,
    E_EvdSelMod_TdcE_High = 5, // TOFINO only
    E_EvdSelMod_TdcP_High = 6, // TOFINO only
    E_EvdSelMod_Mt_High = 7,   // TOFINO only
    E_EvdSelMod_End = 8     // Not used: needed by arrays
  };

  TString GetEvdDet(E_EvdDets det){
    switch(det){
    case E_EvdDet_Tofino: return "TOFI";
    case E_EvdDet_Sil: return "SIL";
    case E_EvdDet_Lmd: return "LMD";
    case E_EvdDet_Tofone: return "TOFO";
    default: Warning("GetEvdDet","detector not defined (%d)",det); return "";
    }
  }
  
  TString GetOperName(E_EvdSelHitOper oper){
    switch(oper){
    case E_Evd_SelOper_AND_sel: return "sel";
    case E_Evd_SelOper_AND_all: return "all";
    default: Warning("GetOperName","operation not defined (%d)",oper); return "";
    }  
  }

  TString GetSelHitMode_Sil(E_EvdSelHitMode_Sil mode){
    switch(mode){
    case E_EvdSelMod_SelSil_Clean: return "Clean";
    default: Warning("GetSelHitMode_Sil","mode not defined (%d)",mode); return "";
    }
  }
  

  TString GetSelHitMode(E_EvdSelHitMode mode,Bool_t is_tofino=kFALSE){
    switch(mode){
    case E_EvdSelMod_AdcE: return "adc E";
    case E_EvdSelMod_AdcP: return "adc P";
    case E_EvdSelMod_TdcE_Low: if(is_tofino) return "tdc E (low)" ; else return "tdc E" ;
    case E_EvdSelMod_TdcP_Low: if(is_tofino) return "tdc P (low)" ; else return "tdc P" ;
    case E_EvdSelMod_Mt_Low:   if(is_tofino) return "Mt (low)"    ; else return "MT" ;
    case E_EvdSelMod_TdcE_High: if(is_tofino) return "tdc E (high)" ; else return "" ;
    case E_EvdSelMod_TdcP_High: if(is_tofino) return "tdc P (high)" ; else return "" ;
    case E_EvdSelMod_Mt_High:   if(is_tofino) return "Mt (high)"    ; else return "" ;
    default: Warning("GetSelHitMode","mode not defined (%d)",mode); return "";
    }
  }
  
  
  TString GetViewName(EFndEvdView view)
    {
      switch(view){
      case FinEvdView_START: return "Default (START)";
      case FinEvdView_Perp_VERT: return "Vert (Perp)";
      case FinEvdView_Orth_VERT: return "Vert (Ortho)";
      default: return 0;
      }
    }
  
 protected:
  TGLSAViewer *fGLSAViewer;
  EFndEvdView fCurrentEvdView;

  Bool_t fDetectorVisibililty[(const Int_t)FGEO_TOFONE];
  //----------
  
  // GUI management
  TGLSAFrame *fPromptFrame; 
  TGCompositeFrame *fDisplayFrameGL;
  TGFont *fUFONT;    // will reflect user font changes
  TGGC   *fUGC;      // will reflect user GC changes
  ULong_t fUColor;   // will reflect user color changes  


  TGVerticalFrame *fFndVertFrame;
  Double_t fFndVFrameW;
  Double_t fFndVFrameH;
  Double_t fPromptWindowSize[2]; // width, height

  // GEOMETRY manipulation frame
  TGGroupFrame *fGrpGuiManip;
  TGLabel *fLableTogLayView;
  TGComboBox *fComboTogLayView;

  TGLabel *fLableSelectView;
  TGComboBox *fComboSelectView;
  // Hit selection //
  TGLabel *fLabelHitSelOper[(Int_t)E_EvdDet_End];
  TGComboBox *fComboHitSelOper[(Int_t)E_EvdDet_End];
  TGListBox *fListBox_SelMod[(Int_t)E_EvdDet_End];

  // event handling frame
  TGGroupFrame *fGrpEvtHandle;
  TGLabel *fLableFidaVer;
  TGComboBox *fComboFidaVer;

  TGLabel *fLableSelectRunType;
  TGComboBox *fComboSelectRunType;

  TGLabel *fLableSelectRunNumber;
  TGNumberEntry *fNumGuiSelectRunNumber;

  TGLabel *fLableSelectEventNumber;
  TGNumberEntry *fNumGuiSelectEventNumber;

  TGCheckButton *fChkBox_Autoupdate;
  TGCheckButton *fChkBox_UseTracks; // look for reconstructed tracks if enabled

  // information region frame
  TGGroupFrame *fGrpInfoRegion;
  TGLRenderArea *fGLInfoRegArea;
  TRootEmbeddedCanvas *fInfoEmbCanvas;
  TCanvas *fInfoCanvas;

  TGTextButton *fTxtBut_SaveDisplay;  // used to save current display (picture) to file
  TGTextButton *fTxtBut_StoreDisplay; // used to store current diplay into the Info Canvas

  // Bottom horizontal frame
  TGHorizontalFrame *fFndHorFrame; // horizontal frame (bottom)

  TGLabel *fLableMinDensity;
  TGHSlider *fSliderMinDensity;
  TGNumberEntry *fNumMinDensity;
  Double_t fDensSliderScale;

  TGLabel *fLableVerboseLev;
  TGNumberEntry *fNumVerboseLev;

  TGLabel *fLableStructVis;
  TGNumberEntry *fNumStructVis;

  // Hits displaying (volumes are handled directly via gGeoManager) //
  Bool_t fRandomMode; // default value: false

  std::vector<FinEvdHit_t> fVolHitsList;
  
  TClonesArray fLmdWHits; // lines for representing the hits wire
  TClonesArray fStbWHits;      // lines for representing the hits wire */
  TPolyMarker3D *fMRS_TofHits[2]; // markers for evaluated hit position (on tofino slabs)
  TPolyMarker3D *fMRS_SilHits[2][2]; // markeers for hit position [layer][normal,high-energy] (on sil modules)
  TPolyMarker3D *fMRS_LmdHits; // markers for evaluated hit position (on lmd wires)

  // Event management //
  // - "HDT" are used for displaying hits
  // - reconstructed tracks are taken from
  //   pre-analysis trees (see below: Reconstructed Information)

  TString fCurRunType;
  Int_t fCurRunNumber;
  Int_t fCurEv;
  
  TFile *fCurDataFile; // hdt.root or dst.root
  TTree *fCurEventTree; // tree contained in hdt.root("F") or dst.root("E")
  TFndHdt *fCurHdt; // current hdt event (must not be deleted)
  
  TFndEvdWireHit::E_EvtWireHitMode fWireHitsMode[FIN_STB+1];

  Int_t fVerboseLevel; // 0: no std-out messages; default value: 1
  Int_t fStructVis; // 0: no structure (default)
  Bool_t fReadyToDisplay;

  // Automatic update management //
  TTimer *fTimer;
  Int_t fUpdateInterval; // time interval for update (seconds): default is 15
  Bool_t fAutoUpdate; // true (default) if autoupdate is set

  // Hit selection //

  // --- Sil is treated as others, but with a different enum!
  E_EvdSelHitOper fSelOperation[(Int_t)E_EvdDet_End]; // operation to be performed (on selected hit modes)
  Bool_t fSelConsider[(Int_t)E_EvdDet_End][(Int_t)E_EvdSelMod_End]; // true for hit selection mode to be considered

  // Reconstructed Information //
  // (pre-analysis trees used) //
  Bool_t fUseTracks;  // true (not the default) if UseTracks is set
  TClonesArray *fTracksArray;  
  
#ifdef FNDEVD_USE_PREAN
  TFndPrean *fPreanRef; // reference for pre-analysis format interface
#endif

 public:
  static TClonesArray *fgTracks;
  
 protected:
  // Saving / Printing //
  TImage *fCurImage; // image in memory (for displaying purposes)
  
 public:
  
  TFndEvd();
  ~TFndEvd();

  // --- Connection methods to interface ROOT-defined actions
  virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
  void PrintEvent_t(Event_t *ev);
  Bool_t HandleButton(Event_t *ev);
  Bool_t HandleDoubleClick(Event_t *ev);
  Bool_t HandleConfigureNotify(Event_t *ev);
  Bool_t HandleKey(Event_t *ev);
  Bool_t HandleMotion(Event_t *ev);
  Bool_t HandleExpose(Event_t *ev);
  // ---

  Int_t Open(const Int_t &dtak_num);
  void  UpdateEVD() { UpdateEVD(kFALSE); } // needed by GUI connection
  void  UpdateEVD(Bool_t reset_view); // needed by GUI connection
  Int_t Close();

  void ToggleAutoUpdate(Bool_t autoupd);
  void AutoUpdate(); // perform an automatic update

  TGLSAViewer *GetGLSAViewer() { return fGLSAViewer;  }
  TGLSAFrame  *GetGLSAFrame()  { return fPromptFrame; }

  void SelectEVDView(EFndEvdView view_id);
  void SelectEVDView(Int_t view_id){ SelectEVDView((EFndEvdView)view_id); } // needed by GUI connection
  
  // called by GUI elements (mouse actions)
  void SetDensityThreshold(Int_t pos);
  void SetDensitySlider(Long_t val);
  void ToggleDetectorVisibility(Int_t det_id); // det_id: see TFndGeometry::EFndGeoLayers


  // following methods could become private:
  void SetLocalFont(TString font_str,TString font_fg_col,TString font_bg_col,TString u_col);

  void BuildUserActionsGUIGroups();
  void BuildInfoRegionGUIGroup();
  void BuildBottomControlsGUI();
  void SetFndGlViewer();

  Bool_t MakeConnections();

  void Test1();
  void Test1(Int_t par);

  // Hits displaying (volumes are handled directly via gGeoManager) //
  void HitDetector(Int_t det, Int_t ch, Int_t mode=FGEO_HIT_DETECTED,Bool_t refresh_display=kTRUE,Double_t mrs_x=0,Double_t mrs_y=0,Double_t mrs_z=0);
  void RemoveHit(Int_t det, Int_t ch,Bool_t refresh_display=kTRUE); // remove a specific hit
  void RemoveAllHits(Bool_t reset_default_view=kFALSE,Bool_t refresh_display=kTRUE);
 
  void ResetMrsHits();
 
  void PrintHits(Bool_t Selected=kTRUE); // default will print only selected hits
  void SetVerboseLevel(Long_t v_lev) {
    fVerboseLevel = (Int_t)( fNumVerboseLev->GetNumber() ); 
    Info("SetVerboseLevel","Verbose level set to: %d",fVerboseLevel);
  }
  void SetStructVis(Long_t v_lev) {
    fStructVis = (Int_t)( fNumStructVis->GetNumber() );
    Bool_t vis = (fStructVis>0)? kTRUE : kFALSE;
    SetStructureVisibility(vis,fStructVis);
    UpdateEVD();
    Info("SetStructVis","Structure visibility set to: %d",fStructVis);
  }
  // Event management //
  void SetRandomMode(const Bool_t &rndm_mode) { fRandomMode = rndm_mode; }
  
  void DisplayEvent(Bool_t keep_current_hits=kFALSE,Bool_t reload=kFALSE);
  void DisplayRandomEvent(Bool_t keep_current_hits); // used to test the Event displaying (and for demo)
  
  void SetRunType(Int_t r_type);
  
  void SetRunNumber(Long_t evt_num){
    fCurRunNumber = (Int_t) fNumGuiSelectRunNumber->GetNumber();
    if(fVerboseLevel >= 1) Info("SetRunNumber","Selected run : \"%d\"",fCurRunNumber);    
  }

  void SetEventNumber(Long_t evt_num){
    fCurEv = (Int_t) fNumGuiSelectEventNumber->GetNumber();
    if(fVerboseLevel >= 1) Info("SetEventNumber","Selected event : \"%d\"",fCurEv);    
    DisplayEvent(kFALSE,kTRUE);
  }
  
  Int_t GetEvent();

  // Hit selection //
 private:
  void SetDefaulHitSelection();
  Int_t CheckTofHit(TFndHTof *hit); // 0:no-good; 1:low-th ; 2:high-th
  Bool_t CheckSilHit(TFndHSilCluster *hit); // check single hit before displaying it
  Bool_t CheckLmdHit(TFndHLmd *hit); // check single hit before displaying it
  Bool_t CheckStbHit(TFndHStb *hit); // check single hit before displaying it

  void ResetMrsTofiHits();
  void ResetMrsSilHits(Int_t layer=0,Bool_t recreate_it=kTRUE); // zero will reset both
  void ResetMrsLmdHits();
  void SetHitsVisibility(Int_t det, Bool_t visible);

 public:

  void CheckSingleSelOper(E_EvdDets det);

  void SetDetSelOper_TOFI(Int_t sel);
  void SetDetSelOper_SIL(Int_t sel);
  void SetDetSelOper_LMD(Int_t sel);
  void SetDetSelOper_TOFO(Int_t sel);

  void PrintOperSel(E_EvdDets det);
  void SetOperSel(E_EvdDets det,E_EvdSelHitOper Selection)
    {
      fSelOperation[(Int_t) det] = Selection;
    }
  //
  void CheckSingleSelList(E_EvdDets det);

  void CheckConsiderSel_TOFI();
  void CheckConsiderSel_SIL();
  void CheckConsiderSel_LMD();
  void CheckConsiderSel_TOFO();

  void PrintConsiderSel(E_EvdDets det);
  void SetConsiderSel(E_EvdDets det,E_EvdSelHitMode mode, Bool_t val)
    { // true for hit selection mode to be considered
      fSelConsider[det][mode] = val;
    }

  // Reconstructed Information //
  // (pre-analysis trees used) //
  void ToggleUseTracks(Bool_t use_trk);
 protected:
  Int_t LoadRecFile();
  void LoadTracks(Bool_t keep_current);
  void LoadRandomTracks(Bool_t keep_current);
 public:
  void DisplayTracks();
  void RemoveAllTracks();

  TClonesArray *GetTracksArray() { return fTracksArray; }
  Int_t GetNumberOfTracks() const { return fTracksArray->GetEntries(); }
  TFndEvdTrack *GetTrack(Int_t track_id)    { return ((TFndEvdTrack*) fTracksArray->At(track_id)); }
  TFndEvdTrack *AddTrack(const Double_t &Bx,const Double_t &By,const Double_t &Bz);

  // Saving / Printing //
  enum E_FndEvd_SaveMode {
    E_FndEvd_Save_HiddenTmp = 0, // recreate tmp hiddden file 
    E_FndEvd_Save_DefaultName = 1, // use a default name in cur-dir (and replace) 
    E_FndEvd_Save_CustomName = 2 // ask for file-name in cur-dir (and replace) 
  };
  
  void StoreCurrentDisplay();  
  void SaveCurrentDisplay(E_FndEvd_SaveMode mode=E_FndEvd_Save_HiddenTmp,TString fnam="");  
  void ShowSavedDisplay(TString filename="");
  void ClearInfoCanvas();

  ClassDef(TFndEvd,0)
};
    
#endif // FROOT_TFndEvd

---