Update interface to remove fitter global generic entry

Now generic entry can be set per fit-level, thus it is possible to use multiple generic entries for different fit classes within single fitter.

Author: rlalik

README.md

@@ -86,7 +86,7 @@ The fitter allows to set default function which will be used for histograms not
 # Features
 HelloFitty provides following structures:
 * `hf::fitter` -- the main fitting manager responsible to read/write data from files and fit histograms
-* `hf::fit_entry` -- a structure holding full info about functions and parameters for a given histogram
+* `hf::entry` -- a structure holding full info about functions and parameters for a given histogram
 * `hf::param` -- a single parameter info: values and boundaries
 * `hf::draw_opts` -- partial and grand function drawing options
 
@@ -118,22 +118,28 @@ By default it will update the auxiliary file unless `update_reference` is set to
 
 You can search whether given histogram is present in the fitter (after loading from file), either using the histogram object or histogram name:
 ```c++
-auto find_fit(TH1* hist) const -> fit_entry*;
-auto find_fit(const char* name) const -> fit_entry*;
+auto find_fit(TH1* hist) const -> entry*;
+auto find_fit(const char* name) const -> entry*;
 ```
-You can finally fit the histogram using the histogram object with the fit entry stored in the fitter, or histogram object and providing additional fit entry object:
+or request to create from generic entry if not found with:
 ```c++
-auto fit(TH1* hist, const char* pars = "BQ", const char* gpars = "") -> bool;
-auto fit(fit_entry* hfp, TH1* hist, const char* pars = "BQ", const char* gpars = "") -> bool;
+auto find_or_make(TH1* hist, entry* generic = nullptr) const -> entry*;
+auto find_or_make(const char* name, entry* generic = nullptr) const -> entry*;
+```
+
+You can finally fit the histogram (or graphs assuimg you rpivide name for nameless graph) using the histogram object with the fit entry stored in the fitter or using generic object fit entry:
+```c++
+auto fit(TH1* hist, const char* pars = "BQ", const char* gpars = "", entry* generic = nullptr) -> std::pair<bool, entry*>;
+auto fit(const char* name, TGraph* graph, const char* pars = "BQ", const char* gpars = "", entry* generic = nullptr) -> std::pair<bool, entry*>;
 ```
 In addition to importing from file, you can add additional fit entries to the fitter:
 ```c++
-auto insert_parameter(std::pair<std::string, fit_entry> hfp) -> void;
-auto insert_parameter(const std::string& name, std::unique_ptr<fit_entry> hfp) -> void;
+auto insert_parameter(std::pair<std::string, entry> hfp) -> void;
+auto insert_parameter(const std::string& name, std::unique_ptr<entry> hfp) -> void;
 ```
 To set default fitting function for histograms not present in the histogram entries collection, use
 ```c++
-auto set_generic_entry(fit_entry generic) -> void;
+auto set_generic_entry(entry generic) -> void;
 ```
 Use of generic function will create an entry in the auxiliary file, e.g.:
 ```c++
@@ -169,14 +175,14 @@ The decorator could have form of text string with a character `*`, which will be
 * decorator `*_v1` on `hist_name` will give `hist_name_v1`
 * but decorator `_v1` on `hist_name` will give `_v1`
 
-## `hf::fit_entry`
+## `hf::entry`
 The fit entry can be created by parsing the input file or created by user and provided to the fitter:
 ```c++
-explicit fit_entry(Double_t range_lower, Double_t range_upper);
+explicit entry(Double_t range_lower, Double_t range_upper);
 ```
 The fit entry can be read from file (as shown above) or created from the code level:
 ```c++
-hf::fit_entry hfp(0, 10);
+hf::entry hfp(0, 10);
 auto fid1 = hfp.add_function("gaus(0)");                    // function id = 0
 auto fid2 = hfp.add_function("expo(3)");                    // function id = 1
 hfp.set_param(0, 10, 0, 20, hf::param::fit_mode::free);     // gaus(0) par [0]
@@ -197,7 +203,7 @@ auto drop() -> void;
 ```
 You can use this before fit and fit result is of worse quality then one can restore original parameters.
 ```c++
-auto hfp = hf::fit_entry(0, 10);
+auto hfp = hf::entry(0, 10);
 hfp.add_function(...);
 // and more...
 

example/example1.cpp

@@ -182,7 +182,7 @@ auto main() -> int
         fmt::print("{}", "\n");
 
         hfp->backup();
-        if (!ff.fit(hfp, hist, "BQ0")) hfp->restore();
+        if (!ff.fit(hist, "BQ0", "", hfp).first) hfp->restore();
 
         fmt::print("{}", "\nAfter fitting:\n");
         hfp->print("test_hist", true);

inc/details.hpp

@@ -2,6 +2,7 @@
 #define HELLOFITTY_DETAILS_H
 
 #include <TF1.h>
+#include <TFitResult.h>
 
 #include <fmt/color.h>
 #include <fmt/core.h>
@@ -177,7 +178,6 @@ struct fitter_impl
     std::string par_ref;
     std::string par_aux;
 
-    entry generic_parameters;
     std::map<std::string, entry> hfpmap;
 
     std::string name_decorator{"*"};
@@ -208,6 +208,12 @@ struct fitter_impl
 
         auto fit_res = dataobj->Fit(tfSum, pars, gpars, hfp->get_fit_range_min(), hfp->get_fit_range_max());
 
+        auto fit_status = fit_res.Get() ? fit_res->Status() : int(fit_res);
+
+        if (fit_status != 0) {
+            return false;
+        }
+
         TF1* new_sig_func = dynamic_cast<TF1*>(dataobj->GetListOfFunctions()->At(0));
 
         // TVirtualFitter * fitter = TVirtualFitter::GetFitter();

include/hellofitty.hpp

@@ -64,6 +64,13 @@ class length_error : public std::length_error
     using std::length_error::length_error;
 };
 
+// Incorrect fitting range
+class range_error : public std::runtime_error
+{
+public:
+    using std::runtime_error::runtime_error;
+};
+
 namespace detail
 {
 struct draw_opts_impl;
@@ -307,15 +314,6 @@ class HELLOFITTY_EXPORT fitter final
 
     auto clear() -> void;
 
-    /// For histograms which have no record in the entries collection, you can set a generic
-    /// function and aparameters to be fit. It will not be used for disabled histograms.
-    /// Pass an empty object to clear the generic entry.
-    /// @param generic a generic histogram function object
-    auto set_generic_entry(entry generic) -> void;
-    /// Check if the generic entry is set.
-    /// @return true if the generic entry exists.
-    auto has_generic_entry() -> bool;
-
     /// Load parameters from the reference input.
     /// @param input_file the input parameters
     /// @return the file was properly imported
@@ -334,42 +332,31 @@ class HELLOFITTY_EXPORT fitter final
     auto find_fit(TH1* hist) const -> entry*;
     auto find_fit(const char* name) const -> entry*;
 
-    auto find_or_make(TH1* hist) -> entry*;
-    auto find_or_make(const char* name) -> entry*;
+    /// Find hfp by histogram name, or create from generic if not null.
+    /// @param hist object to find hfp for
+    /// @param generic object to use as a reference if name not found
+    /// @return hfp found for name, or created from geenric if not nullptr, or nullptr
+    auto find_or_make(TH1* hist, entry* generic = nullptr) -> entry*;
+    auto find_or_make(const char* name, entry* generic = nullptr) -> entry*;
 
     /// Fit the histogram using entry either located in the collection or using generic entry if provided.
     /// @param hist histogram to be fitted
     /// @param pars histogram fitting pars
     /// @param gpars histogram fit drawing pars
+    /// @param generic histogram entry to be used if non present yet
     /// @return pair of bool (true if fit successful) and used entry
-    auto fit(TH1* hist, const char* pars = "BQ", const char* gpars = "") -> std::pair<bool, entry*>;
-    /// Fit the histogram using provided entry. The fit entry is not automatically stored in the collection and must
-    /// be add using @see hf::fitter::insert_parameter.
-    /// @param hfp histogram entry to be used
-    /// @param hist histogram to be fitted
-    /// @param pars histogram fitting pars
-    /// @param gpars histogram fit drawing pars
-    /// @return true if fit was successful
-    auto fit(entry* hfp, TH1* hist, const char* pars = "BQ", const char* gpars = "") -> bool;
+    auto fit(TH1* hist, const char* pars = "BQ", const char* gpars = "", entry* generic = nullptr)
+        -> std::pair<bool, entry*>;
 
     /// Fit the graph using entry either located in the collection or using generic entry if provided.
     /// @param name entry name (graphs are not named object)
     /// @param graph graph to be fitted
     /// @param pars graph fitting pars
     /// @param gpars graph fit drawing pars
+    /// @param generic histogram entry to be used if non present yet
     /// @return pair of bool (true if fit successful) and used entry
-    auto fit(const char* name, TGraph* graph, const char* pars = "BQ", const char* gpars = "")
+    auto fit(const char* name, TGraph* graph, const char* pars = "BQ", const char* gpars = "", entry* generic = nullptr)
         -> std::pair<bool, entry*>;
-    /// Fit the graph using provided entry. The fit entry is not automatically stored in the collection and must
-    /// be add using @see hf::fitter::insert_parameter.
-    /// @param hfp graph entry to be used
-    /// @param name entry name (graphs are not named object)
-    /// @param graph graph to be fitted
-    /// @param hist graph to be fitted
-    /// @param pars graph fitting pars
-    /// @param gpars graph fit drawing pars
-    /// @return true if fit was successful
-    auto fit(entry* hfp, const char* name, TGraph* graph, const char* pars = "BQ", const char* gpars = "") -> bool;
 
     auto print() const -> void;
 

source/entry.cpp

@@ -51,6 +51,8 @@ entry::entry() : m_d{make_unique<detail::entry_impl>()} {}
 
 entry::entry(Double_t range_lower, Double_t range_upper) : m_d{make_unique<detail::entry_impl>()}
 {
+    if (range_lower == range_upper) throw hf::range_error("fitting range cannot be empty");
+
     m_d->range_min = range_lower;
     m_d->range_max = range_upper;
 }
@@ -149,6 +151,8 @@ auto entry::param(const char* name) -> hf::param&
 
 auto entry::set_fit_range(Double_t range_lower, Double_t range_upper) -> void
 {
+    if (range_lower == range_upper) throw hf::range_error("fitting range cannot be empty");
+
     m_d->range_min = range_lower;
     m_d->range_max = range_upper;
 

source/fitter.cpp

@@ -238,94 +238,62 @@ auto fitter::find_fit(const char* name) const -> entry*
     return nullptr;
 }
 
-auto fitter::find_or_make(TH1* hist) -> entry* { return find_or_make(hist->GetName()); }
+auto fitter::find_or_make(TH1* hist, entry* generic) -> entry* { return find_or_make(hist->GetName(), generic); }
 
-auto fitter::find_or_make(const char* name) -> entry*
+auto fitter::find_or_make(const char* name, entry* generic) -> entry*
 {
     entry* hfp = find_fit(name);
-    if (!hfp)
+    if (!hfp and generic)
     {
-        // fmt::print("HFP for histogram {:s} not found, trying from defaults.\n", name);
+        if (detail::fitter_impl::verbose_flag)
+            fmt::print("HFP for histogram {:s} not found, trying from generic.\n", name);
 
-        if (!m_d->generic_parameters.get_functions_count())
-            throw std::logic_error("Generic Fit Entry has no functions.");
+        if (!generic->get_functions_count()) throw std::logic_error("Generic Fit Entry has no functions.");
 
-        hfp = insert_parameter(std::string(name), m_d->generic_parameters);
-        if (!m_d->generic_parameters.get_functions_count()) throw std::logic_error("Could not insert new parameter.");
+        hfp = insert_parameter(std::string(name), *generic);
+        if (!hfp) throw std::logic_error("Could not insert new parameter.");
+
+        if (detail::fitter_impl::verbose_flag) fmt::print("HFP for histogram {:s} created from generic.\n", name);
     }
 
     return hfp;
 }
 
-auto fitter::fit(TH1* hist, const char* pars, const char* gpars) -> std::pair<bool, entry*>
+auto fitter::fit(TH1* hist, const char* pars, const char* gpars, entry* generic) -> std::pair<bool, entry*>
 {
-    entry* hfp = find_fit(hist->GetName());
-    if (!hfp)
-    {
-        fmt::print("HFP for histogram {:s} not found, trying from defaults.\n", hist->GetName());
-
-        if (!m_d->generic_parameters.get_functions_count())
-            throw std::logic_error("Generic Fit Entry has no functions.");
-
-        hfp = insert_parameter(std::string(hist->GetName()), m_d->generic_parameters);
-        if (!m_d->generic_parameters.get_functions_count()) throw std::logic_error("Could not insert new parameter.");
-    }
-
+    entry* hfp = find_or_make(hist->GetName(), generic);
     if (!hfp) return {false, hfp};
 
     hfp->backup();
-    bool status = fit(hfp, hist, pars, gpars);
 
-    if (!status) hfp->restore();
-
-    return {status, hfp};
-}
-
-auto fitter::fit(entry* hfp, TH1* hist, const char* pars, const char* gpars) -> bool
-{
     Int_t bin_l = hist->FindBin(hfp->get_fit_range_min());
     Int_t bin_u = hist->FindBin(hfp->get_fit_range_max());
 
     if (hfp->get_flag_rebin() != 0) { hist->Rebin(hfp->get_flag_rebin()); }
 
-    if (hist->Integral(bin_l, bin_u) == 0) return false;
+    if (bin_u - bin_l == 0) return {false, hfp};
+    // if (hist->Integral(bin_l, bin_u) == 0) return {false, hfp};
+
+    bool status = m_d->generic_fit(hfp, hfp->m_d.get(), hist->GetName(), hist, pars, gpars);
+    if (!status) hfp->restore();
 
-    return m_d->generic_fit(hfp, hfp->m_d.get(), hist->GetName(), hist, pars, gpars);
+    return {status, hfp};
 }
 
-auto fitter::fit(const char* name, TGraph* graph, const char* pars, const char* gpars) -> std::pair<bool, entry*>
+auto fitter::fit(const char* name, TGraph* graph, const char* pars, const char* gpars, entry* generic)
+    -> std::pair<bool, entry*>
 {
-    entry* hfp = find_fit(name);
-    if (!hfp)
-    {
-        fmt::print("HFP for graphs {:s} not found, trying from defaults.\n", name);
-
-        if (!m_d->generic_parameters.get_functions_count())
-            throw std::logic_error("Generic Fit Entry has no functions.");
-
-        hfp = insert_parameter(std::string(name), m_d->generic_parameters);
-        if (!m_d->generic_parameters.get_functions_count()) throw std::logic_error("Could not insert new parameter.");
-    }
-
+    entry* hfp = find_or_make(name, generic);
     if (!hfp) return {false, hfp};
 
     hfp->backup();
-    bool status = fit(hfp, name, graph, pars, gpars);
 
+    bool status = m_d->generic_fit(hfp, hfp->m_d.get(), name, graph, pars, gpars);
     if (!status) hfp->restore();
 
     return {status, hfp};
 }
 
-auto fitter::fit(entry* hfp, const char* name, TGraph* graph, const char* pars, const char* gpars) -> bool
-{
-    return m_d->generic_fit(hfp, hfp->m_d.get(), name, graph, pars, gpars);
-}
-
-auto fitter::set_generic_entry(entry generic) -> void { m_d->generic_parameters = generic; }
-
-auto fitter::has_generic_entry() -> bool { return m_d->generic_parameters.is_valid(); }
-
 auto fitter::set_name_decorator(std::string decorator) -> void { m_d->name_decorator = std::move(decorator); }
 auto fitter::clear_name_decorator() -> void { m_d->name_decorator = "*"; }