PMusrCanvas.h

Go to the documentation of this file.

/***************************************************************************

  PMusrCanvas.h

  Author: Andreas Suter
  e-mail: andreas.suter@psi.ch

***************************************************************************/

/***************************************************************************
 *   Copyright (C) 2007-2023 by Andreas Suter                              *
 *   andreas.suter@psi.ch                                                  *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef _PMUSRCANVAS_H_
#define _PMUSRCANVAS_H_

#include <TObject.h>
#include <TQObject.h>
#include <TStyle.h>
#include <TRootCanvas.h>
#include <TGMenu.h>
#include <TCanvas.h>
#include <TPaveText.h>
#include <TLegend.h>
#include <TPad.h>
#include <TH1F.h>
#include <TGraphErrors.h>
#include <TMultiGraph.h>
#include <TLatex.h>

#include "PMusr.h"
#ifndef __MAKECLING__
#include "PMsrHandler.h"
#include "PRunListCollection.h"
#endif // __MAKECLING__

#define YINFO  0.1
#define YTITLE 0.95
#define XTHEO  0.75

// Current Plot Views
#define PV_DATA                   1
#define PV_FOURIER_REAL           2
#define PV_FOURIER_IMAG           3
#define PV_FOURIER_REAL_AND_IMAG  4
#define PV_FOURIER_PWR            5
#define PV_FOURIER_PHASE          6
#define PV_FOURIER_PHASE_OPT_REAL 7

// Canvas menu id's
#define P_MENU_ID_DATA          10001
#define P_MENU_ID_FOURIER       10002
#define P_MENU_ID_DIFFERENCE    10003
#define P_MENU_ID_AVERAGE       10004
#define P_MENU_ID_EXPORT_DATA   10005

#define P_MENU_PLOT_OFFSET      1000

#define P_MENU_ID_FOURIER_REAL           100
#define P_MENU_ID_FOURIER_IMAG           101
#define P_MENU_ID_FOURIER_REAL_AND_IMAG  102
#define P_MENU_ID_FOURIER_PWR            103
#define P_MENU_ID_FOURIER_PHASE          104
#define P_MENU_ID_FOURIER_PHASE_OPT_REAL 105
#define P_MENU_ID_FOURIER_PHASE_PLUS     106
#define P_MENU_ID_FOURIER_PHASE_MINUS    107

//------------------------------------------------------------------------
class PMusrCanvasPlotRange : public TObject
{
  public:
    PMusrCanvasPlotRange();
    virtual ~PMusrCanvasPlotRange() {}

    virtual void SetXRange(Double_t xmin, Double_t xmax);
    virtual void SetYRange(Double_t ymin, Double_t ymax);

    virtual Bool_t IsXRangePresent() { return fXRangePresent; }
    virtual Bool_t IsYRangePresent() { return fYRangePresent; }

    virtual Double_t GetXmin() { return fXmin; }
    virtual Double_t GetXmax() { return fXmax; }
    virtual Double_t GetYmin() { return fYmin; }
    virtual Double_t GetYmax() { return fYmax; }

  private:
    Bool_t fXRangePresent;
    Bool_t fYRangePresent;
    Double_t fXmin;
    Double_t fXmax;
    Double_t fYmin;
    Double_t fYmax;

  ClassDef(PMusrCanvasPlotRange, 1)
};

//------------------------------------------------------------------------
struct PMusrCanvasDataSet {
  TH1F *data;                
  TH1F *dataFourierRe;       
  TH1F *dataFourierIm;       
  TH1F *dataFourierPwr;      
  TH1F *dataFourierPhase;    
  TH1F *dataFourierPhaseOptReal; 
  TH1F *theory;              
  TH1F *theoryFourierRe;     
  TH1F *theoryFourierIm;     
  TH1F *theoryFourierPwr;    
  TH1F *theoryFourierPhase;  
  TH1F *theoryFourierPhaseOptReal; 
  TH1F *diff;                
  TH1F *diffFourierRe;       
  TH1F *diffFourierIm;       
  TH1F *diffFourierPwr;      
  TH1F *diffFourierPhase;    
  TH1F *diffFourierPhaseOptReal; 
  PMusrCanvasPlotRange *dataRange;    
  UInt_t diffFourierTag; 
};

//------------------------------------------------------------------------
typedef std::vector<PMusrCanvasDataSet> PMusrCanvasDataList;

//------------------------------------------------------------------------
struct PMusrCanvasNonMusrDataSet {
  TGraphErrors *data;               
  TGraphErrors *dataFourierRe;      
  TGraphErrors *dataFourierIm;      
  TGraphErrors *dataFourierPwr;     
  TGraphErrors *dataFourierPhase;   
  TGraphErrors *theory;             
  TGraphErrors *theoryFourierRe;    
  TGraphErrors *theoryFourierIm;    
  TGraphErrors *theoryFourierPwr;   
  TGraphErrors *theoryFourierPhase; 
  TGraphErrors *diff;               
  TGraphErrors *diffFourierRe;      
  TGraphErrors *diffFourierIm;      
  TGraphErrors *diffFourierPwr;     
  TGraphErrors *diffFourierPhase;   
  PMusrCanvasPlotRange *dataRange;    
  UInt_t diffFourierTag; 
};

//------------------------------------------------------------------------
typedef std::vector<PMusrCanvasNonMusrDataSet> PMusrCanvasNonMusrDataList;

//------------------------------------------------------------------------
struct PMusrCanvasAsciiDump {
  PDoubleVector dataX;   
  PDoubleVector data;    
  PDoubleVector dataErr; 
};

//------------------------------------------------------------------------
typedef std::vector<PMusrCanvasAsciiDump> PMusrCanvasAsciiDumpVector;

//--------------------------------------------------------------------------
class PMusrCanvas : public TObject, public TQObject
{
  public:
    PMusrCanvas();
    PMusrCanvas(const Int_t number, const Char_t* title,
                Int_t wtopx, Int_t wtopy, Int_t ww, Int_t wh, const Bool_t batch,
                const Bool_t fourier=false, const Bool_t avg=false, const Bool_t theoAsData=false);
    PMusrCanvas(const Int_t number, const Char_t* title,
                Int_t wtopx, Int_t wtopy, Int_t ww, Int_t wh,
                PMsrFourierStructure fourierDefault,
                const PIntVector markerList, const PIntVector colorList, const Bool_t batch,
                const Bool_t fourier=false, const Bool_t avg=false, const Bool_t theoAsData=false);
    virtual ~PMusrCanvas();

    virtual Bool_t IsValid() { return fValid; }

#ifndef __MAKECLING__
    virtual void SetMsrHandler(PMsrHandler *msrHandler);
    virtual void SetRunListCollection(PRunListCollection *runList) { fRunList = runList; }
#endif // __MAKECLING__

    virtual void SetTimeout(Int_t ival);
    virtual void UpdateParamTheoryPad();
    virtual void UpdateDataTheoryPad();
    virtual void UpdateInfoPad();

    virtual void Done(Int_t status=0); // *SIGNAL*
    virtual void HandleCmdKey(Int_t event, Int_t x, Int_t y, TObject *selected); // SLOT
    virtual void HandleMenuPopup(Int_t id); // SLOT
    virtual void LastCanvasClosed(); // SLOT
    virtual void WindowClosed(); // SLOT

    virtual void SaveGraphicsAndQuit(Char_t *fileName, Char_t *graphicsFormat);
    virtual void ExportData(const Char_t *fileName);

  private:
    Bool_t fTheoAsData;       
    Bool_t fStartWithFourier; 
    Bool_t fStartWithAvg;     
    Int_t  fTimeout;          
    Bool_t fScaleN0AndBkg;    
    Bool_t fBatchMode;        
    Bool_t fValid;            
    Bool_t fAveragedView;     
    Bool_t fDifferenceView;   
    Bool_t fToggleColor;      
    Int_t  fCurrentPlotView;  
    Int_t  fPreviousPlotView; 
    Int_t  fPlotType;         
    Int_t  fPlotNumber;       

    Bool_t fXRangePresent, fYRangePresent; 
    Double_t fXmin, fXmax, fYmin, fYmax;   

    PDoubleVector fCurrentFourierPhase; 
    std::unique_ptr<TLatex> fCurrentFourierPhaseText; 
    std::unique_ptr<TString> fRRFText;      
    std::unique_ptr<TLatex>  fRRFLatexText; 

    std::unique_ptr<TStyle> fStyle; 

    std::unique_ptr<TTimer> fTimeoutTimer; 

    // canvas menu related variables
    TRootCanvas *fImp;           
    TGMenuBar   *fBar;           
    TGPopupMenu *fPopupMain;     
    std::unique_ptr<TGPopupMenu> fPopupFourier;  

    // canvas related variables
    std::unique_ptr<TCanvas> fMainCanvas; 
    std::unique_ptr<TPaveText> fTitlePad; 
    std::unique_ptr<TPad> fDataTheoryPad; 
    std::unique_ptr<TPaveText> fParameterPad; 
    std::unique_ptr<TPaveText> fTheoryPad; 
    std::unique_ptr<TLegend> fInfoPad; 
    std::unique_ptr<TLegend> fMultiGraphLegend; 

    TH1F *fHistoFrame; 

#ifndef __MAKECLING__
    PMsrHandler        *fMsrHandler; 
    PRunListCollection *fRunList;    
#endif // __MAKECLING__

    PMusrCanvasDataSet fDataAvg; 

    PMusrCanvasDataList fData; 
    PMusrCanvasNonMusrDataList fNonMusrData; 
    TMultiGraph *fMultiGraphData; 
    TMultiGraph *fMultiGraphDiff; 

    PMsrFourierStructure fFourier; 
    PIntVector fMarkerList; 
    PIntVector fColorList;  

    virtual void CreateStyle();
    virtual void InitFourier();
    virtual void InitAverage();
    virtual void InitMusrCanvas(const Char_t* title, Int_t wtopx, Int_t wtopy, Int_t ww, Int_t wh);
    virtual void InitDataSet(PMusrCanvasDataSet &dataSet);
    virtual void InitDataSet(PMusrCanvasNonMusrDataSet &dataSet);
    virtual void CleanupDataSet(PMusrCanvasDataSet &dataSet);
    virtual void CleanupDataSet(PMusrCanvasNonMusrDataSet &dataSet);
    virtual void HandleDataSet(UInt_t plotNo, UInt_t runNo, PRunData *data);
    virtual void HandleNonMusrDataSet(UInt_t plotNo, UInt_t runNo, PRunData *data);
    virtual void HandleDifference();
    virtual void HandleFourier();
    virtual void HandleDifferenceFourier();
    virtual void HandleFourierDifference();
    virtual void HandleAverage();
    virtual void CleanupDifference();
    virtual void CleanupFourier();
    virtual void CleanupFourierDifference();
    virtual void CleanupAverage();

    virtual void CalcPhaseOptReFT();
    virtual Double_t CalculateDiff(const Double_t x, const Double_t y, TH1F *theo);
    virtual Double_t CalculateDiff(const Double_t x, const Double_t y, TGraphErrors *theo);
    virtual Int_t  FindBin(const Double_t x, TGraphErrors *graph);

    virtual Double_t GetMaximum(TH1F* histo, Double_t xmin=-1.0, Double_t xmax=-1.0);
    virtual Double_t GetMinimum(TH1F* histo, Double_t xmin=-1.0, Double_t xmax=-1.0);
    virtual Double_t GetMaximum(TGraphErrors* graph, Double_t xmin=-1.0, Double_t xmax=-1.0);
    virtual Double_t GetMinimum(TGraphErrors* graph, Double_t xmin=-1.0, Double_t xmax=-1.0);

    virtual void PlotData(Bool_t unzoom=false);
    virtual void PlotDifference(Bool_t unzoom=false);
    virtual void PlotFourier(Bool_t unzoom=false);
    virtual void PlotFourierDifference(Bool_t unzoom=false);
    virtual void PlotFourierPhaseValue(Bool_t unzoom=false);
    virtual void PlotAverage(Bool_t unzoom=false);
    virtual void IncrementFourierPhase();
    virtual void DecrementFourierPhase();

    virtual Bool_t IsScaleN0AndBkg();
    virtual UInt_t GetNeededAccuracy(PMsrParamStructure param);

    virtual Double_t GetInterpolatedValue(TH1F* histo, Double_t xVal);

    virtual void GetExportDataSet(const TH1F *data, const Double_t xmin, const Double_t xmax,
                                  PMusrCanvasAsciiDumpVector &dumpData, const Bool_t hasError=true);

  ClassDef(PMusrCanvas, 1)
};

#endif // _PMUSRCANVAS_H_