Minimizer test fixed.

Author: LutzGross

SConstruct

@@ -136,7 +136,7 @@ vars.AddVariables(
   EnumVariable('build_trilinos', 'Instructs scons to build the trilinos library.', "make", allowed_values = build_trilinos_flavours),
   ('trilinos_prefix', 'Prefix/Paths to Trilinos installation (need to be set  if build_trilinos = False).', default_prefix),
   ('trilinos_libs', 'Trilinos libraries to link with', []),
-  PathVariable('trilinos_src', 'Top-level source directory for trilinos.', Dir('trilinos_source15').abspath, PathVariable.PathIsDir),
+  PathVariable('trilinos_src', 'Top-level source directory for trilinos.', Dir('trilinos_source16').abspath, PathVariable.PathIsDir),
   PathVariable('trilinos_build', 'Top-level build directory for trilinos.', Dir('#/build_trilinos').abspath, PathVariable.PathIsDirCreate),
   PathVariable('trilinos_install', 'Top-level install directory for trilinos when built', Dir('#/esys.trilinos').abspath, PathVariable.PathIsDirCreate),
   #('trilinos_install', 'path to install trilinos libs, default is <prefix>/lib/esys', 'default'),

escript/py_src/minimizer.py

@@ -812,8 +812,8 @@ def setOptions(self, **opts):
         :key m_tol: relative tolerance for solution `m` for termination of iteration
         :type m_tol: `float`
         :default m_tol: 1e-4
-        :key grad_tol: tolerance for gradient relative to initial costfunction value for termination of iteration
-        :type grad_tol: `float`
+        :key grad_tol: tolerance for gradient relative to initial cost function value for termination of iteration
+        :type grad_tol: `float` or None
         :default grad_tol: 1e-4
         :key truncation: sets the number of previous LBFGS iterations to keep
         :type truncation : `int`
@@ -854,7 +854,10 @@ def setOptions(self, **opts):
             elif o == "m_tol":
                 self._m_tol = max(float(opts[o]), EPSILON)
             elif o == "grad_tol":
-                self._grad_tol = max(float(opts[o]), EPSILON)
+                if opts[o] is None:
+                    self._grad_tol = None
+                else:
+                    self._grad_tol = max(float(opts[o]), EPSILON)
             elif o == 'historySize' or o == 'truncation':
                 assert opts[o] > 2, "Trancation must be greater than 2."
                 self._truncation = max(0, int(opts[o]))
@@ -946,7 +949,8 @@ def run(self, m):
         :rtype: m-type
         """
         assert self._m_tol > 0.
-        assert self._grad_tol > 0.
+        if not self._grad_tol is None:
+            assert self._grad_tol > 0.
         assert self._iterMax > 1
         assert self._relAlphaMin > 0.
         assert self._truncation > 0
@@ -981,7 +985,6 @@ def run(self, m):
             while not converged and not break_down and k < self._restart and iterCount < self._iterMax:
                 self.logger.info("********** iteration %3d **********" % iterCount)
                 self.logger.info("\tF(m) = %g" % Fm)
-                print(Fm)
                 # determine search direction
                 p = -self._twoLoop(H_scale, grad_Fm, s_and_y, m, args_m)
                 # Now we call the line search with F(m+alpha*p)
@@ -1040,16 +1043,17 @@ def run(self, m):
                     args_new = self.getCostFunction().getArgumentsAndCount(m_new)
                     grad_Fm_new = self.getCostFunction().getGradientAndCount(m_new, *args_new)
 
-                Ftol_abs = self._grad_tol * abs(max(abs(Fm), abs(Fm_new)))
-                dFm = abs(Fm - Fm_new)
-                flag = dFm <= Ftol_abs
-                if flag:
-                    converged = True
-                    self.logger.info("F(m) = %g" % Fm_new)
-                    self.logger.info("Gradient has converged: |F-Fold|=%g < g_tol*max(|F|,|Fold|)=%g" % (dFm, Ftol_abs))
-                    break
-                else:
-                    self.logger.info("Gradient checked: |F-Fold|=%g, g_tol*max(|F|,|Fold|)=%g" % (dFm, Ftol_abs))
+                if not self._grad_tol is None:
+                    Ftol_abs = self._grad_tol * abs(max(abs(Fm), abs(Fm_new)))
+                    dFm = abs(Fm - Fm_new)
+                    flag = dFm <= Ftol_abs
+                    if flag:
+                        converged = True
+                        self.logger.info("F(m) = %g" % Fm_new)
+                        self.logger.info("Gradient has converged: |F-Fold|=%g < g_tol*max(|F|,|Fold|)=%g" % (dFm, Ftol_abs))
+                        break
+                    else:
+                        self.logger.info("Gradient checked: |F-Fold|=%g, g_tol*max(|F|,|Fold|)=%g" % (dFm, Ftol_abs))
 
                 delta_g = grad_Fm_new - grad_Fm
                 rho = self.getCostFunction().getDualProductAndCount(delta_m, delta_g)

escript/test/python/run_minimizer.py

@@ -112,31 +112,37 @@ class Test_MinimizerBFGS(unittest.TestCase):
             'm_true': [0.756394642236015, -0.210685240100182,  1.315069006925737] }
     def testTEST1(self):
         F = MinDist(**self.TEST1)
-        solve = MinimizerLBFGS(F, m_tol=1e-8, grad_tol=1e-10, iterMax=30)
+        solve = MinimizerLBFGS(F, m_tol=1e-7, grad_tol=None, iterMax=100)
         m0 = np.zeros((F.dimension,))
         solve.run(m0)
         m = solve.getResult()
-        print(m, F.m_true)
         self.assertTrue(np.allclose(m, F.m_true))
 
     def testTEST2(self):
         F = MinDist(**self.TEST2)
-        solve = MinimizerLBFGS(F, m_tol=1e-8, grad_tol=1e-10,  iterMax=100)
+        solve = MinimizerLBFGS(F, m_tol=1e-7, grad_tol=None,  iterMax=100)
         m0 = np.zeros((F.dimension,))
         solve.run(m0)
         m = solve.getResult()
-        print(m, F.m_true)
         self.assertTrue(np.allclose(m, F.m_true))
 
     def testTEST3(self):
         F = MinDist(**self.TEST3)
-        solve = MinimizerLBFGS(F, m_tol=1e-8, grad_tol=1e-10,  iterMax=100)
+        solve = MinimizerLBFGS(F, m_tol=1e-7, grad_tol=None,  iterMax=100)
         m0 = np.zeros((F.dimension,))
         solve.run(m0)
         m = solve.getResult()
-        print(m, F.m_true)
         self.assertTrue(np.allclose(m, F.m_true))
 
+    def testTEST4(self):
+        F = MinDist(**self.TEST1)
+        solve = MinimizerLBFGS(F, m_tol=1e-10, grad_tol=1e-8, iterMax=100)
+        m0 = np.zeros((F.dimension,))
+        solve.run(m0)
+        m = solve.getResult()
+        #print((m-F.m_true)/F.m_true)
+        self.assertTrue(np.allclose(m, F.m_true, rtol=1e-3))
+
     def testOptions(self):
         """
         test for setting options

escriptcore/test/python/test_objects.py

@@ -614,8 +614,9 @@ def test_DumpAndLoad_Constant(self):
             ]:
 
             for rank in range(5):
+                print(spacename, rank)
                 filename=os.path.join(self.filename_base,
-                        "constant_{0}_rank{1}.nc".format(spacename, rank))
+                        "constant_{0}_rank{1}.h5".format(spacename, rank))
                 d=Data(self.args[rank], functionspace(self.domain))
                 self._diffDataObjects(d,filename)