CUQIpy 0.4.0__py3-none-any.whl → 0.4.0.post0.dev19__py3-none-any.whl

{CUQIpy-0.4.0.dist-info → CUQIpy-0.4.0.post0.dev19.dist-info}/METADATA

@@ -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.dist-info → CUQIpy-0.4.0.post0.dev19.dist-info}/RECORD

@@ -1,6 +1,6 @@
 cuqi/__init__.py,sha256=K0ss2HNqoLUX7wGpSZdaPKxIaKdRS452fcJm4D0pcEs,433
 cuqi/_messages.py,sha256=fzEBrZT2kbmfecBBPm7spVu7yHdxGARQB4QzXhJbCJ0,415
-cuqi/_version.py,sha256=1d4RdYAEpT5aJ2M_OVtwSGn5gXF3JRmJHKn-h0_9RJU,497
+cuqi/_version.py,sha256=JZ7qGpXX_2jvjPCycacUOXXKJPcOS4cR_KiL1scwDxg,509
 cuqi/config.py,sha256=wcYvz19wkeKW2EKCGIKJiTpWt5kdaxyt4imyRkvtTRA,526
 cuqi/diagnostics.py,sha256=5OrbJeqpynqRXOe5MtOKKhe7EAVdOEpHIqHnlMW9G_c,3029
 cuqi/array/__init__.py,sha256=-EeiaiWGNsE3twRS4dD814BIlfxEsNkTCZUc5gjOXb0,30
@@ -39,7 +39,7 @@ cuqi/model/_model.py,sha256=Q_Mg48adoiv9WZKzzSA_kuyy8mEzXKjR9QM1QnpRTPA,24201
 cuqi/operator/__init__.py,sha256=0pc9p-KPyl7KtPV0noB0ddI0CP2iYEHw5rbw49D8Njk,136
 cuqi/operator/_operator.py,sha256=yNwPTh7jR07AiKMbMQQ5_54EgirlKFsbq9JN1EODaQI,8856
 cuqi/pde/__init__.py,sha256=NyS_ZYruCvy-Yg24qKlwm3ZIX058kLNQX9bqs-xg4ZM,99
-cuqi/pde/_pde.py,sha256=wWKwLCLQfJMcpelW0VC5S265dR8RAJEHkKKRs7Ss5rI,10337
+cuqi/pde/_pde.py,sha256=WRkOYyIdT_T3aZepRh0aS9C5nBbUZUcHaA80iSRvgoo,12572
 cuqi/problem/__init__.py,sha256=JxJty4JqHTOqSG6NeTGiXRQ7OLxiRK9jvVq3lXLeIRw,38
 cuqi/problem/_problem.py,sha256=jQ1SXFhS9vbjPOu2EgfXfi3MnioM9r49rSPLlDuMpBY,28944
 cuqi/sampler/__init__.py,sha256=2Rt-ISO5-bNECKOG_JbnLqtwnu9vKnYssmZV1QF-rvQ,361
@@ -63,8 +63,8 @@ cuqi/testproblem/_testproblem.py,sha256=1a52jc92NqsLRGyM5DLySNW0lVVOC6tkyKM_QV4K
 cuqi/utilities/__init__.py,sha256=EfxHLdsyDNugbmbzs43nV_AeKcycM9sVBjG9WZydagA,351
 cuqi/utilities/_get_python_variable_name.py,sha256=QwlBVj2koJRA8s8pWd554p7-ElcI7HUwY32HknaR92E,1827
 cuqi/utilities/_utilities.py,sha256=rjycaxDWExdskIfYXV1z5ZlB0JTlqv3tCmKf08i6U5c,7973
-CUQIpy-0.4.0.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
-CUQIpy-0.4.0.dist-info/METADATA,sha256=AtbU3rbpBpQllnM9HiCWfDES2dQuJcJyus4XBltJCaM,16443
-CUQIpy-0.4.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-CUQIpy-0.4.0.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
-CUQIpy-0.4.0.dist-info/RECORD,,
+CUQIpy-0.4.0.post0.dev19.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
+CUQIpy-0.4.0.post0.dev19.dist-info/METADATA,sha256=tIno8lEYjygD8oI8fQCKj3R69T1IwbERJA6fGMVVA44,16455
+CUQIpy-0.4.0.post0.dev19.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+CUQIpy-0.4.0.post0.dev19.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
+CUQIpy-0.4.0.post0.dev19.dist-info/RECORD,,

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
 

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