PMusrCanvas.h

Go to the documentation of this file.

/***************************************************************************
 
  PMusrCanvas.h
 
  Author: Andreas Suter
  e-mail: andreas.suter@psi.ch
 
***************************************************************************/
 
/***************************************************************************
 *   Copyright (C) 2007-2026 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__
 
//--------------------------------------------------------------------------
// Layout constants
//--------------------------------------------------------------------------
#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 IDs
//--------------------------------------------------------------------------
#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   
 
//--------------------------------------------------------------------------
// Fourier submenu IDs
//--------------------------------------------------------------------------
#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_