Exemplo n.º 1
0
/// Returns true if d-spacing of measured and candidate peak are less than three
/// sigma (of the candidate) apart.
bool PoldiIndexKnownCompounds::isCandidate(
    const PoldiPeak_sptr &measuredPeak,
    const PoldiPeak_sptr &possibleCandidate) const {
    if (!measuredPeak || !possibleCandidate) {
        throw std::invalid_argument("Cannot check null-peaks.");
    }

    return (fabs(static_cast<double>(measuredPeak->d()) -
                 possibleCandidate->d()) /
            fwhmToSigma(possibleCandidate->fwhm(PoldiPeak::AbsoluteD))) < 3.0;
}
Exemplo n.º 2
0
/**
 * Returns a Poldi2DFunction that encapsulates individual peaks
 *
 * This function takes all peaks from the supplied peak collection and
 * generates an IPeakFunction of the type given in the name parameter, wraps
 * them in a Poldi2DFunction and returns it.
 *
 * @param profileFunctionName :: Profile function name.
 * @param peakCollection :: Peak collection with peaks to be used in the fit.
 * @return :: A Poldi2DFunction with peak profile functions.
 */
Poldi2DFunction_sptr PoldiFitPeaks2D::getFunctionIndividualPeaks(
    std::string profileFunctionName,
    const PoldiPeakCollection_sptr &peakCollection) const {
  auto mdFunction = boost::make_shared<Poldi2DFunction>();

  for (size_t i = 0; i < peakCollection->peakCount(); ++i) {
    PoldiPeak_sptr peak = peakCollection->peak(i);

    boost::shared_ptr<PoldiSpectrumDomainFunction> peakFunction =
        boost::dynamic_pointer_cast<PoldiSpectrumDomainFunction>(
            FunctionFactory::Instance().createFunction(
                "PoldiSpectrumDomainFunction"));

    if (!peakFunction) {
      throw std::invalid_argument(
          "Cannot process null pointer poldi function.");
    }

    peakFunction->setDecoratedFunction(profileFunctionName);

    IPeakFunction_sptr wrappedProfile =
        boost::dynamic_pointer_cast<IPeakFunction>(
            peakFunction->getProfileFunction());

    if (wrappedProfile) {
      wrappedProfile->setCentre(peak->d());
      wrappedProfile->setFwhm(peak->fwhm(PoldiPeak::AbsoluteD));
      wrappedProfile->setIntensity(peak->intensity());
    }

    mdFunction->addFunction(peakFunction);
  }

  return mdFunction;
}
Exemplo n.º 3
0
/**
 * Converts normalized peak intensities to count based integral intensities
 *
 * This operation is the opposite of getNormalizedPeakCollection and is used
 * to convert the intensities back to integral intensities.
 *
 * @param peakCollection :: PoldiPeakCollection with normalized intensities
 * @return PoldiPeakCollection with integral intensities
 */
PoldiPeakCollection_sptr PoldiFitPeaks2D::getCountPeakCollection(
    const PoldiPeakCollection_sptr &peakCollection) const {
  if (!peakCollection) {
    throw std::invalid_argument(
        "Cannot proceed with invalid PoldiPeakCollection.");
  }

  if (!m_timeTransformer) {
    throw std::invalid_argument("Cannot proceed without PoldiTimeTransformer.");
  }

  PoldiPeakCollection_sptr countPeakCollection =
      boost::make_shared<PoldiPeakCollection>(PoldiPeakCollection::Integral);
  countPeakCollection->setProfileFunctionName(
      peakCollection->getProfileFunctionName());

  // Get crystal data into new peak collection
  assignCrystalData(countPeakCollection, peakCollection);

  for (size_t i = 0; i < peakCollection->peakCount(); ++i) {
    PoldiPeak_sptr peak = peakCollection->peak(i);
    double calculatedIntensity =
        m_timeTransformer->calculatedTotalIntensity(peak->d());

    PoldiPeak_sptr countPeak = peak->clone();
    countPeak->setIntensity(peak->intensity() * calculatedIntensity);

    countPeakCollection->addPeak(countPeak);
  }

  return countPeakCollection;
}
Exemplo n.º 4
0
/** Creates a vector of IndexCandidatePair-objects.
 *
 *  This function iterates through all peaks in the measured
 *PoldiPeakCollection, getting possible indexing candidates
 *  for each peak (see PoldiIndexKnownCompounds::getIndexCandidatePairs). If no
 *candidates are found it means that
 *  there are no reflections with similar d-spacings from the known compounds,
 *so it is treated as an unindexed peak.
 *  Otherwise, all candidates for this peak are appended to the list of existing
 *candidate pairs.
 *
 *  @param measured :: Measured peaks.
 *  @param knownCompoundPeaks :: Collections of expected peaks.
 *  @return Vector of index candidates.
 */
std::vector<IndexCandidatePair>
PoldiIndexKnownCompounds::getAllIndexCandidatePairs(
    const PoldiPeakCollection_sptr &measured,
    const std::vector<PoldiPeakCollection_sptr> &knownCompoundPeaks) {
    std::vector<IndexCandidatePair> candidates;

    size_t peakCount = measured->peakCount();
    for (size_t i = 0; i < peakCount; ++i) {
        PoldiPeak_sptr currentPeak = measured->peak(i);

        std::vector<IndexCandidatePair> currentCandidates =
            getIndexCandidatePairs(currentPeak, knownCompoundPeaks);

        if (currentCandidates.empty()) {
            collectUnindexedPeak(currentPeak);
        } else {
            candidates.insert(candidates.end(), currentCandidates.begin(),
                              currentCandidates.end());
        }

        g_log.information() << "    Peak at d="
                            << static_cast<double>(currentPeak->d()) << " has "
                            << currentCandidates.size() << " candidates."
                            << std::endl;
    }

    return candidates;
}
Exemplo n.º 5
0
void PoldiPeakSummary::storePeakSummary(TableRow tableRow,
                                        const PoldiPeak_sptr &peak) const {
  UncertainValue q = peak->q();
  UncertainValue d = peak->d();

  tableRow << MillerIndicesIO::toString(peak->hkl())
           << UncertainValueIO::toString(q) << UncertainValueIO::toString(d)
           << d.error() / d.value() * 1e3
           << UncertainValueIO::toString(peak->fwhm(PoldiPeak::Relative) * 1e3)
           << UncertainValueIO::toString(peak->intensity());
}
Exemplo n.º 6
0
/**
 * 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;
}
Exemplo n.º 7
0
/**
 * Tries to refine the initial cell using the supplied peaks
 *
 * This method tries to refine the initial unit cell using the indexed peaks
 * that are supplied in the PoldiPeakCollection. If there are unindexed peaks,
 * the cell will not be refined at all, instead the unmodified initial cell
 * is returned.
 *
 * @param initialCell :: String with the initial unit cell
 * @param crystalSystem :: Crystal system name
 * @param peakCollection :: Collection of bragg peaks, must be indexed
 *
 * @return String for refined unit cell
 */
std::string PoldiFitPeaks2D::getRefinedStartingCell(
    const std::string &initialCell, const std::string &latticeSystem,
    const PoldiPeakCollection_sptr &peakCollection) {

  Geometry::UnitCell cell = Geometry::strToUnitCell(initialCell);

  ILatticeFunction_sptr latticeFunction =
      boost::dynamic_pointer_cast<ILatticeFunction>(
          FunctionFactory::Instance().createFunction("LatticeFunction"));

  latticeFunction->setLatticeSystem(latticeSystem);
  latticeFunction->fix(latticeFunction->parameterIndex("ZeroShift"));
  latticeFunction->setUnitCell(cell);

  // Remove errors from d-values
  PoldiPeakCollection_sptr clone = peakCollection->clone();
  for (size_t i = 0; i < clone->peakCount(); ++i) {
    PoldiPeak_sptr peak = clone->peak(i);

    // If there are unindexed peaks, don't refine, just return the initial cell
    if (peak->hkl() == MillerIndices()) {
      return initialCell;
    }

    peak->setD(UncertainValue(peak->d().value()));
  }

  TableWorkspace_sptr peakTable = clone->asTableWorkspace();

  IAlgorithm_sptr fit = createChildAlgorithm("Fit");
  fit->setProperty("Function",
                   boost::static_pointer_cast<IFunction>(latticeFunction));
  fit->setProperty("InputWorkspace", peakTable);
  fit->setProperty("CostFunction", "Unweighted least squares");
  fit->execute();

  Geometry::UnitCell refinedCell = latticeFunction->getUnitCell();

  return Geometry::unitCellToStr(refinedCell);
}
Exemplo n.º 8
0
/** Assigns most likely indices to measured peaks.
 *
 *  This method takes a list of index candidate pairs and sorts it according to
 *their score, because
 *  a high score corresponds to a high probability of the assignment being
 *correct. Then the function
 *  takes the element with the highest score and inspects the
 *IndexCandidatePair. If the measured reflection
 *  does not have an index yet, it checks whether the candidate index has
 *already been used. In that case,
 *  the measured peak is stored in a buffer. Otherwise, the candidate presents
 *the best solution for the
 *  measured peak (because the current pair has the highest score in the list of
 *remaining candidate pairs) and
 *  the solution is accepted. This means that the measured as well as the
 *candidate peak are marked as "used" and
 *  the measured peak is stored in the PoldiPeakCollection that is located at
 *the index of the current pair.
 *
 *  Then the next element is checked and so on. Whenever a "next best" solution
 *for a measured peak in the mentioned
 *  buffer is found, the peak is removed from that buffer. Once all candidate
 *pairs have been evaluated, the peaks
 *  that are still in the buffer are considered unindexed and treated
 *accordingly.
 *
 *  For a more complete explanation of the principle, please check the
 *documentation in the wiki.
 *
 *  @param candidates :: Vector of possible index candidates.
 */
void PoldiIndexKnownCompounds::assignCandidates(
    const std::vector<IndexCandidatePair> &candidates) {
    // Make a copy since this is going to be modified
    std::vector<IndexCandidatePair> workCandidates = candidates;

    /* The vector is sorted by score (see comparison operator of PeakCandidate),
     * so the first element has the lowest score (lowest probability of being
     * a good guess).
     */
    std::sort(workCandidates.begin(), workCandidates.end());

    std::set<PoldiPeak_sptr> usedMeasuredPeaks;
    std::set<PoldiPeak_sptr> usedExpectedPeaks;

    std::set<PoldiPeak_sptr> unassignedMeasuredPeaks;

    /* The candidate at the back of the vector has the highest score,
     * so it's the candidate with the highest probability of being correct.
     * Consequently, the vector is iterated from end to beginning.
     */
    for (auto it = workCandidates.rbegin(); it != workCandidates.rend(); ++it) {
        IndexCandidatePair currentCandidate = *it;

        PoldiPeak_sptr measuredPeak = currentCandidate.observed;
        PoldiPeak_sptr expectedPeak = currentCandidate.candidate;

        g_log.information() << "    Candidate d="
                            << static_cast<double>(measuredPeak->d()) << " -> "
                            << "Phase: "
                            << currentCandidate.candidateCollectionIndex << " ["
                            << MillerIndicesIO::toString(expectedPeak->hkl())
                            << "] (d=" << static_cast<double>(expectedPeak->d())
                            << "), "
                            << "Score=(" << currentCandidate.positionMatch << "): ";

        /* If the peak has not been indexed yet, it is not stored in the set
         * that holds measured peaks that are already indexed, so the candidate
         * needs to be examined further.
         */
        if (!inPeakSet(usedMeasuredPeaks, measuredPeak)) {

            /* If the theoretical reflection of this index-candidate has already been
             * assigned to a measured peak, the measured peak is inserted into
             * a second set where it is kept in case there is another candidate
             * for this measured peak.
             */
            if (inPeakSet(usedExpectedPeaks, expectedPeak)) {
                unassignedMeasuredPeaks.insert(measuredPeak);
                g_log.information()
                        << "      Candidate rejected: Candidate has been already used."
                        << std::endl;
            } else {
                /* Otherwise, the indexed candidate is accepted and the measured peak
                 * is removed from the set of peaks that are waiting for another
                 * solution.
                 */
                if (inPeakSet(unassignedMeasuredPeaks, measuredPeak)) {
                    unassignedMeasuredPeaks.erase(measuredPeak);
                }

                usedExpectedPeaks.insert(expectedPeak);
                usedMeasuredPeaks.insert(measuredPeak);

                assignPeakIndex(currentCandidate);
                g_log.information() << "      Candidate accepted." << std::endl;
            }
        } else {
            g_log.information()
                    << "      Candidate rejected: peak has already been indexed: ["
                    << MillerIndicesIO::toString(measuredPeak->hkl()) << "]."
                    << std::endl;
        }
    }

    /* All peaks that are still in this set at this point are not indexed and thus
     * inserted into the
     * peak collection that holds unindexed peaks.
     */
    for (auto it = unassignedMeasuredPeaks.begin();
            it != unassignedMeasuredPeaks.end(); ++it) {
        collectUnindexedPeak(*it);
    }
}