technical/html/PMusr_8h_source.html

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


  PMusr.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 _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 PMUSR_UNSUPPORTED_FEATURE      -11


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

#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


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


#define PMUON_LIFETIME 2.1969811


#define GAMMA_BAR_MUON 1.355388094e-2


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

#define ACCEL_PERIOD_PSI     0.01975

#define ACCEL_PERIOD_TRIUMF  0.04337

#define ACCEL_PERIOD_RAL     0.0


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

#define POST_PILEUP_HISTO_OFFSET 20


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

#define PMUSR_UNDEFINED -9.9e99


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

#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


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

#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


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

#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


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

#define MSR_PARAM_MAP_OFFSET 10000

#define MSR_PARAM_FUN_OFFSET 20000


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

#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


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

#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 GetTitle() { return fTitle; }

    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 SetTitle(TString str) { fTitle = str; }

    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 fTitle;

    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 time_t CalcStartDateTime(bool &ok);

    virtual const TString* GetStopTime() { return &fStopTime; }

    virtual const TString* GetStopDate() { return &fStopDate; }

    virtual const time_t GetStopDateTime() { return fStopDateTimeSec; }

    virtual const time_t CalcStopDateTime(bool &ok);

    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 Bool_t DeadTimeCorrectionReady();

    virtual const Int_t GetNumberOfGoodFrames() { return fNumberOfGoodFrames; }

    virtual const std::vector<float> GetDeadTimeParam() { return fDeadTimeParam; }

    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 SetNumberOfGoodFrames(Int_t ival) { fNumberOfGoodFrames = ival; }

    virtual void SetDeadTimeParam(std::vector<float> dvec) { fDeadTimeParam = dvec; }

    virtual void SetDataSet(PRawRunDataSet &dataSet, UInt_t idx=-1) { fData.Set(dataSet, idx); }


    PNonMusrRawRunData fDataNonMusr;


  private:

    TString fVersion{"n/a"};

    TString fGenericValidatorURL{"n/a"};

    TString fSpecificValidatorURL{"n/a"};

    TString fGenerator{"n/a"};

    TString fComment{"n/a"};

    TString fFileName{"n/a"};

    TString fLaboratory{"n/a"};

    TString fBeamline{"n/a"};

    TString fInstrument{"n/a"};

    TString fMuonSource{"n/a"};

    TString fMuonSpecies{"n/a"};

    Double_t fMuonBeamMomentum{PMUSR_UNDEFINED};

    Double_t fMuonSpinAngle{PMUSR_UNDEFINED};

    TString fRunName{"n/a"};

    Int_t   fRunNumber{-1};

    TString fRunTitle{"n/a"};

    TString fSetup{"n/a"};

    TString fStartTime{"n/a"};

    TString fStartDate{"n/a"};

    time_t fStartDateTimeSec{0};

    TString fStopTime{"n/a"};

    TString fStopDate{"n/a"};

    time_t fStopDateTimeSec{0};

    TString fCryo{"n/a"};

    TString fSample{"n/a"};

    TString fOrientation{"n/a"};

    TString fMagnet{"n/a"};

    Double_t fField{PMUSR_UNDEFINED};

    PDoublePairVector fTemp;

    Double_t fEnergy{PMUSR_UNDEFINED};

    Double_t fTransport{PMUSR_UNDEFINED};

    PDoubleVector fRingAnode;

    Double_t fTimeResolution{PMUSR_UNDEFINED};

    PIntVector fRedGreenOffset;

    std::vector<float> fDeadTimeParam;

    Int_t fNumberOfGoodFrames{0};


    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 TString GetDeadTimeCorrection() { return fDeadTimeCorrection; }


    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; }

    virtual void SetDeadTimeCorrection(TString str) { fDeadTimeCorrection = str; }


  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;

    TString fDeadTimeCorrection;

};


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


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 TString GetDeadTimeCorrection() { return fDeadTimeCorrection; }

    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 SetDeadTimeCorrection(TString str) { fDeadTimeCorrection = str; }

    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;

    TString fDeadTimeCorrection;

    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_

PUIntVector
std::vector< UInt_t > PUIntVector
Definition PMusr.h:361

PRunNameTemplateList
std::vector< PRunNameTemplate > PRunNameTemplateList
Definition PMusr.h:1454

PDoublePair
std::pair< Double_t, Double_t > PDoublePair
Definition PMusr.h:391

EPMusrHandleTag
EPMusrHandleTag
Definition PMusr.h:413

kEmpty
@ kEmpty
No operation active.
Definition PMusr.h:414

kFit
@ kFit
Fitting mode - perform least-squares fit to data.
Definition PMusr.h:415

kView
@ kView
Viewing mode - display data and theory without fitting.
Definition PMusr.h:416

PMsrRunList
std::vector< PMsrRunBlock > PMsrRunList
Definition PMusr.h:1245

PMUSR_UNDEFINED
#define PMUSR_UNDEFINED
Definition PMusr.h:172

PBoolVector
std::vector< Bool_t > PBoolVector
Definition PMusr.h:355

PMsrPlotList
std::vector< PMsrPlotStructure > PMsrPlotList
Definition PMusr.h:1312

PMsrLines
std::vector< PMsrLineStructure > PMsrLines
Definition PMusr.h:989

PDoublePairVector
std::vector< PDoublePair > PDoublePairVector
Definition PMusr.h:397

PIntPair
std::pair< Int_t, Int_t > PIntPair
Definition PMusr.h:373

PIntVector
std::vector< Int_t > PIntVector
Definition PMusr.h:367

PMsrParamList
std::vector< PMsrParamStructure > PMsrParamList
Definition PMusr.h:1022

PIntPairVector
std::vector< PIntPair > PIntPairVector
Definition PMusr.h:379

PStringVector
std::vector< TString > PStringVector
Definition PMusr.h:403

PDoubleVector
std::vector< Double_t > PDoubleVector
Definition PMusr.h:385

PRawRunDataList
std::vector< PRawRunData > PRawRunDataList
Definition PMusr.h:970

PMsrGlobalBlock::~PMsrGlobalBlock
virtual ~PMsrGlobalBlock()
Definition PMusr.h:1040

PMsrGlobalBlock::IsPresent
virtual Bool_t IsPresent()
Definition PMusr.h:1042

PMsrGlobalBlock::SetT0Bin
virtual void SetT0Bin(Double_t dval, Int_t idx=-1)
Definition PMusr.cpp:1021

PMsrGlobalBlock::fFitRangeInBins
Bool_t fFitRangeInBins
flag telling if fit range is given in time or in bins
Definition PMusr.h:1086

PMsrGlobalBlock::SetFitRangeInBins
virtual void SetFitRangeInBins(Bool_t bval)
Definition PMusr.h:1070

PMsrGlobalBlock::SetRRFFreq
virtual void SetRRFFreq(Double_t freq, const char *unit)
Definition PMusr.cpp:875

PMsrGlobalBlock::SetFitRange
virtual void SetFitRange(Double_t dval, UInt_t idx)
Definition PMusr.cpp:1137

PMsrGlobalBlock::SetGlobalPresent
virtual void SetGlobalPresent(Bool_t bval)
Definition PMusr.h:1062

PMsrGlobalBlock::GetFitType
virtual Int_t GetFitType()
Definition PMusr.h:1048

PMsrGlobalBlock::fFitRange
Double_t fFitRange[2]
fit range in (us)
Definition PMusr.h:1087

PMsrGlobalBlock::fDataRange
Int_t fDataRange[4]
data bin range (fit type 0, 1, 2, 4)
Definition PMusr.h:1083

PMsrGlobalBlock::GetAddT0Bin
virtual Double_t GetAddT0Bin(UInt_t addRunIdx, UInt_t histoIdx)
Definition PMusr.cpp:1070

PMsrGlobalBlock::SetFitType
virtual void SetFitType(Int_t ival)
Definition PMusr.h:1066

PMsrGlobalBlock::fAlpha
Double_t fAlpha
estimated alpha value from F/B counts
Definition PMusr.h:1090

PMsrGlobalBlock::fFitType
Int_t fFitType
fit type: 0=single histo fit, 1=single histo RRF fit, 2=asymmetry fit, 4=mu^- single histo fit,...
Definition PMusr.h:1082

PMsrGlobalBlock::GetAddT0BinSize
virtual Int_t GetAddT0BinSize(UInt_t addRunIdx)
Definition PMusr.cpp:1046

PMsrGlobalBlock::GetRRFUnitTag
virtual Int_t GetRRFUnitTag()
Definition PMusr.h:1045

PMsrGlobalBlock::fAddT0
std::vector< PDoubleVector > fAddT0
addt0 bins (fit type 0, 1, 2, 4). if fit type 0 -> f0, f1, f2, ...; if fit type 2,...
Definition PMusr.h:1085

PMsrGlobalBlock::GetFitRange
virtual Double_t GetFitRange(UInt_t idx)
Definition PMusr.cpp:1120

PMsrGlobalBlock::fFitRangeOffset
Int_t fFitRangeOffset[2]
if fit range is given in bins it can have the form fit fgb+n0 lgb-n1. This variable holds the n0 and ...
Definition PMusr.h:1088

PMsrGlobalBlock::fGlobalPresent
Bool_t fGlobalPresent
flag showing if a GLOBAL block is present at all.
Definition PMusr.h:1077

PMsrGlobalBlock::fRRFUnitTag
Int_t fRRFUnitTag
RRF unit tag.
Definition PMusr.h:1079

PMsrGlobalBlock::GetT0BinSize
virtual UInt_t GetT0BinSize()
Definition PMusr.h:1050

PMsrGlobalBlock::SetDeadTimeCorrection
virtual void SetDeadTimeCorrection(TString str)
Definition PMusr.h:1074

PMsrGlobalBlock::GetEstimatedAlpha
virtual Double_t GetEstimatedAlpha()
Definition PMusr.h:1059

PMsrGlobalBlock::IsFitRangeInBin
virtual Bool_t IsFitRangeInBin()
Definition PMusr.h:1055

PMsrGlobalBlock::GetDeadTimeCorrection
virtual TString GetDeadTimeCorrection()
Definition PMusr.h:1060

PMsrGlobalBlock::GetDataRange
virtual Int_t GetDataRange(UInt_t idx)
Definition PMusr.cpp:964

PMsrGlobalBlock::SetDataRange
virtual void SetDataRange(Int_t ival, Int_t idx)
Definition PMusr.cpp:981

PMsrGlobalBlock::GetRRFPacking
virtual Int_t GetRRFPacking()
Definition PMusr.h:1047

PMsrGlobalBlock::fDeadTimeCorrection
TString fDeadTimeCorrection
tells if deadtime correction (pulsed sources) should be applied. Possible value: 'no' (default),...
Definition PMusr.h:1091

PMsrGlobalBlock::SetPacking
virtual void SetPacking(Int_t ival)
Definition PMusr.h:1073

PMsrGlobalBlock::fRRFPacking
Int_t fRRFPacking
RRF packing.
Definition PMusr.h:1081

PMsrGlobalBlock::GetRRFUnit
virtual TString GetRRFUnit()
Definition PMusr.cpp:903

PMsrGlobalBlock::fRRFPhase
Double_t fRRFPhase
RRF phase in (°)
Definition PMusr.h:1080

PMsrGlobalBlock::PMsrGlobalBlock
PMsrGlobalBlock()
Definition PMusr.cpp:804

PMsrGlobalBlock::fT0
PDoubleVector fT0
t0 bins (fit type 0, 1, 2, 4). if fit type 0 -> f0, f1, f2, ...; if fit type 2, 4 -> f0,...
Definition PMusr.h:1084

PMsrGlobalBlock::fPacking
Int_t fPacking
packing/rebinning
Definition PMusr.h:1089

PMsrGlobalBlock::SetRRFPhase
virtual void SetRRFPhase(Double_t phase)
Definition PMusr.h:1064

PMsrGlobalBlock::GetPacking
virtual Int_t GetPacking()
Definition PMusr.h:1058

PMsrGlobalBlock::SetRRFPacking
virtual void SetRRFPacking(Int_t pack)
Definition PMusr.cpp:942

PMsrGlobalBlock::fRRFFreq
Double_t fRRFFreq
RRF frequency given in units of (MHz, Mc, T)
Definition PMusr.h:1078

PMsrGlobalBlock::SetFitRangeOffset
virtual void SetFitRangeOffset(Int_t ival, UInt_t idx)
Definition PMusr.cpp:1174

PMsrGlobalBlock::GetAddT0BinEntries
virtual UInt_t GetAddT0BinEntries()
Definition PMusr.h:1052

PMsrGlobalBlock::SetAddT0Bin
virtual void SetAddT0Bin(Double_t dval, UInt_t addRunIdx, UInt_t histoNoIdx)
Definition PMusr.cpp:1097

PMsrGlobalBlock::GetFitRangeOffset
virtual Int_t GetFitRangeOffset(UInt_t idx)
Definition PMusr.cpp:1157

PMsrGlobalBlock::GetT0Bin
virtual Double_t GetT0Bin(UInt_t idx=0)
Definition PMusr.cpp:1004

PMsrGlobalBlock::GetRRFPhase
virtual Double_t GetRRFPhase()
Definition PMusr.h:1046

PMsrGlobalBlock::GetRRFFreq
virtual Double_t GetRRFFreq(const char *unit)
Definition PMusr.cpp:831

PMsrRunBlock::fInstitute
PStringVector fInstitute
e.g. psi, ral, triumf (former: run format)
Definition PMusr.h:1202

PMsrRunBlock::GetMap
virtual PIntVector * GetMap()
Definition PMusr.h:1138

PMsrRunBlock::GetParGlobal
virtual std::map< TString, Int_t > * GetParGlobal()
Definition PMusr.h:1163

PMsrRunBlock::SetLifetimeParamNo
virtual void SetLifetimeParamNo(Int_t ival)
Definition PMusr.h:1175

PMsrRunBlock::fBkgRange
Int_t fBkgRange[4]
background bin range (fit type 0, 2, 4)
Definition PMusr.h:1216

PMsrRunBlock::fNormParamNo
Int_t fNormParamNo
N0 parameter number (fit type 0)
Definition PMusr.h:1207

PMsrRunBlock::GetBetaParamNo
virtual Int_t GetBetaParamNo()
Definition PMusr.h:1133

PMsrRunBlock::PMsrRunBlock
PMsrRunBlock()
Definition PMusr.cpp:1192

PMsrRunBlock::GetYDataLabel
virtual TString * GetYDataLabel()
Definition PMusr.h:1162

PMsrRunBlock::GetInstitute
virtual TString * GetInstitute(UInt_t idx=0)
Definition PMusr.cpp:1385

PMsrRunBlock::fAlpha
Double_t fAlpha
estimated alpha value from F/B counts
Definition PMusr.h:1223

PMsrRunBlock::fBkgEstimated
Double_t fBkgEstimated[2]
keeps estimated background values (if present)
Definition PMusr.h:1214

PMsrRunBlock::fAlphaParamNo
Int_t fAlphaParamNo
alpha parameter number (fit type 2, 4)
Definition PMusr.h:1205

PMsrRunBlock::IsLifetimeCorrected
virtual Bool_t IsLifetimeCorrected()
Definition PMusr.h:1137

PMsrRunBlock::GetDataRange
virtual Int_t GetDataRange(UInt_t idx)
Definition PMusr.cpp:1723

PMsrRunBlock::SetFitRangeOffset
virtual void SetFitRangeOffset(Int_t ival, UInt_t idx)
Definition PMusr.cpp:1934

PMsrRunBlock::GetFileFormat
virtual TString * GetFileFormat(UInt_t idx=0)
Definition PMusr.cpp:1427

PMsrRunBlock::GetBeamlineSize
virtual UInt_t GetBeamlineSize()
Definition PMusr.h:1125

PMsrRunBlock::SetBeamline
virtual void SetBeamline(TString &str, Int_t idx=-1)
Definition PMusr.cpp:1360

PMsrRunBlock::GetPacking
virtual Int_t GetPacking()
Definition PMusr.h:1156

PMsrRunBlock::SetBkgFix
virtual void SetBkgFix(Double_t dval, Int_t idx)
Definition PMusr.cpp:1658

PMsrRunBlock::GetBeamline
virtual TString * GetBeamline(UInt_t idx=0)
Definition PMusr.cpp:1343

PMsrRunBlock::fDataRange
Int_t fDataRange[4]
data bin range (fit type 0, 2, 4)
Definition PMusr.h:1217

PMsrRunBlock::GetFitRange
virtual Double_t GetFitRange(UInt_t idx)
Definition PMusr.cpp:1880

PMsrRunBlock::SetXDataLabel
virtual void SetXDataLabel(TString &str)
Definition PMusr.h:1194

PMsrRunBlock::SetFitType
virtual void SetFitType(Int_t ival)
Definition PMusr.h:1170

PMsrRunBlock::GetAddT0BinSize
virtual Int_t GetAddT0BinSize(UInt_t addRunIdx)
Definition PMusr.cpp:1806

PMsrRunBlock::fLifetimeParamNo
Int_t fLifetimeParamNo
muon lifetime parameter number (fit type 0)
Definition PMusr.h:1209

PMsrRunBlock::GetNormParamNo
virtual Int_t GetNormParamNo()
Definition PMusr.h:1134

PMsrRunBlock::GetBkgEstimated
virtual Double_t GetBkgEstimated(UInt_t idx)
Definition PMusr.cpp:1600

PMsrRunBlock::GetMapGlobal
virtual PIntVector * GetMapGlobal()
Definition PMusr.h:1164

PMsrRunBlock::GetYDataIndex
virtual Int_t GetYDataIndex()
Definition PMusr.h:1160

PMsrRunBlock::fDeadTimeCorrection
TString fDeadTimeCorrection
tells if deadtime correction (pulsed sources) should be applied. Possible value: 'no' (default),...
Definition PMusr.h:1225

PMsrRunBlock::SetFitRange
virtual void SetFitRange(Double_t dval, UInt_t idx)
Definition PMusr.cpp:1897

PMsrRunBlock::SetBkgEstimated
virtual void SetBkgEstimated(Double_t dval, Int_t idx)
Definition PMusr.cpp:1618

PMsrRunBlock::fT0
PDoubleVector fT0
t0 bins (fit type 0, 2, 4). if fit type 0 -> f0, f1, f2, ...; if fit type 2, 4 -> f0,...
Definition PMusr.h:1218

PMsrRunBlock::fBkgFitParamNo
Int_t fBkgFitParamNo
background fit parameter number (fit type 0)
Definition PMusr.h:1208

PMsrRunBlock::GetForwardHistoNoSize
virtual UInt_t GetForwardHistoNoSize()
Definition PMusr.h:1140

PMsrRunBlock::CleanUp
virtual void CleanUp()
Definition PMusr.cpp:1247

PMsrRunBlock::SetFileFormat
virtual void SetFileFormat(TString &str, Int_t idx=-1)
Definition PMusr.cpp:1444

PMsrRunBlock::SetEstimatedAlpha
virtual void SetEstimatedAlpha(Double_t dval)
Definition PMusr.cpp:1984

PMsrRunBlock::GetLifetimeParamNo
virtual Int_t GetLifetimeParamNo()
Definition PMusr.h:1136

PMsrRunBlock::GetAddT0Bin
virtual Double_t GetAddT0Bin(UInt_t addRunIdx, UInt_t histoIdx)
Definition PMusr.cpp:1830

PMsrRunBlock::fBeamline
PStringVector fBeamline
e.g. mue4, mue1, pim3, emu, m15, ... (former: run type)
Definition PMusr.h:1201

PMsrRunBlock::fBetaParamNo
Int_t fBetaParamNo
beta parameter number (fit type 2, 4)
Definition PMusr.h:1206

PMsrRunBlock::GetRunName
virtual TString * GetRunName(UInt_t idx=0)
Definition PMusr.cpp:1301

PMsrRunBlock::GetAddT0BinEntries
virtual UInt_t GetAddT0BinEntries()
Definition PMusr.h:1150

PMsrRunBlock::fLifetimeCorrection
Bool_t fLifetimeCorrection
lifetime correction flag for viewing (fit type 0)
Definition PMusr.h:1210

PMsrRunBlock::SetMap
virtual void SetMap(Int_t mapVal, Int_t idx=-1)
Definition PMusr.cpp:1574

PMsrRunBlock::fXYDataLabel
TString fXYDataLabel[2]
used to get the indices via labels when using db-files (fit type 8)
Definition PMusr.h:1227

PMsrRunBlock::GetInstituteSize
virtual UInt_t GetInstituteSize()
Definition PMusr.h:1127

PMsrRunBlock::GetEstimatedAlpha
virtual Double_t GetEstimatedAlpha()
Definition PMusr.h:1158

PMsrRunBlock::GetDeadTimeCorrection
virtual TString GetDeadTimeCorrection()
Definition PMusr.h:1157

PMsrRunBlock::fFileFormat
PStringVector fFileFormat
e.g. root, nexus, psi-bin, mud, ascii, db
Definition PMusr.h:1203

PMsrRunBlock::SetParGlobal
virtual void SetParGlobal(const TString &str, Int_t ival)
Definition PMusr.cpp:1951

PMsrRunBlock::GetFileFormatSize
virtual UInt_t GetFileFormatSize()
Definition PMusr.h:1129

PMsrRunBlock::fRunName
PStringVector fRunName
name of the run file
Definition PMusr.h:1200

PMsrRunBlock::GetT0BinSize
virtual UInt_t GetT0BinSize()
Definition PMusr.h:1148

PMsrRunBlock::SetPacking
virtual void SetPacking(Int_t ival)
Definition PMusr.h:1190

PMsrRunBlock::SetYDataIndex
virtual void SetYDataIndex(Int_t ival)
Definition PMusr.h:1193

PMsrRunBlock::SetLifetimeCorrection
virtual void SetLifetimeCorrection(Bool_t bval)
Definition PMusr.h:1176

PMsrRunBlock::SetMapGlobal
virtual void SetMapGlobal(UInt_t idx, Int_t ival)
Definition PMusr.cpp:1966

PMsrRunBlock::fMapGlobal
PIntVector fMapGlobal
here is stored if the maps used in the RUN block are global or not
Definition PMusr.h:1238

PMsrRunBlock::GetBkgFix
virtual Double_t GetBkgFix(UInt_t idx)
Definition PMusr.cpp:1641

PMsrRunBlock::SetT0Bin
virtual void SetT0Bin(Double_t dval, Int_t idx=-1)
Definition PMusr.cpp:1781

PMsrRunBlock::fXYDataIndex
Int_t fXYDataIndex[2]
used to get the data indices when using db-files (fit type 8)
Definition PMusr.h:1226

PMsrRunBlock::GetForwardHistoNo
virtual Int_t GetForwardHistoNo(UInt_t idx=0)
Definition PMusr.cpp:1469

PMsrRunBlock::GetXDataIndex
virtual Int_t GetXDataIndex()
Definition PMusr.h:1159

PMsrRunBlock::fFitRangeInBins
Bool_t fFitRangeInBins
flag telling if fit range is given in time or in bins
Definition PMusr.h:1220

PMsrRunBlock::GetAlphaParamNo
virtual Int_t GetAlphaParamNo()
Definition PMusr.h:1132

PMsrRunBlock::SetBkgFitParamNo
virtual void SetBkgFitParamNo(Int_t ival)
Definition PMusr.h:1174

PMsrRunBlock::GetFitRangeOffset
virtual Int_t GetFitRangeOffset(UInt_t idx)
Definition PMusr.cpp:1917

PMsrRunBlock::SetBackwardHistoNo
virtual void SetBackwardHistoNo(Int_t histoNo, Int_t idx=-1)
Definition PMusr.cpp:1534

PMsrRunBlock::SetDataRange
virtual void SetDataRange(Int_t ival, Int_t idx)
Definition PMusr.cpp:1741

PMsrRunBlock::GetFitType
virtual Int_t GetFitType()
Definition PMusr.h:1131

PMsrRunBlock::SetXDataIndex
virtual void SetXDataIndex(Int_t ival)
Definition PMusr.h:1192

PMsrRunBlock::GetBkgRange
virtual Int_t GetBkgRange(UInt_t idx)
Definition PMusr.cpp:1681

PMsrRunBlock::GetBackwardHistoNo
virtual Int_t GetBackwardHistoNo(UInt_t idx=0)
Definition PMusr.cpp:1513

PMsrRunBlock::SetRunName
virtual void SetRunName(TString &str, Int_t idx=-1)
Definition PMusr.cpp:1318

PMsrRunBlock::GetBackwardHistoNoSize
virtual UInt_t GetBackwardHistoNoSize()
Definition PMusr.h:1142

PMsrRunBlock::fParGlobal
std::map< TString, Int_t > fParGlobal
here is stored if the parameters used in the RUN block are global or not
Definition PMusr.h:1237

PMsrRunBlock::fBackwardHistoNo
PIntVector fBackwardHistoNo
backward histogram number (fit type 2, 4)
Definition PMusr.h:1213

PMsrRunBlock::fFitRange
Double_t fFitRange[2]
fit range in (us)
Definition PMusr.h:1221

PMsrRunBlock::fBkgFix
Double_t fBkgFix[2]
fixed background in (1/ns) (fit type 0, 2, 4)
Definition PMusr.h:1215

PMsrRunBlock::SetBetaParamNo
virtual void SetBetaParamNo(Int_t ival)
Definition PMusr.h:1172

PMsrRunBlock::SetYDataLabel
virtual void SetYDataLabel(TString &str)
Definition PMusr.h:1195

PMsrRunBlock::~PMsrRunBlock
virtual ~PMsrRunBlock()
Definition PMusr.cpp:1227

PMsrRunBlock::SetAlphaParamNo
virtual void SetAlphaParamNo(Int_t ival)
Definition PMusr.h:1171

PMsrRunBlock::SetBkgRange
virtual void SetBkgRange(Int_t ival, Int_t idx)
Definition PMusr.cpp:1699

PMsrRunBlock::fMap
PIntVector fMap
map vector needed to switch parameters for different runs within a single theory
Definition PMusr.h:1211

PMsrRunBlock::GetBkgFitParamNo
virtual Int_t GetBkgFitParamNo()
Definition PMusr.h:1135

PMsrRunBlock::fFitRangeOffset
Int_t fFitRangeOffset[2]
if fit range is given in bins it can have the form fit fgb+n0 lgb-n1. This variable holds the n0 and ...
Definition PMusr.h:1222

PMsrRunBlock::SetInstitute
virtual void SetInstitute(TString &str, Int_t idx=-1)
Definition PMusr.cpp:1402

PMsrRunBlock::IsFitRangeInBin
virtual Bool_t IsFitRangeInBin()
Definition PMusr.h:1153

PMsrRunBlock::fFitType
Int_t fFitType
fit type: 0=single histo fit, 2=asymmetry fit, 4=mu^- single histo fit, 8=non muSR fit
Definition PMusr.h:1204

PMsrRunBlock::GetT0Bin
virtual Double_t GetT0Bin(UInt_t idx=0)
Definition PMusr.cpp:1764

PMsrRunBlock::SetDeadTimeCorrection
virtual void SetDeadTimeCorrection(TString str)
Definition PMusr.h:1191

PMsrRunBlock::SetNormParamNo
virtual void SetNormParamNo(Int_t ival)
Definition PMusr.h:1173

PMsrRunBlock::fForwardHistoNo
PIntVector fForwardHistoNo
forward histogram number (fit type 0, 2, 4)
Definition PMusr.h:1212

PMsrRunBlock::SetFitRangeInBins
virtual void SetFitRangeInBins(Bool_t bval)
Definition PMusr.h:1187

PMsrRunBlock::GetXDataLabel
virtual TString * GetXDataLabel()
Definition PMusr.h:1161

PMsrRunBlock::SetForwardHistoNo
virtual void SetForwardHistoNo(Int_t histoNo, Int_t idx=-1)
Definition PMusr.cpp:1490

PMsrRunBlock::fPacking
Int_t fPacking
packing/rebinning
Definition PMusr.h:1224

PMsrRunBlock::GetRunNameSize
virtual UInt_t GetRunNameSize()
Definition PMusr.h:1123

PMsrRunBlock::SetAddT0Bin
virtual void SetAddT0Bin(Double_t dval, UInt_t addRunIdx, UInt_t histoNoIdx)
Definition PMusr.cpp:1857

PMsrRunBlock::fAddT0
std::vector< PDoubleVector > fAddT0
t0 bins for addrun's
Definition PMusr.h:1219

PNonMusrRawRunData
Definition PMusr.h:546

PNonMusrRawRunData::AppendLabel
virtual void AppendLabel(const TString str)
Definition PMusr.h:575

PNonMusrRawRunData::fData
std::vector< PDoubleVector > fData
vector of all data
Definition PMusr.h:615

PNonMusrRawRunData::AppendErrData
virtual void AppendErrData(const PDoubleVector &data)
Definition PMusr.h:593

PNonMusrRawRunData::AppendSubErrData
virtual void AppendSubErrData(const UInt_t idx, const Double_t dval)
Definition PMusr.cpp:229

PNonMusrRawRunData::GetDataTags
virtual const PStringVector * GetDataTags()
Returns pointer to vector of data tags (identifiers for each data column)
Definition PMusr.h:556

PNonMusrRawRunData::AppendDataTag
virtual void AppendDataTag(const TString str)
Definition PMusr.h:587

PNonMusrRawRunData::fLabels
PStringVector fLabels
vector of all labels (used for x-, y-axis title in view)
Definition PMusr.h:613

PNonMusrRawRunData::~PNonMusrRawRunData
virtual ~PNonMusrRawRunData()
Definition PMusr.cpp:139

PNonMusrRawRunData::fFromAscii
Bool_t fFromAscii
if true: data file was an ascii input file, otherwise it is a db/dat input file
Definition PMusr.h:612

PNonMusrRawRunData::AppendSubData
virtual void AppendSubData(const UInt_t idx, const Double_t dval)
Definition PMusr.cpp:209

PNonMusrRawRunData::SetFromAscii
virtual void SetFromAscii(const Bool_t bval)
Definition PMusr.h:564

PNonMusrRawRunData::PNonMusrRawRunData
PNonMusrRawRunData()
Definition PMusr.cpp:118

PNonMusrRawRunData::GetData
virtual const std::vector< PDoubleVector > * GetData()
Returns pointer to vector of data columns.
Definition PMusr.h:558

PNonMusrRawRunData::GetLabels
virtual const PStringVector * GetLabels()
Returns pointer to vector of axis/column labels.
Definition PMusr.h:554

PNonMusrRawRunData::fDataTags
PStringVector fDataTags
vector of all data tags
Definition PMusr.h:614

PNonMusrRawRunData::GetErrData
virtual const std::vector< PDoubleVector > * GetErrData()
Returns pointer to vector of error data columns.
Definition PMusr.h:560

PNonMusrRawRunData::SetSize
virtual void SetSize(const UInt_t size)
Definition PMusr.cpp:162

PNonMusrRawRunData::AppendData
virtual void AppendData(const PDoubleVector &data)
Definition PMusr.h:590

PNonMusrRawRunData::fErrData
std::vector< PDoubleVector > fErrData
vector of all data errors
Definition PMusr.h:616

PNonMusrRawRunData::FromAscii
virtual Bool_t FromAscii()
Returns true if data was loaded from ASCII file, false for db/dat format.
Definition PMusr.h:552

PNonMusrRawRunData::SetLabel
virtual void SetLabel(const UInt_t idx, const TString str)
Definition PMusr.cpp:189

PRawRunDataSet
Definition PMusr.h:631

PRawRunDataSet::GetFirstGoodBin
virtual Int_t GetFirstGoodBin()
Returns the first bin of good data range (after prompt peak)
Definition PMusr.h:647

PRawRunDataSet::GetData
virtual PDoubleVector * GetData()
Returns pointer to raw histogram data vector (counts per bin)
Definition PMusr.h:655

PRawRunDataSet::PRawRunDataSet
PRawRunDataSet()
Definition PMusr.cpp:250

PRawRunDataSet::SetLastBkgBin
virtual void SetLastBkgBin(Int_t lbb)
Definition PMusr.h:685

PRawRunDataSet::Clear
virtual void Clear()
Clears all data from this histogram set.
Definition PMusr.cpp:261

PRawRunDataSet::fLastGoodBin
Int_t fLastGoodBin
keeps the last good bin of the data set
Definition PMusr.h:697

PRawRunDataSet::SetLastGoodBin
virtual void SetLastGoodBin(Int_t lgb)
Definition PMusr.h:679

PRawRunDataSet::GetTimeZeroBin
virtual Double_t GetTimeZeroBin()
Returns the time-zero bin (t0) position.
Definition PMusr.h:643

PRawRunDataSet::SetHistoNo
virtual void SetHistoNo(Int_t no)
Definition PMusr.h:667

PRawRunDataSet::SetData
virtual void SetData(PDoubleVector data)
Definition PMusr.h:688

PRawRunDataSet::fFirstBkgBin
Int_t fFirstBkgBin
keeps the first background bin of the data set
Definition PMusr.h:698

PRawRunDataSet::GetHistoNo
virtual Int_t GetHistoNo()
Returns the histogram number as stored in the data file.
Definition PMusr.h:641

PRawRunDataSet::fTimeZeroBin
Double_t fTimeZeroBin
keeps the time zero bin
Definition PMusr.h:694

PRawRunDataSet::~PRawRunDataSet
virtual ~PRawRunDataSet()
Definition PMusr.h:634

PRawRunDataSet::fTitle
TString fTitle
histogram title.
Definition PMusr.h:691

PRawRunDataSet::GetLastBkgBin
virtual Int_t GetLastBkgBin()
Returns the last bin of background range.
Definition PMusr.h:653

PRawRunDataSet::GetName
virtual TString GetName()
Returns the histogram name.
Definition PMusr.h:639

PRawRunDataSet::SetName
virtual void SetName(TString str)
Definition PMusr.h:664

PRawRunDataSet::GetLastGoodBin
virtual Int_t GetLastGoodBin()
Returns the last bin of good data range.
Definition PMusr.h:649

PRawRunDataSet::SetTimeZeroBinEstimated
virtual void SetTimeZeroBinEstimated(Double_t tzb)
Definition PMusr.h:673

PRawRunDataSet::SetFirstBkgBin
virtual void SetFirstBkgBin(Int_t fbb)
Definition PMusr.h:682

PRawRunDataSet::SetTitle
virtual void SetTitle(TString str)
Definition PMusr.h:661

PRawRunDataSet::fData
PDoubleVector fData
keeps the histogram data
Definition PMusr.h:700

PRawRunDataSet::GetTimeZeroBinEstimated
virtual Double_t GetTimeZeroBinEstimated()
Returns the estimated time-zero bin from automatic determination.
Definition PMusr.h:645

PRawRunDataSet::fLastBkgBin
Int_t fLastBkgBin
keeps the last background bin of the data set
Definition PMusr.h:699

PRawRunDataSet::SetTimeZeroBin
virtual void SetTimeZeroBin(Double_t tzb)
Definition PMusr.h:670

PRawRunDataSet::fHistoNo
Int_t fHistoNo
corresponds to the histogram number in the data file
Definition PMusr.h:693

PRawRunDataSet::fFirstGoodBin
Int_t fFirstGoodBin
keeps the first good bin of the data set
Definition PMusr.h:696

PRawRunDataSet::GetTitle
virtual TString GetTitle()
Returns the histogram title string.
Definition PMusr.h:637

PRawRunDataSet::fTimeZeroBinEstimated
Double_t fTimeZeroBinEstimated
keeps the estimated time zero bin
Definition PMusr.h:695

PRawRunDataSet::GetFirstBkgBin
virtual Int_t GetFirstBkgBin()
Returns the first bin of background range.
Definition PMusr.h:651

PRawRunDataSet::SetFirstGoodBin
virtual void SetFirstGoodBin(Int_t fgb)
Definition PMusr.h:676

PRawRunDataSet::fName
TString fName
keeps the histogram name.
Definition PMusr.h:692

PRawRunDataVector
Definition PMusr.h:715

PRawRunDataVector::Size
virtual UInt_t Size()
Returns the number of histogram data sets in this vector.
Definition PMusr.h:721

PRawRunDataVector::GetSet
virtual PRawRunDataSet * GetSet(UInt_t idx)
Definition PMusr.cpp:319

PRawRunDataVector::Get
virtual PRawRunDataSet * Get(UInt_t histoNo)
Definition PMusr.cpp:341

PRawRunDataVector::~PRawRunDataVector
virtual ~PRawRunDataVector()
Definition PMusr.h:718

PRawRunDataVector::GetT0BinEstimated
virtual Double_t GetT0BinEstimated(UInt_t histoNo)
Definition PMusr.cpp:436

PRawRunDataVector::fDataVec
std::vector< PRawRunDataSet > fDataVec
Definition PMusr.h:804

PRawRunDataVector::GetGoodDataBin
virtual PIntPair GetGoodDataBin(UInt_t histoNo)
Definition PMusr.cpp:489

PRawRunDataVector::GetT0Bin
virtual Double_t GetT0Bin(UInt_t histoNo)
Definition PMusr.cpp:410

PRawRunDataVector::PRawRunDataVector
PRawRunDataVector()
Definition PMusr.h:717

PRawRunDataVector::operator[]
virtual PRawRunDataSet * operator[](UInt_t histoNo)
Definition PMusr.cpp:367

PRawRunDataVector::GetData
virtual PDoubleVector * GetData(UInt_t histoNo)
Definition PMusr.cpp:384

PRawRunDataVector::IsPresent
virtual Bool_t IsPresent(UInt_t histoNo)
Definition PMusr.cpp:291

PRawRunDataVector::GetBkgBin
virtual PIntPair GetBkgBin(UInt_t histoNo)
Definition PMusr.cpp:462

PRawRunDataVector::Set
virtual void Set(PRawRunDataSet dataSet, Int_t idx=-1)
Definition PMusr.cpp:515

PRawRunData::GetSpecificValidatorUrl
virtual const TString * GetSpecificValidatorUrl()
Definition PMusr.h:832

PRawRunData::fRunTitle
TString fRunTitle
run title
Definition PMusr.h:941

PRawRunData::SetStopDate
virtual void SetStopDate(const TString str)
Definition PMusr.h:904

PRawRunData::PRawRunData
PRawRunData()
Definition PMusr.cpp:536

PRawRunData::GetTransport
virtual const Double_t GetTransport()
Definition PMusr.h:865

PRawRunData::GetDataSet
virtual PRawRunDataSet * GetDataSet(const UInt_t idx, Bool_t wantHistoNo=true)
Definition PMusr.cpp:716

PRawRunData::fMuonBeamMomentum
Double_t fMuonBeamMomentum
given in MeV/c, for LEM this is the momentum of the secondary beamline and NOT the momentum of the lo...
Definition PMusr.h:937

PRawRunData::fVersion
TString fVersion
keeps the version information of the data file
Definition PMusr.h:926

PRawRunData::fSetup
TString fSetup
description of the setup of this run
Definition PMusr.h:942

PRawRunData::fStartTime
TString fStartTime
start time of the run
Definition PMusr.h:943

PRawRunData::SetRingAnode
virtual void SetRingAnode(const UInt_t idx, const Double_t dval)
Definition PMusr.cpp:750

PRawRunData::fRunNumber
Int_t fRunNumber
run number
Definition PMusr.h:940

PRawRunData::fDataNonMusr
PNonMusrRawRunData fDataNonMusr
keeps all ascii- or db-file info in case of nonMusr fit
Definition PMusr.h:923

PRawRunData::SetGenerator
virtual void SetGenerator(const TString &str)
Definition PMusr.h:886

PRawRunData::GetDataBin
virtual const PDoubleVector * GetDataBin(const UInt_t histoNo)
Definition PMusr.h:880

PRawRunData::GetNumberOfGoodFrames
virtual const Int_t GetNumberOfGoodFrames()
Definition PMusr.h:876

PRawRunData::GetT0Bin
virtual const Double_t GetT0Bin(const UInt_t histoNo)
Definition PMusr.h:870

PRawRunData::GetTimeResolution
virtual const Double_t GetTimeResolution()
Definition PMusr.h:868

PRawRunData::GetStartDate
virtual const TString * GetStartDate()
Definition PMusr.h:848

PRawRunData::SetMuonSource
virtual void SetMuonSource(const TString &str)
Definition PMusr.h:892

PRawRunData::fStartDate
TString fStartDate
start date of the run
Definition PMusr.h:944

PRawRunData::GetBeamline
virtual const TString * GetBeamline()
Definition PMusr.h:837

PRawRunData::SetTimeResolution
virtual void SetTimeResolution(const Double_t dval)
Definition PMusr.h:917

PRawRunData::fFileName
TString fFileName
keeps the name of the original data file
Definition PMusr.h:931

PRawRunData::GetMuonSpinAngle
virtual const Double_t GetMuonSpinAngle()
Definition PMusr.h:843

PRawRunData::GetSample
virtual const TString * GetSample()
Definition PMusr.h:856

PRawRunData::GetDataNonMusr
virtual const PNonMusrRawRunData * GetDataNonMusr()
Definition PMusr.h:881

PRawRunData::GetMagnetName
virtual const TString * GetMagnetName()
Definition PMusr.h:858

PRawRunData::SetSample
virtual void SetSample(const TString str)
Definition PMusr.h:909

PRawRunData::GetVersion
virtual const TString * GetVersion()
Definition PMusr.h:830

PRawRunData::SetVersion
virtual void SetVersion(const TString &str)
Definition PMusr.h:883

PRawRunData::SetEnergy
virtual void SetEnergy(const Double_t dval)
Definition PMusr.h:914

PRawRunData::SetStartDate
virtual void SetStartDate(const TString str)
Definition PMusr.h:901

PRawRunData::SetTransport
virtual void SetTransport(const Double_t dval)
Definition PMusr.h:915

PRawRunData::fData
PRawRunDataVector fData
keeps the histos together with the histo related properties such as T0, first good bin,...
Definition PMusr.h:963

PRawRunData::fStopDateTimeSec
time_t fStopDateTimeSec
stop run given as time_t object
Definition PMusr.h:948

PRawRunData::SetRunName
virtual void SetRunName(const TString &str)
Definition PMusr.h:896

PRawRunData::SetOrientation
virtual void SetOrientation(const TString str)
Definition PMusr.h:910

PRawRunData::GetStopDateTime
virtual const time_t GetStopDateTime()
Definition PMusr.h:853

PRawRunData::GetOrientation
virtual const TString * GetOrientation()
Definition PMusr.h:857

PRawRunData::GetMuonBeamMomentum
virtual const Double_t GetMuonBeamMomentum()
Definition PMusr.h:842

PRawRunData::SetRedGreenOffset
virtual void SetRedGreenOffset(PIntVector &ivec)
Definition PMusr.h:918

PRawRunData::GetLaboratory
virtual const TString * GetLaboratory()
Definition PMusr.h:836

PRawRunData::fStopTime
TString fStopTime
stop time of the run
Definition PMusr.h:946

PRawRunData::fSample
TString fSample
description of the sample
Definition PMusr.h:950

PRawRunData::GetBkgBin
virtual const PIntPair GetBkgBin(const UInt_t histoNo)
Definition PMusr.h:872

PRawRunData::SetSetup
virtual void SetSetup(const TString str)
Definition PMusr.h:899

PRawRunData::GetInstrument
virtual const TString * GetInstrument()
Definition PMusr.h:838

PRawRunData::GetStartTime
virtual const TString * GetStartTime()
Definition PMusr.h:847

PRawRunData::GetRingAnode
virtual const PDoubleVector GetRingAnode()
Definition PMusr.h:866

PRawRunData::SetStopTime
virtual void SetStopTime(const TString str)
Definition PMusr.h:903

PRawRunData::fComment
TString fComment
keeps the data file comment
Definition PMusr.h:930

PRawRunData::IsPresent
virtual const Bool_t IsPresent(UInt_t histoNo)
Definition PMusr.h:869

PRawRunData::GetTempError
virtual const Double_t GetTempError(const UInt_t idx)
Definition PMusr.cpp:671

PRawRunData::fBeamline
TString fBeamline
keeps the name of the be beamline, e.g. muE4, piM3.1, ...
Definition PMusr.h:933

PRawRunData::fTemp
PDoublePairVector fTemp
measured temperatures and standard deviations during the run
Definition PMusr.h:954

PRawRunData::fRedGreenOffset
PIntVector fRedGreenOffset
keeps the Red/Green offsets
Definition PMusr.h:959

PRawRunData::SetSpecificValidatorUrl
virtual void SetSpecificValidatorUrl(const TString &str)
Definition PMusr.h:885

PRawRunData::GetNoOfTemperatures
virtual const UInt_t GetNoOfTemperatures()
Definition PMusr.h:860

PRawRunData::GetStopTime
virtual const TString * GetStopTime()
Definition PMusr.h:851

PRawRunData::fMagnet
TString fMagnet
name of the sample magnet
Definition PMusr.h:952

PRawRunData::DeadTimeCorrectionReady
virtual const Bool_t DeadTimeCorrectionReady()
Definition PMusr.cpp:734

PRawRunData::fRunName
TString fRunName
name of the run as found in the msr-file
Definition PMusr.h:939

PRawRunData::SetStopDateTime
virtual void SetStopDateTime(const time_t val)
Definition PMusr.h:905

PRawRunData::SetRunTitle
virtual void SetRunTitle(const TString str)
Definition PMusr.h:898

PRawRunData::SetMuonSpinAngle
virtual void SetMuonSpinAngle(const Double_t dval)
Definition PMusr.h:895

PRawRunData::fNumberOfGoodFrames
Int_t fNumberOfGoodFrames
needed to correct dead times at pulsed sources
Definition PMusr.h:961

PRawRunData::SetTemperature
virtual void SetTemperature(const UInt_t idx, const Double_t temp, const Double_t errTemp)
Definition PMusr.cpp:767

PRawRunData::CalcStopDateTime
virtual const time_t CalcStopDateTime(bool &ok)
Definition PMusr.cpp:621

PRawRunData::~PRawRunData
virtual ~PRawRunData()
Definition PMusr.cpp:578

PRawRunData::SetCryoName
virtual void SetCryoName(const TString str)
Definition PMusr.h:908

PRawRunData::fEnergy
Double_t fEnergy
implantation energy of the muon
Definition PMusr.h:955

PRawRunData::fGenericValidatorURL
TString fGenericValidatorURL
keeps the generic validator MusrRoot URL
Definition PMusr.h:927

PRawRunData::SetFileName
virtual void SetFileName(const TString &str)
Definition PMusr.h:888

PRawRunData::SetComment
virtual void SetComment(const TString &str)
Definition PMusr.h:887

PRawRunData::SetMuonSpecies
virtual void SetMuonSpecies(const TString &str)
Definition PMusr.h:893

PRawRunData::fGenerator
TString fGenerator
keeps the data file generator name
Definition PMusr.h:929

PRawRunData::GetStartDateTime
virtual const time_t GetStartDateTime()
Definition PMusr.h:849

PRawRunData::fField
Double_t fField
magnetic field value in (G)
Definition PMusr.h:953

PRawRunData::fStartDateTimeSec
time_t fStartDateTimeSec
start run given as time_t object
Definition PMusr.h:945

PRawRunData::GetField
virtual const Double_t GetField()
Definition PMusr.h:859

PRawRunData::GetRunTitle
virtual const TString * GetRunTitle()
Definition PMusr.h:845

PRawRunData::GetEnergy
virtual const Double_t GetEnergy()
Definition PMusr.h:864

PRawRunData::SetBeamline
virtual void SetBeamline(const TString &str)
Definition PMusr.h:890

PRawRunData::SetTempError
virtual void SetTempError(const UInt_t idx, const Double_t errTemp)
Definition PMusr.cpp:785

PRawRunData::SetNumberOfGoodFrames
virtual void SetNumberOfGoodFrames(Int_t ival)
Definition PMusr.h:919

PRawRunData::GetMuonSpecies
virtual const TString * GetMuonSpecies()
Definition PMusr.h:841

PRawRunData::GetGenerator
virtual const TString * GetGenerator()
Definition PMusr.h:833

PRawRunData::GetComment
virtual const TString * GetComment()
Definition PMusr.h:834

PRawRunData::fDeadTimeParam
std::vector< float > fDeadTimeParam
dead time parameter vector needed for pulsed sources
Definition PMusr.h:960

PRawRunData::GetFileName
virtual const TString * GetFileName()
Definition PMusr.h:835

PRawRunData::fTimeResolution
Double_t fTimeResolution
time resolution of the run in (ns)
Definition PMusr.h:958

PRawRunData::SetRunNumber
virtual void SetRunNumber(const Int_t &val)
Definition PMusr.h:897

PRawRunData::ClearTemperature
virtual void ClearTemperature()
Definition PMusr.h:911

PRawRunData::SetMuonBeamMomentum
virtual void SetMuonBeamMomentum(const Double_t dval)
Definition PMusr.h:894

PRawRunData::GetSetup
virtual const TString * GetSetup()
Definition PMusr.h:846

PRawRunData::SetInstrument
virtual void SetInstrument(const TString &str)
Definition PMusr.h:891

PRawRunData::GetRedGreenOffset
virtual const PIntVector GetRedGreenOffset()
Definition PMusr.h:874

PRawRunData::fTransport
Double_t fTransport
LEM transport settings (Moderator HV)
Definition PMusr.h:956

PRawRunData::fCryo
TString fCryo
name of the cryo
Definition PMusr.h:949

PRawRunData::GetMuonSource
virtual const TString * GetMuonSource()
Definition PMusr.h:840

PRawRunData::fMuonSource
TString fMuonSource
keeps the type of muon source, e.g. continous surface beam, pulsed beam, low energy muon beam
Definition PMusr.h:935

PRawRunData::GetStopDate
virtual const TString * GetStopDate()
Definition PMusr.h:852

PRawRunData::GetRunNumber
virtual const Int_t GetRunNumber()
Definition PMusr.h:844

PRawRunData::SetStartDateTime
virtual void SetStartDateTime(const time_t val)
Definition PMusr.h:902

PRawRunData::SetField
virtual void SetField(const Double_t dval)
Definition PMusr.h:907

PRawRunData::GetRunName
virtual const TString * GetRunName()
Definition PMusr.h:839

PRawRunData::SetStartTime
virtual void SetStartTime(const TString str)
Definition PMusr.h:900

PRawRunData::fMuonSpinAngle
Double_t fMuonSpinAngle
gives the muon spin angle in degrees (reference frame depends on the instrument)
Definition PMusr.h:938

PRawRunData::GetNoOfHistos
virtual const UInt_t GetNoOfHistos()
Definition PMusr.h:878

PRawRunData::GetDeadTimeParam
virtual const std::vector< float > GetDeadTimeParam()
Definition PMusr.h:877

PRawRunData::GetCryoName
virtual const TString * GetCryoName()
Definition PMusr.h:855

PRawRunData::SetLaboratory
virtual void SetLaboratory(const TString &str)
Definition PMusr.h:889

PRawRunData::GetT0BinEstimated
virtual const Double_t GetT0BinEstimated(const UInt_t histoNo)
Definition PMusr.h:871

PRawRunData::fMuonSpecies
TString fMuonSpecies
positive muon or negative muon
Definition PMusr.h:936

PRawRunData::GetTemperature
virtual const PDoublePairVector * GetTemperature() const
Definition PMusr.h:861

PRawRunData::GetGoodDataBin
virtual const PIntPair GetGoodDataBin(const UInt_t histoNo)
Definition PMusr.h:873

PRawRunData::fRingAnode
PDoubleVector fRingAnode
LEM ring anode HVs (L,R[,T,B])
Definition PMusr.h:957

PRawRunData::fInstrument
TString fInstrument
keeps the name of the instrument, e.g. LEM, GPS, MUSR, EMU, ...
Definition PMusr.h:934

PRawRunData::SetMagnetName
virtual void SetMagnetName(const TString str)
Definition PMusr.h:906

PRawRunData::SetDataSet
virtual void SetDataSet(PRawRunDataSet &dataSet, UInt_t idx=-1)
Definition PMusr.h:921

PRawRunData::fLaboratory
TString fLaboratory
keeps the name of the laboratory, e.g. PSI, ISIS, TRIUMF, JPARC
Definition PMusr.h:932

PRawRunData::GetGenericValidatorUrl
virtual const TString * GetGenericValidatorUrl()
Definition PMusr.h:831

PRawRunData::fStopDate
TString fStopDate
stop date of the run
Definition PMusr.h:947

PRawRunData::CalcStartDateTime
virtual const time_t CalcStartDateTime(bool &ok)
Definition PMusr.cpp:595

PRawRunData::SetDeadTimeParam
virtual void SetDeadTimeParam(std::vector< float > dvec)
Definition PMusr.h:920

PRawRunData::fSpecificValidatorURL
TString fSpecificValidatorURL
keeps the instrument specific validator MusrRoot URL
Definition PMusr.h:928

PRawRunData::SetGenericValidatorUrl
virtual void SetGenericValidatorUrl(const TString &str)
Definition PMusr.h:884

PRawRunData::fOrientation
TString fOrientation
description of the orientation
Definition PMusr.h:951

PRunData::SetDataTimeStep
virtual void SetDataTimeStep(Double_t dval)
Definition PMusr.h:481

PRunData::GetX
virtual const PDoubleVector * GetX()
Returns pointer to x-axis vector (used only for non-μSR data)
Definition PMusr.h:466

PRunData::AppendErrorValue
virtual void AppendErrorValue(Double_t dval)
Definition PMusr.h:497

PRunData::AppendValue
virtual void AppendValue(Double_t dval)
Definition PMusr.h:494

PRunData::SetDataTimeStart
virtual void SetDataTimeStart(Double_t dval)
Definition PMusr.h:478

PRunData::GetTheoryTimeStart
virtual Double_t GetTheoryTimeStart()
Returns the start time for theory evaluation in microseconds (μs)
Definition PMusr.h:461

PRunData::GetValue
virtual const PDoubleVector * GetValue()
Returns pointer to data value vector (asymmetry, counts, or y-data)
Definition PMusr.h:468

PRunData::fTheoryTimeStep
Double_t fTheoryTimeStep
time step of the theory, i.e. the time length of a bin
Definition PMusr.h:529

PRunData::GetTheory
virtual const PDoubleVector * GetTheory()
Returns pointer to theory value vector.
Definition PMusr.h:474

PRunData::GetDataTimeStep
virtual Double_t GetDataTimeStep()
Returns the time bin width for data in microseconds (μs)
Definition PMusr.h:459

PRunData::GetTheoryTimeStep
virtual Double_t GetTheoryTimeStep()
Returns the time step for theory evaluation in microseconds (μs)
Definition PMusr.h:463

PRunData::fTheoryTimeStart
Double_t fTheoryTimeStart
start time of the theory
Definition PMusr.h:528

PRunData::fXTheory
PDoubleVector fXTheory
x-axis vector. Only used for non-muSR
Definition PMusr.h:530

PRunData::SetTheoryTimeStart
virtual void SetTheoryTimeStart(Double_t dval)
Definition PMusr.h:484

PRunData::GetError
virtual const PDoubleVector * GetError()
Returns pointer to data error vector (statistical uncertainties)
Definition PMusr.h:470

PRunData::~PRunData
virtual ~PRunData()
Definition PMusr.cpp:69

PRunData::AppendXTheoryValue
virtual void AppendXTheoryValue(Double_t dval)
Definition PMusr.h:500

PRunData::GetDataTimeStart
virtual Double_t GetDataTimeStart()
Returns the start time of the data set in microseconds (μs)
Definition PMusr.h:457

PRunData::fX
PDoubleVector fX
x-axis vector. Only used for non-muSR
Definition PMusr.h:524

PRunData::GetXTheory
virtual const PDoubleVector * GetXTheory()
Returns pointer to x-axis vector for theory (non-μSR only)
Definition PMusr.h:472

PRunData::fValue
PDoubleVector fValue
data vector
Definition PMusr.h:525

PRunData::fDataTimeStart
Double_t fDataTimeStart
start time for the data set
Definition PMusr.h:522

PRunData::AppendXValue
virtual void AppendXValue(Double_t dval)
Definition PMusr.h:491

PRunData::PRunData
PRunData()
Definition PMusr.cpp:50

PRunData::fTheory
PDoubleVector fTheory
theory vector
Definition PMusr.h:531

PRunData::ReplaceTheory
virtual void ReplaceTheory(const PDoubleVector &theo)
Definition PMusr.cpp:103

PRunData::fError
PDoubleVector fError
data error vector
Definition PMusr.h:526

PRunData::fDataTimeStep
Double_t fDataTimeStep
time step for the data set, i.e. the time length of a bin
Definition PMusr.h:523

PRunData::SetTheoryTimeStep
virtual void SetTheoryTimeStep(Double_t dval)
Definition PMusr.h:487

PRunData::AppendTheoryValue
virtual void AppendTheoryValue(Double_t dval)
Definition PMusr.h:503

PRunData::SetTheoryValue
virtual void SetTheoryValue(UInt_t i, Double_t dval)
Definition PMusr.cpp:87

PStringNumberList::PStringNumberList
PStringNumberList(std::string str)
Definition PMusr.h:1407

PStringNumberList::~PStringNumberList
virtual ~PStringNumberList()
Definition PMusr.h:1409

PStringNumberList::GetList
virtual PUIntVector GetList()
Definition PMusr.h:1422

PStringNumberList::fString
std::string fString
Definition PMusr.h:1425

PStringNumberList::StripSpaces
virtual void StripSpaces()
Definition PMusr.cpp:2119

PStringNumberList::fList
PUIntVector fList
Definition PMusr.h:1427

PStringNumberList::PStringNumberList
PStringNumberList(char *str)
Definition PMusr.h:1403

PStringNumberList::fIsValid
bool fIsValid
Definition PMusr.h:1426

PStringNumberList::IsNumber
virtual bool IsNumber(std::string &str)
Definition PMusr.h:1429

PStringNumberList::Parse
virtual bool Parse(std::string &errorMsg, bool ignoreFirstToken=false)
Definition PMusr.cpp:2007

PAny2ManyInfo
Definition PMusr.h:1351

PAny2ManyInfo::inTemplate
TString inTemplate
holds the input file template
Definition PMusr.h:1355

PAny2ManyInfo::outPathFileName
PStringVector outPathFileName
holds the out path/file name
Definition PMusr.h:1362

PAny2ManyInfo::outPath
TString outPath
holds the output path
Definition PMusr.h:1363

PAny2ManyInfo::idf
UInt_t idf
IDF version for NeXus files.
Definition PMusr.h:1367

PAny2ManyInfo::outFileName
TString outFileName
holds the output file name
Definition PMusr.h:1361

PAny2ManyInfo::runList
PUIntVector runList
holds the run number list to be converted
Definition PMusr.h:1358

PAny2ManyInfo::inFileName
PStringVector inFileName
holds the file name of the input data file
Definition PMusr.h:1360

PAny2ManyInfo::compressionTag
UInt_t compressionTag
0=no compression, 1=gzip compression, 2=bzip2 compression
Definition PMusr.h:1365

PAny2ManyInfo::outTemplate
TString outTemplate
holds the output file template
Definition PMusr.h:1356

PAny2ManyInfo::groupHistoList
PIntVector groupHistoList
holds the histo group list offset (used to define for MusrRoot files, what to be exported)
Definition PMusr.h:1359

PAny2ManyInfo::outFormat
TString outFormat
holds the information about the output data file format
Definition PMusr.h:1354

PAny2ManyInfo::inFormat
TString inFormat
holds the information about the input data file format
Definition PMusr.h:1353

PAny2ManyInfo::useStandardOutput
Bool_t useStandardOutput
flag showing if the converted shall be sent to the standard output
Definition PMusr.h:1352

PAny2ManyInfo::rebin
UInt_t rebin
holds the number of bins to be packed
Definition PMusr.h:1364

PAny2ManyInfo::year
TString year
holds the information about the year to be used
Definition PMusr.h:1357

PAny2ManyInfo::compressFileName
TString compressFileName
holds the name of the outputfile name in case of compression is used
Definition PMusr.h:1366

PMetaData
Definition PMusr.h:431

PMetaData::fTemp
PDoubleVector fTemp
Vector of sample temperature(s) in Kelvin (K)
Definition PMusr.h:434

PMetaData::fEnergy
Double_t fEnergy
Muon implantation energy in kiloelectronvolts (keV)
Definition PMusr.h:433

PMetaData::fField
Double_t fField
Applied magnetic field in Gauss (G)
Definition PMusr.h:432

PMsrFourierStructure
Definition PMusr.h:1260

PMsrFourierStructure::fPlotTag
Int_t fPlotTag
tag used for initial plot. 0=real, 1=imaginary, 2=real & imaginary (default), 3=power,...
Definition PMusr.h:1266

PMsrFourierStructure::fFourierBlockPresent
Bool_t fFourierBlockPresent
flag indicating if a Fourier block is present in the msr-file
Definition PMusr.h:1261

PMsrFourierStructure::fPlotRange
Double_t fPlotRange[2]
field/frequency plot range
Definition PMusr.h:1271

PMsrFourierStructure::fPhase
PDoubleVector fPhase
phase(s)
Definition PMusr.h:1269

PMsrFourierStructure::fRangeForPhaseCorrection
Double_t fRangeForPhaseCorrection[2]
field/frequency range for automatic phase correction
Definition PMusr.h:1270

PMsrFourierStructure::fPhaseParamNo
PIntVector fPhaseParamNo
parameter number(s) if used instead of a phase value
Definition PMusr.h:1268

PMsrFourierStructure::fFourierPower
Int_t fFourierPower
i.e. zero padding up to 2^fFourierPower, default = 0 which means NO zero padding
Definition PMusr.h:1264

PMsrFourierStructure::fUnits
Int_t fUnits
flag used to indicate the units. 1=field units (G); 2=field units (T); 3=frequency units (MHz); 4=Mc/...
Definition PMusr.h:1262

PMsrFourierStructure::fPhaseIncrement
Double_t fPhaseIncrement
phase increment for manual phase optimization
Definition PMusr.h:1272

PMsrFourierStructure::fPhaseRef
Int_t fPhaseRef
phase reference for relative phase(s)
Definition PMusr.h:1267

PMsrFourierStructure::fDCCorrected
Bool_t fDCCorrected
if set true, the dc offset of the signal/theory will be removed before the FFT is made.
Definition PMusr.h:1263

PMsrFourierStructure::fApodization
Int_t fApodization
tag indicating the kind of apodization wished, 0=no appodization (default), 1=weak,...
Definition PMusr.h:1265

PMsrLineStructure
Definition PMusr.h:980

PMsrLineStructure::fLineNo
Int_t fLineNo
Line number in original MSR file (1-based)
Definition PMusr.h:981

PMsrLineStructure::fLine
TString fLine
Content of the MSR file line.
Definition PMusr.h:982

PMsrParamStructure
Definition PMusr.h:1003

PMsrParamStructure::fStep
Double_t fStep
Step size / error / negative error (context-dependent)
Definition PMusr.h:1008

PMsrParamStructure::fPosError
Double_t fPosError
Positive error for asymmetric uncertainties.
Definition PMusr.h:1010

PMsrParamStructure::fLowerBoundaryPresent
Bool_t fLowerBoundaryPresent
True if lower bound constraint is active.
Definition PMusr.h:1011

PMsrParamStructure::fNoOfParams
Int_t fNoOfParams
Total number of parameters in FITPARAMETER block.
Definition PMusr.h:1004

PMsrParamStructure::fLowerBoundary
Double_t fLowerBoundary
Lower boundary value for parameter constraints.
Definition PMusr.h:1012

PMsrParamStructure::fNo
Int_t fNo
Parameter number (1, 2, 3, ...)
Definition PMusr.h:1005

PMsrParamStructure::fUpperBoundary
Double_t fUpperBoundary
Upper boundary value for parameter constraints.
Definition PMusr.h:1014

PMsrParamStructure::fPosErrorPresent
Bool_t fPosErrorPresent
True if positive error explicitly defined (asymmetric errors)
Definition PMusr.h:1009

PMsrParamStructure::fUpperBoundaryPresent
Bool_t fUpperBoundaryPresent
True if upper bound constraint is active.
Definition PMusr.h:1013

PMsrParamStructure::fIsGlobal
Bool_t fIsGlobal
True if parameter is global (for msr2data global mode)
Definition PMusr.h:1015

PMsrParamStructure::fValue
Double_t fValue
Parameter value (initial or fitted)
Definition PMusr.h:1007

PMsrParamStructure::fName
TString fName
Parameter name (e.g., "alpha", "lambda", "field")
Definition PMusr.h:1006

PMsrPlotStructure
Definition PMusr.h:1289

PMsrPlotStructure::fUseFitRanges
Bool_t fUseFitRanges
yes -> use the fit ranges to plot the data, no (default) -> use range information if present
Definition PMusr.h:1292

PMsrPlotStructure::fRuns
PIntVector fRuns
list of runs to be plotted
Definition PMusr.h:1296

PMsrPlotStructure::fRRFUnit
UInt_t fRRFUnit
RRF frequency unit. 0=kHz, 1=MHz, 2=Mc/s, 3=Gauss, 4=Tesla.
Definition PMusr.h:1303

PMsrPlotStructure::fLogY
Bool_t fLogY
yes -> y-axis in log-scale, no (default) -> y-axis in lin-scale
Definition PMusr.h:1294

PMsrPlotStructure::fLogX
Bool_t fLogX
yes -> x-axis in log-scale, no (default) -> x-axis in lin-scale
Definition PMusr.h:1293

PMsrPlotStructure::fPlotType
Int_t fPlotType
plot type
Definition PMusr.h:1290

PMsrPlotStructure::fRRFPhaseParamNo
Int_t fRRFPhaseParamNo
parameter number if used instead of a RRF phase value
Definition PMusr.h:1304

PMsrPlotStructure::fRRFFreq
Double_t fRRFFreq
RRF frequency.
Definition PMusr.h:1302

PMsrPlotStructure::fYmax
PDoubleVector fYmax
asymmetry/counts maximum
Definition PMusr.h:1300

PMsrPlotStructure::fLifeTimeCorrection
Bool_t fLifeTimeCorrection
needed for single histo. If yes, only the asymmetry is shown, otherweise the positron spectrum
Definition PMusr.h:1291

PMsrPlotStructure::fViewPacking
Int_t fViewPacking
-1 -> use the run packing to generate the view, otherwise is fViewPacking for the binning of ALL runs...
Definition PMusr.h:1295

PMsrPlotStructure::fRRFPhase
Double_t fRRFPhase
RRF phase.
Definition PMusr.h:1305

PMsrPlotStructure::fRRFPacking
UInt_t fRRFPacking
rotating reference frame (RRF) packing
Definition PMusr.h:1301

PMsrPlotStructure::fYmin
PDoubleVector fYmin
asymmetry/counts minimum
Definition PMusr.h:1299

PMsrPlotStructure::fTmax
PDoubleVector fTmax
time maximum
Definition PMusr.h:1298

PMsrPlotStructure::fTmin
PDoubleVector fTmin
time minimum
Definition PMusr.h:1297

PMsrStatisticStructure
Definition PMusr.h:1326

PMsrStatisticStructure::fNdf
UInt_t fNdf
number of degrees of freedom
Definition PMusr.h:1333

PMsrStatisticStructure::fMinExpected
Double_t fMinExpected
expected total chi2 or max. likelihood
Definition PMusr.h:1334

PMsrStatisticStructure::fDate
TString fDate
string holding fitting date and time
Definition PMusr.h:1329

PMsrStatisticStructure::fStatLines
PMsrLines fStatLines
statistics block in msr-file clear text
Definition PMusr.h:1328

PMsrStatisticStructure::fMin
Double_t fMin
chisq or max. likelihood
Definition PMusr.h:1331

PMsrStatisticStructure::fNdfPerHisto
PUIntVector fNdfPerHisto
number of degrees of freedom per histo
Definition PMusr.h:1336

PMsrStatisticStructure::fMinExpectedPerHisto
PDoubleVector fMinExpectedPerHisto
expected pre histo chi2 or max. likelihood
Definition PMusr.h:1335

PMsrStatisticStructure::fMinPerHisto
PDoubleVector fMinPerHisto
chisq or max. likelihood per histo
Definition PMusr.h:1332

PMsrStatisticStructure::fChisq
Bool_t fChisq
flag telling if min = chi2 or min = max.likelihood
Definition PMusr.h:1330

PMsrStatisticStructure::fValid
Bool_t fValid
flag showing if the statistics block is valid, i.e. a fit took place which converged
Definition PMusr.h:1327

PRunNameTemplate
Definition PMusr.h:1445

PRunNameTemplate::runNameTemplate
TString runNameTemplate
File path template with placeholders (r=run, y=year)
Definition PMusr.h:1447

PRunNameTemplate::instrument
TString instrument
Instrument identifier (e.g., "GPS", "LEM", "DOLLY")
Definition PMusr.h:1446

PStartupOptions
Definition PMusr.h:1378

PStartupOptions::writeExpectedChisq
Bool_t writeExpectedChisq
if set to true, expected chisq and chisq per block will be written
Definition PMusr.h:1379

PStartupOptions::estimateN0
Bool_t estimateN0
if set to true, for single histogram fits N0 will be estimated
Definition PMusr.h:1380