/**
* Get the viewable peaks. Essentially copied from the slice viewer.
* @returns A vector indicating which of the peaks are viewable.
*/
std::vector<bool> ConcretePeaksPresenterVsi::getViewablePeaks() const {
// Need to apply a transform.
// Don't bother to find peaks in the region if there are no peaks to find.
Mantid::API::ITableWorkspace_sptr outTable;
if (this->m_peaksWorkspace->getNumberPeaks() >= 1) {
double effectiveRadius = 1e-2;
std::string viewable = m_viewableRegion->toExtentsAsString();
Mantid::API::IPeaksWorkspace_sptr peaksWS = m_peaksWorkspace;
Mantid::API::IAlgorithm_sptr alg =
Mantid::API::AlgorithmManager::Instance().create("PeaksInRegion");
alg->setChild(true);
alg->setRethrows(true);
alg->initialize();
alg->setProperty("InputWorkspace", peaksWS);
alg->setProperty("OutputWorkspace", peaksWS->name() + "_peaks_in_region");
alg->setProperty("Extents", viewable);
alg->setProperty("CheckPeakExtents", true);
alg->setProperty("PeakRadius", effectiveRadius);
alg->setPropertyValue("CoordinateFrame", m_frame);
alg->execute();
outTable = alg->getProperty("OutputWorkspace");
std::vector<bool> viewablePeaks(outTable->rowCount());
for (size_t i = 0; i < outTable->rowCount(); ++i) {
viewablePeaks[i] = outTable->cell<Mantid::API::Boolean>(i, 1);
}
m_viewablePeaks = viewablePeaks;
} else {
// No peaks will be viewable
m_viewablePeaks = std::vector<bool>();
}
return m_viewablePeaks;
}
/**
* Uses linear algorithm to do the fitting.
* @param histogram the histogram to fit
* @param background an output variable for the calculated background
* @param variance an output variable for background's variance, currently always
* zero.
* @param startX an X value in the first bin to be included in the fit
* @param endX an X value in the last bin to be included in the fit
*/
void CalculateFlatBackground::LinearFit(
const HistogramData::Histogram &histogram, double &background,
double &variance, const double startX, const double endX) {
MatrixWorkspace_sptr WS = WorkspaceFactory::Instance().create(
"Workspace2D", 1, histogram.x().size(), histogram.y().size());
WS->setHistogram(0, histogram);
IAlgorithm_sptr childAlg = createChildAlgorithm("Fit");
IFunction_sptr func =
API::FunctionFactory::Instance().createFunction("LinearBackground");
childAlg->setProperty<IFunction_sptr>("Function", func);
childAlg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", WS);
childAlg->setProperty<bool>("CreateOutput", true);
childAlg->setProperty<int>("WorkspaceIndex", 0);
childAlg->setProperty<double>("StartX", startX);
childAlg->setProperty<double>("EndX", endX);
// Default minimizer doesn't work properly even on the easiest cases,
// so Levenberg-MarquardtMD is used instead
childAlg->setProperty<std::string>("Minimizer", "Levenberg-MarquardtMD");
childAlg->executeAsChildAlg();
std::string outputStatus = childAlg->getProperty("OutputStatus");
if (outputStatus != "success") {
g_log.warning("Unable to successfully fit the data: " + outputStatus);
background = -1;
return;
}
Mantid::API::ITableWorkspace_sptr output =
childAlg->getProperty("OutputParameters");
// Find rows with parameters we are after
size_t rowA0, rowA1;
output->find(static_cast<std::string>("A0"), rowA0, 0);
output->find(static_cast<std::string>("A1"), rowA1, 0);
// Linear function is defined as A0 + A1*x
const double intercept = output->cell<double>(rowA0, 1);
const double slope = output->cell<double>(rowA1, 1);
const double centre = (startX + endX) / 2.0;
// Calculate the value of the flat background by taking the value at the
// centre point of the fit
background = slope * centre + intercept;
// ATM we don't calculate the error here.
variance = 0;
}
/** Save Huber angles to a given table workspace.
*/
Mantid::API::ITableWorkspace_sptr LoadDNSSCD::saveHuber() {
std::vector<double> huber;
for (auto ds : m_data)
huber.push_back(ds.huber);
// remove dublicates
std::sort(huber.begin(), huber.end());
huber.erase(unique(huber.begin(), huber.end()), huber.end());
Mantid::API::ITableWorkspace_sptr huberWS =
WorkspaceFactory::Instance().createTable("TableWorkspace");
huberWS->addColumn("double", "Huber(degrees)");
for (size_t i = 0; i < huber.size(); i++) {
huberWS->appendRow();
huberWS->cell<double>(i, 0) = huber[i];
}
return huberWS;
}
/**This method updates the search result to search tree
*@param ws_sptr :: workspace shared pointer
*@param tablewidget :: pointer to table widget
*/
void ICatUtils::updatesearchResults(Mantid::API::ITableWorkspace_sptr& ws_sptr,QTableWidget* tablewidget )
{
if(!ws_sptr || ws_sptr->rowCount()==0)
{
return ;
}
//now set alternating color flag
tablewidget->setAlternatingRowColors(true);
//stylesheet for alternating background color
tablewidget->setStyleSheet("alternate-background-color: rgb(216, 225, 255)");
//disable sorting as per QT documentation.otherwise setitem will give undesired results
tablewidget->setSortingEnabled(false);
tablewidget->verticalHeader()->setVisible(false);
tablewidget->setRowCount(static_cast<int>(ws_sptr->rowCount()));
tablewidget->setColumnCount(static_cast<int>(ws_sptr->columnCount()));
for (size_t i=0;i<ws_sptr->rowCount();++i)
{
//setting the row height of tableWidget
tablewidget->setRowHeight(static_cast<int>(i),20);
}
QStringList qlabelList;
for(size_t i=0;i<ws_sptr->columnCount();i++)
{
Column_sptr col_sptr = ws_sptr->getColumn(i);
//get the column name to display as the header of table widget
QString colTitle = QString::fromStdString(col_sptr->name());
qlabelList.push_back(colTitle);
for(size_t j=0;j<ws_sptr->rowCount();++j)
{
std::ostringstream ostr;
col_sptr->print(j,ostr);
QTableWidgetItem *newItem = new QTableWidgetItem(QString::fromStdString(ostr.str()));
newItem->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
tablewidget->setItem(static_cast<int>(j),static_cast<int>(i), newItem);
newItem->setToolTip(QString::fromStdString(ostr.str()));
}
}
QFont font;
font.setBold(true);
//setting table widget header labels from table workspace
tablewidget->setHorizontalHeaderLabels(qlabelList);
for (int i=0;i<tablewidget->columnCount();++i)
{
tablewidget->horizontalHeaderItem(i)->setFont(font);
tablewidget->horizontalHeaderItem(i)->setTextAlignment(Qt::AlignLeft);
}
//sorting by title
tablewidget->sortByColumn(2,Qt::AscendingOrder);
//enable sorting
tablewidget->setSortingEnabled(true);
tablewidget->resizeColumnsToContents();
}
/// for displaying the investigatiosn count
void ICatUtils::updateSearchLabel(const Mantid::API::ITableWorkspace_sptr& ws_sptr,QLabel* label)
{
std::stringstream rowcount;
QString results("Search Results : ");
if(!ws_sptr)
{
results+="No investigations to display as an error occured";
}
else{
rowcount<<ws_sptr->rowCount();
results+=QString::fromStdString(rowcount.str()) + " Investigations Found";
}
setLabelText(label,results);
}
/** Executes the algorithm
*
* @throw runtime_error Thrown if algorithm cannot execute
*/
void Fit::execConcrete() {
std::string ties = getPropertyValue("Ties");
if (!ties.empty()) {
m_function->addTies(ties);
}
std::string contstraints = getPropertyValue("Constraints");
if (!contstraints.empty()) {
m_function->addConstraints(contstraints);
}
// prepare the function for a fit
m_function->setUpForFit();
API::FunctionDomain_sptr domain;
API::FunctionValues_sptr values;
m_domainCreator->createDomain(domain, values);
// do something with the function which may depend on workspace
m_domainCreator->initFunction(m_function);
// get the minimizer
std::string minimizerName = getPropertyValue("Minimizer");
API::IFuncMinimizer_sptr minimizer =
API::FuncMinimizerFactory::Instance().createMinimizer(minimizerName);
// Try to retrieve optional properties
int intMaxIterations = getProperty("MaxIterations");
const size_t maxIterations = static_cast<size_t>(intMaxIterations);
// get the cost function which must be a CostFuncFitting
boost::shared_ptr<CostFuncFitting> costFunc =
boost::dynamic_pointer_cast<CostFuncFitting>(
API::CostFunctionFactory::Instance().create(
getPropertyValue("CostFunction")));
costFunc->setFittingFunction(m_function, domain, values);
minimizer->initialize(costFunc, maxIterations);
const int64_t nsteps = maxIterations * m_function->estimateNoProgressCalls();
API::Progress prog(this, 0.0, 1.0, nsteps);
m_function->setProgressReporter(&prog);
// do the fitting until success or iteration limit is reached
size_t iter = 0;
bool success = false;
std::string errorString;
g_log.debug("Starting minimizer iteration\n");
while (iter < maxIterations) {
g_log.debug() << "Starting iteration " << iter << "\n";
m_function->iterationStarting();
if (!minimizer->iterate(iter)) {
errorString = minimizer->getError();
g_log.debug() << "Iteration stopped. Minimizer status string="
<< errorString << "\n";
success = errorString.empty() || errorString == "success";
if (success) {
errorString = "success";
}
break;
}
prog.report();
m_function->iterationFinished();
++iter;
}
g_log.debug() << "Number of minimizer iterations=" << iter << "\n";
minimizer->finalize();
if (iter >= maxIterations) {
if (!errorString.empty()) {
errorString += '\n';
}
errorString += "Failed to converge after " +
boost::lexical_cast<std::string>(maxIterations) +
" iterations.";
}
// return the status flag
setPropertyValue("OutputStatus", errorString);
// degrees of freedom
size_t dof = domain->size() - costFunc->nParams();
if (dof == 0)
dof = 1;
double rawcostfuncval = minimizer->costFunctionVal();
double finalCostFuncVal = rawcostfuncval / double(dof);
setProperty("OutputChi2overDoF", finalCostFuncVal);
// fit ended, creating output
// get the workspace
API::Workspace_const_sptr ws = getProperty("InputWorkspace");
bool doCreateOutput = getProperty("CreateOutput");
std::string baseName = getPropertyValue("Output");
if (!baseName.empty()) {
doCreateOutput = true;
}
bool doCalcErrors = getProperty("CalcErrors");
if (doCreateOutput) {
doCalcErrors = true;
}
if (costFunc->nParams() == 0) {
doCalcErrors = false;
}
GSLMatrix covar;
if (doCalcErrors) {
// Calculate the covariance matrix and the errors.
costFunc->calCovarianceMatrix(covar);
costFunc->calFittingErrors(covar, rawcostfuncval);
}
if (doCreateOutput) {
copyMinimizerOutput(*minimizer);
if (baseName.empty()) {
baseName = ws->name();
if (baseName.empty()) {
baseName = "Output";
}
}
baseName += "_";
declareProperty(
new API::WorkspaceProperty<API::ITableWorkspace>(
"OutputNormalisedCovarianceMatrix", "", Kernel::Direction::Output),
"The name of the TableWorkspace in which to store the final covariance "
"matrix");
setPropertyValue("OutputNormalisedCovarianceMatrix",
baseName + "NormalisedCovarianceMatrix");
Mantid::API::ITableWorkspace_sptr covariance =
Mantid::API::WorkspaceFactory::Instance().createTable("TableWorkspace");
covariance->addColumn("str", "Name");
// set plot type to Label = 6
covariance->getColumn(covariance->columnCount() - 1)->setPlotType(6);
// std::vector<std::string> paramThatAreFitted; // used for populating 1st
// "name" column
for (size_t i = 0; i < m_function->nParams(); i++) {
if (m_function->isActive(i)) {
covariance->addColumn("double", m_function->parameterName(i));
// paramThatAreFitted.push_back(m_function->parameterName(i));
}
}
size_t np = m_function->nParams();
size_t ia = 0;
for (size_t i = 0; i < np; i++) {
if (m_function->isFixed(i))
continue;
Mantid::API::TableRow row = covariance->appendRow();
row << m_function->parameterName(i);
size_t ja = 0;
for (size_t j = 0; j < np; j++) {
if (m_function->isFixed(j))
continue;
if (j == i)
row << 100.0;
else {
if (!covar.gsl()) {
throw std::runtime_error(
"There was an error while allocating the (GSL) covariance "
"matrix "
"which is needed to produce fitting error results.");
}
row << 100.0 * covar.get(ia, ja) /
sqrt(covar.get(ia, ia) * covar.get(ja, ja));
}
++ja;
}
++ia;
}
setProperty("OutputNormalisedCovarianceMatrix", covariance);
// create output parameter table workspace to store final fit parameters
// including error estimates if derivative of fitting function defined
declareProperty(new API::WorkspaceProperty<API::ITableWorkspace>(
"OutputParameters", "", Kernel::Direction::Output),
"The name of the TableWorkspace in which to store the "
"final fit parameters");
setPropertyValue("OutputParameters", baseName + "Parameters");
Mantid::API::ITableWorkspace_sptr result =
Mantid::API::WorkspaceFactory::Instance().createTable("TableWorkspace");
result->addColumn("str", "Name");
// set plot type to Label = 6
result->getColumn(result->columnCount() - 1)->setPlotType(6);
result->addColumn("double", "Value");
result->addColumn("double", "Error");
// yErr = 5
result->getColumn(result->columnCount() - 1)->setPlotType(5);
for (size_t i = 0; i < m_function->nParams(); i++) {
Mantid::API::TableRow row = result->appendRow();
row << m_function->parameterName(i) << m_function->getParameter(i)
<< m_function->getError(i);
}
// Add chi-squared value at the end of parameter table
Mantid::API::TableRow row = result->appendRow();
#if 1
std::string costfuncname = getPropertyValue("CostFunction");
if (costfuncname == "Rwp")
row << "Cost function value" << rawcostfuncval;
else
row << "Cost function value" << finalCostFuncVal;
setProperty("OutputParameters", result);
#else
row << "Cost function value" << finalCostFuncVal;
Mantid::API::TableRow row2 = result->appendRow();
std::string name(getPropertyValue("CostFunction"));
name += " value";
row2 << name << rawcostfuncval;
#endif
setProperty("OutputParameters", result);
bool outputParametersOnly = getProperty("OutputParametersOnly");
if (!outputParametersOnly) {
const bool unrollComposites = getProperty("OutputCompositeMembers");
bool convolveMembers = existsProperty("ConvolveMembers");
if (convolveMembers) {
convolveMembers = getProperty("ConvolveMembers");
}
m_domainCreator->separateCompositeMembersInOutput(unrollComposites,
convolveMembers);
m_domainCreator->createOutputWorkspace(baseName, m_function, domain,
values);
}
}
progress(1.0);
}