PTempCalibGui.h

Go to the documentation of this file.

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

  PTempCalibGui.h

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

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

/***************************************************************************
 *   Copyright (C) 2010 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 _PTEMPCALIBGUI_H_
#define _PTEMPCALIBGUI_H_

#include <vector>
using namespace std;

#include <TROOT.h>
#include <RQ_OBJECT.h>
#include <TGWindow.h>
#include <TGCanvas.h>
#include <TGTab.h>
#include <TGFrame.h>
#include <TGTextEntry.h>
#include <TGButton.h>
#include <TGComboBox.h>
#include <TGNumberEntry.h>
#include <TGLabel.h>
#include <TDatime.h>
#include <TCanvas.h>
#include <TGraph.h>
#include <TGraphErrors.h>

#define TCG_WIDTH  425
#define TCG_HEIGHT 420

#define TCG_NO_OF_RAW_DATA_CH 10

//--------------------------------------------------------------------------

enum EPRawCh {eEmpty, eDateTime, eTempMeasured, ePressure, eHeaterOutput, eSetPointTemp, eHeaterRange,
              eBH1Flow, eChA, eChB, eChC, eChC1, eChC2, eChC3, eChC4, eChD1, eChD2, eChD3, eChD4, eChD5};

//--------------------------------------------------------------------------
class PRawData : public TQObject
{
  RQ_OBJECT("PRawData")

  public:
    PRawData();
    virtual ~PRawData();

    virtual void SetLakeShore(const std::string lakeShore) { fLakeShore = lakeShore; }
    virtual Bool_t IsDataPresent() { return fDataPresent; }
    virtual UInt_t GetNoOfEntries() { return fNoOfEntries; }
    virtual UInt_t GetNoOfRawDataReadings() { return fNoOfRawDataReadings; }
    virtual UInt_t GetRawDataReadingOffset() { return fRawDataReadingOffset; }
    virtual TString GetCtrlCh() { return fCtrlCh; }
    virtual TString GetRawDataCh(UInt_t idx);
    virtual Int_t MapChNo(UInt_t chNo);
    virtual UInt_t GetRawDataSensorType(UInt_t idx);
    virtual UInt_t GetSize() { return fDateTime.size(); }
    virtual UInt_t GetStartTime() { return fStartDateTime.Get(); }
    virtual UInt_t GetTime(UInt_t idx);
    virtual Double_t GetTempMeasured(UInt_t idx);
    virtual Double_t GetPressure(UInt_t idx);
    virtual Double_t GetHeaterOutput(UInt_t idx);
    virtual Double_t GetSetPointTemp(UInt_t idx);
    virtual Double_t GetHeaterRange(UInt_t idx);
    virtual Double_t GetBH1Flow(UInt_t idx);
    virtual Double_t GetRawData(UInt_t ch, UInt_t idx);

    virtual void SetDataPresent(Bool_t bval) { fDataPresent = bval; }
    virtual void SetNoOfEntries(UInt_t val) { fNoOfEntries = val; }
    virtual void SetNoOfRawDataReadings(UInt_t val) { fNoOfRawDataReadings = val; }
    virtual void SetRawDataReadingOffset(UInt_t val) { fRawDataReadingOffset = val; }
    virtual void SetCtrlCh(const TString &str);
    virtual void SetRawDataCh(const TString &str, UInt_t idx);
    virtual void SetRawDataSensorType(UInt_t type, UInt_t idx);
    virtual void SetStartDateTime(const char* dateTime) { fStartDateTime.Set(dateTime); }
    virtual void AddDateTime(TDatime *dt);
    virtual void AddTempMeasured(Double_t temp);
    virtual void AddPressure(Double_t pressure);
    virtual void AddHeaterOutput(Double_t heaterOutput);
    virtual void AddSetPointTemp(Double_t setPoint);
    virtual void AddHeaterRange(Double_t heaterRange);
    virtual void AddBH1Flow(Double_t bh1Flow);
    virtual void AddRawData(Double_t data, UInt_t ch);

  private:
    std::string fLakeShore;

    Bool_t fDataPresent;

    UInt_t fNoOfEntries;
    UInt_t fNoOfRawDataReadings;
    UInt_t fRawDataReadingOffset;
    TString fCtrlCh;
    TString fRawDataCh[TCG_NO_OF_RAW_DATA_CH];
    UInt_t fRawDataSensorType[TCG_NO_OF_RAW_DATA_CH];

    TDatime fStartDateTime;
    vector<TDatime*> fDateTime;
    vector<Double_t> fTempMeasured;
    vector<Double_t> fPressure;
    vector<Double_t> fHeaterOutput;
    vector<Double_t> fSetPointTemp;
    vector<Double_t> fHeaterRange;
    vector<Double_t> fBH1Flow;
    vector< vector<Double_t> > fRawData;

  ClassDef(PRawData, 1)
};

//--------------------------------------------------------------------------
class PDrawRawData : public TQObject
{
  RQ_OBJECT("PDrawRawData")

  public:
    PDrawRawData(UInt_t w, UInt_t h, PRawData &rawData, EPRawCh xIdx, EPRawCh yIdx, const std::string lakeShore);
    virtual ~PDrawRawData();

    virtual void Show();

  private:
    std::string fLakeShore;

    TCanvas *fCanvas;
    TGraph  *fGraph;

    virtual TString GetUnits(UInt_t idx);

  ClassDef(PDrawRawData, 1)
};

//--------------------------------------------------------------------------
class PDrawMeanRawData : public TQObject
{
  RQ_OBJECT("PDrawMeanRawData")

  public:
    PDrawMeanRawData(UInt_t w, UInt_t h,
                     vector<Double_t> &temp, vector<Double_t> &errTemp,
                     vector<Double_t> &data, vector<Double_t> &errData,
                     TString yLabel);

    virtual ~PDrawMeanRawData();

    virtual void Show();

  private:
    TCanvas      *fCanvas;
    TGraphErrors *fGraph;

  ClassDef(PDrawMeanRawData, 1)
};

//--------------------------------------------------------------------------
class PCalibData : public TQObject
{
  RQ_OBJECT("PCalibData")

  public:
    PCalibData();
    virtual ~PCalibData();

    virtual void Init();

    virtual Bool_t   IsValid() { return fValid; }
    virtual TString  GetSensorModel() { return fSensorModel; }
    virtual TString  GetSerialNo() { return fSerialNo; }
    virtual UInt_t   GetDataFormat() { return fDataFormat; }
    virtual Double_t GetSetPointLimit() { return fSetPointLimit; }
    virtual UInt_t   GetTempCoeff() { return fTempCoeff; }
    virtual UInt_t   GetNoOfPoints() { return fNoOfPoints; }
    virtual UInt_t   GetMeasuredSize() { return fMeasured.size(); }
    virtual Double_t GetMeasured(UInt_t idx);
    virtual UInt_t   GetTempSize() { return fTemp.size(); }
    virtual Double_t GetTemp(UInt_t idx);
    virtual Double_t GetTemp(Double_t sensorValue);

    virtual void SetValid(Bool_t valid) { fValid = valid; }
    virtual void SetSensorModel(TString &str) { fSensorModel = str; }
    virtual void SetSerialNo(TString &str) { fSerialNo = str; }
    virtual void SetDataFormat(UInt_t ival);
    virtual void SetSetPointLimit(Double_t dval) { fSetPointLimit = dval; }
    virtual void SetTempCoeff(UInt_t ival);
    virtual void SetNoOfPoints(UInt_t ival) { fNoOfPoints = ival; }
    virtual void AddMeasured(Double_t dval) { fMeasured.push_back(dval); }
    virtual void AddTemp(Double_t dval) { fTemp.push_back(dval); }

  private:
    Bool_t   fValid; // flag showing if the data are valid
    TString  fSensorModel;
    TString  fSerialNo;
    UInt_t   fDataFormat; // 1 = mV/K, 2 = V/K, 3 = Ohm/K, 4 = Log(Ohm)/K, 5 = Log(Ohm)/Log(K)
    Double_t fSetPointLimit;
    UInt_t   fTempCoeff; // 1 = negative, 2 = positive
    UInt_t   fNoOfPoints;

    vector<Double_t> fMeasured; // measured property, e.g. voltage for diodes
    vector<Double_t> fTemp;     // temperature corresponding to the measured property

  ClassDef(PCalibData, 1)
};

//--------------------------------------------------------------------------
class PDrawCalibData : public TQObject
{
  RQ_OBJECT("PDrawCalibData")

  public:
    PDrawCalibData(UInt_t w, UInt_t h, PCalibData &calibData);
    virtual ~PDrawCalibData();

    virtual void Show();

  private:
    TCanvas *fCanvas;
    TGraph  *fGraph;

  ClassDef(PDrawCalibData, 1)
};

//--------------------------------------------------------------------------
class PSensorInfo : public TGFrame
{
  RQ_OBJECT("PSensorInfo")

  public:
    PSensorInfo(TGGroupFrame *frame);
    virtual ~PSensorInfo();

    virtual Int_t GetCh() { return fCh->GetSelected(); }
    virtual Int_t GetSensorType() { return fType->GetSelected(); }
    virtual Int_t GetDataFormat();
    virtual TString GetSensorName() { return fName->GetDisplayText(); }
    virtual TString GetSerialNo() { return fSerialNo->GetDisplayText(); }

    // slot
    virtual void TypeChanged(Int_t);

  private:
    TGLabel     *fChLabel;
    TGComboBox  *fCh;
    TGLabel     *fTypeLabel;
    TGComboBox  *fType;
    TGLabel     *fDataFormatLabel;
    TGComboBox  *fDataFormat;
    TGLabel     *fNameLabel;
    TGTextEntry *fName;
    TGLabel     *fSerialNoLabel;
    TGTextEntry *fSerialNo;

  ClassDef(PSensorInfo, 1)
};

//--------------------------------------------------------------------------

class PTempCalibSensors : public TQObject
{
  RQ_OBJECT("PTempCalibSenors")

  public:
    PTempCalibSensors(const TGWindow *p, const std::string lakeShore);
    virtual ~PTempCalibSensors();

    virtual TGFrame *GetFrame() const { return fFrame; }
    virtual void SetCanvas(TGCanvas *canvas);

    virtual UInt_t GetNoOfSensors() { return fNoOfSensors; }
    virtual Int_t GetCh(UInt_t sensorIdx);
    virtual Int_t GetSensorType(UInt_t sensorIdx);
    virtual Int_t GetDataFormat(UInt_t sensorIdx);
    virtual TString GetSensorName(UInt_t sensorIdx);
    virtual TString GetSerialNo(UInt_t sensorIdx);

    // slots
    virtual void SetNoOfSensors(Long_t);

  private:
    std::string fLakeShore;

    TGCompositeFrame *fFrame;
    TGCanvas         *fCanvas;

    vector<TGGroupFrame*> fCalibSensorFrame;
    vector<PSensorInfo*>  fCalibSensorInfo;

    UInt_t fNoOfSensors;

  ClassDef(PTempCalibSensors, 1)
};

//--------------------------------------------------------------------------

class PTempCalibGui : public TQObject
{
  RQ_OBJECT("PTempCalibGui")

  public:
    PTempCalibGui(const TGWindow *p, UInt_t w, UInt_t h, const std::string lakeShore);
    virtual ~PTempCalibGui();

    // slots
    virtual void CloseWindow();
    virtual void DoBrowse();
    virtual void DoDrawRawData();
    virtual void DoCalibration();
    virtual void DoDrawWithErrors();
    virtual void DoDrawCalibData();
    virtual void DoTabSelected(Int_t id);

    virtual void NoOfThermoCalibChanged(Long_t); // *SIGNAL*

  private:
    std::string        fLakeShore;

    TGMainFrame        *fMain;
    TGHorizontalFrame  *fFrame;
    TGTab              *fTab;

    TGTextEntry        *fTab1FileName;
    TGTextButton       *fTab1BrowseButton;
    TGTextEntry        *fTab1StartTime;
    TGComboBox         *fTab1XComboBox;
    TGComboBox         *fTab1YComboBox;
    TGTextButton       *fTab1DrawButton;
    TGTextButton       *fTab1ExitButton;


    TGComboBox         *fTab2ChannelCalibThermoComboBox;
    TGTextEntry        *fTab2SerialNoCalibThermo;
    TGTextButton       *fTab2BrowseButton;
    TGNumberEntry      *fNoThermoForCalib;
    TGNumberEntry      *fDrawDataNo;
    TGCanvas           *fTempCalibSensorsCanvas;
    PTempCalibSensors  *fTempCalibSensorsContainer;
    TGTextButton       *fTab2CalibButton;
    TGTextButton       *fTab2DrawButton;
    TGTextButton       *fTab2ExitButton;

    TGTextEntry        *fTab3FileName;
    TGTextButton       *fTab3BrowseButton;
    TGTextButton       *fTab3DrawButton;
    TGTextButton       *fTab3ExitButton;

    PRawData   fRawData;
    PCalibData fCalibData;

    virtual void LoadRawData(const char *filename);
    virtual UInt_t UpdateHeaderInfo(vector<TString> &rawData, UInt_t idx);

    virtual void LoadCalibData(const char *filename);

  ClassDef(PTempCalibGui, 1)
};

#endif // _PTEMPCALIBGUI_H_