HWMainWindow.h

Go to the documentation of this file.

/*
 * HWMainWindow.h
 *
 *  Created on: 02 Jan 2019
 *      Author: Valerio Formato
 */

#ifndef HWMainWindow_H_
#define HWMainWindow_H_

#include "RQ_OBJECT.h"

// HERD headers
#include "algorithms/display/HWCaloEventDisplay.h"
#include "algorithms/display/HWHoughTrackEventDisplay.h"
#include "algorithms/display/HWMCTruthDisplay.h"
#include "algorithms/display/HWPSDEventDisplay.h"
#include "algorithms/display/HWTrackingDetectorEventDisplay.h"
#include "common/RefFrame.h"
#include "dataobjects/CaloHits.h"
#include "dataobjects/MCTruth.h"
#include "dataobjects/PsdGeoParamsColl.h"
#include "dataobjects/PsdHitsColl.h"
#include "dataobjects/StkClustersColl.h"
#include "dataobjects/StkGeoParamsColl.h"
#include "dataobjects/Track2D.h"

// EA headers
#include "analysis/EventLoopProxy.h"
#include "core/ObserverPtr.h"

// ROOT headers
#include "TApplication.h"
#include "TEveBoxSet.h"
#include "TEveGeoNode.h"
#include "TEveManager.h"
#include "TEvePointSet.h"
#include "TEveProjectionManager.h"
#include "TEveScene.h"
#include "TEveTrack.h"
#include "TEveTrackPropagator.h"
#include "TEveViewer.h"
#include "TEveWindow.h"
#include "TGNumberEntry.h"

namespace Herd {
class HERDward;
class HWProjections;

class HWMainWindow : public TApplication, public TEveManager {
  RQ_OBJECT("HWMainWindow")

  friend class HERDward;

public:
  HWMainWindow();
  ~HWMainWindow() { Terminate(); };

  void SetReturnFromRun(bool ret) { TApplication::SetReturnFromRun(ret); };
  bool ReturnFromRun() { return TApplication::ReturnFromRun(); };
  void ExitFromLoop();
  void PrevEvent();
  void NextEvent();
  void LoadEvent();
  void SetEventNumber(const char *text);
  void SetDisplayDetector(const char *text);
  void SetGeoTransparency(int transp);
  void Terminate(int status = 0);

private:
  int m_evNo;
  int m_totEvents;

  TGNumberEntryField *m_evField;

  std::unique_ptr<TEveWindowSlot> m_slot;
  std::unique_ptr<TEveWindowPack> m_pack;

  std::unique_ptr<HWProjections> m_projections;

  void LoadGeometry();
  void SetSceneTransparency(TEveGeoNode *node, int transp);
  void MakeTransparentScene(TEveGeoNode *node, int transp);

  HWMCTruthDisplay m_mcTruthDisp;
  HWCaloEventDisplay m_caloDisp;
  HWTrackingDetectorEventDisplay m_trackerDisp;
  HWTrackingDetectorEventDisplay m_scdDisp{"SCD"};
  HWHoughTrackEventDisplay m_houghDisp;
  HWPSDEventDisplay m_psdDisp;

  template <class TrackingGeoParams>
  void SetTrackingClusters(const ClustersColl &clColl, const SidesArray<std::vector<TrackingGeoParams>> &geoParamsColl,
                           HWTrackingDetectorEventDisplay &_disp);

  void SetCaloHits(const CaloHits &caloHits, const CaloGeoParams &caloParams);
  void SetPSDHits(const PsdHitsColl &psdColl, const PsdGeoParamsColl &geoParamsColl);
  void SetHoughTracks(const std::array<std::vector<Track2D>, 3> &tracks);
  void SetMCTruth(const MCTruth &mcTruth);
  void SetTrackerName(std::string name) { m_trackerDisp.SetName(std::move(name)); }

  std::unordered_map<std::string, bool> m_detEnableMap;
  TGMainFrame *m_frmMain;
  TGVerticalFrame *m_frmMainVertical;
  TGGroupFrame *m_hitGroup;

  void ClearScene();
  void MakeGui();
  void AddGUIHitButtons();
  void AddGUITranspSlide();

  // Event loop stuff
  EA::observer_ptr<EA::EventLoopProxy> m_evLoopProxy;
  void SetEventNumber(int evNo);
  void SetNumberOfEvents(int totEvents) { m_totEvents = totEvents; };
  void UpdateDetectorStatus();

  ClassDef(HWMainWindow, 1)
};

class HWProjections {
public:
  HWProjections();

  std::unique_ptr<TEveWindowPack> Init(std::unique_ptr<TEveWindowPack> _pack);
  void AdjustCameras();
  void ClearScene();
  void DrawMCTruth(const HWMCTruthDisplay &mcTruthDisp);
  void DrawCaloHits(const HWCaloEventDisplay &caloDisp);
  void DrawPSDHits(const HWPSDEventDisplay &psdDisp);
  void DrawTrackingDetectorClusters(const HWTrackingDetectorEventDisplay &stkDisp);
  void DrawTracks(const HWHoughTrackEventDisplay &trackDisp);
  void LoadGeometryScene();

  char GetSceneTransparency() { return m_mainTransparency; }
  void SetGeoTransparency(char transp);

private:
  void FillScene(RefFrame::View view, TEveElement *parent, const std::vector<std::string> &excluded,
                 unsigned int depth);

  void SetSceneTransparency(TEveElement *scene, char transp);

  char m_mainTransparency = 95;

  std::unique_ptr<TEveViewer> _XZView;
  std::unique_ptr<TEveViewer> _YZView;
  std::unique_ptr<TEveViewer> _XYView;

  std::unique_ptr<TEveScene> _XZGeomScene;
  std::unique_ptr<TEveScene> _YZGeomScene;
  std::unique_ptr<TEveScene> _XYGeomScene;

  std::unique_ptr<TEveScene> _XZEventScene;
  std::unique_ptr<TEveScene> _YZEventScene;
  std::unique_ptr<TEveScene> _XYEventScene;
};
} // namespace Herd

#endif