/// Sets the profile function and replaces already existing functions in the
/// internally stored CompositeFunction.
void PawleyFunction::setProfileFunction(const std::string &profileFunction) {
m_pawleyParameterFunction->setAttributeValue("ProfileFunction",
profileFunction);
/* At this point PawleyParameterFunction guarantees that it's an IPeakFunction
* and all existing profile functions are replaced.
*/
for (size_t i = 0; i < m_peakProfileComposite->nFunctions(); ++i) {
IPeakFunction_sptr oldFunction = boost::dynamic_pointer_cast<IPeakFunction>(
m_peakProfileComposite->getFunction(i));
IPeakFunction_sptr newFunction = boost::dynamic_pointer_cast<IPeakFunction>(
FunctionFactory::Instance().createFunction(
m_pawleyParameterFunction->getProfileFunctionName()));
newFunction->setCentre(oldFunction->centre());
try {
newFunction->setFwhm(oldFunction->fwhm());
} catch (...) {
// do nothing.
}
newFunction->setHeight(oldFunction->height());
m_peakProfileComposite->replaceFunction(i, newFunction);
}
// Update exposed parameters.
m_compositeFunction->checkFunction();
}
/**
* Returns a Poldi2DFunction that encapsulates a PawleyFunction
*
* This function creates a PawleyFunction using the supplied profile function
* name and the crystal system as well as initial cell from the input
* properties of the algorithm and wraps it in a Poldi2DFunction.
*
* The cell is refined using LatticeFunction to get better starting values.
*
* Because the peak intensities are integral at this step but PawleyFunction
* expects peak heights, a profile function is created and
* setIntensity/height-methods are used to convert.
*
* @param profileFunctionName :: Profile function name for PawleyFunction.
* @param peakCollection :: Peak collection with peaks to be used in the fit.
* @return :: A Poldi2DFunction with a PawleyFunction.
*/
Poldi2DFunction_sptr PoldiFitPeaks2D::getFunctionPawley(
std::string profileFunctionName,
const PoldiPeakCollection_sptr &peakCollection) {
auto mdFunction = boost::make_shared<Poldi2DFunction>();
boost::shared_ptr<PoldiSpectrumPawleyFunction> poldiPawleyFunction =
boost::dynamic_pointer_cast<PoldiSpectrumPawleyFunction>(
FunctionFactory::Instance().createFunction(
"PoldiSpectrumPawleyFunction"));
if (!poldiPawleyFunction) {
throw std::invalid_argument("Could not create pawley function.");
}
poldiPawleyFunction->setDecoratedFunction("PawleyFunction");
IPawleyFunction_sptr pawleyFunction =
poldiPawleyFunction->getPawleyFunction();
pawleyFunction->setProfileFunction(profileFunctionName);
// Extract crystal system from peak collection
PointGroup_sptr pointGroup = peakCollection->pointGroup();
if (!pointGroup) {
throw std::invalid_argument("Can not initialize pawley function properly - "
"peaks do not have point group.");
}
std::string latticeSystem = getLatticeSystemFromPointGroup(pointGroup);
pawleyFunction->setLatticeSystem(latticeSystem);
UnitCell cell = peakCollection->unitCell();
// Extract unit cell from peak collection
pawleyFunction->setUnitCell(getRefinedStartingCell(
unitCellToStr(cell), latticeSystem, peakCollection));
IPeakFunction_sptr pFun = boost::dynamic_pointer_cast<IPeakFunction>(
FunctionFactory::Instance().createFunction(profileFunctionName));
for (size_t i = 0; i < peakCollection->peakCount(); ++i) {
PoldiPeak_sptr peak = peakCollection->peak(i);
pFun->setCentre(peak->d());
pFun->setFwhm(peak->fwhm(PoldiPeak::AbsoluteD));
pFun->setIntensity(peak->intensity());
pawleyFunction->addPeak(peak->hkl().asV3D(),
peak->fwhm(PoldiPeak::AbsoluteD), pFun->height());
}
pawleyFunction->fix(pawleyFunction->parameterIndex("f0.ZeroShift"));
mdFunction->addFunction(poldiPawleyFunction);
return mdFunction;
}
void PoldiFitPeaks1D2::setValuesFromProfileFunction(
PoldiPeak_sptr poldiPeak, const IFunction_sptr &fittedFunction) const {
IPeakFunction_sptr peakFunction =
boost::dynamic_pointer_cast<IPeakFunction>(fittedFunction);
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)));
}
}
/// Creates a PoldiPeak from the given profile function/hkl pair.
PoldiPeak_sptr
PoldiFitPeaks2D::getPeakFromPeakFunction(IPeakFunction_sptr profileFunction,
const V3D &hkl) {
// Use EstimatePeakErrors to calculate errors of FWHM and so on
IAlgorithm_sptr errorAlg = createChildAlgorithm("EstimatePeakErrors");
errorAlg->setProperty(
"Function", boost::dynamic_pointer_cast<IFunction>(profileFunction));
errorAlg->setPropertyValue("OutputWorkspace", "Errors");
errorAlg->execute();
double centre = profileFunction->centre();
double fwhmValue = profileFunction->fwhm();
ITableWorkspace_sptr errorTable = errorAlg->getProperty("OutputWorkspace");
double centreError = errorTable->cell<double>(0, 2);
double fwhmError = errorTable->cell<double>(2, 2);
UncertainValue d(centre, centreError);
UncertainValue fwhm(fwhmValue, fwhmError);
UncertainValue intensity;
bool useIntegratedIntensities = getProperty("OutputIntegratedIntensities");
if (useIntegratedIntensities) {
double integratedIntensity = profileFunction->intensity();
double integratedIntensityError = errorTable->cell<double>(3, 2);
intensity = UncertainValue(integratedIntensity, integratedIntensityError);
} else {
double height = profileFunction->height();
double heightError = errorTable->cell<double>(1, 2);
intensity = UncertainValue(height, heightError);
}
// Create peak with extracted parameters and supplied hkl
PoldiPeak_sptr peak =
PoldiPeak::create(MillerIndices(hkl), d, intensity, UncertainValue(1.0));
peak->setFwhm(fwhm, PoldiPeak::FwhmRelation::AbsoluteD);
return peak;
}