Merge lp:~libadjoint/libadjoint/time-functionals into lp:libadjoint

[Patrick Farrell]

Changes to support the general syntax for Functionals in dolfin-adjoint.

[Simon Funke (simon-funke)]

Please add the missing docstrings for AdjointerTime.finish and .next

Otherwise, looks good.

review: Approve

[lp:~libadjoint/libadjoint/time-functionals]

352. By Patrick Farrell on 2012-07-03

Add some docstrings

[Simon Funke (simon-funke)]

dolfin_adjoint/functional.py, line 13:
 There is a remaining "FIX THIS" comment?

dolfin_adjoint/utils.py, line 10:
 importing adj_html is not required in this module. I suggest to remove this line.

review: Needs Fixing

[Simon Funke (simon-funke)]

Looks good, ship it!

review: Approve

=== modified file 'include/libadjoint/adj_adjointer_routines.h'
--- include/libadjoint/adj_adjointer_routines.h	2012-03-26 11:29:30 +0000
+++ include/libadjoint/adj_adjointer_routines.h	2012-07-03 15:37:21 +0000
@@ -49,6 +49,9 @@
 int adj_variable_known(adj_adjointer* adjointer, adj_variable var, int* known);
 int adj_get_variable_value(adj_adjointer* adjointer, adj_variable var, adj_vector* value);
 
+int adj_set_finished(adj_adjointer* adjointer, int  finished);
+int adj_get_finished(adj_adjointer* adjointer, int* finished);
+
 #ifndef ADJ_HIDE_FROM_USER
 int adj_set_storage_memory_copy(adj_adjointer* adjointer, adj_variable* var);
 int adj_set_storage_memory_incref(adj_adjointer* adjointer, adj_variable* var);

=== modified file 'include/libadjoint/adj_data_structures.h'
--- include/libadjoint/adj_data_structures.h	2012-03-26 08:49:18 +0000
+++ include/libadjoint/adj_data_structures.h	2012-07-03 15:37:21 +0000
@@ -294,6 +294,8 @@
   adj_func_callback_list functional_list;
   adj_func_deriv_callback_list functional_derivative_list;
   adj_parameter_source_callback_list parameter_source_list;
+
+  int finished; /* Is the annotation finished? */
 } adj_adjointer;
 
 int adj_create_variable(char* name, int timestep, int iteration, int auxiliary, adj_variable* var);

=== modified file 'python/libadjoint/libadjoint.py'
--- python/libadjoint/libadjoint.py	2012-06-05 07:57:02 +0000
+++ python/libadjoint/libadjoint.py	2012-07-03 15:37:21 +0000
@@ -78,6 +78,17 @@
     else:
       raise AttributeError
 
+  def __setattr__(self, key, val):
+    if key == "timestep":
+      self.var.timestep = val
+    elif key == "iteration":
+      self.var.iteration = val
+    elif key == "type":
+      type_map = {'ADJ_FORWARD': 1, 'ADJ_ADJOINT': 2, 'ADJ_TLM': 3}
+      self.var.type = type_map[val]
+    else:
+      object.__setattr__(self, key, val)
+
   def __eq__(self, other):
 
     if not isinstance(other, Variable): 
@@ -350,7 +361,7 @@
   def __init__(self):
     pass
 
-  def __call__(self, adjointer, dependencies, values):
+  def __call__(self, adjointer, timestep, dependencies, values):
     '''__call__(self, dependencies, values)
 
     Evaluate functional given dependencies with values. The result must be a scalar.
@@ -412,7 +423,7 @@
       values = [vector(values_c[i]) for i in range(ndepends_c)]
 
       # Now call the callback we've been given
-      output_c[0] = self(adjointer, dependencies, values)
+      output_c[0] = self(adjointer, timestep, dependencies, values)
 
     functional_type = ctypes.CFUNCTYPE(None, ctypes.POINTER(clib.adj_adjointer), ctypes.c_int, ctypes.c_int, ctypes.POINTER(clib.adj_variable), ctypes.POINTER(clib.adj_vector), ctypes.c_char_p, ctypes.POINTER(ctypes.c_double))
     return functional_type(cfunc)
@@ -614,13 +625,58 @@
         ctypes.POINTER(clib.adj_vector), ctypes.c_int, ctypes.POINTER(None), ctypes.POINTER(clib.adj_matrix))
     return rhs_deriv_assembly_type(cfunc)
 
+class AdjointerTime(object):
+  """class to facilitate recording the simulation time at which timesteps occur"""
+  def __init__(self, adjointer):
+    self.time_levels = []
+    self.finished = False
+    self.adjointer = adjointer
+
+  def start(self, time):
+    """start(self, time) 
+    Set the start time of the simulation."""
+    
+    if len(self.time_levels)!=0:
+      raise exceptions.LibadjointErrorInvalidInputs(
+        "time.start() called after simulation started!")
+
+    self.time_levels = [time]
+    
+  def finish(self):
+    """finish()
+    Record that the annotation has finished."""
+    self.finished = True
+    clib.adj_set_finished(self.adjointer.adjointer, 1)
+    
+  def next(self, time):
+    """Increment the timestep counter, and mark the end of the timestep."""
+    
+    if self.finished:
+      raise exceptions.LibadjointErrorInvalidInputs(
+        "time.next() called after simulation finished!")
+      
+    if self.time_levels==[]:
+      raise exceptions.LibadjointErrorInvalidInputs(
+        "time.next() called before time started!")
+
+    self.time_levels.append(time)
+    timestep = len(self.time_levels) - 2
+    self.adjointer.set_times(timestep, self.time_levels[-2], self.time_levels[-1])
+
+  def reset(self):
+    self.__init__(self.adjointer)
+    
+
 class Adjointer(object):
   def __init__(self, adjointer=None):
     self.functions_registered = []
     self.set_function_apis()
 
-    self.equation_timestep=[]
+    self.equation_timestep = []
 
+    # This gets clobbered during casting.
+    self.time = AdjointerTime(self)
+    
     if adjointer is None:
       self.adjointer = clib.adj_adjointer()
       clib.adj_create_adjointer(self.adjointer)
@@ -688,6 +744,7 @@
     self.adjointer_created = True
     self.c_object = self.adjointer
     self.__register_data_callbacks__()
+    self.time.reset()
 
   def __del__(self):
     if self.adjointer_created:
@@ -706,6 +763,10 @@
       timestep_count = ctypes.c_int()
       clib.adj_timestep_count(self.adjointer, timestep_count)
       return timestep_count.value
+    if name == "finished":
+      finished = ctypes.c_int()
+      clib.adj_get_finished(self.adjointer, finished)
+      return finished.value
     else:
       raise AttributeError(name)
 
@@ -767,7 +828,7 @@
 
     clib.adj_register_parameter_source_callback(self.adjointer, str(parameter), cfunc)
 
-  def __set_functional_dependencies__(self, functional, timestep):
+  def set_functional_dependencies(self, functional, timestep):
 
     dependencies = functional.dependencies(self,timestep)
 
@@ -819,7 +880,7 @@
     Evaluate the functional provided at t=timestep.'''
 
     self.__register_functional__(functional)
-    self.__set_functional_dependencies__(functional, timestep)
+    self.set_functional_dependencies(functional, timestep)
 
     output=clib.c_double()
 
@@ -862,7 +923,7 @@
   def get_adjoint_equation(self, equation, functional):
 
     self.__register_functional__(functional)
-    self.__set_functional_dependencies__(functional, self.equation_timestep[equation])
+    self.set_functional_dependencies(functional, self.equation_timestep[equation])
 
     lhs = clib.adj_matrix()
     rhs = clib.adj_vector()
@@ -878,7 +939,7 @@
   def get_adjoint_solution(self, equation, functional):
 
     self.__register_functional__(functional)
-    self.__set_functional_dependencies__(functional, self.equation_timestep[equation])
+    self.set_functional_dependencies(functional, self.equation_timestep[equation])
 
     output = clib.adj_vector()
     adj_var = clib.adj_variable()
@@ -947,6 +1008,16 @@
   def forget_tlm_values(self, equation):
     clib.adj_forget_tlm_values(self.adjointer, equation)
 
+  def set_times(self, timestep, start, end):
+    clib.adj_timestep_set_times(self.adjointer, timestep, start, end)
+
+  def get_times(self, timestep):
+    start = adj_scalar()
+    end = adj_scalar()
+
+    clib.adj_timestep_get_times(self.adjointer, timestep, start, end)
+    return (start.value, end.value)
+
   def __register_data_callbacks__(self):
     self.__register_data_callback__('ADJ_VEC_DUPLICATE_CB', self.__vec_duplicate_callback__)
     self.__register_data_callback__('ADJ_VEC_DESTROY_CB', self.__vec_destroy_callback__)

=== modified file 'src/adj_adjointer_routines.c'
--- src/adj_adjointer_routines.c	2012-06-27 10:54:40 +0000
+++ src/adj_adjointer_routines.c	2012-07-03 15:37:21 +0000
@@ -62,6 +62,8 @@
   adjointer->parameter_source_list.firstnode = NULL;
   adjointer->parameter_source_list.lastnode = NULL;
 
+  adjointer->finished = ADJ_FALSE;
+
   for (i = 0; i < ADJ_NO_OPTIONS; i++)
     adjointer->options[i] = 0; /* 0 is the default for all options */
 
@@ -2437,6 +2439,7 @@
 int adj_timestep_set_functional_dependencies(adj_adjointer* adjointer, int timestep, char* functional, int ndepends, adj_variable* dependencies)
 {
   int i;
+  int j;
   int ierr;
 
   adj_functional_data* functional_data_ptr = NULL;
@@ -2511,6 +2514,21 @@
     /* Record that this variable is necessary for the functional evaluation at this point in time */
     ierr = adj_append_unique(&(data_ptr->depending_timesteps), &(data_ptr->ndepending_timesteps), timestep);
     if (ierr != ADJ_OK) return adj_chkierr_auto(ierr);
+
+    /* Set that the j'th dependency is necessary for this guy's adjoint equation */
+    for (j = 0; j < ndepends; j++)
+    {
+      adj_variable_data* other_data_ptr;
+      ierr = adj_find_variable_data(&(adjointer->varhash), &(dependencies[j]), &other_data_ptr);
+      if (ierr == ADJ_ERR_HASH_FAILED)
+        continue;
+
+      if (other_data_ptr->equation >= 0)
+      {
+        ierr = adj_append_unique(&(data_ptr->adjoint_equations), &(data_ptr->nadjoint_equations), other_data_ptr->equation);
+        if (ierr != ADJ_OK) return adj_chkierr_auto(ierr);
+      }
+    }
   }
   /* We are done */
   return ADJ_OK;
@@ -2743,3 +2761,14 @@
   return ADJ_OK;
 }
 
+int adj_set_finished(adj_adjointer* adjointer, int  finished)
+{
+  adjointer->finished = finished;
+  return ADJ_OK;
+}
+
+int adj_get_finished(adj_adjointer* adjointer, int* finished)
+{
+  *finished = adjointer->finished;
+  return ADJ_OK;
+}

=== modified file 'src/adj_fortran.F90'
--- src/adj_fortran.F90	2012-04-12 15:46:20 +0000
+++ src/adj_fortran.F90	2012-07-03 15:37:21 +0000
@@ -145,6 +145,8 @@
     type(adj_func_callback_list) :: functional_list
     type(adj_func_deriv_callback_list) :: functional_derivative_list
     type(adj_parameter_source_callback_list) :: parameter_source_list
+
+    integer(kind=c_int) :: finished
   end type adj_adjointer
 
   type, bind(c) :: adj_vector