HarpoRecoMonitorGui.cxx

Go to the documentation of this file.

// 
// File HarpoRecoMonitorGui.cxx
//
#include "HarpoRecoMonitorGui.h"

#include "Pmm2Event.h"
#include "HarpoRecoEvent.h"
#include "HarpoSimEvent.h"
#include "HarpoClustering.h"
#include "HarpoTrackingPh.h"

#include "HarpoAnalyseVertex3D.h"
#include "HarpoAnalyseBertrand.h"
#include "HarpoMatchingVertex.h"
#include "HarpoAnalyseEtrack.h"
#include "HarpoAnalysePattern.h"
#include "HarpoAnalyseTemplate.h"
#include "HarpoAnalysePedestalShift.h"

#include <TPad.h>
#include <TH1.h>
#include <TH2.h>
#include <TH3F.h>
#include <TGraph2D.h>
#include <THStack.h>
#include <TLine.h>
#include <TArrow.h>
#include <TEllipse.h>
#include <TPolyLine3D.h>
#include <TCanvas.h>
#include <TRootEmbeddedCanvas.h>
#include <TGFrame.h>
#include <TGComboBox.h>
#include <TGButton.h>
#include <TGLabel.h>
#include <TGText.h>
#include <TGButtonGroup.h>
#include <TGNumberEntry.h>
#include <TGListBox.h>
#include <TObjArray.h>
#include <TLegend.h>
#include <TClonesArray.h>
#include <TSystemDirectory.h>
#include <TSystem.h>
#include <TStyle.h>
#include <TSpectrum.h>
#include <TChain.h>
#include <TProfile.h>
#include <TGraph.h>
#include <TLatex.h>
#include <TMath.h>

#include "MakeNiceHisto.h"

#include <TGTab.h>
#include <TApplication.h>

#include "TThread.h"
#include "TMethodCall.h"
#include "TMapFile.h"

#include <math.h>

#include <iostream>
using namespace std;
#include <fstream>


enum ETestCommandIdentifiers {
  M_DISPLAY_EVENT,
  M_NEXT_EVENT,
  M_PREV_EVENT,
  M_FIND_EVENT,
  M_SAVE,
  M_DISPLAY,
  M_AUTOREFRESH,
  M_CONF_CLUSTERING,
  M_SET_CONF_CLUSTERING,
  M_CONF_TRACKING,
  M_SET_CONF_TRACKING,
  M_CONF_MATCHING,
  M_SET_CONF_MATCHING,
  M_CONF_VERTEXING,
  M_SET_CONF_VERTEXING,
  M_CONF_ANALYSIS,
  M_SET_CONF_ANALYSIS,
  M_CONF_SELECTOR,
  M_SET_CONF_SELECTOR
};

HarpoRecoMonitorGui::HarpoRecoMonitorGui(const TGWindow *p, UInt_t w, UInt_t h, UInt_t opt, int argc, char **argv)
  : TGMainFrame(p, w, h, opt)
{

  ecTabRaw = 0;
  ecTabNoiseSuppr = 0;
  ecTabClusters = 0;
  ecTabClustersTracks = 0;
  ecTabTracks = 0;
  ecTabMatching = 0;
  ecTab3D = 0;
  ecTabSim = 0;
  ecTabVertex = 0;
  ecSideSummary = 0;
  fInfoBox = 0;
  // cTabEvent = 0;
  // cTab3D = 0;
  cSideSummary = 0;

  fFrameMain        = 0;
  fChooseRun        = 0;
  fChooseEvent      = 0;
  fChooseNEvents    = 0;
  fDisplayEvent     = 0;
  fNextEvent        = 0;
  fDisplay          = 0;
  fDisplayBox       = 0;
  fSave             = 0;

  fChooseNch        = 0;
  fChooseSig        = 0;
  fChooseDelta        = 0;


  fRunNumber = 0;
 
  fAutoRefresh = kTRUE;
  fCurrentEventNumber = 0;


  //  HarpoRunHeader *hdr;

  HarpoConfig *cfg = new HarpoConfig(argc,argv,0x17);
  cfg->Init();
  cfg->print();

  // fClusteringType = CLUSTERING_NONE;
  // fTrackingType = TRACKING_NONE;
  // fMatchingType = MATCHING_NONE;
  // fVertexingType = VERTEXING_NONE;
  // fAnalysisType = ANALYSIS_NONE;
  fClusteringType = CLUSTERING_BLOCS;
  fTrackingType = TRACKING_KALMANNEW;
  fMatchingType = MATCHING_VERTEX;
  fVertexingType = VERTEXING_BASIC;
  fAnalysisType = ANALYSIS_NONE;
  fSelectorType = SELECTOR_NONE;
  hDoca = new TH1F("hDoca",";DOCA [mm]",500,0,50);
  hOpenAngle = new TH1F("hOpenAngle",";#theta [^{o}]",360,-180,180);
  hOmegaAngle = new TH1F("hOmegaAngle",";#theta [^{o}]",360,-180,180);
  Long64_t clusteringType;
  if ( ! gHConfig->Lookup("monitor.Clustering",clusteringType) )
    Info("Constructor","Default Clustering: %d",fClusteringType);
  else
    fClusteringType = clusteringType;
  Long64_t trackingType;
  if ( ! gHConfig->Lookup("monitor.Tracking",trackingType) )
    Info("Constructor","Default Tracking: %d",fTrackingType);
  else
    fTrackingType = trackingType;



  fClustering[CLUSTERING_NONE] = 0;
  fClustering[CLUSTERING_BASIC] = new HarpoClustering();
  fClustering[CLUSTERING_BLOCS] = new HarpoClusteringBlocs();
  for(UInt_t i = 0; i<kNclustering; i++){
    if(i == CLUSTERING_NONE) continue;
    fClustering[i]->Init();
  }

  fTracking[TRACKING_NONE] = 0;
  fTracking[TRACKING_HOUGH] = new HarpoHoughTracking();
  fTracking[TRACKING_KALMAN] = new HarpoKalmanTracking();
  fTracking[TRACKING_KALMANNEW] = new HarpoKalmanNew();
  fTracking[TRACKING_PH] = new HarpoTrackingPh();
  //fTracking1->Init();
  for(UInt_t i = 0; i<kNtracking; i++){
    if(i == TRACKING_NONE) continue;
    fTracking[i]->Init();
    fTracking[i]->SetConfig();
  }

  fMatching[MATCHING_NONE] = 0;
  fMatching[MATCHING_BASIC] = new HarpoMatching();
  fMatching[MATCHING_VERTEX] = new HarpoMatchingVertex();
  for(UInt_t i = 0; i<kNmatching; i++){
    if(i == MATCHING_NONE) continue;
    fMatching[i]->Init();
    fMatching[i]->SetConfig();
  }

  fVertexing[VERTEXING_NONE] = 0;
  fVertexing[VERTEXING_BASIC] = new HarpoVertexing();
  for(UInt_t i = 0; i<kNvertexing; i++){
    if(i == VERTEXING_NONE) continue;
    fVertexing[i]->Init();
    fVertexing[i]->SetConfig();
  }

  fAnalysis[ANALYSIS_NONE] = 0;
  fAnalysis[ANALYSIS_ANALYSEVERTEX3D] = new HarpoAnalyseVertex3D();
  fAnalysis[ANALYSIS_ANALYSEBERTRAND] = new HarpoAnalyseBertrand();
  fAnalysis[ANALYSIS_ANALYSEETRACK] = new HarpoAnalyseEtrack();
  fAnalysis[ANALYSIS_ANALYSEPATTERN] = new HarpoAnalysePattern();
  fAnalysis[ANALYSIS_ANALYSEPEDESTALSHIFT] = new HarpoAnalysePedestalShift();
  fAnalysis[ANALYSIS_TEMPLATE] = new HarpoAnalyseTemplate();
  for(UInt_t i = 0; i<kNanalysis; i++){
    if(i == ANALYSIS_NONE) continue;
    fAnalysis[i]->Init();
    fAnalysis[i]->SetConfig();
  }

  fSaturation = new HarpoAnalysePedestalShift();
  fSaturation->Init();



  fTrackFitting = new HarpoKalmanFitting();
  fTrackFitting->Init();

  fBaselineFluct = new HarpoAnalyseBaselineFluct();
  fBaselineFluct->Init();

  fSelector[SELECTOR_NONE] = 0;
  fSelector[SELECTOR_TEMPLATE] = new HarpoEventSelector();
  fSelector[SELECTOR_VERTEX] = new HarpoSelectorVertex();
  fSelector[SELECTOR_PILEUP] = new HarpoSelectorPileUp();
  fSelector[SELECTOR_STRAIGHTTRACKS] = new HarpoSelectorStraightTracks();
  for(UInt_t i = 0; i<kNselector; i++){
    if(i == SELECTOR_NONE) continue;
    fSelector[i]->Init();
    fSelector[i]->SetConfig();
  }
  // fEventSelector = new HarpoEventSelector();
  // fEventSelector->Init();
  // fSelectorSelectorVertex = new HarpoSelectorVertex();
  // fSelectorSelectorVertex->Init();
  // fSelectorSelectorPileUp = new HarpoSelectorPileUp();
  // fSelectorSelectorPileUp->Init();
  // fSelectorSelectorStraightTracks = new HarpoSelectorStraightTracks();
  // fSelectorSelectorStraightTracks->Init();

  fReader = new HarpoReader( cfg );


  if ( fReader->Init(hSyncTime) ) {
    // hdr = fReader->GetRunHeader();
  }else{
    printf ("Int ERROR exiting ...\n");
    return;
  }

  printf ("Initialized\n");
 
  fNevt = 0;

  fEvent = 0;

  fHistEvent[0] = new TH2F("fHistEventX",";time [30ns bin]; X channel",512,0,512,288,0,288);
  fHistEvent[1] = new TH2F("fHistEventY",";time [30ns bin]; Y channel",512,0,512,288,0,288);

  fHistSpectrum[0] = new TH1F("fHistSpectrumX",";time [30ns bin]; X Q [ADC]",512,0,512);
  fHistSpectrum[1] = new TH1F("fHistSpectrumY",";time [30ns bin]; Y Q [ADC]",512,0,512);

  fHistEventEmpty[0] = new TH2F("fHistEventEmptyX",";time [30ns bin]; X channel",512,0,512,288,0,288);
  fHistEventEmpty[1] = new TH2F("fHistEventEmptyY",";time [30ns bin]; Y channel",512,0,512,288,0,288);

  UInt_t xsize1   = 200;
  UInt_t xsize2   = 800;
  UInt_t mainx   = xsize1 + xsize2;
  UInt_t mainy   = 700;

  gStyle->SetFrameBorderMode(1);
  gStyle->SetFrameBorderSize(1);
  gStyle->SetOptStat(0);

  TGVerticalFrame* f1 = new TGVerticalFrame(this,xsize1,mainy,kVerticalFrame);
  TGVerticalFrame* f2 = new TGVerticalFrame(this,xsize2,mainy,kVerticalFrame);
  this->AddFrame(f1,new TGLayoutHints(kLHintsLeft | kLHintsExpandY,5,5,5,5));
  this->AddFrame(f2,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY,5,5,5,5));
  TGVerticalFrame* f20 = new TGVerticalFrame(f2,xsize2,mainy,kVerticalFrame);
  f2->AddFrame(f20,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY,5,5,5,5));
  TGHorizontalFrame* f21 = new TGHorizontalFrame(f2,xsize2,150,kHorizontalFrame);
  f2->AddFrame(f21,new TGLayoutHints(kLHintsExpandX | kLHintsBottom ,5,5,5,5));

  BuildButtonsFrame(f1);
  BuildDisplayFrame(f20);
  BuildInfoFrame(f21);
  
  MapSubwindows();
  MapWindow();
  SetWindowName("HARPO Reco Monitor");
  MoveResize(0,0,mainx,mainy);

  Layout();

  fAutoScale = kFALSE;

  SetStyle();


  DisplayEvent();

}



void HarpoRecoMonitorGui::CloseWindow()
{
   // Got close message for this MainFrame. Terminate the application
   // or returns from the TApplication event loop (depending on the
   // argument specified in TApplication::Run()).

   gApplication->Terminate(0);


}



void HarpoRecoMonitorGui::BuildDisplayFrame(TGVerticalFrame* f20)
{

  UInt_t xsize2 = f20->GetWidth();
  UInt_t mainy = f20->GetHeight();

  fEventLabel = new TGLabel(f20,"NO DATA");
  fEventLabel->SetHeight(40);
  f20->AddFrame(fEventLabel,new TGLayoutHints(kLHintsExpandX,5,5,5,5));

  fTab = new TGTab(f20, xsize2, mainy);

  TGCompositeFrame *tf = fTab->AddTab("Raw maps");
  ecTabRaw = new TRootEmbeddedCanvas("ecTabRaw",tf,xsize2,mainy);
  tf->AddFrame(ecTabRaw,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY,5,5,5,5));

  tf = fTab->AddTab("Noise Suppr");
  ecTabNoiseSuppr = new TRootEmbeddedCanvas("ecTabNoiseSuppr",tf,xsize2,mainy);
  tf->AddFrame(ecTabNoiseSuppr,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY,5,5,5,5));
  
  tf = fTab->AddTab("Clusters");
  ecTabClusters = new TRootEmbeddedCanvas("ecTabClusters",tf,xsize2,mainy);
  tf->AddFrame(ecTabClusters,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY,5,5,5,5));

  tf = fTab->AddTab("Tracking");
  ecTabClustersTracks = new TRootEmbeddedCanvas("ecTabClustersTracks",tf,xsize2,mainy);
  tf->AddFrame(ecTabClustersTracks,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY,5,5,5,5));

  tf = fTab->AddTab("Tracks");
  ecTabTracks = new TRootEmbeddedCanvas("ecTabTracks",tf,xsize2,mainy);
  tf->AddFrame(ecTabTracks,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY,5,5,5,5));

  tf = fTab->AddTab("Matching");
  ecTabMatching = new TRootEmbeddedCanvas("ecTabMatching",tf,xsize2,mainy);
  tf->AddFrame(ecTabMatching,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY,5,5,5,5));

  tf = fTab->AddTab("Vertexing");
  ecTabVertexing = new TRootEmbeddedCanvas("ecTabVertex",tf,xsize2,mainy);
  tf->AddFrame(ecTabVertexing,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY,5,5,5,5));

  tf = fTab->AddTab("Vertexes");
  ecTabVertex = new TRootEmbeddedCanvas("ecTabVertex",tf,xsize2,mainy);
  tf->AddFrame(ecTabVertex,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY,5,5,5,5));

  tf = fTab->AddTab("3D");
  ecTab3D = new TRootEmbeddedCanvas("ecTab3D",tf,xsize2,mainy);
  tf->AddFrame(ecTab3D,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY,5,5,5,5));

  tf = fTab->AddTab("Sim");
  ecTabSim = new TRootEmbeddedCanvas("ecTabSim",tf,xsize2,mainy);
  tf->AddFrame(ecTabSim,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY,5,5,5,5));

  tf = fTab->AddTab("Analysis");
  ecTabAnalysis = new TRootEmbeddedCanvas("ecTabAnalysis",tf,xsize2,mainy);
  tf->AddFrame(ecTabAnalysis,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY,5,5,5,5));

  f20->AddFrame(fTab,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY,5,5,5,5));



  ecTabRaw->GetCanvas()->SetName("cTabRaw");
  ecTabRaw->GetCanvas()->Divide(2);
  ecTabNoiseSuppr->GetCanvas()->SetName("cTabNoiseSuppr");
  ecTabNoiseSuppr->GetCanvas()->Divide(2);
  ecTabClusters->GetCanvas()->SetName("cTabClusters");
  ecTabClusters->GetCanvas()->Divide(2);
  ecTabClustersTracks->GetCanvas()->SetName("cTabClustersTracks");
  ecTabClustersTracks->GetCanvas()->Divide(2);
  // ((HarpoTrackingPh*)fTracking2)->SetCanvas(ecTabClustersTracks->GetCanvas()->GetPad(1),0);
  // ((HarpoTrackingPh*)fTracking2)->SetHist(fHistEvent[0],0);
  // ((HarpoTrackingPh*)fTracking2)->SetCanvas(ecTabClustersTracks->GetCanvas()->GetPad(2),1);
  // ((HarpoTrackingPh*)fTracking2)->SetHist(fHistEvent[1],1);
  ecTabTracks->GetCanvas()->SetName("cTabTracks");
  ecTabTracks->GetCanvas()->Divide(2);
  ecTabMatching->GetCanvas()->SetName("cTabMatching");
  ecTabMatching->GetCanvas()->Divide(2);
  ecTab3D->GetCanvas()->SetName("cTab3D");
  ecTab3D->GetCanvas()->Divide(2);
  ecTabSim->GetCanvas()->SetName("cTabSim");
  ecTabSim->GetCanvas()->Divide(2);
  ecTabVertexing->GetCanvas()->SetName("cTabVertexing");
  ecTabVertexing->GetCanvas()->Divide(2);
  ecTabVertex->GetCanvas()->SetName("cTabVertex");
  ecTabVertex->GetCanvas()->Divide(2);
  ecTabAnalysis->GetCanvas()->SetName("cTabAnalysis");
  ecTabAnalysis->GetCanvas()->Divide(2);

}

void HarpoRecoMonitorGui::BuildInfoFrame(TGHorizontalFrame* f21)
{

  UInt_t xsize = f21->GetWidth();
  //  UInt_t xsize2 = xsize/4;
  UInt_t ysize = f21->GetHeight();
  //  UInt_t ysize2 = 20;

  // TGLayoutHints* fLayout1 = new TGLayoutHints(kLHintsLeft ,5,5,5,5);
  // TGLayoutHints* fLayout2 = new TGLayoutHints(kLHintsRight ,5,5,5,5);
  TGLayoutHints* fLayout3 = new TGLayoutHints(kLHintsTop | kLHintsExpandX ,5,5,5,5);
  //  TGLayoutHints* fLayout4 = new TGLayoutHints(kLHintsTop | kLHintsLeft,5,5,5,5);


  //  ecSideSummary = new TRootEmbeddedCanvas("ecSideSummary",f1,xsize1,300);
  fInfoBox = new TGListBox(f21);
  fInfoBox->Resize(xsize,ysize);
  f21->AddFrame(fInfoBox,fLayout3);

  // TGVerticalFrame* f211 = new TGVerticalFrame(f21,xsize2,ysize,kVerticalFrame);
  // TGLabel* fBaselineLabel = new TGLabel(f211, "Noise suppression");
  // TGHorizontalFrame* f2111 = new TGHorizontalFrame(f211,xsize2,ysize2,kHorizontalFrame);
  // TGLabel* fNchLabel = new TGLabel(f2111, "#channels");
  // fChooseNch    = new TGNumberEntry(f2111);
  // fChooseNch->SetNumber(30);
  // TGHorizontalFrame* f2112 = new TGHorizontalFrame(f211,xsize2,ysize2,kHorizontalFrame);
  // TGLabel* fSigLabel = new TGLabel(f2112, "#sigma");
  // fChooseSig    = new TGNumberEntry(f2112);
  // fChooseSig->SetNumber(20);
  // TGHorizontalFrame* f2113 = new TGHorizontalFrame(f211,xsize2,ysize2,kHorizontalFrame);
  // TGLabel* fDeltaLabel = new TGLabel(f2113, "#delta");
  // fChooseDelta    = new TGNumberEntry(f2113);
  // fChooseDelta->SetNumber(5);
  // TGHorizontalFrame* f2114 = new TGHorizontalFrame(f211,xsize2,ysize2,kHorizontalFrame);
  // TGLabel* fTruncLLabel = new TGLabel(f2114, "TruncL");
  // fChooseTruncL    = new TGNumberEntry(f2114);
  // fChooseTruncL->SetNumber(10);
  // TGHorizontalFrame* f2115 = new TGHorizontalFrame(f211,xsize2,ysize2,kHorizontalFrame);
  // TGLabel* fTruncHLabel = new TGLabel(f2115, "TruncH");
  // fChooseTruncH    = new TGNumberEntry(f2115);
  // fChooseTruncH->SetNumber(70);
  // f21->AddFrame(f211,fLayout4);
  // f211->AddFrame(fBaselineLabel,fLayout3);
  // f211->AddFrame(f2111,fLayout3);
  // f211->AddFrame(f2112,fLayout3);
  // f211->AddFrame(f2113,fLayout3);
  // f211->AddFrame(f2114,fLayout3);
  // f211->AddFrame(f2115,fLayout3);
  // f2111->AddFrame(fNchLabel,fLayout1);
  // f2111->AddFrame(fChooseNch,fLayout2);
  // f2112->AddFrame(fChooseSig,fLayout2);
  // f2112->AddFrame(fSigLabel,fLayout1);
  // f2113->AddFrame(fChooseDelta,fLayout2);
  // f2113->AddFrame(fDeltaLabel,fLayout1);
  // f2114->AddFrame(fChooseTruncL,fLayout2);
  // f2114->AddFrame(fTruncLLabel,fLayout1);
  // f2115->AddFrame(fChooseTruncH,fLayout2);
  // f2115->AddFrame(fTruncHLabel,fLayout1);



  // TGVerticalFrame* f212 = new TGVerticalFrame(f21,xsize2,ysize,kVerticalFrame);
  // TGLabel* fClusteringLabel = new TGLabel(f212, "Clustering");
  // TGHorizontalFrame* f2121 = new TGHorizontalFrame(f212,xsize2,ysize2,kHorizontalFrame);
  // TGLabel* fThrLabel = new TGLabel(f2121, "Threshold");
  // fChooseThr    = new TGNumberEntry(f2121);
  // Double_t thr = 3;
  // gHConfig->Lookup("Clustering.Thr",thr);
  // fChooseThr->SetNumber(thr);
  // TGHorizontalFrame* f2122 = new TGHorizontalFrame(f212,xsize2,ysize2,kHorizontalFrame);
  // TGLabel* fNoiseThrLabel = new TGLabel(f2122, "Noise Thr");
  // fChooseNoiseThr    = new TGNumberEntry(f2122);
  // Double_t noiseThr = 10;
  // gHConfig->Lookup("Clustering.NoiseThr",noiseThr);
  // fChooseNoiseThr->SetNumber(noiseThr);
  // f21->AddFrame(f212,fLayout4);
  // f212->AddFrame(fClusteringLabel,fLayout3);
  // f212->AddFrame(f2121,fLayout3);
  // f212->AddFrame(f2122,fLayout3);
  // f2121->AddFrame(fThrLabel,fLayout1);
  // f2121->AddFrame(fChooseThr,fLayout2);
  // f2122->AddFrame(fNoiseThrLabel,fLayout1);
  // f2122->AddFrame(fChooseNoiseThr,fLayout2);


}

void HarpoRecoMonitorGui::BuildButtonsFrame(TGVerticalFrame* f1)
{

  UInt_t xsize1 = f1->GetWidth();
  UInt_t ysize   = 20;
  //  TGLayoutHints* fLayout1 = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY,5,5,5,5);
  //TGLayoutHints* fLayout12 = new TGLayoutHints(kLHintsLeft,5,5,5,5);
  TGLayoutHints* fLayout2 = new TGLayoutHints(kLHintsExpandX | kLHintsTop,5,5,5,5);
  //  TGLayoutHints* fLayout3 = new TGLayoutHints(kLHintsBottom | kLHintsCenterX,5,5,5,5);
  //TGLayoutHints* fLayout3 = new TGLayoutHints(kLHintsBottom ,5,5,5,5);

  TGHorizontalFrame* autorefreshFrame = new TGHorizontalFrame(f1,xsize1,ysize,kHorizontalFrame);
  TGLabel* fDelayLabel = new TGLabel(f1, "");
  fChooseDelay    = new TGNumberEntry(autorefreshFrame);
  fChooseDelay->Resize(xsize1 -20  ,ysize);
  fAutoRefreshButton = new TGTextButton(autorefreshFrame, "Get Event", M_DISPLAY_EVENT);
  fAutoRefreshButton->Resize(20, ysize);
  fAutoRefreshButton->Associate(this);
  //  fChooseDir->Select(1);
  autorefreshFrame->AddFrame(fAutoRefreshButton,fLayout2);
  autorefreshFrame->AddFrame(fDelayLabel,fLayout2);//new TGLayoutHints(kLHintsExpandX | kLHintsCenterY,5,5,5,5));
  autorefreshFrame->AddFrame(fChooseDelay,fLayout2);
  Int_t firstevent = gHConfig->GetFromEvent();
  fChooseDelay->SetNumber(firstevent);


  fDisplayEvent = new TGTextButton(f1,"Display Current Event",M_DISPLAY_EVENT);
  fDisplayEvent->Associate(this);

  fSave = new TGTextButton(f1,"Save Current Event",M_SAVE);
  fSave->Associate(this);

  fNextEvent = new TGTextButton(f1,"Next Event",M_NEXT_EVENT);
  fNextEvent->Associate(this);
  //  fNextEvent->SetState(kButtonDisabled,kFALSE);

  fPrevEvent = new TGTextButton(f1,"Previous Event",M_PREV_EVENT);
  fPrevEvent->Associate(this);
  //  fPrevEvent->SetState(kButtonDisabled,kFALSE);

  fFindEvent = new TGTextButton(f1,"Find Next Event",M_FIND_EVENT);
  fFindEvent->Associate(this);
  //  fPrevEvent->SetState(kButtonDisabled,kFALSE);

  TGHorizontalFrame* fCheckShowSpectrumFrame = new TGHorizontalFrame(f1,xsize1,ysize,kHorizontalFrame);
  TGLabel* fCheckShowSpectrumLabel = new TGLabel(fCheckShowSpectrumFrame, "Show spectrum");
  fCheckShowSpectrum = new TGCheckButton(fCheckShowSpectrumFrame);
  fCheckShowSpectrumFrame->AddFrame(fCheckShowSpectrum,new TGLayoutHints(kLHintsLeft,5,5,5,5));
  fCheckShowSpectrumFrame->AddFrame(fCheckShowSpectrumLabel,new TGLayoutHints(kLHintsLeft,5,5,5,5));

  TGHorizontalFrame* fCheckAnimClusteringFrame = new TGHorizontalFrame(f1,xsize1,ysize,kHorizontalFrame);
  TGLabel* fCheckAnimClusteringLabel = new TGLabel(fCheckAnimClusteringFrame, "Show clustering");
  fCheckAnimClustering = new TGCheckButton(fCheckAnimClusteringFrame);
  fCheckAnimClusteringFrame->AddFrame(fCheckAnimClustering,new TGLayoutHints(kLHintsLeft,5,5,5,5));
  fCheckAnimClusteringFrame->AddFrame(fCheckAnimClusteringLabel,new TGLayoutHints(kLHintsLeft,5,5,5,5));

  TGHorizontalFrame* fCheckAnimTrackingFrame = new TGHorizontalFrame(f1,xsize1,ysize,kHorizontalFrame);
  TGLabel* fCheckAnimTrackingLabel = new TGLabel(fCheckAnimTrackingFrame, "Show Kalman tracking");
  fCheckAnimTracking = new TGCheckButton(fCheckAnimTrackingFrame);
  fCheckAnimTrackingFrame->AddFrame(fCheckAnimTracking,new TGLayoutHints(kLHintsLeft,5,5,5,5));
  fCheckAnimTrackingFrame->AddFrame(fCheckAnimTrackingLabel,new TGLayoutHints(kLHintsLeft,5,5,5,5));

  TGHorizontalFrame* fCheckAnimFittingFrame = new TGHorizontalFrame(f1,xsize1,ysize,kHorizontalFrame);
  TGLabel* fCheckAnimFittingLabel = new TGLabel(fCheckAnimFittingFrame, "Show Kalman fitting");
  fCheckAnimFitting = new TGCheckButton(fCheckAnimFittingFrame);
  fCheckAnimFittingFrame->AddFrame(fCheckAnimFitting,new TGLayoutHints(kLHintsLeft,5,5,5,5));
  fCheckAnimFittingFrame->AddFrame(fCheckAnimFittingLabel,new TGLayoutHints(kLHintsLeft,5,5,5,5));

  TGHorizontalFrame* triggerFrame = new TGHorizontalFrame(f1,xsize1,ysize,kHorizontalFrame);
  fChooseTrigger = new TGComboBox(triggerFrame, "Trigger");
  fChooseTrigger->AddEntry("All Trigger Lines",-2);
  fChooseTrigger->AddEntry("Unknown",-1);
  fChooseTrigger->AddEntry("TTZ",0);
  fChooseTrigger->AddEntry("Gamma",2);
  fChooseTrigger->AddEntry("No Mesh",3);
  fChooseTrigger->AddEntry("Inv Mesh",4);
  fChooseTrigger->AddEntry("No Up",5);
  fChooseTrigger->AddEntry("---",6);
  fChooseTrigger->AddEntry("Gamma, L",7);
  fChooseTrigger->AddEntry("No Mesh, L",8);
  fChooseTrigger->AddEntry("Inv Mesh, L",9);
  fChooseTrigger->AddEntry("No Up, L",10);
  fChooseTrigger->AddEntry("No PM, L",11);
  fChooseTrigger->AddEntry("No L",12);
  fChooseTrigger->AddEntry("---",13);
  fChooseTrigger->AddEntry("Cosmic",14);
  fChooseTrigger->AddEntry("---",15);
  fChooseTrigger->Select(-2);
  fChooseTrigger->Resize(xsize1 -20  ,ysize);
  triggerFrame->AddFrame(fChooseTrigger,fLayout2);

  TGHorizontalFrame* eventTypeFrame = new TGHorizontalFrame(f1,xsize1,ysize,kHorizontalFrame);
  fChooseEventType = new TGComboBox(eventTypeFrame, "Event Type");
  fChooseEventType->AddEntry("All events",-1);
  fChooseEventType->AddEntry("Empty",0);
  fChooseEventType->AddEntry("Depot",1);
  fChooseEventType->AddEntry("Traversing",3);
  fChooseEventType->AddEntry("Created",4);
  fChooseEventType->AddEntry("Contained",5);
  fChooseEventType->AddEntry("Gamma Candidate",6);
  fChooseEventType->AddEntry("Delta",7);
  fChooseEventType->AddEntry("2 Tracks other",8);
  fChooseEventType->AddEntry("Shower",9);
  fChooseEventType->AddEntry("Other",10);
  fChooseEventType->AddEntry("Good Gamma Candidate",11);
  fChooseEventType->AddEntry("Good Triplet Candidate",12);
  fChooseEventType->Select(6);
  fChooseEventType->Resize(xsize1 -20  ,ysize);
  eventTypeFrame->AddFrame(fChooseEventType,fLayout2);

  TGHorizontalFrame* clusteringTypeFrame = new TGHorizontalFrame(f1,xsize1,ysize,kHorizontalFrame);
  TGLabel* clusteringLabel = new TGLabel(clusteringTypeFrame, "Clustering");
  fChooseClusteringType = new TGComboBox(clusteringTypeFrame, "Clustering");
  for(UInt_t i = 0; i<kNclustering; i++){
    switch(i){
    case CLUSTERING_NONE: fChooseClusteringType->AddEntry("NONE",i); break;
    case CLUSTERING_BASIC: fChooseClusteringType->AddEntry("Peaks",i); break;
    case CLUSTERING_BLOCS: fChooseClusteringType->AddEntry("2D blocs",i); break;
    default: fChooseClusteringType->AddEntry("UNKNOWN",i); break;
    }
  }
  // fChooseClusteringType->AddEntry("Basic (obsolete)",1);
  // fChooseClusteringType->AddEntry("Peaks",2);
  // fChooseClusteringType->AddEntry("2D blocs",3);
  fChooseClusteringType->Select(fClusteringType);
  fChooseClusteringType->Resize(xsize1 -20  ,ysize);
  clusteringTypeFrame->AddFrame(clusteringLabel,fLayout2);
  clusteringTypeFrame->AddFrame(fChooseClusteringType,fLayout2);
  TGTextButton* fConfClustering = new TGTextButton(clusteringTypeFrame,"Config",M_CONF_CLUSTERING);
  fConfClustering->Associate(this);
  clusteringTypeFrame->AddFrame(fConfClustering,fLayout2);

  TGHorizontalFrame* trackingTypeFrame = new TGHorizontalFrame(f1,xsize1,ysize,kHorizontalFrame);
  TGLabel* trackingLabel = new TGLabel(trackingTypeFrame, "Tracking");
  fChooseTrackingType = new TGComboBox(trackingTypeFrame, "Tracking");
  for(UInt_t i = 0; i<kNtracking; i++){
    switch(i){
    case TRACKING_NONE: fChooseTrackingType->AddEntry("NONE",i); break;
    case TRACKING_HOUGH: fChooseTrackingType->AddEntry("Hough multiscale",i); break;
    case TRACKING_KALMAN: fChooseTrackingType->AddEntry("Kalman",i); break;
    case TRACKING_KALMANNEW: fChooseTrackingType->AddEntry("Kalman (new)",i); break;
    case TRACKING_PH: fChooseTrackingType->AddEntry("Kalman (old)",i); break;
    }
  } 
  // fChooseTrackingType->AddEntry("NONE",0);
  // fChooseTrackingType->AddEntry("Hough, fixed binning (obsolete)",1);
  // fChooseTrackingType->AddEntry("Kalman",2);
  // fChooseTrackingType->AddEntry("Hough multiscale",3);
  fChooseTrackingType->Select(fTrackingType);
  fChooseTrackingType->Resize(xsize1 -20  ,ysize);
  trackingTypeFrame->AddFrame(trackingLabel,fLayout2);
  trackingTypeFrame->AddFrame(fChooseTrackingType,fLayout2);
  TGTextButton* fConfTracking = new TGTextButton(trackingTypeFrame,"Config",M_CONF_TRACKING);
  fConfTracking->Associate(this);
  trackingTypeFrame->AddFrame(fConfTracking,fLayout2);

  TGHorizontalFrame* matchingTypeFrame = new TGHorizontalFrame(f1,xsize1,ysize,kHorizontalFrame);
  TGLabel* matchingLabel = new TGLabel(matchingTypeFrame, "Matching");
  fChooseMatchingType = new TGComboBox(matchingTypeFrame, "Matching");
  for(UInt_t i = 0; i<kNmatching; i++){
    switch(i){
    case MATCHING_NONE: fChooseMatchingType->AddEntry("NONE",i); break;
    case MATCHING_BASIC: fChooseMatchingType->AddEntry("Basic",i); break;
    case MATCHING_VERTEX: fChooseMatchingType->AddEntry("Vertex",i); break;
    }
  } 
  fChooseMatchingType->Select(fMatchingType);
  fChooseMatchingType->Resize(xsize1 -20  ,ysize);
  matchingTypeFrame->AddFrame(matchingLabel,fLayout2);
  matchingTypeFrame->AddFrame(fChooseMatchingType,fLayout2);
  TGTextButton* fConfMatching = new TGTextButton(matchingTypeFrame,"Config",M_CONF_MATCHING);
  fConfMatching->Associate(this);
  matchingTypeFrame->AddFrame(fConfMatching,fLayout2);

  TGHorizontalFrame* vertexingTypeFrame = new TGHorizontalFrame(f1,xsize1,ysize,kHorizontalFrame);
  TGLabel* vertexingLabel = new TGLabel(vertexingTypeFrame, "Vertexing");
  fChooseVertexingType = new TGComboBox(vertexingTypeFrame, "Vertexing");
  for(UInt_t i = 0; i<kNvertexing; i++){
    switch(i){
    case VERTEXING_NONE: fChooseVertexingType->AddEntry("NONE",i); break;
    case VERTEXING_BASIC: fChooseVertexingType->AddEntry("Basic",i); break;
    }
  } 
  fChooseVertexingType->Select(fVertexingType);
  fChooseVertexingType->Resize(xsize1 -20  ,ysize);
  vertexingTypeFrame->AddFrame(vertexingLabel,fLayout2);
  vertexingTypeFrame->AddFrame(fChooseVertexingType,fLayout2);
  TGTextButton* fConfVertexing = new TGTextButton(vertexingTypeFrame,"Config",M_CONF_VERTEXING);
  fConfVertexing->Associate(this);
  vertexingTypeFrame->AddFrame(fConfVertexing,fLayout2);

  TGHorizontalFrame* analysisTypeFrame = new TGHorizontalFrame(f1,xsize1,ysize,kHorizontalFrame);
  TGLabel* analysisLabel = new TGLabel(analysisTypeFrame, "Analysis");
  fChooseAnalysisType = new TGComboBox(analysisTypeFrame, "Analysis");
  for(UInt_t i = 0; i<kNanalysis; i++){
    switch(i){
    case ANALYSIS_NONE: fChooseAnalysisType->AddEntry("NONE",i); break;
    case ANALYSIS_ANALYSEBERTRAND: fChooseAnalysisType->AddEntry("AnalyseBertrand",i); break;
    case ANALYSIS_ANALYSEVERTEX3D: fChooseAnalysisType->AddEntry("AnalyseVertex3D",i); break;
    case ANALYSIS_ANALYSEETRACK: fChooseAnalysisType->AddEntry("AnalyseEtrack",i); break;
    case ANALYSIS_ANALYSEPATTERN: fChooseAnalysisType->AddEntry("AnalysePattern",i); break;
    case ANALYSIS_ANALYSEPEDESTALSHIFT: fChooseAnalysisType->AddEntry("AnalysePedestalShift",i); break;
    case ANALYSIS_TEMPLATE: fChooseAnalysisType->AddEntry("Template",i); break;
    }
  } 
  fChooseAnalysisType->Select(fAnalysisType);
  fChooseAnalysisType->Resize(xsize1 -20  ,ysize);
  analysisTypeFrame->AddFrame(analysisLabel,fLayout2);
  analysisTypeFrame->AddFrame(fChooseAnalysisType,fLayout2);
  TGTextButton* fConfAnalysis = new TGTextButton(analysisTypeFrame,"Config",M_CONF_ANALYSIS);
  fConfAnalysis->Associate(this);
  analysisTypeFrame->AddFrame(fConfAnalysis,fLayout2);

  TGHorizontalFrame* selectorTypeFrame = new TGHorizontalFrame(f1,xsize1,ysize,kHorizontalFrame);
  TGLabel* selectorLabel = new TGLabel(selectorTypeFrame, "Selector");
  fChooseSelectorType = new TGComboBox(selectorTypeFrame, "Event Selector");
  // fChooseEventSelector->AddEntry("NONE",0);
  // fChooseEventSelector->AddEntry("HarpoSelectorStraightTracks",2);
  // fChooseEventSelector->AddEntry("HarpoSelectorPileUp",3);
  // fChooseEventSelector->AddEntry("HarpoSelectorVertex",4);
  // fChooseEventSelector->AddEntry("HarpoEventSelector",1);
  // fChooseEventSelector->Resize(xsize1 -20  ,ysize);
  // eventSelectorFrame->AddFrame(fChooseEventSelector,fLayout2);
  for(UInt_t i = 0; i<kNselector; i++){
    switch(i){
    case SELECTOR_NONE: fChooseSelectorType->AddEntry("NONE",i); break;
    case SELECTOR_TEMPLATE: fChooseSelectorType->AddEntry("Template",i); break;
    case SELECTOR_PILEUP: fChooseSelectorType->AddEntry("PileUp",i); break;
    case SELECTOR_VERTEX: fChooseSelectorType->AddEntry("Vertex",i); break;
    case SELECTOR_STRAIGHTTRACKS: fChooseSelectorType->AddEntry("StraightTracks",i); break;
    }
  } 
  fChooseSelectorType->Select(fSelectorType);
  fChooseSelectorType->Resize(xsize1 -20  ,ysize);
  selectorTypeFrame->AddFrame(selectorLabel,fLayout2);
  selectorTypeFrame->AddFrame(fChooseSelectorType,fLayout2);
  TGTextButton* fConfSelector = new TGTextButton(selectorTypeFrame,"Config",M_CONF_SELECTOR);
  fConfSelector->Associate(this);
  selectorTypeFrame->AddFrame(fConfSelector,fLayout2);




  f1->AddFrame(autorefreshFrame,fLayout2);
  f1->AddFrame(fDisplayEvent,fLayout2);
  f1->AddFrame(fSave,fLayout2);
  f1->AddFrame(fNextEvent,fLayout2);
  f1->AddFrame(fPrevEvent,fLayout2);
  f1->AddFrame(fFindEvent,fLayout2);
  f1->AddFrame(fCheckShowSpectrumFrame,fLayout2);
  f1->AddFrame(fCheckAnimClusteringFrame,fLayout2);
  f1->AddFrame(fCheckAnimTrackingFrame,fLayout2);
  f1->AddFrame(fCheckAnimFittingFrame,fLayout2);
  f1->AddFrame(triggerFrame,fLayout2);
  f1->AddFrame(eventTypeFrame,fLayout2);
  f1->AddFrame(clusteringTypeFrame,fLayout2);
  f1->AddFrame(trackingTypeFrame,fLayout2);
  f1->AddFrame(matchingTypeFrame,fLayout2);
  f1->AddFrame(vertexingTypeFrame,fLayout2);
  f1->AddFrame(analysisTypeFrame,fLayout2);
  f1->AddFrame(selectorTypeFrame,fLayout2);
  //f1->AddFrame(ecSideSummary,fLayout1);
}







void HarpoRecoMonitorGui::SetListOfRuns(TGComboBox* /* box */, const char* /* dirname */)
{
}


Bool_t HarpoRecoMonitorGui::GetNextEvent()
{

  return kTRUE;

}

void HarpoRecoMonitorGui::InitEvent(HarpoEvent* evt)
{
  Info("DisplayMap","%p",evt);

  if(fEvent == 0) return;

  for(Int_t ndet=0;ndet<2;ndet++) {
    if(!gHDetSet->isExist(ndet)) continue;
    HarpoDccMap * m = evt->GetDccMap(ndet);
    if ( m == NULL ) continue;
    fHistEvent[ndet]->Reset();
    fHistSpectrum[ndet]->Reset();
    for(Int_t i=1;i<NADC;i++){ //Time bins
      //      Double_t sigmaQ = 0;
      Double_t Qt=0;
      for(Int_t j=0;j<NCHAN;j++){ // Channels
        Double_t q = m->GetData(j,i);
        fHistEvent[ndet]->SetBinContent(i+1,j+1,q);
        if(q >= 0)
          Qt=Qt+q;
      }
      fHistSpectrum[ndet]->SetBinContent(i+1,Qt);
    }  
    fHistEvent[ndet]->SetMinimum(1);
    fHistEvent[ndet]->SetMaximum(4096);
  }
}


void HarpoRecoMonitorGui::DisplayMap(TRootEmbeddedCanvas* ecTab,Int_t proj,Int_t copy)
{
  Info("DisplayMap","%p",fEvent);

  if(fEvent == 0) return;

  //  if(!cTabEvent){
  TCanvas* cTab = ecTab->GetCanvas();
  cTab->GetPad(1)->Delete();
  cTab->GetPad(2)->Delete();
  cTab->Divide(2);
  if(proj){
    cTab->GetPad(1)->Divide(1,2);
    cTab->GetPad(2)->Divide(1,2);
  }

  TLatex* latex = new TLatex();
  latex->SetTextFont(132);
  latex->SetTextAlign(12);
  latex->SetTextSize(0.08);

  for(Int_t ndet=0;ndet<2;ndet++) {
    if(!gHDetSet->isExist(ndet)) continue;
    HarpoDccMap * m = fEvent->GetDccMap(ndet);
    if ( m == NULL ) continue;
    Int_t color = ndet? kRed : kBlue;
    latex->SetTextColor(color);
    // TH2F* hEvent = new TH2F("hEvent",";time [tb]; channel",508,0,508,304,0,304);
    // fHistEvent[ndet]->Reset();
    // fHistSpectrum[ndet]->Reset();
    // for(Int_t i=1;i<NADC;i++){ //Time bins
    //   Double_t sigmaQ = 0;
    //   Double_t Qt=0;
    //   for(Int_t j=0;j<NCHAN;j++){ // Channels
    //  Double_t q = m->GetData(j,i);
    //  if(proj && q <= -1000) q = 0;
    //  //      hEvent->SetBinContent(i+1,j+1,q);
    //  fHistEvent[ndet]->SetBinContent(i+1,j+1,q);
    //     Qt=Qt+q;
    //   }
    //   fHistSpectrum[ndet]->SetBinContent(i+1,Qt);
    // }  
    // hEvent->SetMinimum(0.1);
    // hEvent->SetMaximum(4096);
    //fHistEvent[ndet]->SetMinimum(0.1);
    fHistEvent[ndet]->SetMinimum(1);
    fHistEvent[ndet]->SetMaximum(4096);

    if(proj){
      MakeNiceHisto(fHistEvent[ndet],cTab->GetPad(ndet+1)->GetPad(1),"col",copy);
    }else
      MakeNiceHisto(fHistEvent[ndet],cTab->GetPad(ndet+1),"colz",copy);
    //      MakeNiceHisto(hEvent,cTab->GetPad(ndet+1),"colz",1);
    
    TLine* line = new TLine();
    line->SetLineWidth(2);
    line->SetLineStyle(2);
    line->DrawLine(0,194,511,194);
    line->DrawLine(0,94,511,94);

    if(ndet==0){
      line->SetLineWidth(1);
      line->SetLineStyle(3);
      line->DrawLine(0,259,511,259);
      line->DrawLine(0,226,511,226);
      line->DrawLine(0,160.5,511,160.5);
      line->DrawLine(0,127.5,511,127.5);
      line->DrawLine(0,61.5,511,61.5);
      line->DrawLine(0,28.5,511,28.5);
    }
    //hEvent->Delete();
  }



  // MakeNiceHisto(hEvent,cTab->GetPad(ndet+1)->GetPad(1),"colz");
  // TH1D* hEventProj = hEvent->ProjectionX();
  if(proj){
    TH1D* hEventProjX = fHistEvent[0]->ProjectionX();
    
    hEventProjX->SetLineColor(kBlue);
    TH1D* hEventProjY = fHistEvent[1]->ProjectionX();
    hEventProjY->SetLineColor(kRed);
    MakeNiceHisto(hEventProjX,cTab->GetPad(1)->GetPad(2),"");
    hEventProjY->DrawCopy("same");
    TH1D* hRatio = (TH1D*)hEventProjX->Clone();
    hRatio->SetLineColor(kBlack);
    hRatio->Divide(hEventProjY);
    hRatio->SetMinimum(0);
    hRatio->SetMaximum(2);
    MakeNiceHisto(hRatio,cTab->GetPad(2)->GetPad(2),"");

    
    TLine* line = new TLine();
    line->SetLineWidth(1);
    line->SetLineStyle(2);
    line->DrawLine(0,1,511,1);
    //  cTab->GetPad(ndet+1)->cd(1);
  }
  cTab->Update();
}



void HarpoRecoMonitorGui::DisplayEmptyMap(TRootEmbeddedCanvas* ecTab,Int_t copy)
{
  Info("DisplayMap","%p",fEvent);

  if(fEvent == 0) return;

  //  if(!cTabEvent){
  TCanvas* cTab = ecTab->GetCanvas();
  cTab->GetPad(1)->Delete();
  cTab->GetPad(2)->Delete();
  cTab->Divide(2);

  TLatex* latex = new TLatex();
  latex->SetTextFont(132);
  latex->SetTextAlign(12);
  latex->SetTextSize(0.08);

  for(Int_t ndet=0;ndet<2;ndet++) {
    if(!gHDetSet->isExist(ndet)) continue;
    Int_t color = ndet? kRed : kBlue;
    latex->SetTextColor(color);
    // TH2F* hEvent = new TH2F("hEvent",";time [tb]; channel",508,0,508,304,0,304);
    //    fHistEvent[ndet]->Reset();

    MakeNiceHisto(fHistEventEmpty[ndet],cTab->GetPad(ndet+1),"col",copy);
    
    TLine* line = new TLine();
    line->SetLineWidth(2);
    line->SetLineStyle(2);
    line->DrawLine(0,194,511,194);
    line->DrawLine(0,94,511,94);

    if(ndet==0){
      line->SetLineWidth(1);
      line->SetLineStyle(3);
      line->DrawLine(0,259,511,259);
      line->DrawLine(0,226,511,226);
      line->DrawLine(0,160.5,511,160.5);
      line->DrawLine(0,127.5,511,127.5);
      line->DrawLine(0,61.5,511,61.5);
      line->DrawLine(0,28.5,511,28.5);
    }
    //hEvent->Delete();
  }

  cTab->Update();
}




// void HarpoRecoMonitorGui::DisplayClusters(TRootEmbeddedCanvas* ecTab)
// {

//   TCanvas* cTab = ecTab->GetCanvas();
//   HarpoRecoEvent* reco = fEvent->GetRecoEvent();
//   TClonesArray* clArray = reco->GetClustersArray();
//   Int_t nCl = clArray->GetEntries();

//   TGraph* gCX = new TGraph();
//   TGraph* gCY = new TGraph();
//   TGraph* gTX = new TGraph();
//   TGraph* gTY = new TGraph();

//   TGraph* gTXnoise = new TGraph();
//   TGraph* gTYnoise = new TGraph();
//   gTXnoise->SetMarkerStyle(28);
//   gTYnoise->SetMarkerStyle(28);
//   // TGraph* gCXnotrack = new TGraph();
//   // TGraph* gCYnotrack = new TGraph();
//   // TGraph* gTXnotrack = new TGraph();
//   // TGraph* gTYnotrack = new TGraph();

//   for(Int_t icl = 0; icl<nCl; icl++){
//     HarpoRecoClusters* cluster = (HarpoRecoClusters*)clArray->At(icl);
//     Int_t ind = cluster->GetIndex();
//     Double_t mean = cluster->GetMean();
//     Int_t plane = cluster->GetPlane();
//     Int_t type = cluster->GetType();
//     Int_t width = cluster->GetWidth();
//     Double_t q = cluster->GetQ();
//     Int_t idcluster = cluster->GetIdClusterTrack();
//     if(plane!=XPLANE && plane !=YPLANE) continue;
//     // if(type == CCLUSTER && width<10) continue;
//     // if(type == TCLUSTER && width>10) continue;
//     if(plane==XPLANE && type == CCLUSTER) gCX->SetPoint(gCX->GetN(),mean,ind+0.5);
//     if(plane==XPLANE && type == TCLUSTER) gTX->SetPoint(gTX->GetN(),ind+0.5,mean);
//     if(plane==YPLANE && type == CCLUSTER) gCY->SetPoint(gCY->GetN(),mean,ind+0.5);
//     if(plane==YPLANE && type == TCLUSTER) gTY->SetPoint(gTY->GetN(),ind+0.5,mean);



//     if(cluster->GetQuality()<0){
//       //      std::cout << "Noisy cluster: " << icl << "  " << cluster->GetQuality() << std::endl;
//       if(plane==XPLANE && type == TCLUSTER) gTXnoise->SetPoint(gTXnoise->GetN(),ind+0.5,mean);
//       if(plane==YPLANE && type == TCLUSTER) gTYnoise->SetPoint(gTYnoise->GetN(),ind+0.5,mean);
//     }
//     // if(idcluster>=0) continue; 
//     // if(plane==0 && type == 0) gCXnotrack->SetPoint(gCXnotrack->GetN(),mean,ind);
//     // if(plane==0 && type == 1) gTXnotrack->SetPoint(gTXnotrack->GetN(),ind,mean);
//     // if(plane==1 && type == 0) gCYnotrack->SetPoint(gCYnotrack->GetN(),mean,ind);
//     // if(plane==1 && type == 1) gTYnotrack->SetPoint(gTYnotrack->GetN(),ind,mean);
//   }

//   gCX->SetMarkerStyle(7);
//   gTX->SetMarkerStyle(7);
//   gCY->SetMarkerStyle(7);
//   gTY->SetMarkerStyle(7);
//   gCX->SetMarkerSize(0.5);
//   gTX->SetMarkerSize(0.5);
//   gCY->SetMarkerSize(0.5);
//   gTY->SetMarkerSize(0.5);
//   gCX->SetMarkerColor(kGray);
//   gCY->SetMarkerColor(kGray);
//   // gCXnotrack->SetMarkerStyle(7);
//   // gTXnotrack->SetMarkerStyle(7);
//   // gCYnotrack->SetMarkerStyle(7);
//   // gTYnotrack->SetMarkerStyle(7);
  
//   std::cout << gCX->GetN() << " " << gCY->GetN() << " " << gTX->GetN() << " " << gTY->GetN() << std::endl;


//   cTab->cd(1);
//   if(gCX->GetN()>0) gCX->Draw("Psame");
//   if(gTX->GetN()>0) gTX->Draw("Psame");
//   if(gTXnoise->GetN()>0) gTXnoise->Draw("Psame");
//   cTab->cd(2);
//   if(gCY->GetN()>0) gCY->Draw("Psame");
//   if(gTY->GetN()>0) gTY->Draw("Psame");
//   if(gTYnoise->GetN()>0) gTYnoise->Draw("Psame");

//   cTab->Update();
// }

void HarpoRecoMonitorGui::DisplayClustersTracks(TRootEmbeddedCanvas* ecTab)
{

  TCanvas* cTab = ecTab->GetCanvas();
  HarpoRecoEvent* reco = fEvent->GetRecoEvent();
  TClonesArray* clArray = reco->GetClustersArray();
  Int_t nCl = clArray->GetEntries();



  TGraph* gX[10];
  TGraph* gY[10];
  TGraph* gXnoise[10];
  TGraph* gYnoise[10];
  for(Int_t i = 0; i<10; i++){
    gX[i] = new TGraph();
    gY[i] = new TGraph();
    gX[i]->SetMarkerStyle(7);
    gY[i]->SetMarkerStyle(7);
    gX[i]->SetMarkerSize(0.5);
    gY[i]->SetMarkerSize(0.5);
    gX[i]->SetMarkerColor(i+2);
    gY[i]->SetMarkerColor(i+2);

    gXnoise[i] = new TGraph();
    gYnoise[i] = new TGraph();
    gXnoise[i]->SetMarkerStyle(28);
    gYnoise[i]->SetMarkerStyle(28);
    gXnoise[i]->SetMarkerSize(1);
    gYnoise[i]->SetMarkerSize(1);
    gXnoise[i]->SetMarkerColor(i+2);
    gYnoise[i]->SetMarkerColor(i+2);
  }

  for(Int_t icl = 0; icl<nCl; icl++){
    HarpoRecoClusters* cluster = (HarpoRecoClusters*)clArray->At(icl);
    Int_t ind = cluster->GetIndex();
    Double_t mean = cluster->GetMean();
    Int_t plane = cluster->GetPlane();
    Int_t type = cluster->GetType();
    Int_t nTr = cluster->GetNtr();
    for(Int_t k = 0; k<nTr; k++){
      Int_t itr = cluster->GetIdClusterTrack(k);
      //    std::cout << "Track: " << itr << std::endl;
      if(itr<0) continue;
      if(itr>=10) continue;
      if(plane!=XPLANE && plane !=YPLANE) continue;
      if(plane==XPLANE && type == CCLUSTER) gX[itr]->SetPoint(gX[itr]->GetN(),mean,ind+0.5);
      if(plane==XPLANE && type == TCLUSTER) gX[itr]->SetPoint(gX[itr]->GetN(),ind+0.5,mean);
      if(plane==YPLANE && type == CCLUSTER) gY[itr]->SetPoint(gY[itr]->GetN(),mean,ind+0.5);
      if(plane==YPLANE && type == TCLUSTER) gY[itr]->SetPoint(gY[itr]->GetN(),ind+0.5,mean);
      if(cluster->GetQuality()<0){
        if(plane==XPLANE && type == CCLUSTER) gXnoise[itr]->SetPoint(gXnoise[itr]->GetN(),mean,ind+0.5);
        if(plane==XPLANE && type == TCLUSTER) gXnoise[itr]->SetPoint(gXnoise[itr]->GetN(),ind+0.5,mean);
        if(plane==YPLANE && type == CCLUSTER) gYnoise[itr]->SetPoint(gYnoise[itr]->GetN(),mean,ind+0.5);
        if(plane==YPLANE && type == TCLUSTER) gYnoise[itr]->SetPoint(gYnoise[itr]->GetN(),ind+0.5,mean);
      }
    }
  }

  TLegend* lX = new TLegend(0.1,0.5,0.3,0.98);
  TLegend* lY = new TLegend(0.1,0.5,0.3,0.98);
  for(Int_t i = 0; i<10; i++){
    cTab->cd(1);
    if(gX[i]->GetN()>0){
      std::cout << "gX[" << i << "] => " << gX[i]->GetN() << endl;
      gX[i]->Draw("Psame");
      gXnoise[i]->Draw("Psame");
      lX->AddEntry(gX[i],Form("%d",i),"P");
    }
    cTab->cd(2);
    if(gY[i]->GetN()>0){
      std::cout << "gY[" << i << "] => " << gY[i]->GetN() << endl;
      gY[i]->Draw("Psame");
      gYnoise[i]->Draw("Psame");
      lY->AddEntry(gY[i],Form("%d",i),"P");
    }
    // if(fTrackingType==2)
    //   fTracking2->hNcl->Draw();
  }    
  cTab->cd(1);
  lX->Draw();
  cTab->cd(2);
  lY->Draw();
  cTab->Update();
}

void HarpoRecoMonitorGui::DisplayTracks(TRootEmbeddedCanvas* ecTab)
{

  TFile* savefile = NULL;
  Char_t filename[256];
  sprintf(filename,"plots/tracking/run%d_evt%ld.root",
          fEvent->GetRunHeader()->GetRun(),
          fEvent->GetHeader()->GetEvtNo());
  Bool_t save = !gSystem->AccessPathName(filename);
  if(save) savefile = new TFile(filename,"update");

  TCanvas* cTab = ecTab->GetCanvas();
  HarpoRecoEvent* reco = fEvent->GetRecoEvent();
  TClonesArray* trArray = reco->GetTracksArray();
  Int_t nTr = trArray->GetEntries();
  //  Info("DisplayTracks","Ntracks = %d (%d)",nTr,reco->GetTrackType());
  TClonesArray* clArray = reco->GetClustersArray();
  Int_t nCl = clArray->GetEntries();
  //  Int_t colorList[2][nTr];

  TLegend* l[2];
  l[0] = new TLegend(0.1,0.5,0.3,0.98);
  l[1] = new TLegend(0.1,0.5,0.3,0.98);
  TLatex* latex = new TLatex();
  latex->SetTextFont(132);
  latex->SetTextAlign(12);
  latex->SetTextSize(0.08);
  
  Double_t angleX[10], angleY[10];
  Int_t nclX[10], nclY[10];
  //  Int_t planeTr[10];
  TF1* line[2][nTr];
  TGraph* g[2][nTr];
  //  Int_t color = 2;


  TGraph* gAll[2];
  gAll[0] = new TGraph();
  gAll[1] = new TGraph();
  gAll[0]->SetMarkerStyle(6);
  gAll[1]->SetMarkerStyle(6);
  gAll[0]->SetMarkerColor(kGray);
  gAll[1]->SetMarkerColor(kGray);
  for(Int_t icl = 0; icl<nCl; icl++){
    HarpoRecoClusters* cluster = (HarpoRecoClusters*)clArray->At(icl);
    Int_t ndet = cluster->GetPlane();
    Double_t x = cluster->GetX();
    Double_t z = cluster->GetZ();
    gAll[ndet]->SetPoint(gAll[ndet]->GetN(),z,x);
  }
  cTab->cd(1);
  gAll[0]->Draw("Psame");
  cTab->cd(2);
  gAll[1]->Draw("Psame");

  for(Int_t itr = 0; itr<nTr; itr++){
    
    HarpoRecoTracks* track = (HarpoRecoTracks*)trArray->At(itr);
    
    Int_t ndet = track->GetPlane();
    Int_t trId = track->GetNtrack();    
    Int_t color = trId+2;

    //TGraph* 
    g[ndet][itr] = new TGraph();
    g[ndet][itr]->SetMarkerStyle(6);
    g[ndet][itr]->SetMarkerColor(color);
    for(Int_t icl = 0; icl<nCl; icl++){
      HarpoRecoClusters* cluster = (HarpoRecoClusters*)clArray->At(icl);
      if(cluster->GetPlane()!=ndet) continue;
      Bool_t test = kFALSE;
      Int_t nTr = cluster->GetNtr();
      for(Int_t i = 0; i<nTr; i++)
        if(cluster->GetIdClusterTrack(i)==trId) test = kTRUE;
      if(!test) continue;
      //if(cluster->GetIdClusterTrack()!=trId) continue;
      Double_t x = cluster->GetX();
      Double_t z = cluster->GetZ();
      //Info("DisplayTracks","%g %g",z,x);
      g[ndet][itr]->SetPoint(g[ndet][itr]->GetN(),z,x);
    }

    Double_t x0 = track->GetX0();
    Double_t slope = track->GetAngleTrack(); 

    Double_t xStart = track->GetXstart();
    Double_t zStart = track->GetZstart();
    Double_t xEnd = track->GetXend();
    Double_t zEnd = track->GetZend();
    Info("DisplayTracks","%g %g   %g %g",xStart,zStart,xEnd,zEnd);

    cTab->cd(ndet+1);
    TEllipse* eStart = new TEllipse(zStart,xStart,4);
    eStart->SetFillColor(color);
    eStart->Draw();
    TEllipse* eEnd = new TEllipse(zEnd,xEnd,4);
    eEnd->SetFillColor(color);
    eEnd->Draw();

    if(0){
      HarpoDccMap* m = fEvent->GetDccMap(ndet);
      Int_t n = 0;
      TGraph* gStart = new TGraph();
      Int_t l = 0, start = 1000;
      Bool_t empty = kFALSE;
      for(Int_t i=0;i<1000;i++){
        Double_t phi = i*4*TMath::Pi()/1000;
        Double_t xTmp = xStart + 30*TMath::Cos(phi);
        Double_t zTmp = zStart + 30*TMath::Sin(phi);
        Int_t channel = Int_t(xTmp);
        Int_t timebin = Int_t(zTmp);
        if(channel<0 || channel>=NCHAN) continue;
        if(timebin<0 || timebin>=NADC) continue;
        Int_t q = m->GetData(channel,timebin);    
        if(q>0){
          gStart->SetPoint(n,zTmp,xTmp);
          n++;
          empty = kFALSE;
        }else{
          if(!empty) start = i;
          if(i-start>l) l = i-start;
          empty = kTRUE;
        }
      }
      gStart->SetLineWidth(2);
      gStart->SetLineStyle(2);
      gStart->Draw("Lsame");
      latex->DrawLatex(zStart,xStart,Form("%d",l));
      n = 0;
      l = 0; start = 1000;
      TGraph* gEnd = new TGraph();
      for(Int_t i=0;i<1000;i++){
        Double_t phi = i*4*TMath::Pi()/1000;
        Double_t xTmp = xEnd + 30*TMath::Cos(phi);
        Double_t zTmp = zEnd + 30*TMath::Sin(phi);
        Int_t channel = Int_t(xTmp);
        Int_t timebin = Int_t(zTmp);
        Int_t q;
        if(channel<0 || channel>=NCHAN || timebin<0 || timebin>=NADC) q = 0;
        else q = m->GetData(channel,timebin);    
        if(q>0){
          gEnd->SetPoint(n,zTmp,xTmp);
          n++;
          empty = kFALSE;
        }else{
          if(!empty) start = i;
          if(i-start>l) l = i-start;
          empty = kTRUE;
        }
      }
      gEnd->SetLineWidth(2);
      gEnd->SetLineStyle(3);
      gEnd->Draw("Lsame");
      latex->DrawLatex(zEnd,xEnd,Form("%d",l));
      //      Double_t frac = n*0.001
    }



    Double_t zmin, zmax;
    if(zEnd<zStart){
      zmin = zEnd;
      zmax = zStart;
    }else{
      zmax = zEnd;
      zmin = zStart;
    }
    line[ndet][itr] = new TF1(Form("line%d_%d",itr,ndet),"pol1",zmin,zmax);

    line[ndet][itr]->SetParameter(0,x0);// + z0*slope);
    line[ndet][itr]->SetParameter(1,slope);

    l[ndet]->AddEntry(line[ndet][itr],Form("%d (%d)",trId,track->GetQtTrack()),"L");
    line[ndet][itr]->SetLineColor(color);
    g[ndet][itr]->Draw("Psame");
    line[ndet][itr]->DrawCopy("same");
    if(save){
      g[ndet][itr]->Write(Form("g_%d_%d",itr,ndet));
      line[ndet][itr]->Write(Form("line_%d_%d",itr,ndet));
    }
  }
  if(save) savefile->Close();
  cTab->cd(1);
  l[0]->Draw();
  cTab->cd(2);
  l[1]->Draw();
  cTab->Update();


  return;
  // if(fTracksCanvas && stheta && ctheta && nDraw == 10){
  //    //Info("FindTrack","%g %g", x + RouteHough*sigtrans*ctheta, y + RouteHough*sigtrans*stheta);
  //    // fGraphRoute[mtrack]->SetPoint(fGraphRoute[mtrack]->GetN(), x + RouteHough*sigtrans*ctheta, y + RouteHough*sigtrans*stheta);
  //    // fGraphRoute[mtrack]->SetPoint(fGraphRoute[mtrack]->GetN(), x - RouteHough*sigtrans*ctheta, y - RouteHough*sigtrans*stheta);
  //    fGraphRoute[mtrack]->SetPoint(fGraphRoute[mtrack]->GetN(), x + sigtrans*ctheta, y + sigtrans*stheta);
  //    fGraphRoute[mtrack]->SetPoint(fGraphRoute[mtrack]->GetN(), x - sigtrans*ctheta, y - sigtrans*stheta);
  //    // gRoute->SetPoint(gRoute->GetN(), x + RouteHough*sigtrans*ctheta, y + RouteHough*sigtrans*stheta);
  //    // gRoute->SetPoint(gRoute->GetN(), x - RouteHough*sigtrans*ctheta, y - RouteHough*sigtrans*stheta);
  //    nDraw = 0;
  // }


  if(fTrackingType==2){


    TClonesArray* trArrayK = reco->GetKalmanTracksArray();
    Int_t nTrK = trArrayK->GetEntries();
    TGraph* g2[2][nTrK];
    for(Int_t i = 0; i<nTrK; i++){
      g2[0][i] = new TGraph();
      g2[1][i] = new TGraph();
    }
    for(Int_t icl = 0; icl<nCl; icl++){
      HarpoRecoClusters* cluster = (HarpoRecoClusters*)clArray->At(icl);
      Int_t plane = cluster->GetPlane();
      Int_t idTr = cluster->GetIdClusterTrack();
      if(plane!=XPLANE && plane !=YPLANE) continue;
      if(idTr<0) continue;
      if(idTr>=nTrK) continue;
      g2[plane][idTr]->SetPoint(g2[plane][idTr]->GetN(),cluster->GetZfit(0),cluster->GetXfit(0));
    }

    Info("DisplayTracks","NtracksK = %d",nTrK);
    //    TLine* line[nTrK];
    for(Int_t itr = 0; itr<nTrK; itr++){
      HarpoRecoKalmanTracks* track = (HarpoRecoKalmanTracks*)trArrayK->At(itr);
      Int_t plane = track->GetPlane();
      Int_t trId = track->GetNtrack();
      cTab->cd(plane+1);
      if(!g2[plane][trId]) continue;
      if(g2[plane][trId]->GetN()<1) continue;
      Info("DisplayTracks","Plane %d, Tr %d => Ncl = %d",plane, trId,g2[plane][trId]->GetN());
      g2[plane][trId]->SetMarkerColor(trId+2);
      g2[plane][trId]->SetMarkerStyle(6);
      g2[plane][trId]->Draw("Psame");
      l[plane]->AddEntry(g2[plane][trId],Form("%d",trId),"P");

      // line[plane][itr] = new TLine();
      // //      lineT->SetLineStyle(10);
      // //      lineT->SetLineWidth(2);
      // line[plane][itr]->SetLineColor(trId+2);
      // line[plane][itr]->DrawLine(track->GetZstart(),track->GetXstart(),track->GetZstart()+100*track->GetPzStart(),track->GetXstart()+100*track->GetPxStart());
      // line[plane][itr]->DrawLine(track->GetZend(),track->GetXend(),track->GetZend()+100*track->GetPzEnd(),track->GetXend()+100*track->GetPxEnd());



    }
    cTab->cd(1);
    l[0]->Draw();
    cTab->cd(2);
    l[1]->Draw();
    cTab->Update();
    return;
  }




  for(Int_t itr = 0; itr<nTr; itr++){
    
    HarpoRecoTracks* track = (HarpoRecoTracks*)trArray->At(itr);
    
    Int_t ndet = track->GetPlane();
    // Double_t theta = track->GetMtheta();
    // Double_t rho = track->GetMrho();
    if(fTrackingType == 3){
      fInfoBox->NewEntry(Form("SigRho = %g",((HarpoRecoHoughTracks*)track)->GetSigrho()));
      Info("DisplayTracks","SigRho = %g",((HarpoRecoHoughTracks*)track)->GetSigrho());
      if(!((HarpoRecoHoughTracks*)track)->GetSigrho()) continue;
    }
    Double_t angX=track->GetAngleTrack();;
    if(ndet==0) cout<<"angle="<<angX<<endl;
    //    planeTr[itr] = ndet;
    if(ndet==0) angleX[itr]=track->GetAngleTrack();
    if(ndet==1) angleY[itr]=track->GetAngleTrack();
    if(ndet==0) nclX[itr]=track->GetNclusterTrack();
    if(ndet==1) nclY[itr]=track->GetNclusterTrack();
    //    Int_t rlambda=0;
    Int_t trId = track->GetNtrack();    

    Int_t color = trId+2;//colorList[ndet][trId];//itr+2;  
    
    Double_t x0 = track->GetX0();//start();
    //   fInfoBox->NewEntry(Form("X0 = %g",x0));
    //    Double_t z0 = 0;//track->GetZstart();
    //    Double_t slope = TMath::Tan(track->GetAngleTrack()); 
    Double_t slope = track->GetAngleTrack(); 

    Double_t zmin, zmax;
    if(track->GetZend()<track->GetZstart()){
      zmin = track->GetZend();
      zmax = track->GetZstart();
    }else{
      zmax = track->GetZend();
      zmin = track->GetZstart();
    }
    line[ndet][itr] = new TF1(Form("line%d",itr),"pol1",zmin,zmax);

    line[ndet][itr]->SetParameter(0,x0);// + z0*slope);
    line[ndet][itr]->SetParameter(1,slope);

    l[ndet]->AddEntry(line[ndet][itr],Form("%d (%d)",trId,track->GetQtTrack()),"L");
    line[ndet][itr]->SetLineColor(color);
    cTab->cd(ndet+1);
    line[ndet][itr]->DrawCopy("same");
   
    cTab->cd(ndet+1);
  }
  cTab->cd(1);
  l[0]->Draw();
  cTab->cd(2);
  l[1]->Draw();

  if(fTrackingType==2){
    cTab->Update();
    return;
  }

  // TGraph* gXT[10];
  // TGraph* gYT[10];
  TGraph* gCXAssoc[10];
  TGraph* gTXAssoc[10];
  TGraph* gCYAssoc[10];
  TGraph* gTYAssoc[10];

  for(Int_t i = 0; i<10; i++){
    // gXT[i] = new TGraph();
    // gYT[i] = new TGraph();
    gCXAssoc[i] = new TGraph();
    gCYAssoc[i] = new TGraph();
    gTXAssoc[i] = new TGraph();
    gTYAssoc[i] = new TGraph();
    //    Info("DisplayTracks","*Draw Track %d %p",i,gCXAssoc[i]);

    angleX[i]=100.;
    angleY[i]=100.;
    nclX[i] = -1;
    nclY[i] = -1;

    Int_t color = i+2;  
    // gXT[i]->SetMarkerStyle(10);
    // gYT[i]->SetMarkerStyle(10);
    // gXT[i]->SetLineColor(color);
    // gYT[i]->SetLineColor(color);
    // gXT[i]->SetMarkerColor(color);
    // gYT[i]->SetMarkerColor(color);
    
    gCXAssoc[i] -> SetMarkerStyle(7);
    gCYAssoc[i] -> SetMarkerStyle(7);
    gTXAssoc[i] -> SetMarkerStyle(7);
    gTYAssoc[i] -> SetMarkerStyle(7);
    
    gCXAssoc[i] -> SetMarkerSize(0.5);
    gCYAssoc[i] -> SetMarkerSize(0.5);
    gTXAssoc[i] -> SetMarkerSize(0.5);
    gTYAssoc[i] -> SetMarkerSize(0.5);
    
    gCXAssoc[i] -> SetMarkerColor(color);
    gCYAssoc[i] -> SetMarkerColor(color);
    gTXAssoc[i] -> SetMarkerColor(color);
    gTYAssoc[i] -> SetMarkerColor(color);  
  }
  Info("DisplayTracks","Draw Track %p (%d)",gCXAssoc[0],nTr);

  //    Info("DisplayTracks","Draw Track %p",gCXAssoc[0]);

  for(Int_t icl = 0; icl<nCl; icl++){
    HarpoRecoClusters* cluster = (HarpoRecoClusters*)clArray->At(icl);
    Int_t ind = cluster->GetIndex();
    Double_t mean = cluster->GetMean();
    Int_t plane = cluster->GetPlane();
    Int_t type = cluster->GetType();
    //    Int_t idcluster = cluster->GetIdClusterTrack();
    if(plane!=XPLANE && plane !=YPLANE) continue;

    for(Int_t i = 0; i<10; i++){
      Int_t itr = cluster->GetIdClusterTrack(i);
      //std::cout << "****** " << i << " => " << itr << " ******" << std::endl;
      if(itr<0) continue;
      if(itr>=10) continue;
      //if(planeTr[itr] != plane) continue;
      //if(planeTr[itr] == plane){
      // if(ndet==0 && plane==0 && type == 0 && idcluster==itr) gCXAssoc[itr]->SetPoint(gCXAssoc[itr]->GetN(),mean,ind);
      // if(ndet==0 && plane==0 && type == 1 && idcluster==itr) gTXAssoc[itr]->SetPoint(gTXAssoc[itr]->GetN(),ind,mean);
      // if(ndet==1 && plane==1 && type == 0 && idcluster==itr) gCYAssoc[itr]->SetPoint(gCYAssoc[itr]->GetN(),mean,ind);
      // if(ndet==1 && plane==1 && type == 1 && idcluster==itr) gTYAssoc[itr]->SetPoint(gTYAssoc[itr]->GetN(),ind,mean);
      if(plane==XPLANE && type == CCLUSTER) gCXAssoc[itr]->SetPoint(gCXAssoc[itr]->GetN(),mean,ind);
      if(plane==XPLANE && type == TCLUSTER) gTXAssoc[itr]->SetPoint(gTXAssoc[itr]->GetN(),ind,mean);
      if(plane==YPLANE && type == CCLUSTER) gCYAssoc[itr]->SetPoint(gCYAssoc[itr]->GetN(),mean,ind);
      if(plane==YPLANE && type == TCLUSTER) gTYAssoc[itr]->SetPoint(gTYAssoc[itr]->GetN(),ind,mean);
      
      //}
      //}
    }
    
  }
  //    Info("DisplayTracks","Draw Track %p",gCXAssoc[0]);
  
  Double_t ylatexX = 280, ylatexY = 280;
  for(Int_t i = 0; i<10; i++){
    cTab->cd(1);
    // if(!gXT[i]) continue;
    // if(gXT[i]->GetN()>0) gXT[i]->Draw("Psame");
    //Info("DisplayTracks","Draw Track %d %p",i,gCXAssoc[i]);
    if(!gCXAssoc[i]) continue;
    if(gCXAssoc[i]->GetN()>0) 
      gCXAssoc[i]->Draw("Psame");
    if(gTXAssoc[i]->GetN()>0) 
      gTXAssoc[i]->Draw("Psame");
    latex->SetTextSize(0.06);
    latex->SetTextColor(i+2);
    if(angleX[i] != 100){
      latex->DrawLatex(10,ylatexX,Form("track %d: %.2f %d",i, angleX[i]*180./TMath::Pi(), nclX[i]));
      ylatexX -= 20;
    }

    // if(fTrackingType == 3 && planeTr[i] == XPLANE){
    //   TGraph* gRouteX = fTracking3->GetGraphRoute(i);
    //   gRouteX->SetMarkerColor(i+2);
    //   gRouteX->SetLineColor(i+2);
    //   gRouteX->SetLineStyle(3);
    //   if(gRouteX) gRouteX->Draw("Lsame");
    // }

    cTab->cd(2);
    // if(gYT[i]->GetN()>0) gYT[i]->Draw("Psame");
    if(gCYAssoc[i]->GetN()>0) gCYAssoc[i]->Draw("Psame");
    if(gTYAssoc[i]->GetN()>0) gTYAssoc[i]->Draw("Psame");
    latex->SetTextSize(0.06);
    latex->SetTextColor(i+2);
    if(angleY[i] != 100){
      latex->DrawLatex(10,ylatexY,Form("track %d: %.2f %d",i, angleY[i]*180./TMath::Pi(),nclY[i]));
      ylatexY -= 20;
    }
    // if(fTrackingType == 3 && planeTr[i] == YPLANE){
    //   TGraph* gRouteY = fTracking3->GetGraphRoute(i);
    //   gRouteY->SetMarkerColor(i+2);
    //   gRouteY->SetLineColor(i+2);
    //   gRouteY->SetLineStyle(3);
    //   if(gRouteY) gRouteY->Draw("Lsame");
    // }

    // gTXAssoc[i]->Delete();
    // gCXAssoc[i]->Delete();
    // gTYAssoc[i]->Delete();
    // gCYAssoc[i]->Delete();
  }
  
  cTab->Update();

}



void HarpoRecoMonitorGui::DisplayVertex(TRootEmbeddedCanvas* ecTab)
{

  TCanvas* c = ecTab->GetCanvas();
  TClonesArray* vArray = fEvent->GetRecoEvent()->GetVertexArray();
  Int_t nV = vArray->GetEntries();
  Info("DisplayAnalysis","nV = %d",nV);
  for(Int_t i = 0; i<nV; i++){
    HarpoRecoVertex* vertex = (HarpoRecoVertex*)vArray->At(i);
    Int_t plane = vertex->GetPlane();
    Double_t xV = vertex->GetXvertex();
    Double_t zV = vertex->GetZvertex();
    Double_t pxV = vertex->GetPxVertex();
    Double_t pzV = vertex->GetPzVertex();
    Double_t thV = vertex->GetThetaVertex();
    c->cd(plane+1);
    Info("DisplayAnalysis","%d    %g %g",plane,zV,xV);
    TEllipse* eStart = new TEllipse(zV,xV,4);
    eStart->SetLineColor(kGray);
    if(vertex->GetChi2Vertex()<0)
      eStart->SetFillColor(kGray);
    else
      eStart->SetFillColor(kGreen);
    eStart->Draw();

    TArrow* arrow = new TArrow();
    arrow->SetLineColor(kGray);
    arrow->SetFillColor(kGray);
    arrow->SetArrowSize(0.01);
    arrow->DrawArrow(zV,xV,zV+30*pzV,xV+30*pxV);

    Double_t cTh = TMath::Cos(thV*0.5);
    Double_t sTh = TMath::Sin(thV*0.5);
    Double_t px1 = pxV*cTh + pzV*sTh;
    Double_t pz1 = pzV*cTh - pxV*sTh;
    Double_t px2 = pxV*cTh - pzV*sTh;
    Double_t pz2 = pzV*cTh + pxV*sTh;
    TLine* l1 = new TLine();
    l1->SetLineColor(kGray);
    l1->SetLineWidth(3);
    l1->DrawLine(zV,xV,zV+30*pz1,xV+30*px1);
    TLine* l2 = new TLine();
    l2->SetLineColor(kGray);
    l2->SetLineWidth(2);
    l2->DrawLine(zV,xV,zV+30*pz2,xV+30*px2);

    //    Double_t x[5], z[5];
    // Double_t a[5] = {-20, 60, 60,-20,-20};
    // Double_t b[5] = { 30, 30,-30,-30, 30};
    // for(Int_t k = 0; k<5; k++){
    //   x[k] = xV + a[k]*pxV + b[k]*pzV;
    //   z[k] = zV + a[k]*pzV - b[k]*pxV;
    // }
    // TPolyLine* box = new TPolyLine(5,z,x);
    // box->Draw();



  }  
  c->Update();
  return;
}



void HarpoRecoMonitorGui::Display3D(TRootEmbeddedCanvas* ecTab)
{


  TCanvas* cTab = ecTab->GetCanvas();
  // cTab->GetPad(1)->Delete();
  // cTab->GetPad(2)->Delete();
  // cTab->Divide(2);
  // cTab->GetPad(2)->Divide(1,2);
  
  HarpoRecoEvent* reco = fEvent->GetRecoEvent();
  TClonesArray* vertex3DArray = reco->GetVertex3DArray();
  Int_t nV3D  = vertex3DArray->GetEntries();
  //  fInfoBox->RemoveAll();
  for(Int_t i = 0; i<nV3D; i++){
    HarpoRecoVertex3D* vertex = (HarpoRecoVertex3D*)vertex3DArray->At(i);
    Double_t x = vertex->GetXvertex3D();
    Double_t y = vertex->GetYvertex3D();
    Double_t z = vertex->GetZvertex3D();
    Double_t px1 = vertex->GetPx1Vertex3D();
    Double_t py1 = vertex->GetPy1Vertex3D();
    Double_t pz1 = vertex->GetPz1Vertex3D();
    Double_t px2 = vertex->GetPx2Vertex3D();
    Double_t py2 = vertex->GetPy2Vertex3D();
    Double_t pz2 = vertex->GetPz2Vertex3D(); 
    Double_t angle_omega = atan2(pz2*px1-pz1*px2,pz2*py1-pz1*py2);

    Int_t color = i+2;

    cTab->cd(1);
    TEllipse* eStartX = new TEllipse(z,x,3);
    eStartX->SetLineColor(color);
    eStartX->SetFillColor(color);
    eStartX->Draw();

    TLine* l1x = new TLine();
    l1x->SetLineColor(color);
    l1x->SetLineWidth(2);
    l1x->SetLineStyle(2);
    l1x->DrawLine(z,x,z+100*pz1,x+100*px1);
    TLine* l2x = new TLine();
    l2x->SetLineColor(color);
    l2x->SetLineWidth(2);
    l2x->SetLineStyle(3);
    l2x->DrawLine(z,x,z+100*pz2,x+100*px2);

    cTab->cd(2);
    TEllipse* eStartY = new TEllipse(z,y,3);
    eStartY->SetLineColor(color);
    eStartY->SetFillColor(color);
    eStartY->Draw();

    TLine* l1y = new TLine();
    l1y->SetLineColor(color);
    l1y->SetLineWidth(2);
    l1y->SetLineStyle(2);
    l1y->DrawLine(z,y,z+100*pz1,y+100*py1);
    TLine* l2y = new TLine();
    l2y->SetLineColor(color);
    l2y->SetLineWidth(2);
    l2y->SetLineStyle(3);
    l2y->DrawLine(z,y,z+100*pz2,y+100*py2);

    if(z>350) continue;

    if(angle_omega>0.5*TMath::Pi()) angle_omega -= TMath::Pi();
    if(angle_omega<-0.5*TMath::Pi()) angle_omega += TMath::Pi();
    fInfoBox->NewEntry(Form("%d: omega = %g",i,angle_omega));

  }  



  if (gHDetSet->isExist(SIMDET)){
    HarpoSimEvent *simEvt = (HarpoSimEvent *)(fEvent->GetDetEvent(SIMDET));
    // Int_t nIonTr = simEvt->GetNtracks();
    // for(Int_t i = 0; i<nIonTr; i++){
    //   TpcSimIonisationTrack* tr = simEvt->GetIonisationTrack(i);
    //   Int_t nPoints = tr->GetNpoints();
    //   for(Int_t j = 0; j<nPoints; j++){
    //  TpcSimIonisationPoint* point = tr->GetPoint(j);
    //  //hNeSim->Fill(point->GetNe());
    //   }
    // }
    Double_t angle_omega_sim = 0;
    Double_t psim[2][3];
    TpcSimMCEvent* mcEvent = simEvt->GetMCEvent();
    Int_t nMCtr = mcEvent->GetNtracks();
    if(nMCtr==2){
      for(Int_t i = 0; i<nMCtr; i++){
        TpcSimMCTrack* track = mcEvent->GetTrack(i);
        Double_t x = track->GetX0() + 149.3;
        Double_t y = track->GetY0() + 149.3;
        Double_t z = track->GetZ0() + 228.5;
        Double_t px = track->GetPx();
        Double_t py = track->GetPy();
        Double_t pz = track->GetPz();

        TLine* lx = new TLine();
        lx->SetLineColor(kBlack);
        lx->SetLineWidth(2);
        lx->SetLineStyle(2+i);
        cTab->cd(1);
        lx->DrawLine(z,x,z+100*pz,x+100*px);
        TLine* ly = new TLine();
        ly->SetLineColor(kBlack);
        ly->SetLineWidth(2);
        ly->SetLineStyle(2+i);
        cTab->cd(2);
        ly->DrawLine(z,y,z+100*pz,y+100*py);
      }


      Double_t norm[2] = {0,0};
      for(Int_t i = 0; i<nMCtr; i++){
        TpcSimMCTrack* track = mcEvent->GetTrack(i);
        psim[i][0] = track->GetPy();
        psim[i][1] = track->GetPx();
        psim[i][2] = track->GetPz();
        norm[i] = TMath::Sqrt(psim[i][0]*psim[i][0]+psim[i][1]*psim[i][1]+psim[i][2]*psim[i][2]);
        //hPsim->Fill(track->GetPx(),track->GetPy(),track->GetPz());
      }
      Double_t u1u2 = 0;
      for(Int_t k = 0; k<3; k++){
        psim[0][k] /= norm[0];
        psim[1][k] /= norm[1];
        u1u2 += psim[0][k]*psim[1][k];
      }
      
      angle_omega_sim = atan2((psim[1][2]*psim[0][0]-psim[0][2]*psim[1][0]),(psim[1][2]*psim[0][1]-psim[0][2]*psim[1][1]));  
   
    if(angle_omega_sim>0.5*TMath::Pi()) angle_omega_sim -= TMath::Pi();
    if(angle_omega_sim<-0.5*TMath::Pi()) angle_omega_sim += TMath::Pi();
    fInfoBox->NewEntry(Form("omega_sim = %g",angle_omega_sim));
    }
  }














  // TH3F* hDummy3D = new TH3F("hDummy3D",";Z;X;Y",10,0,511,10,0,288,10,0,288);
  // cTab->cd(1);
  // hDummy3D->Draw();
  // for(Int_t i = 0; i<nV3D; i++){
  //   HarpoRecoVertex3D* vertex = (HarpoRecoVertex3D*)vertex3DArray->At(i);
  //   Double_t x = vertex->GetXvertex3D();
  //   Double_t y = vertex->GetYvertex3D();
  //   Double_t z = vertex->GetZvertex3D();
  //   Double_t px1 = vertex->GetPx1Vertex3D();
  //   Double_t py1 = vertex->GetPy1Vertex3D();
  //   Double_t pz1 = vertex->GetPz1Vertex3D();
  //   Double_t px2 = vertex->GetPx2Vertex3D();
  //   Double_t py2 = vertex->GetPy2Vertex3D();
  //   Double_t pz2 = vertex->GetPz2Vertex3D();
    
    
  //   TPolyLine3D *l1 = new TPolyLine3D(2);
  //   l1->SetPoint(0,z,x,y);
  //   l1->SetPoint(1,z+100*pz1,x+100*px1,y+100*py1);
  //   l1->SetLineColor(kRed);
  //   l1->Draw();
  //   TPolyLine3D *l2 = new TPolyLine3D(2);
  //   l2->SetPoint(0,z,x,y);
  //   l2->SetPoint(1,z+100*pz2,x+100*px2,y+100*py2);
  //   l2->SetLineColor(kBlue);
  //   l2->Draw();
  // }

  // TClonesArray* matchArray = reco->GetMatchingArray();
  // Int_t nMatch = matchArray->GetEntries();
  // TClonesArray* trArray = reco->GetTracksArray();
  // Int_t nTr = trArray->GetEntries();
  // fInfoBox->NewEntry(Form("nMatch = %d (%d)",matchArray->GetEntries(),nTr));
  // if(nMatch<1) return;
  
  // TH3F* hDummy3D = new TH3F("hDummy3D",";Z;X;Y",10,0,511,10,0,288,10,0,288);
  // cTab->cd(1);
  // hDummy3D->Draw();
  // //  MakeNiceHisto(hDummy3D,cTab->GetPad(1),"lego");
  // Int_t used[NTRACK][NTRACK];
  // for(Int_t i = 0; i<NTRACK; i++)
  //   for(Int_t j = 0; j<NTRACK; j++)
  //     used[i][j] = kBlack;
  // Int_t color = 2;
  // Double_t x0[nMatch], y0[nMatch], z0[nMatch], slopeX[nMatch], slopeY[nMatch];
  // Double_t x1[nMatch], y1[nMatch], z1[nMatch];
  // for(Int_t i = 0; i<nMatch; i++){
  //   x0[i] = -1000;
  //   y0[i] = -1000;
  //   z0[i] = -1000;
  //   x1[i] = -1000;
  //   y1[i] = -1000;
  //   z1[i] = -1000;
  //   slopeX[i] = -1000;
  //   slopeY[i] = -1000;
  //   cTab->cd(1);
  //   HarpoRecoMatching* match = (HarpoRecoMatching*)matchArray->At(i);

  //   Int_t trX = match->GetiMatchTrX();
  //   Int_t trY = match->GetiMatchTrY();
  //   Int_t trX2 = match->GetiMatchTrX2();
  //   Int_t trY2 = match->GetiMatchTrY2();
  //   fInfoBox->NewEntry(Form("%d: (%d,%d) (%d,%d)",i,trX,trX2,trY,trY2));
  //   if(used[trX][trY] == kBlack){
  //     used[trX][trY] = color;
  //     color++;
  //   }
    
  //   // if(g){
  //   //   g->SetMarkerStyle(7);
  //   //   g->Draw("Psame");
  //   //   g->SetMarkerColor(used[trX][trY]);
  //   // }

  //   for(Int_t itr = 0; itr<nTr; itr++){
      
  //     HarpoRecoTracks* track = (HarpoRecoTracks*)trArray->At(itr);
  //     Int_t trId = track->GetNtrack();
  //     Int_t plane = track->GetPlane();

  //     std::cout << "TRACK " << itr << " " << trId << "  (" << trX << "," << trY << ")" << std::endl;

  //     if(trId == trX && plane == XPLANE){
  //    // x0[i] = track->GetMrho();
  //    // slopeX[i] = track->GetMtheta();
  //    slopeX[i] = TMath::Tan(track->GetAngleTrack());
  //    x0[i] = track->GetXstart();// - track->GetZstart()*slopeX[i];
  //    z0[i] = track->GetZstart();
  //    x1[i] = track->GetXend();// - track->GetZstart()*slopeX[i];
  //    z1[i] = track->GetZend();
  //     }
  //     if(trId == trY && plane == YPLANE){
  //    // y0[i] = track->GetMrho();
  //    // slopeY[i] = track->GetMtheta();
  //    slopeY[i] = TMath::Tan(track->GetAngleTrack());
  //    y0[i] = track->GetXstart();// - track->GetZstart()*slopeY[i];
  //    y1[i] = track->GetXend();// - track->GetZstart()*slopeY[i];
  //     }
  //   }
  //   TPolyLine3D *l = new TPolyLine3D(2);
  //   // l->SetPoint(0,0,x0[i],y0[i]);
  //   // l->SetPoint(1,500,x0[i]+500*slopeX[i],y0[i]+500*slopeY[i]);
  //   l->SetPoint(0,z0[i],x0[i],y0[i]);
  //   l->SetPoint(1,500,x0[i]+(500-z0[i])*slopeX[i],y0[i]+(500-z0[i])*slopeY[i]);
  //   l->SetLineColor(used[trX][trY]);
  //   l->Draw();
  //   fInfoBox->NewEntry(Form("3D track %d: z0=%.3g, x0=%.3g, y0=%.3g, sX=%.3g, sY=%.3g", i, z0[i], x0[i], y0[i], slopeX[i], slopeY[i]));
  // }


  // for(Int_t i = 0; i<nMatch; i++){
  //   //fInfoBox->NewEntry(Form("3D track %d: x0=%.3g, y0=%.3g, sX=%.3g, sY=%.3g", i, x0, y0, slopeX[i], slopeY[i]));

  //   Double_t p1[3] = {slopeX[i], slopeY[i], 1};
  //   Double_t x1[3] = {x0[i], y0[i], 0};
  //   Double_t norm1 = 0;
  //   for(Int_t k = 0; k<3; k++) norm1 += p1[k]*p1[k];
  //   norm1 = TMath::Sqrt(norm1);
  //   for(Int_t k = 0; k<3; k++) p1[k] /= norm1;
  //   for(Int_t j = i+1; j<nMatch; j++){
  //     Double_t p2[3] = {slopeX[j], slopeY[j], 1};
  //     Double_t x2[3] = {x0[j], y0[j], 0};
  //     Double_t norm2 = 0;
  //     for(Int_t k = 0; k<3; k++) norm2 += p2[k]*p2[k];
  //     norm2 = TMath::Sqrt(norm2);
  //     for(Int_t k = 0; k<3; k++) p2[k] /= norm2;
  //     Double_t u1u2 = 0, u1dX = 0, u2dX = 0;
  //     for(Int_t k = 0; k<3; k++){
  //    u1u2 += p1[k]*p2[k];
  //    u1dX += p1[k]*(x1[k]-x2[k]);
  //    u2dX += p2[k]*(x1[k]-x2[k]);
  //     }

  //     Double_t t1 =   (u1u2*u2dX - u1dX)/(1 - u1u2*u1u2);
  //     Double_t t2 = - (u1u2*u1dX - u2dX)/(1 - u1u2*u1u2);

    
  //     Double_t xPoca1[3], xPoca2[3];
  //     Double_t doca = 0;
  //     for(Int_t k = 0; k<3; k++){
  //    xPoca1[k] = x1[k] + t1*p1[k];
  //    xPoca2[k] = x2[k] + t2*p2[k];
  //    doca += (xPoca1[k]-xPoca2[k])*(xPoca1[k]-xPoca2[k]);
  //     }
  //     doca = TMath::Sqrt(doca);
  //     if(doca>0.01){
  //    hDoca->Fill(doca);
  //    TPolyLine3D *lPoca = new TPolyLine3D(2);
  //    lPoca->SetPoint(0,xPoca1[2],xPoca1[0],xPoca1[1]);
  //    lPoca->SetPoint(1,xPoca2[2],xPoca2[0],xPoca2[1]);
  //    lPoca->Draw();
  //     }

  //     Double_t angle_open=acos(u1u2/(norm1*norm2));

  //     Double_t angle_omega = atan2((p2[2]*p1[0]-p1[2]*p2[0]),(p2[2]*p1[1]-p1[2]*p2[1]));
  //     hOpenAngle->Fill(angle_open*180./TMath::Pi());
  //     hOmegaAngle->Fill(angle_omega*180./TMath::Pi());

  //     //fInfoBox->NewEntry(Form("%d %d: doca=%.3gmm, #theta=%.3g^{o}, #omega=%.3g^{o}", i, j, doca,angle_open*180./TMath::Pi(),angle_omega*180./TMath::Pi()));


  //   }      
  // }


  // MakeNiceHisto(hDoca,cTab->GetPad(2)->GetPad(1));
  // MakeNiceHisto(hOpenAngle,cTab->GetPad(2)->GetPad(2));
  // hOmegaAngle->SetLineColor(kRed);
  // hOmegaAngle->DrawCopy("same");

  cTab->Update();
  return;



}



void HarpoRecoMonitorGui::DisplaySim(TRootEmbeddedCanvas* ecTab)
{

  TCanvas* cTab = ecTab->GetCanvas();
 

  if (!gHDetSet->isExist(SIMDET)) return;

  HarpoSimEvent *simEvt = (HarpoSimEvent *)(fEvent->GetDetEvent(SIMDET));
  Int_t nIonTr = simEvt->GetNtracks();
  for(Int_t i = 0; i<nIonTr; i++){
    TpcSimIonisationTrack* tr = simEvt->GetIonisationTrack(i);
    Int_t nPoints = tr->GetNpoints();
    TGraph* gX = new TGraph();
    gX->SetMarkerStyle(7);
    gX->SetMarkerColor(2+i);
    TGraph* gY = new TGraph();
    gY->SetMarkerStyle(7);
    gY->SetMarkerColor(2+i);
    for(Int_t j = 0; j<nPoints; j++){
      TpcSimIonisationPoint* point = tr->GetPoint(j);
      gX->SetPoint(j,point->GetZ()+ 88.5,point->GetX()+ 150.5);
      gY->SetPoint(j,point->GetZ()+ 88.5,point->GetY()+ 150.5);
      //hNeSim->Fill(point->GetNe());
    }
    cTab->cd(1);
    gX->Draw("Psame");
    cTab->cd(2);
    gY->Draw("Psame");
  }
  // Double_t angle_omega_sim = 0;
  // Double_t psim[2][3];
  TpcSimMCEvent* mcEvent = simEvt->GetMCEvent();
  Int_t nMCtr = mcEvent->GetNtracks();
  for(Int_t i = 0; i<nMCtr; i++){
    TpcSimMCTrack* track = mcEvent->GetTrack(i);
    Double_t x = track->GetX0() + 149.3;
    Double_t y = track->GetY0() + 149.3;
    Double_t z = track->GetZ0() + 228.5;
    Double_t px = track->GetPx();
    Double_t py = track->GetPy();
    Double_t pz = track->GetPz();


    fInfoBox->NewEntry(Form("PDG Code: %d", track->GetPdgCode()));

    Int_t color = kBlack;    
    if(track->GetPdgCode() == 22){
      px = -px; py = -py; pz = -pz;
      color = kMagenta;
    }

    TLine* lx = new TLine();
    lx->SetLineColor(color);
    lx->SetLineWidth(2);
    lx->SetLineStyle(2+i);
    cTab->cd(1);
    lx->DrawLine(z,x,z+100*pz,x+100*px);
    TLine* ly = new TLine();
    ly->SetLineColor(color);
    ly->SetLineWidth(2);
    ly->SetLineStyle(2+i);
    cTab->cd(2);
    ly->DrawLine(z,y,z+100*pz,y+100*py);
  }

  cTab->Update();

}

void HarpoRecoMonitorGui::SetBaselineFluctParam()
{
  // Info("SetBaselineFluctParam","%f %f %f %f %f",fChooseNch->GetNumber(),fChooseSig->GetNumber(),fChooseDelta->GetNumber(),fChooseTruncL->GetNumber()*0.01,fChooseTruncH->GetNumber()*0.01);
  // fBaselineFluct->SetLimNch(fChooseNch->GetNumber());
  // fBaselineFluct->SetLimSig(fChooseSig->GetNumber());
  // fBaselineFluct->SetLimDelta(fChooseDelta->GetNumber());
  // fBaselineFluct->SetLimTruncL(fChooseTruncL->GetNumber()*0.01);
  // fBaselineFluct->SetLimTruncH(fChooseTruncH->GetNumber()*0.01);
}


void HarpoRecoMonitorGui::SetConfig()
{
  fClusteringType = fChooseClusteringType->GetSelected();
  if(fClusteringType<0 || fClusteringType>=(Int_t)kNclustering)
    fClusteringType = CLUSTERING_NONE;
  fTrackingType = fChooseTrackingType->GetSelected();
  if(fTrackingType<0 || fTrackingType>=(Int_t)kNtracking)
    fTrackingType = TRACKING_NONE;
  fMatchingType = fChooseMatchingType->GetSelected();
  if(fMatchingType<0 || fMatchingType>=(Int_t)kNmatching)
    fMatchingType = MATCHING_NONE;
  fVertexingType = fChooseVertexingType->GetSelected();
  if(fVertexingType<0 || fVertexingType>=(Int_t)kNvertexing)
    fVertexingType = VERTEXING_NONE;

  fAnalysisType = fChooseAnalysisType->GetSelected();
  if(fAnalysisType<0 || fAnalysisType>=(Int_t)kNanalysis)
    fAnalysisType = ANALYSIS_NONE;
  fSelectorType = fChooseSelectorType->GetSelected();
  if(fSelectorType<0 || fSelectorType>=(Int_t)kNselector)
    fSelectorType = SELECTOR_NONE;

}

void HarpoRecoMonitorGui::SetSelectorParam()
{

  // if(fEventSelector){
  //   fEventSelector->SetChooseEventType(fChooseSelectorType->GetSelected());
  // }
}

void HarpoRecoMonitorGui::DisplayInfo(HarpoEvent* event)
{

  fInfoBox->RemoveAll();

  Double_t qtot[2];

  for(Int_t ndet=0;ndet<2;ndet++) {
    if(!gHDetSet->isExist(ndet)) continue;
    HarpoDccMap * m = fEvent->GetDccMap(ndet);
    if ( m == NULL ) continue;
    for(Int_t i=1;i<NADC;i++){ //Time bins
      for(Int_t j=0;j<NCHAN;j++){ // Channels
        Double_t q = m->GetData(j,i);
        if(q<=-1000) continue;
        qtot[ndet] += q;
      }
    }  
  }

  Double_t ratio = -1;
  if(qtot[1]) ratio = qtot[0]/qtot[1];

  fInfoBox->NewEntry(Form("Ratio: %g", ratio));




  if (!gHDetSet->isExist(XDCC)) return;
  if (!gHDetSet->isExist(YDCC)) return;
  // Process RAW data
  HarpoDccMap* mX = event->GetDccMap(XDCC);
  HarpoDccMap* mY = event->GetDccMap(YDCC);
  if ( mX == NULL ) return;
  if ( mY == NULL ) return;

  Int_t i2 = 0;
  Double_t qTotX3 = 0, qTotY3 = 0;
  Double_t meanX3 = 0, meanY3 = 0;
  Double_t meanXevt = 0, meanYevt = 0;

  for(Int_t i=0;i<NADC;i++){ //Time bins
    Double_t qTotX = 0, qTotY = 0;
    Double_t meanX = 0, meanY = 0;
    for(Int_t j=0;j<NCHAN;j++){ // Channels
      Double_t qX = mX->GetData(j,i);
      Double_t qY = mY->GetData(j,i);
      if(qX > 0){
        qTotX += qX;
        meanX += j*qX;
        qTotX3 += qX;
        meanX3 += j*qX;
      }
      if(qY > 0){
        qTotY += qY;
        meanY += j*qY;
        qTotY3 += qY;
        meanY3 += j*qY;
      }
    }
    if(qTotX*qTotY == 0) continue;
    meanX /= qTotX;
    meanY /= qTotY;
    if(i2 == 2){
      meanXevt = meanX3/qTotX3;
      meanYevt = meanY3/qTotY3;
      fInfoBox->NewEntry(Form("X = %g, Y = %g", meanXevt, meanYevt));
      if(TMath::Abs(meanXevt-144)>10) break;
      if(TMath::Abs(meanYevt-144)>10) break;
    }
    i2++;
    if(i<150 && i2>2) break;
    if(i2 == 3){
      Double_t xMin = 400, yMin = 400, xMax = -1, yMax = -1;
      for(Int_t J=0;J<NCHAN;J++){ // Channels
        Double_t qXch = 0, qYch = 0;
        for(Int_t I=i-1;I<i+100 && I<NADC;I++){ //Time bins
          Double_t qX = mX->GetData(J,I);
          Double_t qY = mY->GetData(J,I);
          if(qX > 0)
            qXch += qX;
          if(qY > 0)
            qYch += qY;
        }
        if(qXch>1000 && J<xMin) xMin = J;
        if(qYch>1000 && J<yMin) yMin = J;
        if(qXch>1000 && J>xMax) xMax = J;
        if(qYch>1000 && J>yMax) yMax = J;
      }
      std::cout << xMin << " " << yMin << " " << xMax << " " <<yMax << std::endl;
      Int_t widthX = xMax-xMin+1;
      Int_t widthY = yMax-yMin+1;
      fInfoBox->NewEntry(Form("wX = %d, wY = %d", widthX, widthY));

    }


  }


}


void HarpoRecoMonitorGui::DisplayEvent(HarpoEvent* event)
{
  Info("DisplayEvent","%p",fEvent);
  if(event == 0) return;
  fEvent->GetHeader()->SetEvtNo(fReader->GetReadEvts());
  fEvent->SetRunHeader(fReader->GetRunHeader());
  fNevt++;

  DisplayInfo(event);

  InitEvent(event);

  DisplayMap(ecTabRaw,fCheckShowSpectrum->IsOn(),1);

  SetBaselineFluctParam();
  fBaselineFluct->ProcessEvent(event);
  DisplayMap(ecTabNoiseSuppr,fCheckShowSpectrum->IsOn());


  SetConfig();
  DisplayMap(ecTabClusters);


  if(fClusteringType != CLUSTERING_NONE && fClusteringType<(Int_t)kNclustering){
    fClustering[fClusteringType]->ProcessEvent(event); 
    fClustering[fClusteringType]->DisplayAnalysis(ecTabClusters,fInfoBox);
    fClustering[fClusteringType]->DisplayAnalysis(ecTabClustersTracks,fInfoBox);
  }

  // if(fCheckAnimClustering->IsOn()){
  //   fTab->SetTab(2);
  //   fClustering2->SetCanvas(ecTabClusters->GetCanvas()->GetPad(1),ecTabClusters->GetCanvas()->GetPad(2));
  //   fClustering2->SetHist(fHistEvent[0],fHistEvent[1]);
  // }else{
  //   fClustering2->SetCanvas(NULL,NULL);
  //   fClustering2->SetHist(NULL,NULL);
  // }
  // if(fClusteringType != 0) event->GetRecoEvent()->ResetClustersArray();
  // switch(fClusteringType){
  //   //  case 1: fClustering1->ProcessEvent(event); break;
  // case 2: 
  //   fClustering2->ProcessEvent(event); 
  //   fClustering2->DisplayAnalysis(ecTabClusters,fInfoBox);
  //   fClustering2->DisplayAnalysis(ecTabClustersTracks,fInfoBox);
  //   break;
  // case 3: 
  //   fClustering3->ProcessEvent(event); 
  //   fClustering3->DisplayAnalysis(ecTabClusters,fInfoBox);
  //   fClustering3->DisplayAnalysis(ecTabClustersTracks,fInfoBox);
  //   break;
  //   //  default: fClustering1->ProcessEvent(event); break;
  // }
  std::cout << "****   " << event->GetRecoEvent()->GetClustersArray()->GetEntries() << "   ****" << std::endl;
  //  DisplayClusters(ecTabClusters);

  //  SetTrackingParam();
  std::cout << "****   " << event->GetRecoEvent()->GetClustersArray()->GetEntries() << "   ****" << std::endl;
  DisplayEmptyMap(ecTabClustersTracks);

  // fTracking3->SetCanvas(ecTabClustersTracks->GetCanvas());
  // fTracking3->SetTracksCanvas(ecTabTracks->GetCanvas());
                                                         //  DisplayClusters(ecTabClustersTracks);
  if(fVertexingType != VERTEXING_BASIC){
    if(fTrackingType != TRACKING_NONE && fTrackingType<(Int_t)kNtracking){
      event->GetRecoEvent()->ResetTracksArray();
      DisplayEmptyMap(ecTabClustersTracks);
      fTracking[fTrackingType]->ProcessEvent(event);
      fTracking[fTrackingType]->DisplayAnalysis(ecTabClustersTracks,fInfoBox);
    }
    DisplayEmptyMap(ecTabTracks);
    DisplayTracks(ecTabTracks);
  }

  fSaturation->ProcessEvent(event);

  if(fVertexingType != VERTEXING_NONE && fVertexingType<(Int_t)kNvertexing){
    event->GetRecoEvent()->ResetVertexArray();
    fVertexing[fVertexingType]->ProcessEvent(event);
    fVertexing[fVertexingType]->DisplayAnalysis(ecTabVertexing,fInfoBox);
  }
  DisplayMap(ecTabVertex);
  DisplayVertex(ecTabVertex);

  if(fTrackingType == TRACKING_KALMANNEW){
    if(fCheckAnimTracking->IsOn()){
      fTab->SetTab(3);
      ((HarpoKalmanNew*)fTracking[fTrackingType])->SetCanvas(ecTabClustersTracks->GetCanvas()->GetPad(1),0);
      ((HarpoKalmanNew*)fTracking[fTrackingType])->SetHist(fHistEventEmpty[0],0);
      ((HarpoKalmanNew*)fTracking[fTrackingType])->SetCanvas(ecTabClustersTracks->GetCanvas()->GetPad(2),1);
      ((HarpoKalmanNew*)fTracking[fTrackingType])->SetHist(fHistEventEmpty[1],1);
    }else{
      ((HarpoKalmanNew*)fTracking[fTrackingType])->SetCanvas(0,0);
      ((HarpoKalmanNew*)fTracking[fTrackingType])->SetHist(0,0);
      ((HarpoKalmanNew*)fTracking[fTrackingType])->SetCanvas(0,1);
      ((HarpoKalmanNew*)fTracking[fTrackingType])->SetHist(0,1);
    }
  }

  if(fVertexingType == VERTEXING_BASIC){
    if(fTrackingType != TRACKING_NONE && fTrackingType<(Int_t)kNtracking){
      event->GetRecoEvent()->ResetTracksArray();
      DisplayEmptyMap(ecTabClustersTracks);
      fTracking[fTrackingType]->ProcessEvent(event);
      fTracking[fTrackingType]->DisplayAnalysis(ecTabClustersTracks,fInfoBox);
    }
    DisplayEmptyMap(ecTabTracks);
    DisplayTracks(ecTabTracks);
  }


  if(fMatchingType != MATCHING_NONE && fMatchingType<(Int_t)kNmatching){
    if(fMatchingType == MATCHING_BASIC)
      event->GetRecoEvent()->ResetMatchingArray();
    if(fMatchingType == MATCHING_VERTEX)
      event->GetRecoEvent()->ResetVertex3DArray();
    fMatching[fMatchingType]->ProcessEvent(event);
    fMatching[fMatchingType]->DisplayAnalysis(ecTabMatching,fInfoBox);
  }



  DisplayMap(ecTab3D);
  Display3D(ecTab3D);

  DisplayMap(ecTabSim);
  DisplaySim(ecTabSim);


  if(fAnalysisType != ANALYSIS_NONE && fAnalysisType<(Int_t)kNanalysis){
    fAnalysis[fAnalysisType]->ProcessEvent(event);
    fAnalysis[fAnalysisType]->DisplayAnalysis(ecTabAnalysis,fInfoBox);
  }

  std::cout << "****   " << event->GetRecoEvent()->GetClustersArray()->GetEntries() << "   ****" << std::endl;
  return;

  if(fCheckAnimFitting->IsOn()){
    fTab->SetTab(3);
    (fTrackFitting)->SetCanvas(ecTabClustersTracks->GetCanvas()->GetPad(1),0);
    (fTrackFitting)->SetHist(fHistEventEmpty[0],0);
    (fTrackFitting)->SetCanvas(ecTabClustersTracks->GetCanvas()->GetPad(2),1);
    (fTrackFitting)->SetHist(fHistEventEmpty[1],1);
  }else{
    (fTrackFitting)->SetCanvas(0,0);
    (fTrackFitting)->SetHist(0,0);
    (fTrackFitting)->SetCanvas(0,1);
    (fTrackFitting)->SetHist(0,1);
  }
  fTrackFitting->ProcessEvent(event);
  std::cout << "****   " << event->GetRecoEvent()->GetClustersArray()->GetEntries() << "   ****" << std::endl;
  return;
}


void HarpoRecoMonitorGui::NextEvent()
{

  //  if(HarpoConfig::gHReaderType!=hRootReader) return;

  Int_t Event = Int_t(fChooseDelay->GetNumber()) + 1;
  fChooseDelay->SetNumber(Event);
  Bool_t test = fReader->NextEvent();
  if(test)
    fEvent = fReader->GetEvent();
  else
    fEvent = 0;
  // fAna->ProcessEvent(evt);
  // evt->Delete();

  DisplayEvent(fEvent);
  return;
}

 
void HarpoRecoMonitorGui::PrevEvent()
{

  if(HarpoConfig::gHReaderType!=hRootReader){
    Warning("PrevEvent","Cannot navigate back with RAW Reader");
    return;
  }
  Int_t Event = Int_t(fChooseDelay->GetNumber()) - 1;
  fChooseDelay->SetNumber(Event);
  Bool_t test =  fReader->Find(Event);
  if(test)
    fEvent = fReader->GetEvent();
  else
    fEvent = 0;

  DisplayEvent(fEvent);
  return;

}

 
void HarpoRecoMonitorGui::DisplayEvent()
{
  Int_t Event = Int_t(fChooseDelay->GetNumber());

  Bool_t test =  fReader->Find(Event);
  std::cout << "############ " << test << " ##############" << std::endl;
  if(test)
    fEvent = fReader->GetEvent();
  else
    fEvent = NULL;

  DisplayEvent(fEvent);
  return;
}


 
void HarpoRecoMonitorGui::LoopEvents(Int_t nEvents)
{




  for(Int_t i = 0; i<nEvents; i++){
    Bool_t test = fReader->NextEvent();
    if(test){
      fEvent = fReader->GetEvent();
      DisplayEvent(fEvent);
    }else{
      fEvent = 0;
      break;
    }
  }
  return;
}


 
void HarpoRecoMonitorGui::FindEvent()
{

  SetSelectorParam();
  while(1){
    Bool_t test = fReader->NextEvent();
    if(test){
      std::cout << "." << std::flush;
      fEvent = fReader->GetEvent();

      //      Int_t select = fChooseEventSelector->GetSelected();
      if(fSelector[fSelectorType])
        fSelector[fSelectorType]->ProcessEvent(fEvent);
      Info("FindEvent","****** EvAnaStatus %d *******",fEvent->GetHeader()->GetEvAnaStatus());
      
      Int_t triggerType = -1;
      if(gHDetSet->isExist(PMM2)) {
        Pmm2Event *anaEvt = static_cast<Pmm2Event *>(fEvent->GetDetEvent(PMM2)); 
        triggerType = anaEvt->GetTriggerType();
      }
      if(fChooseTrigger->GetSelected() != -2 &&
         triggerType != fChooseTrigger->GetSelected()) continue;

 //  cout << "Trigger Type" << fChooseTrigger->GetSelected() << "  " << triggerType << endl;
 //  if(fChooseTrigger->GetSelected() != -2 &&
 //     triggerType != fChooseTrigger->GetSelected()) return false;

      // switch(fChooseEventSelector->GetSelected()){
      // case 1: fEventSelector->ProcessEvent(fEvent); break;
      // case 4: fSelectorSelectorVertex->ProcessEvent(fEvent); break;
      // case 3: fSelectorSelectorPileUp->ProcessEvent(fEvent); break;
      // case 2: fSelectorSelectorStraightTracks->ProcessEvent(fEvent); break;
      // }
      if(!fEvent->GetHeader()) continue;
      Info("FindEvent","****** EvAnaStatus %d *******",fEvent->GetHeader()->GetEvAnaStatus());
      if(fEvent->GetHeader()->GetEvAnaStatus() == 0) break;
    }else{
      fEvent = 0;
      break;
    }
  }
  fChooseDelay->SetNumber(fReader->GetReadEvts()-1); // Current event = nevents - 1
  DisplayEvent(fEvent);
  return;
}

Bool_t HarpoRecoMonitorGui::TestEvent(HarpoEvent* /* event */)
{

 
 //  Int_t EventType;
 //  if(event->GetRecoEvent()->GetEventType()<11)
 //    EventType = event->GetRecoEvent()->GetEventType();
 //  if(fEventSelector->IsGamma==1)
 //    EventType =11;
 //  if(fEventSelector->IsTriplet==1)
 //    EventType =12;

 // cout<<"Good Gamma event" << fEventSelector->IsGamma<<endl;
 // cout << "Event Type" << fChooseEventType->GetSelected() << "  " << EventType << endl;

 //  if(fChooseEventType->GetSelected() != -1 &&
 //     EventType != fChooseEventType->GetSelected()) return false;

 //  //  Int_t TTZType=event->GetRecoEvent()->GetEventTTZ();

 //  Int_t triggerType = -1;
 //  if(gHDetSet->isExist(PMM2)) {
 //    Pmm2Event *anaEvt = static_cast<Pmm2Event *>(event->GetDetEvent(PMM2)); 
 //    triggerType = anaEvt->GetTriggerType();
 //  }

 //  cout << "Trigger Type" << fChooseTrigger->GetSelected() << "  " << triggerType << endl;
 //  if(fChooseTrigger->GetSelected() != -2 &&
 //     triggerType != fChooseTrigger->GetSelected()) return false;

  return kTRUE;
}


void HarpoRecoMonitorGui::Save()
{

  // TCanvas* c = new TCanvas("c","",1600,800);
  // c->Divide(2);
  //  TCanvas* c = ecTabRaw->GetCanvas();

  // for(Int_t ndet = 0; ndet<2; ndet++){
  //   h1Ev2D[ndet]->SetMinimum(0.1);
  //   MakeNiceHisto(h1Ev2D[ndet],c->GetPad(ndet+1),"colz");
  // }

  //  const char* savedir="plots/events";
  //  const char* savedir = gSystem->ExpandPathName("$HARPO_ANA_DIR/reco");
  //  const char* savedir = gSystem->ExpandPathName(Form("$HARPO_ANA_DIR/reco/run%d/event%li",fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
  Char_t savedir[512];
  sprintf(savedir,"$HARPO_ANA_DIR/reco/run%d/event%li",fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts());
  gSystem->Exec(Form("mkdir -p %s",savedir));
  if(!gSystem->AccessPathName(savedir)){
    ecTabRaw->GetCanvas()->SaveAs(Form("%s/run%d_event%li_all.pdf[",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    ecTabNoiseSuppr->GetCanvas()->SaveAs(Form("%s/run%d_event%li_all.pdf",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    ecTabClusters->GetCanvas()->SaveAs(Form("%s/run%d_event%li_all.pdf",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    ecTabClustersTracks->GetCanvas()->SaveAs(Form("%s/run%d_event%li_all.pdf",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    ecTabTracks->GetCanvas()->SaveAs(Form("%s/run%d_event%li_all.pdf",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    ecTabMatching->GetCanvas()->SaveAs(Form("%s/run%d_event%li_all.pdf",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    ecTabVertex->GetCanvas()->SaveAs(Form("%s/run%d_event%li_all.pdf",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    ecTab3D->GetCanvas()->SaveAs(Form("%s/run%d_event%li_all.pdf]",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    //    c->SaveAs(Form("%s/run%d_event%li_all.pdf",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    //    c->SaveAs(Form("%s/run%d_event%li.png",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
  }else{
    ecTabRaw->GetCanvas()->SaveAs(Form("run%d_event%li_all.pdf[",fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    ecTabNoiseSuppr->GetCanvas()->SaveAs(Form("run%d_event%li_all.pdf",fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    ecTabClusters->GetCanvas()->SaveAs(Form("run%d_event%li_all.pdf",fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    ecTabClustersTracks->GetCanvas()->SaveAs(Form("run%d_event%li_all.pdf",fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    ecTabTracks->GetCanvas()->SaveAs(Form("run%d_event%li_all.pdf",fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    ecTabMatching->GetCanvas()->SaveAs(Form("run%d_event%li_all.pdf",fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    ecTabVertex->GetCanvas()->SaveAs(Form("run%d_event%li_all.pdf",fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    ecTab3D->GetCanvas()->SaveAs(Form("run%d_event%li_all.pdf]",fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    //    c->SaveAs(Form("run%d_event%li._allpdf",fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
    //    c->SaveAs(Form("run%d_event%li.png",fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
  }

  SaveEvent(fEvent,savedir);

}


void HarpoRecoMonitorGui::SaveEvent(HarpoEvent* evt, const char* savedir)
{

  InitEvent(evt);

  TLatex* latex = new TLatex();
  latex->SetTextFont(132);
  latex->SetTextAlign(12);
  latex->SetTextSize(0.08);

  HarpoRecoEvent* reco = evt->GetRecoEvent();
  TClonesArray* matchArray = reco->GetMatchingArray();
  TClonesArray* trArray = reco->GetTracksArray();
  Int_t nMatch = matchArray->GetEntries();

  TCanvas* cSave;
  cSave = new TCanvas("cSave","c",1100,1100);
  // cSave->Divide(2,1);

  TCanvas* cSaveLog;
  cSaveLog = new TCanvas("cSaveLog","log",1100,1100);
  // cSaveLog->Divide(2,1);

  TCanvas* cSaveSp;
  cSaveSp = new TCanvas("cSaveSp","spectrum",1100,1100);
  // cSaveSp->Divide(2,1);
  
  TCanvas* cSaveAll;
  cSaveAll = new TCanvas("cSaveAll","all",1500,500);
  cSaveAll->Divide(3);
  TVirtualPad* cSaveAll1 = cSaveAll->GetPad(1);
  cSaveAll1->SetName("cSaveAll1");
  TVirtualPad* cSaveAll2 = cSaveAll->GetPad(2);
  cSaveAll2->SetName("cSaveAll2");
  
  Int_t nPlanes = 2;
  Double_t left = 0.12, right = 0.12, bottom = 0.07, top = 0.01;
  /* TClonesArray* pads  = */CanvasPartition(cSave,1,nPlanes,left,right,bottom,top);
  /* TClonesArray* padsLog  = */CanvasPartition(cSaveLog,1,nPlanes,left,right,bottom,top);
  //  TClonesArray* padsSp  = CanvasPartition(cSaveSp,1,nPlanes,left,right,bottom,top);
  /* TClonesArray* padsAll1  = */ CanvasPartition(cSaveAll1,1,nPlanes,left,right,bottom,top);
  /* TClonesArray* padsAll2  = */ CanvasPartition(cSaveAll2,1,nPlanes,left,right,bottom,top);

  //  Double_t vcorr = 455./545, hcorr = 1;
  Double_t vcorr = ((1. - bottom - top)/2. + top)/((1. - bottom - top)/2. + bottom); //, hcorr = 1;

  TLine* lineT = new TLine();
  lineT->SetLineStyle(10);
  lineT->SetLineWidth(2);
  lineT->SetLineColor(kGray+1);
  Double_t tmin = 90., tmax = 415.;

  if(fMatchingType == MATCHING_BASIC){
    for(Int_t i = 0; i<nMatch; i++){
      HarpoRecoMatching* match = (HarpoRecoMatching*)matchArray->At(i);
      TCanvas* cMatch = new TCanvas(Form("cMatch%d",i));
      ((HarpoMatching*)fMatching[fMatchingType])->DrawMatching(match,cMatch);
      Int_t iTrX1 = match->GetiMatchTrX();
      Int_t iTrX2 = match->GetiMatchTrX2();
      Int_t iTrY1 = match->GetiMatchTrY();
      Int_t iTrY2 = match->GetiMatchTrY2();
      cMatch->SaveAs(Form("%s/run%d_event%ld_match_%d-%d_%d-%d.png",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts(),iTrX1,iTrX2,iTrY1,iTrY2));
      cMatch->SaveAs(Form("%s/run%d_event%ld_match_%d-%d_%d-%d.pdf",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts(),iTrX1,iTrX2,iTrY1,iTrY2));
    }
  }

  if(fReader->GetRunHeader()->GetSimDataFlag()){ // FIXME
    for(Int_t plane = 0; plane<2; plane++){
      for(Int_t i = 0; i<NADC-35; i++){
        for(Int_t j = 0; j<NCHAN; j++){
        fHistEvent[plane]->SetBinContent(NADC-i+1,j+1,fHistEvent[plane]->GetBinContent(NADC-35-i+1,j+1));
        }
      }
    }
  }

  char name[16];
  sprintf(name,"%s_%i_%i",cSave->GetName(),0,1);
  std::cout << name << std::endl;
  cSave->cd(0);
  ((TPad*) gROOT->FindObject(name))->Draw();
  ((TPad*) gROOT->FindObject(name))->cd();
  SetHistStyle(fHistEvent[0]);
  fHistEvent[0]->DrawCopy("colz");
  lineT->DrawLine(tmin,1,tmin,288);
  lineT->DrawLine(tmax,1,tmax,288);
  sprintf(name,"%s_%i_%i",cSave->GetName(),0,0);
  std::cout << name << std::endl;
  cSave->cd(0);
  ((TPad*) gROOT->FindObject(name))->Draw();
  ((TPad*) gROOT->FindObject(name))->cd();
  SetHistStyle(fHistEvent[1]);
  fHistEvent[1]->GetYaxis()->SetLabelSize(fHistEvent[1]->GetYaxis()->GetLabelSize()*vcorr);
  fHistEvent[1]->GetYaxis()->SetTitleSize(fHistEvent[1]->GetYaxis()->GetTitleSize()*vcorr);
  fHistEvent[1]->GetYaxis()->SetTitleOffset(fHistEvent[1]->GetYaxis()->GetTitleOffset()/vcorr);
  fHistEvent[1]->DrawCopy("colz");
  lineT->DrawLine(tmin,1,tmin,288);
  lineT->DrawLine(tmax,1,tmax,288);

  sprintf(name,"%s_%i_%i",cSaveLog->GetName(),0,1);
  std::cout << name << std::endl;
  cSaveLog->cd(0);
  ((TPad*) gROOT->FindObject(name))->Draw();
  ((TPad*) gROOT->FindObject(name))->SetLogz();
  ((TPad*) gROOT->FindObject(name))->cd();
  //SetHistStyle(fHistEvent[0]);
  fHistEvent[0]->DrawCopy("colz");
  lineT->DrawLine(tmin,1,tmin,288);
  lineT->DrawLine(tmax,1,tmax,288);
  sprintf(name,"%s_%i_%i",cSaveLog->GetName(),0,0);
  std::cout << name << std::endl;
  cSaveLog->cd(0);
  ((TPad*) gROOT->FindObject(name))->Draw();
  ((TPad*) gROOT->FindObject(name))->SetLogz();
  ((TPad*) gROOT->FindObject(name))->cd();
  //SetHistStyle(fHistEvent[1]);
  fHistEvent[1]->DrawCopy("colz");
  lineT->DrawLine(tmin,1,tmin,288);
  lineT->DrawLine(tmax,1,tmax,288);




  sprintf(name,"%s_%i_%i",cSaveAll1->GetName(),0,1);
  std::cout << name << std::endl;
  cSaveAll1->cd(0);
  ((TPad*) gROOT->FindObject(name))->Draw();
  ((TPad*) gROOT->FindObject(name))->cd();
  SetHistStyle(fHistEvent[0]);
  fHistEvent[0]->DrawCopy("colz");
  lineT->DrawLine(tmin,1,tmin,288);
  lineT->DrawLine(tmax,1,tmax,288);
  sprintf(name,"%s_%i_%i",cSaveAll1->GetName(),0,0);
  std::cout << name << std::endl;
  cSaveAll1->cd(0);
  ((TPad*) gROOT->FindObject(name))->Draw();
  ((TPad*) gROOT->FindObject(name))->cd();
  SetHistStyle(fHistEvent[1]);
  fHistEvent[1]->GetYaxis()->SetLabelSize(fHistEvent[1]->GetYaxis()->GetLabelSize()*vcorr);
  fHistEvent[1]->GetYaxis()->SetTitleSize(fHistEvent[1]->GetYaxis()->GetTitleSize()*vcorr);
  fHistEvent[1]->GetYaxis()->SetTitleOffset(fHistEvent[1]->GetYaxis()->GetTitleOffset()/vcorr);
  fHistEvent[1]->DrawCopy("colz");
  lineT->DrawLine(tmin,1,tmin,288);
  lineT->DrawLine(tmax,1,tmax,288);





  SetHistStyle(fHistEventEmpty[0]);
  SetHistStyle(fHistEventEmpty[1]);
  fHistEventEmpty[1]->GetYaxis()->SetLabelSize(fHistEventEmpty[1]->GetYaxis()->GetLabelSize()*vcorr);
  fHistEventEmpty[1]->GetYaxis()->SetTitleSize(fHistEventEmpty[1]->GetYaxis()->GetTitleSize()*vcorr);
  fHistEventEmpty[1]->GetYaxis()->SetTitleOffset(fHistEventEmpty[1]->GetYaxis()->GetTitleOffset()/vcorr);

  Int_t nTr = trArray->GetEntries();
  if(fTrackingType==2){
    Int_t ntrX = ((HarpoKalmanTracking*)fTracking[2])->GetNtr(0);
    Int_t ntrY = ((HarpoKalmanTracking*)fTracking[2])->GetNtr(1);
    if(ntrX>ntrY) ntrY = ntrX;
    //    const Int_t ntr = ntrY;//fTracking2->GetNtr(plane);
    //    TGraph* g[2][ntr];
    TLegend* l[2];

    TClonesArray* trArrayK = reco->GetKalmanTracksArray();
    Int_t nTrK = trArrayK->GetEntries();
    TGraph* g2[2][nTrK];
    for(Int_t i = 0; i<nTrK; i++){
      g2[0][i] = new TGraph();
      g2[1][i] = new TGraph();
    }
    TClonesArray* clArray = reco->GetClustersArray();
    Int_t nCl = clArray->GetEntries();
    for(Int_t icl = 0; icl<nCl; icl++){
      HarpoRecoClusters* cluster = (HarpoRecoClusters*)clArray->At(icl);
      Int_t plane = cluster->GetPlane();
      Int_t idTr = cluster->GetIdClusterTrack();
      if(plane!=XPLANE && plane !=YPLANE) continue;
      if(idTr<0) continue;
      //      Int_t idTr = fTracking2->GetId(idcluster,plane);
      //Info("DisplayTracks","plane = %d, idTr = %d (%g, %g)", plane, idTr,cluster->GetZfit(0),cluster->GetXfit(0));

      g2[plane][idTr]->SetPoint(g2[plane][idTr]->GetN(),cluster->GetZfit(0),cluster->GetXfit(0));
    }



    //    Int_t colorList[2][ntr];
    for(Int_t plane = 0; plane<2; plane++){
      sprintf(name,"%s_%i_%i",cSaveAll2->GetName(),0,1-plane);
      std::cout << name << std::endl;
      cSaveAll2->cd(0);
      ((TPad*) gROOT->FindObject(name))->Draw();
      ((TPad*) gROOT->FindObject(name))->cd();
      fHistEventEmpty[plane]->DrawCopy();
      lineT->DrawLine(tmin,1,tmin,288);
      lineT->DrawLine(tmax,1,tmax,288);
      l[plane] = new TLegend(0.1,0.7 + 0.01*plane,0.3,.99 + 0.01*plane);
      //      Int_t color = 2;
      for(Int_t itr = 0; itr<nTrK; itr++){
        HarpoRecoKalmanTracks* track = (HarpoRecoKalmanTracks*)trArrayK->At(itr);
        Int_t trId = track->GetNtrack();
        if(plane != track->GetPlane()) continue;
        if(!g2[plane][trId]) continue;
        if(g2[plane][trId]->GetN()<1) continue;
        Info("DisplayTracks","Plane %d, Tr %d => Ncl = %d",plane, trId,g2[plane][trId]->GetN());
        g2[plane][trId]->SetMarkerColor(trId+2);
        g2[plane][trId]->SetMarkerStyle(6);
        g2[plane][trId]->Draw("Psame");
        l[plane]->AddEntry(g2[plane][trId],Form("%d",trId),"P");
      }
      // for(Int_t itr = 0; itr<ntr; itr++){
      //        g[plane][itr] = fTracking2->GetGraph(itr,plane);
      //        if(!g[plane][itr]) continue;
      //        //      if(g[plane][itr] == 0) continue;
      //        //      cout << itr << "    ===>   " << g[plane][itr]->GetN() << endl;
      //        if(g[plane][itr]->GetN()<1) continue;
      //        g[plane][itr]->SetMarkerStyle(6);
      //        g[plane][itr]->SetMarkerColor(color);
      //        colorList[plane][itr] = color;
      //        color++;
      //        g[plane][itr]->Draw("Psame");
      //        l[plane]->AddEntry(g[plane][itr],Form("%d",itr),"P");
      // }
      //l[plane]->Draw();
    }


  }
 

  
  //Double_t angleX[10], angleY[10];
  //  Int_t nclX[10], nclY[10];
  //Int_t planeTr[10];
  for(Int_t itr = 0; itr<nTr; itr++){
    
    HarpoRecoTracks* track = (HarpoRecoTracks*)trArray->At(itr);
    
    Int_t ndet = track->GetPlane();
    // Double_t theta = track->GetMtheta();
    // Double_t rho = track->GetMrho();
    // fInfoBox->NewEntry(Form("SigRho = %g",track->GetSigrho()));
    // Info("DisplayTracks","SigRho = %g",track->GetSigrho());
    Double_t angX=track->GetAngleTrack();;
    if(ndet==0) cout<<"angle="<<angX<<endl;
    //    planeTr[itr] = ndet;
    //    if(ndet==0) angleX[itr]=track->GetAngleTrack();
    //    if(ndet==1) angleY[itr]=track->GetAngleTrack();
    //    if(ndet==0) nclX[itr]=track->GetNclusterTrack();
    //    if(ndet==1) nclY[itr]=track->GetNclusterTrack();
    //    Int_t rlambda=0;
    
    //    Int_t color = itr+2;  
    sprintf(name,"%s_%i_%i",cSaveAll2->GetName(),0,1-ndet);
    std::cout << name << std::endl;
    cSaveAll2->cd(0);
    //((TPad*) gROOT->FindObject(name))->Draw();
    ((TPad*) gROOT->FindObject(name))->cd();
    
    // TF1* line = new TF1("line","pol1",0,511);
    // // if(rho<0){ theta = TMath::Pi()/2 - theta; }
    // // else rho = -rho;
    // line->SetParameter(0,rho/TMath::Cos(theta) + 511./2.*TMath::Tan(theta) + 144);
    // //    line->SetParameter(1, - 1./TMath::Tan(theta));
    // line->SetParameter(1, - TMath::Tan(theta));
    // line->SetLineColor(color);

    // line->DrawCopy("same");
    // line->Delete();
    
    // TEllipse* pStart = new TEllipse();
    // pStart->SetFillColor(color);
    // pStart->DrawEllipse(track->GetZstart(),track->GetXstart(),5,0,0,360,0);
    // pStart->Delete();
    // TEllipse* pEnd = new TEllipse();
    // pEnd->SetFillColor(color);
    // pEnd->SetFillStyle(3001);
    // pEnd->DrawEllipse(track->GetZend(),track->GetXend(),5,0,0,360,0);
    // pEnd->Delete();
    
    // TLine* line = new TLine();  
    // line->SetLineColor(color);  

  }




  fInfoBox->NewEntry(Form("nMatch = %d",matchArray->GetEntries()));
  //  if(nMatch<1) return;
  
  TH3F* hDummy3D = new TH3F("hDummy3D",";Z;X;Y",10,0,511,10,0,288,10,0,288);
  cSaveAll->cd(3);
  hDummy3D->Draw();
  //  MakeNiceHisto(hDummy3D,cTab->GetPad(1),"lego");
  Int_t used[NTRACK][NTRACK];
  for(Int_t i = 0; i<NTRACK; i++)
    for(Int_t j = 0; j<NTRACK; j++)
      used[i][j] = kBlack;
  Int_t color = 2;
  Double_t z0[nMatch], /*  z1[nMatch], */ x0[nMatch], y0[nMatch], slopeX[nMatch], slopeY[nMatch];
  for(Int_t i = 0; i<nMatch; i++){
    x0[i] = -1000;
    y0[i] = -1000;
    slopeX[i] = -1000;
    slopeY[i] = -1000;
    cSaveAll->cd(3);
    HarpoRecoMatching* match = (HarpoRecoMatching*)matchArray->At(i);
    Int_t trX = match->GetiMatchTrX();
    Int_t trY = match->GetiMatchTrY();
    if(used[trX][trY] == kBlack){
      used[trX][trY] = color;
      color++;
    }
    
    //    g->SetMarkerColor(used[trX][trY]);


    for(Int_t itr = 0; itr<nTr; itr++){
      
      HarpoRecoTracks* track = (HarpoRecoTracks*)trArray->At(itr);
      Int_t trId = track->GetNtrack();
      Int_t plane = track->GetPlane();

      if(trId == trX && plane == XPLANE){
        //      x0[i] = track->GetMrho();
        if(track->GetZstart()<track->GetZend()){
          z0[i] = track->GetZstart();
          //      z1[i] = track->GetZend();
        }else{
          //      z1[i] = track->GetZstart();
          z0[i] = track->GetZend();
        }
        //      slopeX[i] = track->GetMtheta();
        slopeX[i] = TMath::Tan(track->GetAngleTrack());
        x0[i] = track->GetXstart() - track->GetZstart()*slopeX[i];
      }
      if(trId == trY && plane == YPLANE){
        //      y0[i] = track->GetMrho();
        //slopeY[i] = track->GetMtheta();
        slopeY[i] = TMath::Tan(track->GetAngleTrack());
        y0[i] = track->GetXstart() - track->GetZstart()*slopeY[i];
      }
    }
    TPolyLine3D *l = new TPolyLine3D(2);
    l->SetPoint(0,z0[i],x0[i] + z0[i]*slopeX[i],y0[i] + z0[i]*slopeY[i]);
    l->SetPoint(1,500,x0[i] + 500*slopeX[i],y0[i]+500*slopeY[i]);
    l->SetLineColor(used[trX][trY]);
    l->Draw();
  }
  
  Double_t egamma = fReader->GetRunHeader()->GetEgamma();
  const Int_t kNeReal = 13;
  Double_t eGammaReal[kNeReal] = {1.74, 2.73, 3.93, 4.68, 6.76, 11.8, 16.9, 18.5, 26.6, 33.3, 38.1, 52.1, 74.3};
  for(Int_t i = 0; i<kNeReal; i++)
    if(eGammaReal[i]-egamma>0 && eGammaReal[i]-egamma<2) egamma = eGammaReal[i];
  if(egamma>0){
    Info("Save","Egamma = %g",egamma);
    sprintf(name,"%s_%i_%i",cSave->GetName(),0,1);
    cSave->cd(0);
    ((TPad*) gROOT->FindObject(name))->cd();
    latex->SetTextSize(0.12);
    //latex->DrawLatex(20,260,Form("E_{#gamma} = %.3g MeV",egamma));
  }
  cSave->SaveAs(Form("%s/run%d_event%ld_linZ.png",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
  cSave->SaveAs(Form("%s/run%d_event%ld_linZ.pdf",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
  cSave->SaveAs(Form("%s/run%d_event%ld_linZ.C",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
  cSaveLog->SaveAs(Form("%s/run%d_event%ld_logZ.pdf",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
  cSaveSp->SaveAs(Form("%s/run%d_event%ld_Spectrum.pdf",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
  cSaveSp->SaveAs(Form("%s/run%d_event%ld_Spectrum.png",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
  cSaveAll->SaveAs(Form("%s/run%d_event%ld_all.png",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
  cSaveAll->SaveAs(Form("%s/run%d_event%ld_all.pdf",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));
  cSaveAll->SaveAs(Form("%s/run%d_event%ld_all.C",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()));




  std::ofstream textfile;
  textfile.open(Form("%s/run%d_event%ld_X.txt",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()), std::ofstream::out);
  for(Int_t i = 1; i<=fHistEvent[0]->GetXaxis()->GetNbins(); i++)
    for(Int_t j = 1; j<=fHistEvent[0]->GetYaxis()->GetNbins(); j++)
      if(fHistEvent[0]->GetBinContent(i,j)>0)
        textfile << i << "\t" << j << endl;
  textfile.close();
  textfile.open(Form("%s/run%d_event%ld_X_2.txt",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()), std::ofstream::out);
  for(Int_t i = 1; i<=fHistEvent[0]->GetXaxis()->GetNbins(); i++)
    for(Int_t j = 1; j<=fHistEvent[0]->GetYaxis()->GetNbins(); j++)
      if(fHistEvent[0]->GetBinContent(i,j)>0)
        textfile << i << "\t" << j << "\t" << fHistEvent[0]->GetBinContent(i,j) << endl;
  textfile.close();
  textfile.open(Form("%s/run%d_event%ld_Y.txt",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()), std::ofstream::out);
  for(Int_t i = 1; i<=fHistEvent[1]->GetXaxis()->GetNbins(); i++)
    for(Int_t j = 1; j<=fHistEvent[1]->GetYaxis()->GetNbins(); j++)
      if(fHistEvent[1]->GetBinContent(i,j)>0)
        textfile << i << "\t" << j << endl;
  textfile.close();
  textfile.open(Form("%s/run%d_event%ld_Y_2.txt",savedir,fReader->GetRunHeader()->GetRun(),fReader->GetReadEvts()), std::ofstream::out);
  for(Int_t i = 1; i<=fHistEvent[0]->GetXaxis()->GetNbins(); i++)
    for(Int_t j = 1; j<=fHistEvent[0]->GetYaxis()->GetNbins(); j++)
      if(fHistEvent[1]->GetBinContent(i,j)>0)
        textfile << i << "\t" << j << "\t" << fHistEvent[1]->GetBinContent(i,j) << endl;
  textfile.close();

}


// //__________________________________________________________________
// void HarpoRecoMonitorGui::Hist2dClicked(TVirtualPad* pad, TObject* select, Int_t event) 
// {
//   //this action function is called whenever you click the mouse
//   //it just prints the pad coordinates and channel number, and
//   //displays the pulse in time in another window
  
//   if (event != kButton1Down) return; //has to click to see pad signal in time
//   if (!select) return;
//   if (!select->InheritsFrom("TH2F")) return;
//   TH2F *hist = (TH2F*)select;
// }


//---------------------------------






Bool_t HarpoRecoMonitorGui::ProcessMessage(Long_t msg, Long_t parm1, Long_t)
{

  SetConfig();
  switch(GET_MSG(msg)){
  case kC_COMMAND:
    switch(GET_SUBMSG(msg)){
    case kCM_BUTTON:
      switch(parm1){
      case M_DISPLAY_EVENT: DisplayEvent(); break;
      case M_NEXT_EVENT: NextEvent(); break;
      case M_FIND_EVENT: FindEvent(); break;
      case M_SET_CONF_TRACKING: 
        if(fTracking[fTrackingType]) fTracking[fTrackingType]->SetConfig();
        break;
      case M_CONF_TRACKING: 
        if(fTracking[fTrackingType]) fTracking[fTrackingType]->ConfigFrame(this,M_SET_CONF_TRACKING);
        break;
      case M_SET_CONF_CLUSTERING: 
        if(fClustering[fClusteringType]) fClustering[fClusteringType]->SetConfig();
        break;
      case M_CONF_CLUSTERING: 
        if(fClustering[fClusteringType]) fClustering[fClusteringType]->ConfigFrame(this,M_SET_CONF_CLUSTERING);
        break;
      case M_SET_CONF_MATCHING: 
        if(fMatching[fMatchingType]) fMatching[fMatchingType]->SetConfig();
        break;
      case M_CONF_MATCHING: 
        if(fMatching[fMatchingType]) fMatching[fMatchingType]->ConfigFrame(this,M_SET_CONF_MATCHING);
        break;
      case M_SET_CONF_VERTEXING: 
        if(fVertexing[fVertexingType]) fVertexing[fVertexingType]->SetConfig();
        break;
      case M_CONF_VERTEXING: 
        if(fVertexing[fVertexingType]) fVertexing[fVertexingType]->ConfigFrame(this,M_SET_CONF_VERTEXING);
        break;
      case M_SET_CONF_ANALYSIS: 
        if(fAnalysis[fAnalysisType]) fAnalysis[fAnalysisType]->SetConfig();
        break;
      case M_CONF_ANALYSIS: 
        if(fAnalysis[fAnalysisType]) fAnalysis[fAnalysisType]->ConfigFrame(this,M_SET_CONF_ANALYSIS);
        break;
      case M_SET_CONF_SELECTOR: 
        if(fSelector[fSelectorType]) fSelector[fSelectorType]->SetConfig();
        break;
      case M_CONF_SELECTOR: 
        if(fSelector[fSelectorType]) fSelector[fSelectorType]->ConfigFrame(this,M_SET_CONF_SELECTOR);
        break;
        //      case M_DISPLAY: Display(); break;
      case M_SAVE: Save(); break;
      case M_PREV_EVENT: PrevEvent(); break;
      case M_AUTOREFRESH:
        LoopEvents(fChooseDelay->GetNumber());
        break;
      default: cout << "Unknown button" << endl; break;
      }
    default:
      break;
    }
  default: 
      break;
  }

  return kTRUE;
}



void HarpoRecoMonitorGui::SetStyle()
{

}




Double_t HarpoRecoMonitorGui::TruncSigma(TArrayD* vect, Double_t &truncS, Double_t &truncM, Double_t tl, Double_t th)
{
  //
  // Calculates the truncated mean mean of the non zero value in vect
  // The truncation is done on the 100*tl% lowest and 100*(1-th) highest value
  //
  //  debug(2,"truncated mean");


  Int_t size = vect->GetSize();
  Double_t truncMean = 0;
  Double_t truncSigma = 0;
  Int_t* index = new Int_t[size];
  TMath::Sort(size,vect->GetArray(),index,kFALSE);
  Int_t t = 0, tLow, tHigh;


  while(vect->At(index[t])<10&&t<size-1) t++;
  tLow  = TMath::FloorNint(t + (size - t)*tl);
  tHigh = TMath::FloorNint(t + (size - t)*th);

  for(Int_t tind = tLow; tind<tHigh; tind++){
    truncMean += vect->At(index[tind]);
    truncSigma += vect->At(index[tind])*vect->At(index[tind]);
  }

  truncM = 0;
  truncS = 0;
  if(tHigh-tLow == 0) return 0;

  truncMean /= (tHigh-tLow);
  truncSigma /= (tHigh-tLow);
  truncSigma -= truncMean*truncMean;

  truncM = truncMean;
  truncS = TMath::Sqrt(truncSigma);


  return truncSigma;
}