PoldiFitPeaks2D.h

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2014 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once

#include "MantidAPI/Algorithm.h"
#include "MantidAPI/IFunction.h"
#include "MantidAPI/IPeakFunction.h"
#include "MantidGeometry/Crystal/PointGroup.h"
#include "MantidKernel/System.h"
#include "MantidSINQ/DllConfig.h"

#include "MantidKernel/Matrix.h"

#include "MantidDataObjects/TableWorkspace.h"
#include "MantidSINQ/PoldiUtilities/Poldi2DFunction.h"
#include "MantidSINQ/PoldiUtilities/PoldiPeakCollection.h"
#include "MantidSINQ/PoldiUtilities/PoldiTimeTransformer.h"

namespace Mantid {
namespace Poldi {

/** PoldiFitPeaks2D

    An Algorithm to fit a POLDI 2D-spectrum from a given table containing POLDI
    peak data. A MatrixWorkspace containing a proper POLDI instrument definition
   is required
    to determine output workspace dimensions etc.

    In order to use the algorithm for calculating a theoretical spectrum,
    the MaximumIterations property can be set to 0.

      @author Michael Wedel, Paul Scherrer Institut - SINQ
      @date 16/05/2014
  */

class MANTID_SINQ_DLL PoldiFitPeaks2D : public API::Algorithm {
public:
  const std::string name() const override;
  int version() const override;
  const std::vector<std::string> seeAlso() const override { return {"PoldiFitPeaks1D"}; }
  const std::string category() const override;

  const std::string summary() const override;

  std::map<std::string, std::string> validateInputs() override;

  bool checkGroups() override { return false; }

protected:
  // Workspace handling
  std::vector<PoldiPeakCollection_sptr> getPeakCollectionsFromInput() const;

  PoldiPeakCollection_sptr getPeakCollection(const DataObjects::TableWorkspace_sptr &peakTable) const;

  // Peak integration and transformations
  std::vector<PoldiPeakCollection_sptr>
  getNormalizedPeakCollections(const std::vector<PoldiPeakCollection_sptr> &peakCollections) const;

  PoldiPeakCollection_sptr getIntegratedPeakCollection(const PoldiPeakCollection_sptr &rawPeakCollection) const;
  PoldiPeakCollection_sptr getNormalizedPeakCollection(const PoldiPeakCollection_sptr &peakCollection) const;

  std::vector<PoldiPeakCollection_sptr> getCountPeakCollections(const API::IFunction_sptr &fitFunction);
  PoldiPeakCollection_sptr getCountPeakCollection(const PoldiPeakCollection_sptr &peakCollection) const;

  // Conversion between peaks and functions
  PoldiPeak_sptr getPeakFromPeakFunction(const API::IPeakFunction_sptr &profileFunction, const Kernel::V3D &hkl);

  // Conversion between peak collections and functions
  Poldi2DFunction_sptr getFunctionFromPeakCollection(const PoldiPeakCollection_sptr &peakCollection);

  Poldi2DFunction_sptr getFunctionIndividualPeaks(const std::string &profileFunctionName,
                                                  const PoldiPeakCollection_sptr &peakCollection) const;

  Poldi2DFunction_sptr getFunctionPawley(const std::string &profileFunctionName,
                                         const PoldiPeakCollection_sptr &peakCollection);

  std::string getLatticeSystemFromPointGroup(const Geometry::PointGroup_sptr &pointGroup) const;

  std::string getRefinedStartingCell(const std::string &initialCell, const std::string &latticeSystem,
                                     const PoldiPeakCollection_sptr &peakCollection);

  std::string getUserSpecifiedTies(const API::IFunction_sptr &poldiFn);

  PoldiPeakCollection_sptr getPeakCollectionFromFunction(const API::IFunction_sptr &fitFunction);

  void assignMillerIndices(const PoldiPeakCollection_sptr &from, PoldiPeakCollection_sptr &to) const;

  void assignCrystalData(PoldiPeakCollection_sptr &normalizedPeakCollection,
                         const PoldiPeakCollection_sptr &peakCollection) const;

  // Extraction of 1D spectrum and cell
  API::MatrixWorkspace_sptr get1DSpectrum(const API::IFunction_sptr &fitFunction,
                                          const API::MatrixWorkspace_sptr &workspace) const;

  API::MatrixWorkspace_sptr getQSpectrum(const API::FunctionDomain1D &domain, const API::FunctionValues &values) const;

  API::ITableWorkspace_sptr getRefinedCellParameters(const API::IFunction_sptr &fitFunction) const;

  // Interacting with Fit
  API::IAlgorithm_sptr calculateSpectrum(const std::vector<PoldiPeakCollection_sptr> &peakCollections,
                                         const API::MatrixWorkspace_sptr &matrixWorkspace);

  API::MatrixWorkspace_sptr getWorkspace(const API::IAlgorithm_sptr &fitAlgorithm) const;
  API::IFunction_sptr getFunction(const API::IAlgorithm_sptr &fitAlgorithm) const;

  void addBackgroundTerms(const Poldi2DFunction_sptr &poldi2DFunction) const;

  std::shared_ptr<Kernel::DblMatrix>
  getLocalCovarianceMatrix(const std::shared_ptr<const Kernel::DblMatrix> &covarianceMatrix, size_t parameterOffset,
                           size_t nParams) const;

  // Poldi instrument book-keeping
  void setPoldiInstrument(const PoldiInstrumentAdapter_sptr &instrument);
  void setTimeTransformerFromInstrument(const PoldiInstrumentAdapter_sptr &poldiInstrument);
  void setTimeTransformer(const PoldiTimeTransformer_sptr &poldiTimeTransformer);

  void setDeltaTFromWorkspace(const API::MatrixWorkspace_sptr &matrixWorkspace);
  void setDeltaT(double newDeltaT);
  bool isValidDeltaT(double deltaT) const;

  PoldiInstrumentAdapter_sptr m_poldiInstrument;
  PoldiTimeTransformer_sptr m_timeTransformer;
  double m_deltaT{0.0};

private:
  void init() override;
  void exec() override;
};

} // namespace Poldi
} // namespace Mantid