TEST(FunctionFactoryTest, CreateCompositeFunctionTest)
{
std::string ini = "CompositeFunction("
"FunctionFactoryTestFunction(A=10,B=20),"
"FunctionFactoryTestFunction(A=30,B=40)"
")";
IFunction_sptr fun = FunctionFactory::instance().createFitFunction(ini);
EXPECT_TRUE( fun.get() != nullptr );
CompositeFunction_sptr cf = boost::dynamic_pointer_cast<CompositeFunction>(fun);
EXPECT_TRUE( cf.get() != nullptr );
EXPECT_EQ( cf->nFunctions(), 2 );
auto f1 = cf->getFunction(0);
auto f2 = cf->getFunction(1);
EXPECT_EQ(f1->getParameter("A"),10);
EXPECT_EQ(f1->getParameter("B"),20);
EXPECT_EQ(f2->getParameter("A"),30);
EXPECT_EQ(f2->getParameter("B"),40);
EXPECT_EQ(cf->getParameter("f0.A"),10);
EXPECT_EQ(cf->getParameter("f0.B"),20);
EXPECT_EQ(cf->getParameter("f1.A"),30);
EXPECT_EQ(cf->getParameter("f1.B"),40);
std::cerr << '\n' << fun->asString(true) << '\n' << std::endl;
IFunction_sptr fun1 = FunctionFactory::instance().createFitFunction(ini);
EXPECT_TRUE( fun1.get() != nullptr );
cf = boost::dynamic_pointer_cast<CompositeFunction>(fun1);
EXPECT_TRUE( cf.get() != nullptr );
EXPECT_EQ( cf->nFunctions(), 2 );
EXPECT_EQ(cf->getParameter("f0.A"),10);
EXPECT_EQ(cf->getParameter("f0.B"),20);
EXPECT_EQ(cf->getParameter("f1.A"),30);
EXPECT_EQ(cf->getParameter("f1.B"),40);
}
/// Returns a TableWorkspace with refined cell parameters and error.
ITableWorkspace_sptr PoldiFitPeaks2D::getRefinedCellParameters(
const IFunction_sptr &fitFunction) const {
Poldi2DFunction_sptr poldi2DFunction =
boost::dynamic_pointer_cast<Poldi2DFunction>(fitFunction);
if (!poldi2DFunction || poldi2DFunction->nFunctions() < 1) {
throw std::invalid_argument(
"Cannot process function that is not a Poldi2DFunction.");
}
// Create a new table for lattice parameters
ITableWorkspace_sptr latticeParameterTable =
WorkspaceFactory::Instance().createTable();
latticeParameterTable->addColumn("str", "Parameter");
latticeParameterTable->addColumn("double", "Value");
latticeParameterTable->addColumn("double", "Error");
// The first function should be PoldiSpectrumPawleyFunction
boost::shared_ptr<PoldiSpectrumPawleyFunction> poldiPawleyFunction =
boost::dynamic_pointer_cast<PoldiSpectrumPawleyFunction>(
poldi2DFunction->getFunction(0));
if (!poldiPawleyFunction) {
throw std::invalid_argument("First function in Poldi2DFunction is not "
"PoldiSpectrumPawleyFunction.");
}
// Get the actual PawleyFunction to extract parameters.
IPawleyFunction_sptr pawleyFunction =
boost::dynamic_pointer_cast<IPawleyFunction>(
poldiPawleyFunction->getDecoratedFunction());
if (pawleyFunction) {
CompositeFunction_sptr pawleyParts =
boost::dynamic_pointer_cast<CompositeFunction>(
pawleyFunction->getDecoratedFunction());
// The first function in PawleyFunction contains the parameters
IFunction_sptr pawleyParameters = pawleyParts->getFunction(0);
for (size_t i = 0; i < pawleyParameters->nParams(); ++i) {
TableRow newRow = latticeParameterTable->appendRow();
newRow << pawleyParameters->parameterName(i)
<< pawleyParameters->getParameter(i)
<< pawleyParameters->getError(i);
}
}
return latticeParameterTable;
}
void PoldiFitPeaks1D::setValuesFromProfileFunction(
PoldiPeak_sptr poldiPeak, const IFunction_sptr &fittedFunction) const {
CompositeFunction_sptr totalFunction =
boost::dynamic_pointer_cast<CompositeFunction>(fittedFunction);
if (totalFunction) {
IPeakFunction_sptr peakFunction =
boost::dynamic_pointer_cast<IPeakFunction>(
totalFunction->getFunction(0));
if (peakFunction) {
poldiPeak->setIntensity(
UncertainValue(peakFunction->height(), peakFunction->getError(0)));
poldiPeak->setQ(
UncertainValue(peakFunction->centre(), peakFunction->getError(1)));
poldiPeak->setFwhm(UncertainValue(peakFunction->fwhm(),
getFwhmWidthRelation(peakFunction) *
peakFunction->getError(2)));
}
}
}
PoldiPeakCollection_sptr
PoldiFitPeaks1D2::fitPeaks(const PoldiPeakCollection_sptr &peaks) {
g_log.information() << "Peaks to fit: " << peaks->peakCount() << std::endl;
std::vector<RefinedRange_sptr> rawRanges = getRefinedRanges(peaks);
std::vector<RefinedRange_sptr> reducedRanges = getReducedRanges(rawRanges);
g_log.information() << "Ranges used for fitting: " << reducedRanges.size()
<< std::endl;
Workspace2D_sptr dataWorkspace = getProperty("InputWorkspace");
m_fitplots->removeAll();
for (size_t i = 0; i < reducedRanges.size(); ++i) {
RefinedRange_sptr currentRange = reducedRanges[i];
int nMin = getBestChebyshevPolynomialDegree(dataWorkspace, currentRange);
if (nMin > -1) {
IAlgorithm_sptr fit = getFitAlgorithm(dataWorkspace, currentRange, nMin);
fit->execute();
IFunction_sptr fitFunction = fit->getProperty("Function");
CompositeFunction_sptr composite =
boost::dynamic_pointer_cast<CompositeFunction>(fitFunction);
if (!composite) {
throw std::runtime_error("Not a composite function!");
}
std::vector<PoldiPeak_sptr> peaks = currentRange->getPeaks();
for (size_t i = 0; i < peaks.size(); ++i) {
setValuesFromProfileFunction(peaks[i], composite->getFunction(i));
MatrixWorkspace_sptr fpg = fit->getProperty("OutputWorkspace");
m_fitplots->addWorkspace(fpg);
}
}
}
return getReducedPeakCollection(peaks);
}
/**
* Construct a PoldiPeakCollection from a Poldi2DFunction
*
* This method performs the opposite operation of
*getFunctionFromPeakCollection.
* It takes a function, checks if it's of the proper type and turns the
* information into a PoldiPeakCollection.
*
* @param Poldi2DFunction with one PoldiSpectrumDomainFunction per peak
* @return PoldiPeakCollection containing peaks with normalized intensities
*/
PoldiPeakCollection_sptr PoldiFitPeaks2D::getPeakCollectionFromFunction(
const IFunction_sptr &fitFunction) {
Poldi2DFunction_sptr poldi2DFunction =
boost::dynamic_pointer_cast<Poldi2DFunction>(fitFunction);
if (!poldi2DFunction) {
throw std::invalid_argument(
"Cannot process function that is not a Poldi2DFunction.");
}
PoldiPeakCollection_sptr normalizedPeaks =
boost::make_shared<PoldiPeakCollection>(PoldiPeakCollection::Integral);
boost::shared_ptr<const Kernel::DblMatrix> covarianceMatrix =
poldi2DFunction->getCovarianceMatrix();
size_t offset = 0;
for (size_t i = 0; i < poldi2DFunction->nFunctions(); ++i) {
boost::shared_ptr<PoldiSpectrumPawleyFunction> poldiPawleyFunction =
boost::dynamic_pointer_cast<PoldiSpectrumPawleyFunction>(
poldi2DFunction->getFunction(i));
// If it's a Pawley function, there are several peaks in one function.
if (poldiPawleyFunction) {
IPawleyFunction_sptr pawleyFunction =
poldiPawleyFunction->getPawleyFunction();
if (pawleyFunction) {
CompositeFunction_sptr decoratedFunction =
boost::dynamic_pointer_cast<CompositeFunction>(
pawleyFunction->getDecoratedFunction());
offset = decoratedFunction->getFunction(0)->nParams();
for (size_t j = 0; j < pawleyFunction->getPeakCount(); ++j) {
IPeakFunction_sptr profileFunction =
pawleyFunction->getPeakFunction(j);
size_t nLocalParams = profileFunction->nParams();
boost::shared_ptr<Kernel::DblMatrix> localCov =
getLocalCovarianceMatrix(covarianceMatrix, offset, nLocalParams);
profileFunction->setCovarianceMatrix(localCov);
// Increment offset for next function
offset += nLocalParams;
V3D peakHKL = pawleyFunction->getPeakHKL(j);
PoldiPeak_sptr peak =
getPeakFromPeakFunction(profileFunction, peakHKL);
normalizedPeaks->addPeak(peak);
}
}
break;
}
// Otherwise, it's just one peak in this function.
boost::shared_ptr<PoldiSpectrumDomainFunction> peakFunction =
boost::dynamic_pointer_cast<PoldiSpectrumDomainFunction>(
poldi2DFunction->getFunction(i));
if (peakFunction) {
IPeakFunction_sptr profileFunction =
boost::dynamic_pointer_cast<IPeakFunction>(
peakFunction->getProfileFunction());
// Get local covariance matrix
size_t nLocalParams = profileFunction->nParams();
boost::shared_ptr<Kernel::DblMatrix> localCov =
getLocalCovarianceMatrix(covarianceMatrix, offset, nLocalParams);
profileFunction->setCovarianceMatrix(localCov);
// Increment offset for next function
offset += nLocalParams;
PoldiPeak_sptr peak =
getPeakFromPeakFunction(profileFunction, V3D(0, 0, 0));
normalizedPeaks->addPeak(peak);
}
}
return normalizedPeaks;
}