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; }