PMusrWiz.h

Go to the documentation of this file.

/***************************************************************************
 
  PMusrWiz.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 _PMUSRWIZ_
#define _PMUSRWIZ_
 
#include <memory>
 
#include <QString>
#include <QStringList>
#include <QWizard>
#include <QWizardPage>
#include <QObject>
#include <QLineEdit>
#include <QComboBox>
#include <QCheckBox>
#include <QPlainTextEdit>
#include <QPushButton>
#include <QLabel>
#include <QFormLayout>
 
#include "musrWiz.h"
#include "PAdmin.h"
 
#define INST_UNDEF  0
#define INST_PSI    1
#define INST_TRIUMF 2
#define INST_ISIS   3
#define INST_JPARC  4
 
#define FIT_TYPE_UNDEF            0
#define FIT_TYPE_SINGLE_HISTO     1
#define FIT_TYPE_SINGLE_HISTO_RRF 2
#define FIT_TYPE_ASYMMETRY        3
#define FIT_TYPE_ASYMMETRY_RRF    4
#define FIT_TYPE_MU_MINUS         5
#define FIT_TYPE_NONE_MUSR        6
 
#define MEASURE_UNDEF 0
#define MEASURE_ZF    1
#define MEASURE_TF    2
#define MEASURE_LF    3
 
#define T0_FROM_FILE    0
#define T0_FROM_MUSR_T0 1
#define T0_ENTER_WIZ    2
 
//-------------------------------------------------------------------
struct PParamGui {
  QLineEdit *paramName;
  QLineEdit *paramVal;
  QLineEdit *paramStep;
  QLineEdit *paramBoundLow;
  QLineEdit *paramBoundHigh;
};
 
//-------------------------------------------------------------------
class PMsrData
{
  public:
    PMsrData();
    ~PMsrData();
 
    void clearParam() { fParam.clear(); }
    void clearFunc() { fFunc.clear(); }
    void clearMap() { fMap.clear(); }
 
    void setMsrPathName(QString str) { fMsrPathName = str; }
    void setMsrFileName(QString fileName) { fMsrFileName = fileName; }
    void appendMsrFileName(QString str) { fMsrFileName += str; }
    void setYear(QString year) { fYear = year; }
    void setRunNumber(int runNo) { fRunNumber = runNo; }
    void setInstitute(QString institute) { fInstitute = institute; }
    void setInstrument(QString instrument) { fInstrument = instrument; }
    void setSetup(QString setup) { fSetup = setup; }
    void setFitType(int fitType) { fFitType = fitType; }
    void setTypeOfMeasurement(int type) { fTypeOfMeasurement = type; }
    void setT0Tag(int tag) { fT0Tag = tag; }
    void setT0(int t0) { fT0 = t0; }
    void setTheory(QString str) { fTheo = str; }
    void setParam(QVector<PParam> param) { fParam = param; }
    void setParam(int idx, PParam param);
    void appendParam(QVector<PParam> param);
    void setMap(QVector<PParam> map) { fMap = map; }
    void setMap(int idx, PParam map);
    void appendMap(QVector<PParam> map);
    void setMapTemplateName(int idx, QString name);
    void setFunc(int funNo, QString str="??");
    void setPacking(int pack) { fPacking = abs(pack); }
    void setFitStart(double start) { fFitStart = start; }
    void setFitEnd(double end) { fFitEnd = end; }
    void setCmd(QString cmd) { fCommands = cmd; }
    void setTemplate(int templ) { fTemplate = templ; }
    void setTemplate(PTheoTemplate templ) { fTheoTempl = templ; }
 
    QString getMsrPathName() { return fMsrPathName; }
    QString getMsrFileName() { return fMsrFileName; }
    QString getYear() { return fYear; }
    int getRunNumber() { return fRunNumber; }
    QString getInstitute() { return fInstitute; }
    QString getInstrument() { return fInstrument; }
    QString getSetup() { return fSetup; }
    int getFitType() { return fFitType; }
    QString getFitTypeString();
    int getTypeOfMeasurement() { return fTypeOfMeasurement; }
    int getT0Tag() { return fT0Tag; }
    int getT0() { return fT0; }
    QString getTheory() { return fTheo; }
    int getNoOfParam() { return fParam.size(); }
    PParam getParam(int idx);
    int getNoOfMap() { return fMap.size(); }
    PParam getMap(int idx);
    int getNoOfFunc() { return fFunc.size(); }
    int getFuncNo(int idx);
    bool isPresent(const QString funStr);
    QString getFunc(int funNo);
    QString getFuncAll();
    int getPacking() { return fPacking; }
    double getFitStart() { return fFitStart; }
    double getFitEnd() { return fFitEnd; }
    QString getCmd() { return fCommands; }
    bool isTemplate() { return (fTemplate == -1) ? false : true; }
    PTheoTemplate getTemplate() { return fTheoTempl; }
 
    void sort(QString whichVec);
    void removeFunc(QVector<int> &funList);
 
  private:
    int fTemplate;
    QString fMsrPathName;
    QString fMsrFileName;
    int fRunNumber;
    QString fInstitute;
    QString fInstrument;
    QString fSetup;
    int fFitType;
    int fTypeOfMeasurement;
    int fT0Tag;
    int fT0;
    QString fYear;
    int fPacking;
    double fFitStart;
    double fFitEnd;
    QString fCommands;
 
    QString fTheo;
 
    PTheoTemplate   fTheoTempl;
    QVector<PParam> fParam;
    QVector<PFunc>  fFunc;
    QVector<PParam> fMap;
};
 
//-------------------------------------------------------------------
class PShowTheo : public QDialog
{
  public:
    PShowTheo(QString theo, QString func = QString(""),
              QWidget *parent = Q_NULLPTR, Qt::WindowFlags f = Qt::WindowFlags());
};
 
//-------------------------------------------------------------------
class PIntroPage : public QWizardPage
{
  Q_OBJECT
 
  public:
    PIntroPage(PAdmin *admin, PMsrData *data, QWidget *parent=0);
 
    int nextId() const Q_DECL_OVERRIDE;
    bool validatePage() override;
 
  private slots:
    void handleInstituteChanged(int idx);
    void handleFitType(int idx);
    void checkSetup(int idx);
    void handleT0(int idx);
 
  private:
    PAdmin *fAdmin;
    PMsrData *fMsrData;
 
    std::unique_ptr<QLineEdit> fMsrFileName;
    std::unique_ptr<QLineEdit> fYear;
    std::unique_ptr<QLineEdit> fRunNumber;
    std::unique_ptr<QComboBox> fInstitute;
    std::unique_ptr<QComboBox> fInstrument;
    std::unique_ptr<QComboBox> fFitType;
    std::unique_ptr<QComboBox> fMeasurementType;
    std::unique_ptr<QComboBox> fT0;
};
 
//-------------------------------------------------------------------
class PTheoPage : public QWizardPage
{
  Q_OBJECT
 
  public:
    PTheoPage(PAdmin *admin, PMsrData *data, QWidget *parent=0);
 
    int nextId() const Q_DECL_OVERRIDE;
    void initializePage() override;
    bool validatePage() override;
 
  private slots:
    void templateState(int);
    void clearAll();
    void addTheory();
    void checkTheory();
 
  private:
    PAdmin *fAdmin;
    PMsrData *fMsrData;
 
    bool fTheoValid;
    bool fHaveMap;
    bool fHaveFunc;
 
    int fTheoBlockNo;
 
    QVector<PParam> fParamList;
    QVector<PParam> fMapList;
    QVector<int> fFunList;
 
    std::unique_ptr<QPlainTextEdit> fTheo;
    std::unique_ptr<QCheckBox> fEditTemplate;
    std::unique_ptr<QPushButton> fClearAll;
    std::unique_ptr<QComboBox> fTheoSelect;
    std::unique_ptr<QPushButton> fTheoAdd;
    std::unique_ptr<QPushButton> fCheckTheo;
 
    QString getTheoryFunction(int idx);
    bool analyzeTokens(QString str, int noOfTokens);
    void dealWithParam(QString theo, int paramNo, int paramIdx);
    void dealWithMap(QString theo, int mapNo, int paramIdx);
    void dealWithFun(int funNo);
};
 
//-------------------------------------------------------------------
class PFuncPage : public QWizardPage
{
  Q_OBJECT
 
  public:
    PFuncPage(PMsrData *data, QWidget *parent=0);
 
    int nextId() const Q_DECL_OVERRIDE;
    void initializePage() override;
    void cleanupPage() override;
    bool validatePage() override;
 
  private slots:
    void showTheo();
 
  private:
    PMsrData *fMsrData;
 
    std::unique_ptr<QPlainTextEdit> fFunc;
    std::unique_ptr<QPushButton> fShowTheo;
 
    int getFuncNo(const QString str);
};
 
//-------------------------------------------------------------------
class PMapPage : public QWizardPage
{
  Q_OBJECT
 
  public:
    PMapPage(PMsrData *data, QWidget *parent=0);
 
    int nextId() const Q_DECL_OVERRIDE;
    void initializePage() override;
    bool validatePage() override;
 
  private slots:
    void showTheo();
 
  private:
    PMsrData *fMsrData;
 
    std::unique_ptr<QFormLayout> fMapPageLayout;
    QVector<PParamGui> fMapGuiVec;
    std::unique_ptr<QPushButton> fShowTheo;
};
 
//-------------------------------------------------------------------
class PParamPage : public QWizardPage
{
  Q_OBJECT
 
  public:
    PParamPage(PMsrData *data, QWidget *parent=0);
 
    int nextId() const Q_DECL_OVERRIDE;
    void initializePage() override;
    bool validatePage() override;
 
  private slots:
    void showTheo();
 
  private:
    PMsrData *fMsrData;
 
    std::unique_ptr<QFormLayout> fParameterPageLayout;
    QVector<PParamGui> fParamGuiVec;
    std::unique_ptr<QPushButton> fShowTheo;
};
 
//-------------------------------------------------------------------
class PFitInfoPage : public QWizardPage
{
  Q_OBJECT
 
  public:
    PFitInfoPage(PMsrData *data, QWidget *parent=0);
 
    int nextId() const Q_DECL_OVERRIDE;
    void initializePage() override;
    bool validatePage() override;
 
  private:
    PMsrData *fMsrData;
 
    std::unique_ptr<QLineEdit> fFitRangeStart;
    std::unique_ptr<QLineEdit> fFitRangeEnd;
    std::unique_ptr<QLineEdit> fPacking;
    std::unique_ptr<QPlainTextEdit> fCommands;
};
 
//-------------------------------------------------------------------
class PConclusionPage : public QWizardPage
{
  Q_OBJECT
 
  public:
    PConclusionPage(PAdmin *admin, PMsrData *data, QString *msrFilePath, QWidget *parent=0);
 
  private slots:
    void saveAsMsrFile();
    void saveAsTemplate();
 
  private:
    QString *fMsrFilePath;
    PAdmin *fAdmin;
    PMsrData *fMsrData;
 
    std::unique_ptr<QLabel> fMsrPathFileLabel;
    std::unique_ptr<QLineEdit> fMsrFilePathLineEdit;
    std::unique_ptr<QPushButton> fSaveAsMsrFile;
    std::unique_ptr<QPushButton> fSaveAsTemplate;
};
 
//-------------------------------------------------------------------
class PMusrWiz : public QWizard
{
  Q_OBJECT
 
  friend class PIntroPage;
  friend class PTheoPage;
  friend class PMapPage;
  friend class PFuncPage;
  friend class PParamPage;
  friend class PFitInfoPage;
 
  public:
    PMusrWiz(QWidget *parent=Q_NULLPTR);
    PMusrWiz(PAdmin *admin, PMsrData *msrData, QWidget *parent=Q_NULLPTR);
 
  private slots:
    virtual int writeMsrFile(int result);
    virtual void help();
 
  protected:
    enum {ePageIntro, ePageTheory, ePageMaps, ePageFunctions, ePageParameters, ePageFitInfo, ePageConclusion};
 
  private:
    QString fMsrFilePath;
    PAdmin *fAdmin;
    PMsrData *fMsrData;
 
    QString getRunName(PInstrument *instru);
 
    virtual int writeMsrFileSingleHisto();
    virtual int writeMsrFileAsymmetry();
};
 
#endif //  _PMUSRWIZ_