Enable new objective metric in the GUI

GUI/coregui/Models/MinimizerItem.cpp

@@ -24,6 +24,8 @@
 #include "IIntensityFunction.h"
 #include "VarianceFunctions.h"
 #include "VarianceFunctionItems.h"
+#include "ObjectiveMetric.h"
+#include "ObjectiveMetricUtils.h"
 
 namespace  {
 const QString none_fun = "None";
@@ -40,22 +42,28 @@ MinimizerItem::MinimizerItem(const QString &model_type) : SessionItem(model_type
 // ----------------------------------------------------------------------------
 
 const QString MinimizerContainerItem::P_MINIMIZERS = "Minimizer";
-const QString MinimizerContainerItem::P_INTENSITY_FUNCTION = "Intensity function";
-const QString MinimizerContainerItem::P_VARIANCE_FUNCTIONS = "Variance";
+const QString MinimizerContainerItem::P_METRIC = "Objective metric";
+const QString MinimizerContainerItem::P_NORM = "Norm function";
 
-MinimizerContainerItem::MinimizerContainerItem() : MinimizerItem(Constants::MinimizerContainerType)
+MinimizerContainerItem::MinimizerContainerItem()
+    : MinimizerItem(Constants::MinimizerContainerType)
 {
     addGroupProperty(P_MINIMIZERS, Constants::MinimizerLibraryGroup)
         ->setToolTip(QStringLiteral("Minimizer library"));
 
-    ComboProperty combo = ComboProperty() << none_fun << sqrt_fun << log10_fun;
-    addProperty(P_INTENSITY_FUNCTION, combo.variant())->setToolTip(
-                "Function to apply for both simulated and experimental intensities \n"
-                "before calculating the value of residual.");
-
-    addGroupProperty(P_VARIANCE_FUNCTIONS, Constants::VarianceFunctionGroup)
-        ->setToolTip(QStringLiteral("Variance functions for residual normalization"));
+    ComboProperty metric_combo;
+    for (auto& item: ObjectiveMetricUtils::metricNames())
+        metric_combo << QString::fromStdString(item);
+    addProperty(P_METRIC, metric_combo.variant())
+        ->setToolTip("Objective metric to use for estimating distance between simulated and "
+                     "experimental data.");
 
+    ComboProperty norm_combo;
+    for (auto& item: ObjectiveMetricUtils::normNames())
+        norm_combo << QString::fromStdString(item);
+    addProperty(P_NORM, norm_combo.variant())
+        ->setToolTip("Normalization to use for estimating distance between simulated and "
+                     "experimental data.");
 }
 
 std::unique_ptr<IMinimizer> MinimizerContainerItem::createMinimizer() const
@@ -63,23 +71,11 @@ std::unique_ptr<IMinimizer> MinimizerContainerItem::createMinimizer() const
     return groupItem<MinimizerItem>(P_MINIMIZERS).createMinimizer();
 }
 
-std::unique_ptr<IIntensityFunction> MinimizerContainerItem::createIntensityFunction() const
-{
-    QString value = getItemValue(P_INTENSITY_FUNCTION).value<ComboProperty>().getValue();
-
-    if (value == sqrt_fun) {
-        return std::make_unique<IntensityFunctionSqrt>();
-    } else if(value == log10_fun) {
-        return std::make_unique<IntensityFunctionLog>();
-    } else {
-        return std::unique_ptr<IIntensityFunction>();
-    }
-}
-
-std::unique_ptr<IVarianceFunction> MinimizerContainerItem::createVarianceFunction() const
+std::unique_ptr<ObjectiveMetric> MinimizerContainerItem::createMetric() const
 {
-    auto& variance_item = groupItem<IVarianceFunctionItem>(P_VARIANCE_FUNCTIONS);
-    return variance_item.createVarianceFunction();
+    QString metric = getItemValue(P_METRIC).value<ComboProperty>().getValue();
+    QString norm = getItemValue(P_NORM).value<ComboProperty>().getValue();
+    return ObjectiveMetricUtils::createMetric(metric.toStdString(), norm.toStdString());
 }
 
 // ----------------------------------------------------------------------------

GUI/coregui/Models/MinimizerItem.h

@@ -20,6 +20,7 @@
 class IMinimizer;
 class IIntensityFunction;
 class IVarianceFunction;
+class ObjectiveMetric;
 
 //! The MinimizerItem class is the base item to hold minimizer settings.
 
@@ -36,13 +37,13 @@ class BA_CORE_API_ MinimizerContainerItem : public MinimizerItem
 {
 public:
     static const QString P_MINIMIZERS;
-    static const QString P_INTENSITY_FUNCTION;
-    static const QString P_VARIANCE_FUNCTIONS;
+    static const QString P_METRIC;
+    static const QString P_NORM;
+
     MinimizerContainerItem();
 
     std::unique_ptr<IMinimizer> createMinimizer() const;
-    std::unique_ptr<IIntensityFunction> createIntensityFunction() const;
-    std::unique_ptr<IVarianceFunction> createVarianceFunction() const;
+    std::unique_ptr<ObjectiveMetric> createMetric() const;
 };
 
 //! The MinuitMinimizerItem class represents settings for ROOT Minuit2 minimizer.

GUI/coregui/Views/FitWidgets/FitObjectiveBuilder.cpp

@@ -33,6 +33,7 @@
 #include "ChiSquaredModule.h"
 #include "IIntensityFunction.h"
 #include "VarianceFunctions.h"
+#include "ObjectiveMetric.h"
 
 FitObjectiveBuilder::FitObjectiveBuilder(JobItem* jobItem)
     : m_jobItem(jobItem)
@@ -46,12 +47,8 @@ void FitObjectiveBuilder::runFit()
 {
     m_fit_objective = createFitObjective();
 
-    auto module = createChiSquaredModule();
-    m_fit_objective->setChiSquaredModule(*module);
-
-    fcn_residual_t residual_func = [&](const Fit::Parameters& params) {
-        return m_fit_objective->evaluate_residuals(params);
-    };
+    auto module = m_jobItem->fitSuiteItem()->minimizerContainerItem()->createMetric();
+    m_fit_objective->setObjectiveMetric(std::move(module));
 
     if (m_observer) {
         fit_observer_t plot_observer = [&](const FitObjective& obj) {
@@ -60,10 +57,22 @@ void FitObjectiveBuilder::runFit()
         m_fit_objective->initPlot(1, plot_observer);
     }
 
-    Fit::Minimizer minimizer;
-    minimizer.setMinimizer(createMinimizer().release());
+    auto minimizer_impl = createMinimizer();
+    const bool requires_residuals = minimizer_impl->requiresResiduals();
 
-    auto result = minimizer.minimize(residual_func, createParameters());
+    Fit::Minimizer minimizer;
+    minimizer.setMinimizer(minimizer_impl.release());
+
+    auto result =
+        requires_residuals
+            ? minimizer.minimize(
+                  [&](const Fit::Parameters& params) {
+                      return m_fit_objective->evaluate_residuals(params);
+                  },
+                  createParameters())
+            : minimizer.minimize(
+                  [&](const Fit::Parameters& params) { return m_fit_objective->evaluate(params); },
+                  createParameters());
     m_fit_objective->finalize(result);
 }
 
@@ -86,19 +95,6 @@ std::unique_ptr<IMinimizer> FitObjectiveBuilder::createMinimizer() const
     return fitSuiteItem->minimizerContainerItem()->createMinimizer();
 }
 
-std::unique_ptr<IChiSquaredModule> FitObjectiveBuilder::createChiSquaredModule() const
-{
-    std::unique_ptr<IChiSquaredModule> result = std::make_unique<ChiSquaredModule>();
-
-    auto fitSuiteItem = m_jobItem->fitSuiteItem();
-    auto intensityFunction = fitSuiteItem->minimizerContainerItem()->createIntensityFunction();
-    if (intensityFunction)
-        result->setIntensityFunction(*intensityFunction);
-    auto variaceFunction = fitSuiteItem->minimizerContainerItem()->createVarianceFunction();
-    result->setVarianceFunction(*variaceFunction);
-    return result;
-}
-
 Fit::Parameters FitObjectiveBuilder::createParameters() const
 {
     auto fitSuiteItem = m_jobItem->fitSuiteItem();