410 lines
17 KiB
C++
410 lines
17 KiB
C++
/***************************************************************************
|
|
|
|
PFourierCanvas.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 _PFOURIERCANVAS_H_
|
|
#define _PFOURIERCANVAS_H_
|
|
|
|
#include <vector>
|
|
#include <memory>
|
|
|
|
#include <TObject.h>
|
|
#include <TQObject.h>
|
|
#include <TTimer.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 <TLatex.h>
|
|
|
|
#include "PMusr.h"
|
|
#include "PFourier.h"
|
|
|
|
// Canvas menu id's
|
|
#define P_MENU_ID_FOURIER 10001
|
|
#define P_MENU_ID_AVERAGE 10002
|
|
#define P_MENU_ID_AVERAGE_PER_DATA_SET 10003
|
|
#define P_MENU_ID_EXPORT_DATA 10004
|
|
|
|
#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
|
|
|
|
//------------------------------------------------------------------------
|
|
/**
|
|
* <p>Structure holding all Fourier transform histograms for one data set.
|
|
*
|
|
* <p>This structure bundles all different representations of a single
|
|
* Fourier transform, including real, imaginary, power, phase, and
|
|
* phase-optimized spectra. Each μSR run or dataset gets one instance.
|
|
*
|
|
* <p><b>Purpose:</b> Provides complete Fourier analysis results in one
|
|
* container for easy access and visualization switching.
|
|
*
|
|
* @see PFourierCanvas
|
|
* @see PFourier
|
|
*/
|
|
struct PFourierCanvasDataSet {
|
|
TH1F *dataFourierRe; ///< Real part Re(F): absorption-mode spectrum (mixed phase if uncorrected)
|
|
TH1F *dataFourierIm; ///< Imaginary part Im(F): dispersion-mode spectrum
|
|
TH1F *dataFourierPwr; ///< Power spectrum |F| = √(Re² + Im²): phase-independent amplitude
|
|
TH1F *dataFourierPhase; ///< Phase spectrum φ = atan2(Im, Re): phase angle in radians
|
|
TH1F *dataFourierPhaseOptReal; ///< Phase-optimized real spectrum: maximized absorption mode with minimal imaginary component
|
|
std::vector<Double_t> optPhase; ///< Optimal phase parameters [c₀, c₁] for phase correction: φ(ω) = c₀ + c₁·ω
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
/**
|
|
* <p>Type alias for a collection of Fourier data sets.
|
|
*
|
|
* <p>Represents multiple μSR runs or datasets, each with complete
|
|
* Fourier transform results. Used for multi-run visualization and
|
|
* averaging operations.
|
|
*
|
|
* @see PFourierCanvasDataSet
|
|
*/
|
|
typedef std::vector<PFourierCanvasDataSet> PFourierCanvasDataList;
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>Interactive ROOT canvas for visualizing μSR Fourier transform spectra.
|
|
*
|
|
* <p>PFourierCanvas provides a sophisticated GUI for displaying and analyzing
|
|
* Fourier-transformed μSR data with multiple viewing modes:
|
|
* - Real spectrum (absorption mode)
|
|
* - Imaginary spectrum (dispersion mode)
|
|
* - Real + Imaginary overlay
|
|
* - Power spectrum (magnitude)
|
|
* - Phase spectrum
|
|
* - Phase-optimized real spectrum
|
|
*
|
|
* <p><b>Key features:</b>
|
|
* - Multi-run visualization with color/marker coding
|
|
* - Interactive phase adjustment (±5° increments)
|
|
* - Automatic averaging across all runs or per dataset
|
|
* - Export to data files
|
|
* - Batch mode for non-interactive operation
|
|
* - Customizable markers and colors
|
|
* - Menu-driven interface with keyboard shortcuts
|
|
*
|
|
* <p><b>Usage modes:</b>
|
|
* - <b>Interactive:</b> Full GUI with menus for exploring spectra
|
|
* - <b>Batch:</b> Automated plot generation for scripts
|
|
* - <b>Individual:</b> Display each run separately
|
|
* - <b>Averaged:</b> Show ensemble average across all data
|
|
* - <b>Per-dataset average:</b> Average within grouped datasets
|
|
*
|
|
* <p><b>Architecture:</b> Uses ROOT TQObject for signal/slot mechanism,
|
|
* enabling clean event handling and timeout functionality.
|
|
*
|
|
* @see PFourier
|
|
* @see PFourierCanvasDataSet
|
|
*/
|
|
class PFourierCanvas : public TObject, public TQObject
|
|
{
|
|
public:
|
|
/**
|
|
* <p>Default constructor - creates empty canvas.
|
|
*
|
|
* <p>Initializes internal state with default values. Not typically
|
|
* used directly; prefer constructors with data parameters.
|
|
*/
|
|
PFourierCanvas();
|
|
|
|
/**
|
|
* <p>Constructor with automatic marker/color generation.
|
|
*
|
|
* <p>Creates interactive Fourier canvas with randomly generated
|
|
* markers and colors for each data set.
|
|
*
|
|
* @param fourier Vector of PFourier objects containing transformed data
|
|
* @param dataSetTag Vector of dataset identifiers for grouping runs
|
|
* @param title Canvas window title
|
|
* @param showAverage If true, display average across all runs
|
|
* @param showAveragePerDataSet If true, average within each dataset group
|
|
* @param fourierPlotOpt Initial plot mode (real/imag/power/phase/etc.)
|
|
* @param fourierXrange X-axis range [min, max] in output units (G/T/MHz)
|
|
* @param phase Initial phase offset in degrees for Re/Im display
|
|
* @param wtopx X position of canvas window (pixels)
|
|
* @param wtopy Y position of canvas window (pixels)
|
|
* @param ww Canvas width (pixels)
|
|
* @param wh Canvas height (pixels)
|
|
* @param batch If true, run in batch mode (no GUI interaction)
|
|
*/
|
|
PFourierCanvas(std::vector<PFourier*> &fourier, PIntVector dataSetTag, const Char_t* title,
|
|
const Bool_t showAverage, const Bool_t showAveragePerDataSet,
|
|
const Int_t fourierPlotOpt, Double_t fourierXrange[2], Double_t phase,
|
|
Int_t wtopx, Int_t wtopy, Int_t ww, Int_t wh, const Bool_t batch);
|
|
|
|
/**
|
|
* <p>Constructor with explicit marker/color specification.
|
|
*
|
|
* <p>Creates interactive Fourier canvas with user-defined visual
|
|
* styling for each data set. Provides full control over plot appearance.
|
|
*
|
|
* @param fourier Vector of PFourier objects containing transformed data
|
|
* @param dataSetTag Vector of dataset identifiers for grouping runs
|
|
* @param title Canvas window title
|
|
* @param showAverage If true, display average across all runs
|
|
* @param showAveragePerDataSet If true, average within each dataset group
|
|
* @param fourierPlotOpt Initial plot mode (real/imag/power/phase/etc.)
|
|
* @param fourierXrange X-axis range [min, max] in output units (G/T/MHz)
|
|
* @param phase Initial phase offset in degrees for Re/Im display
|
|
* @param wtopx X position of canvas window (pixels)
|
|
* @param wtopy Y position of canvas window (pixels)
|
|
* @param ww Canvas width (pixels)
|
|
* @param wh Canvas height (pixels)
|
|
* @param markerList ROOT marker styles (20-30) for each dataset
|
|
* @param colorList ROOT color indices for each dataset
|
|
* @param batch If true, run in batch mode (no GUI interaction)
|
|
*/
|
|
PFourierCanvas(std::vector<PFourier*> &fourier, PIntVector dataSetTag, const Char_t* title,
|
|
const Bool_t showAverage, const Bool_t showAveragePerDataSet,
|
|
const Int_t fourierPlotOpt, Double_t fourierXrange[2], Double_t phase,
|
|
Int_t wtopx, Int_t wtopy, Int_t ww, Int_t wh,
|
|
const PIntVector markerList, const PIntVector colorList, const Bool_t batch);
|
|
|
|
/**
|
|
* <p>Signal emitted when user closes canvas or timeout expires.
|
|
*
|
|
* <p>This signal notifies parent applications that the canvas
|
|
* is terminating. Used for cleanup and application flow control.
|
|
*
|
|
* @param status Exit status code (0 = normal, non-zero = error)
|
|
*/
|
|
virtual void Done(Int_t status=0); // *SIGNAL*
|
|
|
|
/**
|
|
* <p>Slot for handling keyboard events in the canvas.
|
|
*
|
|
* <p>Processes keyboard shortcuts:
|
|
* - '+': Increment phase by 5°
|
|
* - '-': Decrement phase by 5°
|
|
* - Other keys: Reserved for future use
|
|
*
|
|
* @param event ROOT event type identifier
|
|
* @param x Mouse x-coordinate at event time
|
|
* @param y Mouse y-coordinate at event time
|
|
* @param selected ROOT object under cursor (if any)
|
|
*/
|
|
virtual void HandleCmdKey(Int_t event, Int_t x, Int_t y, TObject *selected); // SLOT
|
|
|
|
/**
|
|
* <p>Slot for handling menu selection events.
|
|
*
|
|
* <p>Processes menu item selections:
|
|
* - View mode changes (Real/Imag/Power/Phase/etc.)
|
|
* - Averaging toggles (All/Per-dataset/Off)
|
|
* - Data export
|
|
* - Phase adjustments
|
|
*
|
|
* @param id Menu item identifier (P_MENU_ID_* constants)
|
|
*/
|
|
virtual void HandleMenuPopup(Int_t id); // SLOT
|
|
|
|
/**
|
|
* <p>Slot called when canvas window is closed by user.
|
|
*
|
|
* <p>Triggers cleanup and emits Done() signal. Part of ROOT's
|
|
* window management system.
|
|
*/
|
|
virtual void LastCanvasClosed(); // SLOT
|
|
|
|
/**
|
|
* <p>Redraws the Fourier spectrum pad with current settings.
|
|
*
|
|
* <p>Updates the main plotting area with current view mode,
|
|
* phase settings, and averaging options. Called automatically
|
|
* after parameter changes.
|
|
*/
|
|
virtual void UpdateFourierPad();
|
|
|
|
/**
|
|
* <p>Redraws the legend/info pad with current dataset information.
|
|
*
|
|
* <p>Updates the legend showing which datasets are displayed,
|
|
* with appropriate markers and colors.
|
|
*/
|
|
virtual void UpdateInfoPad();
|
|
|
|
/**
|
|
* <p>Checks if canvas initialized successfully.
|
|
*
|
|
* @return True if canvas is ready for display, false on initialization errors
|
|
*/
|
|
virtual Bool_t IsValid() { return fValid; }
|
|
|
|
/**
|
|
* <p>Sets automatic timeout for canvas closure.
|
|
*
|
|
* <p>Useful for batch processing or automated testing. Canvas
|
|
* emits Done() signal after timeout expires.
|
|
*
|
|
* @param ival Timeout in milliseconds (≤0 = no timeout)
|
|
*/
|
|
virtual void SetTimeout(Int_t ival);
|
|
|
|
/**
|
|
* <p>Saves canvas to graphics file and exits.
|
|
*
|
|
* <p>Exports current canvas view to image file (format determined
|
|
* by extension: .pdf, .png, .eps, .root, etc.) and closes canvas.
|
|
*
|
|
* @param fileName Output file path with extension
|
|
*/
|
|
virtual void SaveGraphicsAndQuit(const Char_t *fileName);
|
|
|
|
/**
|
|
* <p>Exports Fourier spectrum data to ASCII file.
|
|
*
|
|
* <p>Writes frequency/field values and corresponding spectrum
|
|
* amplitudes in columnar format for external analysis.
|
|
*
|
|
* @param pathFileName Output data file path (typically .dat extension)
|
|
*/
|
|
virtual void ExportData(const Char_t *pathFileName);
|
|
|
|
private:
|
|
Int_t fTimeout; ///< timeout after which the Done signal should be emited. If timeout <= 0, no timeout is taking place
|
|
Bool_t fBatchMode; ///< musrview in ROOT batch mode
|
|
Bool_t fValid; ///< if true, everything looks OK
|
|
Bool_t fAveragedView; ///< tag showing that the averaged view for ALL data or normal view should be presented.
|
|
Bool_t fAveragedViewPerDataSet; ///< tag showing that the averaged view for individual data sets or normal view should be presented.
|
|
PIntVector fDataSetTag; ///< vector holding the data set tags
|
|
Int_t fCurrentPlotView; ///< tag showing what the current plot view is: real, imag, power, phase, ...
|
|
Double_t fInitialXRange[2]; ///< keeps the initial x-range
|
|
Double_t fInitialYRange[2]; ///< keeps the initial y-range
|
|
|
|
TString fTitle;
|
|
TString fXaxisTitle;
|
|
std::vector<PFourier*> fFourier; ///< keeps all the Fourier data, ownership is with the caller
|
|
PFourierCanvasDataList fFourierHistos; ///< keeps all the Fourier histos
|
|
PFourierCanvasDataList fFourierAverage; ///< keeps the average of the Fourier histos
|
|
Double_t fCurrentFourierPhase; ///< keeps the current Fourier phase (real/imag)
|
|
std::unique_ptr<TLatex> fCurrentFourierPhaseText; ///< used in Re/Im Fourier to show the current phase in the pad
|
|
|
|
std::unique_ptr<TStyle> fStyle; ///< A collection of all graphics attributes
|
|
|
|
std::unique_ptr<TTimer> fTimeoutTimer; ///< timeout timer in order to terminate if no action is taking place for too long
|
|
|
|
PIntVector fMarkerList; ///< list of markers
|
|
PIntVector fColorList; ///< list of colors
|
|
|
|
// canvas menu related variables
|
|
TRootCanvas *fImp; ///< ROOT native GUI version of main window with menubar and drawing area
|
|
TGMenuBar *fBar; ///< menu bar
|
|
TGPopupMenu *fPopupMain; ///< popup menu MusrFT in the main menu bar
|
|
std::unique_ptr<TGPopupMenu> fPopupFourier; ///< popup menu of the MusrFT/Fourier sub menu
|
|
|
|
// canvas related variables
|
|
std::unique_ptr<TCanvas> fMainCanvas; ///< main canvas
|
|
std::unique_ptr<TPaveText> fTitlePad; ///< title pad used to display a title
|
|
std::unique_ptr<TPad> fFourierPad; ///< fourier pad used to display the fourier
|
|
std::unique_ptr<TLegend> fInfoPad; ///< info pad used to display a legend of the data plotted
|
|
std::unique_ptr<TLegend> fLegAvgPerDataSet; ///< legend used for averaged per data set view
|
|
|
|
/// Creates X-axis label based on unit type (Gauss/Tesla/MHz/Mc/s)
|
|
virtual void CreateXaxisTitle();
|
|
|
|
/// Initializes ROOT plotting style (colors, fonts, margins, etc.)
|
|
virtual void CreateStyle();
|
|
|
|
/// Generates all Fourier histograms (Re/Im/Pwr/Phase) from PFourier objects
|
|
virtual void InitFourierDataSets();
|
|
|
|
/// Creates ROOT canvas with menu bar, pads, and event connections
|
|
/// @param title Window title
|
|
/// @param wtopx Window x-position
|
|
/// @param wtopy Window y-position
|
|
/// @param ww Window width
|
|
/// @param wh Window height
|
|
virtual void InitFourierCanvas(const Char_t* title, Int_t wtopx, Int_t wtopy, Int_t ww, Int_t wh);
|
|
|
|
/// Deletes averaged histogram data to free memory
|
|
virtual void CleanupAverage();
|
|
|
|
/// Computes averaged Fourier spectra across runs or per dataset
|
|
virtual void HandleAverage();
|
|
|
|
/// Calculates phase-optimized real Fourier for all datasets
|
|
virtual void CalcPhaseOptReal();
|
|
|
|
/// Draws individual Fourier spectra (non-averaged view)
|
|
virtual void PlotFourier();
|
|
|
|
/// Displays current phase value as text overlay on canvas
|
|
virtual void PlotFourierPhaseValue();
|
|
|
|
/// Draws averaged Fourier spectra (averaged view modes)
|
|
virtual void PlotAverage();
|
|
|
|
/// Increases phase by 5° and redraws Re/Im spectra
|
|
virtual void IncrementFourierPhase();
|
|
|
|
/// Decreases phase by 5° and redraws Re/Im spectra
|
|
virtual void DecrementFourierPhase();
|
|
|
|
/// Finds maximum value in histogram within optional x-range
|
|
/// @param histo Input histogram
|
|
/// @param xmin Range minimum (-1.0 = use full range)
|
|
/// @param xmax Range maximum (-1.0 = use full range)
|
|
/// @return Maximum y-value in range
|
|
virtual Double_t GetMaximum(TH1F* histo, Double_t xmin=-1.0, Double_t xmax=-1.0);
|
|
|
|
/// Finds minimum value in histogram within optional x-range
|
|
/// @param histo Input histogram
|
|
/// @param xmin Range minimum (-1.0 = use full range)
|
|
/// @param xmax Range maximum (-1.0 = use full range)
|
|
/// @return Minimum y-value in range
|
|
virtual Double_t GetMinimum(TH1F* histo, Double_t xmin=-1.0, Double_t xmax=-1.0);
|
|
|
|
/// Linearly interpolates histogram value at arbitrary x-position
|
|
/// @param histo Input histogram
|
|
/// @param xVal X-coordinate for interpolation
|
|
/// @return Interpolated y-value
|
|
virtual Double_t GetInterpolatedValue(TH1F* histo, Double_t xVal);
|
|
|
|
/// Extracts dataset name from histogram title
|
|
/// @param title Full histogram title
|
|
/// @return Parsed dataset identifier
|
|
virtual TString GetDataSetName(TString title);
|
|
|
|
ClassDef(PFourierCanvas, 1)
|
|
};
|
|
|
|
#endif // _PFOURIERCANVAS_H_
|