Compatibility with latest tlm_adjoint: Update methods to properties

Author: jrmaddison

fenics_ice/minimize_l_bfgs.py

@@ -1100,7 +1100,7 @@ def F(*X, force=False):
                 function_axpy(change, -1.0, last_m)
                 change_norm = max(change_norm, function_linf_norm(change))
             if change_norm == 0.0:
-                return last_F[2].value()
+                return last_F[2].value
 
         last_F[0] = functions_copy(X)
         functions_assign(M, X)
@@ -1116,12 +1116,12 @@ def F(*X, force=False):
         last_F[2] = forward(last_F[1])
         manager.stop()
 
-        return last_F[2].value()
+        return last_F[2].value
 
     def Fp(*X):
         F(*X, force=last_F[1] is None)
         dJ = manager.compute_gradient(last_F[2], last_F[1])
-        if manager._cp_schedule.is_exhausted():
+        if manager._cp_schedule.is_exhausted:
             last_F[1] = None
         return dJ
 

fenics_ice/solver.py

@@ -878,7 +878,7 @@ def inversion(self):
         ##########################################
         # dJ = compute_gradient(J, self.alpha)
         # ddJ = Hessian(forward)
-        # min_order = taylor_test(forward, self.alpha, J_val=J.value(),
+        # min_order = taylor_test(forward, self.alpha, J_val=J.value,
         #                         dJ=dJ, ddJ=ddJ, seed=1.0e-6)
 
         def l_bfgs_converged(it, old_J_val, new_J_val,
@@ -1309,36 +1309,36 @@ def comp_J_inv(self, verbose=False):
          u_PRP, v_PRP, l_u_obs, l_v_obs, J_u_obs, J_v_obs) = \
             self._cached_J_mismatch_data
 
-        J_ls_term_u = Functional(name="J_term_u", space=J.space())
-        J_ls_term_v = Functional(name="J_term_v", space=J.space())
+        J_ls_term_u = Functional(name="J_term_u", space=J.space)
+        J_ls_term_v = Functional(name="J_term_v", space=J.space)
 
         # .5 * u^T P^T R_u_obs^{-1} P u
-        J_term = space_new(J.space())
+        J_term = space_new(J.space)
         InnerProduct(J_term, uf, uf, M=u_PRP, alpha = fac).solve()
         J_ls_term_u.addto(J_term)
 
         # .5 * v^T P^T R_v_obs^{-1} P v
-        J_term = space_new(J.space())
+        J_term = space_new(J.space)
         InnerProduct(J_term, vf, vf, M=v_PRP, alpha = fac).solve()
         J_ls_term_v.addto(J_term)
 
         # -.5 * 2 * u_obs^T R_u_obs^{-1} P u
-        J_term = space_new(J.space())
+        J_term = space_new(J.space)
         InnerProduct(J_term, uf, l_u_obs, alpha=-2.0 * fac).solve()
         J_ls_term_u.addto(J_term)
 
         # -.5 * 2 * v_obs^T R_v_obs^{-1} P v
-        J_term = space_new(J.space())
+        J_term = space_new(J.space)
         InnerProduct(J_term, vf, l_v_obs, alpha=-2.0 * fac).solve()
         J_ls_term_v.addto(J_term)
 
         # .5 * u_obs R_u_obs^{-1} u_obs
-        J_term = space_new(J.space())
+        J_term = space_new(J.space)
         function_assign(J_term, fac * J_u_obs)
         J_ls_term_u.addto(J_term)
 
         # .5 * v_obs R_v_obs^{-1} v_obs
-        J_term = space_new(J.space())
+        J_term = space_new(J.space)
         function_assign(J_term, fac * J_v_obs)
         J_ls_term_v.addto(J_term)
 
@@ -1375,7 +1375,7 @@ def comp_J_inv(self, verbose=False):
 
         if verbose:
             # Print out results
-            J1 = J.value()
+            J1 = J.value
             J2 = (function_scalar_value(J_ls_term_u)
                   + function_scalar_value(J_ls_term_v))
 

runs/run_taylor_fwd_inv.py

@@ -84,7 +84,7 @@ def forward_ts(cntrl, cntrl_init, name):
                                                              cntrl_curr_init,
                                                              cntrl_curr.name()),
                                 cntrl_curr,
-                                J_val=J.value(),
+                                J_val=J.value,
                                 dJ=dJ_curr,
                                 seed=seeds[cntrl_curr.name()],
                                 M0=cntrl_curr_init,

tests/test_runs.py

@@ -57,7 +57,7 @@ def test_run_inversion(persistent_temp_model, monkeypatch):
     cntrl = mdl_out.solvers[0].get_control()[0]
     cntrl_norm = norm(cntrl.vector())
 
-    J_inv = mdl_out.solvers[0].J_inv.value()
+    J_inv = mdl_out.solvers[0].J_inv.value
 
     pytest.check_float_result(cntrl_norm,
                               expected_cntrl_norm,
@@ -220,7 +220,7 @@ def forward_ts(cntrl, cntrl_init, name):
                                                              cntrl_curr_init,
                                                              cntrl_curr.name()),
                                 cntrl_curr,
-                                J_val=J.value(),
+                                J_val=J.value,
                                 dJ=dJ_curr,
                                 seed=seeds[cntrl_curr.name()],
                                 M0=cntrl_curr_init,
@@ -356,7 +356,7 @@ def test_run_smith_inversion(temp_model, monkeypatch):
     mdl_out = run_inv.run_inv(toml_file)
 
     # Test inversion value
-    J_inv = mdl_out.solvers[0].J_inv.value()
+    J_inv = mdl_out.solvers[0].J_inv.value
 
     pytest.check_float_result(J_inv,
                               expected_J_inv,