PMusrT0.h

Go to the documentation of this file.

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

  PMusrT0.h

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

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

/***************************************************************************
 *   Copyright (C) 2007-2023 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 _PMUSRT0_H_
#define _PMUSRT0_H_

#include <memory>

#include <TObject.h>
#include <TQObject.h>
#include <TStyle.h>
#include <TRootCanvas.h>
#include <TGMenu.h>
#include <TCanvas.h>
#include <TH1.h>
#include <TLine.h>
#include <TLatex.h>
#include <TTimer.h>

#include "PMusr.h"
#ifndef __MAKECLING__
#include "PMsrHandler.h"
#endif // __MAKECLING__

#define PMUSRT0_FORWARD  0
#define PMUSRT0_BACKWARD 1

#define PMUSRT0_GET_T0                    0
#define PMUSRT0_GET_DATA_AND_BKG_RANGE    1
#define PMUSRT0_GET_T0_DATA_AND_BKG_RANGE 2


//--------------------------------------------------------------------------
class PMusrT0Data {
  public:
    PMusrT0Data();
    virtual ~PMusrT0Data();


    virtual void InitData();

    virtual Bool_t IsSingleHisto() { return fSingleHisto; }
    virtual UInt_t GetRawRunDataSize() { return fRawRunData.size(); }
    virtual PRawRunData* GetRawRunData(Int_t idx);
    virtual Int_t GetRunNo() { return fRunNo; }
    virtual Int_t GetAddRunIdx() { return fAddRunIdx; }
    virtual Int_t GetHistoNoIdx() { return fHistoNoIdx; }
    virtual UInt_t GetHistoNoSize() { return fHistoNo.size(); }
    virtual Int_t GetHistoNo(UInt_t idx);
    virtual Int_t GetDetectorTag() { return fDetectorTag; }
    virtual Int_t GetCmdTag() { return fCmdTag; }
    virtual UInt_t GetT0BinSize() { return fT0.size(); }
    virtual Int_t GetT0Bin(UInt_t idx);
    virtual UInt_t GetAddT0Entries() { return fAddT0.size(); }
    virtual UInt_t GetAddT0BinSize(UInt_t idx);
    virtual Int_t GetAddT0Bin(UInt_t addRunIdx, UInt_t idx);
    virtual Int_t GetT0BinData() { return fT0Data; }

    virtual void SetSingleHisto(const Bool_t flag) { fSingleHisto = flag; }
    virtual void SetRawRunData(const std::vector<PRawRunData*> rawRunData) { fRawRunData = rawRunData; }
    virtual void SetRunNo(const UInt_t runNo) { fRunNo = runNo; }
    virtual void SetAddRunIdx(const UInt_t addRunIdx) { fAddRunIdx = addRunIdx; }
    virtual void SetHistoNoIdx(const UInt_t histoNoIdx) { fHistoNoIdx = histoNoIdx; }
    virtual void SetHistoNo(const PIntVector histoNo) { fHistoNo = histoNo; }
    virtual void SetDetectorTag(const UInt_t detectorTag) { fDetectorTag = detectorTag; }
    virtual void SetCmdTag(const UInt_t cmdTag) { fCmdTag = cmdTag; }
    virtual void SetT0Bin(UInt_t val, UInt_t idx);
    virtual void SetAddT0Bin(UInt_t val, UInt_t addRunIdx, UInt_t idx);
    virtual void SetT0BinData(UInt_t val) { fT0Data = val; }

  private:
    Bool_t fSingleHisto;              
    std::vector<PRawRunData*> fRawRunData; 
    Int_t fRunNo;                     
    Int_t fAddRunIdx;                 
    Int_t fHistoNoIdx;                
    PIntVector fHistoNo;              
    Int_t fDetectorTag;               
    Int_t fCmdTag;                    
    PIntVector fT0;                   
    std::vector<PIntVector> fAddT0;   
    Int_t fT0Data;                    
};


//--------------------------------------------------------------------------
class PMusrT0 : public TObject, public TQObject
{
  public:
    PMusrT0();
    PMusrT0(PMusrT0Data &data);

    virtual Bool_t IsValid() { return fValid; }

    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 Quit(); // SLOT
    virtual void SetTimeout(Int_t timeout);

#ifndef __MAKECLING__
    virtual void SetMsrHandler(PMsrHandler *msrHandler);
#endif // __MAKECLING__

    virtual void InitT0();
    virtual void InitDataAndBkg();
    virtual Int_t GetStatus() { return fStatus; }

  private:
#ifndef __MAKECLING__
    PMsrHandler *fMsrHandler; 
#endif // __MAKECLING__
    Int_t  fTimeout;          

    Bool_t fValid; 

    Int_t fStatus; 

    PMusrT0Data fMusrT0Data; 

    Bool_t fDataAndBkgEnabled; 
    Bool_t fT0Enabled; 
    Int_t  fT0Estimated; 
    Bool_t fShowT0DataChannel;

    std::unique_ptr<TTimer> fTimeoutTimer; 

    // canvas related variables
    std::unique_ptr<TCanvas> fMainCanvas; 

    std::unique_ptr<TH1F> fHisto; 
    std::unique_ptr<TH1F> fData;  
    std::unique_ptr<TH1F> fBkg;   

    std::unique_ptr<TLatex> fToDoInfo; 

    std::unique_ptr<TLine> fT0Line; 
    std::unique_ptr<TLine> fT0DataLine; 
    std::unique_ptr<TLine> fFirstBkgLine; 
    std::unique_ptr<TLine> fLastBkgLine; 
    std::unique_ptr<TLine> fFirstDataLine; 
    std::unique_ptr<TLine> fLastDataLine; 

    Int_t fPx; 
    Int_t fPy; 

    Int_t fDataRange[2]; 
    Int_t fBkgRange[2]; 

    void ShowDataFileT0Channel();
    void HideDataFileT0Channel();
    void SetT0Channel();
    void SetEstimatedT0Channel();
    void SetDataFirstChannel();
    void SetDataLastChannel();
    void SetBkgFirstChannel();
    void SetBkgLastChannel();
    void UnZoom();
    void ZoomT0();

  ClassDef(PMusrT0, 1)
};

#endif // _PMUSRT0_H_