PMusrT0.h

Go to the documentation of this file.

/***************************************************************************
 
  PMusrT0.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 _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__
 
//--------------------------------------------------------------------------
// Detector tags
//--------------------------------------------------------------------------
#define PMUSRT0_FORWARD  0   
#define PMUSRT0_BACKWARD 1   
 
//--------------------------------------------------------------------------
// Command/mode tags
//--------------------------------------------------------------------------
#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_