added the option to split a user function into a global and run-block related part (see MUSR-134)

This commit is contained in:
nemu
2010-11-10 13:13:00 +00:00
parent c4dfc3cbce
commit f4d6e349fe
41 changed files with 2401 additions and 161 deletions

View File

@ -43,7 +43,7 @@ using namespace std;
#define GAMMA_MU 0.0851615503527
#define DEGREE2RAD 0.0174532925199
ClassImp(PNL_PippardFitter)
ClassImp(PNL_PippardFitterGlobal)
//--------------------------------------------------------------------------
// Constructor
@ -51,8 +51,12 @@ ClassImp(PNL_PippardFitter)
/**
*
*/
PNL_PippardFitter::PNL_PippardFitter()
PNL_PippardFitterGlobal::PNL_PippardFitterGlobal()
{
fValid = true;
fStartupHandler = 0;
fRgeHandler = 0;
// read XML startup file
char startup_path_name[128];
TSAXParser *saxParser = new TSAXParser();
@ -62,18 +66,9 @@ PNL_PippardFitter::PNL_PippardFitter()
Int_t status = saxParser->ParseFile(startup_path_name);
// check for parse errors
if (status) { // error
cout << endl << "**WARNING** reading/parsing nonlocal_startup.xml.";
cout << endl << ">> PNL_PippardFitterGlobal::PNL_PippardFitterGlobal: **WARNING** reading/parsing nonlocal_startup.xml.";
cout << endl;
// clean up
if (saxParser) {
delete saxParser;
saxParser = 0;
}
if (fStartupHandler) {
delete fStartupHandler;
fStartupHandler = 0;
}
assert(false);
fValid = false;
}
// clean up
@ -84,21 +79,21 @@ PNL_PippardFitter::PNL_PippardFitter()
// check if everything went fine with the startup handler
if (!fStartupHandler->IsValid()) {
cout << endl << "PNL_PippardFitter::PNL_PippardFitter **PANIC ERROR**";
cout << endl << " startup handler too unhappy. Will terminate unfriendly, sorry.";
cout << endl << ">> PNL_PippardFitterGlobal::PNL_PippardFitterGlobal **PANIC ERROR**";
cout << endl << ">> startup handler too unhappy. Will terminate unfriendly, sorry.";
cout << endl;
assert(false);
fValid = false;
}
fFourierPoints = fStartupHandler->GetFourierPoints();
// load all the TRIM.SP rge-files
fRgeHandler = new PNL_RgeHandler(fStartupHandler->GetTrimSpDataPathList());
fRgeHandler = new PNL_RgeHandler(fStartupHandler->GetTrimSpDataPathList(), fStartupHandler->GetTrimSpDataVectorList());
if (!fRgeHandler->IsValid()) {
cout << endl << "PNL_PippardFitter::PNL_PippardFitter **PANIC ERROR**";
cout << endl << " rge data handler too unhappy. Will terminate unfriendly, sorry.";
cout << endl << ">> PNL_PippardFitterGlobal::PNL_PippardFitterGlobal **PANIC ERROR**";
cout << endl << ">> rge data handler too unhappy. Will terminate unfriendly, sorry.";
cout << endl;
assert(false);
fValid = false;
}
fPlanPresent = false;
@ -115,7 +110,7 @@ PNL_PippardFitter::PNL_PippardFitter()
/**
*
*/
PNL_PippardFitter::~PNL_PippardFitter()
PNL_PippardFitterGlobal::~PNL_PippardFitterGlobal()
{
fPreviousParam.clear();
@ -136,107 +131,45 @@ PNL_PippardFitter::~PNL_PippardFitter()
delete fRgeHandler;
fRgeHandler = 0;
}
/*
if (fStartupHandler) {
delete fStartupHandler;
fStartupHandler = 0;
}
*/
}
//--------------------------------------------------------------------------
// operator()
// CalculateField (public)
//--------------------------------------------------------------------------
/**
*
*/
Double_t PNL_PippardFitter::operator()(Double_t t, const std::vector<Double_t> &param) const
void PNL_PippardFitterGlobal::CalculateField(const std::vector<Double_t> &param) const
{
// param: [0] energy, [1] temp, [2] thickness, [3] meanFreePath, [4] xi0, [5] lambdaL, [6] Bext, [7] phase, [8] dead-layer
assert(param.size() == 9);
// for negative time return polarization == 1
if (t <= 0.0)
return 1.0;
// calculate field if parameter have changed
if (NewParameters(param)) { // new parameters, hence B(z), P(t), ..., needs to be calculated
// keep parameters
for (UInt_t i=0; i<param.size(); i++)
fPreviousParam[i] = param[i];
fEnergyIndex = fRgeHandler->GetRgeEnergyIndex(param[0]);
CalculateField(param);
}
// calcualte polarization
Bool_t done = false;
Double_t pol = 0.0, dPol = 0.0;
Double_t z=0.0;
Int_t terminate = 0;
Double_t dz = 1.0;
do {
if (z < param[8]) { // z < dead-layer
dPol = fRgeHandler->GetRgeValue(fEnergyIndex, z) * cos(GAMMA_MU * param[6] * t + param[7] * DEGREE2RAD);;
} else {
dPol = fRgeHandler->GetRgeValue(fEnergyIndex, z) * cos(GAMMA_MU * param[6] * GetMagneticField(z-param[8]) * t + param[7] * DEGREE2RAD);
}
z += dz;
pol += dPol;
// change in polarization is very small hence start termination counting
if (fabs(dPol) < 1.0e-7) {
terminate++;
} else {
terminate = 0;
}
if (terminate > 10) // polarization died out hence one can stop
done = true;
} while (!done);
// cout << endl << "t = " << t << ", pol = " << pol*dz;
return pol*dz;
}
//--------------------------------------------------------------------------
// NewParameters
//--------------------------------------------------------------------------
/**
*
*/
Bool_t PNL_PippardFitter::NewParameters(const std::vector<Double_t> &param) const
{
// check that param are new and hence a calculation is needed
Bool_t newParams = false;
if (fPreviousParam.size() == 0) {
for (UInt_t i=0; i<param.size(); i++)
fPreviousParam.push_back(param[i]);
return true;
}
newParams = true;
} else {
assert(param.size() == fPreviousParam.size());
assert(param.size() == fPreviousParam.size());
Bool_t result = false;
for (UInt_t i=0; i<param.size(); i++) {
if (param[i] != fPreviousParam[i]) {
result = true;
break;
for (UInt_t i=0; i<param.size(); i++) {
if (param[i] != fPreviousParam[i]) {
newParams = true;
break;
}
}
}
return result;
}
if (!newParams)
return;
//--------------------------------------------------------------------------
// CalculateField
//--------------------------------------------------------------------------
/**
*
*/
void PNL_PippardFitter::CalculateField(const std::vector<Double_t> &param) const
{
// param: [0] energy, [1] temp, [2] thickness, [3] meanFreePath, [4] xi0, [5] lambdaL, [6] Bext, [7] phase, [8] dead-layer
// keep parameters
for (UInt_t i=0; i<param.size(); i++)
fPreviousParam[i] = param[i];
//cout << endl << "in CalculateField ..." << endl;
//cout << endl << "fFourierPoints = " << fFourierPoints;
@ -324,7 +257,7 @@ void PNL_PippardFitter::CalculateField(const std::vector<Double_t> &param) const
/**
*
*/
Double_t PNL_PippardFitter::GetMagneticField(const Double_t z) const
Double_t PNL_PippardFitterGlobal::GetMagneticField(const Double_t z) const
{
Double_t result = -1.0;
@ -350,7 +283,7 @@ Double_t PNL_PippardFitter::GetMagneticField(const Double_t z) const
/**
*
*/
Double_t PNL_PippardFitter::DeltaBCS(const Double_t t) const
Double_t PNL_PippardFitterGlobal::DeltaBCS(const Double_t t) const
{
Double_t result = 0.0;
@ -392,7 +325,7 @@ Double_t PNL_PippardFitter::DeltaBCS(const Double_t t) const
/**
*
*/
Double_t PNL_PippardFitter::LambdaL_T(const Double_t lambdaL, const Double_t t) const
Double_t PNL_PippardFitterGlobal::LambdaL_T(const Double_t lambdaL, const Double_t t) const
{
return lambdaL/sqrt(1.0-pow(t,4.0));
}
@ -404,7 +337,7 @@ Double_t PNL_PippardFitter::LambdaL_T(const Double_t lambdaL, const Double_t t)
* <p> Approximated xi_P(T). The main approximation is that (lamdaL(T)/lambdaL(0))^2 = 1/(1-t^2). This way
* xi_P(T) is close the the BCS xi_BCS(T).
*/
Double_t PNL_PippardFitter::XiP_T(const Double_t xi0, const Double_t meanFreePath, Double_t t) const
Double_t PNL_PippardFitterGlobal::XiP_T(const Double_t xi0, const Double_t meanFreePath, Double_t t) const
{
if (t>0.96)
t=0.96;
@ -413,3 +346,134 @@ Double_t PNL_PippardFitter::XiP_T(const Double_t xi0, const Double_t meanFreePat
return xi0*meanFreePath/(meanFreePath*J0T+xi0);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
ClassImp(PNL_PippardFitter)
//--------------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------------
/**
*
*/
PNL_PippardFitter::PNL_PippardFitter()
{
fValid = false;
fInvokedGlobal = false;
fPippardFitterGlobal = 0;
}
//--------------------------------------------------------------------------
// Destructor
//--------------------------------------------------------------------------
/**
*
*/
PNL_PippardFitter::~PNL_PippardFitter()
{
if ((fPippardFitterGlobal != 0) && fInvokedGlobal) {
delete fPippardFitterGlobal;
fPippardFitterGlobal = 0;
// cout << endl << "debug> in PNL_PippardFitter::~PNL_PippardFitter(), fPippardFitterGlobal deleted." << endl;
}
}
//--------------------------------------------------------------------------
// SetGlobalPart (public)
//--------------------------------------------------------------------------
/**
* <p>
*
* <b>return:</b>
*
* \param globalPart
* \param idx
*/
void PNL_PippardFitter::SetGlobalPart(vector<void*> &globalPart, UInt_t idx)
{
fIdxGlobal = static_cast<Int_t>(idx);
if ((Int_t)globalPart.size() <= fIdxGlobal) {
fPippardFitterGlobal = new PNL_PippardFitterGlobal();
if (fPippardFitterGlobal == 0) {
fValid = false;
cerr << endl << ">> PNL_PippardFitter::SetGlobalPart(): **ERROR** Couldn't invoke global user function object, sorry ..." << endl;
} else if (!fPippardFitterGlobal->IsValid()) {
fValid = false;
cerr << endl << ">> PNL_PippardFitter::SetGlobalPart(): **ERROR** initialization of global user function object failed, sorry ..." << endl;
} else {
fValid = true;
fInvokedGlobal = true;
globalPart.resize(fIdxGlobal+1);
globalPart[fIdxGlobal] = dynamic_cast<PNL_PippardFitterGlobal*>(fPippardFitterGlobal);
// cout << endl << ">> debug> PNL_PippardFitter::SetGlobalPart(): invoked global user function object, fPippardFitterGlobal = " << fPippardFitterGlobal << ", fInvokedGlobal=" << fInvokedGlobal;
}
} else {
fValid = true;
fPippardFitterGlobal = (PNL_PippardFitterGlobal*)globalPart[fIdxGlobal];
}
}
//--------------------------------------------------------------------------
// GlobalPartIsValid (public)
//--------------------------------------------------------------------------
/**
* <p>
*
* <b>return:</b>
*/
Bool_t PNL_PippardFitter::GlobalPartIsValid() const
{
// cout << endl << "debug> PNL_PippardFitter::GlobalPartIsValid(): fValid=" << fValid << ", fGlobalUserFcn->IsValid()=" << fPippardFitterGlobal->IsValid() << endl;
return (fValid && fPippardFitterGlobal->IsValid());
}
//--------------------------------------------------------------------------
// operator()
//--------------------------------------------------------------------------
/**
*
*/
Double_t PNL_PippardFitter::operator()(Double_t t, const std::vector<Double_t> &param) const
{
// param: [0] energy, [1] temp, [2] thickness, [3] meanFreePath, [4] xi0, [5] lambdaL, [6] Bext, [7] phase, [8] dead-layer
assert(param.size() == 9);
// for negative time return polarization == 1
if (t <= 0.0)
return 1.0;
// calculate field if parameter have changed
fPippardFitterGlobal->CalculateField(param);
Int_t energyIndex = fPippardFitterGlobal->GetEnergyIndex(param[0]);
// calcualte polarization
Bool_t done = false;
Double_t pol = 0.0, dPol = 0.0;
Double_t z=0.0;
Int_t terminate = 0;
Double_t dz = 1.0;
do {
if (z < param[8]) { // z < dead-layer
dPol = fPippardFitterGlobal->GetMuoneStoppingDensity(energyIndex, z) * cos(GAMMA_MU * param[6] * t + param[7] * DEGREE2RAD);
} else {
dPol = fPippardFitterGlobal->GetMuoneStoppingDensity(energyIndex, z) * cos(GAMMA_MU * param[6] * fPippardFitterGlobal->GetMagneticField(z-param[8]) * t + param[7] * DEGREE2RAD);
}
z += dz;
pol += dPol;
// change in polarization is very small hence start termination counting
if (fabs(dPol) < 1.0e-9) {
terminate++;
} else {
terminate = 0;
}
if (terminate > 10) // polarization died out hence one can stop
done = true;
} while (!done);
return pol*dz;
}

View File

@ -38,15 +38,21 @@
#include "PNL_StartupHandler.h"
#include "PNL_RgeHandler.h"
class PNL_PippardFitter : public PUserFcnBase
class PNL_PippardFitterGlobal
{
public:
PNL_PippardFitter();
virtual ~PNL_PippardFitter();
PNL_PippardFitterGlobal();
virtual ~PNL_PippardFitterGlobal();
virtual Double_t operator()(Double_t t, const std::vector<Double_t> &param) const;
Bool_t IsValid() { return fValid; }
virtual void CalculateField(const std::vector<Double_t> &param) const;
virtual Int_t GetEnergyIndex(const Double_t energy) { return fRgeHandler->GetRgeEnergyIndex(energy); }
virtual Double_t GetMuoneStoppingDensity(const Int_t energyIndex, const Double_t z) const { return fRgeHandler->GetRgeValue(energyIndex, z); }
virtual Double_t GetMagneticField(const Double_t z) const;
private:
Bool_t fValid;
PNL_StartupHandler *fStartupHandler;
PNL_RgeHandler *fRgeHandler;
@ -64,14 +70,33 @@ class PNL_PippardFitter : public PUserFcnBase
mutable Int_t fEnergyIndex; // keeps the proper index to select n(z)
virtual Bool_t NewParameters(const std::vector<Double_t> &param) const;
virtual void CalculateField(const std::vector<Double_t> &param) const;
virtual Double_t GetMagneticField(const Double_t z) const;
virtual Double_t DeltaBCS(const Double_t t) const;
virtual Double_t LambdaL_T(const Double_t lambdaL, const Double_t t) const;
virtual Double_t XiP_T(const Double_t xi0, const Double_t meanFreePath, Double_t t) const;
ClassDef(PNL_PippardFitterGlobal, 1)
};
class PNL_PippardFitter : public PUserFcnBase
{
public:
PNL_PippardFitter();
virtual ~PNL_PippardFitter();
virtual Bool_t NeedGlobalPart() const { return true; }
virtual void SetGlobalPart(vector<void*> &globalPart, UInt_t idx);
virtual Bool_t GlobalPartIsValid() const;
virtual Double_t operator()(Double_t t, const std::vector<Double_t> &param) const;
private:
Bool_t fValid;
Bool_t fInvokedGlobal;
Int_t fIdxGlobal;
PNL_PippardFitterGlobal *fPippardFitterGlobal;
ClassDef(PNL_PippardFitter, 1)
};

View File

@ -35,6 +35,7 @@
#pragma link off all classes;
#pragma link off all functions;
#pragma link C++ class PNL_PippardFitterGlobal+;
#pragma link C++ class PNL_PippardFitter+;
#endif

View File

@ -43,11 +43,11 @@ using namespace std;
/**
*
*/
PNL_RgeHandler::PNL_RgeHandler(const PStringVector &rgeDataPathList)
PNL_RgeHandler::PNL_RgeHandler(const PStringVector &rgeDataPathList, const PDoubleVector &rgeDataEnergyList)
{
fIsValid = false;
fIsValid = LoadRgeData(rgeDataPathList);
fIsValid = LoadRgeData(rgeDataPathList, rgeDataEnergyList);
}
//--------------------------------------------------------------------------
@ -146,7 +146,7 @@ Double_t PNL_RgeHandler::GetRgeValue(const Double_t energy, const Double_t dist)
/**
*
*/
Bool_t PNL_RgeHandler::LoadRgeData(const PStringVector &rgeDataPathList)
Bool_t PNL_RgeHandler::LoadRgeData(const PStringVector &rgeDataPathList, const PDoubleVector &rgeDataEnergyList)
{
ifstream fin;
PNL_RgeData data;
@ -166,17 +166,8 @@ Bool_t PNL_RgeHandler::LoadRgeData(const PStringVector &rgeDataPathList)
return false;
}
// extract energy from rgeDataPathList name
dataName = rgeDataPathList[i];
// remove rge extension
dataName.Remove(dataName.Length()-4, 4);
// get energy part
dataName.Replace(0, dataName.Length()-3, "");
if (!dataName.IsDigit()) {
fin.close();
return false;
}
data.energy = dataName.Atof()/10.0;
// keep energy (in keV)
data.energy = rgeDataEnergyList[i]/1000.0;
// read msr-file
idx = 0;

View File

@ -37,7 +37,7 @@
class PNL_RgeHandler
{
public:
PNL_RgeHandler(const PStringVector &rgeDataPathList);
PNL_RgeHandler(const PStringVector &rgeDataPathList, const PDoubleVector &rgeDataEnergyList);
virtual ~PNL_RgeHandler();
virtual Bool_t IsValid() { return fIsValid; }
@ -49,7 +49,7 @@ class PNL_RgeHandler
Bool_t fIsValid;
PNL_RgeDataList fRgeDataList;
virtual Bool_t LoadRgeData(const PStringVector &rgeDataPathList);
virtual Bool_t LoadRgeData(const PStringVector &rgeDataPathList, const PDoubleVector &rgeDataEnergyList);
};
#endif // _PNL_RGEHANDLER_H_

View File

@ -64,6 +64,7 @@ PNL_StartupHandler::PNL_StartupHandler()
fStartupFileFound = true;
fStartupFilePath = TString(startup_path_name);
} else { // startup file is not found in the current directory
cout << endl << "PNL_StartupHandler(): **WARNING** Couldn't find nonlocal_startup.xml in the current directory, will try default one." << endl;
strncpy(startup_path_name, "/home/nemu/analysis/musrfit/src/external/Nonlocal/nonlocal_startup.xml", sizeof(startup_path_name));
if (StartupFileExists(startup_path_name)) {
fStartupFileFound = true;
@ -81,6 +82,7 @@ PNL_StartupHandler::PNL_StartupHandler()
PNL_StartupHandler::~PNL_StartupHandler()
{
fTrimSpDataPathList.clear();
fTrimSpDataEnergyList.clear();
}
//--------------------------------------------------------------------------
@ -154,8 +156,6 @@ void PNL_StartupHandler::OnEndElement(const char *str)
void PNL_StartupHandler::OnCharacters(const char *str)
{
TString tstr;
Double_t dval;
char sstr[128];
switch (fKey) {
case eFourierPoints:
@ -174,18 +174,16 @@ void PNL_StartupHandler::OnCharacters(const char *str)
case eEnergy:
tstr = str;
if (tstr.IsFloat()) {
dval = tstr.Atof();
fTrimSpDataEnergyList.push_back(tstr.Atof());
tstr = fTrimSpDataPath;
tstr += str;
tstr += ".rge";
fTrimSpDataPathList.push_back(tstr);
} else {
cout << endl << "PNL_StartupHandler::OnCharacters: **ERROR** when finding energy:";
cout << endl << "\"" << str << "\" is not a double.";
cout << endl << "\"" << str << "\" is not a floating point number, will ignore it and use the default value.";
cout << endl;
fIsValid = false;
}
tstr = fTrimSpDataPath;
sprintf(sstr, "%03d", (int)(round(dval*10.0)));
tstr += sstr;
tstr += ".rge";
fTrimSpDataPathList.push_back(tstr);
break;
default:
break;

View File

@ -59,6 +59,7 @@ class PNL_StartupHandler : public TObject
virtual TString GetStartupFilePath() { return fStartupFilePath; }
virtual const Int_t GetFourierPoints() const { return fFourierPoints; }
virtual const PStringVector GetTrimSpDataPathList() const { return fTrimSpDataPathList; }
virtual const PDoubleVector GetTrimSpDataVectorList() const { return fTrimSpDataEnergyList; }
virtual bool StartupFileFound() { return fStartupFileFound; }
@ -74,6 +75,7 @@ class PNL_StartupHandler : public TObject
Int_t fFourierPoints;
TString fTrimSpDataPath;
PStringVector fTrimSpDataPathList;
PDoubleVector fTrimSpDataEnergyList;
bool StartupFileExists(char *fln);

View File

@ -46,6 +46,10 @@ public:
TLondon1DHS();
~TLondon1DHS();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -75,6 +79,10 @@ public:
TLondon1D1L();
~TLondon1D1L();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -106,6 +114,10 @@ public:
TLondon1D2L();
~TLondon1D2L();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -136,6 +148,10 @@ public:
TProximity1D1LHS();
~TProximity1D1LHS();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -166,6 +182,10 @@ public:
TLondon1D3L();
~TLondon1D3L();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -196,6 +216,10 @@ public:
TLondon1D3LS();
~TLondon1D3LS();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:

View File

@ -46,6 +46,10 @@ public:
TSkewedGss();
~TSkewedGss();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:

View File

@ -46,6 +46,10 @@ public:
TBulkTriVortexLondon();
~TBulkTriVortexLondon();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -75,6 +79,10 @@ public:
TBulkSqVortexLondon();
~TBulkSqVortexLondon();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -104,6 +112,10 @@ public:
TBulkTriVortexML();
~TBulkTriVortexML();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -133,6 +145,10 @@ public:
TBulkTriVortexAGL();
~TBulkTriVortexAGL();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -162,6 +178,10 @@ public:
TBulkTriVortexNGL();
~TBulkTriVortexNGL();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:

View File

@ -44,6 +44,10 @@ public:
TBNMR(){}
~TBNMR(){}
Bool_t NeedGlobalPart() const { return false; }
void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
Bool_t GlobalPartIsValid() const { return true; }
// function operator
double operator()(double, const vector<double>&) const;
@ -58,6 +62,10 @@ public:
ExpRlx(){}
~ExpRlx(){}
Bool_t NeedGlobalPart() const { return false; }
void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
Bool_t GlobalPartIsValid() const { return true; }
// function operator
double operator()(double, const vector<double>&) const;
@ -72,6 +80,10 @@ public:
SExpRlx(){}
~SExpRlx(){}
Bool_t NeedGlobalPart() const { return false; }
void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
Bool_t GlobalPartIsValid() const { return true; }
// function operator
double operator()(double, const vector<double>&) const;

View File

@ -41,6 +41,10 @@ public:
TMeanFieldsForScHalfSpace();
~TMeanFieldsForScHalfSpace() {delete fImpProfile; fImpProfile = 0;}
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double CalcMeanB (double, const TLondon1D_HS&) const;
@ -57,6 +61,10 @@ public:
TMeanFieldsForScSingleLayer();
~TMeanFieldsForScSingleLayer() {delete fImpProfile; fImpProfile = 0;}
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double CalcMeanB (double, const vector<double>&, const vector<double>&, const TLondon1D_1L&) const;
@ -73,6 +81,10 @@ public:
TMeanFieldsForScBilayer();
~TMeanFieldsForScBilayer() {delete fImpProfile; fImpProfile = 0;}
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double CalcMeanB (double, const vector<double>&, const vector<double>&, const TLondon1D_2L&) const;
@ -89,6 +101,10 @@ public:
TMeanFieldsForScTrilayer();
~TMeanFieldsForScTrilayer() {delete fImpProfile; fImpProfile = 0;}
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double CalcMeanB (double, const vector<double>&, const vector<double>&, const TLondon1D_3L&) const;
@ -105,6 +121,10 @@ public:
TMeanFieldsForScTrilayerWithInsulator();
~TMeanFieldsForScTrilayerWithInsulator() {delete fImpProfile; fImpProfile = 0;}
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
double CalcMeanB (double, const vector<double>&, const vector<double>&, const TLondon1D_3LwInsulator&) const;

View File

@ -46,6 +46,10 @@ public:
TGapSWave();
~TGapSWave();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -66,6 +70,10 @@ public:
TGapDWave();
~TGapDWave();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -86,6 +94,10 @@ public:
TGapCosSqDWave();
~TGapCosSqDWave();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -106,6 +118,10 @@ public:
TGapSinSqDWave();
~TGapSinSqDWave();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -127,6 +143,10 @@ public:
TGapAnSWave();
~TGapAnSWave();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -147,6 +167,10 @@ public:
TGapNonMonDWave1();
~TGapNonMonDWave1();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -167,6 +191,10 @@ public:
TGapNonMonDWave2();
~TGapNonMonDWave2();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -188,6 +216,10 @@ public:
TGapPowerLaw() {}
~TGapPowerLaw() {}
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -201,6 +233,10 @@ public:
TGapDirtySWave() {}
~TGapDirtySWave() {}
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -215,6 +251,10 @@ public:
TLambdaSWave();
~TLambdaSWave();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -229,6 +269,10 @@ public:
TLambdaDWave();
~TLambdaDWave();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -243,6 +287,10 @@ public:
TLambdaAnSWave();
~TLambdaAnSWave();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -257,6 +305,10 @@ public:
TLambdaNonMonDWave1();
~TLambdaNonMonDWave1();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -271,6 +323,10 @@ public:
TLambdaNonMonDWave2();
~TLambdaNonMonDWave2();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -286,6 +342,10 @@ public:
TLambdaPowerLaw() {}
~TLambdaPowerLaw() {}
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -299,6 +359,10 @@ public:
TLambdaInvSWave();
~TLambdaInvSWave();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -313,6 +377,10 @@ public:
TLambdaInvDWave();
~TLambdaInvDWave();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -327,6 +395,10 @@ public:
TLambdaInvAnSWave();
~TLambdaInvAnSWave();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -341,6 +413,10 @@ public:
TLambdaInvNonMonDWave1();
~TLambdaInvNonMonDWave1();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -355,6 +431,10 @@ public:
TLambdaInvNonMonDWave2();
~TLambdaInvNonMonDWave2();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -370,6 +450,10 @@ public:
TLambdaInvPowerLaw() {}
~TLambdaInvPowerLaw() {}
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -383,6 +467,10 @@ public:
TFilmMagnetizationDWave();
~TFilmMagnetizationDWave();
virtual Bool_t NeedGlobalPart() const { return false; }
virtual void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
virtual Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:

View File

@ -56,6 +56,10 @@ public:
TLFStatGssKT();
~TLFStatGssKT();
Bool_t NeedGlobalPart() const { return false; }
void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -70,6 +74,10 @@ public:
TLFStatLorKT();
~TLFStatLorKT();
Bool_t NeedGlobalPart() const { return false; }
void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -84,6 +92,10 @@ public:
TLFDynGssKT();
~TLFDynGssKT();
Bool_t NeedGlobalPart() const { return false; }
void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -110,6 +122,10 @@ public:
TLFDynLorKT();
~TLFDynLorKT();
Bool_t NeedGlobalPart() const { return false; }
void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private:
@ -138,6 +154,10 @@ public:
TLFSGInterpolation();
~TLFSGInterpolation();
Bool_t NeedGlobalPart() const { return false; }
void SetGlobalPart(vector<void *> &globalPart, UInt_t idx) { }
Bool_t GlobalPartIsValid() const { return true; }
double operator()(double, const vector<double>&) const;
private: