CUQIpy 0.4.0__tar.gz → 0.4.0.post0.dev19__tar.gz

{CUQIpy-0.4.0 → CUQIpy-0.4.0.post0.dev19}/CUQIpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 0.4.0
+Version: 0.4.0.post0.dev19
 Summary: Computational Uncertainty Quantification for Inverse problems in Python
 Maintainer-email: "Nicolai A. B. Riis" <nabr@dtu.dk>, "Jakob S. Jørgensen" <jakj@dtu.dk>, "Amal M. Alghamdi" <amaal@dtu.dk>
 License:                                  Apache License

{CUQIpy-0.4.0 → CUQIpy-0.4.0.post0.dev19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 0.4.0
+Version: 0.4.0.post0.dev19
 Summary: Computational Uncertainty Quantification for Inverse problems in Python
 Maintainer-email: "Nicolai A. B. Riis" <nabr@dtu.dk>, "Jakob S. Jørgensen" <jakj@dtu.dk>, "Amal M. Alghamdi" <amaal@dtu.dk>
 License:                                  Apache License

{CUQIpy-0.4.0 → CUQIpy-0.4.0.post0.dev19}/cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-05-26T15:28:04+0200",
+ "date": "2023-06-09T10:16:49+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "c13be03edb3eb06da1d67ca35ebbcdc1ccf84f5b",
- "version": "0.4.0"
+ "full-revisionid": "d7e4a312b9c749d530f7cf3c06068857ab6b2fe2",
+ "version": "0.4.0.post0.dev19"
 }
 '''  # END VERSION_JSON
 

{CUQIpy-0.4.0 → CUQIpy-0.4.0.post0.dev19}/cuqi/pde/_pde.py

@@ -84,6 +84,8 @@ class PDE(ABC):
 
     @grid_obs.setter
     def grid_obs(self,value):
+        if value is None:
+            value = self.grid_sol
         self._grids_equal = self._compare_grid(value,self.grid_sol)
         self._grid_obs = value
 
@@ -186,7 +188,10 @@ class TimeDependentLinearPDE(LinearPDE):
         Callable function with signature `PDE_form(parameter, t)` where `parameter` is the Bayesian parameter and `t` is the time at which the PDE form is evaluated. The function returns a tuple of (`differential_operator`, `source_term`, `initial_condition`) where `differential_operator` is the linear operator at time `t`, `source_term` is the source term at time `t`, and `initial_condition` is the initial condition. The types of `differential_operator` and `source_term` are determined by what the method :meth:`linalg_solve` accepts as linear operator and right-hand side, respectively. The type of `initial_condition` should be the same type as the solution returned by :meth:`linalg_solve`.
 
     time_steps : ndarray 
-        An array of the discretized times corresponding to the time steps that starts with the initial time and ends with the final time.
+        An array of the discretized times corresponding to the time steps that starts with the initial time and ends with the final time
+        
+    time_obs : array_like or str
+        If passed as an array_like, it is an array of the times at which the solution is observed. If passed as a string it can be set to `final` to observe at the final time step, or `all` to observe at all time steps. Default is `final`.
 
     method: str
         Time stepping method. Currently two options are available `forward_euler` and  `backward_euler`.
@@ -199,12 +204,25 @@ class TimeDependentLinearPDE(LinearPDE):
     See demos/demo34_TimeDependentLinearPDE.py for 1D heat and 1D wave equations.
     """
 
-    def __init__(self, PDE_form, time_steps, method='forward_euler', **kwargs):
+    def __init__(self, PDE_form, time_steps, time_obs='final', method='forward_euler', **kwargs):
         super().__init__(PDE_form, **kwargs)
 
         self.time_steps = time_steps
         self.method = method
 
+        # Set time_obs
+        if time_obs is None:
+            raise ValueError("time_obs cannot be None")
+        elif isinstance(time_obs, str):
+            if time_obs.lower() == 'final':
+                time_obs = time_steps[-1:]
+            elif time_obs.lower() == 'all':
+                time_obs = time_steps
+            else:
+                raise ValueError("if time_obs is a string, it can only be set "
+                                 +"to `final` or `all`")
+        self._time_obs = time_obs
+
     @property
     def method(self):
         return self._method
@@ -226,37 +244,62 @@ class TimeDependentLinearPDE(LinearPDE):
 
     def solve(self):
         """Solve PDE by time-stepping"""
+        # initialize time-dependent solution
+        self.assemble_step(self.time_steps[0])
+        u = np.empty((len(self.initial_condition), len(self.time_steps)))
+        u[:, 0] = self.initial_condition
 
         if self.method == 'forward_euler':
             for idx, t in enumerate(self.time_steps[:-1]):
                 dt = self.time_steps[idx+1] - t
                 self.assemble_step(t)
-                if idx == 0:
-                    u = self.initial_condition
-                u = (dt*self.diff_op + np.eye(len(u)))@u + dt*self.rhs  # from u at time t, gives u at t+dt
+                u_pre = u[:, idx]
+                u[:, idx+1] = (dt*self.diff_op + np.eye(len(u_pre)))@u_pre + dt*self.rhs  # from u at time t, gives u at t+dt
             info = None
 
         if self.method == 'backward_euler':
             for idx, t in enumerate(self.time_steps[1:]):
                 dt = t - self.time_steps[idx]
                 self.assemble_step(t)
-                if idx == 0:
-                    u = self.initial_condition
-                A = np.eye(len(u)) - dt*self.diff_op
+                u_pre = u[:, idx]
+                A = np.eye(len(u_pre)) - dt*self.diff_op
                 # from u at time t-dt, gives u at t
-                u, info = self._solve_linear_system(
-                    A, u + dt*self.rhs, self._linalg_solve, self._linalg_solve_kwargs)
+                u[:, idx+1], info = self._solve_linear_system(
+                    A, u_pre + dt*self.rhs, self._linalg_solve, self._linalg_solve_kwargs)
 
         return u, info
 
     def observe(self, solution):
-            
-        if self.grids_equal:
-            solution_obs = solution
+
+        # If observation grid is the same as solution grid and observation time
+        # is the final time step then no need to interpolate
+        if self.grids_equal and np.all(self.time_steps[-1:] == self._time_obs):
+            solution_obs = solution[..., -1]
+
+        # Interpolate solution in time and space to the observation
+        # time and space
         else:
-            solution_obs = interp1d(self.grid_sol, solution, kind='quadratic')(self.grid_obs)
+            # Raise error if solution is 2D or 3D in space 
+            if len(solution.shape) > 2:
+                raise ValueError("Interpolation of solutions of 2D and 3D "+ 
+                                 "space dimensions based on the provided "+
+                                 "grid_obs and time_obs are not supported. "+
+                                 "You can, instead, pass a custom "+
+                                 "observation_map and pass grid_obs and "+
+                                 "time_obs as None.")
+            
+            # Interpolate solution in space and time to the observation
+            # time and space
+            solution_obs = scipy.interpolate.RectBivariateSpline(
+                self.grid_sol, self.time_steps, solution)(self.grid_obs,
+                                                          self._time_obs)
 
+        # Apply observation map
         if self.observation_map is not None:
             solution_obs = self.observation_map(solution_obs)
-            
-        return solution_obs
+        
+        # squeeze if only one time observation
+        if len(self._time_obs) == 1:
+            solution_obs = solution_obs.squeeze()
+
+        return solution_obs

{CUQIpy-0.4.0 → CUQIpy-0.4.0.post0.dev19}/tests/test_pde.py

@@ -181,14 +181,26 @@ def test_observe():
     assert(np.all(np.isclose(observed_sol, expected_observed_sol)))
 
 
-@pytest.mark.parametrize("method, time_steps, parametrization, expected_sol",
-                         [('forward_euler', 'fixed', 'initial_condition', 'sol1'),
-                          ('backward_euler', 'fixed', 'initial_condition', 'sol2'),
-                             ('backward_euler', 'varying',
-                              'initial_condition', 'sol3'),
-                             ('backward_euler', 'fixed', 'source_term1', 'sol4'),
-                             ('backward_euler', 'fixed', 'source_term2', 'sol5')])
-def test_TimeDependentLinearPDE_heat1D(copy_reference, method, time_steps, parametrization, expected_sol):
+@pytest.mark.parametrize(
+    "method, time_steps, parametrization, expected_sol",
+    [('forward_euler', 'fixed', 'initial_condition', 'sol1'),
+     ('backward_euler', 'fixed', 'initial_condition', 'sol2'),
+     ('backward_euler', 'varying',
+      'initial_condition', 'sol3'),
+     ('backward_euler', 'fixed', 'source_term1', 'sol4'),
+     ('backward_euler', 'fixed', 'source_term2', 'sol5')])
+@pytest.mark.parametrize(
+    "grid_obs, time_obs, observation_map, expected_obs",
+    [(None, 'final', None, 'obs1'),
+     (None, 'final', lambda x: x**2, 'obs2'),
+     ('half_grid', 'FINAL', None, 'obs3'),
+     ('half_grid', 'every_5', None, 'obs4'),
+     (None, 'every_5', lambda x: x**2, 'obs5'),
+     (np.array([3, 4.9]), np.array([0.9, 1]), lambda x: x**2, 'obs6')])
+def test_TimeDependentLinearPDE_heat1D(copy_reference, method, time_steps,
+                                       parametrization, expected_sol,
+                                       grid_obs, time_obs, observation_map,
+                                       expected_obs):
     """ Compute the final time solution of a 1D heat equation and
         compare it with previously stored solution (for 5 different set up choices).
     """
@@ -197,6 +209,7 @@ def test_TimeDependentLinearPDE_heat1D(copy_reference, method, time_steps, param
     L = 5  # 1D domain length
     max_time = 1  # Final time
     dx = L/(dim+1)   # Space step size
+    grid_sol = np.linspace(dx, L-dx, dim)  # Solution grid
 
     if method == 'forward_euler':
         cfl = 5/11  # The cfl condition to have a stable solution
@@ -234,18 +247,78 @@ def test_TimeDependentLinearPDE_heat1D(copy_reference, method, time_steps, param
         elif parametrization == 'source_term2':
             parameters = np.ones(dim)
 
-    # 4. Create a PDE object
+    # 4. Set up the observation parameters
+    if grid_obs == 'half_grid':
+        grid_obs = grid_sol[int(dim/2):]
+
+    if time_obs == 'every_5':
+        time_obs = time_steps[::5]
+
+    # 5. Create a PDE object
     PDE = cuqi.pde.TimeDependentLinearPDE(
-        PDE_form, time_steps, method=method)
+        PDE_form, time_steps, method=method,
+        grid_sol=grid_sol,
+        grid_obs=grid_obs, time_obs=time_obs,
+        observation_map=observation_map)
 
-    # 5 Solve the PDE
+    # 6. Solve the PDE
     PDE.assemble(parameters)
     sol, info = PDE.solve()
 
-    # 6 Compare the obtained solution with previously stored solution
-    solution_file = copy_reference("data/Heat1D_5solutions.npz")
+    # 7. Compare the obtained solution with previously stored solution
+    solution_file = copy_reference("data/Heat1D_data/Heat1D_5solutions.npz")
     expected_sols = np.load(solution_file)
-    assert(np.allclose(sol, expected_sols[expected_sol]))
+    assert (np.allclose(sol[:, -1], expected_sols[expected_sol]))
+
+    # 8. Compute the observed solution and compare it with previously
+    # stored solution
+
+    # compute the observed solution using the PDE object
+    obs_sol = PDE.observe(sol)
+
+    # compute the expected observed solution (for comparison)
+    if isinstance(time_obs, str) and time_obs.lower() == 'final':
+        time_obs = time_steps[-1:]
+    if grid_obs is None:
+        grid_obs = grid_sol
+
+    idx_x = [True if x in grid_obs else False for x in grid_sol]
+    idx_t = [True if t in time_obs else False for t in time_steps]
+
+    if sum(idx_x) != len(grid_obs) or sum(idx_t) != len(time_obs):
+        expected_observed_sol = scipy.interpolate.RectBivariateSpline(
+            grid_sol, time_steps, sol)(grid_obs, time_obs
+                                       )
+    else:
+        expected_observed_sol = sol[idx_x, :][:, idx_t]
+
+    if observation_map is not None:
+        expected_observed_sol = observation_map(expected_observed_sol)
+
+    if len(PDE._time_obs) == 1:
+        expected_observed_sol = expected_observed_sol.squeeze()
+
+    # load expected observed solution (for comparison)
+    # Skip sol1 due to its large size (not stored in file to save space)
+    if expected_sol != 'sol1':
+        obs_sol_file = copy_reference("data/Heat1D_data/Heat1D_obs_sol_"
+                                      + expected_sol+"_"
+                                      + expected_obs+".npz")
+        expected_observed_sol_from_file = np.load(obs_sol_file)["obs_sol"]
+
+        if len(PDE._time_obs) == 1:
+            expected_observed_sol_from_file = \
+                expected_observed_sol_from_file.squeeze()
+
+    # Compare the observed solution with the two expected observed solution
+    # (computed and loaded from file)
+    assert (np.allclose(obs_sol, expected_observed_sol))
+
+    if expected_sol != 'sol1':
+        assert (np.allclose(obs_sol, expected_observed_sol_from_file))
+    else:
+        assert expected_sol == 'sol1'
+
 
 @pytest.mark.xfail(reason="Test fails due to difficult to compare values (1e-6 to 1e-42)")
 def test_TimeDependentLinearPDE_wave1D(copy_reference):