PMusr.h

Go to the documentation of this file.

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

  PMusr.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 _PMUSR_H_
#define _PMUSR_H_

#include <vector>
#include <map>

#include <TString.h>

// the following ifdef is needed for GCC 4.6 or higher, fftw 3.3 or higher and root 5.30.03 or lower
//#ifdef __CINT__
//typedef struct { char a[7]; } __float128; // needed since cint doesn't know it
//#endif
#include "fftw3.h"

#define PMUSR_SUCCESS                    0
#define PMUSR_SYNTAX_REQUEST            -1
#define PMUSR_WRONG_STARTUP_SYNTAX      -2
#define PMUSR_MSR_FILE_NOT_FOUND        -3
#define PMUSR_MSR_ALLOCATION_ERROR      -4
#define PMUSR_MSR_SYNTAX_ERROR          -5
#define PMUSR_TOKENIZE_ERROR            -6
#define PMUSR_MSR_LOG_FILE_WRITE_ERROR  -7
#define PMUSR_MSR_FILE_WRITE_ERROR      -8
#define PMUSR_DATA_FILE_READ_ERROR      -9
#define PMUSR_MSR_RUN_ERROR            -10

#define PRUN_SINGLE_HISTO     0
#define PRUN_SINGLE_HISTO_RRF 1
#define PRUN_ASYMMETRY        2
#define PRUN_ASYMMETRY_RRF    3
#define PRUN_MU_MINUS         4
#define PRUN_ASYMMETRY_BNMR   5
#define PRUN_NON_MUSR         8

// muon lifetime in (us) - see e.g.:
// P. A. Zyla et al. (Particle Data Group), Prog. Theor. Exp. Phys. 2020, 083C01 (2020).
// https://doi.org/10.1093/ptep/ptaa104
// https://pdg.lbl.gov/2021/
#define PMUON_LIFETIME 2.1969811

// muon gyromagnetic ratio: gamma_mu = 2.0 * mu_mu / hbar - see e.g.:
// E. Tiesinga et al., Rev. Mod. Phys. 93, 025010 (2021).
// https://doi.org/10.1103/RevModPhys.93.025010
// https://physics.nist.gov/cuu/Constants/index.html
// mu_mu = -4.490 448 30(10) * 1e-26 J/T
// hbar  =  1.054 571 817... * 1e-34 J*s
// gamma_muon / (2 pi) = 135.538 809 4(30)      MHz/T
//                     =   0.013 553 880 94(30) MHz/G
#define GAMMA_BAR_MUON 1.355388094e-2

// accelerator cycles in (us), needed to determine proper background
#define ACCEL_PERIOD_PSI     0.01975
#define ACCEL_PERIOD_TRIUMF  0.04337
#define ACCEL_PERIOD_RAL     0.0

// used to filter post pileup correct data histos from root files
#define POST_PILEUP_HISTO_OFFSET 20

// defines a value for 'undefined values'
#define PMUSR_UNDEFINED -9.9e99

//-------------------------------------------------------------
// msr block header tags
#define MSR_TAG_TITLE        0
#define MSR_TAG_FITPARAMETER 1
#define MSR_TAG_THEORY       2
#define MSR_TAG_FUNCTIONS    3
#define MSR_TAG_GLOBAL       4
#define MSR_TAG_RUN          5
#define MSR_TAG_COMMANDS     6
#define MSR_TAG_FOURIER      7
#define MSR_TAG_PLOT         8
#define MSR_TAG_STATISTIC    9

//-------------------------------------------------------------
// msr fit type tags
#define MSR_FITTYPE_SINGLE_HISTO     0
#define MSR_FITTYPE_SINGLE_HISTO_RRF 1
#define MSR_FITTYPE_ASYM             2
#define MSR_FITTYPE_ASYM_RRF         3
#define MSR_FITTYPE_MU_MINUS         4
#define MSR_FITTYPE_BNMR             5
#define MSR_FITTYPE_NON_MUSR         8

//-------------------------------------------------------------
// msr plot type tags
#define MSR_PLOT_SINGLE_HISTO     0
#define MSR_PLOT_SINGLE_HISTO_RRF 1
#define MSR_PLOT_ASYM             2
#define MSR_PLOT_ASYM_RRF         3
#define MSR_PLOT_MU_MINUS         4
#define MSR_PLOT_BNMR             5
#define MSR_PLOT_NON_MUSR         8

//-------------------------------------------------------------
// map and fun offsets for parameter parsing
#define MSR_PARAM_MAP_OFFSET 10000
#define MSR_PARAM_FUN_OFFSET 20000

//-------------------------------------------------------------
// fourier related tags
#define FOURIER_UNIT_NOT_GIVEN 0
#define FOURIER_UNIT_GAUSS     1
#define FOURIER_UNIT_TESLA     2
#define FOURIER_UNIT_FREQ      3
#define FOURIER_UNIT_CYCLES    4

#define FOURIER_APOD_NOT_GIVEN 0
#define FOURIER_APOD_NONE      1
#define FOURIER_APOD_WEAK      2
#define FOURIER_APOD_MEDIUM    3
#define FOURIER_APOD_STRONG    4

#define FOURIER_PLOT_NOT_GIVEN      0
#define FOURIER_PLOT_REAL           1
#define FOURIER_PLOT_IMAG           2
#define FOURIER_PLOT_REAL_AND_IMAG  3
#define FOURIER_PLOT_POWER          4
#define FOURIER_PLOT_PHASE          5
#define FOURIER_PLOT_PHASE_OPT_REAL 6

//-------------------------------------------------------------
// RRF related tags
#define RRF_UNIT_UNDEF -1
#define RRF_UNIT_kHz    0
#define RRF_UNIT_MHz    1
#define RRF_UNIT_Mcs    2
#define RRF_UNIT_G      3
#define RRF_UNIT_T      4

#define RRF_FREQ_UNDEF  1.0e10

//-------------------------------------------------------------
typedef std::vector<Bool_t> PBoolVector;

//-------------------------------------------------------------
typedef std::vector<UInt_t> PUIntVector;

//-------------------------------------------------------------
typedef std::vector<Int_t> PIntVector;

//-------------------------------------------------------------
typedef std::pair<Int_t, Int_t> PIntPair;

//-------------------------------------------------------------
typedef std::vector<PIntPair> PIntPairVector;

//-------------------------------------------------------------
typedef std::vector<Double_t> PDoubleVector;

//-------------------------------------------------------------
typedef std::pair<Double_t, Double_t> PDoublePair;

//-------------------------------------------------------------
typedef std::vector<PDoublePair> PDoublePairVector;

//-------------------------------------------------------------
typedef std::vector<TString> PStringVector;

//-------------------------------------------------------------
enum EPMusrHandleTag { kEmpty, kFit, kView };

//-------------------------------------------------------------
struct PMetaData {
  Double_t fField;  
  Double_t fEnergy; 
  PDoubleVector fTemp; 
};

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

    virtual Double_t GetDataTimeStart() { return fDataTimeStart; }
    virtual Double_t GetDataTimeStep() { return fDataTimeStep; }
    virtual Double_t GetTheoryTimeStart() { return fTheoryTimeStart; }
    virtual Double_t GetTheoryTimeStep() { return fTheoryTimeStep; }

    virtual const PDoubleVector* GetX() { return &fX; }
    virtual const PDoubleVector* GetValue() { return &fValue; }
    virtual const PDoubleVector* GetError() { return &fError; }
    virtual const PDoubleVector* GetXTheory() { return &fXTheory; }
    virtual const PDoubleVector* GetTheory() { return &fTheory; }

    virtual void SetDataTimeStart(Double_t dval) { fDataTimeStart = dval; }
    virtual void SetDataTimeStep(Double_t dval) { fDataTimeStep = dval; }
    virtual void SetTheoryTimeStart(Double_t dval) { fTheoryTimeStart = dval; }
    virtual void SetTheoryTimeStep(Double_t dval) { fTheoryTimeStep = dval; }

    virtual void AppendXValue(Double_t dval) { fX.push_back(dval); }
    virtual void AppendValue(Double_t dval) { fValue.push_back(dval); }
    virtual void AppendErrorValue(Double_t dval) { fError.push_back(dval); }
    virtual void AppendXTheoryValue(Double_t dval) { fXTheory.push_back(dval); }
    virtual void AppendTheoryValue(Double_t dval) { fTheory.push_back(dval); }

    virtual void SetTheoryValue(UInt_t i, Double_t dval);
    virtual void ReplaceTheory(const PDoubleVector &theo);

  private:
    // data related info
    Double_t fDataTimeStart; 
    Double_t fDataTimeStep;  
    PDoubleVector fX;        
    PDoubleVector fValue;    
    PDoubleVector fError;    
    // theory related info
    Double_t fTheoryTimeStart; 
    Double_t fTheoryTimeStep;  
    PDoubleVector fXTheory;    
    PDoubleVector fTheory;     
  };

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

    virtual Bool_t FromAscii() { return fFromAscii; }
    virtual const PStringVector* GetLabels() { return &fLabels; }
    virtual const PStringVector* GetDataTags() { return &fDataTags; }
    virtual const std::vector<PDoubleVector>* GetData() { return &fData; }
    virtual const std::vector<PDoubleVector>* GetErrData() { return &fErrData; }

    virtual void SetFromAscii(const Bool_t bval) { fFromAscii = bval; }
    virtual void SetSize(const UInt_t size);
    virtual void AppendLabel(const TString str) { fLabels.push_back(str); }
    virtual void SetLabel(const UInt_t idx, const TString str);
    virtual void AppendDataTag(const TString str) { fDataTags.push_back(str); }
    virtual void AppendData(const PDoubleVector &data) { fData.push_back(data); }
    virtual void AppendErrData(const PDoubleVector &data) { fErrData.push_back(data); }
    virtual void AppendSubData(const UInt_t idx, const Double_t dval);
    virtual void AppendSubErrData(const UInt_t idx, const Double_t dval);

  private:
    Bool_t fFromAscii;              
    PStringVector fLabels;          
    PStringVector fDataTags;        
    std::vector<PDoubleVector> fData;    
    std::vector<PDoubleVector> fErrData; 
};

//-------------------------------------------------------------
class PRawRunDataSet {
  public:
    PRawRunDataSet();
    virtual ~PRawRunDataSet() { fData.clear(); }

    virtual TString GetName() { return fName; }
    virtual Int_t GetHistoNo() { return fHistoNo; }
    virtual Double_t GetTimeZeroBin() { return fTimeZeroBin; }
    virtual Double_t GetTimeZeroBinEstimated() { return fTimeZeroBinEstimated; }
    virtual Int_t GetFirstGoodBin() { return fFirstGoodBin; }
    virtual Int_t GetLastGoodBin() { return fLastGoodBin; }
    virtual Int_t GetFirstBkgBin() { return fFirstBkgBin; }
    virtual Int_t GetLastBkgBin() { return fLastBkgBin; }
    virtual PDoubleVector *GetData() { return &fData; }

    virtual void Clear();
    virtual void SetName(TString str) { fName = str; }
    virtual void SetHistoNo(Int_t no) { fHistoNo = no; }
    virtual void SetTimeZeroBin(Double_t tzb) { fTimeZeroBin = tzb; }
    virtual void SetTimeZeroBinEstimated(Double_t tzb) { fTimeZeroBinEstimated = tzb; }
    virtual void SetFirstGoodBin(Int_t fgb) { fFirstGoodBin = fgb; }
    virtual void SetLastGoodBin(Int_t lgb) { fLastGoodBin = lgb; }
    virtual void SetFirstBkgBin(Int_t fbb) { fFirstBkgBin = fbb; }
    virtual void SetLastBkgBin(Int_t lbb) { fLastGoodBin = lbb; }
    virtual void SetData(PDoubleVector data) { fData = data; }

  private:
    TString fName;         
    Int_t fHistoNo;        
    Double_t fTimeZeroBin; 
    Double_t fTimeZeroBinEstimated; 
    Int_t fFirstGoodBin;   
    Int_t fLastGoodBin;    
    Int_t fFirstBkgBin;    
    Int_t fLastBkgBin;     
    PDoubleVector fData;   
};

//-------------------------------------------------------------
class PRawRunDataVector {
  public:
    PRawRunDataVector() {}
    virtual ~PRawRunDataVector() { fDataVec.clear(); }

    virtual UInt_t Size() { return fDataVec.size(); }
    virtual Bool_t IsPresent(UInt_t histoNo);
    virtual PRawRunDataSet* GetSet(UInt_t idx);
    virtual PRawRunDataSet* Get(UInt_t histoNo);
    virtual PRawRunDataSet* operator[](UInt_t histoNo);
    virtual PDoubleVector* GetData(UInt_t histoNo);
    virtual Double_t GetT0Bin(UInt_t histoNo);
    virtual Double_t GetT0BinEstimated(UInt_t histoNo);
    virtual PIntPair GetBkgBin(UInt_t histoNo);
    virtual PIntPair GetGoodDataBin(UInt_t histoNo);

    virtual void Set(PRawRunDataSet dataSet, Int_t idx=-1);

  private:
    std::vector<PRawRunDataSet> fDataVec;
};

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

    virtual const TString* GetVersion() { return &fVersion; }
    virtual const TString* GetGenericValidatorUrl() { return &fGenericValidatorURL; }
    virtual const TString* GetSpecificValidatorUrl() { return &fSpecificValidatorURL; }
    virtual const TString* GetGenerator() { return &fGenerator; }
    virtual const TString* GetComment() { return &fComment; }
    virtual const TString* GetFileName() { return &fFileName; }
    virtual const TString* GetLaboratory() { return &fLaboratory; }
    virtual const TString* GetBeamline() { return &fBeamline; }
    virtual const TString* GetInstrument() { return &fInstrument; }
    virtual const TString* GetRunName() { return &fRunName; }
    virtual const TString* GetMuonSource() { return &fMuonSource; }
    virtual const TString* GetMuonSpecies() { return &fMuonSpecies; }
    virtual const Double_t GetMuonBeamMomentum() { return fMuonBeamMomentum; }
    virtual const Double_t GetMuonSpinAngle() { return fMuonSpinAngle; }
    virtual const Int_t GetRunNumber() { return fRunNumber; }
    virtual const TString* GetRunTitle() { return &fRunTitle; }
    virtual const TString* GetSetup() { return &fSetup; }
    virtual const TString* GetStartTime() { return &fStartTime; }
    virtual const TString* GetStartDate() { return &fStartDate; }
    virtual const time_t GetStartDateTime() { return fStartDateTimeSec; }
    virtual const TString* GetStopTime() { return &fStopTime; }
    virtual const TString* GetStopDate() { return &fStopDate; }
    virtual const time_t GetStopDateTime() { return fStopDateTimeSec; }
    virtual const TString* GetCryoName() { return &fCryo; }
    virtual const TString* GetSample() { return &fSample; }
    virtual const TString* GetOrientation() { return &fOrientation; }
    virtual const TString* GetMagnetName() { return &fMagnet; }
    virtual const Double_t GetField() { return fField; }
    virtual const UInt_t GetNoOfTemperatures() { return fTemp.size(); }
    virtual const PDoublePairVector* GetTemperature() const { return &fTemp; }
    virtual const Double_t GetTemperature(const UInt_t idx);
    virtual const Double_t GetTempError(const UInt_t idx);
    virtual const Double_t GetEnergy() { return fEnergy; }
    virtual const Double_t GetTransport() { return fTransport; }
    virtual const PDoubleVector GetRingAnode() { return fRingAnode; }
    virtual const Double_t GetRingAnode(const UInt_t idx);
    virtual const Double_t GetTimeResolution() { return fTimeResolution; }    
    virtual const Bool_t IsPresent(UInt_t histoNo) { return fData.IsPresent(histoNo); }
    virtual const Double_t GetT0Bin(const UInt_t histoNo) { return fData.GetT0Bin(histoNo); }
    virtual const Double_t GetT0BinEstimated(const UInt_t histoNo) { return fData.GetT0BinEstimated(histoNo); }
    virtual const PIntPair GetBkgBin(const UInt_t histoNo) { return fData.GetBkgBin(histoNo); }
    virtual const PIntPair GetGoodDataBin(const UInt_t histoNo) { return fData.GetGoodDataBin(histoNo); }
    virtual const PIntVector GetRedGreenOffset() { return fRedGreenOffset; }
    virtual const UInt_t GetNoOfHistos() { return fData.Size(); }
    virtual PRawRunDataSet* GetDataSet(const UInt_t idx, Bool_t wantHistoNo = true);
    virtual const PDoubleVector* GetDataBin(const UInt_t histoNo) { return fData.GetData(histoNo); }
    virtual const PNonMusrRawRunData* GetDataNonMusr() { return &fDataNonMusr; }

    virtual void SetVersion(const TString &str) { fVersion = str; }
    virtual void SetGenericValidatorUrl(const TString &str) { fGenericValidatorURL = str; }
    virtual void SetSpecificValidatorUrl(const TString &str) { fSpecificValidatorURL = str; }
    virtual void SetGenerator(const TString &str) { fGenerator = str; }
    virtual void SetComment(const TString &str) { fComment = str; }
    virtual void SetFileName(const TString &str) { fFileName = str; }
    virtual void SetLaboratory(const TString &str) { fLaboratory = str; }
    virtual void SetBeamline(const TString &str) { fBeamline = str; }
    virtual void SetInstrument(const TString &str) { fInstrument = str; }
    virtual void SetMuonSource(const TString &str) { fMuonSource = str; }
    virtual void SetMuonSpecies(const TString &str) { fMuonSpecies = str; }
    virtual void SetMuonBeamMomentum(const Double_t dval) { fMuonBeamMomentum = dval; }
    virtual void SetMuonSpinAngle(const Double_t dval) { fMuonSpinAngle = dval; }
    virtual void SetRunName(const TString &str) { fRunName = str; }
    virtual void SetRunNumber(const Int_t &val) { fRunNumber = val; }
    virtual void SetRunTitle(const TString str) { fRunTitle = str; }
    virtual void SetSetup(const TString str) { fSetup = str; }
    virtual void SetStartTime(const TString str) { fStartTime = str; }
    virtual void SetStartDate(const TString str) { fStartDate = str; }
    virtual void SetStartDateTime(const time_t val) { fStartDateTimeSec = val; }
    virtual void SetStopTime(const TString str) { fStopTime = str; }
    virtual void SetStopDate(const TString str) { fStopDate = str; }
    virtual void SetStopDateTime(const time_t val) { fStopDateTimeSec = val; }
    virtual void SetMagnetName(const TString str) { fMagnet = str; }
    virtual void SetField(const Double_t dval) { fField = dval; }
    virtual void SetCryoName(const TString str) { fCryo = str; }
    virtual void SetSample(const TString str) { fSample = str; }
    virtual void SetOrientation(const TString str) { fOrientation = str; }
    virtual void ClearTemperature() { fTemp.clear(); }
    virtual void SetTemperature(const UInt_t idx, const Double_t temp, const Double_t errTemp);
    virtual void SetTempError(const UInt_t idx, const Double_t errTemp);
    virtual void SetEnergy(const Double_t dval) { fEnergy = dval; }
    virtual void SetTransport(const Double_t dval) { fTransport = dval; }
    virtual void SetRingAnode(const UInt_t idx, const Double_t dval);
    virtual void SetTimeResolution(const Double_t dval) { fTimeResolution = dval; }
    virtual void SetRedGreenOffset(PIntVector &ivec) { fRedGreenOffset = ivec; }
    virtual void SetDataSet(PRawRunDataSet &dataSet, UInt_t idx=-1) { fData.Set(dataSet, idx); }

    PNonMusrRawRunData fDataNonMusr; 

  private:
    TString fVersion;                
    TString fGenericValidatorURL;    
    TString fSpecificValidatorURL;   
    TString fGenerator;              
    TString fComment;                
    TString fFileName;               
    TString fLaboratory;             
    TString fBeamline;               
    TString fInstrument;             
    TString fMuonSource;             
    TString fMuonSpecies;            
    Double_t fMuonBeamMomentum;      
    Double_t fMuonSpinAngle;         
    TString fRunName;                
    Int_t   fRunNumber;              
    TString fRunTitle;               
    TString fSetup;                  
    TString fStartTime;              
    TString fStartDate;              
    time_t fStartDateTimeSec;        
    TString fStopTime;               
    TString fStopDate;               
    time_t fStopDateTimeSec;         
    TString fCryo;                   
    TString fSample;                 
    TString fOrientation;            
    TString fMagnet;                 
    Double_t fField;                 
    PDoublePairVector fTemp;         
    Double_t fEnergy;                
    Double_t fTransport;             
    PDoubleVector fRingAnode;        
    Double_t fTimeResolution;        
    PIntVector fRedGreenOffset;      

    PRawRunDataVector fData;         
};

//-------------------------------------------------------------
typedef std::vector<PRawRunData> PRawRunDataList;

//-------------------------------------------------------------
struct PMsrLineStructure {
  Int_t   fLineNo; 
  TString fLine;   
};

//-------------------------------------------------------------
typedef std::vector<PMsrLineStructure> PMsrLines;

//-------------------------------------------------------------
struct PMsrParamStructure{
  Int_t fNoOfParams;              
  Int_t fNo;                      
  TString fName;                  
  Double_t fValue;                
  Double_t fStep;                 
  Bool_t   fPosErrorPresent;      
  Double_t fPosError;             
  Bool_t   fLowerBoundaryPresent; 
  Double_t fLowerBoundary;        
  Bool_t   fUpperBoundaryPresent; 
  Double_t fUpperBoundary;        
  Bool_t   fIsGlobal;             
};

//-------------------------------------------------------------
typedef std::vector<PMsrParamStructure> PMsrParamList;

//-------------------------------------------------------------
class PMsrGlobalBlock {
  public:
    PMsrGlobalBlock();
    virtual ~PMsrGlobalBlock() {}

    virtual Bool_t IsPresent() { return fGlobalPresent; }
    virtual Double_t GetRRFFreq(const char *unit);
    virtual TString GetRRFUnit();
    virtual Int_t GetRRFUnitTag() { return fRRFUnitTag; }
    virtual Double_t GetRRFPhase() { return fRRFPhase; }
    virtual Int_t GetRRFPacking() { return fRRFPacking; }
    virtual Int_t GetFitType() { return fFitType; }
    virtual Int_t GetDataRange(UInt_t idx);
    virtual UInt_t GetT0BinSize() { return fT0.size(); }
    virtual Double_t GetT0Bin(UInt_t idx=0);
    virtual UInt_t GetAddT0BinEntries() { return fAddT0.size(); }
    virtual Int_t GetAddT0BinSize(UInt_t addRunIdx);
    virtual Double_t GetAddT0Bin(UInt_t addRunIdx, UInt_t histoIdx);
    virtual Bool_t IsFitRangeInBin() { return fFitRangeInBins; }
    virtual Double_t GetFitRange(UInt_t idx);
    virtual Int_t GetFitRangeOffset(UInt_t idx);
    virtual Int_t GetPacking() { return fPacking; }
    virtual Double_t GetEstimatedAlpha() { return fAlpha; }

    virtual void SetGlobalPresent(Bool_t bval) { fGlobalPresent = bval; }
    virtual void SetRRFFreq(Double_t freq, const char *unit);
    virtual void SetRRFPhase(Double_t phase) { fRRFPhase = phase; }
    virtual void SetRRFPacking(Int_t pack);
    virtual void SetFitType(Int_t ival) { fFitType = ival; }
    virtual void SetDataRange(Int_t ival, Int_t idx);
    virtual void SetT0Bin(Double_t dval, Int_t idx=-1);
    virtual void SetAddT0Bin(Double_t dval, UInt_t addRunIdx, UInt_t histoNoIdx);
    virtual void SetFitRangeInBins(Bool_t bval) { fFitRangeInBins = bval; }
    virtual void SetFitRange(Double_t dval, UInt_t idx);
    virtual void SetFitRangeOffset(Int_t ival, UInt_t idx);
    virtual void SetPacking(Int_t ival) { fPacking = ival; }

  private:
    Bool_t fGlobalPresent;    
    Double_t fRRFFreq;        
    Int_t fRRFUnitTag;        
    Double_t fRRFPhase;       
    Int_t fRRFPacking;        
    Int_t fFitType;           
    Int_t fDataRange[4];      
    PDoubleVector fT0;        
    std::vector<PDoubleVector> fAddT0; 
    Bool_t fFitRangeInBins;   
    Double_t fFitRange[2];    
    Int_t fFitRangeOffset[2]; 
    Int_t fPacking;           
    Double_t fAlpha;          
};

//-------------------------------------------------------------
class PMsrRunBlock {
  public:
    PMsrRunBlock();
    virtual ~PMsrRunBlock();
    virtual void CleanUp();

    virtual UInt_t GetRunNameSize() { return fRunName.size(); }
    virtual TString *GetRunName(UInt_t idx=0);
    virtual UInt_t GetBeamlineSize() { return fBeamline.size(); }
    virtual TString *GetBeamline(UInt_t idx=0);
    virtual UInt_t GetInstituteSize() { return fInstitute.size(); }
    virtual TString *GetInstitute(UInt_t idx=0);
    virtual UInt_t GetFileFormatSize() { return fFileFormat.size(); }
    virtual TString *GetFileFormat(UInt_t idx=0);
    virtual Int_t GetFitType() { return fFitType; }
    virtual Int_t GetAlphaParamNo() { return fAlphaParamNo; }
    virtual Int_t GetBetaParamNo() { return fBetaParamNo; }
    virtual Int_t GetNormParamNo() { return fNormParamNo; }
    virtual Int_t GetBkgFitParamNo() { return fBkgFitParamNo; }
    virtual Int_t GetLifetimeParamNo() { return fLifetimeParamNo; }
    virtual Bool_t IsLifetimeCorrected() { return fLifetimeCorrection; }
    virtual PIntVector* GetMap() { return &fMap; }
    virtual Int_t GetMap(UInt_t idx);
    virtual UInt_t GetForwardHistoNoSize() { return fForwardHistoNo.size(); }
    virtual Int_t GetForwardHistoNo(UInt_t idx=0);
    virtual UInt_t GetBackwardHistoNoSize() { return fBackwardHistoNo.size(); }
    virtual Int_t GetBackwardHistoNo(UInt_t idx=0);
    virtual Double_t GetBkgEstimated(UInt_t idx);
    virtual Double_t GetBkgFix(UInt_t idx);
    virtual Int_t GetBkgRange(UInt_t idx);
    virtual Int_t GetDataRange(UInt_t idx);
    virtual UInt_t GetT0BinSize() { return fT0.size(); }
    virtual Double_t GetT0Bin(UInt_t idx=0);
    virtual UInt_t GetAddT0BinEntries() { return fAddT0.size(); }
    virtual Int_t GetAddT0BinSize(UInt_t addRunIdx);
    virtual Double_t GetAddT0Bin(UInt_t addRunIdx, UInt_t histoIdx);
    virtual Bool_t IsFitRangeInBin() { return fFitRangeInBins; }
    virtual Double_t GetFitRange(UInt_t idx);
    virtual Int_t GetFitRangeOffset(UInt_t idx);
    virtual Int_t GetPacking() { return fPacking; }
    virtual Double_t GetEstimatedAlpha() { return fAlpha; }
    virtual Int_t GetXDataIndex() { return fXYDataIndex[0]; }
    virtual Int_t GetYDataIndex() { return fXYDataIndex[1]; }
    virtual TString* GetXDataLabel() { return &fXYDataLabel[0]; }
    virtual TString* GetYDataLabel() { return &fXYDataLabel[1]; }
    virtual std::map<TString, Int_t> *GetParGlobal() { return &fParGlobal; }
    virtual PIntVector *GetMapGlobal() { return &fMapGlobal; }

    virtual void SetRunName(TString &str, Int_t idx=-1);
    virtual void SetBeamline(TString &str, Int_t idx=-1);
    virtual void SetInstitute(TString &str, Int_t idx=-1);
    virtual void SetFileFormat(TString &str, Int_t idx=-1);
    virtual void SetFitType(Int_t ival) { fFitType = ival; }
    virtual void SetAlphaParamNo(Int_t ival) { fAlphaParamNo = ival; }
    virtual void SetBetaParamNo(Int_t ival) { fBetaParamNo = ival; }
    virtual void SetNormParamNo(Int_t ival) { fNormParamNo = ival; }
    virtual void SetBkgFitParamNo(Int_t ival) { fBkgFitParamNo = ival; }
    virtual void SetLifetimeParamNo(Int_t ival) { fLifetimeParamNo = ival; }
    virtual void SetLifetimeCorrection(Bool_t bval) { fLifetimeCorrection = bval; }
    virtual void SetMap(Int_t mapVal, Int_t idx=-1);
    virtual void SetForwardHistoNo(Int_t histoNo, Int_t idx=-1);
    virtual void SetBackwardHistoNo(Int_t histoNo, Int_t idx=-1);
    virtual void SetBkgEstimated(Double_t dval, Int_t idx);
    virtual void SetEstimatedAlpha(Double_t dval);
    virtual void SetBkgFix(Double_t dval, Int_t idx);
    virtual void SetBkgRange(Int_t ival, Int_t idx);
    virtual void SetDataRange(Int_t ival, Int_t idx);
    virtual void SetT0Bin(Double_t dval, Int_t idx=-1);
    virtual void SetAddT0Bin(Double_t dval, UInt_t addRunIdx, UInt_t histoNoIdx);
    virtual void SetFitRangeInBins(Bool_t bval) { fFitRangeInBins = bval; }
    virtual void SetFitRange(Double_t dval, UInt_t idx);
    virtual void SetFitRangeOffset(Int_t ival, UInt_t idx);
    virtual void SetPacking(Int_t ival) { fPacking = ival; }
    virtual void SetXDataIndex(Int_t ival) { fXYDataIndex[0] = ival; }
    virtual void SetYDataIndex(Int_t ival) { fXYDataIndex[1] = ival; }
    virtual void SetXDataLabel(TString& str) { fXYDataLabel[0] = str; }
    virtual void SetYDataLabel(TString& str) { fXYDataLabel[1] = str; }
    virtual void SetParGlobal(const TString &str, Int_t ival);
    virtual void SetMapGlobal(UInt_t idx, Int_t ival);

  private:
    PStringVector fRunName;         
    PStringVector fBeamline;        
    PStringVector fInstitute;       
    PStringVector fFileFormat;      
    Int_t fFitType;                 
    Int_t fAlphaParamNo;            
    Int_t fBetaParamNo;             
    Int_t fNormParamNo;             
    Int_t fBkgFitParamNo;           
    Int_t fLifetimeParamNo;         
    Bool_t fLifetimeCorrection;     
    PIntVector fMap;                
    PIntVector fForwardHistoNo;     
    PIntVector fBackwardHistoNo;    
    Double_t fBkgEstimated[2];      
    Double_t fBkgFix[2];            
    Int_t fBkgRange[4];             
    Int_t fDataRange[4];            
    PDoubleVector fT0;              
    std::vector<PDoubleVector> fAddT0;   
    Bool_t fFitRangeInBins;         
    Double_t fFitRange[2];          
    Int_t fFitRangeOffset[2];       
    Double_t fAlpha;                
    Int_t fPacking;                 
    Int_t fXYDataIndex[2];          
    TString fXYDataLabel[2];        

    // Two members used for msr2data in the global mode: fParGlobal and fMapGlobal
    // These are intended to track global and run specific parameters used in the RUN blocks
    // Suggested keys for the std::map: (alpha, beta, norm, bkgfit, lifetime)
    // Suggested values for the std::map: 1 -> parameter is global
    //                                    0 -> parameter is run specific
    //                                    -1 -> tag not present in the RUN block
    // The information about global parameters in the map line is stored in an std::vector which should have the same length as the map-vector
    // The values in this std::vector can be the same as for the std::map of the other parameters.
    std::map<TString, Int_t> fParGlobal; 
    PIntVector fMapGlobal;          
};

//-------------------------------------------------------------
typedef std::vector<PMsrRunBlock> PMsrRunList;

//-------------------------------------------------------------
struct PMsrFourierStructure {
  Bool_t fFourierBlockPresent; 
  Int_t  fUnits;               
  Bool_t fDCCorrected;         
  Int_t  fFourierPower;        
  Int_t  fApodization;         
  Int_t  fPlotTag;             
  Int_t  fPhaseRef;            
  PIntVector  fPhaseParamNo;   
  PDoubleVector fPhase;        
  Double_t fRangeForPhaseCorrection[2]; 
  Double_t fPlotRange[2];      
  Double_t fPhaseIncrement;    
};

//-------------------------------------------------------------
struct PMsrPlotStructure{
  Int_t    fPlotType;      
  Bool_t   fLifeTimeCorrection; 
  Bool_t   fUseFitRanges;  
  Bool_t   fLogX;          
  Bool_t   fLogY;          
  Int_t    fViewPacking;   
  PIntVector fRuns;        
  PDoubleVector  fTmin;    
  PDoubleVector  fTmax;    
  PDoubleVector  fYmin;    
  PDoubleVector  fYmax;    
  UInt_t fRRFPacking;      
  Double_t fRRFFreq;       
  UInt_t fRRFUnit;         
  Int_t  fRRFPhaseParamNo; 
  Double_t fRRFPhase;      
};

//-------------------------------------------------------------
typedef std::vector<PMsrPlotStructure>  PMsrPlotList;

//-------------------------------------------------------------
struct PMsrStatisticStructure {
  Bool_t fValid;     
  PMsrLines fStatLines; 
  TString fDate;     
  Bool_t   fChisq;   
  Double_t fMin;     
  PDoubleVector fMinPerHisto; 
  UInt_t fNdf;       
  Double_t fMinExpected; 
  PDoubleVector fMinExpectedPerHisto; 
  PUIntVector fNdfPerHisto; 
};

//-------------------------------------------------------------
struct PAny2ManyInfo {
  Bool_t useStandardOutput{false}; 
  TString inFormat{""};            
  TString outFormat{""};           
  TString inTemplate{""};          
  TString outTemplate{""};         
  TString year{""};                
  PUIntVector runList;             
  PIntVector groupHistoList;       
  PStringVector inFileName;        
  TString outFileName{""};         
  PStringVector outPathFileName;   
  TString outPath{""};             
  UInt_t rebin{1};                 
  UInt_t compressionTag{0};        
  TString compressFileName{""};    
  UInt_t idf{0};                   
};

//-------------------------------------------------------------
struct PStartupOptions {
  Bool_t writeExpectedChisq; 
  Bool_t estimateN0;         
};

//-------------------------------------------------------------
class PStringNumberList {
  public:
    PStringNumberList(char *str) { fString = str; }
    PStringNumberList(std::string str) { fString = str; }
    virtual ~PStringNumberList() { fList.clear(); }

    virtual bool Parse(std::string &errorMsg, bool ignoreFirstToken=false);
    virtual PUIntVector GetList() { return fList; }

  private:
    std::string fString;
    bool fIsValid;
    PUIntVector fList;

    virtual bool IsNumber(std::string &str) { return (str.find_first_not_of("0123456789") == std::string::npos); }
    virtual void StripSpaces();
};

//-------------------------------------------------------------
struct PRunNameTemplate {
  TString instrument{""};
  TString runNameTemplate{""};
};

//-------------------------------------------------------------
typedef std::vector<PRunNameTemplate> PRunNameTemplateList;

#endif // _PMUSR_H_