diff --git a/Code/Mantid/Framework/API/inc/MantidAPI/IFuncMinimizer.h b/Code/Mantid/Framework/API/inc/MantidAPI/IFuncMinimizer.h
index ee45efe672c45976eaa764d737f3332899dae461..e3532a0f53c2ff1e6b002c112f4326dfb03186a8 100644
--- a/Code/Mantid/Framework/API/inc/MantidAPI/IFuncMinimizer.h
+++ b/Code/Mantid/Framework/API/inc/MantidAPI/IFuncMinimizer.h
@@ -69,6 +69,10 @@ public:
/// Get value of cost function
virtual double costFunctionVal() = 0;
+ /// Finalize minimization, eg store additional outputs
+ virtual void finalize() {}
+
+
protected:
/// Error string.
std::string m_errorString;
diff --git a/Code/Mantid/Framework/CurveFitting/inc/MantidCurveFitting/FABADAMinimizer.h b/Code/Mantid/Framework/CurveFitting/inc/MantidCurveFitting/FABADAMinimizer.h
index 96c17435ca3dcc78da315df6bd3ab5dfe0435703..751e195e233676fd8a9f8be9af86c8a123189af1 100644
--- a/Code/Mantid/Framework/CurveFitting/inc/MantidCurveFitting/FABADAMinimizer.h
+++ b/Code/Mantid/Framework/CurveFitting/inc/MantidCurveFitting/FABADAMinimizer.h
@@ -40,8 +40,6 @@ public:
/// Constructor
FABADAMinimizer();
virtual ~FABADAMinimizer();
- /// Lo ha puesto Roman y no se para que!! creo que es el destructor
-
/// Name of the minimizer.
std::string name() const { return "FABADA"; }
/// Initialize minimizer, i.e. pass a function to minimize.
@@ -51,6 +49,8 @@ public:
virtual bool iterate(size_t iter);
/// Return current value of the cost function
virtual double costFunctionVal();
+ /// Finalize minimization, eg store additional outputs
+ virtual void finalize();
private:
/// Pointer to the cost function. Must be the least squares.
@@ -85,8 +85,9 @@ private:
std::vector<bool> m_bound;
/// Convergence criteria for each parameter
std::vector<double> m_criteria;
+ /// Maximum number of iterations
+ size_t m_max_iter;
};
-
} // namespace CurveFitting
} // namespace Mantid
diff --git a/Code/Mantid/Framework/CurveFitting/src/FABADAMinimizer.cpp b/Code/Mantid/Framework/CurveFitting/src/FABADAMinimizer.cpp
index 96696fb9f968ab9b92dfeb4ce5bcc19e2f97dc4d..4fb27b06173e78b5e22ab8ee59ff7e9996818884 100644
--- a/Code/Mantid/Framework/CurveFitting/src/FABADAMinimizer.cpp
+++ b/Code/Mantid/Framework/CurveFitting/src/FABADAMinimizer.cpp
@@ -37,41 +37,51 @@ namespace {
Kernel::Logger g_log("FABADAMinimizer");
// absolute maximum number of iterations when fit must converge
const size_t convergenceMaxIterations = 50000;
-// histogram length for the PDF output workspace
-const size_t pdf_length = 50;
// number of iterations when convergence isn't expected
const size_t lowerIterationLimit = 350;
+// very large number
+const double largeNumber = 1e100;
+// jump checking rate
+const size_t jumpCheckingRate = 200;
+// low jump limit
+const double lowJumpLimit = 1e-25;
}
DECLARE_FUNCMINIMIZER(FABADAMinimizer, FABADA)
//----------------------------------------------------------------------------------------------
/// Constructor
-FABADAMinimizer::FABADAMinimizer() : API::IFuncMinimizer(), m_conv_point(0) {
+FABADAMinimizer::FABADAMinimizer() {
declareProperty("ChainLength", static_cast<size_t>(10000),
"Length of the converged chain.");
+ declareProperty("StepsBetweenValues", static_cast<size_t>(10),
+ "Steps realized between keeping each result.");
declareProperty(
- "ConvergenceCriteria", 0.0001,
- "Variance in Chi square for considering convergence reached.");
- declareProperty(new API::WorkspaceProperty<>("OutputWorkspacePDF", "pdf",
- Kernel::Direction::Output),
- "The name to give the output workspace");
- declareProperty(new API::WorkspaceProperty<>("OutputWorkspaceChain", "chain",
+ "ConvergenceCriteria", 0.01,
+ "Variance in Cost Function for considering convergence reached.");
+ declareProperty("JumpAcceptanceRate", 0.6666666,
+ "Desired jumping acceptance rate");
+ declareProperty(
+ new API::WorkspaceProperty<>("PDF", "PDF", Kernel::Direction::Output),
+ "The name to give the output workspace");
+ declareProperty(new API::WorkspaceProperty<>("Chains", "Chain",
Kernel::Direction::Output),
"The name to give the output workspace");
- declareProperty(new API::WorkspaceProperty<>("OutputWorkspaceConverged", "",
- Kernel::Direction::Output,
- API::PropertyMode::Optional),
- "The name to give the output workspace");
- declareProperty(new API::WorkspaceProperty<API::ITableWorkspace>(
- "ChiSquareTable", "chi2", Kernel::Direction::Output),
+ declareProperty(new API::WorkspaceProperty<>(
+ "ConvergedChain", "ConvergedChain",
+ Kernel::Direction::Output, API::PropertyMode::Optional),
"The name to give the output workspace");
+ declareProperty(
+ new API::WorkspaceProperty<API::ITableWorkspace>(
+ "CostFunctionTable", "CostFunction", Kernel::Direction::Output),
+ "The name to give the output workspace");
declareProperty(new API::WorkspaceProperty<API::ITableWorkspace>(
- "PdfError", "pdfE", Kernel::Direction::Output),
+ "Parameters", "Parameters", Kernel::Direction::Output),
"The name to give the output workspace");
}
//----------------------------------------------------------------------------------------------
+
/// Destructor
FABADAMinimizer::~FABADAMinimizer() {}
@@ -114,12 +124,12 @@ void FABADAMinimizer::initialize(API::ICostFunction_sptr function,
if (bcon->hasLower()) {
m_lower.push_back(bcon->lower());
} else {
- m_lower.push_back(-10e100);
+ m_lower.push_back(-largeNumber);
}
if (bcon->hasUpper()) {
m_upper.push_back(bcon->upper());
} else {
- m_upper.push_back(10e100);
+ m_upper.push_back(largeNumber);
}
if (p < m_lower[i]) {
p = m_lower[i];
@@ -130,10 +140,14 @@ void FABADAMinimizer::initialize(API::ICostFunction_sptr function,
m_parameters.set(i, p);
}
}
+ } else {
+ m_lower.push_back(-largeNumber);
+ m_upper.push_back(largeNumber);
}
std::vector<double> v;
v.push_back(p);
m_chain.push_back(v);
+ m_max_iter = maxIterations;
m_changes.push_back(0);
m_par_converged.push_back(false);
m_criteria.push_back(getProperty("ConvergenceCriteria"));
@@ -148,6 +162,7 @@ void FABADAMinimizer::initialize(API::ICostFunction_sptr function,
v.push_back(m_chi2);
m_chain.push_back(v);
m_converged = false;
+ m_max_iter = maxIterations;
}
/// Do one iteration. Returns true if iterations to be continued, false if they
@@ -158,14 +173,14 @@ bool FABADAMinimizer::iterate(size_t) {
throw std::runtime_error("Cost function isn't set up.");
}
- size_t n = m_leastSquares->nParams();
- size_t m = n;
+ size_t nParams = m_leastSquares->nParams();
+ size_t m = nParams;
// Just for the last iteration. For doing exactly the indicated number of
// iterations.
- if (m_converged && m_counter == (m_numberIterations)) {
+ if (m_converged && m_counter == m_numberIterations) {
size_t t = getProperty("ChainLength");
- m = t % n;
+ m = t % nParams;
}
// Do one iteration of FABADA's algorithm for each parameter.
@@ -174,25 +189,17 @@ bool FABADAMinimizer::iterate(size_t) {
// Calculate the step, depending on convergence reached or not
double step;
- if (m_converged) {
+ if (m_converged || m_bound[i]) {
boost::mt19937 mt;
- mt.seed(123 * (int(m_counter) + 45 * int(i)));
-
+ mt.seed(123 * (int(m_counter) +
+ 45 * int(i))); // Numeros inventados para la seed
boost::normal_distribution<double> distr(0.0, std::abs(m_jump[i]));
boost::variate_generator<
boost::mt19937, boost::normal_distribution<double>> gen(mt, distr);
-
step = gen();
-
} else {
step = m_jump[i];
}
- // Couts just for helping when developing when coding
- /// std::cout << std::endl << m_counter << "." << i <<
- /// std::endl<<std::endl<< m_parameters.get(i)<<std::endl; //DELETE AT THE
- /// END
- /// std::cout << "Real step: " << step << " Due to the m_jump: " <<
- /// m_jump[i] << std::endl; //DELETE AT THE END
// Calculate the new value of the parameter
double new_value = m_parameters.get(i) + step;
@@ -200,11 +207,25 @@ bool FABADAMinimizer::iterate(size_t) {
// Comproves if it is inside the boundary constrinctions. If not, changes
// it.
if (m_bound[i]) {
- if (new_value < m_lower[i]) {
- new_value = m_lower[i] + (m_lower[i] - new_value) / 2;
+ while (new_value < m_lower[i]) {
+ if (std::abs(step) > m_upper[i] - m_lower[i]) {
+ new_value = m_parameters.get(i) + step / 10.0;
+ step = step / 10;
+ m_jump[i] = m_jump[i] / 10;
+ } else {
+ new_value =
+ m_lower[i] + std::abs(step) - (m_parameters.get(i) - m_lower[i]);
+ }
}
- if (new_value > m_upper[i]) {
- new_value = m_upper[i] - (new_value - m_upper[i]) / 2;
+ while (new_value > m_upper[i]) {
+ if (std::abs(step) > m_upper[i] - m_lower[i]) {
+ new_value = m_parameters.get(i) + step / 10.0;
+ step = step / 10;
+ m_jump[i] = m_jump[i] / 10;
+ } else {
+ new_value =
+ m_upper[i] - (std::abs(step) + m_parameters.get(i) - m_upper[i]);
+ }
}
}
@@ -216,102 +237,79 @@ bool FABADAMinimizer::iterate(size_t) {
m_leastSquares->setParameter(i, new_value);
double chi2_new = m_leastSquares->val();
- /// std::cout << "OLD Chi2: " << m_chi2 << " NEW Chi2: " << chi2_new
- /// << std::endl; // DELETE AT THE END
-
// If new Chi square value is lower, jumping directly to new parameter
if (chi2_new < m_chi2) {
- for (size_t j = 0; j < n; j++) {
+ for (size_t j = 0; j < nParams; j++) {
m_chain[j].push_back(new_parameters.get(j));
}
- m_chain[n].push_back(chi2_new);
+ m_chain[nParams].push_back(chi2_new);
m_parameters = new_parameters;
m_chi2 = chi2_new;
m_changes[i] += 1;
- /// std::cout << "Salta directamente!!" << std::endl;// DELETE AT THE END
+
}
// If new Chi square value is higher, it depends on the probability
else {
// Calculate probability of change
double prob = exp((m_chi2 / 2.0) - (chi2_new / 2.0));
- /// std::cout << "PROBABILIDAD cambio: " << prob << std::endl;// DELETE
- /// AT THE END
// Decide if changing or not
boost::mt19937 mt;
mt.seed(int(time_t()) + 48 * (int(m_counter) + 76 * int(i)));
boost::uniform_real<> distr(0.0, 1.0);
double p = distr(mt);
- /// std::cout << " Random number " << p << std::endl;// DELETE AT THE END
if (p <= prob) {
- for (size_t j = 0; j < n; j++) {
+ for (size_t j = 0; j < nParams; j++) {
m_chain[j].push_back(new_parameters.get(j));
}
- m_chain[n].push_back(chi2_new);
+ m_chain[nParams].push_back(chi2_new);
m_parameters = new_parameters;
m_chi2 = chi2_new;
m_changes[i] += 1;
- /// std::cout << "SI hay cambio" << std::endl;// DELETE AT THE END
} else {
- for (size_t j = 0; j < n; j++) {
+ for (size_t j = 0; j < nParams; j++) {
m_chain[j].push_back(m_parameters.get(j));
}
- m_chain[n].push_back(m_chi2);
+ m_chain[nParams].push_back(m_chi2);
m_leastSquares->setParameter(i, new_value - m_jump[i]);
m_jump[i] = -m_jump[i];
- /// std::cout << "NO hay cambio" << std::endl;// DELETE AT THE END
}
}
- /// std::cout << std::endl << std::endl << std::endl;// DELETE AT THE END
-
- const size_t jumpCheckingRate = 200;
- const double lowJumpLimit = 1e-15;
+ const double jumpAR = getProperty("JumpAcceptanceRate");
// Update the jump once each jumpCheckingRate iterations
- if (m_counter % jumpCheckingRate == 150) {
+ if (m_counter % jumpCheckingRate == 150) // JUMP CHECKING RATE IS 200, BUT
+ // IS NOT CHECKED AT FIRST STEP, IT
+ // IS AT 150
+ {
double jnew;
- // All this is just a temporal test...
- std::vector<double>::const_iterator first = m_chain[n].end() - 41;
- std::vector<double>::const_iterator last = m_chain[n].end();
- std::vector<double> test(first, last);
- int c = 0;
- for (int j = 0; j < 39; ++j) {
- if (test[j] == test[j + 1]) {
- c += 1;
- }
+ if (m_changes[i] == 0.0) {
+ jnew = m_jump[i] /
+ 10.0; // JUST FOR THE CASE THERE HAS NOT BEEN ANY CHANGE.
+ } else {
+ double f = m_changes[i] / double(m_counter);
+ jnew = m_jump[i] * f / jumpAR;
}
- if (c > 38) {
- jnew = m_jump[i] / 100;
- } // ...untill here.
- else {
- if (m_changes[i] == 0.0) {
- jnew = m_jump[i] / 10.0;
- } else {
- double f = m_changes[i] / double(m_counter);
- jnew = m_jump[i] * f / 0.6666666666;
- /// std::cout << f << " m_counter "<< m_counter << " m_changes
- /// " << m_changes[i] << std::endl; // DELETE AT THE END
- }
- }
m_jump[i] = jnew;
// Check if the new jump is too small. It means that it has been a wrong
// convergence.
if (std::abs(m_jump[i]) < lowJumpLimit) {
API::IFunction_sptr fun = m_leastSquares->getFittingFunction();
- throw std::runtime_error(
- "Wrong convergence for parameter " + fun->parameterName(i) +
- ". Try to set a proper initial value this parameter");
+ g_log.warning()
+ << "Wrong convergence for parameter " + fun->parameterName(i) +
+ ". Try to set a proper initial value for this parameter"
+ << std::endl;
}
}
// Check if the Chi square value has converged for parameter i.
- if (!m_par_converged[i] &&
- m_counter > 350) // It only check since the iteration number 350
- {
+ const size_t startingPoint =
+ 350; // The iteration since it starts to check if convergence is reached
+ if (!m_par_converged[i] && m_counter > startingPoint) {
if (chi2_new != m_chi2) {
double chi2_quotient = std::abs(chi2_new - m_chi2) / m_chi2;
if (chi2_quotient < m_criteria[i]) {
@@ -319,28 +317,28 @@ bool FABADAMinimizer::iterate(size_t) {
}
}
}
- }
+ } // for i
- m_counter +=
- 1; // Update the counter, after finishing the iteration for each parameter
+ // Update the counter, after finishing the iteration for each parameter
+ m_counter += 1;
// Check if Chi square has converged for all the parameters.
if (m_counter > lowerIterationLimit && !m_converged) {
size_t t = 0;
- for (size_t i = 0; i < n; i++) {
+ for (size_t i = 0; i < nParams; i++) {
if (m_par_converged[i]) {
t += 1;
}
}
// If all parameters have converged:
// It set up both the counter and the changes' vector to 0, in order to
- // consider only the
- // data of the converged part of the chain, when updating the jump.
- if (t == n) {
+ // consider only the data of the converged part of the chain, when updating
+ // the jump.
+ if (t == nParams) {
m_converged = true;
- m_conv_point = m_counter * n + 1;
+ m_conv_point = m_counter * nParams + 1;
m_counter = 0;
- for (size_t i = 0; i < n; ++i) {
+ for (size_t i = 0; i < nParams; ++i) {
m_changes[i] = 0;
}
}
@@ -357,7 +355,7 @@ bool FABADAMinimizer::iterate(size_t) {
else {
API::IFunction_sptr fun = m_leastSquares->getFittingFunction();
std::string failed = "";
- for (size_t i = 0; i < n; ++i) {
+ for (size_t i = 0; i < nParams; ++i) {
if (!m_par_converged[i]) {
failed = failed + fun->parameterName(i) + ", ";
}
@@ -365,7 +363,7 @@ bool FABADAMinimizer::iterate(size_t) {
failed.replace(failed.end() - 2, failed.end(), ".");
throw std::runtime_error(
"Convegence NOT reached after " +
- boost::lexical_cast<std::string>(m_counter) +
+ boost::lexical_cast<std::string>(m_max_iter) +
" iterations.\n Try to set better initial values for parameters: " +
failed);
}
@@ -375,176 +373,262 @@ bool FABADAMinimizer::iterate(size_t) {
if (m_counter <= m_numberIterations) {
return true;
}
- // When the all the iterations have been done, calculate and show all the
- // results.
- else {
- // Create the workspace for the Probability Density Functions
- API::MatrixWorkspace_sptr ws = API::WorkspaceFactory::Instance().create(
- "Workspace2D", n, pdf_length + 1, pdf_length);
-
- // Create the workspace for the parameters' value and errors.
- API::ITableWorkspace_sptr wsPdfE =
- API::WorkspaceFactory::Instance().createTable("TableWorkspace");
- wsPdfE->addColumn("str", "Name");
- wsPdfE->addColumn("double", "Value");
- wsPdfE->addColumn("double", "Left's error");
- wsPdfE->addColumn("double", "Rigth's error");
-
- std::vector<double>::iterator pos_min = std::min_element(
- m_chain[n].begin() + m_conv_point,
- m_chain[n]
- .end()); // Calculate the position of the minimum Chi aquare value
- m_chi2 = *pos_min;
- // index of the minimum chi^2
- size_t minIndex =
- static_cast<size_t>(std::distance(m_chain[n].begin(), pos_min));
-
- std::vector<double> par_def(n);
- API::IFunction_sptr fun = m_leastSquares->getFittingFunction();
+ // If convergence has been reached, but the maximum of iterations have been
+ // reached before finishing the chain, stop and throw the error.
+ if (m_counter >= m_max_iter) {
+ throw std::length_error("Convegence reached but Max Iterations parameter "
+ "insufficient for creating the whole chain.\n "
+ "Increase Max Iterations");
+ }
+ // nothing else to do, stop interations
+ return false;
+ }
+ // can we even get here?
+ return true;
+}
- // Do one iteration for each parameter.
- for (size_t j = 0; j < n; ++j) {
- // Calculate the parameter value and the errors
- par_def[j] = m_chain[j][minIndex];
- std::vector<double>::const_iterator first =
- m_chain[j].begin() + m_conv_point;
- std::vector<double>::const_iterator last = m_chain[j].end();
- std::vector<double> conv_chain(first, last);
- size_t conv_length = conv_chain.size();
- std::sort(conv_chain.begin(), conv_chain.end());
- std::vector<double>::const_iterator pos_par =
- std::find(conv_chain.begin(), conv_chain.end(), par_def[j]);
- int sigma = int(0.34 * double(conv_length));
- // make sure the iterator is valid in any case
- std::vector<double>::const_iterator pos_left = conv_chain.begin();
- if (sigma < static_cast<int>(std::distance(pos_left, pos_par))) {
- pos_left = pos_par - sigma;
- }
- // make sure the iterator is valid in any case
- std::vector<double>::const_iterator pos_right = conv_chain.end() - 1;
- if (sigma < static_cast<int>(std::distance(pos_par, pos_right))) {
- pos_right = pos_par + sigma;
- }
- API::TableRow row = wsPdfE->appendRow();
- row << fun->parameterName(j) << par_def[j] << *pos_left - *pos_par
- << *pos_right - *pos_par;
-
- // Calculate the Probability Density Function
- std::vector<double> pdf_y(pdf_length, 0);
- double start = conv_chain[0];
- double bin = (conv_chain[conv_length - 1] - start) / pdf_length;
- size_t step = 0;
- MantidVec &X = ws->dataX(j);
- MantidVec &Y = ws->dataY(j);
- X[0] = start;
- for (size_t i = 1; i < pdf_length + 1; i++) {
- double bin_end = start + static_cast<double>(i) * bin;
- X[i] = bin_end;
- while (step < conv_length && conv_chain[step] <= bin_end) {
- pdf_y[i - 1] += 1;
- ++step;
- }
- Y[i - 1] = pdf_y[i - 1] / (double(conv_length) * bin);
- }
+double FABADAMinimizer::costFunctionVal() { return m_chi2; }
- // Calculate the most probable value, from the PDF.
- std::vector<double>::iterator pos_MP =
- std::max_element(pdf_y.begin(), pdf_y.end());
- double mostP = X[pos_MP - pdf_y.begin()] + (bin / 2.0);
- m_leastSquares->setParameter(j, mostP);
- }
+/// When the all the iterations have been done, calculate and show all the
+/// results.
+void FABADAMinimizer::finalize() {
+ // Creating the reduced chain (considering only one each "Steps between
+ // values" values)
+ size_t cl = getProperty("ChainLength");
+ size_t n_steps = getProperty("StepsBetweenValues");
+ size_t conv_length = size_t(double(cl) / double(n_steps));
+ std::vector<std::vector<double>> red_conv_chain;
+ size_t nParams = m_leastSquares->nParams();
+ for (size_t e = 0; e <= nParams; ++e) {
+ std::vector<double> v;
+ v.push_back(m_chain[e][m_conv_point]);
+ red_conv_chain.push_back(v);
+ }
- // Set and name the two workspaces already calculated.
- setProperty("OutputWorkspacePDF", ws);
- setProperty("PdfError", wsPdfE);
-
- // Create the workspace for the complete parameters' chain (the last
- // histogram is for the Chi square).
- size_t chain_length = m_chain[0].size();
- API::MatrixWorkspace_sptr wsC = API::WorkspaceFactory::Instance().create(
- "Workspace2D", n + 1, chain_length, chain_length);
-
- // Do one iteration for each parameter plus one for Chi square.
- for (size_t j = 0; j < n + 1; ++j) {
- MantidVec &X = wsC->dataX(j);
- MantidVec &Y = wsC->dataY(j);
- for (size_t k = 0; k < chain_length; ++k) {
- X[k] = double(k);
- Y[k] = m_chain[j][k];
- }
+ // Calculate the red_conv_chain for the cost fuction.
+ auto first = m_chain[nParams].begin() + m_conv_point;
+ auto last = m_chain[nParams].end();
+ std::vector<double> conv_chain(first, last);
+ for (size_t k = 1; k < conv_length; ++k) {
+ red_conv_chain[nParams].push_back(conv_chain[n_steps * k]);
+ }
+
+ // Calculate the position of the minimum Chi square value
+ auto pos_min = std::min_element(red_conv_chain[nParams].begin(),
+ red_conv_chain[nParams].end());
+ m_chi2 = *pos_min;
+
+ std::vector<double> par_def(nParams);
+ std::vector<double> error_left(nParams);
+ std::vector<double> error_rigth(nParams);
+ API::IFunction_sptr fun = m_leastSquares->getFittingFunction();
+
+ // Do one iteration for each parameter.
+ for (size_t j = 0; j < nParams; ++j) {
+ // Calculate the parameter value and the errors
+ auto first = m_chain[j].begin() + m_conv_point;
+ auto last = m_chain[j].end();
+ std::vector<double> conv_chain(first, last);
+ auto &rc_chain_j = red_conv_chain[j];
+ for (size_t k = 0; k < conv_length; ++k) {
+ rc_chain_j.push_back(conv_chain[n_steps * k]);
+ }
+ par_def[j] = rc_chain_j[pos_min - red_conv_chain[nParams].begin()];
+ std::sort(rc_chain_j.begin(), rc_chain_j.end());
+ auto pos_par = std::find(rc_chain_j.begin(), rc_chain_j.end(), par_def[j]);
+ size_t sigma = static_cast<size_t>(0.34 * double(conv_length));
+
+ auto pos_left = rc_chain_j.begin();
+ if (sigma < static_cast<size_t>(std::distance(pos_left, pos_par))) {
+ pos_left = pos_par - sigma;
+ }
+ // make sure the iterator is valid in any case
+ auto pos_right = rc_chain_j.end() - 1;
+ if (sigma < static_cast<size_t>(std::distance(pos_par, pos_right))) {
+ pos_right = pos_par + sigma;
+ }
+ error_left[j] = *pos_left - *pos_par;
+ error_rigth[j] = *pos_right - *pos_par;
+ }
+
+ const bool outputParametersTable = !getPropertyValue("Parameters").empty();
+
+ if (outputParametersTable) {
+
+ // Create the workspace for the parameters' value and errors.
+ API::ITableWorkspace_sptr wsPdfE =
+ API::WorkspaceFactory::Instance().createTable("TableWorkspace");
+ wsPdfE->addColumn("str", "Name");
+ wsPdfE->addColumn("double", "Value");
+ wsPdfE->addColumn("double", "Left's error");
+ wsPdfE->addColumn("double", "Rigth's error");
+
+ for (size_t j = 0; j < nParams; ++j) {
+ API::TableRow row = wsPdfE->appendRow();
+ row << fun->parameterName(j) << par_def[j] << error_left[j]
+ << error_rigth[j];
+ }
+ // Set and name the Parameter Errors workspace.
+ setProperty("Parameters", wsPdfE);
+ }
+
+ // Set the best parameter values
+ for (size_t j = 0; j < nParams; ++j) {
+ m_leastSquares->setParameter(j, par_def[j]);
+ }
+
+ double mostPchi2;
+
+ // Create the workspace for the Probability Density Functions
+ size_t pdf_length = 20; // histogram length for the PDF output workspace
+ API::MatrixWorkspace_sptr ws = API::WorkspaceFactory::Instance().create(
+ "Workspace2D", nParams + 1, pdf_length + 1, pdf_length);
+
+ // Calculate the cost function Probability Density Function
+ std::sort(red_conv_chain[nParams].begin(), red_conv_chain[nParams].end());
+ std::vector<double> pdf_y(pdf_length, 0);
+ double start = red_conv_chain[nParams][0];
+ double bin =
+ (red_conv_chain[nParams][conv_length - 1] - start) / double(pdf_length);
+ size_t step = 0;
+ MantidVec &X = ws->dataX(nParams);
+ MantidVec &Y = ws->dataY(nParams);
+ X[0] = start;
+ for (size_t i = 1; i < pdf_length + 1; i++) {
+ double bin_end = start + double(i) * bin;
+ X[i] = bin_end;
+ while (step < conv_length && red_conv_chain[nParams][step] <= bin_end) {
+ pdf_y[i - 1] += 1;
+ ++step;
+ }
+ Y[i - 1] = pdf_y[i - 1] / (double(conv_length) * bin);
+ }
+
+ std::vector<double>::iterator pos_MPchi2 =
+ std::max_element(pdf_y.begin(), pdf_y.end());
+
+ if (pos_MPchi2 - pdf_y.begin() == 0) {
+ // mostPchi2 = X[pos_MPchi2-pdf_y.begin()];
+ mostPchi2 = *pos_min;
+ } else {
+ mostPchi2 = X[pos_MPchi2 - pdf_y.begin()] + (bin / 2.0);
+ }
+
+ // Do one iteration for each parameter.
+ for (size_t j = 0; j < nParams; ++j) {
+ // Calculate the Probability Density Function
+ std::vector<double> pdf_y(pdf_length, 0);
+ double start = red_conv_chain[j][0];
+ double bin =
+ (red_conv_chain[j][conv_length - 1] - start) / double(pdf_length);
+ size_t step = 0;
+ MantidVec &X = ws->dataX(j);
+ MantidVec &Y = ws->dataY(j);
+ X[0] = start;
+ for (size_t i = 1; i < pdf_length + 1; i++) {
+ double bin_end = start + double(i) * bin;
+ X[i] = bin_end;
+ while (step < conv_length && red_conv_chain[j][step] <= bin_end) {
+ pdf_y[i - 1] += 1;
+ ++step;
}
+ Y[i - 1] = pdf_y[i - 1] / (double(conv_length) * bin);
+ }
- // Set and name the workspace for the complete chain
- setProperty("OutputWorkspaceChain", wsC);
-
- // Read if necessary to show the workspace for the converged part of the
- // chain.
- const bool con = !getPropertyValue("OutputWorkspaceConverged").empty();
-
- if (con) {
- // Create the workspace for the converged part of the chain.
- size_t conv_length = (m_counter - 1) * n + m;
- API::MatrixWorkspace_sptr wsConv =
- API::WorkspaceFactory::Instance().create("Workspace2D", n + 1,
- conv_length, conv_length);
-
- // Do one iteration for each parameter plus one for Chi square.
- for (size_t j = 0; j < n + 1; ++j) {
- std::vector<double>::const_iterator first =
- m_chain[j].begin() + m_conv_point;
- std::vector<double>::const_iterator last = m_chain[j].end();
- std::vector<double> conv_chain(first, last);
- MantidVec &X = wsConv->dataX(j);
- MantidVec &Y = wsConv->dataY(j);
- for (size_t k = 0; k < conv_length; ++k) {
- X[k] = double(k);
- Y[k] = conv_chain[k];
- }
- }
+ // Calculate the most probable value, from the PDF.
+ std::vector<double>::iterator pos_MP =
+ std::max_element(pdf_y.begin(), pdf_y.end());
+ double mostP = X[pos_MP - pdf_y.begin()] + (bin / 2.0);
+ m_leastSquares->setParameter(j, mostP);
+ }
+
+ // Set and name the PDF workspace.
+ setProperty("PDF", ws);
- // Set and name the workspace for the converged part of the chain.
- setProperty("OutputWorkspaceConverged", wsConv);
+ const bool outputChains = !getPropertyValue("Chains").empty();
+
+ if (outputChains) {
+
+ // Create the workspace for the complete parameters' chain (the last
+ // histogram is for the Chi square).
+ size_t chain_length = m_chain[0].size();
+ API::MatrixWorkspace_sptr wsC = API::WorkspaceFactory::Instance().create(
+ "Workspace2D", nParams + 1, chain_length, chain_length);
+
+ // Do one iteration for each parameter plus one for Chi square.
+ for (size_t j = 0; j < nParams + 1; ++j) {
+ MantidVec &X = wsC->dataX(j);
+ MantidVec &Y = wsC->dataY(j);
+ for (size_t k = 0; k < chain_length; ++k) {
+ X[k] = double(k);
+ Y[k] = m_chain[j][k];
}
+ }
- // Create the workspace for the Chi square values.
- API::ITableWorkspace_sptr wsChi2 =
- API::WorkspaceFactory::Instance().createTable("TableWorkspace");
- wsChi2->addColumn("double", "Chi2min");
- wsChi2->addColumn("double", "Chi2MP");
- wsChi2->addColumn("double", "Chi2min_red");
- wsChi2->addColumn("double", "Chi2MP_red");
-
- // Calculate de Chi square most probable.
- double Chi2MP = m_leastSquares->val();
-
- // Reset the best parameter values ---> Si al final no se muestra la tabla
- // que sale por defecto, esto se podra borrar...
- for (size_t j = 0; j < n; ++j) {
- m_leastSquares->setParameter(j, par_def[j]);
+ // Set and name the workspace for the complete chain
+ setProperty("Chains", wsC);
+ }
+
+ // Read if necessary to show the workspace for the converged part of the
+ // chain.
+ const bool outputConvergedChains = !getPropertyValue("ConvergedChain").empty();
+
+ if (outputConvergedChains) {
+ // Create the workspace for the converged part of the chain.
+ API::MatrixWorkspace_sptr wsConv = API::WorkspaceFactory::Instance().create(
+ "Workspace2D", nParams + 1, conv_length, conv_length);
+
+ // Do one iteration for each parameter plus one for Chi square.
+ for (size_t j = 0; j < nParams + 1; ++j) {
+ std::vector<double>::const_iterator first =
+ m_chain[j].begin() + m_conv_point;
+ std::vector<double>::const_iterator last = m_chain[j].end();
+ std::vector<double> conv_chain(first, last);
+ MantidVec &X = wsConv->dataX(j);
+ MantidVec &Y = wsConv->dataY(j);
+ for (size_t k = 0; k < conv_length; ++k) {
+ X[k] = double(k);
+ Y[k] = conv_chain[n_steps * k];
}
+ }
- // Obtain the quantity of the initial data.
- API::FunctionDomain_sptr domain = m_leastSquares->getDomain();
- size_t data_number = domain->size();
+ // Set and name the workspace for the converged part of the chain.
+ setProperty("ConvergedChain", wsConv);
+ }
- // Calculate the value for the reduced Chi square.
- double Chi2min_red =
- *pos_min / (double(data_number - n)); // For de minimum value.
- double Chi2MP_red =
- Chi2MP / (double(data_number - n)); // For the most probable.
+ // Read if necessary to show the workspace for the Chi square values.
+ const bool outputCostFunctionTable = !getPropertyValue("CostFunctionTable").empty();
- // Add the information to the workspace and name it.
- API::TableRow row = wsChi2->appendRow();
- row << *pos_min << Chi2MP << Chi2min_red << Chi2MP_red;
- setProperty("ChiSquareTable", wsChi2);
+ if (outputCostFunctionTable) {
- return false;
- }
+ // Create the workspace for the Chi square values.
+ API::ITableWorkspace_sptr wsChi2 =
+ API::WorkspaceFactory::Instance().createTable("TableWorkspace");
+ wsChi2->addColumn("double", "Chi2min");
+ wsChi2->addColumn("double", "Chi2MP");
+ wsChi2->addColumn("double", "Chi2min_red");
+ wsChi2->addColumn("double", "Chi2MP_red");
+
+ // Obtain the quantity of the initial data.
+ API::FunctionDomain_sptr domain = m_leastSquares->getDomain();
+ size_t data_number = domain->size();
+
+ // Calculate the value for the reduced Chi square.
+ double Chi2min_red =
+ m_chi2 / (double(data_number - nParams)); // For de minimum value.
+ double mostPchi2_red = mostPchi2 / (double(data_number - nParams));
+
+ // Add the information to the workspace and name it.
+ API::TableRow row = wsChi2->appendRow();
+ row << m_chi2 << mostPchi2 << Chi2min_red << mostPchi2_red;
+ setProperty("CostFunctionTable", wsChi2);
}
- return true;
+ // Set the best parameter values
+ for (size_t j = 0; j < nParams; ++j) {
+ m_leastSquares->setParameter(j, par_def[j]);
+ }
}
-double FABADAMinimizer::costFunctionVal() { return m_chi2; }
} // namespace CurveFitting
} // namespace Mantid
diff --git a/Code/Mantid/Framework/CurveFitting/src/Fit.cpp b/Code/Mantid/Framework/CurveFitting/src/Fit.cpp
index b0e1c9b99b332dfb5a691440a0984ed531e29c7f..691c124409b3ae99a5e9cba7499b0da0d525bcd7 100644
--- a/Code/Mantid/Framework/CurveFitting/src/Fit.cpp
+++ b/Code/Mantid/Framework/CurveFitting/src/Fit.cpp
@@ -445,6 +445,8 @@ void Fit::exec() {
}
g_log.debug() << "Number of minimizer iterations=" << iter << "\n";
+ minimizer->finalize();
+
if (iter >= maxIterations) {
if (!errorString.empty()) {
errorString += '\n';
diff --git a/Code/Mantid/Framework/CurveFitting/test/FABADAMinimizerTest.h b/Code/Mantid/Framework/CurveFitting/test/FABADAMinimizerTest.h
index a8f1857f0f065c6b8cbb6b988828c70a02a36323..54ce15e4a07bfeecd967620864af4b4f26a2c64b 100644
--- a/Code/Mantid/Framework/CurveFitting/test/FABADAMinimizerTest.h
+++ b/Code/Mantid/Framework/CurveFitting/test/FABADAMinimizerTest.h
@@ -13,171 +13,166 @@
#include "MantidTestHelpers/FakeObjects.h"
#include "MantidKernel/Exception.h"
-
using Mantid::CurveFitting::FABADAMinimizer;
using namespace Mantid::API;
using namespace Mantid;
using namespace Mantid::CurveFitting;
-class FABADAMinimizerTest : public CxxTest::TestSuite
-{
+class FABADAMinimizerTest : public CxxTest::TestSuite {
public:
// This pair of boilerplate methods prevent the suite being created statically
// This means the constructor isn't called when running other tests
- static FABADAMinimizerTest *createSuite() { return new FABADAMinimizerTest(); }
- static void destroySuite( FABADAMinimizerTest *suite ) { delete suite; }
-
+ static FABADAMinimizerTest *createSuite() {
+ return new FABADAMinimizerTest();
+ }
+ static void destroySuite(FABADAMinimizerTest *suite) { delete suite; }
- void test_expDecay()
- {
- const bool histogram(false);
- auto ws2 = createTestWorkspace(histogram);
+ void test_expDecay() {
+ auto ws2 = createTestWorkspace();
API::IFunction_sptr fun(new ExpDecay);
- fun->setParameter("Height",8.);
- fun->setParameter("Lifetime",1.0);
+ fun->setParameter("Height", 8.);
+ fun->setParameter("Lifetime", 1.0);
Fit fit;
fit.initialize();
fit.setRethrows(true);
- fit.setProperty("Function",fun);
- fit.setProperty("InputWorkspace",ws2);
- fit.setProperty("WorkspaceIndex",0);
- fit.setProperty("CreateOutput",true);
- fit.setProperty("MaxIterations",100000);
- fit.setProperty("Minimizer", "FABADA,ChainLength=5000,ConvergenceCriteria = 0.1, OutputWorkspaceConverged=conv");
+ fit.setProperty("Function", fun);
+ fit.setProperty("InputWorkspace", ws2);
+ fit.setProperty("WorkspaceIndex", 0);
+ fit.setProperty("CreateOutput", true);
+ fit.setProperty("MaxIterations", 100000);
+ fit.setProperty("Minimizer", "FABADA,ChainLength=5000,StepsBetweenValues="
+ "10,ConvergenceCriteria = 0.1");
- TS_ASSERT_THROWS_NOTHING( fit.execute() );
+ TS_ASSERT_THROWS_NOTHING(fit.execute());
TS_ASSERT(fit.isExecuted());
- TS_ASSERT_DELTA( fun->getParameter("Height"), 10.0, 1e-1);
- TS_ASSERT_DELTA( fun->getParameter("Lifetime"), 0.5, 1e-2);
+ TS_ASSERT_DELTA(fun->getParameter("Height"), 10.0, 0.7);
+ TS_ASSERT_DELTA(fun->getParameter("Lifetime"), 0.5, 0.1);
+ TS_ASSERT_DELTA(fun->getError(0), 0.7, 1e-1);
+ TS_ASSERT_DELTA(fun->getError(1), 0.06, 1e-2);
TS_ASSERT_EQUALS(fit.getPropertyValue("OutputStatus"), "success");
- size_t n = fun -> nParams();
+ size_t n = fun->nParams();
- TS_ASSERT( AnalysisDataService::Instance().doesExist("pdf") );
+ TS_ASSERT(AnalysisDataService::Instance().doesExist("PDF"));
MatrixWorkspace_sptr wsPDF = boost::dynamic_pointer_cast<MatrixWorkspace>(
- API::AnalysisDataService::Instance().retrieve("pdf"));
+ API::AnalysisDataService::Instance().retrieve("PDF"));
TS_ASSERT(wsPDF);
- TS_ASSERT_EQUALS(wsPDF->getNumberHistograms(),n);
-
- const Mantid::MantidVec& X = wsPDF->dataX(0);
- const Mantid::MantidVec& Y = wsPDF->dataY(0);
- TS_ASSERT_EQUALS(X.size(), 51);
- TS_ASSERT_EQUALS(Y.size(), 50);
-
- TS_ASSERT( AnalysisDataService::Instance().doesExist("chi2") );
- ITableWorkspace_sptr chi2table = boost::dynamic_pointer_cast<ITableWorkspace>(
- API::AnalysisDataService::Instance().retrieve("chi2"));
-
- TS_ASSERT(chi2table);
- TS_ASSERT_EQUALS(chi2table->columnCount(), 4);
- TS_ASSERT_EQUALS(chi2table->rowCount(), 1);
- TS_ASSERT_EQUALS(chi2table->getColumn(0)->type(), "double");
- TS_ASSERT_EQUALS(chi2table->getColumn(0)->name(), "Chi2min");
- TS_ASSERT_EQUALS(chi2table->getColumn(1)->type(), "double");
- TS_ASSERT_EQUALS(chi2table->getColumn(1)->name(), "Chi2MP");
- TS_ASSERT_EQUALS(chi2table->getColumn(2)->type(), "double");
- TS_ASSERT_EQUALS(chi2table->getColumn(2)->name(), "Chi2min_red");
- TS_ASSERT_EQUALS(chi2table->getColumn(3)->type(), "double");
- TS_ASSERT_EQUALS(chi2table->getColumn(3)->name(), "Chi2MP_red");
- TS_ASSERT(chi2table->Double(0,0) <= chi2table->Double(0,1));
- TS_ASSERT(chi2table->Double(0,2) <= chi2table->Double(0,3));
- TS_ASSERT_DELTA(chi2table->Double(0,0), chi2table->Double(0,1), 1);
- TS_ASSERT_DELTA(chi2table->Double(0,0), 0.0, 1.0);
-
- TS_ASSERT( AnalysisDataService::Instance().doesExist("conv") );
+ TS_ASSERT_EQUALS(wsPDF->getNumberHistograms(), n + 1);
+
+ const Mantid::MantidVec &X = wsPDF->dataX(0);
+ const Mantid::MantidVec &Y = wsPDF->dataY(0);
+ TS_ASSERT_EQUALS(X.size(), 21);
+ TS_ASSERT_EQUALS(Y.size(), 20);
+
+ TS_ASSERT(AnalysisDataService::Instance().doesExist("CostFunction"));
+ ITableWorkspace_sptr CostFunctionTable =
+ boost::dynamic_pointer_cast<ITableWorkspace>(
+ API::AnalysisDataService::Instance().retrieve("CostFunction"));
+
+ TS_ASSERT(CostFunctionTable);
+ TS_ASSERT_EQUALS(CostFunctionTable->columnCount(), 4);
+ TS_ASSERT_EQUALS(CostFunctionTable->rowCount(), 1);
+ TS_ASSERT_EQUALS(CostFunctionTable->getColumn(0)->type(), "double");
+ TS_ASSERT_EQUALS(CostFunctionTable->getColumn(0)->name(), "Chi2min");
+ TS_ASSERT_EQUALS(CostFunctionTable->getColumn(1)->type(), "double");
+ TS_ASSERT_EQUALS(CostFunctionTable->getColumn(1)->name(), "Chi2MP");
+ TS_ASSERT_EQUALS(CostFunctionTable->getColumn(2)->type(), "double");
+ TS_ASSERT_EQUALS(CostFunctionTable->getColumn(2)->name(), "Chi2min_red");
+ TS_ASSERT_EQUALS(CostFunctionTable->getColumn(3)->type(), "double");
+ TS_ASSERT_EQUALS(CostFunctionTable->getColumn(3)->name(), "Chi2MP_red");
+ TS_ASSERT(CostFunctionTable->Double(0, 0) <=
+ CostFunctionTable->Double(0, 1));
+ TS_ASSERT(CostFunctionTable->Double(0, 2) <=
+ CostFunctionTable->Double(0, 3));
+ //TS_ASSERT_DELTA(CostFunctionTable->Double(0, 0),
+ // CostFunctionTable->Double(0, 1), 1.5);
+ TS_ASSERT_DELTA(CostFunctionTable->Double(0, 0), 0.0, 1.0);
+
+ TS_ASSERT(AnalysisDataService::Instance().doesExist("ConvergedChain"));
MatrixWorkspace_sptr wsConv = boost::dynamic_pointer_cast<MatrixWorkspace>(
- API::AnalysisDataService::Instance().retrieve("conv"));
+ API::AnalysisDataService::Instance().retrieve("ConvergedChain"));
TS_ASSERT(wsConv);
- TS_ASSERT_EQUALS(wsConv->getNumberHistograms(),n+1);
+ TS_ASSERT_EQUALS(wsConv->getNumberHistograms(), n + 1);
- const Mantid::MantidVec& Xconv = wsConv->dataX(0);
- TS_ASSERT_EQUALS(Xconv.size(), 5000);
- TS_ASSERT_EQUALS(Xconv[2437], 2437);
+ const Mantid::MantidVec &Xconv = wsConv->dataX(0);
+ TS_ASSERT_EQUALS(Xconv.size(), 500);
+ TS_ASSERT_EQUALS(Xconv[437], 437);
- TS_ASSERT( AnalysisDataService::Instance().doesExist("chain") );
+ TS_ASSERT(AnalysisDataService::Instance().doesExist("chain"));
MatrixWorkspace_sptr wsChain = boost::dynamic_pointer_cast<MatrixWorkspace>(
- API::AnalysisDataService::Instance().retrieve("chain"));
+ API::AnalysisDataService::Instance().retrieve("chain"));
TS_ASSERT(wsChain);
- TS_ASSERT_EQUALS(wsChain->getNumberHistograms(),n+1);
+ TS_ASSERT_EQUALS(wsChain->getNumberHistograms(), n + 1);
- const Mantid::MantidVec& Xchain = wsChain->dataX(0);
- TS_ASSERT_EQUALS(Xchain.size(), 6881);
+ const Mantid::MantidVec &Xchain = wsChain->dataX(0);
TS_ASSERT_EQUALS(Xchain[5000], 5000);
TS_ASSERT(Xconv.size() < Xchain.size());
- TS_ASSERT( AnalysisDataService::Instance().doesExist("pdfE") );
- ITableWorkspace_sptr Etable = boost::dynamic_pointer_cast<ITableWorkspace>(
- API::AnalysisDataService::Instance().retrieve("pdfE"));
-
- TS_ASSERT(Etable);
- TS_ASSERT_EQUALS(Etable->columnCount(), 4);
- TS_ASSERT_EQUALS(Etable->rowCount(), n);
- TS_ASSERT_EQUALS(Etable->getColumn(0)->type(), "str");
- TS_ASSERT_EQUALS(Etable->getColumn(0)->name(), "Name");
- TS_ASSERT_EQUALS(Etable->getColumn(1)->type(), "double");
- TS_ASSERT_EQUALS(Etable->getColumn(1)->name(), "Value");
- TS_ASSERT_EQUALS(Etable->getColumn(2)->type(), "double");
- TS_ASSERT_EQUALS(Etable->getColumn(2)->name(), "Left's error");
- TS_ASSERT_EQUALS(Etable->getColumn(3)->type(), "double");
- TS_ASSERT_EQUALS(Etable->getColumn(3)->name(), "Rigth's error");
- TS_ASSERT(Etable->Double(0,1) == fun->getParameter("Height"));
- TS_ASSERT(Etable->Double(1,1) == fun->getParameter("Lifetime"));
-
+ TS_ASSERT(AnalysisDataService::Instance().doesExist("Parameters"));
+ ITableWorkspace_sptr Ptable = boost::dynamic_pointer_cast<ITableWorkspace>(
+ API::AnalysisDataService::Instance().retrieve("Parameters"));
+
+ TS_ASSERT(Ptable);
+ TS_ASSERT_EQUALS(Ptable->columnCount(), 4);
+ TS_ASSERT_EQUALS(Ptable->rowCount(), n);
+ TS_ASSERT_EQUALS(Ptable->getColumn(0)->type(), "str");
+ TS_ASSERT_EQUALS(Ptable->getColumn(0)->name(), "Name");
+ TS_ASSERT_EQUALS(Ptable->getColumn(1)->type(), "double");
+ TS_ASSERT_EQUALS(Ptable->getColumn(1)->name(), "Value");
+ TS_ASSERT_EQUALS(Ptable->getColumn(2)->type(), "double");
+ TS_ASSERT_EQUALS(Ptable->getColumn(2)->name(), "Left's error");
+ TS_ASSERT_EQUALS(Ptable->getColumn(3)->type(), "double");
+ TS_ASSERT_EQUALS(Ptable->getColumn(3)->name(), "Rigth's error");
+ TS_ASSERT(Ptable->Double(0, 1) == fun->getParameter("Height"));
+ TS_ASSERT(Ptable->Double(1, 1) == fun->getParameter("Lifetime"));
}
- void test_low_MaxIterations()
- {
- const bool histogram(false);
- auto ws2 = createTestWorkspace(histogram);
+ void test_low_MaxIterations() {
+ auto ws2 = createTestWorkspace();
API::IFunction_sptr fun(new ExpDecay);
- fun->setParameter("Height",1.);
- fun->setParameter("Lifetime",1.0);
+ fun->setParameter("Height", 1.);
+ fun->setParameter("Lifetime", 1.0);
Fit fit;
fit.initialize();
fit.setRethrows(true);
- fit.setProperty("Function",fun);
- fit.setProperty("InputWorkspace",ws2);
- fit.setProperty("WorkspaceIndex",0);
- fit.setProperty("CreateOutput",true);
- fit.setProperty("MaxIterations",10);
- fit.setProperty("Minimizer", "FABADA,ChainLength=5000,ConvergenceCriteria = 0.01, OutputWorkspaceConverged=conv");
-
- TS_ASSERT_THROWS( fit.execute(), std::runtime_error );
+ fit.setProperty("Function", fun);
+ fit.setProperty("InputWorkspace", ws2);
+ fit.setProperty("WorkspaceIndex", 0);
+ fit.setProperty("CreateOutput", true);
+ fit.setProperty("MaxIterations", 10);
+ fit.setProperty("Minimizer", "FABADA,ChainLength=5000,StepsBetweenValues="
+ "10,ConvergenceCriteria = 0.01");
- TS_ASSERT( !fit.isExecuted() );
+ TS_ASSERT_THROWS(fit.execute(), std::runtime_error);
+ TS_ASSERT(!fit.isExecuted());
}
-private:
- API::MatrixWorkspace_sptr createTestWorkspace(const bool histogram)
- {
+private:
+ API::MatrixWorkspace_sptr createTestWorkspace() {
MatrixWorkspace_sptr ws2(new WorkspaceTester);
- ws2->initialize(2,20,20);
-
- for(size_t is = 0; is < ws2->getNumberHistograms(); ++is)
- {
- Mantid::MantidVec& x = ws2->dataX(is);
- Mantid::MantidVec& y = ws2->dataY(is);
- for(size_t i = 0; i < ws2->blocksize(); ++i)
- {
+ ws2->initialize(2, 20, 20);
+
+ for (size_t is = 0; is < ws2->getNumberHistograms(); ++is) {
+ Mantid::MantidVec &x = ws2->dataX(is);
+ Mantid::MantidVec &y = ws2->dataY(is);
+ for (size_t i = 0; i < ws2->blocksize(); ++i) {
x[i] = 0.1 * double(i);
- y[i] = (10.0 + double(is)) * exp( -(x[i])/ (0.5*(1 + double(is))) );
+ y[i] = (10.0 + double(is)) * exp(-(x[i]) / (0.5 * (1 + double(is))));
}
- if(histogram) x.back() = x[x.size()-2] + 0.1;
}
return ws2;
}
};
-
#endif /* MANTID_CURVEFITTING_FABADAMINIMIZERTEST_H_ */