CompositeFunction.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2009 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
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAPI/IFunction.h"
#include "MantidAPI/Jacobian.h"
 
#include <map>
 
namespace Mantid {
namespace API {
class MANTID_API_DLL CompositeFunction : public virtual IFunction {
public:
  CompositeFunction();
 
  /* Overriden methods */
 
  std::string name() const override { return "CompositeFunction"; }
  void setWorkspace(std::shared_ptr<const Workspace> ws) override;
  void setMatrixWorkspace(std::shared_ptr<const API::MatrixWorkspace> workspace, size_t wi, double startX,
                          double endX) override;
  void setStepSizeMethod(const StepSizeMethod stepSizeMethod) override;
 
  void function(const FunctionDomain &domain, FunctionValues &values) const override;
  void functionDeriv(const FunctionDomain &domain, Jacobian &jacobian) override;
 
  void setParameter(size_t, const double &value, bool explicitlySet = true) override;
  void setParameterDescription(size_t, const std::string &description) override;
  [[nodiscard]] double getParameter(size_t i) const override;
  [[nodiscard]] double getParameter(size_t i, size_t j) const;
  void setParameter(const std::string &name, const double &value, bool explicitlySet = true) override;
  void setParameterDescription(const std::string &name, const std::string &description) override;
  [[nodiscard]] double getParameter(const std::string &name) const override;
  bool hasParameter(const std::string &name) const override;
  bool hasAttribute(const std::string &name) const override;
  [[nodiscard]] Attribute getAttribute(const std::string &name) const override;
  // Set an attribute value
  void setAttribute(const std::string &name, const API::IFunction::Attribute &value) override;
  // Register the functions usage
  void registerFunctionUsage(bool internal) override;
  [[nodiscard]] size_t nParams() const override;
  // Total number of attributes, which includes global and local function
  // attributes
  [[nodiscard]] size_t nAttributes() const override;
  // Total number of global attributes, defined at the composite function level
  [[nodiscard]] size_t nGlobalAttributes() const noexcept { return IFunction::nAttributes(); }
  [[nodiscard]] size_t parameterIndex(const std::string &name) const override;
  [[nodiscard]] std::string parameterName(size_t i) const override;
  [[nodiscard]] std::string parameterName(size_t i, size_t j) const;
  [[nodiscard]] std::string attributeName(size_t i) const override;
  [[nodiscard]] std::string parameterDescription(size_t i) const override;
  [[nodiscard]] bool isExplicitlySet(size_t i) const override;
  [[nodiscard]] double getError(size_t i) const override;
  [[nodiscard]] double getError(size_t i, size_t j) const;
  [[nodiscard]] double getError(const std::string &name) const override;
  void setError(size_t i, double err) override;
  void setError(const std::string &name, double err) override;
  [[nodiscard]] double activeParameter(size_t i) const override;
  void setActiveParameter(size_t i, double value) override;
  void updateActive(const double *in);
  [[nodiscard]] std::string nameOfActive(size_t i) const override;
  [[nodiscard]] std::string descriptionOfActive(size_t i) const override;
 
  [[nodiscard]] size_t getParameterIndex(const ParameterReference &ref) const override;
  [[nodiscard]] IFunction_sptr getContainingFunction(const ParameterReference &ref) const;
 
  void applyTies() override;
  void clearTies() override;
  // Unhide base class function: removeTie(string). Avoids Intel compiler
  // warning
  using IFunction::removeTie;
  bool removeTie(size_t i) override;
  [[nodiscard]] ParameterTie *getTie(size_t i) const override;
 
  [[nodiscard]] IConstraint *getConstraint(size_t i) const override;
  void setUpForFit() override;
  void removeConstraint(const std::string &parName) override;
  [[nodiscard]] size_t getNumberDomains() const override;
  [[nodiscard]] std::vector<std::shared_ptr<IFunction>> createEquivalentFunctions() const override;
  [[nodiscard]] bool hasFunction(const std::string &functionName) const;
  [[nodiscard]] IFunction_sptr getFunction(std::size_t i) const override;
  [[nodiscard]] std::size_t nFunctions() const override { return m_functions.size(); }
 
  /* CompositeFunction own methods */
 
  virtual size_t addFunction(IFunction_sptr f);
  void removeFunction(size_t i);
  void replaceFunction(size_t functionIndex, const IFunction_sptr &f);
  void replaceFunctionPtr(const IFunction_sptr &f_old, const IFunction_sptr &f_new);
  [[nodiscard]] std::size_t functionIndex(const std::string &functionName) const;
  [[nodiscard]] std::size_t functionIndex(std::size_t i) const;
  [[nodiscard]] std::size_t attributeFunctionIndex(std::size_t i) const;
  [[nodiscard]] size_t parameterLocalIndex(size_t i, bool recursive = false) const;
  [[nodiscard]] std::string parameterLocalName(size_t i, bool recursive = false) const;
  void checkFunction();
  void clear();
  virtual size_t nLocalAttributes() const { return 0; }
  virtual std::vector<std::string> getLocalAttributeNames() const { return std::vector<std::string>(); }
  virtual Attribute getLocalAttribute(size_t i, const std::string &attName) const {
    (void)i;
    throw std::invalid_argument("Attribute " + attName + " not found in function " + this->name());
  }
  virtual void setLocalAttribute(size_t i, const std::string &attName, const Attribute &) {
    (void)i;
    throw std::invalid_argument("Attribute " + attName + " not found in function " + this->name());
  }
  virtual bool hasLocalAttribute(const std::string &) const { return false; }
  template <typename T> void setLocalAttributeValue(size_t i, const std::string &attName, const T &value) {
    setLocalAttribute(i, attName, Attribute(value));
  }
  void setLocalAttributeValue(size_t i, const std::string &attName, const char *value) {
    setLocalAttribute(i, attName, Attribute(std::string(value)));
  }
  void setParameterStatus(size_t i, ParameterStatus status) override;
  ParameterStatus getParameterStatus(size_t i) const override;
  static std::pair<std::string, size_t> parseName(const std::string &varName);
 
protected:
  void init() override;
  void declareParameter(const std::string &name, double initValue = 0, const std::string &description = "") override;
 
  void declareAttribute(const std::string &name, const API::IFunction::Attribute &defaultValue);
  void declareAttribute(const std::string &name, const API::IFunction::Attribute &defaultValue,
                        const Kernel::IValidator &validator);
  std::string writeToString(const std::string &parentLocalAttributesStr = "") const override;
 
  size_t paramOffset(size_t i) const { return m_paramOffsets[i]; }
 
private:
  // get attribute offset from attribute index
  size_t getAttributeOffset(size_t attributeIndex) const;
  std::vector<IFunction_sptr> m_functions;
  std::vector<size_t> m_paramOffsets;
  std::vector<size_t> m_IFunction;
  // Attribute index vector, where the index is the attribute number and the
  // value is the containing function e.g the attributes in function 1, {A1},
  // are given by A1 = {index for index < m_attributeIndex.size() |
  // m_attributeIndex[index] = 1}
  std::vector<size_t> m_attributeIndex;
  size_t m_nParams;
  size_t m_nAttributes;
  mutable size_t m_iConstraintFunction;
  // Global attributes
  void createDefaultGlobalAttributes();
  std::vector<std::string> m_globalAttributeNames;
};
 
using CompositeFunction_sptr = std::shared_ptr<CompositeFunction>;
using CompositeFunction_const_sptr = std::shared_ptr<const CompositeFunction>;
 
class PartialJacobian : public Jacobian {
  Jacobian *m_J; 
  size_t m_iY0;  
  size_t m_iP0; 
public:
  PartialJacobian(Jacobian *J, size_t iP0)
      : m_J(J), m_iY0(0), m_iP0(iP0) //,m_iaP0(iap0)
  {}
  PartialJacobian(Jacobian *J, size_t iY0, size_t iP0) : m_J(J), m_iY0(iY0), m_iP0(iP0) {}
  void set(size_t iY, size_t iP, double value) override { m_J->set(m_iY0 + iY, m_iP0 + iP, value); }
  double get(size_t iY, size_t iP) override { return m_J->get(m_iY0 + iY, m_iP0 + iP); }
  void zero() override {
    throw Kernel::Exception::NotImplementedError("zero() is not implemented for PartialJacobian");
  }
  void addNumberToColumn(const double &value, const size_t &iP) override { m_J->addNumberToColumn(value, m_iP0 + iP); }
};
 
} // namespace API
} // namespace Mantid