LMU/musrfit
5
0
Fork 0
Code Issues 6 Pull Requests Actions Packages Projects Releases 4 Activity

changed variables to comply with the ROOT standards. Error messages now sent to stderr rather than stdout

Browse Source
This commit is contained in:
nemu
2009-10-30 08:29:27 +00:00
parent e14feae99d
commit 2a03bb7f61
34 changed files with 1822 additions and 1773 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
src/include/PFitter.h
View File

@ -63,20 +63,20 @@ Will handle all the possible minuit commands and actually do things ...
class PFitter
{
public:
PFitter(PMsrHandler *runInfo, PRunListCollection *runListCollection, bool chisq_only = false);
PFitter(PMsrHandler *runInfo, PRunListCollection *runListCollection, Bool_t chisq_only = false);
virtual ~PFitter();
bool IsValid() { return fIsValid; }
bool HasConverged() { return fConverged; }
bool DoFit();
Bool_t IsValid() { return fIsValid; }
Bool_t HasConverged() { return fConverged; }
Bool_t DoFit();
private:
bool fIsValid;
bool fConverged;
bool fChisqOnly;
bool fUseChi2;
Bool_t fIsValid;
Bool_t fConverged;
Bool_t fChisqOnly;
Bool_t fUseChi2;
unsigned int fStrategy;
UInt_t fStrategy;
PMsrHandler *fRunInfo;
@ -90,15 +90,15 @@ class PFitter
ROOT::Minuit2::FunctionMinimum *fFcnMin; ///< function minimum object
ROOT::Minuit2::MnUserParameterState *fMnUserParamState; ///< keeps the current user parameter state
bool CheckCommands();
bool SetParameters();
Bool_t CheckCommands();
Bool_t SetParameters();
bool ExecuteHesse();
bool ExecuteMigrad();
bool ExecuteMinimize();
bool ExecuteMinos();
bool ExecuteSave();
bool ExecuteSimplex();
Bool_t ExecuteHesse();
Bool_t ExecuteMigrad();
Bool_t ExecuteMinimize();
Bool_t ExecuteMinos();
Bool_t ExecuteSave();
Bool_t ExecuteSimplex();
};
#endif // _PFITTER_H_

12
src/include/PFitterFcn.h
View File

@ -41,17 +41,17 @@
class PFitterFcn : public ROOT::Minuit2::FCNBase
{
public:
PFitterFcn(PRunListCollection *runList, bool useChi2);
PFitterFcn(PRunListCollection *runList, Bool_t useChi2);
~PFitterFcn();
double Up() const { return fUp; }
double operator()(const std::vector<double>&) const;
Double_t Up() const { return fUp; }
Double_t operator()(const std::vector<Double_t>&) const;
unsigned int GetTotalNoOfFittedBins() { return fRunListCollection->GetTotalNoOfBinsFitted(); }
UInt_t GetTotalNoOfFittedBins() { return fRunListCollection->GetTotalNoOfBinsFitted(); }
private:
double fUp;
bool fUseChi2;
Double_t fUp;
Bool_t fUseChi2;
PRunListCollection *fRunListCollection;
};

44
src/include/PFourier.h
View File

@ -45,43 +45,43 @@
class PFourier
{
public:
PFourier(TH1F *data, int unitTag,
double startTime = 0.0, double endTime = 0.0,
unsigned int zeroPaddingPower = 0);
PFourier(TH1F *data, Int_t unitTag,
Double_t startTime = 0.0, Double_t endTime = 0.0,
UInt_t zeroPaddingPower = 0);
virtual ~PFourier();
virtual void Transform(unsigned int apodizationTag = 0);
virtual void Transform(UInt_t apodizationTag = 0);
virtual double GetResolution() { return fResolution; }
virtual TH1F* GetRealFourier(const double scale = 1.0);
virtual TH1F* GetImaginaryFourier(const double scale = 1.0);
virtual TH1F* GetPowerFourier(const double scale = 1.0);
virtual TH1F* GetPhaseFourier(const double scale = 1.0);
virtual Double_t GetResolution() { return fResolution; }
virtual TH1F* GetRealFourier(const Double_t scale = 1.0);
virtual TH1F* GetImaginaryFourier(const Double_t scale = 1.0);
virtual TH1F* GetPowerFourier(const Double_t scale = 1.0);
virtual TH1F* GetPhaseFourier(const Double_t scale = 1.0);
virtual bool IsValid() { return fValid; }
virtual Bool_t IsValid() { return fValid; }
private:
TH1F *fData;
bool fValid;
int fUnitTag; ///< 1=Field Units (G), 2=Frequency Units (MHz), 3=Angular Frequency Units (Mc/s)
Bool_t fValid;
Int_t fUnitTag; ///< 1=Field Units (G), 2=Frequency Units (MHz), 3=Angular Frequency Units (Mc/s)
int fApodization; ///< 0=none, 1=weak, 2=medium, 3=strong
Int_t fApodization; ///< 0=none, 1=weak, 2=medium, 3=strong
double fTimeResolution;
double fStartTime;
double fEndTime;
unsigned int fZeroPaddingPower;
double fResolution;
Double_t fTimeResolution;
Double_t fStartTime;
Double_t fEndTime;
UInt_t fZeroPaddingPower;
Double_t fResolution;
unsigned int fNoOfData;
unsigned int fNoOfBins;
UInt_t fNoOfData;
UInt_t fNoOfBins;
fftw_plan fFFTwPlan;
fftw_complex *fIn;
fftw_complex *fOut;
virtual void PrepareFFTwInputData(unsigned int apodizationTag);
virtual void ApodizeData(int apodizationTag);
virtual void PrepareFFTwInputData(UInt_t apodizationTag);
virtual void ApodizeData(Int_t apodizationTag);
};
#endif // _PFOURIER_H_

36
src/include/PFunction.h
View File

@ -65,11 +65,11 @@ using namespace boost::spirit;
//----------------------------------------------------------------------------
typedef struct func_tree_node {
int fID; ///< tag showing what tree element this is
int fOperatorTag; ///< tag for '+', '-', '*', '/'
int fFunctionTag; ///< tag got "cos", "sin", ...
int fIvalue; ///< for parameter numbers and maps
double fDvalue; ///< for numbers
Int_t fID; ///< tag showing what tree element this is
Int_t fOperatorTag; ///< tag for '+', '-', '*', '/'
Int_t fFunctionTag; ///< tag got "cos", "sin", ...
Int_t fIvalue; ///< for parameter numbers and maps
Double_t fDvalue; ///< for numbers
vector<func_tree_node> children; ///< holding sub-tree
} PFuncTreeNode;
@ -79,32 +79,32 @@ class PFunction {
PFunction(tree_parse_info<> info);
virtual ~PFunction();
virtual bool IsValid() { return fValid; }
virtual int GetFuncNo() { return fFuncNo; }
virtual bool CheckMapAndParamRange(unsigned int mapSize, unsigned int paramSize);
virtual double Eval(vector<double> param);
virtual void SetMap(vector<int> map) { fMap = map; }
virtual Bool_t IsValid() { return fValid; }
virtual Int_t GetFuncNo() { return fFuncNo; }
virtual Bool_t CheckMapAndParamRange(UInt_t mapSize, UInt_t paramSize);
virtual Double_t Eval(vector<Double_t> param);
virtual void SetMap(vector<Int_t> map) { fMap = map; }
virtual TString* GetFuncString() { return &fFuncString; }
protected:
virtual bool SetFuncNo();
virtual Bool_t SetFuncNo();
virtual bool FindAndCheckMapAndParamRange(PFuncTreeNode &node, unsigned int mapSize, unsigned int paramSize);
virtual bool GenerateFuncEvalTree();
virtual Bool_t FindAndCheckMapAndParamRange(PFuncTreeNode &node, UInt_t mapSize, UInt_t paramSize);
virtual Bool_t GenerateFuncEvalTree();
virtual void FillFuncEvalTree(iter_t const& i, PFuncTreeNode &node);
virtual double EvalNode(PFuncTreeNode &node);
virtual Double_t EvalNode(PFuncTreeNode &node);
virtual void CleanupFuncEvalTree();
virtual void CleanupNode(PFuncTreeNode &node);
private:
tree_parse_info<> fInfo;
vector<double> fParam;
vector<int> fMap;
vector<Double_t> fParam;
vector<Int_t> fMap;
PFuncTreeNode fFunc;
bool fValid; ///< flag showing if the function is valid
int fFuncNo; ///< function number, i.e. FUNx with x the function number
Bool_t fValid; ///< flag showing if the function is valid
Int_t fFuncNo; ///< function number, i.e. FUNx with x the function number
virtual void EvalTreeForString(tree_parse_info<> info);
virtual void EvalTreeForStringExpression(iter_t const& i);

18
src/include/PFunctionHandler.h
View File

@ -48,17 +48,17 @@ class PFunctionHandler
PFunctionHandler(PMsrLines lines);
virtual ~PFunctionHandler();
virtual bool IsValid() { return fValid; }
virtual bool DoParse();
virtual bool CheckMapAndParamRange(unsigned int mapSize, unsigned int paramSize);
virtual double Eval(int funNo, vector<int> map, vector<double> param);
virtual int GetFuncNo(unsigned int idx);
virtual int GetFuncIndex(int funcNo);
virtual unsigned int GetNoOfFuncs() { return fFuncs.size(); }
virtual TString* GetFuncString(unsigned int idx);
virtual Bool_t IsValid() { return fValid; }
virtual Bool_t DoParse();
virtual Bool_t CheckMapAndParamRange(UInt_t mapSize, UInt_t paramSize);
virtual double Eval(Int_t funNo, vector<Int_t> map, vector<double> param);
virtual Int_t GetFuncNo(UInt_t idx);
virtual Int_t GetFuncIndex(Int_t funcNo);
virtual UInt_t GetNoOfFuncs() { return fFuncs.size(); }
virtual TString* GetFuncString(UInt_t idx);
private:
bool fValid;
Bool_t fValid;
PMsrLines fLines;
vector<PFunction> fFuncs;

68
src/include/PMsrHandler.h
View File

@ -47,11 +47,11 @@
class PMsrHandler
{
public:
PMsrHandler(const char *fileName);
PMsrHandler(const Char_t *fileName);
virtual ~PMsrHandler();
virtual int ReadMsrFile();
virtual int WriteMsrLogFile(const bool messages = true);
virtual Int_t ReadMsrFile();
virtual Int_t WriteMsrLogFile(const Bool_t messages = true);
virtual TString* GetMsrTitle() { return &fTitle; }
virtual PMsrParamList* GetMsrParamList() { return &fParam; }
@ -65,37 +65,37 @@ class PMsrHandler
virtual TString* GetMsrFileDirectoryPath() { return &fMsrFileDirectoryPath; }
virtual unsigned int GetNoOfParams() { return fParam.size(); }
virtual UInt_t GetNoOfParams() { return fParam.size(); }
virtual const TString& GetFileName() const { return fFileName; }
virtual void SetMsrTitle(const TString &title) { fTitle = title; }
virtual bool SetMsrParamValue(unsigned int i, double value);
virtual bool SetMsrParamStep(unsigned int i, double value);
virtual bool SetMsrParamPosErrorPresent(unsigned int i, bool value);
virtual bool SetMsrParamPosError(unsigned int i, double value);
virtual Bool_t SetMsrParamValue(UInt_t i, Double_t value);
virtual Bool_t SetMsrParamStep(UInt_t i, Double_t value);
virtual Bool_t SetMsrParamPosErrorPresent(UInt_t i, Bool_t value);
virtual Bool_t SetMsrParamPosError(UInt_t i, Double_t value);
virtual void SetMsrT0Entry(unsigned int runNo, unsigned int idx, int bin);
virtual void SetMsrDataRangeEntry(unsigned int runNo, unsigned int idx, int bin);
virtual void SetMsrBkgRangeEntry(unsigned int runNo, unsigned int idx, int bin);
virtual void SetMsrT0Entry(UInt_t runNo, UInt_t idx, Int_t bin);
virtual void SetMsrDataRangeEntry(UInt_t runNo, UInt_t idx, Int_t bin);
virtual void SetMsrBkgRangeEntry(UInt_t runNo, UInt_t idx, Int_t bin);
virtual void CopyMsrStatisticBlock() { fCopyStatisticsBlock = true; }
virtual void SetMsrStatisticConverged(bool converged) { fStatistic.fValid = converged; }
virtual void SetMsrStatisticMin(double min) { fStatistic.fMin = min; }
virtual void SetMsrStatisticNdf(unsigned int ndf) { fStatistic.fNdf = ndf; }
virtual void SetMsrStatisticConverged(Bool_t converged) { fStatistic.fValid = converged; }
virtual void SetMsrStatisticMin(Double_t min) { fStatistic.fMin = min; }
virtual void SetMsrStatisticNdf(UInt_t ndf) { fStatistic.fNdf = ndf; }
virtual int GetNoOfFuncs() { return fFuncHandler->GetNoOfFuncs(); }
virtual unsigned int GetFuncNo(int idx) { return fFuncHandler->GetFuncNo(idx); }
virtual unsigned int GetFuncIndex(int funNo) { return fFuncHandler->GetFuncIndex(funNo); }
virtual bool CheckMapAndParamRange(unsigned int mapSize, unsigned int paramSize)
virtual Int_t GetNoOfFuncs() { return fFuncHandler->GetNoOfFuncs(); }
virtual UInt_t GetFuncNo(Int_t idx) { return fFuncHandler->GetFuncNo(idx); }
virtual UInt_t GetFuncIndex(Int_t funNo) { return fFuncHandler->GetFuncIndex(funNo); }
virtual Bool_t CheckMapAndParamRange(UInt_t mapSize, UInt_t paramSize)
{ return fFuncHandler->CheckMapAndParamRange(mapSize, paramSize); }
virtual double EvalFunc(unsigned int i, vector<int> map, vector<double> param)
virtual Double_t EvalFunc(UInt_t i, vector<Int_t> map, vector<Double_t> param)
{ return fFuncHandler->Eval(i,map,param); }
virtual int ParameterInUse(unsigned int paramNo);
virtual bool CheckUniquenessOfParamNames(unsigned int &parX, unsigned int &parY);
virtual bool CheckMaps();
virtual bool CheckFuncs();
virtual Int_t ParameterInUse(UInt_t paramNo);
virtual Bool_t CheckUniquenessOfParamNames(UInt_t &parX, UInt_t &parY);
virtual Bool_t CheckMaps();
virtual Bool_t CheckFuncs();
private:
TString fFileName; ///< file name of the msr-file
@ -110,29 +110,29 @@ class PMsrHandler
PMsrPlotList fPlots; ///< holds a list of the plot input parameters
PMsrStatisticStructure fStatistic; ///< holds the statistic info
int fMsrBlockCounter; ///< used to select the proper msr-block
Int_t fMsrBlockCounter; ///< used to select the proper msr-block
PFunctionHandler *fFuncHandler; ///< needed to parse functions
PIntVector fParamInUse; ///< array holding the information if a particular parameter is used at all, i.e. if the theory is using it (perhaps via maps or functions)
bool fCopyStatisticsBlock; ///< flag, if true: just copy to old statistics block (musrt0), otherwise write a new one (musrfit)
Bool_t fCopyStatisticsBlock; ///< flag, if true: just copy to old statistics block (musrt0), otherwise write a new one (musrfit)
virtual bool HandleFitParameterEntry(PMsrLines &line);
virtual bool HandleTheoryEntry(PMsrLines &line);
virtual bool HandleFunctionsEntry(PMsrLines &line);
virtual bool HandleRunEntry(PMsrLines &line);
virtual bool HandleCommandsEntry(PMsrLines &line);
virtual bool HandleFourierEntry(PMsrLines &line);
virtual bool HandlePlotEntry(PMsrLines &line);
virtual bool HandleStatisticEntry(PMsrLines &line);
virtual Bool_t HandleFitParameterEntry(PMsrLines &line);
virtual Bool_t HandleTheoryEntry(PMsrLines &line);
virtual Bool_t HandleFunctionsEntry(PMsrLines &line);
virtual Bool_t HandleRunEntry(PMsrLines &line);
virtual Bool_t HandleCommandsEntry(PMsrLines &line);
virtual Bool_t HandleFourierEntry(PMsrLines &line);
virtual Bool_t HandlePlotEntry(PMsrLines &line);
virtual Bool_t HandleStatisticEntry(PMsrLines &line);
virtual void FillParameterInUse(PMsrLines &theory, PMsrLines &funcs, PMsrLines &run);
virtual void InitRunParameterStructure(PMsrRunStructure &param);
virtual void InitFourierParameterStructure(PMsrFourierStructure &fourier);
virtual bool FilterNumber(TString str, const char *filter, int offset, int &no);
virtual Bool_t FilterNumber(TString str, const Char_t *filter, Int_t offset, Int_t &no);
};
#endif // _PMSRHANDLER_H_

24
src/include/PMusrCanvas.h
View File

@ -147,9 +147,9 @@ class PMusrCanvas : public TObject, public TQObject
{
public:
PMusrCanvas();
PMusrCanvas(const int number, const char* title,
PMusrCanvas(const Int_t number, const Char_t* title,
Int_t wtopx, Int_t wtopy, Int_t ww, Int_t wh, const Bool_t batch);
PMusrCanvas(const int number, const char* title,
PMusrCanvas(const Int_t number, const Char_t* title,
Int_t wtopx, Int_t wtopy, Int_t ww, Int_t wh,
PMsrFourierStructure fourierDefault,
const PIntVector markerList, const PIntVector colorList, const Bool_t batch);
@ -171,7 +171,7 @@ class PMusrCanvas : public TObject, public TQObject
virtual void HandleMenuPopup(Int_t id); // SLOT
virtual void LastCanvasClosed(); // SLOT
virtual void SaveGraphicsAndQuit(char *fileName, char *graphicsFormat);
virtual void SaveGraphicsAndQuit(Char_t *fileName, Char_t *graphicsFormat);
private:
Bool_t fBatchMode; /// musrview in ROOT batch mode
@ -222,27 +222,27 @@ class PMusrCanvas : public TObject, public TQObject
virtual void CreateStyle();
virtual void InitFourier();
virtual void InitMusrCanvas(const char* title, Int_t wtopx, Int_t wtopy, Int_t ww, Int_t wh);
virtual void InitMusrCanvas(const Char_t* title, Int_t wtopx, Int_t wtopy, Int_t ww, Int_t wh);
virtual void InitDataSet(PMusrCanvasDataSet &dataSet);
virtual void InitDataSet(PMusrCanvasNonMusrDataSet &dataSet);
virtual void CleanupDataSet(PMusrCanvasDataSet &dataSet);
virtual void CleanupDataSet(PMusrCanvasNonMusrDataSet &dataSet);
virtual void HandleDataSet(unsigned int plotNo, unsigned int runNo, PRunData *data);
virtual void HandleNonMusrDataSet(unsigned int plotNo, unsigned int runNo, PRunData *data);
virtual void HandleDataSet(UInt_t plotNo, UInt_t runNo, PRunData *data);
virtual void HandleNonMusrDataSet(UInt_t plotNo, UInt_t runNo, PRunData *data);
virtual void HandleDifference();
virtual void HandleFourier();
virtual void HandleFourierDifference();
virtual double FindOptimalFourierPhase();
virtual Double_t FindOptimalFourierPhase();
virtual void CleanupDifference();
virtual void CleanupFourier();
virtual void CleanupFourierDifference();
virtual double CalculateDiff(const double x, const double y, TH1F *theo);
virtual double CalculateDiff(const double x, const double y, TGraphErrors *theo);
virtual Int_t FindBin(const double x, TGraphErrors *graph);
virtual Double_t CalculateDiff(const Double_t x, const Double_t y, TH1F *theo);
virtual Double_t CalculateDiff(const Double_t x, const Double_t y, TGraphErrors *theo);
virtual Int_t FindBin(const Double_t x, TGraphErrors *graph);
virtual double GetGlobalMaximum(TH1F* histo);
virtual double GetGlobalMinimum(TH1F* histo);
virtual Double_t GetGlobalMaximum(TH1F* histo);
virtual Double_t GetGlobalMinimum(TH1F* histo);
virtual void PlotData();
virtual void PlotDifference();

12
src/include/PMusrT0.h
View File

@ -55,7 +55,7 @@ class PMusrT0 : public TObject, public TQObject
{
public:
PMusrT0();
PMusrT0(PRawRunData *rawRunData, int runNo, int histoNo, int detectorTag, int addRunNo);
PMusrT0(PRawRunData *rawRunData, Int_t runNo, Int_t histoNo, Int_t detectorTag, Int_t addRunNo);
virtual ~PMusrT0();
@ -73,12 +73,12 @@ class PMusrT0 : public TObject, public TQObject
PMsrHandler *fMsrHandler;
#endif // __MAKECINT__
int fStatus;
Int_t fStatus;
int fRunNo;
int fDetectorTag;
int fAddRunNo;
int fAddRunOffset;
Int_t fRunNo;
Int_t fDetectorTag;
Int_t fAddRunNo;
Int_t fAddRunOffset;
// canvas related variables
TCanvas *fMainCanvas;

26
src/include/PRunAsymmetry.h
View File

@ -38,34 +38,34 @@ class PRunAsymmetry : public PRunBase
{
public:
PRunAsymmetry();
PRunAsymmetry(PMsrHandler *msrInfo, PRunDataHandler *rawData, unsigned int runNo, EPMusrHandleTag tag);
PRunAsymmetry(PMsrHandler *msrInfo, PRunDataHandler *rawData, UInt_t runNo, EPMusrHandleTag tag);
virtual ~PRunAsymmetry();
virtual double CalcChiSquare(const std::vector<double>& par);
virtual double CalcMaxLikelihood(const std::vector<double>& par);
virtual Double_t CalcChiSquare(const std::vector<Double_t>& par);
virtual Double_t CalcMaxLikelihood(const std::vector<Double_t>& par);
virtual void CalcTheory();
virtual unsigned int GetNoOfFitBins() { return fNoOfFitBins; }
virtual UInt_t GetNoOfFitBins() { return fNoOfFitBins; }
protected:
virtual bool PrepareData();
virtual bool PrepareFitData(PRawRunData* runData, unsigned int histoNo[2]);
virtual bool PrepareViewData(PRawRunData* runData, unsigned int histoNo[2]);
virtual Bool_t PrepareData();
virtual Bool_t PrepareFitData(PRawRunData* runData, UInt_t histoNo[2]);
virtual Bool_t PrepareViewData(PRawRunData* runData, UInt_t histoNo[2]);
private:
unsigned int fAlphaBetaTag; ///< 1-> alpha = beta = 1; 2-> alpha != 1, beta = 1; 3-> alpha = 1, beta != 1; 4-> alpha != 1, beta != 1
UInt_t fAlphaBetaTag; ///< 1-> alpha = beta = 1; 2-> alpha != 1, beta = 1; 3-> alpha = 1, beta != 1; 4-> alpha != 1, beta != 1
double fFitStartTime;
double fFitStopTime;
unsigned int fNoOfFitBins;
Double_t fFitStartTime;
Double_t fFitStopTime;
UInt_t fNoOfFitBins;
PDoubleVector fForward; ///< forward histo data
PDoubleVector fForwardErr; ///< forward histo errors
PDoubleVector fBackward; ///< backward histo data
PDoubleVector fBackwardErr; ///< backward histo errors
bool SubtractFixBkg();
bool SubtractEstimatedBkg();
Bool_t SubtractFixBkg();
Bool_t SubtractEstimatedBkg();
};
#endif // _PRUNASYMMETRY_H_

31
src/include/PRunBase.h
View File

@ -44,42 +44,31 @@ using namespace std;
//------------------------------------------------------------------------------------------
/**
* brauche ich eine base class um zwischen den verschiedenen run-modi unterscheiden zu können?
* Ich meine:
* - single histogram
* - asymmetry
* - RRF
* - non muSR
*
* --> JA
*
* PTheory and PFunctions werden direkt für jeden run generiert, da man dann maps und functions
* direkt für den spezifischen run umsetzen kann (da man eliminiert alle maps und functions). Dies
* garantiert effiziente theory-Aufrufe da diese in chisq/maxlikelyhood x-fach aufgerufen werden.
* <p>
*/
class PRunBase
{
public:
PRunBase();
PRunBase(PMsrHandler *msrInfo, PRunDataHandler *rawData, unsigned int runNo, EPMusrHandleTag tag);
PRunBase(PMsrHandler *msrInfo, PRunDataHandler *rawData, UInt_t runNo, EPMusrHandleTag tag);
virtual ~PRunBase();
virtual double CalcChiSquare(const vector<double>& par) = 0; // pure virtual, i.e. needs to be implemented by the deriving class!!
virtual double CalcMaxLikelihood(const vector<double>& par) = 0; // pure virtual, i.e. needs to be implemented by the deriving class!!
virtual Double_t CalcChiSquare(const vector<Double_t>& par) = 0; // pure virtual, i.e. needs to be implemented by the deriving class!!
virtual Double_t CalcMaxLikelihood(const vector<Double_t>& par) = 0; // pure virtual, i.e. needs to be implemented by the deriving class!!
virtual void CalcTheory() = 0; // pure virtual, i.e. needs to be implemented by the deriving class!!
virtual unsigned int GetRunNo() { return fRunNo; }
virtual UInt_t GetRunNo() { return fRunNo; }
virtual PRunData* GetData() { return &fData; }
virtual void CleanUp();
virtual bool IsValid() { return fValid; }
virtual Bool_t IsValid() { return fValid; }
protected:
bool fValid;
Bool_t fValid;
EPMusrHandleTag fHandleTag; ///< tag telling whether this is used for fit, view, ...
int fRunNo; ///< number of the run within the msr file
Int_t fRunNo; ///< number of the run within the msr file
PMsrHandler *fMsrInfo; ///< msr-file handler
PMsrRunStructure *fRunInfo; ///< run info used to filter out needed infos for the run
PRunDataHandler *fRawData; ///< holds the raw run data
@ -87,10 +76,10 @@ class PRunBase
PIntVector fParamNo; ///< vector of parameter numbers for the specifc run
PRunData fData; ///< data to be fitted, viewed, i.e. binned data
double fTimeResolution; ///< time resolution in (us)
Double_t fTimeResolution; ///< time resolution in (us)
PIntVector fT0s; ///< all t0's of a run! The derived classes will handle it
virtual bool PrepareData() = 0; // pure virtual, i.e. needs to be implemented by the deriving class!!
virtual Bool_t PrepareData() = 0; // pure virtual, i.e. needs to be implemented by the deriving class!!
PDoubleVector fFuncValues; ///< is keeping the values of the functions from the FUNCTIONS block
PTheory *fTheory; ///< theory needed to calculate chi-square

48
src/include/PRunListCollection.h
View File

@ -51,36 +51,36 @@ class PRunListCollection
enum EDataSwitch { kIndex, kRunNo };
virtual bool Add(int runNo, EPMusrHandleTag tag);
virtual Bool_t Add(Int_t runNo, EPMusrHandleTag tag);
virtual double GetSingleHistoChisq(const std::vector<double>& par) const;
virtual double GetAsymmetryChisq(const std::vector<double>& par) const;
virtual double GetRRFChisq(const std::vector<double>& par) const;
virtual double GetNonMusrChisq(const std::vector<double>& par) const;
virtual Double_t GetSingleHistoChisq(const std::vector<Double_t>& par) const;
virtual Double_t GetAsymmetryChisq(const std::vector<Double_t>& par) const;
virtual Double_t GetRRFChisq(const std::vector<Double_t>& par) const;
virtual Double_t GetNonMusrChisq(const std::vector<Double_t>& par) const;
virtual double GetSingleHistoMaximumLikelihood(const std::vector<double>& par) const;
virtual double GetAsymmetryMaximumLikelihood(const std::vector<double>& par) const;
virtual double GetRRFMaximumLikelihood(const std::vector<double>& par) const;
virtual double GetNonMusrMaximumLikelihood(const std::vector<double>& par) const;
virtual Double_t GetSingleHistoMaximumLikelihood(const std::vector<Double_t>& par) const;
virtual Double_t GetAsymmetryMaximumLikelihood(const std::vector<Double_t>& par) const;
virtual Double_t GetRRFMaximumLikelihood(const std::vector<Double_t>& par) const;
virtual Double_t GetNonMusrMaximumLikelihood(const std::vector<Double_t>& par) const;
virtual unsigned int GetTotalNoOfBinsFitted() const;
virtual UInt_t GetTotalNoOfBinsFitted() const;
virtual unsigned int GetNoOfSingleHisto() const { return fRunSingleHistoList.size(); }
virtual unsigned int GetNoOfAsymmetry() const { return fRunAsymmetryList.size(); }
virtual unsigned int GetNoOfRRF() const { return fRunRRFList.size(); }
virtual unsigned int GetNoOfNonMusr() const { return fRunNonMusrList.size(); }
virtual UInt_t GetNoOfSingleHisto() const { return fRunSingleHistoList.size(); }
virtual UInt_t GetNoOfAsymmetry() const { return fRunAsymmetryList.size(); }
virtual UInt_t GetNoOfRRF() const { return fRunRRFList.size(); }
virtual UInt_t GetNoOfNonMusr() const { return fRunNonMusrList.size(); }
virtual PRunData* GetSingleHisto(unsigned int index, EDataSwitch tag=kIndex);
virtual PRunData* GetAsymmetry(unsigned int index, EDataSwitch tag=kIndex);
virtual PRunData* GetRRF(unsigned int index, EDataSwitch tag=kIndex);
virtual PRunData* GetNonMusr(unsigned int index, EDataSwitch tag=kIndex);
virtual PRunData* GetSingleHisto(UInt_t index, EDataSwitch tag=kIndex);
virtual PRunData* GetAsymmetry(UInt_t index, EDataSwitch tag=kIndex);
virtual PRunData* GetRRF(UInt_t index, EDataSwitch tag=kIndex);
virtual PRunData* GetNonMusr(UInt_t index, EDataSwitch tag=kIndex);
virtual vector< pair<double, double> > GetTemp(const TString &runName) const;
virtual double GetField(const TString &runName) const;
virtual double GetEnergy(const TString &runName) const;
virtual const char* GetSetup(const TString &runName) const;
virtual const char* GetXAxisTitle(const TString &runName, const unsigned int idx) const;
virtual const char* GetYAxisTitle(const TString &runName, const unsigned int idx) const;
virtual vector< pair<Double_t, Double_t> > GetTemp(const TString &runName) const;
virtual Double_t GetField(const TString &runName) const;
virtual Double_t GetEnergy(const TString &runName) const;
virtual const Char_t* GetSetup(const TString &runName) const;
virtual const Char_t* GetXAxisTitle(const TString &runName, const UInt_t idx) const;
virtual const Char_t* GetYAxisTitle(const TString &runName, const UInt_t idx) const;
private:
PMsrHandler *fMsrInfo; ///< keeps all msr file info

24
src/include/PRunNonMusr.h
View File

@ -39,29 +39,29 @@ class PRunNonMusr : public PRunBase
{
public:
PRunNonMusr();
PRunNonMusr(PMsrHandler *msrInfo, PRunDataHandler *rawData, unsigned int runNo, EPMusrHandleTag tag);
PRunNonMusr(PMsrHandler *msrInfo, PRunDataHandler *rawData, UInt_t runNo, EPMusrHandleTag tag);
virtual ~PRunNonMusr();
virtual double CalcChiSquare(const std::vector<double>& par);
virtual double CalcMaxLikelihood(const std::vector<double>& par);
virtual Double_t CalcChiSquare(const std::vector<Double_t>& par);
virtual Double_t CalcMaxLikelihood(const std::vector<Double_t>& par);
virtual void CalcTheory();
virtual unsigned int GetNoOfFitBins() { return fNoOfFitBins; }
virtual UInt_t GetNoOfFitBins() { return fNoOfFitBins; }
virtual unsigned int GetXIndex();
virtual unsigned int GetYIndex();
virtual UInt_t GetXIndex();
virtual UInt_t GetYIndex();
protected:
virtual bool PrepareData();
virtual bool PrepareFitData();
virtual bool PrepareViewData();
virtual Bool_t PrepareData();
virtual Bool_t PrepareFitData();
virtual Bool_t PrepareViewData();
private:
PRawRunData *fRawRunData;
double fFitStartTime;
double fFitStopTime;
unsigned int fNoOfFitBins;
Double_t fFitStartTime;
Double_t fFitStopTime;
UInt_t fNoOfFitBins;
};
#endif // _PRUNNONMUSR_H_

16
src/include/PRunRRF.h
View File

@ -38,22 +38,22 @@ class PRunRRF : public PRunBase
{
public:
PRunRRF();
PRunRRF(PMsrHandler *msrInfo, PRunDataHandler *rawData, unsigned int runNo, EPMusrHandleTag tag);
PRunRRF(PMsrHandler *msrInfo, PRunDataHandler *rawData, UInt_t runNo, EPMusrHandleTag tag);
virtual ~PRunRRF();
virtual double CalcChiSquare(const std::vector<double>& par);
virtual double CalcMaxLikelihood(const std::vector<double>& par);
virtual Double_t CalcChiSquare(const std::vector<Double_t>& par);
virtual Double_t CalcMaxLikelihood(const std::vector<Double_t>& par);
virtual void CalcTheory();
virtual unsigned int GetNoOfFitBins() { return fNoOfFitBins; }
virtual UInt_t GetNoOfFitBins() { return fNoOfFitBins; }
protected:
virtual bool PrepareData();
virtual Bool_t PrepareData();
private:
double fFitStartTime;
double fFitStopTime;
unsigned int fNoOfFitBins;
Double_t fFitStartTime;
Double_t fFitStopTime;
UInt_t fNoOfFitBins;
};
#endif // _PRUNRRF_H_

26
src/include/PRunSingleHisto.h
View File

@ -38,28 +38,28 @@ class PRunSingleHisto : public PRunBase
{
public:
PRunSingleHisto();
PRunSingleHisto(PMsrHandler *msrInfo, PRunDataHandler *rawData, unsigned int runNo, EPMusrHandleTag tag);
PRunSingleHisto(PMsrHandler *msrInfo, PRunDataHandler *rawData, UInt_t runNo, EPMusrHandleTag tag);
virtual ~PRunSingleHisto();
virtual double CalcChiSquare(const std::vector<double>& par);
virtual double CalcMaxLikelihood(const std::vector<double>& par);
virtual Double_t CalcChiSquare(const std::vector<Double_t>& par);
virtual Double_t CalcMaxLikelihood(const std::vector<Double_t>& par);
virtual void CalcTheory();
virtual unsigned int GetNoOfFitBins() { return fNoOfFitBins; }
virtual UInt_t GetNoOfFitBins() { return fNoOfFitBins; }
protected:
virtual bool PrepareData();
virtual bool PrepareFitData(PRawRunData* runData, const unsigned int histoNo);
virtual bool PrepareRawViewData(PRawRunData* runData, const unsigned int histoNo);
virtual bool PrepareViewData(PRawRunData* runData, const unsigned int histoNo);
virtual Bool_t PrepareData();
virtual Bool_t PrepareFitData(PRawRunData* runData, const UInt_t histoNo);
virtual Bool_t PrepareRawViewData(PRawRunData* runData, const UInt_t histoNo);
virtual Bool_t PrepareViewData(PRawRunData* runData, const UInt_t histoNo);
private:
double fFitStartTime;
double fFitStopTime;
unsigned int fNoOfFitBins;
double fBackground; ///< needed if background range is given. In units per bin
Double_t fFitStartTime;
Double_t fFitStopTime;
UInt_t fNoOfFitBins;
Double_t fBackground; ///< needed if background range is given. In units per bin
bool EstimateBkg(unsigned int histoNo);
Bool_t EstimateBkg(UInt_t histoNo);
};
#endif // _PRUNSINGLEHISTO_H_

22
src/include/PStartupHandler.h
View File

@ -47,16 +47,16 @@ class PStartupHandler : public TObject, public TQObject
virtual void OnStartDocument(); // SLOT
virtual void OnEndDocument(); // SLOT
virtual void OnStartElement(const char*, const TList*); // SLOT
virtual void OnEndElement(const char*); // SLOT
virtual void OnCharacters(const char*); // SLOT
virtual void OnComment(const char*); // SLOT
virtual void OnWarning(const char*); // SLOT
virtual void OnError(const char*); // SLOT
virtual void OnFatalError(const char*); // SLOT
virtual void OnCdataBlock(const char*, Int_t); // SLOT
virtual void OnStartElement(const Char_t*, const TList*); // SLOT
virtual void OnEndElement(const Char_t*); // SLOT
virtual void OnCharacters(const Char_t*); // SLOT
virtual void OnComment(const Char_t*); // SLOT
virtual void OnWarning(const Char_t*); // SLOT
virtual void OnError(const Char_t*); // SLOT
virtual void OnFatalError(const Char_t*); // SLOT
virtual void OnCdataBlock(const Char_t*, Int_t); // SLOT
virtual bool StartupFileFound() { return fStartupFileFound; }
virtual Bool_t StartupFileFound() { return fStartupFileFound; }
virtual TString GetStartupFilePath() { return fStartupFilePath; }
virtual void CheckLists();
@ -73,14 +73,14 @@ class PStartupHandler : public TObject, public TQObject
eColorList, eColor};
EKeyWords fKey;
bool fStartupFileFound;
Bool_t fStartupFileFound;
TString fStartupFilePath;
PMsrFourierStructure fFourierDefaults;
PStringVector fDataPathList;
PIntVector fMarkerList;
PIntVector fColorList;
bool StartupFileExists(char *fln);
Bool_t StartupFileExists(Char_t *fln);
ClassDef(PStartupHandler, 1)
};

92
src/include/PTheory.h
View File

@ -107,12 +107,12 @@ class PTheory;
* <p>Structure holding the infos of a the available internally defined functions.
*/
typedef struct theo_data_base {
unsigned int fType; ///< function tag
unsigned int fNoOfParam; ///< number of parameters for this function
bool fTable; ///< table flag, indicating if the function is generate from a table
TString fName; ///< name of the function as written into the msr-file
TString fAbbrev; ///< abbreviation of the function name
TString fComment; ///< comment added in the msr-file theory block to help the used
UInt_t fType; ///< function tag
UInt_t fNoOfParam; ///< number of parameters for this function
Bool_t fTable; ///< table flag, indicating if the function is generate from a table
TString fName; ///< name of the function as written into the msr-file
TString fAbbrev; ///< abbreviation of the function name
TString fComment; ///< comment added in the msr-file theory block to help the used
TString fCommentTimeShift; ///< comment added in the msr-file theory block if there is a time shift
} PTheoDataBase;
@ -192,52 +192,52 @@ static PTheoDataBase fgTheoDataBase[THEORY_MAX] = {
class PTheory
{
public:
PTheory(PMsrHandler *msrInfo, unsigned int runNo, const bool hasParent = false);
PTheory(PMsrHandler *msrInfo, UInt_t runNo, const Bool_t hasParent = false);
virtual ~PTheory();
virtual bool IsValid();
virtual double Func(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Bool_t IsValid();
virtual Double_t Func(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
private:
virtual void CleanUp(PTheory *theo);
virtual int SearchDataBase(TString name);
virtual Int_t SearchDataBase(TString name);
virtual void MakeCleanAndTidyTheoryBlock(PMsrLines* fullTheoryBlock);
virtual void MakeCleanAndTidyPolynom(unsigned int i, PMsrLines* fullTheoryBlock);
virtual void MakeCleanAndTidyUserFcn(unsigned int i, PMsrLines* fullTheoryBlock);
virtual void MakeCleanAndTidyPolynom(UInt_t i, PMsrLines* fullTheoryBlock);
virtual void MakeCleanAndTidyUserFcn(UInt_t i, PMsrLines* fullTheoryBlock);
virtual double Asymmetry(const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double SimpleExp(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double GeneralExp(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double SimpleGauss(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double StaticGaussKT(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double StaticGaussKTLF(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double DynamicGaussKTLF(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double StaticLorentzKT(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double StaticLorentzKTLF(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double DynamicLorentzKTLF(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double CombiLGKT(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double SpinGlass(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double RandomAnisotropicHyperfine(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double Abragam(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double InternalField(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double TFCos(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double Bessel(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double InternalBessel(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double SkewedGauss(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double Polynom(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual double UserFcn(register double t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t Asymmetry(const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t SimpleExp(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t GeneralExp(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t SimpleGauss(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t StaticGaussKT(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t StaticGaussKTLF(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t DynamicGaussKTLF(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t StaticLorentzKT(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t StaticLorentzKTLF(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t DynamicLorentzKTLF(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t CombiLGKT(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t SpinGlass(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t RandomAnisotropicHyperfine(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t Abragam(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t InternalField(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t TFCos(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t Bessel(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t InternalBessel(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t SkewedGauss(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t Polynom(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual Double_t UserFcn(register Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
virtual void CalculateGaussLFIntegral(const double *val) const;
virtual void CalculateLorentzLFIntegral(const double *val) const;
virtual double GetLFIntegralValue(const double t) const;
virtual void CalculateDynKTLF(const double *val, int tag) const;
virtual double GetDynKTLFValue(const double t) const;
virtual void CalculateGaussLFIntegral(const Double_t *val) const;
virtual void CalculateLorentzLFIntegral(const Double_t *val) const;
virtual Double_t GetLFIntegralValue(const Double_t t) const;
virtual void CalculateDynKTLF(const Double_t *val, Int_t tag) const;
virtual Double_t GetDynKTLFValue(const Double_t t) const;
// variables
bool fValid;
unsigned int fType;
vector<unsigned int> fParamNo; ///< holds the parameter numbers for the theory (including maps and functions, see constructor desciption)
unsigned int fNoOfParam;
Bool_t fValid;
UInt_t fType;
vector<UInt_t> fParamNo; ///< holds the parameter numbers for the theory (including maps and functions, see constructor desciption)
UInt_t fNoOfParam;
PTheory *fAdd, *fMul;
TString fUserFcnClassName; ///< name of the user function class for within root
@ -247,10 +247,10 @@ class PTheory
PMsrHandler *fMsrInfo;
mutable double fPrevParam[THEORY_MAX_PARAM]; ///< needed for LF-stuff
mutable PDoubleVector fLFIntegral; ///< needed for LF-stuff. Keeps the non-analytic integral values
mutable double fDynLFdt;
mutable PDoubleVector fDynLFFuncValue; ///< needed for LF-stuff. Keeps the dynamic LF KT function values
mutable Double_t fPrevParam[THEORY_MAX_PARAM]; ///< needed for LF-stuff
mutable PDoubleVector fLFIntegral; ///< needed for LF-stuff. Keeps the non-analytic integral values
mutable Double_t fDynLFdt;
mutable PDoubleVector fDynLFFuncValue; ///< needed for LF-stuff. Keeps the dynamic LF KT function values
};
#endif // _PTHEORY_H_