qavrgfitter.h

Go to the documentation of this file.

#ifndef QAVRGFITTER_H
#define QAVRGFITTER_H

#include <QObject>
#include <QMutex>
#include <QVector>
#include "qcepproperty.h"

class QavrgAcquisition;

class QavrgFitter : public QObject
{
  Q_OBJECT;

public:
  QavrgFitter(QavrgAcquisition *acq, int chan);
  ~QavrgFitter();

public slots:
  void performCalculation();

  QVector<double> readResult(int parm, int start, int nbins);
  QVector<double> readResult(int parm);
  double readResult(int parm, int bin);
  double readResultAverage(int parm, int start, int nbins);
  double readResultBunchAverage(int parm, int bunch, int norbits);

  QVector<double> get_RawData(int start, int nbins);
  QVector<double> get_RawData();
  double get_RawData(int bin);

  QVector<double> get_ReferenceData(int start, int nbins);
  QVector<double> get_ReferenceData();
  double get_ReferenceData(int bin);

  QVector<double> get_DarkData(int start, int nbins);
  QVector<double> get_DarkData();
  double get_DarkData(int bin);

  QVector<double> get_FitData(int start, int nbins);
  QVector<double> get_FitData();
  double get_FitData(int bin);

public:
  void resize(int nsamples);

  void setReferenceData();
  void saveReferenceData();
  void loadReferenceData();

  void setDarkData();
  void saveDarkData();
  void loadDarkData();

  QMutex *mutex();
  double *rawDataPtr();
  double *referenceDataPtr();
  double *darkDataPtr();

  int resultSize();

//  QList<double> calculateFittedValues(double startpos, double endpos);
//  QList<double> calculateBackground(double startpos, double edgepos);

  void prepareCalculation();
  void readSettings(QSettings *settings);
  void writeSettings(QSettings *settings);

  double inputFullScale(int index) const;
  double get_InputFullScale() const;
  void set_InputFullScale(double val);

  enum {
    Background,
    Slope,
    PeakHeight
  };

private:
  QString referenceDataPath();
  QString darkDataPath();

private:
  /*mutable*/ QMutex      m_Mutex;
  QavrgAcquisition   *m_Acquisition;
  int                 m_Channel;

  int                 m_NSamples;
  QVector<double>     m_RawData;
  QVector<double>     m_DarkData;
  QVector<double>     m_ReferenceData;
  QVector<double>     m_FitData;

  QVector< QVector<double> >     m_Results;
  int                 m_ResultSize;

public:
  Q_PROPERTY(double inputFullScale READ get_InputFullScale WRITE set_InputFullScale STORED false);
  Q_PROPERTY(int inputGain READ get_InputGain WRITE set_InputGain);
  QCEP_INTEGER_PROPERTY(InputGain);
  Q_PROPERTY(double inputOffset READ get_InputOffset WRITE set_InputOffset);
  QCEP_DOUBLE_PROPERTY(InputOffset);
  Q_PROPERTY(int inputBandwidth READ get_InputBandwidth WRITE set_InputBandwidth);
  QCEP_INTEGER_PROPERTY(InputBandwidth);
  Q_PROPERTY(int inputCoupling READ get_InputCoupling WRITE set_InputCoupling);
  QCEP_INTEGER_PROPERTY(InputCoupling);

  Q_PROPERTY(double fittingOffset READ get_FittingOffset WRITE set_FittingOffset);
  QCEP_DOUBLE_PROPERTY(FittingOffset);
  Q_PROPERTY(int fittingStart READ get_FittingStart WRITE set_FittingStart);
  QCEP_INTEGER_PROPERTY(FittingStart);
  Q_PROPERTY(int fittingEnd   READ get_FittingEnd   WRITE set_FittingEnd);
  QCEP_INTEGER_PROPERTY(FittingEnd);

  Q_PROPERTY(bool displayData   READ get_DisplayData   WRITE set_DisplayData);
  QCEP_BOOLEAN_PROPERTY(DisplayData);
  Q_PROPERTY(bool displayRaw    READ get_DisplayRaw    WRITE set_DisplayRaw);
  QCEP_BOOLEAN_PROPERTY(DisplayRaw);
  Q_PROPERTY(bool displayReference   READ get_DisplayReference   WRITE set_DisplayReference);
  QCEP_BOOLEAN_PROPERTY(DisplayReference);
  Q_PROPERTY(bool displayDark   READ get_DisplayDark   WRITE set_DisplayDark);
  QCEP_BOOLEAN_PROPERTY(DisplayDark);
  Q_PROPERTY(bool displayFit   READ get_DisplayFit   WRITE set_DisplayFit);
  QCEP_BOOLEAN_PROPERTY(DisplayFit);

  Q_PROPERTY(bool darkAvailable READ get_DarkAvailable WRITE set_DarkAvailable STORED false);
  QCEP_BOOLEAN_PROPERTY(DarkAvailable);
  Q_PROPERTY(bool referenceAvailable READ get_ReferenceAvailable WRITE set_ReferenceAvailable STORED false);
  QCEP_BOOLEAN_PROPERTY(ReferenceAvailable);
//  Q_PROPERTY(bool darkChanged READ get_DarkChanged WRITE set_DarkChanged STORED false);
//  QCEP_BOOLEAN_PROPERTY(DarkChanged);
//  Q_PROPERTY(bool referenceChanged READ get_ReferenceChanged WRITE set_ReferenceChanged STORED false);
//  QCEP_BOOLEAN_PROPERTY(ReferenceChanged);
};

#endif