exception ctach fix

lib/LatAnalyze/Numerical/CompositeMinimizer.cpp

@@ -0,0 +1,71 @@
+/*
+ * CompositeMinimizer.cpp, part of LatAnalyze 3
+ *
+ * Copyright (C) 2013 - 2024 Antonin Portelli
+ *
+ * LatAnalyze 3 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LatAnalyze 3 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LatAnalyze 3.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <LatAnalyze/Numerical/CompositeMinimizer.hpp>
+#include <LatAnalyze/includes.hpp>
+#include "CompositeMinimizer.hpp"
+
+using namespace std;
+using namespace Latan;
+
+/******************************************************************************
+ *                   CompositeMinimizer implementation                        *
+ ******************************************************************************/
+// constructor ////////////////////////////////////////////////////////////////
+CompositeMinimizer::CompositeMinimizer(const std::vector<Minimizer *> &minimizer)
+: minVec_(minimizer)
+{
+    if (minVec_.size() == 0)
+    {
+        LATAN_ERROR(Size, "minimizer vector has size 0");
+    }
+}
+
+// access /////////////////////////////////////////////////////////////////////
+bool CompositeMinimizer::supportLimits(void) const
+{
+    return false;
+}
+
+// minimization ///////////////////////////////////////////////////////////////
+const DVec &CompositeMinimizer::operator()(const DoubleFunction &f)
+{
+    DVec &x = getState();
+    DVec tmp;
+    unsigned int i = 1, nMin = minVec_.size();
+
+    // resize minimizer state to match function number of arguments
+    if (f.getNArg() != x.size())
+    {
+        resize(f.getNArg());
+    }
+
+    for (auto &m: minVec_)
+    {
+        if (getVerbosity() >= Verbosity::Normal)
+        {
+            cout << "********** Composite minimizer step " << i << "/" << nMin << endl;
+        }
+        m->setInit(x);
+        x = (*m)(f);
+        i++;
+    }
+
+    return x;
+}

lib/LatAnalyze/Numerical/CompositeMinimizer.hpp

@@ -0,0 +1,68 @@
+/*
+ * CompositeMinimizer.hpp, part of LatAnalyze 3
+ *
+ * Copyright (C) 2013 - 2024 Antonin Portelli
+ *
+ * LatAnalyze 3 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LatAnalyze 3 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LatAnalyze 3.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef Latan_CompositeMinimizer_hpp_
+#define Latan_CompositeMinimizer_hpp_
+
+#include <LatAnalyze/Global.hpp>
+#include <LatAnalyze/Functional/Function.hpp>
+#include <LatAnalyze/Numerical/Minimizer.hpp>
+
+BEGIN_LATAN_NAMESPACE
+
+/******************************************************************************
+ *                       Class for chaining minimizers                        *
+ ******************************************************************************/
+class CompositeMinimizer: public Minimizer
+{
+public:
+    // constructors
+    explicit CompositeMinimizer(const std::vector<Minimizer *> &minimizer);
+    template <typename... Ts>
+    CompositeMinimizer(Minimizer &min, Ts & ... minimisers);
+    // destructor
+    virtual ~CompositeMinimizer(void) = default;
+    // access
+    virtual bool supportLimits(void) const;
+    // minimization
+    virtual const DVec & operator()(const DoubleFunction &f);
+private:
+    std::vector<Minimizer *> minVec_;
+};
+
+/******************************************************************************
+ *              CompositeMinimizer template implementation                    *
+ ******************************************************************************/
+template <typename... Ts>
+CompositeMinimizer::CompositeMinimizer(Minimizer &min, Ts & ... minimisers)
+{
+    static_assert(static_or<std::is_assignable<Minimizer &, Ts>::value...>::value,
+                  "model arguments are not compatible with Minimizer");
+
+
+    minVec_ = {&min, &minimisers...};
+    if (minVec_.size() == 0)
+    {
+        LATAN_ERROR(Size, "minimizer vector has size 0");
+    }
+}
+
+END_LATAN_NAMESPACE
+
+#endif // Latan_CompositeMinimizer_hpp_

lib/LatAnalyze/Numerical/MinuitMinimizer.cpp

@@ -164,8 +164,7 @@ const DVec & MinuitMinimizer::operator()(const DoubleFunction &f)
     {
         if (getVerbosity() >= Verbosity::Normal)
         {
-            cout << "========== Minuit minimization, pass #" << n + 1;
+            cout << "========== Minuit minimization, pass #" << n + 1 << endl;
-            cout << " =========" << endl;
         }
         min.Minimize();
         status = min.Status();

lib/LatAnalyze/Numerical/NloptMinimizer.cpp

@@ -94,8 +94,7 @@ const DVec & NloptMinimizer::operator()(const DoubleFunction &f)
     {
         if (getVerbosity() >= Verbosity::Normal)
         {
-            cout << "========== NLopt minimization, pass #" << n + 1;
+            cout << "========== NLopt minimization, pass #" << n + 1 << endl;
-            cout << " ==========" << endl;
             cout << "Algorithm: " << min.get_algorithm_name() << endl;
             cout << "Max eval.= " << min.get_maxeval();
             cout << " -- Precision= " << min.get_xtol_rel() << endl;

lib/LatAnalyze/Physics/DataFilter.hpp

@@ -118,20 +118,9 @@ double LaplaceDataFilter::optimiseFunction(const StatArray<MatType, o> &data,
         
         return res;
     }, 1);
-
+    
-    prec = 0.1;
     min.setPrecision(prec);
     reg = min(fnReg)(0);
-    for (unsigned int pass = 0; pass < nPass; pass++)
-    {
-        min.setLowLimit(0., (1.-10.*prec)*reg);
-        min.setHighLimit(0., (1.+10.*prec)*reg);
-        init(0) = reg;
-        min.setInit(init);
-        prec *= 0.1;
-        min.setPrecision(prec);
-        reg = min(fnReg)(0);
-    }
 
     return reg;
 }

lib/source-list.cmake

@@ -25,6 +25,7 @@ set(LATAN_HEADERS
     LatAnalyze/Io/IoObject.hpp
     LatAnalyze/Io/Xml/tinyxml2.hpp
     LatAnalyze/Io/XmlReader.hpp
+    LatAnalyze/Numerical/CompositeMinimizer.hpp
     LatAnalyze/Numerical/DWT.hpp
     LatAnalyze/Numerical/DWTFilters.hpp
     LatAnalyze/Numerical/Derivative.hpp
@@ -77,6 +78,7 @@ set(LATAN_SOURCES
     LatAnalyze/Io/Hdf5File.cpp
     LatAnalyze/Io/Io.cpp
     LatAnalyze/Io/XmlReader.cpp
+    LatAnalyze/Numerical/CompositeMinimizer.cpp
     LatAnalyze/Numerical/DWT.cpp
     LatAnalyze/Numerical/DWTFilters.cpp
     LatAnalyze/Numerical/Derivative.cpp

utils/sample-read.cpp

@@ -46,7 +46,7 @@ int main(int argc, char *argv[])
             Io::save(s, copy, File::Mode::write, name);
         }
     }
-    catch (Exceptions::Definition)
+    catch (Exceptions::Definition &)
     {
         DSample s    = Io::load<DSample>(fileName);
         string  name = Io::getFirstName(fileName);