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

modernized code to C++11 and newer.

Browse Source 
This allows to analyze the code by external code analyzers. Since a lot is adopted,
the version is changed to 1.4.3
This commit is contained in:
suter_a
2019-04-16 15:34:49 +02:00
parent e6d424e900
commit 795cd75b1e
136 changed files with 6870 additions and 7085 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
src/external/libFitPofB/include/TBofZCalc.h vendored
View File

@@ -30,7 +30,6 @@
#define _TBofZCalc_H_
#include <vector>
using namespace std;
/**
* <p>Base class for any kind of theory function B(z)
@@ -47,8 +46,8 @@ public:
fParam.clear();
}
virtual vector<double>* DataZ() const {return &fZ;}
virtual vector<double>* DataBZ() const {return &fBZ;}
virtual std::vector<double>* DataZ() const {return &fZ;}
virtual std::vector<double>* DataBZ() const {return &fBZ;}
virtual void Calculate();
virtual double GetBofZ(double) const = 0;
virtual double GetBmin() const = 0;
@@ -58,9 +57,9 @@ public:
protected:
int fSteps; ///< number of discrete points where B(z) is calculated
double fDZ; ///< resolution in z (spacing between two neighboring discrete B(z) points)
vector<double> fParam; ///< parameters of the B(z) function
mutable vector<double> fZ; ///< vector holding all z-values
mutable vector<double> fBZ; ///< vector holding all B(z)-values
std::vector<double> fParam; ///< parameters of the B(z) function
mutable std::vector<double> fZ; ///< vector holding all z-values
mutable std::vector<double> fBZ; ///< vector holding all B(z)-values
};
/**
@@ -73,7 +72,7 @@ public:
TBofZCalcInverse() {}
virtual ~TBofZCalcInverse() {}
virtual vector< pair<double, double> > GetInverseAndDerivative(double) const = 0;
virtual std::vector< std::pair<double, double> > GetInverseAndDerivative(double) const = 0;
};
/**
@@ -83,11 +82,11 @@ class TLondon1D_HS : public TBofZCalcInverse {
public:
TLondon1D_HS(const vector<double>&, unsigned int steps = 3000);
TLondon1D_HS(const std::vector<double>&, unsigned int steps = 3000);
double GetBofZ(double) const;
double GetBmin() const;
double GetBmax() const;
vector< pair<double, double> > GetInverseAndDerivative(double) const;
std::vector< std::pair<double, double> > GetInverseAndDerivative(double) const;
};
@@ -98,11 +97,11 @@ class TLondon1D_1L : public TBofZCalcInverse {
public:
TLondon1D_1L(const vector<double>&, unsigned int steps = 3000);
TLondon1D_1L(const std::vector<double>&, unsigned int steps = 3000);
double GetBofZ(double) const;
double GetBmin() const;
double GetBmax() const;
vector< pair<double, double> > GetInverseAndDerivative(double) const;
std::vector< std::pair<double, double> > GetInverseAndDerivative(double) const;
private:
void SetBmin();
@@ -121,11 +120,11 @@ class TLondon1D_2L : public TBofZCalcInverse {
public:
TLondon1D_2L(const vector<double>&, unsigned int steps = 3000);
TLondon1D_2L(const std::vector<double>&, unsigned int steps = 3000);
double GetBofZ(double) const;
double GetBmin() const;
double GetBmax() const;
vector< pair<double, double> > GetInverseAndDerivative(double) const;
std::vector< std::pair<double, double> > GetInverseAndDerivative(double) const;
private:
void SetBmin();
@@ -145,11 +144,11 @@ class TProximity1D_1LHS : public TBofZCalcInverse {
public:
TProximity1D_1LHS(const vector<double>&, unsigned int steps = 3000);
TProximity1D_1LHS(const std::vector<double>&, unsigned int steps = 3000);
double GetBofZ(double) const;
double GetBmin() const;
double GetBmax() const;
vector< pair<double, double> > GetInverseAndDerivative(double) const;
std::vector< std::pair<double, double> > GetInverseAndDerivative(double) const;
private:
void SetBmin();
@@ -168,11 +167,11 @@ class TLondon1D_3L : public TBofZCalcInverse {
public:
TLondon1D_3L(const vector<double>&, unsigned int steps = 3000);
TLondon1D_3L(const std::vector<double>&, unsigned int steps = 3000);
double GetBofZ(double) const;
double GetBmin() const;
double GetBmax() const;
vector< pair<double, double> > GetInverseAndDerivative(double) const;
std::vector< std::pair<double, double> > GetInverseAndDerivative(double) const;
private:
void SetBmin();
@@ -192,11 +191,11 @@ class TLondon1D_3LS : public TBofZCalcInverse {
public:
TLondon1D_3LS(const vector<double>&, unsigned int steps = 3000);
TLondon1D_3LS(const std::vector<double>&, unsigned int steps = 3000);
double GetBofZ(double) const;
double GetBmin() const;
double GetBmax() const;
vector< pair<double, double> > GetInverseAndDerivative(double) const;
std::vector< std::pair<double, double> > GetInverseAndDerivative(double) const;
private:
void SetBmin();
@@ -216,7 +215,7 @@ class TLondon1D_3LwInsulator : public TBofZCalc {
public:
TLondon1D_3LwInsulator(const vector<double>&, unsigned int steps = 3000);
TLondon1D_3LwInsulator(const std::vector<double>&, unsigned int steps = 3000);
double GetBofZ(double) const;
double GetBmin() const;
double GetBmax() const;

25
src/external/libFitPofB/include/TBulkTriVortexFieldCalc.h vendored
View File

@@ -31,7 +31,6 @@
#include <vector>
#include <string>
using namespace std;
// 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__
@@ -51,7 +50,7 @@ public:
virtual ~TBulkVortexFieldCalc();
virtual double* DataB() const {return fFFTout;}
virtual void SetParameters(const vector<double>& par) {fParam = par; fGridExists = false;}
virtual void SetParameters(const std::vector<double>& par) {fParam = par; fGridExists = false;}
virtual void CalculateGrid() const = 0;
virtual double GetBmin() const;
virtual double GetBmax() const;
@@ -61,13 +60,13 @@ public:
virtual bool IsTriangular() const = 0;
protected:
vector<double> fParam; ///< parameters used to calculate B(x,y)
std::vector<double> fParam; ///< parameters used to calculate B(x,y)
unsigned int fSteps; ///< number of steps in which the "unit cell" of the vortex lattice is devided in (in each direction)
mutable fftw_complex *fFFTin; ///< Fourier components of the field
mutable double *fFFTout; ///< spatial field distribution B(x,y) in a "unit cell" of the vortex lattice
fftw_plan fFFTplan; ///< FFTW plan for the 2D-Fourier transform from Fourier space to real space
bool fUseWisdom; ///< tag determining if FFTW wisdom is used
string fWisdom; ///< file name of the FFTW wisdom-file
std::string fWisdom; ///< file name of the FFTW wisdom-file
mutable bool fGridExists; ///< tag determining if B(x,y) has been calculated for the given set of parameters
};
@@ -79,7 +78,7 @@ class TBulkTriVortexLondonFieldCalc : public TBulkVortexFieldCalc {
public:
TBulkTriVortexLondonFieldCalc(const string&, const unsigned int steps = 256);
TBulkTriVortexLondonFieldCalc(const std::string&, const unsigned int steps = 256);
~TBulkTriVortexLondonFieldCalc() {}
void CalculateGrid() const;
@@ -95,7 +94,7 @@ class TBulkAnisotropicTriVortexLondonFieldCalc : public TBulkVortexFieldCalc {
public:
TBulkAnisotropicTriVortexLondonFieldCalc(const string&, const unsigned int steps = 256);
TBulkAnisotropicTriVortexLondonFieldCalc(const std::string&, const unsigned int steps = 256);
~TBulkAnisotropicTriVortexLondonFieldCalc() {}
void CalculateGrid() const;
@@ -111,7 +110,7 @@ class TBulkSqVortexLondonFieldCalc : public TBulkVortexFieldCalc {
public:
TBulkSqVortexLondonFieldCalc(const string&, const unsigned int steps = 256);
TBulkSqVortexLondonFieldCalc(const std::string&, const unsigned int steps = 256);
~TBulkSqVortexLondonFieldCalc() {}
void CalculateGrid() const;
@@ -127,7 +126,7 @@ class TBulkTriVortexMLFieldCalc : public TBulkVortexFieldCalc {
public:
TBulkTriVortexMLFieldCalc(const string&, const unsigned int steps = 256);
TBulkTriVortexMLFieldCalc(const std::string&, const unsigned int steps = 256);
~TBulkTriVortexMLFieldCalc() {}
void CalculateGrid() const;
@@ -144,7 +143,7 @@ class TBulkAnisotropicTriVortexMLFieldCalc : public TBulkVortexFieldCalc {
public:
TBulkAnisotropicTriVortexMLFieldCalc(const string&, const unsigned int steps = 256);
TBulkAnisotropicTriVortexMLFieldCalc(const std::string&, const unsigned int steps = 256);
~TBulkAnisotropicTriVortexMLFieldCalc() {}
void CalculateGrid() const;
@@ -160,7 +159,7 @@ class TBulkTriVortexAGLFieldCalc : public TBulkVortexFieldCalc {
public:
TBulkTriVortexAGLFieldCalc(const string&, const unsigned int steps = 256);
TBulkTriVortexAGLFieldCalc(const std::string&, const unsigned int steps = 256);
~TBulkTriVortexAGLFieldCalc() {}
void CalculateGrid() const;
@@ -176,7 +175,7 @@ class TBulkTriVortexAGLIIFieldCalc : public TBulkVortexFieldCalc {
public:
TBulkTriVortexAGLIIFieldCalc(const string&, const unsigned int steps = 256);
TBulkTriVortexAGLIIFieldCalc(const std::string&, const unsigned int steps = 256);
~TBulkTriVortexAGLIIFieldCalc() {}
void CalculateGrid() const;
@@ -193,7 +192,7 @@ class TBulkAnisotropicTriVortexAGLFieldCalc : public TBulkVortexFieldCalc {
public:
TBulkAnisotropicTriVortexAGLFieldCalc(const string&, const unsigned int steps = 256);
TBulkAnisotropicTriVortexAGLFieldCalc(const std::string&, const unsigned int steps = 256);
~TBulkAnisotropicTriVortexAGLFieldCalc() {}
void CalculateGrid() const;
@@ -210,7 +209,7 @@ class TBulkTriVortexNGLFieldCalc : public TBulkVortexFieldCalc {
public:
TBulkTriVortexNGLFieldCalc(const string&, const unsigned int steps = 256);
TBulkTriVortexNGLFieldCalc(const std::string&, const unsigned int steps = 256);
~TBulkTriVortexNGLFieldCalc();
void CalculateGrid() const;

17
src/external/libFitPofB/include/TFilmTriVortexFieldCalc.h vendored
View File

@@ -32,7 +32,6 @@
#include <vector>
#include <string>
using namespace std;
// 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__
@@ -52,8 +51,8 @@ public:
virtual ~TFilmVortexFieldCalc();
virtual vector<float*> DataB() const {return fBout;}
virtual void SetParameters(const vector<float>& par) {fParam = par; fGridExists = false;}
virtual std::vector<float*> DataB() const {return fBout;}
virtual void SetParameters(const std::vector<float>& par) {fParam = par; fGridExists = false;}
virtual void CalculateGrid() const = 0;
virtual float GetBmin() const;
virtual float GetBmax() const;
@@ -62,14 +61,14 @@ public:
virtual unsigned int GetNumberOfSteps() const {return fSteps;}
protected:
vector<float> fParam;
std::vector<float> fParam;
unsigned int fSteps; // number of steps, the "unit cell" of the vortex lattice is devided in (in x- and y- direction)
unsigned int fStepsZ; // number of layers that should be calculated in z-direction (film slices)
mutable fftwf_complex *fFFTin; // Fourier components of omega
mutable vector<float*> fBout; // three pointers to Bx, By, Bz; each of these arrays is in row-major order
mutable std::vector<float*> fBout; // three pointers to Bx, By, Bz; each of these arrays is in row-major order
fftwf_plan fFFTplan;
bool fUseWisdom;
string fWisdom;
std::string fWisdom;
mutable bool fGridExists;
};
@@ -81,7 +80,7 @@ class TFilmTriVortexNGLFieldCalc : public TFilmVortexFieldCalc {
public:
TFilmTriVortexNGLFieldCalc(const string&, const unsigned int steps = 256, const unsigned int stepsZ = 32);
TFilmTriVortexNGLFieldCalc(const std::string&, const unsigned int steps = 256, const unsigned int stepsZ = 32);
~TFilmTriVortexNGLFieldCalc();
void CalculateGrid() const;
@@ -91,7 +90,7 @@ public:
fftwf_complex* GetRealSpaceMatrix() const {return fRealSpaceMatrix;}
float* GetOmegaMatrix() const {return fOmegaMatrix;}
fftwf_complex* GetBkSMatrix() const {return fBkS;}
vector<float*> GetOmegaDiffMatrix() const {return fOmegaDiffMatrix;}
std::vector<float*> GetOmegaDiffMatrix() const {return fOmegaDiffMatrix;}
fftwf_complex* GetQMatrix() const {return fQMatrix;}
fftwf_complex* GetPMatrix() const {return fPkMatrix;}
@@ -113,7 +112,7 @@ private:
void CalculateGatVortexCore() const;
mutable float *fOmegaMatrix;
mutable vector<float*> fOmegaDiffMatrix;
mutable std::vector<float*> fOmegaDiffMatrix;
mutable fftwf_complex *fRealSpaceMatrix;
mutable fftwf_complex *fBkMatrix;
mutable fftwf_complex *fPkMatrix;

76
src/external/libFitPofB/include/TLondon1D.h vendored
View File

@@ -44,13 +44,13 @@ public:
~TLondon1DHS();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual void SetGlobalPart(std::vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double operator()(double, const std::vector<double>&) const;
private:
mutable vector<double> fPar; ///< parameters of the model
mutable std::vector<double> fPar; ///< parameters of the model
TTrimSPData *fImpProfile; ///< low energy muon implantation profiles
TPofBCalc *fPofB; ///< static field distribution P(B)
TPofTCalc *fPofT; ///< muon spin polarization p(t)
@@ -77,22 +77,22 @@ public:
~TLondon1D1L();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual void SetGlobalPart(std::vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double operator()(double, const std::vector<double>&) const;
private:
mutable vector<double> fPar; ///< parameters of the model
mutable std::vector<double> fPar; ///< parameters of the model
TTrimSPData *fImpProfile; ///< low energy muon implantation profiles
TPofBCalc *fPofB; ///< static field distribution P(B)
TPofTCalc *fPofT; ///< muon spin polarization p(t)
mutable bool fCalcNeeded; ///< tag needed to avoid unnecessary calculations if the core parameters were unchanged
mutable bool fFirstCall; ///< tag for checking if the function operator is called the first time
mutable vector<double> fParForPofT; ///< parameters for the calculation of p(t)
mutable vector<double> fParForBofZ; ///< parameters for the calculation of B(z)
mutable vector<double> fParForPofB; ///< parameters for the calculation of P(B)
string fWisdom; ///< file name of the FFTW wisdom file
mutable std::vector<double> fParForPofT; ///< parameters for the calculation of p(t)
mutable std::vector<double> fParForBofZ; ///< parameters for the calculation of B(z)
mutable std::vector<double> fParForPofB; ///< parameters for the calculation of P(B)
std::string fWisdom; ///< file name of the FFTW wisdom file
unsigned int fNSteps; ///< number of points for which B(z) is calculated
//mutable unsigned int fCallCounter;
@@ -112,22 +112,22 @@ public:
~TLondon1D2L();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual void SetGlobalPart(std::vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double operator()(double, const std::vector<double>&) const;
private:
mutable vector<double> fPar; ///< parameters of the model
mutable std::vector<double> fPar; ///< parameters of the model
TTrimSPData *fImpProfile; ///< low energy muon implantation profiles
TPofBCalc *fPofB; ///< static field distribution P(B)
TPofTCalc *fPofT; ///< muon spin polarization p(t)
mutable bool fCalcNeeded; ///< tag needed to avoid unnecessary calculations if the core parameters were unchanged
mutable bool fFirstCall; ///< tag for checking if the function operator is called the first time
mutable vector<double> fParForPofT; ///< parameters for the calculation of p(t)
mutable vector<double> fParForBofZ; ///< parameters for the calculation of B(z)
mutable vector<double> fParForPofB; ///< parameters for the calculation of P(B)
string fWisdom; ///< file name of the FFTW wisdom file
mutable std::vector<double> fParForPofT; ///< parameters for the calculation of p(t)
mutable std::vector<double> fParForBofZ; ///< parameters for the calculation of B(z)
mutable std::vector<double> fParForPofB; ///< parameters for the calculation of P(B)
std::string fWisdom; ///< file name of the FFTW wisdom file
unsigned int fNSteps; ///< number of points for which B(z) is calculated
ClassDef(TLondon1D2L,1)
@@ -146,22 +146,22 @@ public:
~TProximity1D1LHS();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual void SetGlobalPart(std::vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double operator()(double, const std::vector<double>&) const;
private:
mutable vector<double> fPar; ///< parameters of the model
mutable std::vector<double> fPar; ///< parameters of the model
TTrimSPData *fImpProfile; ///< low energy muon implantation profiles
TPofBCalc *fPofB; ///< static field distribution P(B)
TPofTCalc *fPofT; ///< muon spin polarization p(t)
mutable bool fCalcNeeded; ///< tag needed to avoid unnecessary calculations if the core parameters were unchanged
mutable bool fFirstCall; ///< tag for checking if the function operator is called the first time
mutable vector<double> fParForPofT; ///< parameters for the calculation of p(t)
mutable vector<double> fParForBofZ; ///< parameters for the calculation of B(z)
mutable vector<double> fParForPofB; ///< parameters for the calculation of P(B)
string fWisdom; ///< file name of the FFTW wisdom file
mutable std::vector<double> fParForPofT; ///< parameters for the calculation of p(t)
mutable std::vector<double> fParForBofZ; ///< parameters for the calculation of B(z)
mutable std::vector<double> fParForPofB; ///< parameters for the calculation of P(B)
std::string fWisdom; ///< file name of the FFTW wisdom file
unsigned int fNSteps; ///< number of points for which B(z) is calculated
ClassDef(TProximity1D1LHS,1)
@@ -180,22 +180,22 @@ public:
~TLondon1D3L();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual void SetGlobalPart(std::vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double operator()(double, const std::vector<double>&) const;
private:
mutable vector<double> fPar; ///< parameters of the model
mutable std::vector<double> fPar; ///< parameters of the model
TTrimSPData *fImpProfile; ///< low energy muon implantation profiles
TPofBCalc *fPofB; ///< static field distribution P(B)
TPofTCalc *fPofT; ///< muon spin polarization p(t)
mutable bool fCalcNeeded; ///< tag needed to avoid unnecessary calculations if the core parameters were unchanged
mutable bool fFirstCall; ///< tag for checking if the function operator is called the first time
mutable vector<double> fParForPofT; ///< parameters for the calculation of p(t)
mutable vector<double> fParForBofZ; ///< parameters for the calculation of B(z)
mutable vector<double> fParForPofB; ///< parameters for the calculation of P(B)
string fWisdom; ///< file name of the FFTW wisdom file
mutable std::vector<double> fParForPofT; ///< parameters for the calculation of p(t)
mutable std::vector<double> fParForBofZ; ///< parameters for the calculation of B(z)
mutable std::vector<double> fParForPofB; ///< parameters for the calculation of P(B)
std::string fWisdom; ///< file name of the FFTW wisdom file
unsigned int fNSteps; ///< number of points for which B(z) is calculated
ClassDef(TLondon1D3L,1)
@@ -214,22 +214,22 @@ public:
~TLondon1D3LS();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual void SetGlobalPart(std::vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double operator()(double, const std::vector<double>&) const;
private:
mutable vector<double> fPar; ///< parameters of the model
mutable std::vector<double> fPar; ///< parameters of the model
TTrimSPData *fImpProfile; ///< low energy muon implantation profiles
TPofBCalc *fPofB; ///< static field distribution P(B
TPofTCalc *fPofT; ///< muon spin polarization p(t)
mutable bool fCalcNeeded; ///< tag needed to avoid unnecessary calculations if the core parameters were unchanged
mutable bool fFirstCall; ///< tag for checking if the function operator is called the first time
mutable vector<double> fParForPofT; ///< parameters for the calculation of p(t)
mutable vector<double> fParForBofZ; ///< parameters for the calculation of B(z)
mutable vector<double> fParForPofB; ///< parameters for the calculation of P(B)
string fWisdom; ///< file name of the FFTW wisdom file
mutable std::vector<double> fParForPofT; ///< parameters for the calculation of p(t)
mutable std::vector<double> fParForBofZ; ///< parameters for the calculation of B(z)
mutable std::vector<double> fParForPofB; ///< parameters for the calculation of P(B)
std::string fWisdom; ///< file name of the FFTW wisdom file
unsigned int fNSteps; ///< number of points for which B(z) is calculated
ClassDef(TLondon1D3LS,1)

18
src/external/libFitPofB/include/TPofBCalc.h vendored
View File

@@ -46,25 +46,25 @@ class TPofBCalc {
public:
// standard constructor: allocates memory for B and PB, the arrays are filled later by one of the Calculate-methods
TPofBCalc(const vector<double>&);
TPofBCalc(const std::vector<double>&);
// alternative constructor: PB is not actually calculated but copied from a vector
TPofBCalc(const vector<double>&, const vector<double>& , double dt = 0.01);
TPofBCalc(const std::vector<double>&, const std::vector<double>& , double dt = 0.01);
~TPofBCalc() {
delete[] fB; fB = 0;
delete[] fPB; fPB = 0;
delete[] fB; fB = nullptr;
delete[] fPB; fPB = nullptr;
}
void Calculate(const string&, const vector<double>&);
void Calculate(const TBofZCalc*, const TTrimSPData*, const vector<double>&, unsigned int);
void Calculate(const TBofZCalcInverse*, const TTrimSPData*, const vector<double>&);
void Calculate(const TBulkVortexFieldCalc*, const vector<double>&);
void Calculate(const std::string&, const std::vector<double>&);
void Calculate(const TBofZCalc*, const TTrimSPData*, const std::vector<double>&, unsigned int);
void Calculate(const TBofZCalcInverse*, const TTrimSPData*, const std::vector<double>&);
void Calculate(const TBulkVortexFieldCalc*, const std::vector<double>&);
const double* DataB() const {return fB;}
double* DataPB() const {return fPB;}
double GetBmin() const {return fBmin;}
double GetBmax() const {return fBmax;}
unsigned int GetPBSize() const {return fPBSize;}
void SetPB(const vector<double>&) const;
void SetPB(const std::vector<double>&) const;
void ConvolveGss(double);
void AddBackground(double, double, double);
double GetFirstMoment() const;

6
src/external/libFitPofB/include/TPofTCalc.h vendored
View File

@@ -48,14 +48,14 @@ class TPofTCalc {
public:
TPofTCalc(const TPofBCalc*, const string&, const vector<double>&);
TPofTCalc(const TPofBCalc*, const std::string&, const std::vector<double>&);
~TPofTCalc();
const double* DataT() const {return fT;}
const double* DataPT() const {return fPT;}
void DoFFT();
void CalcPol(const vector<double>&);
void FakeData(const string&, const vector<double>&, const vector<double>*);
void CalcPol(const std::vector<double>&);
void FakeData(const std::string&, const std::vector<double>&, const std::vector<double>*);
double Eval(double) const;
private:

12
src/external/libFitPofB/include/TSkewedGss.h vendored
View File

@@ -44,20 +44,20 @@ public:
~TSkewedGss();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual void SetGlobalPart(std::vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double operator()(double, const std::vector<double>&) const;
private:
mutable vector<double> fPar; ///< parameters of the model
mutable std::vector<double> fPar; ///< parameters of the model
TPofBCalc *fPofB; ///< static field distribution P(B)
TPofTCalc *fPofT; ///< muon spin polarization p(t)
mutable bool fCalcNeeded; ///< tag needed to avoid unnecessary calculations if the core parameters were unchanged
mutable bool fFirstCall; ///< tag for checking if the function operator is called the first time
mutable vector<double> fParForPofT; ///< parameters for the calculation of p(t)
mutable vector<double> fParForPofB; ///< parameters for the calculation of P(B)
string fWisdom; ///< file name of the FFTW wisdom file
mutable std::vector<double> fParForPofT; ///< parameters for the calculation of p(t)
mutable std::vector<double> fParForPofB; ///< parameters for the calculation of P(B)
std::string fWisdom; ///< file name of the FFTW wisdom file
ClassDef(TSkewedGss,1)
};

132
src/external/libFitPofB/include/TVortex.h vendored
View File

@@ -44,22 +44,22 @@ public:
~TBulkTriVortexLondon();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual void SetGlobalPart(std::vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double operator()(double, const std::vector<double>&) const;
private:
mutable vector<double> fPar; ///< parameters of the model
mutable std::vector<double> fPar; ///< parameters of the model
TBulkTriVortexLondonFieldCalc *fVortex; ///< spatial field distribution B(x,y) within the vortex lattice
TPofBCalc *fPofB; ///< static field distribution P(B)
TPofTCalc *fPofT; ///< muon spin polarization p(t)
mutable bool fCalcNeeded; ///< tag needed to avoid unnecessary calculations if the core parameters were unchanged
mutable bool fFirstCall; ///< tag for checking if the function operator is called the first time
mutable vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable vector<double> fParForPofT; ///< parameters for the calculation of p(t)
string fWisdom; ///< file name of the FFTW wisdom file
mutable std::vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable std::vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable std::vector<double> fParForPofT; ///< parameters for the calculation of p(t)
std::string fWisdom; ///< file name of the FFTW wisdom file
unsigned int fGridSteps; ///< number of points in x- and y-direction for which B(x,y) is calculated
ClassDef(TBulkTriVortexLondon,1)
@@ -77,22 +77,22 @@ public:
~TBulkSqVortexLondon();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual void SetGlobalPart(std::vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double operator()(double, const std::vector<double>&) const;
private:
mutable vector<double> fPar; ///< parameters of the model
mutable std::vector<double> fPar; ///< parameters of the model
TBulkSqVortexLondonFieldCalc *fVortex; ///< spatial field distribution B(x,y) within the vortex lattice
TPofBCalc *fPofB; ///< static field distribution P(B)
TPofTCalc *fPofT; ///< muon spin polarization p(t)
mutable bool fCalcNeeded; ///< tag needed to avoid unnecessary calculations if the core parameters were unchanged
mutable bool fFirstCall; ///< tag for checking if the function operator is called the first time
mutable vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable vector<double> fParForPofT; ///< parameters for the calculation of p(t)
string fWisdom; ///< file name of the FFTW wisdom file
mutable std::vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable std::vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable std::vector<double> fParForPofT; ///< parameters for the calculation of p(t)
std::string fWisdom; ///< file name of the FFTW wisdom file
unsigned int fGridSteps; ///< number of points in x- and y-direction for which B(x,y) is calculated
ClassDef(TBulkSqVortexLondon,1)
@@ -110,22 +110,22 @@ public:
~TBulkTriVortexML();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual void SetGlobalPart(std::vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double operator()(double, const std::vector<double>&) const;
private:
mutable vector<double> fPar; ///< parameters of the model
mutable std::vector<double> fPar; ///< parameters of the model
TBulkTriVortexMLFieldCalc *fVortex; ///< spatial field distribution B(x,y) within the vortex lattice
TPofBCalc *fPofB; ///< static field distribution P(B)
TPofTCalc *fPofT; ///< muon spin polarization p(t)
mutable bool fCalcNeeded; ///< tag needed to avoid unnecessary calculations if the core parameters were unchanged
mutable bool fFirstCall; ///< tag for checking if the function operator is called the first time
mutable vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable vector<double> fParForPofT; ///< parameters for the calculation of p(t)
string fWisdom; ///< file name of the FFTW wisdom file
mutable std::vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable std::vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable std::vector<double> fParForPofT; ///< parameters for the calculation of p(t)
std::string fWisdom; ///< file name of the FFTW wisdom file
unsigned int fGridSteps; ///< number of points in x- and y-direction for which B(x,y) is calculated
ClassDef(TBulkTriVortexML,1)
@@ -143,22 +143,22 @@ public:
~TBulkTriVortexAGL();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual void SetGlobalPart(std::vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double operator()(double, const std::vector<double>&) const;
private:
mutable vector<double> fPar; ///< parameters of the model
mutable std::vector<double> fPar; ///< parameters of the model
TBulkTriVortexAGLFieldCalc *fVortex; ///< spatial field distribution B(x,y) within the vortex lattice
TPofBCalc *fPofB; ///< static field distribution P(B)
TPofTCalc *fPofT; ///< muon spin polarization p(t)
mutable bool fCalcNeeded; ///< tag needed to avoid unnecessary calculations if the core parameters were unchanged
mutable bool fFirstCall; ///< tag for checking if the function operator is called the first time
mutable vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable vector<double> fParForPofT; ///< parameters for the calculation of p(t)
string fWisdom; ///< file name of the FFTW wisdom file
mutable std::vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable std::vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable std::vector<double> fParForPofT; ///< parameters for the calculation of p(t)
std::string fWisdom; ///< file name of the FFTW wisdom file
unsigned int fGridSteps; ///< number of points in x- and y-direction for which B(x,y) is calculated
ClassDef(TBulkTriVortexAGL,1)
@@ -176,22 +176,22 @@ public:
~TBulkTriVortexAGLII();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual void SetGlobalPart(std::vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double operator()(double, const std::vector<double>&) const;
private:
mutable vector<double> fPar; ///< parameters of the model
mutable std::vector<double> fPar; ///< parameters of the model
TBulkTriVortexAGLIIFieldCalc *fVortex; ///< spatial field distribution B(x,y) within the vortex lattice
TPofBCalc *fPofB; ///< static field distribution P(B)
TPofTCalc *fPofT; ///< muon spin polarization p(t)
mutable bool fCalcNeeded; ///< tag needed to avoid unnecessary calculations if the core parameters were unchanged
mutable bool fFirstCall; ///< tag for checking if the function operator is called the first time
mutable vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable vector<double> fParForPofT; ///< parameters for the calculation of p(t)
string fWisdom; ///< file name of the FFTW wisdom file
mutable std::vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable std::vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable std::vector<double> fParForPofT; ///< parameters for the calculation of p(t)
std::string fWisdom; ///< file name of the FFTW wisdom file
unsigned int fGridSteps; ///< number of points in x- and y-direction for which B(x,y) is calculated
ClassDef(TBulkTriVortexAGLII,1)
@@ -209,22 +209,22 @@ public:
~TBulkTriVortexNGL();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual void SetGlobalPart(std::vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double operator()(double, const std::vector<double>&) const;
private:
mutable vector<double> fPar; ///< parameters of the model
mutable std::vector<double> fPar; ///< parameters of the model
TBulkTriVortexNGLFieldCalc *fVortex; ///< spatial field distribution B(x,y) within the vortex lattice
TPofBCalc *fPofB; ///< static field distribution P(B)
TPofTCalc *fPofT; ///< muon spin polarization p(t)
mutable bool fCalcNeeded; ///< tag needed to avoid unnecessary calculations if the core parameters were unchanged
mutable bool fFirstCall; ///< tag for checking if the function operator is called the first time
mutable vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable vector<double> fParForPofT; ///< parameters for the calculation of p(t)
string fWisdom; ///< file name of the FFTW wisdom file
mutable std::vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable std::vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable std::vector<double> fParForPofT; ///< parameters for the calculation of p(t)
std::string fWisdom; ///< file name of the FFTW wisdom file
unsigned int fGridSteps; ///< number of points in x- and y-direction for which B(x,y) is calculated
ClassDef(TBulkTriVortexNGL,1)
@@ -245,22 +245,22 @@ public:
bool IsValid() { return fValid; }
void Calc(const vector<double>&) const;
void Calc(const std::vector<double>&) const;
const TPofTCalc* GetPolarizationPointer() const { return fPofT; }
private:
mutable bool fValid; ///< tag indicating if the global part has been calculated
mutable vector<double> fPar; ///< parameter vector
mutable std::vector<double> fPar; ///< parameter vector
TBulkAnisotropicTriVortexLondonFieldCalc *fVortex; ///< spatial field distribution B(x,y) within the vortex lattice
TPofBCalc *fPofB; ///< static field distribution P(B)
TPofTCalc *fPofT; ///< muon spin polarization p(t)
mutable bool fCalcNeeded; ///< tag needed to avoid unnecessary calculations if the core parameters were unchanged
mutable bool fFirstCall; ///< tag for checking if the function operator is called the first time
mutable vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable vector<double> fParForPofT; ///< parameters for the calculation of p(t)
string fWisdom; ///< file name of the FFTW wisdom file
mutable std::vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable std::vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable std::vector<double> fParForPofT; ///< parameters for the calculation of p(t)
std::string fWisdom; ///< file name of the FFTW wisdom file
unsigned int fGridSteps; ///< number of points in x- and y-direction for which B(x,y) is calculated
// definition of the class for the ROOT-dictionary
@@ -280,10 +280,10 @@ public:
~TBulkAnisotropicTriVortexLondon();
virtual bool NeedGlobalPart() const { return true; }
virtual void SetGlobalPart(vector<void *> &globalPart, unsigned int idx);
virtual void SetGlobalPart(std::vector<void *> &globalPart, unsigned int idx);
virtual bool GlobalPartIsValid() const;
double operator()(double, const vector<double>&) const;
double operator()(double, const std::vector<double>&) const;
private:
bool fValid;
@@ -309,22 +309,22 @@ public:
bool IsValid() { return fValid; }
void Calc(const vector<double>&) const;
void Calc(const std::vector<double>&) const;
const TPofTCalc* GetPolarizationPointer() const { return fPofT; }
private:
mutable bool fValid; ///< tag indicating if the global part has been calculated
mutable vector<double> fPar; ///< parameter vector
mutable std::vector<double> fPar; ///< parameter vector
TBulkAnisotropicTriVortexMLFieldCalc *fVortex; ///< spatial field distribution B(x,y) within the vortex lattice
TPofBCalc *fPofB; ///< static field distribution P(B)
TPofTCalc *fPofT; ///< muon spin polarization p(t)
mutable bool fCalcNeeded; ///< tag needed to avoid unnecessary calculations if the core parameters were unchanged
mutable bool fFirstCall; ///< tag for checking if the function operator is called the first time
mutable vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable vector<double> fParForPofT; ///< parameters for the calculation of p(t)
string fWisdom; ///< file name of the FFTW wisdom file
mutable std::vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable std::vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable std::vector<double> fParForPofT; ///< parameters for the calculation of p(t)
std::string fWisdom; ///< file name of the FFTW wisdom file
unsigned int fGridSteps; ///< number of points in x- and y-direction for which B(x,y) is calculated
// definition of the class for the ROOT-dictionary
@@ -344,10 +344,10 @@ public:
~TBulkAnisotropicTriVortexML();
virtual bool NeedGlobalPart() const { return true; }
virtual void SetGlobalPart(vector<void *> &globalPart, unsigned int idx);
virtual void SetGlobalPart(std::vector<void *> &globalPart, unsigned int idx);
virtual bool GlobalPartIsValid() const;
double operator()(double, const vector<double>&) const;
double operator()(double, const std::vector<double>&) const;
private:
bool fValid;
@@ -373,22 +373,22 @@ public:
bool IsValid() { return fValid; }
void Calc(const vector<double>&) const;
void Calc(const std::vector<double>&) const;
const TPofTCalc* GetPolarizationPointer() const { return fPofT; }
private:
mutable bool fValid; ///< tag indicating if the global part has been calculated
mutable vector<double> fPar; ///< parameter vector
mutable std::vector<double> fPar; ///< parameter vector
TBulkAnisotropicTriVortexAGLFieldCalc *fVortex; ///< spatial field distribution B(x,y) within the vortex lattice
TPofBCalc *fPofB; ///< static field distribution P(B)
TPofTCalc *fPofT; ///< muon spin polarization p(t)
mutable bool fCalcNeeded; ///< tag needed to avoid unnecessary calculations if the core parameters were unchanged
mutable bool fFirstCall; ///< tag for checking if the function operator is called the first time
mutable vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable vector<double> fParForPofT; ///< parameters for the calculation of p(t)
string fWisdom; ///< file name of the FFTW wisdom file
mutable std::vector<double> fParForVortex; ///< parameters for the calculation of B(x,y)
mutable std::vector<double> fParForPofB; ///< parameters for the calculation of P(B)
mutable std::vector<double> fParForPofT; ///< parameters for the calculation of p(t)
std::string fWisdom; ///< file name of the FFTW wisdom file
unsigned int fGridSteps; ///< number of points in x- and y-direction for which B(x,y) is calculated
// definition of the class for the ROOT-dictionary
@@ -408,10 +408,10 @@ public:
~TBulkAnisotropicTriVortexAGL();
virtual bool NeedGlobalPart() const { return true; }
virtual void SetGlobalPart(vector<void *> &globalPart, unsigned int idx);
virtual void SetGlobalPart(std::vector<void *> &globalPart, unsigned int idx);
virtual bool GlobalPartIsValid() const;
double operator()(double, const vector<double>&) const;
double operator()(double, const std::vector<double>&) const;
private:
bool fValid;