From 553206fdf670c5c6810d1561b26ff3486bdc9f89 Mon Sep 17 00:00:00 2001
From: Daniel Ching <carterbox@users.noreply.github.com>
Date: Thu, 28 Apr 2022 13:46:18 -0500
Subject: [PATCH 01/15] NEW: Add reconstruction context manager for ptycho
 reconstruction

Because
- Allows checking results of reconstruction without stopping and
destroying data on GPU
- Hides away internal APIs and device memory management
---
 src/tike/ptycho/ptycho.py | 311 +++++++++++++++++++++++++-------------
 1 file changed, 204 insertions(+), 107 deletions(-)

diff --git a/src/tike/ptycho/ptycho.py b/src/tike/ptycho/ptycho.py
index 93b153d1..da1fe5b7 100644
--- a/src/tike/ptycho/ptycho.py
+++ b/src/tike/ptycho/ptycho.py
@@ -52,6 +52,7 @@
 __all__ = [
     "reconstruct",
     "simulate",
+    "Reconstruction",
 ]
 
 from itertools import product, chain
@@ -234,118 +235,214 @@ def reconstruct(
         function to resume reconstruction from the previous state.
 
     """
-    if (np.any(np.asarray(data.shape) < 1) or data.ndim != 3
-            or data.shape[-2] != data.shape[-1]):
-        raise ValueError(
-            f"data shape {data.shape} is incorrect. "
-            "It should be (N, W, H), "
-            "where N >= 1 is the number of square diffraction patterns.")
-    if (scan.ndim != 2 or scan.shape[1] != 2
-            or np.any(np.asarray(scan.shape) < 1)):
-        raise ValueError(f"scan shape {scan.shape} is incorrect. "
-                         "It should be (N, 2) "
-                         "where N >= 1 is the number of scan positions.")
-    if data.shape[0] != scan.shape[0]:
-        raise ValueError(
-            f"data shape {data.shape} and scan shape {scan.shape} "
-            "are incompatible. They should have the same leading dimension.")
-    if (probe.ndim != 5 or probe.shape[:2] != (1, 1)
-            or np.any(np.asarray(probe.shape) < 1)
-            or probe.shape[-2] != probe.shape[-1]):
-        raise ValueError(f"probe shape {probe.shape} is incorrect. "
-                         "It should be (1, 1, S, W, H) "
-                         "where S >=1 is the number of probes, and "
-                         "W, H >= 1 are the square probe grid dimensions.")
-    if np.any(np.asarray(probe.shape[-2:]) > np.asarray(data.shape[-2:])):
-        raise ValueError(f"probe shape {probe.shape} is incorrect."
-                         "The probe width/height must be "
-                         f"<= the data width/height {data.shape}.")
-    if (psi.ndim != 2
-            or np.any(np.asarray(psi.shape) <= np.asarray(probe.shape[-2:]))):
-        raise ValueError(f"psi shape {psi.shape} is incorrect. "
-                         "It should be (W, H) where W, H > probe.shape[-2:].")
-    check_allowed_positions(scan, psi, probe.shape)
-    logger.info("{} for {:,d} - {:,d} by {:,d} frames for {:,d} "
-                "iterations.".format(
-                    algorithm_options.name,
-                    *data.shape[-3:],
-                    algorithm_options.num_iter,
-                ))
-
-    if use_mpi is True:
-        mpi = MPIComm
-        if psi is None:
+    with tike.ptycho.Reconstruction(
+            data,
+            probe,
+            psi,
+            scan,
+            algorithm_options,
+            eigen_probe,
+            eigen_weights,
+            model,
+            num_gpu,
+            object_options,
+            position_options,
+            probe_options,
+            use_mpi,
+    ) as context:
+        context.iterate(algorithm_options.num_iter)
+        result = context.get_result()
+    return result
+
+
+class Reconstruction():
+
+    def __init__(
+        self,
+        data,
+        probe,
+        psi,
+        scan,
+        algorithm_options=solvers.RpieOptions(),
+        eigen_probe=None,
+        eigen_weights=None,
+        model='gaussian',
+        num_gpu=1,
+        object_options=None,
+        position_options=None,
+        probe_options=None,
+        use_mpi=False,
+    ):
+        if (np.any(np.asarray(data.shape) < 1) or data.ndim != 3
+                or data.shape[-2] != data.shape[-1]):
             raise ValueError(
-                "When MPI is enabled, initial object guess cannot be None; "
-                "automatic psi initialization is not synchronized "
-                "across processes.")
-    else:
-        mpi = None
-    with (cp.cuda.Device(num_gpu[0] if isinstance(num_gpu, tuple) else None)):
-        with Ptycho(
-                probe_shape=probe.shape[-1],
-                detector_shape=data.shape[-1],
-                nz=psi.shape[-2],
-                n=psi.shape[-1],
-                model=model,
-        ) as operator, Comm(num_gpu, mpi) as comm:
-
-            (
-                batches,
-                data,
-                result,
-                scan,
-            ) = _setup(
-                algorithm_options,
-                comm,
-                data,
-                eigen_probe,
-                eigen_weights,
-                object_options,
-                operator,
-                probe,
-                psi,
-                position_options,
-                probe_options,
-                scan,
+                f"data shape {data.shape} is incorrect. "
+                "It should be (N, W, H), "
+                "where N >= 1 is the number of square diffraction patterns.")
+        if (scan.ndim != 2 or scan.shape[1] != 2
+                or np.any(np.asarray(scan.shape) < 1)):
+            raise ValueError(f"scan shape {scan.shape} is incorrect. "
+                             "It should be (N, 2) "
+                             "where N >= 1 is the number of scan positions.")
+        if data.shape[0] != scan.shape[0]:
+            raise ValueError(
+                f"data shape {data.shape} and scan shape {scan.shape} "
+                "are incompatible. They should have the same leading dimension."
             )
+        if (probe.ndim != 5 or probe.shape[:2] != (1, 1)
+                or np.any(np.asarray(probe.shape) < 1)
+                or probe.shape[-2] != probe.shape[-1]):
+            raise ValueError(f"probe shape {probe.shape} is incorrect. "
+                             "It should be (1, 1, S, W, H) "
+                             "where S >=1 is the number of probes, and "
+                             "W, H >= 1 are the square probe grid dimensions.")
+        if np.any(np.asarray(probe.shape[-2:]) > np.asarray(data.shape[-2:])):
+            raise ValueError(f"probe shape {probe.shape} is incorrect."
+                             "The probe width/height must be "
+                             f"<= the data width/height {data.shape}.")
+        if (psi.ndim != 2 or
+                np.any(np.asarray(psi.shape) <= np.asarray(probe.shape[-2:]))):
+            raise ValueError(
+                f"psi shape {psi.shape} is incorrect. "
+                "It should be (W, H) where W, H > probe.shape[-2:].")
+        check_allowed_positions(scan, psi, probe.shape)
+        logger.info("{} for {:,d} - {:,d} by {:,d} frames for {:,d} "
+                    "iterations.".format(
+                        algorithm_options.name,
+                        *data.shape[-3:],
+                        algorithm_options.num_iter,
+                    ))
+
+        if use_mpi is True:
+            mpi = MPIComm
+            if psi is None:
+                raise ValueError(
+                    "When MPI is enabled, initial object guess cannot be None; "
+                    "automatic psi initialization is not synchronized "
+                    "across processes.")
+        else:
+            mpi = None
+
+        self.data = data
+        self.probe = probe
+        self.psi = psi
+        self.scan = scan
+        self.algorithm_options = algorithm_options
+        self.eigen_probe = eigen_probe
+        self.eigen_weights = eigen_weights
+
+        self.object_options = object_options
+        self.position_options = position_options
+        self.probe_options = probe_options
+
+        self.device = cp.cuda.Device(
+            num_gpu[0] if isinstance(num_gpu, tuple) else None)
+        self.operator = Ptycho(
+            probe_shape=probe.shape[-1],
+            detector_shape=data.shape[-1],
+            nz=psi.shape[-2],
+            n=psi.shape[-1],
+            model=model,
+        )
+        self.comm = Comm(num_gpu, mpi)
 
-            start = time.perf_counter()
-            for i in range(algorithm_options.num_iter):
-
-                logger.info(f"{algorithm_options.name} epoch {i:,d}")
-
-                # TODO: Append new information to everything that emits from
-                # _setup.
-
-                result = _iterate(
-                    algorithm_options,
-                    batches,
-                    comm,
-                    data,
-                    operator,
-                    position_options,
-                    probe_options,
-                    result,
-                )
-
-                # TODO: Grab intermediate psi/probe from GPU.
-
-                algorithm_options.times.append(time.perf_counter() - start)
-                start = time.perf_counter()
-
-            return _teardown(
-                algorithm_options,
-                comm,
-                eigen_probe,
-                eigen_weights,
-                object_options,
-                position_options,
-                probe_options,
-                result,
-                scan,
+    def __enter__(self):
+        self.device.__enter__()
+        self.operator.__enter__()
+        self.comm.__enter__()
+
+        (
+            self.batches,
+            self.data,
+            self.result,
+            self.scan,
+        ) = _setup(
+            self.algorithm_options,
+            self.comm,
+            self.data,
+            self.eigen_probe,
+            self.eigen_weights,
+            self.object_options,
+            self.operator,
+            self.probe,
+            self.psi,
+            self.position_options,
+            self.probe_options,
+            self.scan,
+        )
+        return self
+
+    def iterate(self, num_iter):
+        start = time.perf_counter()
+        for i in range(num_iter):
+
+            logger.info(f"{self.algorithm_options.name} epoch "
+                        f"{len(self.algorithm_options.times):,d}")
+
+            self.result = _iterate(
+                self.algorithm_options,
+                self.batches,
+                self.comm,
+                self.data,
+                self.operator,
+                self.position_options,
+                self.probe_options,
+                self.result,
             )
 
+            self.algorithm_options.times.append(time.perf_counter() - start)
+            start = time.perf_counter()
+
+    def get_result(self):
+        return _teardown(
+            self.algorithm_options,
+            self.comm,
+            self.eigen_probe,
+            self.eigen_weights,
+            self.object_options,
+            self.position_options,
+            self.probe_options,
+            self.result,
+            self.scan,
+        )
+
+    def __exit__(self, type, value, traceback):
+        self.comm.__exit__(type, value, traceback)
+        self.operator.__exit__(type, value, traceback)
+        self.device.__exit__(type, value, traceback)
+
+    def peek(self):
+        """Peek at the curent values of object and probe mid-reconstruction."""
+        reorder = np.argsort(np.concatenate(self.comm.order))
+        eigen_probe = self.result['eigen_probe'][0].get(
+        ) if 'eigen_probe' in self.result else None
+        eigen_weights = self.comm.pool.gather(
+            self.result['eigen_weights'],
+            axis=-3,
+        )[reorder].get() if 'eigen_weights' in self.result else None
+        probe = self.result['probe'][0].get()
+        psi = self.result['psi'][0].get()
+        return psi, probe, eigen_probe, eigen_weights
+
+    def _append_new_data(
+        comm,
+        new_data,
+        new_scan,
+        data,
+        scan,
+        eigen_weights,
+        operator,
+        position_options,
+    ):
+        """"Append new diffraction patterns and scan positions to exisiting result."""
+        raise NotImplementedError()
+
+        # Assign positions and data to correct devices and batches.
+
+        # increase the size of eigen_weights and position options
+
+        return eigen_weights, position_options, data, scan
+
 
 def _setup(
     algorithm_options,

From 45dd23e20ea61cd4e4ef9a0d45dc19d968cae3c6 Mon Sep 17 00:00:00 2001
From: Daniel Ching <carterbox@users.noreply.github.com>
Date: Tue, 3 May 2022 17:52:55 -0500
Subject: [PATCH 02/15] NEW: Switch to plain momentum for lstsq_grad

---
 src/tike/opt.py                  | 17 +++++++++++++++++
 src/tike/ptycho/solvers/lstsq.py | 22 +++++++++++++++++++---
 tests/ptycho/test_ptycho.py      |  7 +++++--
 3 files changed, 41 insertions(+), 5 deletions(-)

diff --git a/src/tike/opt.py b/src/tike/opt.py
index 48a7c548..2753571a 100644
--- a/src/tike/opt.py
+++ b/src/tike/opt.py
@@ -37,6 +37,23 @@ def put_batch(y, x, b, n):
     x[b[n]] = y
 
 
+def momentum(g, v, m, vdecay=None, mdecay=0.9):
+    """Add momentum to the gradient direction.
+
+    Parameters
+    ----------
+    g : vector
+        The current gradient.
+    m : vector
+        The momentum.
+    eps : float
+        A tiny constant to prevent zero division.
+    """
+    m = 0 if m is None else m
+    m = mdecay * m + (1 - mdecay) * g
+    return m, None, m
+
+
 def adagrad(g, v=None, eps=1e-6):
     """Return the adaptive gradient algorithm direction.
 
diff --git a/src/tike/ptycho/solvers/lstsq.py b/src/tike/ptycho/solvers/lstsq.py
index a11b7b24..4f0ba362 100644
--- a/src/tike/ptycho/solvers/lstsq.py
+++ b/src/tike/ptycho/solvers/lstsq.py
@@ -473,7 +473,7 @@ def _update_nearplane(
                     dpsi,
                     object_options.v,
                     object_options.m,
-                ) = tike.opt.adam(
+                ) = tike.opt.momentum(
                     g=dpsi,
                     v=object_options.v,
                     m=object_options.m,
@@ -495,9 +495,25 @@ def _update_nearplane(
                     axis=-5,
                 )
 
+
+            dprobe = weighted_step_probe[0] * common_grad_probe[0]
+            if probe_options.use_adaptive_moment:
+                if probe_options.m is None:
+                    probe_options.m = cp.zeros_like(probe[0])
+                (
+                    dprobe,
+                    probe_options.v,
+                    probe_options.m[..., [m], :, :],
+                ) = tike.opt.momentum(
+                    g=dprobe,
+                    v=probe_options.v,
+                    m=probe_options.m[..., [m], :, :],
+                    vdecay=probe_options.vdecay,
+                    mdecay=probe_options.mdecay,
+                )
+
             # (27a) Probe update
-            probe[0][..., [m], :, :] += (weighted_step_probe[0] *
-                                         common_grad_probe[0])
+            probe[0][..., [m], :, :] += dprobe
             probe = comm.pool.bcast([probe[0]])
 
         if position_options and m == 0:
diff --git a/tests/ptycho/test_ptycho.py b/tests/ptycho/test_ptycho.py
index 783f2137..1fea19e7 100644
--- a/tests/ptycho/test_ptycho.py
+++ b/tests/ptycho/test_ptycho.py
@@ -323,7 +323,10 @@ def test_consistent_lstsq_grad(self):
                 'num_gpu':
                     2,
                 'probe_options':
-                    ProbeOptions(orthogonality_constraint=True,),
+                    ProbeOptions(
+                        orthogonality_constraint=True,
+                        use_adaptive_moment=True,
+                    ),
                 'object_options':
                     ObjectOptions(
                         use_adaptive_moment=True,
@@ -354,7 +357,7 @@ def test_consistent_lstsq_grad_variable_probe(self):
                 ProbeOptions(),
             'object_options':
                 ObjectOptions(
-                    use_adaptive_moment=True,
+                    use_adaptive_moment=8,
                 ),
             'use_mpi':
                 _mpi_size > 1,

From a0b49df6a75fcb748541e8a2cd791e7d8a36dfbb Mon Sep 17 00:00:00 2001
From: Daniel Ching <carterbox@users.noreply.github.com>
Date: Tue, 3 May 2022 17:53:10 -0500
Subject: [PATCH 03/15] BUG: Handle no eigen_probes in peek

---
 src/tike/ptycho/ptycho.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tike/ptycho/ptycho.py b/src/tike/ptycho/ptycho.py
index da1fe5b7..fe67f1a4 100644
--- a/src/tike/ptycho/ptycho.py
+++ b/src/tike/ptycho/ptycho.py
@@ -415,11 +415,11 @@ def peek(self):
         """Peek at the curent values of object and probe mid-reconstruction."""
         reorder = np.argsort(np.concatenate(self.comm.order))
         eigen_probe = self.result['eigen_probe'][0].get(
-        ) if 'eigen_probe' in self.result else None
+        ) if self.eigen_probe is not None else None
         eigen_weights = self.comm.pool.gather(
             self.result['eigen_weights'],
             axis=-3,
-        )[reorder].get() if 'eigen_weights' in self.result else None
+        )[reorder].get() if self.eigen_weights is not None else None
         probe = self.result['probe'][0].get()
         psi = self.result['psi'][0].get()
         return psi, probe, eigen_probe, eigen_weights

From a056ba7bca866c856b668fa18859e88a78b7e236 Mon Sep 17 00:00:00 2001
From: Daniel Ching <carterbox@users.noreply.github.com>
Date: Wed, 4 May 2022 17:53:21 -0500
Subject: [PATCH 04/15] Split probe and psi get functions

---
 src/tike/ptycho/ptycho.py | 22 +++++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/src/tike/ptycho/ptycho.py b/src/tike/ptycho/ptycho.py
index fe67f1a4..88367254 100644
--- a/src/tike/ptycho/ptycho.py
+++ b/src/tike/ptycho/ptycho.py
@@ -256,6 +256,12 @@ def reconstruct(
 
 
 class Reconstruction():
+    """Context manager for streaming ptychography reconstruction.
+
+    Uses same parameters as the functional reconstruct API.
+
+    ..seealso:: tike.ptycho.reconstruct
+    """
 
     def __init__(
         self,
@@ -411,8 +417,13 @@ def __exit__(self, type, value, traceback):
         self.operator.__exit__(type, value, traceback)
         self.device.__exit__(type, value, traceback)
 
-    def peek(self):
-        """Peek at the curent values of object and probe mid-reconstruction."""
+
+    def get_psi(self):
+        """Return the current object estimate as numpy arrays."""
+        return self.result['psi'][0].get()
+
+    def get_probe(self):
+        """Return the current probe, eigen_probe, weights as numpy arrays."""
         reorder = np.argsort(np.concatenate(self.comm.order))
         eigen_probe = self.result['eigen_probe'][0].get(
         ) if self.eigen_probe is not None else None
@@ -421,7 +432,12 @@ def peek(self):
             axis=-3,
         )[reorder].get() if self.eigen_weights is not None else None
         probe = self.result['probe'][0].get()
-        psi = self.result['psi'][0].get()
+        return probe, eigen_probe, eigen_weights
+
+    def peek(self):
+        """Return the curent values of object and probe as numpy arrays."""
+        psi = self.get_psi()
+        probe, eigen_probe, eigen_weights = self.get_probe()
         return psi, probe, eigen_probe, eigen_weights
 
     def _append_new_data(

From ee9d085dbc7272a0b2fea3df163d356228e688dd Mon Sep 17 00:00:00 2001
From: Daniel Ching <carterbox@users.noreply.github.com>
Date: Mon, 9 May 2022 16:39:20 -0500
Subject: [PATCH 05/15] API: Add a dataclass to make online reconstruction API
 easier

---
 src/tike/ptycho/position.py          |  51 +++-
 src/tike/ptycho/ptycho.py            | 417 ++++++++++++---------------
 src/tike/ptycho/solvers/__init__.py  |   1 +
 src/tike/ptycho/solvers/adam.py      |  33 ++-
 src/tike/ptycho/solvers/conjugate.py |  32 +-
 src/tike/ptycho/solvers/lstsq.py     |  44 +--
 src/tike/ptycho/solvers/options.py   |  91 +++++-
 src/tike/ptycho/solvers/rpie.py      |  39 ++-
 tests/operators/test_lamino.py       |   8 +-
 tests/operators/util.py              |   6 +-
 tests/ptycho/test_position.py        |  35 +++
 tests/ptycho/test_ptycho.py          | 343 +++++++++++-----------
 tests/test_lamino.py                 |  12 +-
 13 files changed, 613 insertions(+), 499 deletions(-)
 create mode 100644 tests/ptycho/test_position.py

diff --git a/src/tike/ptycho/position.py b/src/tike/ptycho/position.py
index ce71ec89..76507843 100644
--- a/src/tike/ptycho/position.py
+++ b/src/tike/ptycho/position.py
@@ -40,6 +40,34 @@ def __post_init__(self):
                 dtype='float32',
             )
 
+    def append(self, new_scan):
+        self.initial_scan = np.append(
+            self.initial_scan,
+            values=new_scan,
+            axis=-2,
+        )
+        if self.use_adaptive_moment:
+            self._momentum = np.pad(
+                self._momentum,
+                pad_width=(
+                    (0, len(new_scan)),
+                    (0, 0),
+                ),
+                mode='constant',
+            )
+
+    def empty(self):
+        new = PositionOptions(
+            np.empty((0, 2)),
+            use_adaptive_moment=self.use_adaptive_moment,
+            vdecay=self.vdecay,
+            mdecay=self.mdecay,
+            use_position_regularization=self.use_position_regularization,
+        )
+        if self.use_adaptive_moment:
+            new._momentum = np.empty((0, 4))
+        return new
+
     def split(self, indices):
         """Split the PositionOption meta-data along indices."""
         new = PositionOptions(
@@ -53,13 +81,34 @@ def split(self, indices):
             new._momentum = self._momentum[..., indices, :]
         return new
 
-    def join(self, other, indices):
+    def insert(self, other, indices):
         """Replace the PositionOption meta-data with other data."""
         self.initial_scan[..., indices, :] = other.initial_scan
         if self.use_adaptive_moment:
             self._momentum[..., indices, :] = other._momentum
         return self
 
+    def join(self, other, indices):
+        """Replace the PositionOption meta-data with other data."""
+        len_scan = self.initial_scan.shape[-2]
+        max_index = max(indices.max() + 1, len_scan)
+        new_initial_scan = np.empty(
+            (*self.initial_scan.shape[:-2], max_index, 2),
+            dtype=self.initial_scan.dtype,
+        )
+        new_initial_scan[..., :len_scan, :] = self.initial_scan
+        new_initial_scan[..., indices, :] = other.initial_scan
+        self.initial_scan = new_initial_scan
+        if self.use_adaptive_moment:
+            new_momentum = np.empty(
+                (*self.initial_scan.shape[:-2], max_index, 4),
+                dtype=self.initial_scan.dtype,
+            )
+            new_momentum[..., :len_scan, :] = self._momentum
+            new_momentum[..., indices, :] = other._momentum
+            self._momentum = new_momentum
+        return self
+
     def copy_to_device(self):
         """Copy to the current GPU memory."""
         self.initial_scan = cp.asarray(self.initial_scan)
diff --git a/src/tike/ptycho/ptycho.py b/src/tike/ptycho/ptycho.py
index 88367254..08dec727 100644
--- a/src/tike/ptycho/ptycho.py
+++ b/src/tike/ptycho/ptycho.py
@@ -55,7 +55,7 @@
     "Reconstruction",
 ]
 
-from itertools import product, chain
+from itertools import product
 import logging
 import time
 
@@ -68,7 +68,6 @@
 from tike.ptycho import solvers
 import tike.random
 
-from .object import get_padded_object
 from .position import (
     PositionOptions,
     check_allowed_positions,
@@ -173,17 +172,9 @@ def simulate(
 
 def reconstruct(
     data,
-    probe,
-    psi,
-    scan,
-    algorithm_options=solvers.RpieOptions(),
-    eigen_probe=None,
-    eigen_weights=None,
+    parameters,
     model='gaussian',
     num_gpu=1,
-    object_options=None,
-    position_options=None,
-    probe_options=None,
     use_mpi=False,
 ):
     """Solve the ptychography problem using the given `algorithm`.
@@ -194,32 +185,13 @@ def reconstruct(
         The intensity (square of the absolute value) of the propagated
         wavefront; i.e. what the detector records. FFT-shifted so the
         diffraction peak is at the corners.
-    probe : (1, 1, SHARED, WIDE, HIGH) complex64
-        The shared complex illumination function amongst all positions.
-    scan : (POSI, 2) float32
-        Coordinates of the minimum corner of the probe grid for each
-        measurement in the coordinate system of psi. Coordinate order
-        consistent with WIDE, HIGH order.
-    algorithm_options : :py:class:`tike.ptycho.solvers.IterativeOptions`
-        A class containing algorithm specific parameters
-    eigen_probe : (EIGEN, SHARED, WIDE, HIGH) complex64
-        The eigen probes for all positions.
-    eigen_weights : (POSI, EIGEN, SHARED) float32
-        The relative intensity of the eigen probes at each position.
+
     model : "gaussian", "poisson"
         The noise model to use for the cost function.
     num_gpu : int, tuple(int)
         The number of GPUs to use or a tuple of the device numbers of the GPUs
         to use. If the number of GPUs is less than the requested number, only
         workers for the available GPUs are allocated.
-    object_options : :py:class:`tike.ptycho.ObjectOptions`
-        A class containing settings related to object updates.
-    position_options : :py:class:`tike.ptycho.PositionOptions`
-        A class containing settings related to position correction.
-    probe_options : :py:class:`tike.ptycho.ProbeOptions`
-        A class containing settings related to probe updates.
-    psi : (WIDE, HIGH) complex64
-        The wavefront modulation coefficients of the object.
     use_mpi : bool
         Whether to use MPI or not.
 
@@ -237,20 +209,12 @@ def reconstruct(
     """
     with tike.ptycho.Reconstruction(
             data,
-            probe,
-            psi,
-            scan,
-            algorithm_options,
-            eigen_probe,
-            eigen_weights,
+            parameters,
             model,
             num_gpu,
-            object_options,
-            position_options,
-            probe_options,
             use_mpi,
     ) as context:
-        context.iterate(algorithm_options.num_iter)
+        context.iterate(parameters.algorithm_options.num_iter)
         result = context.get_result()
     return result
 
@@ -266,17 +230,9 @@ class Reconstruction():
     def __init__(
         self,
         data,
-        probe,
-        psi,
-        scan,
-        algorithm_options=solvers.RpieOptions(),
-        eigen_probe=None,
-        eigen_weights=None,
+        parameters,
         model='gaussian',
         num_gpu=1,
-        object_options=None,
-        position_options=None,
-        probe_options=None,
         use_mpi=False,
     ):
         if (np.any(np.asarray(data.shape) < 1) or data.ndim != 3
@@ -285,43 +241,28 @@ def __init__(
                 f"data shape {data.shape} is incorrect. "
                 "It should be (N, W, H), "
                 "where N >= 1 is the number of square diffraction patterns.")
-        if (scan.ndim != 2 or scan.shape[1] != 2
-                or np.any(np.asarray(scan.shape) < 1)):
-            raise ValueError(f"scan shape {scan.shape} is incorrect. "
-                             "It should be (N, 2) "
-                             "where N >= 1 is the number of scan positions.")
-        if data.shape[0] != scan.shape[0]:
+        if data.shape[0] != parameters.scan.shape[0]:
             raise ValueError(
-                f"data shape {data.shape} and scan shape {scan.shape} "
+                f"data shape {data.shape} and scan shape {parameters.scan.shape} "
                 "are incompatible. They should have the same leading dimension."
             )
-        if (probe.ndim != 5 or probe.shape[:2] != (1, 1)
-                or np.any(np.asarray(probe.shape) < 1)
-                or probe.shape[-2] != probe.shape[-1]):
-            raise ValueError(f"probe shape {probe.shape} is incorrect. "
-                             "It should be (1, 1, S, W, H) "
-                             "where S >=1 is the number of probes, and "
-                             "W, H >= 1 are the square probe grid dimensions.")
-        if np.any(np.asarray(probe.shape[-2:]) > np.asarray(data.shape[-2:])):
-            raise ValueError(f"probe shape {probe.shape} is incorrect."
-                             "The probe width/height must be "
-                             f"<= the data width/height {data.shape}.")
-        if (psi.ndim != 2 or
-                np.any(np.asarray(psi.shape) <= np.asarray(probe.shape[-2:]))):
+        if np.any(
+                np.asarray(parameters.probe.shape[-2:]) > np.asarray(
+                    data.shape[-2:])):
             raise ValueError(
-                f"psi shape {psi.shape} is incorrect. "
-                "It should be (W, H) where W, H > probe.shape[-2:].")
-        check_allowed_positions(scan, psi, probe.shape)
+                f"probe shape {parameters.probe.shape} is incorrect."
+                "The probe width/height must be "
+                f"<= the data width/height {data.shape}.")
         logger.info("{} for {:,d} - {:,d} by {:,d} frames for {:,d} "
                     "iterations.".format(
-                        algorithm_options.name,
+                        parameters.algorithm_options.name,
                         *data.shape[-3:],
-                        algorithm_options.num_iter,
+                        parameters.algorithm_options.num_iter,
                     ))
 
         if use_mpi is True:
             mpi = MPIComm
-            if psi is None:
+            if parameters.psi is None:
                 raise ValueError(
                     "When MPI is enabled, initial object guess cannot be None; "
                     "automatic psi initialization is not synchronized "
@@ -330,24 +271,15 @@ def __init__(
             mpi = None
 
         self.data = data
-        self.probe = probe
-        self.psi = psi
-        self.scan = scan
-        self.algorithm_options = algorithm_options
-        self.eigen_probe = eigen_probe
-        self.eigen_weights = eigen_weights
-
-        self.object_options = object_options
-        self.position_options = position_options
-        self.probe_options = probe_options
+        self.parameters = parameters
 
         self.device = cp.cuda.Device(
             num_gpu[0] if isinstance(num_gpu, tuple) else None)
         self.operator = Ptycho(
-            probe_shape=probe.shape[-1],
+            probe_shape=parameters.probe.shape[-1],
             detector_shape=data.shape[-1],
-            nz=psi.shape[-2],
-            n=psi.shape[-1],
+            nz=parameters.psi.shape[-2],
+            n=parameters.psi.shape[-1],
             model=model,
         )
         self.comm = Comm(num_gpu, mpi)
@@ -360,21 +292,12 @@ def __enter__(self):
         (
             self.batches,
             self.data,
-            self.result,
-            self.scan,
+            self.parameters,
         ) = _setup(
-            self.algorithm_options,
             self.comm,
             self.data,
-            self.eigen_probe,
-            self.eigen_weights,
-            self.object_options,
             self.operator,
-            self.probe,
-            self.psi,
-            self.position_options,
-            self.probe_options,
-            self.scan,
+            self.parameters,
         )
         return self
 
@@ -382,34 +305,25 @@ def iterate(self, num_iter):
         start = time.perf_counter()
         for i in range(num_iter):
 
-            logger.info(f"{self.algorithm_options.name} epoch "
-                        f"{len(self.algorithm_options.times):,d}")
+            logger.info(f"{self.parameters.algorithm_options.name} epoch "
+                        f"{len(self.parameters.algorithm_options.times):,d}")
 
-            self.result = _iterate(
-                self.algorithm_options,
+            self.parameters = _iterate(
                 self.batches,
                 self.comm,
                 self.data,
                 self.operator,
-                self.position_options,
-                self.probe_options,
-                self.result,
+                self.parameters,
             )
 
-            self.algorithm_options.times.append(time.perf_counter() - start)
+            self.parameters.algorithm_options.times.append(time.perf_counter() -
+                                                           start)
             start = time.perf_counter()
 
     def get_result(self):
         return _teardown(
-            self.algorithm_options,
             self.comm,
-            self.eigen_probe,
-            self.eigen_weights,
-            self.object_options,
-            self.position_options,
-            self.probe_options,
-            self.result,
-            self.scan,
+            self.parameters,
         )
 
     def __exit__(self, type, value, traceback):
@@ -417,21 +331,25 @@ def __exit__(self, type, value, traceback):
         self.operator.__exit__(type, value, traceback)
         self.device.__exit__(type, value, traceback)
 
-
     def get_psi(self):
         """Return the current object estimate as numpy arrays."""
-        return self.result['psi'][0].get()
+        return self.parameters.psi[0].get()
 
     def get_probe(self):
         """Return the current probe, eigen_probe, weights as numpy arrays."""
         reorder = np.argsort(np.concatenate(self.comm.order))
-        eigen_probe = self.result['eigen_probe'][0].get(
-        ) if self.eigen_probe is not None else None
-        eigen_weights = self.comm.pool.gather(
-            self.result['eigen_weights'],
-            axis=-3,
-        )[reorder].get() if self.eigen_weights is not None else None
-        probe = self.result['probe'][0].get()
+        if self.parameters.eigen_probe is None:
+            eigen_probe = None
+        else:
+            eigen_probe = self.parameters.eigen_probe[0].get()
+        if self.parameters.eigen_weights is None:
+            eigen_weights = None
+        else:
+            eigen_weights = self.comm.pool.gather(
+                self.parameters.eigen_weights,
+                axis=-3,
+            )[reorder].get()
+        probe = self.parameters.probe[0].get()
         return probe, eigen_probe, eigen_weights
 
     def peek(self):
@@ -440,193 +358,230 @@ def peek(self):
         probe, eigen_probe, eigen_weights = self.get_probe()
         return psi, probe, eigen_probe, eigen_weights
 
-    def _append_new_data(
-        comm,
+    def append_new_data(
+        self,
         new_data,
         new_scan,
-        data,
-        scan,
-        eigen_weights,
-        operator,
-        position_options,
     ):
         """"Append new diffraction patterns and scan positions to exisiting result."""
-        raise NotImplementedError()
+        # Assign positions and data to correct devices.
+        odd_pool = self.comm.pool.num_workers % 2
+        (
+            order,
+            new_scan,
+            new_data,
+        ) = split_by_scan_grid(
+            self.comm.pool,
+            (
+                self.comm.pool.num_workers
+                if odd_pool else self.comm.pool.num_workers // 2,
+                1 if odd_pool else 2,
+            ),
+            new_scan,
+            new_data,
+        )
+        # FIXME: Append makes a copy of each array!
+        self.data = self.comm.pool.map(
+            cp.append,
+            self.data,
+            new_data,
+            axis=0,
+        )
+        self.parameters.scan = self.comm.pool.map(
+            cp.append,
+            self.parameters.scan,
+            new_scan,
+            axis=0,
+        )
+        self.comm.order = self.comm.pool.map(
+            _order_join,
+            self.comm.order,
+            order,
+        )
+
+        # Rebatch on each device
+        self.batches = self.comm.pool.map(
+            getattr(tike.random,
+                    self.parameters.algorithm_options.batch_method),
+            self.parameters.scan,
+            num_cluster=self.parameters.algorithm_options.num_batch,
+        )
+
+        if self.parameters.eigen_weights is not None:
+            self.parameters.eigen_weights = self.comm.pool.map(
+                cp.pad,
+                self.parameters.eigen_weights,
+                pad_width=(
+                    (0, len(new_scan)),  # position
+                    (0, 0),  # eigen
+                    (0, 0),  # shared
+                ),
+                mode='mean',
+            )
 
-        # Assign positions and data to correct devices and batches.
+        if self.parameters.position_options is not None:
+            self.parameters.position_options = self.comm.pool.map(
+                PositionOptions.append,
+                self.parameters.position_options,
+                new_scan,
+            )
 
-        # increase the size of eigen_weights and position options
 
-        return eigen_weights, position_options, data, scan
+def _order_join(a, b):
+    return np.append(a, b + len(a))
 
 
 def _setup(
-    algorithm_options,
     comm,
     data,
-    eigen_probe,
-    eigen_weights,
-    object_options,
     operator,
-    probe,
-    psi,
-    position_options,
-    probe_options,
-    scan,
+    parameters,
 ):
     # Divide the inputs into regions
     odd_pool = comm.pool.num_workers % 2
     (
         comm.order,
-        scan,
+        parameters.scan,
         data,
-        eigen_weights,
+        parameters.eigen_weights,
     ) = split_by_scan_grid(
         comm.pool,
         (
             comm.pool.num_workers if odd_pool else comm.pool.num_workers // 2,
             1 if odd_pool else 2,
         ),
-        scan,
+        parameters.scan,
         data,
-        eigen_weights,
-    )
-    result = dict(
-        psi=comm.pool.bcast([psi.astype('complex64')]),
-        probe=comm.pool.bcast([probe.astype('complex64')]),
-        scan=scan,
-        probe_options=probe_options.copy_to_device()
-        if probe_options is not None else None,
-        object_options=object_options.copy_to_device()
-        if object_options is not None else None,
-        algorithm_options=algorithm_options,
+        parameters.eigen_weights,
     )
-    if eigen_probe is not None:
-        result.update({
-            'eigen_probe':
-                comm.pool.bcast([eigen_probe.astype('complex64')])
-                if eigen_probe is not None else None,
-        })
-    if eigen_weights is not None:
-        result.update({
-            'eigen_weights': eigen_weights,
-        })
-    if position_options:
+
+    parameters.psi = comm.pool.bcast([parameters.psi.astype('complex64')])
+
+    parameters.probe = comm.pool.bcast([parameters.probe.astype('complex64')])
+
+    if parameters.probe_options is not None:
+        parameters.probe_options = parameters.probe_options.copy_to_device()
+
+    if parameters.object_options is not None:
+        parameters.object_options = parameters.object_options.copy_to_device()
+
+    if parameters.eigen_probe is not None:
+        parameters.eigen_probe = comm.pool.bcast(
+            [parameters.eigen_probe.astype('complex64')])
+
+    if parameters.position_options is not None:
         # TODO: Consider combining put/split, get/join operations?
-        result['position_options'] = comm.pool.map(
+        parameters.position_options = comm.pool.map(
             PositionOptions.copy_to_device,
-            (position_options.split(x) for x in comm.order),
+            (parameters.position_options.split(x) for x in comm.order),
         )
 
     # Unique batch for each device
     batches = comm.pool.map(
-        getattr(tike.random, algorithm_options.batch_method),
-        scan,
-        num_cluster=algorithm_options.num_batch,
+        getattr(tike.random, parameters.algorithm_options.batch_method),
+        parameters.scan,
+        num_cluster=parameters.algorithm_options.num_batch,
     )
 
-    result['probe'] = _rescale_probe(
+    parameters.probe = _rescale_probe(
         operator,
         comm,
         data,
-        result['psi'],
-        result['scan'],
-        result['probe'],
-        num_batch=algorithm_options.num_batch,
+        parameters.psi,
+        parameters.scan,
+        parameters.probe,
+        num_batch=parameters.algorithm_options.num_batch,
     )
 
     return (
         batches,
         data,
-        result,
-        scan,
+        parameters,
     )
 
 
 def _iterate(
-    algorithm_options,
     batches,
     comm,
     data,
     operator,
-    position_options,
-    probe_options,
-    result,
+    parameters,
 ):
-    if probe_options is not None:
-        if probe_options.centered_intensity_constraint:
-            result['probe'] = comm.pool.map(
+    if parameters.probe_options is not None:
+        if parameters.probe_options.centered_intensity_constraint:
+            parameters.probe = comm.pool.map(
                 constrain_center_peak,
-                result['probe'],
+                parameters.probe,
             )
-        if probe_options.sparsity_constraint < 1:
-            result['probe'] = comm.pool.map(
+        if parameters.probe_options.sparsity_constraint < 1:
+            parameters.probe = comm.pool.map(
                 constrain_probe_sparsity,
-                result['probe'],
-                f=probe_options.sparsity_constraint,
+                parameters.probe,
+                f=parameters.probe_options.sparsity_constraint,
             )
 
-    result = getattr(solvers, algorithm_options.name)(
+    parameters = getattr(solvers, parameters.algorithm_options.name)(
         operator,
         comm,
         data=data,
         batches=batches,
-        **result,
+        parameters=parameters,
     )
 
-    if (position_options and position_options.use_position_regularization):
+    if (parameters.position_options
+            and parameters.position_options[0].use_position_regularization):
 
         # TODO: Regularize on all GPUs
-        result['scan'][0], _ = affine_position_regularization(
+        parameters.scan[0], _ = affine_position_regularization(
             operator,
-            result['psi'][0],
-            result['probe'][0],
-            position_options.initial_scan[0],
-            result['scan'][0],
+            parameters.psi[0],
+            parameters.probe[0],
+            parameters.position_options.initial_scan[0],
+            parameters.scan[0],
         )
 
-    return result
+    return parameters
 
 
 def _teardown(
-    algorithm_options,
     comm,
-    eigen_probe,
-    eigen_weights,
-    object_options,
-    position_options,
-    probe_options,
-    result,
-    scan,
+    parameters,
 ):
     reorder = np.argsort(np.concatenate(comm.order))
-    if position_options is not None:
+    if parameters.position_options is not None:
+        host_position_options = parameters.position_options[0].empty()
         for x, o in zip(
                 comm.pool.map(
                     PositionOptions.copy_to_host,
-                    result['position_options'],
+                    parameters.position_options,
                 ),
                 comm.order,
         ):
-            position_options.join(x, o)
-
-    return dict(
-        algorithm_options=algorithm_options,
-        eigen_probe=result['eigen_probe'][0].get()
-        if eigen_probe is not None else None,
-        eigen_weights=comm.pool.gather(
-            result['eigen_weights'],
+            host_position_options = host_position_options.join(x, o)
+        parameters.position_options = host_position_options
+
+    if parameters.eigen_probe is not None:
+        parameters.eigen_probe = parameters.eigen_probe[0].get()
+
+    if parameters.eigen_weights is not None:
+        parameters.eigen_weights = comm.pool.gather(
+            parameters.eigen_weights,
             axis=-3,
-        )[reorder].get() if eigen_weights is not None else None,
-        object_options=result['object_options'].copy_to_host()
-        if object_options is not None else None,
-        position_options=position_options,
-        probe=result['probe'][0].get(),
-        probe_options=result['probe_options'].copy_to_host()
-        if probe_options is not None else None,
-        psi=result['psi'][0].get(),
-        scan=comm.pool.gather_host(scan, axis=-2)[reorder],
-    )
+        )[reorder].get()
+
+    if parameters.object_options is not None:
+        parameters.object_options = parameters.object_options.copy_to_host()
+
+    parameters.probe = parameters.probe[0].get()
+
+    if parameters.probe_options is not None:
+        parameters.probe_options = parameters.probe_options.copy_to_host()
+
+    parameters.psi = parameters.psi[0].get()
+
+    parameters.scan = comm.pool.gather_host(parameters.scan, axis=-2)[reorder]
+
+    return parameters
 
 
 def _get_rescale(data, psi, scan, probe, num_batch, operator):
diff --git a/src/tike/ptycho/solvers/__init__.py b/src/tike/ptycho/solvers/__init__.py
index be814cb3..1b8ffa4a 100644
--- a/src/tike/ptycho/solvers/__init__.py
+++ b/src/tike/ptycho/solvers/__init__.py
@@ -13,6 +13,7 @@
     'CgradOptions',
     'lstsq_grad',
     'LstsqOptions',
+    'PtychoParameters',
     'rpie',
     'RpieOptions',
 ]
diff --git a/src/tike/ptycho/solvers/adam.py b/src/tike/ptycho/solvers/adam.py
index 062e9c5a..aa68f85f 100644
--- a/src/tike/ptycho/solvers/adam.py
+++ b/src/tike/ptycho/solvers/adam.py
@@ -14,13 +14,7 @@ def adam_grad(
     data,
     batches,
     *,
-    probe,
-    scan,
-    psi,
-    algorithm_options,
-    probe_options=None,
-    position_options=None,
-    object_options=None,
+    parameters,
 ):
     """Solve the ptychography problem using ADAptive Moment gradient descent.
 
@@ -68,6 +62,14 @@ def adam_grad(
     .. seealso:: :py:mod:`tike.ptycho`
 
     """
+    probe = parameters.probe
+    scan = parameters.scan
+    psi = parameters.psi
+    algorithm_options = parameters.algorithm_options
+    probe_options = parameters.probe_options
+    position_options = parameters.position_options
+    object_options = parameters.object_options
+
     for n in randomizer.permutation(len(batches[0])):
 
         bdata = comm.pool.map(get_batch, data, batches, n=n)
@@ -98,15 +100,14 @@ def adam_grad(
                             a=object_options.smoothness_constraint)
 
     algorithm_options.costs.append(cost)
-    return {
-        'probe': probe,
-        'psi': psi,
-        'scan': scan,
-        'algorithm_options': algorithm_options,
-        'probe_options': probe_options,
-        'object_options': object_options,
-        'position_options': position_options,
-    }
+    parameters.probe = probe
+    parameters.psi = psi
+    parameters.scan = scan
+    parameters.algorithm_options = algorithm_options
+    parameters.probe_options = probe_options
+    parameters.object_options = object_options
+    parameters.position_options = position_options
+    return parameters
 
 
 def _grad_all(data, psi, scan, probe, mode=None, op=None):
diff --git a/src/tike/ptycho/solvers/conjugate.py b/src/tike/ptycho/solvers/conjugate.py
index 9ff1eb07..c1c27e8e 100644
--- a/src/tike/ptycho/solvers/conjugate.py
+++ b/src/tike/ptycho/solvers/conjugate.py
@@ -14,13 +14,7 @@ def cgrad(
     data,
     batches,
     *,
-    probe,
-    scan,
-    psi,
-    algorithm_options,
-    probe_options=None,
-    position_options=None,
-    object_options=None,
+    parameters,
 ):
     """Solve the ptychography problem using conjugate gradient.
 
@@ -68,6 +62,13 @@ def cgrad(
     .. seealso:: :py:mod:`tike.ptycho`
 
     """
+    probe = parameters.probe
+    scan = parameters.scan
+    psi = parameters.psi
+    algorithm_options = parameters.algorithm_options
+    probe_options = parameters.probe_options
+    position_options = parameters.position_options
+    object_options = parameters.object_options
     for n in randomizer.permutation(len(batches[0])):
 
         bdata = comm.pool.map(get_batch, data, batches, n=n)
@@ -125,15 +126,14 @@ def cgrad(
             # TODO: Assign bscan into scan when positions are updated
 
     algorithm_options.costs.append(cost)
-    return {
-        'probe': probe,
-        'psi': psi,
-        'scan': scan,
-        'algorithm_options': algorithm_options,
-        'probe_options': probe_options,
-        'object_options': object_options,
-        'position_options': position_options,
-    }
+    parameters.probe = probe
+    parameters.psi = psi
+    parameters.scan = scan
+    parameters.algorithm_options = algorithm_options
+    parameters.probe_options = probe_options
+    parameters.object_options = object_options
+    parameters.position_options = position_options
+    return parameters
 
 
 def _update_probe(
diff --git a/src/tike/ptycho/solvers/lstsq.py b/src/tike/ptycho/solvers/lstsq.py
index 4f0ba362..83b7d2bf 100644
--- a/src/tike/ptycho/solvers/lstsq.py
+++ b/src/tike/ptycho/solvers/lstsq.py
@@ -19,15 +19,7 @@ def lstsq_grad(
     data,
     batches,
     *,
-    probe,
-    scan,
-    psi,
-    algorithm_options,
-    eigen_probe=None,
-    eigen_weights=None,
-    probe_options=None,
-    position_options=None,
-    object_options=None,
+    parameters,
 ):
     """Solve the ptychography problem using Odstrcil et al's approach.
 
@@ -84,6 +76,16 @@ def lstsq_grad(
     .. seealso:: :py:mod:`tike.ptycho`
 
     """
+    probe = parameters.probe
+    scan = parameters.scan
+    psi = parameters.psi
+    algorithm_options = parameters.algorithm_options
+    probe_options = parameters.probe_options
+    position_options = parameters.position_options
+    object_options = parameters.object_options
+    eigen_probe = parameters.eigen_probe
+    eigen_weights = parameters.eigen_weights
+
     if eigen_probe is None:
         beigen_probe = [None] * comm.pool.num_workers
     else:
@@ -174,7 +176,7 @@ def lstsq_grad(
 
         if position_options:
             comm.pool.map(
-                PositionOptions.join,
+                PositionOptions.insert,
                 position_options,
                 bposition_options,
                 [b[n] for b in batches],
@@ -217,17 +219,16 @@ def lstsq_grad(
         )))
 
     algorithm_options.costs.append(cost)
-    return {
-        'probe': probe,
-        'psi': psi,
-        'scan': scan,
-        'eigen_probe': eigen_probe,
-        'eigen_weights': eigen_weights,
-        'algorithm_options': algorithm_options,
-        'probe_options': probe_options,
-        'object_options': object_options,
-        'position_options': position_options,
-    }
+    parameters.probe = probe
+    parameters.psi = psi
+    parameters.scan = scan
+    parameters.algorithm_options = algorithm_options
+    parameters.probe_options = probe_options
+    parameters.object_options = object_options
+    parameters.position_options = position_options
+    parameters.eigen_weights = eigen_weights
+    parameters.eigen_probe = eigen_probe
+    return parameters
 
 
 def _psi_preconditioner(psi_update_denominator,
@@ -495,7 +496,6 @@ def _update_nearplane(
                     axis=-5,
                 )
 
-
             dprobe = weighted_step_probe[0] * common_grad_probe[0]
             if probe_options.use_adaptive_moment:
                 if probe_options.m is None:
diff --git a/src/tike/ptycho/solvers/options.py b/src/tike/ptycho/solvers/options.py
index 99d352c5..317885da 100644
--- a/src/tike/ptycho/solvers/options.py
+++ b/src/tike/ptycho/solvers/options.py
@@ -1,10 +1,16 @@
-from abc import ABC
+import abc
 import dataclasses
-from typing import List
+import typing
+
+import numpy as np
+
+from tike.ptycho.object import ObjectOptions
+from tike.ptycho.position import PositionOptions, check_allowed_positions
+from tike.ptycho.probe import ProbeOptions
 
 
 @dataclasses.dataclass
-class IterativeOptions(ABC):
+class IterativeOptions(abc.ABC):
     """A base class providing options for iterative algorithms.
 
     .. versionadded:: 0.20.0
@@ -20,13 +26,19 @@ class IterativeOptions(ABC):
     """The name of the batch selection method. Choose from the cluster_ methods
     in the tike.random module."""
 
-    costs: List[float] = dataclasses.field(init=False, default_factory=list)
+    costs: typing.List[float] = dataclasses.field(
+        init=False,
+        default_factory=list,
+    )
     """The objective function value at previous iterations."""
 
     num_iter: int = 1
     """The number of epochs to process before returning."""
 
-    times: List[float] = dataclasses.field(init=False, default_factory=list)
+    times: typing.List[float] = dataclasses.field(
+        init=False,
+        default_factory=list,
+    )
     """The per-iteration wall-time for each previous iteration."""
 
 
@@ -67,3 +79,72 @@ class RpieOptions(IterativeOptions):
 @dataclasses.dataclass
 class LstsqOptions(IterativeOptions):
     name: str = dataclasses.field(default='lstsq_grad', init=False)
+
+
+@dataclasses.dataclass
+class PtychoParameters():
+    """A class for storing the ptychography forward model parameters.
+
+    Replaces the dictionary?
+
+    Parameters
+    ----------
+    probe : (1, 1, SHARED, WIDE, HIGH) complex64
+        The shared complex illumination function amongst all positions.
+    scan : (POSI, 2) float32
+        Coordinates of the minimum corner of the probe grid for each
+        measurement in the coordinate system of psi. Coordinate order
+        consistent with WIDE, HIGH order.
+    eigen_probe : (EIGEN, SHARED, WIDE, HIGH) complex64
+        The eigen probes for all positions.
+    eigen_weights : (POSI, EIGEN, SHARED) float32
+        The relative intensity of the eigen probes at each position.
+    object_options : :py:class:`tike.ptycho.ObjectOptions`
+        A class containing settings related to object updates.
+    position_options : :py:class:`tike.ptycho.PositionOptions`
+        A class containing settings related to position correction.
+    probe_options : :py:class:`tike.ptycho.ProbeOptions`
+        A class containing settings related to probe updates.
+    psi : (WIDE, HIGH) complex64
+        The wavefront modulation coefficients of the object.
+    algorithm_options : :py:class:`tike.ptycho.solvers.IterativeOptions`
+        A class containing algorithm specific parameters
+
+    .. versionadded:: 0.22.0
+    """
+    probe: np.array
+    psi: np.array
+    scan: np.array
+    eigen_probe: np.array = None
+    eigen_weights: np.array = None
+    algorithm_options: IterativeOptions = dataclasses.field(
+        default_factory=RpieOptions,)
+    probe_options: ProbeOptions = None
+    object_options: ObjectOptions = None
+    position_options: PositionOptions = None
+
+    def __post_init__(self):
+        if (self.scan.ndim != 2 or self.scan.shape[1] != 2
+                or np.any(np.asarray(self.scan.shape) < 1)):
+            raise ValueError(f"scan shape {self.scan.shape} is incorrect. "
+                             "It should be (N, 2) "
+                             "where N >= 1 is the number of scan positions.")
+
+        if (self.probe.ndim != 5 or self.probe.shape[:2] != (1, 1)
+                or np.any(np.asarray(self.probe.shape) < 1)
+                or self.probe.shape[-2] != self.probe.shape[-1]):
+            raise ValueError(f"probe shape {self.probe.shape} is incorrect. "
+                             "It should be (1, 1, S, W, H) "
+                             "where S >=1 is the number of probes, and "
+                             "W, H >= 1 are the square probe grid dimensions.")
+        if (self.psi.ndim != 2 or np.any(
+                np.asarray(self.psi.shape) <= np.asarray(self.probe.shape[-2:]))
+           ):
+            raise ValueError(
+                f"psi shape {self.psi.shape} is incorrect. "
+                "It should be (W, H) where W, H > probe.shape[-2:].")
+        check_allowed_positions(
+            self.scan,
+            self.psi,
+            self.probe.shape,
+        )
diff --git a/src/tike/ptycho/solvers/rpie.py b/src/tike/ptycho/solvers/rpie.py
index 28d8d727..0ba701a7 100644
--- a/src/tike/ptycho/solvers/rpie.py
+++ b/src/tike/ptycho/solvers/rpie.py
@@ -18,13 +18,7 @@ def rpie(
     data,
     batches,
     *,
-    probe,
-    scan,
-    psi,
-    algorithm_options,
-    probe_options=None,
-    position_options=None,
-    object_options=None,
+    parameters,
 ):
     """Solve the ptychography problem using regularized ptychographical engine.
 
@@ -79,6 +73,14 @@ def rpie(
     .. seealso:: :py:mod:`tike.ptycho`
 
     """
+    probe = parameters.probe
+    scan = parameters.scan
+    psi = parameters.psi
+    algorithm_options = parameters.algorithm_options
+    probe_options = parameters.probe_options
+    position_options = parameters.position_options
+    object_options = parameters.object_options
+
     for n in tike.opt.randomizer.permutation(len(batches[0])):
 
         bdata = comm.pool.map(tike.opt.get_batch, data, batches, n=n)
@@ -138,7 +140,7 @@ def rpie(
 
         if position_options is not None:
             comm.pool.map(
-                tike.ptycho.position.PositionOptions.join,
+                tike.ptycho.position.PositionOptions.insert,
                 position_options,
                 bposition_options,
                 [b[n] for b in batches],
@@ -165,15 +167,14 @@ def rpie(
                             a=object_options.smoothness_constraint)
 
     algorithm_options.costs.append(cost)
-    return {
-        'probe': probe,
-        'psi': psi,
-        'scan': scan,
-        'algorithm_options': algorithm_options,
-        'probe_options': probe_options,
-        'object_options': object_options,
-        'position_options': position_options,
-    }
+    parameters.probe = probe
+    parameters.psi = psi
+    parameters.scan = scan
+    parameters.algorithm_options = algorithm_options
+    parameters.probe_options = probe_options
+    parameters.object_options = object_options
+    parameters.position_options = position_options
+    return parameters
 
 
 def _update_wavefront(data, varying_probe, scan, psi, op=None):
@@ -277,9 +278,7 @@ def _update_nearplane(
             degree=probe_options.probe_support_degree,
         )
 
-        probe[0] += step_length * (
-            probe_update_numerator - b * probe[0]
-            ) / (
+        probe[0] += step_length * (probe_update_numerator - b * probe[0]) / (
             (1 - alpha) * probe_update_denominator +
             alpha * probe_update_denominator.max(
                 axis=(-2, -1),
diff --git a/tests/operators/test_lamino.py b/tests/operators/test_lamino.py
index 6352f38e..7651a1f5 100644
--- a/tests/operators/test_lamino.py
+++ b/tests/operators/test_lamino.py
@@ -58,9 +58,11 @@ def setUp(self, n=16, ntheta=8, tilt=np.pi / 3, eps=1e-1):
                                  dtype='complex64')
         self.d_name = 'data'
         self.kwargs = {
-            'theta': self.xp.linspace(0, 2 * np.pi, ntheta).astype('float32'),
-            'grid': self.xp.asarray(self.operator._make_grid().reshape(n**3, 3),
-                                    dtype='int16'),
+            'theta':
+                self.xp.linspace(0, 2 * np.pi, ntheta).astype('float32'),
+            'grid':
+                self.xp.asarray(self.operator._make_grid().reshape(n**3, 3),
+                                dtype='int16'),
         }
         print(self.operator)
 
diff --git a/tests/operators/util.py b/tests/operators/util.py
index 10e2ea70..c27afaf3 100644
--- a/tests/operators/util.py
+++ b/tests/operators/util.py
@@ -61,10 +61,8 @@ def test_scaled(self):
         b = inner_complex(self.m, self.m)
         print()
         # NOTE: Inner product with self is real-only magnitude of self
-        print('<F*Fm, F*Fm> = {:.5g}{:+.5g}j'.format(a.real.item(),
-                                                     0))
-        print('<   m,    m> = {:.5g}{:+.5g}j'.format(b.real.item(),
-                                                     0))
+        print('<F*Fm, F*Fm> = {:.5g}{:+.5g}j'.format(a.real.item(), 0))
+        print('<   m,    m> = {:.5g}{:+.5g}j'.format(b.real.item(), 0))
         self.xp.testing.assert_allclose(a.real, b.real, rtol=1e-5, atol=0)
 
     def test_fwd_time(self):
diff --git a/tests/ptycho/test_position.py b/tests/ptycho/test_position.py
new file mode 100644
index 00000000..95e1f302
--- /dev/null
+++ b/tests/ptycho/test_position.py
@@ -0,0 +1,35 @@
+import optparse
+import numpy as np
+import tike.ptycho
+from tike.ptycho.position import PositionOptions
+
+
+def test_position_join(N=245, num_batch=11):
+
+    scan = np.random.rand(N, 2)
+    assert scan.shape == (N, 2)
+    indices = np.arange(N)
+    assert np.amin(indices) == 0
+    assert np.amax(indices) == N - 1
+    np.random.shuffle(indices)
+    batches = np.array_split(indices, num_batch)
+
+    opts = tike.ptycho.PositionOptions(scan, use_adaptive_moment=True,)
+
+    optsb = [opts.split(b) for b in batches]
+
+    # Copies non-array params into new object
+    new_opts = optsb[0].split([])
+
+    for b, i in zip(optsb, batches):
+        new_opts = new_opts.join(b, i)
+
+    np.testing.assert_array_equal(
+        new_opts.initial_scan,
+        opts.initial_scan,
+    )
+
+    np.testing.assert_array_equal(
+        new_opts._momentum,
+        opts._momentum,
+    )
diff --git a/tests/ptycho/test_ptycho.py b/tests/ptycho/test_ptycho.py
index 1fea19e7..d3b05908 100644
--- a/tests/ptycho/test_ptycho.py
+++ b/tests/ptycho/test_ptycho.py
@@ -47,6 +47,7 @@
 # #########################################################################
 
 import bz2
+from inspect import Parameter
 import lzma
 import os
 import pickle
@@ -218,48 +219,51 @@ def test_consistent_simulate(self):
 
 class TemplatePtychoRecon():
 
+    def init_params(self):
+        return tike.ptycho.PtychoParameters(
+            psi=np.ones((600, 600), dtype=np.complex64),
+            probe=self.probe,
+            scan=self.scan,
+        )
+
     def template_consistent_algorithm(self, *, params={}):
         """Check ptycho.solver.algorithm for consistency."""
 
-        result = {
-            'psi': np.ones((600, 600), dtype=np.complex64),
-            'probe': self.probe,
-        }
-
         if params.get('use_mpi') is True:
             with MPIComm() as IO:
-                result['probe'] = IO.Bcast(result['probe'])
-                weights = params.get('eigen_weights')
-                if weights is not None:
+                params['parameters'].probe = IO.Bcast(
+                    params['parameters'].probe)
+                if params['parameters'].eigen_weights is not None:
                     (
-                        self.scan,
+                        params['parameters'].scan,
                         self.data,
-                        params['eigen_weights'],
+                        params['parameters'].eigen_weights,
                     ) = IO.MPIio_ptycho(
-                        self.scan,
+                        params['parameters'].scan,
                         self.data,
-                        weights,
+                        params['parameters'].eigen_weights,
                     )
                 else:
-                    self.scan, self.data = IO.MPIio_ptycho(self.scan, self.data)
-
-        result['scan'] = self.scan
+                    params['parameters'].scan, self.data = IO.MPIio_ptycho(
+                        params['parameters'].scan, self.data)
 
         # Call twice to check that reconstruction continuation is correct
         for _ in range(2):
-            params.update(result)
-            result = tike.ptycho.reconstruct(
+            params['parameters'] = tike.ptycho.reconstruct(
                 **params,
                 data=self.data,
             )
         print()
-        print('\n'.join(f'{c:1.3e}' for c in result['algorithm_options'].costs))
-        return result
+        print('\n'.join(
+            f'{c:1.3e}' for c in params['parameters'].algorithm_options.costs))
+        return params['parameters']
 
 
 class TestPtychoRecon(TemplatePtychoRecon, unittest.TestCase):
     """Test various ptychography reconstruction methods for consistency."""
 
+    post_name = ""
+
     def setUp(self, filename='data/siemens-star-small.npz.bz2'):
         """Load a dataset for reconstruction."""
         dataset_file = os.path.join(testdir, filename)
@@ -275,130 +279,129 @@ def setUp(self, filename='data/siemens-star-small.npz.bz2'):
 
     def test_consistent_adam_grad(self):
         """Check ptycho.solver.adam_grad for consistency."""
+        params = self.init_params()
+        params.algorithm_options = tike.ptycho.AdamOptions(
+            num_batch=5,
+            num_iter=16,
+        )
+        params.probe_options = ProbeOptions()
+        params.object_options = ObjectOptions()
         _save_ptycho_result(
             self.template_consistent_algorithm(params={
-                'algorithm_options':
-                    tike.ptycho.AdamOptions(
-                        num_batch=5,
-                        num_iter=16,
-                    ),
-                'num_gpu':
-                    2,
-                'probe_options':
-                    ProbeOptions(),
-                'object_options':
-                    ObjectOptions(),
-                'use_mpi':
-                    _mpi_size > 1,
-            },), f"{'mpi-' if _mpi_size > 1 else ''}adam_grad")
+                'parameters': params,
+                'num_gpu': 2,
+                'use_mpi': _mpi_size > 1,
+            },), f"{'mpi-' if _mpi_size > 1 else ''}adam_grad{self.post_name}")
 
     def test_consistent_cgrad(self):
         """Check ptycho.solver.cgrad for consistency."""
+        params = self.init_params()
+        params.algorithm_options = tike.ptycho.CgradOptions(
+            num_batch=5,
+            num_iter=16,
+        )
+        params.probe_options = ProbeOptions()
+        params.object_options = ObjectOptions()
         _save_ptycho_result(
             self.template_consistent_algorithm(params={
-                'algorithm_options':
-                    tike.ptycho.CgradOptions(
-                        num_batch=5,
-                        num_iter=16,
-                    ),
-                'num_gpu':
-                    2,
-                'probe_options':
-                    ProbeOptions(),
-                'object_options':
-                    ObjectOptions(),
-                'use_mpi':
-                    _mpi_size > 1,
-            },), f"{'mpi-' if _mpi_size > 1 else ''}cgrad")
+                'parameters': params,
+                'num_gpu': 2,
+                'use_mpi': _mpi_size > 1,
+            },), f"{'mpi-' if _mpi_size > 1 else ''}cgrad{self.post_name}")
 
     def test_consistent_lstsq_grad(self):
         """Check ptycho.solver.lstsq_grad for consistency."""
+        params = self.init_params()
+        params.algorithm_options = tike.ptycho.LstsqOptions(
+            num_batch=5,
+            num_iter=16,
+        )
+        params.probe_options = ProbeOptions(use_adaptive_moment=True,)
+        params.object_options = ObjectOptions(use_adaptive_moment=True,)
         _save_ptycho_result(
             self.template_consistent_algorithm(params={
-                'algorithm_options':
-                    tike.ptycho.LstsqOptions(
-                        num_batch=5,
-                        num_iter=16,
-                    ),
-                'num_gpu':
-                    2,
-                'probe_options':
-                    ProbeOptions(
-                        orthogonality_constraint=True,
-                        use_adaptive_moment=True,
-                    ),
-                'object_options':
-                    ObjectOptions(
-                        use_adaptive_moment=True,
-                    ),
-                'use_mpi':
-                    _mpi_size > 1,
-            },), f"{'mpi-' if _mpi_size > 1 else ''}lstsq_grad")
+                'parameters': params,
+                'num_gpu': 2,
+                'use_mpi': _mpi_size > 1,
+            },), f"{'mpi-' if _mpi_size > 1 else ''}lstsq_grad{self.post_name}")
 
     def test_consistent_lstsq_grad_variable_probe(self):
         """Check ptycho.solver.lstsq_grad for consistency."""
-
-        probes_with_modes = min(3, self.probe.shape[-3])
-        eigen_probe, weights = tike.ptycho.probe.init_varying_probe(
-            self.scan,
-            self.probe,
+        params = self.init_params()
+        probes_with_modes = min(3, params.probe.shape[-3])
+        params.eigen_probe, params.eigen_weights = tike.ptycho.probe.init_varying_probe(
+            params.scan,
+            params.probe,
             num_eigen_probes=3,
             probes_with_modes=probes_with_modes,
         )
+        params.algorithm_options = tike.ptycho.LstsqOptions(
+            num_batch=5,
+            num_iter=16,
+        )
+        params.probe_options = ProbeOptions(use_adaptive_moment=True,)
+        params.object_options = ObjectOptions(use_adaptive_moment=True,)
         result = self.template_consistent_algorithm(params={
-            'algorithm_options':
-                tike.ptycho.LstsqOptions(
-                    num_batch=5,
-                    num_iter=16,
-                ),
-            'num_gpu':
-                2,
-            'probe_options':
-                ProbeOptions(),
-            'object_options':
-                ObjectOptions(
-                    use_adaptive_moment=8,
-                ),
-            'use_mpi':
-                _mpi_size > 1,
-            'eigen_probe':
-                eigen_probe,
-            'eigen_weights':
-                weights,
+            'parameters': params,
+            'num_gpu': 2,
+            'use_mpi': _mpi_size > 1,
         },)
         _save_ptycho_result(
             result,
-            f"{'mpi-' if _mpi_size > 1 else ''}lstsq_grad-variable-probe",
+            f"{'mpi-' if _mpi_size > 1 else ''}lstsq_grad-variable-probe{self.post_name}",
         )
-        assert np.all(
-            result['eigen_weights'][..., 1:, probes_with_modes:] == 0), (
-                "These weights should be unused/untouched "
-                "and should have been initialized to zero.")
+        assert np.all(result.eigen_weights[..., 1:, probes_with_modes:] == 0), (
+            "These weights should be unused/untouched "
+            "and should have been initialized to zero.")
 
     def test_consistent_rpie(self):
         """Check ptycho.solver.rpie for consistency."""
+        params = self.init_params()
+        params.algorithm_options = tike.ptycho.RpieOptions(
+            num_batch=5,
+            num_iter=16,
+        )
+        params.probe_options = ProbeOptions()
+        params.object_options = ObjectOptions()
         _save_ptycho_result(
             self.template_consistent_algorithm(params={
-                'algorithm_options':
-                    tike.ptycho.RpieOptions(
-                        num_batch=5,
-                        num_iter=16,
-                    ),
-                'num_gpu':
-                    2,
-                'probe_options':
-                    ProbeOptions(),
-                'object_options':
-                    ObjectOptions(),
-                'use_mpi':
-                    _mpi_size > 1,
-            },), f"{'mpi-' if _mpi_size > 1 else ''}rpie")
-
-    def test_invalid_algorithm_name(self):
-        """Check that wrong names are handled gracefully."""
-        with self.assertRaises(AttributeError):
-            self.template_consistent_algorithm(params=dict(
-                algorithm_options=tike.ptycho.solvers.EpaeOptions()))
+                'parameters': params,
+                'num_gpu': 2,
+                'use_mpi': _mpi_size > 1,
+            },), f"{'mpi-' if _mpi_size > 1 else ''}rpie{self.post_name}")
+
+
+class TestPtychoOnline(TestPtychoRecon, unittest.TestCase):
+    """Test ptychography reconstruction when data is streaming."""
+
+    post_name = "-online"
+
+    def setUp(self, chunks=16) -> None:
+        TestPtychoRecon.setUp(self)
+        data = np.array_split(self.data, chunks, axis=0)
+        scan = np.array_split(self.scan, chunks, axis=0)
+        assert len(data) == chunks
+        assert len(scan) == chunks
+
+        self.data = data[0]
+        self.scan = scan[0]
+        self.data_more = data[1:]
+        self.scan_more = scan[1:]
+
+    def template_consistent_algorithm(self, *, params={}):
+
+        with tike.ptycho.Reconstruction(**params, data=self.data) as context:
+            context.iterate(2)
+            for d, s in zip(self.data_more, self.scan_more):
+                context.append_new_data(
+                    new_data=d,
+                    new_scan=s,
+                )
+                context.iterate(2)
+            result = context.get_result()
+        print()
+        print('\n'.join(f'{c:1.3e}' for c in result.algorithm_options.costs))
+        return result
 
 
 class TestPtychoPosition(TemplatePtychoRecon, unittest.TestCase):
@@ -431,8 +434,8 @@ def _save_position_error_variance(self, result, algorithm):
             plt.title(algorithm)
             tike.view.plot_positions_convergence(
                 self.scan_truth,
-                result['position_options'].initial_scan,
-                result['scan'],
+                result.position_options.initial_scan,
+                result.scan,
             )
             plt.savefig(os.path.join(fname, 'position-error.svg'))
             plt.close()
@@ -442,45 +445,38 @@ def _save_position_error_variance(self, result, algorithm):
     def test_consistent_rpie_ref(self):
         """Check ptycho.solver.rpie position correction."""
         algorithm = f"{'mpi-' if _mpi_size > 1 else ''}rpie-position-ref"
+        params = self.init_params()
+        params.algorithm_options = tike.ptycho.RpieOptions(
+            num_batch=5,
+            num_iter=16,
+        )
+        params.probe_options = ProbeOptions()
+        params.object_options = ObjectOptions()
         result = self.template_consistent_algorithm(params={
-            'algorithm_options':
-                tike.ptycho.RpieOptions(
-                    num_batch=5,
-                    num_iter=16,
-                ),
-            'num_gpu':
-                2,
-            'probe_options':
-                ProbeOptions(),
-            'object_options':
-                ObjectOptions(),
-            'use_mpi':
-                _mpi_size > 1,
+            'parameters': params,
+            'num_gpu': 2,
+            'use_mpi': _mpi_size > 1,
         },)
         _save_ptycho_result(result, algorithm)
 
     def test_consistent_rpie(self):
         """Check ptycho.solver.rpie position correction."""
         algorithm = f"{'mpi-' if _mpi_size > 1 else ''}rpie-position"
+        params = self.init_params()
+        params.algorithm_options = tike.ptycho.RpieOptions(
+            num_batch=5,
+            num_iter=16,
+        )
+        params.position_options = PositionOptions(
+            self.scan,
+            use_adaptive_moment=True,
+        )
+        params.probe_options = ProbeOptions()
+        params.object_options = ObjectOptions()
         result = self.template_consistent_algorithm(params={
-            'algorithm_options':
-                tike.ptycho.RpieOptions(
-                    num_batch=5,
-                    num_iter=16,
-                ),
-            'num_gpu':
-                2,
-            'position_options':
-                PositionOptions(
-                    self.scan,
-                    use_adaptive_moment=True,
-                ),
-            'probe_options':
-                ProbeOptions(),
-            'object_options':
-                ObjectOptions(),
-            'use_mpi':
-                _mpi_size > 1,
+            'parameters': params,
+            'num_gpu': 2,
+            'use_mpi': _mpi_size > 1,
         },)
         _save_ptycho_result(result, algorithm)
         self._save_position_error_variance(result, algorithm)
@@ -488,25 +484,21 @@ def test_consistent_rpie(self):
     def test_consistent_lstsq_grad(self):
         """Check ptycho.solver.lstsq_grad for consistency."""
         algorithm = f"{'mpi-' if _mpi_size > 1 else ''}lstsq_grad-position"
+        params = self.init_params()
+        params.algorithm_options = tike.ptycho.LstsqOptions(
+            num_batch=5,
+            num_iter=16,
+        )
+        params.position_options = PositionOptions(
+            self.scan,
+            use_adaptive_moment=True,
+        )
+        params.probe_options = ProbeOptions()
+        params.object_options = ObjectOptions()
         result = self.template_consistent_algorithm(params={
-            'algorithm_options':
-                tike.ptycho.LstsqOptions(
-                    num_batch=5,
-                    num_iter=16,
-                ),
-            'num_gpu':
-                2,
-            'position_options':
-                PositionOptions(
-                    self.scan,
-                    use_adaptive_moment=True,
-                ),
-            'probe_options':
-                ProbeOptions(),
-            'object_options':
-                ObjectOptions(),
-            'use_mpi':
-                _mpi_size > 1,
+            'parameters': params,
+            'num_gpu': 2,
+            'use_mpi': _mpi_size > 1,
         },)
         _save_ptycho_result(result, algorithm)
         self._save_position_error_variance(result, algorithm)
@@ -569,8 +561,8 @@ def _save_ptycho_result(result, algorithm):
         os.makedirs(fname, exist_ok=True)
 
         fig, ax1, ax2, = tike.view.plot_cost_convergence(
-            result['algorithm_options'].costs,
-            result['algorithm_options'].times,
+            result.algorithm_options.costs,
+            result.algorithm_options.times,
         )
         ax2.set_xlim(0, 20)
         fig.suptitle(algorithm)
@@ -579,7 +571,7 @@ def _save_ptycho_result(result, algorithm):
         plt.savefig(os.path.join(fname, 'convergence.svg'))
         plt.imsave(
             f'{fname}/{0}-phase.png',
-            np.angle(result['psi']).astype('float32'),
+            np.angle(result.psi).astype('float32'),
             # The output of np.angle is locked to (-pi, pi]
             cmap=plt.cm.twilight,
             vmin=-np.pi,
@@ -587,13 +579,13 @@ def _save_ptycho_result(result, algorithm):
         )
         plt.imsave(
             f'{fname}/{0}-ampli.png',
-            np.abs(result['psi']).astype('float32'),
+            np.abs(result.psi).astype('float32'),
         )
-        _save_probe(fname, result['probe'])
-        if result['eigen_weights'] is not None:
-            _save_eigen_weights(fname, result['eigen_weights'])
-            if result['eigen_weights'].shape[-2] > 1:
-                _save_eigen_probe(fname, result['eigen_probe'])
+        _save_probe(fname, result.probe)
+        if result.eigen_weights is not None:
+            _save_eigen_weights(fname, result.eigen_weights)
+            if result.eigen_weights.shape[-2] > 1:
+                _save_eigen_probe(fname, result.eigen_probe)
     except ImportError:
         pass
 
@@ -606,5 +598,6 @@ def _save_eigen_weights(fname, weights):
     plt.tight_layout()
     plt.savefig(f'{fname}/weights.svg')
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/test_lamino.py b/tests/test_lamino.py
index 2bba837c..6c761b79 100644
--- a/tests/test_lamino.py
+++ b/tests/test_lamino.py
@@ -264,9 +264,9 @@ def setUp(self, n=2, b=2):
 
     def _radon_equal(self, module, eps):
         for tilt, axis, theta in zip(
-            [0, np.pi / 2,  np.pi / 2],
-            [0,         1,          2],
-            [0,         0, -np.pi / 2],
+            [0, np.pi / 2, np.pi / 2],
+            [0, 1, 2],
+            [0, 0, -np.pi / 2],
         ):
             projection = module.simulate(
                 obj=self.original,
@@ -287,9 +287,9 @@ def _radon_equal(self, module, eps):
     def _radon_equal_reverse(self, module, eps):
         for tilt, axis, theta, flip in zip(
             [np.pi, -np.pi / 2, np.pi / 2],
-            [0,              1,         2],
-            [0,              0, np.pi / 2],
-            [0,              0,         1],
+            [0, 1, 2],
+            [0, 0, np.pi / 2],
+            [0, 0, 1],
         ):
             projection = module.simulate(
                 obj=self.original,

From f324d2a0ed7eb00392524332b079c9dd544532a9 Mon Sep 17 00:00:00 2001
From: Daniel Ching <carterbox@users.noreply.github.com>
Date: Fri, 13 May 2022 18:54:04 -0500
Subject: [PATCH 06/15] DOC: Update docs to fix errors

---
 docs/source/api/ptycho.solvers.rst | 5 -----
 docs/source/conf.py                | 2 +-
 src/tike/ptycho/solvers/options.py | 2 +-
 3 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/docs/source/api/ptycho.solvers.rst b/docs/source/api/ptycho.solvers.rst
index 2c0392c3..9faac4bf 100644
--- a/docs/source/api/ptycho.solvers.rst
+++ b/docs/source/api/ptycho.solvers.rst
@@ -9,8 +9,3 @@ solvers
    .. autosummary::
       :nosignatures:
       :recursive:
-
-      adam_grad
-      cgrad
-      lstsq_grad
-      rpie
diff --git a/docs/source/conf.py b/docs/source/conf.py
index d041edaa..4bec5a18 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -52,7 +52,7 @@
 
 # bibtex setting
 bibtex_bibfiles = [
-    'zrefs.bib',
+    'bibtex/zrefs.bib',
 ]
 
 # extlinks settings
diff --git a/src/tike/ptycho/solvers/options.py b/src/tike/ptycho/solvers/options.py
index 317885da..fcdf8fd3 100644
--- a/src/tike/ptycho/solvers/options.py
+++ b/src/tike/ptycho/solvers/options.py
@@ -23,7 +23,7 @@ class IterativeOptions(abc.ABC):
     processed sequentially."""
 
     batch_method: str = 'cluster_wobbly_center'
-    """The name of the batch selection method. Choose from the cluster_ methods
+    """The name of the batch selection method. Choose from the cluster methods
     in the tike.random module."""
 
     costs: typing.List[float] = dataclasses.field(

From 9ab8b0c07efb2cb9ff524112b5769c316a3c8891 Mon Sep 17 00:00:00 2001
From: Daniel Ching <carterbox@users.noreply.github.com>
Date: Fri, 13 May 2022 18:54:23 -0500
Subject: [PATCH 07/15] REF: Remove one level of functions in internal ptycho
 API

---
 src/tike/ptycho/ptycho.py | 300 +++++++++++++++++---------------------
 1 file changed, 131 insertions(+), 169 deletions(-)

diff --git a/src/tike/ptycho/ptycho.py b/src/tike/ptycho/ptycho.py
index 08dec727..9aaac3b8 100644
--- a/src/tike/ptycho/ptycho.py
+++ b/src/tike/ptycho/ptycho.py
@@ -185,7 +185,6 @@ def reconstruct(
         The intensity (square of the absolute value) of the propagated
         wavefront; i.e. what the detector records. FFT-shifted so the
         diffraction peak is at the corners.
-
     model : "gaussian", "poisson"
         The noise model to use for the cost function.
     num_gpu : int, tuple(int)
@@ -272,7 +271,6 @@ def __init__(
 
         self.data = data
         self.parameters = parameters
-
         self.device = cp.cuda.Device(
             num_gpu[0] if isinstance(num_gpu, tuple) else None)
         self.operator = Ptycho(
@@ -289,16 +287,69 @@ def __enter__(self):
         self.operator.__enter__()
         self.comm.__enter__()
 
+        # Divide the inputs into regions
+        odd_pool = self.comm.pool.num_workers % 2
         (
-            self.batches,
+            self.comm.order,
+            self.parameters.scan,
             self.data,
-            self.parameters,
-        ) = _setup(
-            self.comm,
+            self.parameters.eigen_weights,
+        ) = split_by_scan_grid(
+            self.comm.pool,
+            (
+                self.comm.pool.num_workers
+                if odd_pool else self.comm.pool.num_workers // 2,
+                1 if odd_pool else 2,
+            ),
+            self.parameters.scan,
             self.data,
+            self.parameters.eigen_weights,
+        )
+
+        self.parameters.psi = self.comm.pool.bcast(
+            [self.parameters.psi.astype('complex64')])
+
+        self.parameters.probe = self.comm.pool.bcast(
+            [self.parameters.probe.astype('complex64')])
+
+        if self.parameters.probe_options is not None:
+            self.parameters.probe_options = self.parameters.probe_options.copy_to_device(
+            )
+
+        if self.parameters.object_options is not None:
+            self.parameters.object_options = self.parameters.object_options.copy_to_device(
+            )
+
+        if self.parameters.eigen_probe is not None:
+            self.parameters.eigen_probe = self.comm.pool.bcast(
+                [self.parameters.eigen_probe.astype('complex64')])
+
+        if self.parameters.position_options is not None:
+            # TODO: Consider combining put/split, get/join operations?
+            self.parameters.position_options = self.comm.pool.map(
+                PositionOptions.copy_to_device,
+                (self.parameters.position_options.split(x)
+                 for x in self.comm.order),
+            )
+
+        # Unique batch for each device
+        self.batches = self.comm.pool.map(
+            getattr(tike.random,
+                    self.parameters.algorithm_options.batch_method),
+            self.parameters.scan,
+            num_cluster=self.parameters.algorithm_options.num_batch,
+        )
+
+        self.parameters.probe = _rescale_probe(
             self.operator,
-            self.parameters,
+            self.comm,
+            self.data,
+            self.parameters.psi,
+            self.parameters.scan,
+            self.parameters.probe,
+            num_batch=self.parameters.algorithm_options.num_batch,
         )
+
         return self
 
     def iterate(self, num_iter):
@@ -308,23 +359,87 @@ def iterate(self, num_iter):
             logger.info(f"{self.parameters.algorithm_options.name} epoch "
                         f"{len(self.parameters.algorithm_options.times):,d}")
 
-            self.parameters = _iterate(
-                self.batches,
-                self.comm,
-                self.data,
+            if self.parameters.probe_options is not None:
+                if self.parameters.probe_options.centered_intensity_constraint:
+                    self.parameters.probe = self.comm.pool.map(
+                        constrain_center_peak,
+                        self.parameters.probe,
+                    )
+                if self.parameters.probe_options.sparsity_constraint < 1:
+                    self.parameters.probe = self.comm.pool.map(
+                        constrain_probe_sparsity,
+                        self.parameters.probe,
+                        f=self.parameters.probe_options.sparsity_constraint,
+                    )
+
+            self.parameters = getattr(
+                solvers,
+                self.parameters.algorithm_options.name,
+            )(
                 self.operator,
-                self.parameters,
+                self.comm,
+                data=self.data,
+                batches=self.batches,
+                parameters=self.parameters,
             )
 
+            if (self.parameters.position_options and self.parameters
+                    .position_options[0].use_position_regularization):
+
+                # TODO: Regularize on all GPUs
+                self.parameters.scan[0], _ = affine_position_regularization(
+                    self.operator,
+                    self.parameters.psi[0],
+                    self.parameters.probe[0],
+                    self.parameters.position_options.initial_scan[0],
+                    self.parameters.scan[0],
+                )
+
             self.parameters.algorithm_options.times.append(time.perf_counter() -
                                                            start)
             start = time.perf_counter()
 
     def get_result(self):
-        return _teardown(
-            self.comm,
-            self.parameters,
-        )
+        reorder = np.argsort(np.concatenate(self.comm.order))
+        if self.parameters.position_options is not None:
+            host_position_options = self.parameters.position_options[0].empty()
+            for x, o in zip(
+                    self.comm.pool.map(
+                        PositionOptions.copy_to_host,
+                        self.parameters.position_options,
+                    ),
+                    self.comm.order,
+            ):
+                host_position_options = host_position_options.join(x, o)
+            self.parameters.position_options = host_position_options
+
+        if self.parameters.eigen_probe is not None:
+            self.parameters.eigen_probe = self.parameters.eigen_probe[0].get()
+
+        if self.parameters.eigen_weights is not None:
+            self.parameters.eigen_weights = self.comm.pool.gather(
+                self.parameters.eigen_weights,
+                axis=-3,
+            )[reorder].get()
+
+        if self.parameters.object_options is not None:
+            self.parameters.object_options = self.parameters.object_options.copy_to_host(
+            )
+
+        self.parameters.probe = self.parameters.probe[0].get()
+
+        if self.parameters.probe_options is not None:
+            self.parameters.probe_options = self.parameters.probe_options.copy_to_host(
+            )
+
+        self.parameters.psi = self.parameters.psi[0].get()
+
+        self.parameters.scan = self.comm.pool.gather_host(
+            self.parameters.scan,
+            axis=-2,
+        )[reorder]
+
+        return self.parameters
 
     def __exit__(self, type, value, traceback):
         self.comm.__exit__(type, value, traceback)
@@ -431,159 +546,6 @@ def _order_join(a, b):
     return np.append(a, b + len(a))
 
 
-def _setup(
-    comm,
-    data,
-    operator,
-    parameters,
-):
-    # Divide the inputs into regions
-    odd_pool = comm.pool.num_workers % 2
-    (
-        comm.order,
-        parameters.scan,
-        data,
-        parameters.eigen_weights,
-    ) = split_by_scan_grid(
-        comm.pool,
-        (
-            comm.pool.num_workers if odd_pool else comm.pool.num_workers // 2,
-            1 if odd_pool else 2,
-        ),
-        parameters.scan,
-        data,
-        parameters.eigen_weights,
-    )
-
-    parameters.psi = comm.pool.bcast([parameters.psi.astype('complex64')])
-
-    parameters.probe = comm.pool.bcast([parameters.probe.astype('complex64')])
-
-    if parameters.probe_options is not None:
-        parameters.probe_options = parameters.probe_options.copy_to_device()
-
-    if parameters.object_options is not None:
-        parameters.object_options = parameters.object_options.copy_to_device()
-
-    if parameters.eigen_probe is not None:
-        parameters.eigen_probe = comm.pool.bcast(
-            [parameters.eigen_probe.astype('complex64')])
-
-    if parameters.position_options is not None:
-        # TODO: Consider combining put/split, get/join operations?
-        parameters.position_options = comm.pool.map(
-            PositionOptions.copy_to_device,
-            (parameters.position_options.split(x) for x in comm.order),
-        )
-
-    # Unique batch for each device
-    batches = comm.pool.map(
-        getattr(tike.random, parameters.algorithm_options.batch_method),
-        parameters.scan,
-        num_cluster=parameters.algorithm_options.num_batch,
-    )
-
-    parameters.probe = _rescale_probe(
-        operator,
-        comm,
-        data,
-        parameters.psi,
-        parameters.scan,
-        parameters.probe,
-        num_batch=parameters.algorithm_options.num_batch,
-    )
-
-    return (
-        batches,
-        data,
-        parameters,
-    )
-
-
-def _iterate(
-    batches,
-    comm,
-    data,
-    operator,
-    parameters,
-):
-    if parameters.probe_options is not None:
-        if parameters.probe_options.centered_intensity_constraint:
-            parameters.probe = comm.pool.map(
-                constrain_center_peak,
-                parameters.probe,
-            )
-        if parameters.probe_options.sparsity_constraint < 1:
-            parameters.probe = comm.pool.map(
-                constrain_probe_sparsity,
-                parameters.probe,
-                f=parameters.probe_options.sparsity_constraint,
-            )
-
-    parameters = getattr(solvers, parameters.algorithm_options.name)(
-        operator,
-        comm,
-        data=data,
-        batches=batches,
-        parameters=parameters,
-    )
-
-    if (parameters.position_options
-            and parameters.position_options[0].use_position_regularization):
-
-        # TODO: Regularize on all GPUs
-        parameters.scan[0], _ = affine_position_regularization(
-            operator,
-            parameters.psi[0],
-            parameters.probe[0],
-            parameters.position_options.initial_scan[0],
-            parameters.scan[0],
-        )
-
-    return parameters
-
-
-def _teardown(
-    comm,
-    parameters,
-):
-    reorder = np.argsort(np.concatenate(comm.order))
-    if parameters.position_options is not None:
-        host_position_options = parameters.position_options[0].empty()
-        for x, o in zip(
-                comm.pool.map(
-                    PositionOptions.copy_to_host,
-                    parameters.position_options,
-                ),
-                comm.order,
-        ):
-            host_position_options = host_position_options.join(x, o)
-        parameters.position_options = host_position_options
-
-    if parameters.eigen_probe is not None:
-        parameters.eigen_probe = parameters.eigen_probe[0].get()
-
-    if parameters.eigen_weights is not None:
-        parameters.eigen_weights = comm.pool.gather(
-            parameters.eigen_weights,
-            axis=-3,
-        )[reorder].get()
-
-    if parameters.object_options is not None:
-        parameters.object_options = parameters.object_options.copy_to_host()
-
-    parameters.probe = parameters.probe[0].get()
-
-    if parameters.probe_options is not None:
-        parameters.probe_options = parameters.probe_options.copy_to_host()
-
-    parameters.psi = parameters.psi[0].get()
-
-    parameters.scan = comm.pool.gather_host(parameters.scan, axis=-2)[reorder]
-
-    return parameters
-
-
 def _get_rescale(data, psi, scan, probe, num_batch, operator):
 
     n1 = 0.0

From 8f1703dd601906d770de8f52237b69a9e6af94c7 Mon Sep 17 00:00:00 2001
From: Daniel Ching <carterbox@users.noreply.github.com>
Date: Fri, 13 May 2022 19:19:20 -0500
Subject: [PATCH 08/15] DOC: Update ptycho example for new API

---
 docs/source/examples/ptycho.ipynb | 1520 ++++++++++++++++++-----------
 1 file changed, 952 insertions(+), 568 deletions(-)

diff --git a/docs/source/examples/ptycho.ipynb b/docs/source/examples/ptycho.ipynb
index 96d24efd..0402a293 100644
--- a/docs/source/examples/ptycho.ipynb
+++ b/docs/source/examples/ptycho.ipynb
@@ -11,7 +11,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -28,22 +28,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "tike is version 0.19.1.dev30+gb78bacd\n",
-      "numpy is version 1.21.4\n",
-      "cupy is version 9.6.0\n"
+      "tike is version 0.20.2.dev5+g7dee447.d20220304\n",
+      "numpy is version 1.22.2\n",
+      "cupy is version 10.3.0\n"
      ]
     }
    ],
    "source": [
     "for module in [tike, np, cupy]:\n",
-    "    print(\"{} is version {}\".format(module.__name__, module.__version__))"
+    "    print(\"{} is version {}\".format(module.__name__, module.__version__))\n",
+    "# Note the versions below were used to generate this notebook. Use a compatible version to get results shown here."
    ]
   },
   {
@@ -57,7 +58,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -81,7 +82,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -90,7 +91,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -99,7 +100,7 @@
        "((1, 1, 1, 128, 128), dtype('complex64'))"
       ]
      },
-     "execution_count": 24,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -110,7 +111,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
@@ -122,7 +123,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 4 Axes>"
       ]
@@ -162,7 +163,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -171,7 +172,7 @@
        "((516, 2), dtype('float32'))"
       ]
      },
-     "execution_count": 26,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -182,12 +183,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -216,12 +217,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
@@ -237,7 +238,7 @@
        "(0.0, 963.0, dtype('float32'))"
       ]
      },
-     "execution_count": 28,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -261,38 +262,42 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
-    "probe_options = tike.ptycho.ProbeOptions()  # uses default settings for probe recovery\n",
-    "object_options = tike.ptycho.ObjectOptions(\n",
-    "    # The object will be updated.\n",
-    "    positivity_constraint=0.03,  # smoothness constraint will use our provided setting\n",
-    "    # other object options will be default values\n",
-    ")\n",
-    "position_options = None # indicates that positions will not be updated"
+    "# initial guess for psi can be automatically generated, but it will recenter the scaning positions\n",
+    "psi, scan = tike.ptycho.object.get_padded_object(scan, probe)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {
-    "scrolled": true
-   },
+   "execution_count": 11,
+   "metadata": {},
    "outputs": [],
    "source": [
-    "# Provide initial guesses for parameters that are updated\n",
-    "result = {\n",
-    "    # initial guess for psi can be automatically generated\n",
-    "    'probe': probe,\n",
-    "    'scan': scan,\n",
-    "}"
+    "parameters = tike.ptycho.PtychoParameters(\n",
+    "    # Provide initial guesses for parameters that are updated\n",
+    "    probe=probe,\n",
+    "    scan=scan,\n",
+    "    psi=psi,\n",
+    "    probe_options=tike.ptycho.ProbeOptions(), # uses default settings for probe recovery\n",
+    "    object_options=tike.ptycho.ObjectOptions(\n",
+    "        # The object will be updated.\n",
+    "        use_adaptive_moment=True,  # smoothness constraint will use our provided setting\n",
+    "        # other object options will be default values\n",
+    "    ),\n",
+    "    position_options=None, # indicates that positions will not be updated\n",
+    "    algorithm_options=tike.ptycho.RpieOptions(\n",
+    "        num_iter=64,\n",
+    "        num_batch=7,\n",
+    "    ),\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 12,
    "metadata": {
     "scrolled": true
    },
@@ -302,646 +307,1031 @@
      "output_type": "stream",
      "text": [
       "INFO:tike.ptycho.ptycho:rpie for 516 - 128 by 128 frames for 64 iterations.\n",
-      "INFO:tike.ptycho.ptycho:object and probe rescaled by 94.210822\n",
+      "INFO:tike.random:Clustering method is wobbly center.\n",
+      "INFO:tike.ptycho.ptycho:Probe rescaled by 94.334901\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 0\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.66374e+00\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.72043e+00\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.30904e+00\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.15139e+00\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.12207e+00\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.09669e+00\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.10055e+00\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.64563e+00\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.71423e+00\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.27707e+00\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.23932e+00\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.12872e+00\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.11972e+00\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.08593e+00\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 1\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +9.72138e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.01868e+00\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +9.54360e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.01698e+00\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +9.47063e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +9.63399e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +9.50959e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.93592e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.01822e+00\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.03768e+00\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +9.76870e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +9.83960e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +9.87449e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +1.00762e+00\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 2\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.83935e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +9.07639e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +9.06364e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.47993e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.69575e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.68897e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.78904e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.45044e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +9.25679e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.88366e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +9.04823e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +9.05695e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +9.01499e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.90855e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 3\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.94221e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.48746e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.00954e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.99763e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.27559e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.63992e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.78296e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.47206e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.77654e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.57616e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.14371e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.10765e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.49549e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +8.15158e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 4\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.57906e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.77982e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.52674e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.97348e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.33229e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.28052e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.18655e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.65837e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.89830e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.44493e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.57339e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.44391e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.92632e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.59359e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 5\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.11115e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.11925e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.30741e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.94381e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.88837e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.69519e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.54670e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.21477e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.39475e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.42778e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.56851e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.16525e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.42887e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.06928e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 6\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.02164e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.62508e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.63390e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.16737e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.38210e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.24036e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.23693e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.79236e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.86219e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.99538e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.03086e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.82873e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.66786e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.73879e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 7\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.89558e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.30137e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.95977e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.94818e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.79748e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.05675e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.80934e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.71768e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +7.04179e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.75921e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.91958e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.66038e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.62732e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.51656e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 8\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.38350e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.57763e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.23582e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.63381e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.65288e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.51189e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.50923e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.22277e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.38441e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.35538e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.56709e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.46533e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.37751e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.29259e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 9\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.34123e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.23779e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.36969e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.33053e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.23889e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.17197e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.18539e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.64951e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.52736e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.33423e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.36036e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.27863e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.19535e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.21508e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 10\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.45198e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.57828e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.26095e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.11522e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.10040e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.05318e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.05068e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.44976e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.75429e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.26726e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.29132e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.29413e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.21750e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.20627e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 11\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.88417e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.91633e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.91593e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.87452e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.78478e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.88589e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.87108e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.75462e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.50955e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.97392e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.00476e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.07127e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.07372e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.00862e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 12\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.26408e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.82680e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.54611e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.53933e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.66561e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.66667e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.77369e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.43015e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.16556e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.73476e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.07102e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.81410e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.97654e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +6.00401e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 13\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.37790e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.58405e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.29092e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.46674e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.53664e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.45810e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.58537e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.66826e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.64175e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.81173e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.89803e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.72215e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.70720e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.78858e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 14\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.31711e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.37677e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.11633e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.25988e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.41449e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.39406e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.52706e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.78506e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.55780e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.28211e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.90227e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.98501e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.86274e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.84964e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 15\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.86936e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.34147e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.17122e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.25819e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.37540e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.29972e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.30075e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.36749e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.43339e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.40495e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.64928e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.57904e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.78970e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.68762e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 16\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.04918e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.09324e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.22439e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.19767e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.13818e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.13881e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.23027e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.04616e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.68669e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.99717e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.54191e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.66743e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.77744e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.60077e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 17\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.96581e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.95013e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.95201e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.14470e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.03308e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.15820e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.23435e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.26651e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.52168e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.40741e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.70008e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.42592e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.59773e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.68498e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 18\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.03071e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.79756e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.96239e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.99831e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.05869e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.04778e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.04749e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.32004e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.54505e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.17250e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.36106e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.58701e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.60031e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.54805e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 19\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.91608e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.73642e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.86959e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.86345e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.03841e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.09580e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.05607e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.14130e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.58364e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.28304e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.57468e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.31288e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.51050e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.43432e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 20\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.28145e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.97896e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.91783e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.93953e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.96495e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.91207e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.01850e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.16939e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.68461e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.38018e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.40742e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.49881e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.38716e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.26396e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 21\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.87478e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.83306e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.76233e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.90280e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.86408e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.94951e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.87466e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.96598e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.01986e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.36764e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.43495e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.37966e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.37210e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.42362e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 22\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.72200e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.83385e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.63373e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.89319e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.83812e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.00349e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.88528e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.96021e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.17707e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.20646e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.07880e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.31309e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.29899e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.23116e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 23\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.19404e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.90941e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.78540e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.79801e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.86346e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.89632e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.85648e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.72199e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.12530e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.29286e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.08733e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.09235e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.28330e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.23239e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 24\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.44097e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.89749e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.72256e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.76000e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.88465e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.78148e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.84896e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.62307e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.16478e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.97398e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.13754e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.26872e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.13257e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.13855e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 25\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.61220e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.79973e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.72487e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.67330e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.85827e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.81271e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.74659e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.01387e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.20977e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.96570e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.89529e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.11386e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.20113e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.27174e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 26\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.57443e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.83294e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.52246e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.78661e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.79761e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.75385e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.84558e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.94527e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.99816e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.86613e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.93701e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.97406e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.99333e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.13832e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 27\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.57674e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.44631e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.79480e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.86138e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.81960e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.74414e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.74702e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.33747e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.48439e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.24293e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.08605e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.93324e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.14117e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.95508e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 28\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.63236e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.71323e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.60518e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.68961e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.75431e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.71312e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.81262e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.40046e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.96769e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.81229e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.66180e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.10987e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.03900e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.06169e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 29\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.72638e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.62944e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.54874e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.71657e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.73232e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.70939e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.77276e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.49108e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.65425e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.65484e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.98208e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.08647e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.91136e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.90033e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 30\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.34821e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.73952e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.52476e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.86036e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.73028e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.73716e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.71784e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.79288e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +5.01176e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.84621e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.67757e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.96045e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.92616e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.98349e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 31\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.54695e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.38405e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.77938e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.67086e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.65654e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.78536e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.80576e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.72258e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.57585e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.61084e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.84490e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.79418e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.82014e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.83516e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 32\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.59622e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.66513e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.55984e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.67187e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.72396e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.75459e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.71236e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.48651e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.18252e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.62544e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.86220e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.92839e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.81098e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.86722e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 33\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.35503e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.70011e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.73700e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.68588e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.61954e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.74821e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.69842e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.13690e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.57926e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.65334e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.73810e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.80403e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.69546e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.76977e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 34\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.07515e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.75698e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.55016e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.62432e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.73767e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.78833e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.73180e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.58300e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.50102e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.53406e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.65606e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.63055e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.60650e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.80672e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 35\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.46615e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.52511e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.53702e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.81881e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.70591e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.70146e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.68039e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.48171e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.09897e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.70460e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.61873e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.64824e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.58263e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.75526e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 36\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.55276e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.46408e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.44472e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.69132e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.76290e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.65919e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.78665e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.22494e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.51311e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.62639e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.46552e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.58576e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.63481e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.56336e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 37\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.56478e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.55110e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.61759e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.66070e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.75183e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.62558e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.70961e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.37374e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.19236e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.18596e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.67479e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.59993e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.57211e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.63124e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 38\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.56886e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.63457e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.50232e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.71038e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.60372e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.72671e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.70377e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.25571e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.18770e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.48509e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.32279e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.62418e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.55372e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.55486e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 39\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.51076e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.63025e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.46282e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.72528e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.65293e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.74253e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.66005e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.26059e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.26583e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.40475e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.38718e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.55330e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.33086e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.57384e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 40\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.59829e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.45303e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.65276e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.50599e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.68972e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.74329e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.72323e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.31201e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.97040e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.30604e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.29441e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.52491e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.46970e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.49767e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 41\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.42264e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.60512e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.57753e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.72092e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.69786e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.64264e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.68387e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.26408e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.23511e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.29781e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.35932e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.27436e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.42668e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.39582e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 42\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.53296e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.59129e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.55560e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.62223e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.60908e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.70677e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.69479e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.15827e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.99906e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.39161e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.35609e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.39361e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.32968e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.31935e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 43\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.57159e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.54230e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.41735e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.64108e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.76206e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.65626e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.69359e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.73822e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.12631e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.40160e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.32049e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.33077e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.23524e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.35768e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 44\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.51728e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.33713e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.68323e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.72322e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.64944e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.67748e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.63034e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.75696e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.10082e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.95276e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.40558e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.32540e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.30688e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.35245e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 45\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.37073e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.65347e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.69217e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.56797e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.65882e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.69428e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.61464e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.93013e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.18255e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.94894e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.32140e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.22166e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.34311e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.20018e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 46\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.42623e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.66046e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.63645e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.59145e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.59840e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.73084e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.63185e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.16524e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.92587e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.89155e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.27021e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.25882e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.28481e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.16806e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 47\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.47288e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.46982e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.69655e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.48547e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.70812e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.69124e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.66913e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.30287e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.17446e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.05280e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.18544e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.32501e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.28777e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.16222e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 48\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.58339e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.59814e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.47766e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.50774e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.69347e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.64792e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.74610e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.86384e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.08265e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.83903e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.17363e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.23277e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.17332e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.19843e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 49\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.48658e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.50851e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.63900e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.55351e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.65688e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.74624e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.61813e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.89772e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.15358e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.11951e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.90255e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.15766e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.13413e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.17501e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 50\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.55160e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.56910e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.54151e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.66968e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.64401e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.58159e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.72498e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.78494e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.06431e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.16574e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.02224e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.12398e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.10154e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.08913e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 51\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.26201e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.68139e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.64367e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.61188e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.60458e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.68197e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.64709e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.76267e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.01969e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.13357e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.06424e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.09511e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.05136e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.04761e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 52\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.56639e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.48360e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.64267e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.51771e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.60452e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.70993e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.65849e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.96316e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.02834e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.02075e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.97257e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.94160e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.11753e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.03082e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 53\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.52675e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.51171e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.42291e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.71364e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.61509e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.72167e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.62620e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.86420e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.01713e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.88273e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.95726e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.99698e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.14889e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.00978e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 54\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.31398e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.64446e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.43330e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.67354e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.61487e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.70622e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.65416e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.92550e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.89442e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.87197e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.99190e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.86904e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.08018e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.10672e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 55\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.48587e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.57890e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.60811e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.48588e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.70947e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.64623e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.66234e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.79356e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.57907e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.96498e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.05931e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.94820e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.06085e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.03433e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 56\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.54459e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.60384e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.40072e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.63379e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.61294e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.64845e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.68863e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.82439e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.85777e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.72998e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.95692e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.00823e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.04866e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.99997e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 57\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.48029e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.65179e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.60634e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.50940e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.57525e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.67854e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.62773e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.81232e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.77842e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.79638e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.00910e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.86256e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.02850e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.95485e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 58\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.33582e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.52172e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.65979e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.69617e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.66941e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.60422e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.59818e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.15300e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.86693e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.94512e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.93703e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.93308e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.98229e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +4.00231e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 59\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.54074e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.56358e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.58052e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.53851e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.66420e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.58432e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.67045e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.63692e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.90878e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.88027e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.76656e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.92294e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.95239e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.88220e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 60\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.24956e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.69861e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.55194e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.69437e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.66205e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.58125e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.63697e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.73790e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.90372e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.91095e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.82514e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.83104e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.88366e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.82996e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 61\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.56464e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.54016e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.44707e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.47491e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.68615e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.72517e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.68100e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.79210e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.73130e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.68441e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.81661e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.94189e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.97880e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.80307e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 62\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.58534e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.42671e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.56009e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.64722e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.60207e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.62881e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.63030e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.74277e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.74196e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.56143e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.84806e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.94906e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.88169e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.90401e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n",
       "INFO:tike.ptycho.ptycho:rpie epoch 63\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.59267e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.28403e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.68189e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.62608e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.58327e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.65277e-01\n",
-      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.64473e-01\n",
-      "INFO:tike.ptycho.object:Object positivity constrained with ratio 3.000e-02\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.75314e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.63408e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.81705e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.71110e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.84112e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.89305e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
+      "INFO:tike.ptycho.solvers.rpie:  farplane cost is +3.83406e-01\n",
+      "INFO:tike.ptycho.probe:Probe support constraint with weight 1.000e+01, radius 3.000e-01, degree 5.000e+00\n",
       "INFO:tike.ptycho.object:Object smooth constrained with kernel param 0.000e+00\n"
      ]
     }
@@ -949,27 +1339,21 @@
    "source": [
     "logging.basicConfig(level=logging.INFO)\n",
     "\n",
+    "# returns an updated PtychoParameters object\n",
     "result = tike.ptycho.reconstruct(\n",
     "    data=data,\n",
-    "    **result,\n",
-    "    algorithm_options=tike.ptycho.RpieOptions(\n",
-    "        num_iter=64,\n",
-    "        num_batch=7,\n",
-    "    ),\n",
-    "    probe_options=probe_options,\n",
-    "    object_options=object_options,\n",
-    "    position_options=position_options,\n",
+    "    parameters=parameters,\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -982,25 +1366,25 @@
    ],
    "source": [
     "plt.figure()\n",
-    "plt.semilogy(result['algorithm_options'].costs)\n",
+    "plt.semilogy(parameters.algorithm_options.costs)\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "(-0.14927544+0.007181996j) (2.4805176-0.15983747j)\n"
+      "(-0.6326242-0.5178276j) (4.789826-0.69965494j)\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1200x800 with 4 Axes>"
       ]
@@ -1013,7 +1397,7 @@
    ],
    "source": [
     "plt.figure(dpi=200)\n",
-    "tike.view.plot_phase(result['psi'], amin=0)\n",
+    "tike.view.plot_phase(result.psi, amin=0)\n",
     "plt.show()"
    ]
   },
@@ -1032,7 +1416,7 @@
   "kernelspec": {
    "display_name": "Python [conda env:tike]",
    "language": "python",
-   "name": "python3"
+   "name": "conda-env-tike-py"
   },
   "language_info": {
    "codemirror_mode": {
@@ -1044,7 +1428,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.12"
+   "version": "3.10.2"
   }
  },
  "nbformat": 4,

From d734deee694e8b3e1d5e0bdaf5a0d44c94e461ee Mon Sep 17 00:00:00 2001
From: Daniel Ching <carterbox@users.noreply.github.com>
Date: Mon, 16 May 2022 11:53:30 -0500
Subject: [PATCH 09/15] DOC: Add type hints and docstrings

---
 src/tike/ptycho/ptycho.py          | 27 ++++++++++-------
 src/tike/ptycho/solvers/options.py | 48 ++++++++++++++----------------
 2 files changed, 39 insertions(+), 36 deletions(-)

diff --git a/src/tike/ptycho/ptycho.py b/src/tike/ptycho/ptycho.py
index 9aaac3b8..b6e76c21 100644
--- a/src/tike/ptycho/ptycho.py
+++ b/src/tike/ptycho/ptycho.py
@@ -58,6 +58,7 @@
 from itertools import product
 import logging
 import time
+import typing
 
 import numpy as np
 import cupy as cp
@@ -185,6 +186,8 @@ def reconstruct(
         The intensity (square of the absolute value) of the propagated
         wavefront; i.e. what the detector records. FFT-shifted so the
         diffraction peak is at the corners.
+    parameters: :py:class:`tike.ptycho.solvers.PtychoParameters`
+        A class containing reconstruction parameters.
     model : "gaussian", "poisson"
         The noise model to use for the cost function.
     num_gpu : int, tuple(int)
@@ -223,7 +226,7 @@ class Reconstruction():
 
     Uses same parameters as the functional reconstruct API.
 
-    ..seealso:: tike.ptycho.reconstruct
+    .. seealso:: :py:func:`tike.ptycho.reconstruct`
     """
 
     def __init__(
@@ -352,7 +355,8 @@ def __enter__(self):
 
         return self
 
-    def iterate(self, num_iter):
+    def iterate(self, num_iter: int) -> None:
+        """Advance the reconstruction by num_iter epochs."""
         start = time.perf_counter()
         for i in range(num_iter):
 
@@ -399,7 +403,8 @@ def iterate(self, num_iter):
                                                            start)
             start = time.perf_counter()
 
-    def get_result(self):
+    def get_result(self) -> solvers.PtychoParameters:
+        """Return the current parameter estimates."""
         reorder = np.argsort(np.concatenate(self.comm.order))
         if self.parameters.position_options is not None:
             host_position_options = self.parameters.position_options[0].empty()
@@ -446,11 +451,11 @@ def __exit__(self, type, value, traceback):
         self.operator.__exit__(type, value, traceback)
         self.device.__exit__(type, value, traceback)
 
-    def get_psi(self):
-        """Return the current object estimate as numpy arrays."""
+    def get_psi(self) -> np.array:
+        """Return the current object estimate as a numpy array."""
         return self.parameters.psi[0].get()
 
-    def get_probe(self):
+    def get_probe(self) -> typing.Tuple[np.array, np.array, np.array]:
         """Return the current probe, eigen_probe, weights as numpy arrays."""
         reorder = np.argsort(np.concatenate(self.comm.order))
         if self.parameters.eigen_probe is None:
@@ -467,7 +472,7 @@ def get_probe(self):
         probe = self.parameters.probe[0].get()
         return probe, eigen_probe, eigen_weights
 
-    def peek(self):
+    def peek(self) -> typing.Tuple[np.array, np.array, np.array, np.array]:
         """Return the curent values of object and probe as numpy arrays."""
         psi = self.get_psi()
         probe, eigen_probe, eigen_weights = self.get_probe()
@@ -475,10 +480,10 @@ def peek(self):
 
     def append_new_data(
         self,
-        new_data,
-        new_scan,
-    ):
-        """"Append new diffraction patterns and scan positions to exisiting result."""
+        new_data: np.array,
+        new_scan: np.array,
+    ) -> None:
+        """"Append new diffraction patterns and positions to existing result."""
         # Assign positions and data to correct devices.
         odd_pool = self.comm.pool.num_workers % 2
         (
diff --git a/src/tike/ptycho/solvers/options.py b/src/tike/ptycho/solvers/options.py
index fcdf8fd3..f04a5f2e 100644
--- a/src/tike/ptycho/solvers/options.py
+++ b/src/tike/ptycho/solvers/options.py
@@ -85,43 +85,41 @@ class LstsqOptions(IterativeOptions):
 class PtychoParameters():
     """A class for storing the ptychography forward model parameters.
 
-    Replaces the dictionary?
-
-    Parameters
-    ----------
-    probe : (1, 1, SHARED, WIDE, HIGH) complex64
-        The shared complex illumination function amongst all positions.
-    scan : (POSI, 2) float32
-        Coordinates of the minimum corner of the probe grid for each
-        measurement in the coordinate system of psi. Coordinate order
-        consistent with WIDE, HIGH order.
-    eigen_probe : (EIGEN, SHARED, WIDE, HIGH) complex64
-        The eigen probes for all positions.
-    eigen_weights : (POSI, EIGEN, SHARED) float32
-        The relative intensity of the eigen probes at each position.
-    object_options : :py:class:`tike.ptycho.ObjectOptions`
-        A class containing settings related to object updates.
-    position_options : :py:class:`tike.ptycho.PositionOptions`
-        A class containing settings related to position correction.
-    probe_options : :py:class:`tike.ptycho.ProbeOptions`
-        A class containing settings related to probe updates.
-    psi : (WIDE, HIGH) complex64
-        The wavefront modulation coefficients of the object.
-    algorithm_options : :py:class:`tike.ptycho.solvers.IterativeOptions`
-        A class containing algorithm specific parameters
-
     .. versionadded:: 0.22.0
     """
     probe: np.array
+    """(1, 1, SHARED, WIDE, HIGH) complex64 The shared illumination function
+    amongst all positions."""
+
     psi: np.array
+    """(WIDE, HIGH) complex64 The wavefront modulation coefficients of
+    the object."""
+
     scan: np.array
+    """(POSI, 2) float32 Coordinates of the minimum corner of the probe
+    grid for each measurement in the coordinate system of psi. Coordinate order
+    consistent with WIDE, HIGH order."""
+
     eigen_probe: np.array = None
+    """(EIGEN, SHARED, WIDE, HIGH) complex64
+    The eigen probes for all positions."""
+
     eigen_weights: np.array = None
+    """(POSI, EIGEN, SHARED) float32
+    The relative intensity of the eigen probes at each position."""
+
     algorithm_options: IterativeOptions = dataclasses.field(
         default_factory=RpieOptions,)
+    """A class containing algorithm specific parameters"""
+
     probe_options: ProbeOptions = None
+    """A class containing settings related to probe updates."""
+
     object_options: ObjectOptions = None
+    """A class containing settings related to object updates."""
+
     position_options: PositionOptions = None
+    """A class containing settings related to position correction."""
 
     def __post_init__(self):
         if (self.scan.ndim != 2 or self.scan.shape[1] != 2

From c37efa13f5ae15f21289ca4297e3bfb715e66a60 Mon Sep 17 00:00:00 2001
From: Daniel Ching <carterbox@users.noreply.github.com>
Date: Mon, 16 May 2022 12:24:29 -0500
Subject: [PATCH 10/15] STY: Revert some unrelated format changes

---
 tests/operators/test_lamino.py |  8 +++-----
 tests/operators/util.py        |  6 ++++--
 tests/test_lamino.py           | 12 ++++++------
 3 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/tests/operators/test_lamino.py b/tests/operators/test_lamino.py
index 7651a1f5..6352f38e 100644
--- a/tests/operators/test_lamino.py
+++ b/tests/operators/test_lamino.py
@@ -58,11 +58,9 @@ def setUp(self, n=16, ntheta=8, tilt=np.pi / 3, eps=1e-1):
                                  dtype='complex64')
         self.d_name = 'data'
         self.kwargs = {
-            'theta':
-                self.xp.linspace(0, 2 * np.pi, ntheta).astype('float32'),
-            'grid':
-                self.xp.asarray(self.operator._make_grid().reshape(n**3, 3),
-                                dtype='int16'),
+            'theta': self.xp.linspace(0, 2 * np.pi, ntheta).astype('float32'),
+            'grid': self.xp.asarray(self.operator._make_grid().reshape(n**3, 3),
+                                    dtype='int16'),
         }
         print(self.operator)
 
diff --git a/tests/operators/util.py b/tests/operators/util.py
index c27afaf3..10e2ea70 100644
--- a/tests/operators/util.py
+++ b/tests/operators/util.py
@@ -61,8 +61,10 @@ def test_scaled(self):
         b = inner_complex(self.m, self.m)
         print()
         # NOTE: Inner product with self is real-only magnitude of self
-        print('<F*Fm, F*Fm> = {:.5g}{:+.5g}j'.format(a.real.item(), 0))
-        print('<   m,    m> = {:.5g}{:+.5g}j'.format(b.real.item(), 0))
+        print('<F*Fm, F*Fm> = {:.5g}{:+.5g}j'.format(a.real.item(),
+                                                     0))
+        print('<   m,    m> = {:.5g}{:+.5g}j'.format(b.real.item(),
+                                                     0))
         self.xp.testing.assert_allclose(a.real, b.real, rtol=1e-5, atol=0)
 
     def test_fwd_time(self):
diff --git a/tests/test_lamino.py b/tests/test_lamino.py
index 6c761b79..2bba837c 100644
--- a/tests/test_lamino.py
+++ b/tests/test_lamino.py
@@ -264,9 +264,9 @@ def setUp(self, n=2, b=2):
 
     def _radon_equal(self, module, eps):
         for tilt, axis, theta in zip(
-            [0, np.pi / 2, np.pi / 2],
-            [0, 1, 2],
-            [0, 0, -np.pi / 2],
+            [0, np.pi / 2,  np.pi / 2],
+            [0,         1,          2],
+            [0,         0, -np.pi / 2],
         ):
             projection = module.simulate(
                 obj=self.original,
@@ -287,9 +287,9 @@ def _radon_equal(self, module, eps):
     def _radon_equal_reverse(self, module, eps):
         for tilt, axis, theta, flip in zip(
             [np.pi, -np.pi / 2, np.pi / 2],
-            [0, 1, 2],
-            [0, 0, np.pi / 2],
-            [0, 0, 1],
+            [0,              1,         2],
+            [0,              0, np.pi / 2],
+            [0,              0,         1],
         ):
             projection = module.simulate(
                 obj=self.original,

From 4cbf2aec7003d7535c1a1007ec282091ad7dd3d9 Mon Sep 17 00:00:00 2001
From: Daniel Ching <carterbox@users.noreply.github.com>
Date: Mon, 16 May 2022 13:43:29 -0500
Subject: [PATCH 11/15] STY: Remove unused imports

---
 tests/ptycho/test_ptycho.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/tests/ptycho/test_ptycho.py b/tests/ptycho/test_ptycho.py
index d3b05908..b0567842 100644
--- a/tests/ptycho/test_ptycho.py
+++ b/tests/ptycho/test_ptycho.py
@@ -47,7 +47,6 @@
 # #########################################################################
 
 import bz2
-from inspect import Parameter
 import lzma
 import os
 import pickle
@@ -61,7 +60,7 @@
 from tike.ptycho.probe import ProbeOptions
 from tike.ptycho.position import PositionOptions
 from tike.ptycho.object import ObjectOptions
-from tike.communicators import Comm, MPIComm
+from tike.communicators import MPIComm
 import tike.random
 
 __author__ = "Daniel Ching, Xiaodong Yu"

From 35e5c6bb163b01f492893ba72f58100066266f48 Mon Sep 17 00:00:00 2001
From: Daniel Ching <carterbox@users.noreply.github.com>
Date: Tue, 17 May 2022 15:24:30 -0500
Subject: [PATCH 12/15] DOC: Only print nearplane cost for debug

---
 src/tike/ptycho/solvers/lstsq.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/tike/ptycho/solvers/lstsq.py b/src/tike/ptycho/solvers/lstsq.py
index 83b7d2bf..08daead8 100644
--- a/src/tike/ptycho/solvers/lstsq.py
+++ b/src/tike/ptycho/solvers/lstsq.py
@@ -558,7 +558,9 @@ def _get_nearplane_gradients(
 
     diff = nearplane[..., [m], :, :]
 
-    logger.info('%10s cost is %+12.5e', 'nearplane', tike.linalg.norm(diff))
+    if __debug__:
+        logger.debug('%10s cost is %+12.5e', 'nearplane',
+                     tike.linalg.norm(diff))
 
     if recover_psi:
         # (24b)

From 92b9f613e005f6d842bd321510423fc3bdde453f Mon Sep 17 00:00:00 2001
From: Daniel Ching <carterbox@users.noreply.github.com>
Date: Tue, 17 May 2022 16:24:22 -0500
Subject: [PATCH 13/15] API: Make get_result private

---
 src/tike/ptycho/ptycho.py | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/tike/ptycho/ptycho.py b/src/tike/ptycho/ptycho.py
index b6e76c21..7d27364a 100644
--- a/src/tike/ptycho/ptycho.py
+++ b/src/tike/ptycho/ptycho.py
@@ -217,8 +217,7 @@ def reconstruct(
             use_mpi,
     ) as context:
         context.iterate(parameters.algorithm_options.num_iter)
-        result = context.get_result()
-    return result
+    return context.parameters
 
 
 class Reconstruction():
@@ -403,7 +402,7 @@ def iterate(self, num_iter: int) -> None:
                                                            start)
             start = time.perf_counter()
 
-    def get_result(self) -> solvers.PtychoParameters:
+    def _get_result(self):
         """Return the current parameter estimates."""
         reorder = np.argsort(np.concatenate(self.comm.order))
         if self.parameters.position_options is not None:
@@ -444,9 +443,8 @@ def get_result(self) -> solvers.PtychoParameters:
             axis=-2,
         )[reorder]
 
-        return self.parameters
-
     def __exit__(self, type, value, traceback):
+        self._get_result()
         self.comm.__exit__(type, value, traceback)
         self.operator.__exit__(type, value, traceback)
         self.device.__exit__(type, value, traceback)

From a72f5ce9cf66af5537f838f929909e525c1287d1 Mon Sep 17 00:00:00 2001
From: Daniel Ching <carterbox@users.noreply.github.com>
Date: Wed, 18 May 2022 13:35:03 -0500
Subject: [PATCH 14/15] REF: Keep separate copies of ptychoparameters for host
 and device

---
 src/tike/ptycho/ptycho.py   | 201 +++++++++++++++++++-----------------
 tests/ptycho/test_ptycho.py |   2 +-
 2 files changed, 107 insertions(+), 96 deletions(-)

diff --git a/src/tike/ptycho/ptycho.py b/src/tike/ptycho/ptycho.py
index 7d27364a..40eef411 100644
--- a/src/tike/ptycho/ptycho.py
+++ b/src/tike/ptycho/ptycho.py
@@ -55,6 +55,7 @@
     "Reconstruction",
 ]
 
+import copy
 from itertools import product
 import logging
 import time
@@ -273,6 +274,7 @@ def __init__(
 
         self.data = data
         self.parameters = parameters
+        self._device_parameters = copy.deepcopy(parameters)
         self.device = cp.cuda.Device(
             num_gpu[0] if isinstance(num_gpu, tuple) else None)
         self.operator = Ptycho(
@@ -293,9 +295,9 @@ def __enter__(self):
         odd_pool = self.comm.pool.num_workers % 2
         (
             self.comm.order,
-            self.parameters.scan,
+            self._device_parameters.scan,
             self.data,
-            self.parameters.eigen_weights,
+            self._device_parameters.eigen_weights,
         ) = split_by_scan_grid(
             self.comm.pool,
             (
@@ -303,53 +305,53 @@ def __enter__(self):
                 if odd_pool else self.comm.pool.num_workers // 2,
                 1 if odd_pool else 2,
             ),
-            self.parameters.scan,
+            self._device_parameters.scan,
             self.data,
-            self.parameters.eigen_weights,
+            self._device_parameters.eigen_weights,
         )
 
-        self.parameters.psi = self.comm.pool.bcast(
-            [self.parameters.psi.astype('complex64')])
+        self._device_parameters.psi = self.comm.pool.bcast(
+            [self._device_parameters.psi.astype('complex64')])
 
-        self.parameters.probe = self.comm.pool.bcast(
-            [self.parameters.probe.astype('complex64')])
+        self._device_parameters.probe = self.comm.pool.bcast(
+            [self._device_parameters.probe.astype('complex64')])
 
-        if self.parameters.probe_options is not None:
-            self.parameters.probe_options = self.parameters.probe_options.copy_to_device(
+        if self._device_parameters.probe_options is not None:
+            self._device_parameters.probe_options = self._device_parameters.probe_options.copy_to_device(
             )
 
-        if self.parameters.object_options is not None:
-            self.parameters.object_options = self.parameters.object_options.copy_to_device(
+        if self._device_parameters.object_options is not None:
+            self._device_parameters.object_options = self._device_parameters.object_options.copy_to_device(
             )
 
-        if self.parameters.eigen_probe is not None:
-            self.parameters.eigen_probe = self.comm.pool.bcast(
-                [self.parameters.eigen_probe.astype('complex64')])
+        if self._device_parameters.eigen_probe is not None:
+            self._device_parameters.eigen_probe = self.comm.pool.bcast(
+                [self._device_parameters.eigen_probe.astype('complex64')])
 
-        if self.parameters.position_options is not None:
+        if self._device_parameters.position_options is not None:
             # TODO: Consider combining put/split, get/join operations?
-            self.parameters.position_options = self.comm.pool.map(
+            self._device_parameters.position_options = self.comm.pool.map(
                 PositionOptions.copy_to_device,
-                (self.parameters.position_options.split(x)
+                (self._device_parameters.position_options.split(x)
                  for x in self.comm.order),
             )
 
         # Unique batch for each device
         self.batches = self.comm.pool.map(
             getattr(tike.random,
-                    self.parameters.algorithm_options.batch_method),
-            self.parameters.scan,
-            num_cluster=self.parameters.algorithm_options.num_batch,
+                    self._device_parameters.algorithm_options.batch_method),
+            self._device_parameters.scan,
+            num_cluster=self._device_parameters.algorithm_options.num_batch,
         )
 
-        self.parameters.probe = _rescale_probe(
+        self._device_parameters.probe = _rescale_probe(
             self.operator,
             self.comm,
             self.data,
-            self.parameters.psi,
-            self.parameters.scan,
-            self.parameters.probe,
-            num_batch=self.parameters.algorithm_options.num_batch,
+            self._device_parameters.psi,
+            self._device_parameters.scan,
+            self._device_parameters.probe,
+            num_batch=self._device_parameters.algorithm_options.num_batch,
         )
 
         return self
@@ -359,89 +361,98 @@ def iterate(self, num_iter: int) -> None:
         start = time.perf_counter()
         for i in range(num_iter):
 
-            logger.info(f"{self.parameters.algorithm_options.name} epoch "
-                        f"{len(self.parameters.algorithm_options.times):,d}")
+            logger.info(
+                f"{self._device_parameters.algorithm_options.name} epoch "
+                f"{len(self._device_parameters.algorithm_options.times):,d}")
 
-            if self.parameters.probe_options is not None:
-                if self.parameters.probe_options.centered_intensity_constraint:
-                    self.parameters.probe = self.comm.pool.map(
+            if self._device_parameters.probe_options is not None:
+                if self._device_parameters.probe_options.centered_intensity_constraint:
+                    self._device_parameters.probe = self.comm.pool.map(
                         constrain_center_peak,
-                        self.parameters.probe,
+                        self._device_parameters.probe,
                     )
-                if self.parameters.probe_options.sparsity_constraint < 1:
-                    self.parameters.probe = self.comm.pool.map(
+                if self._device_parameters.probe_options.sparsity_constraint < 1:
+                    self._device_parameters.probe = self.comm.pool.map(
                         constrain_probe_sparsity,
-                        self.parameters.probe,
-                        f=self.parameters.probe_options.sparsity_constraint,
+                        self._device_parameters.probe,
+                        f=self._device_parameters.probe_options
+                        .sparsity_constraint,
                     )
 
-            self.parameters = getattr(
+            self._device_parameters = getattr(
                 solvers,
-                self.parameters.algorithm_options.name,
+                self._device_parameters.algorithm_options.name,
             )(
                 self.operator,
                 self.comm,
                 data=self.data,
                 batches=self.batches,
-                parameters=self.parameters,
+                parameters=self._device_parameters,
             )
 
-            if (self.parameters.position_options and self.parameters
-                    .position_options[0].use_position_regularization):
+            if (self._device_parameters.position_options
+                    and self._device_parameters.position_options[0]
+                    .use_position_regularization):
 
                 # TODO: Regularize on all GPUs
-                self.parameters.scan[0], _ = affine_position_regularization(
-                    self.operator,
-                    self.parameters.psi[0],
-                    self.parameters.probe[0],
-                    self.parameters.position_options.initial_scan[0],
-                    self.parameters.scan[0],
-                )
-
-            self.parameters.algorithm_options.times.append(time.perf_counter() -
-                                                           start)
+                self._device_parameters.scan[
+                    0], _ = affine_position_regularization(
+                        self.operator,
+                        self._device_parameters.psi[0],
+                        self._device_parameters.probe[0],
+                        self._device_parameters.position_options
+                        .initial_scan[0],
+                        self._device_parameters.scan[0],
+                    )
+
+            self._device_parameters.algorithm_options.times.append(
+                time.perf_counter() - start)
             start = time.perf_counter()
 
     def _get_result(self):
         """Return the current parameter estimates."""
+        self.parameters.probe = self._device_parameters.probe[0].get()
+
+        self.parameters.psi = self._device_parameters.psi[0].get()
+
         reorder = np.argsort(np.concatenate(self.comm.order))
-        if self.parameters.position_options is not None:
-            host_position_options = self.parameters.position_options[0].empty()
-            for x, o in zip(
-                    self.comm.pool.map(
-                        PositionOptions.copy_to_host,
-                        self.parameters.position_options,
-                    ),
-                    self.comm.order,
-            ):
-                host_position_options = host_position_options.join(x, o)
-            self.parameters.position_options = host_position_options
+        self.parameters.scan = self.comm.pool.gather_host(
+            self._device_parameters.scan,
+            axis=-2,
+        )[reorder]
 
-        if self.parameters.eigen_probe is not None:
-            self.parameters.eigen_probe = self.parameters.eigen_probe[0].get()
+        if self._device_parameters.eigen_probe is not None:
+            self.parameters.eigen_probe = self._device_parameters.eigen_probe[
+                0].get()
 
-        if self.parameters.eigen_weights is not None:
+        if self._device_parameters.eigen_weights is not None:
             self.parameters.eigen_weights = self.comm.pool.gather(
-                self.parameters.eigen_weights,
+                self._device_parameters.eigen_weights,
                 axis=-3,
             )[reorder].get()
 
-        if self.parameters.object_options is not None:
-            self.parameters.object_options = self.parameters.object_options.copy_to_host(
-            )
-
-        self.parameters.probe = self.parameters.probe[0].get()
+        self.parameters.algorithm_options = self._device_parameters.algorithm_options
 
-        if self.parameters.probe_options is not None:
-            self.parameters.probe_options = self.parameters.probe_options.copy_to_host(
+        if self._device_parameters.probe_options is not None:
+            self.parameters.probe_options = self._device_parameters.probe_options.copy_to_host(
             )
 
-        self.parameters.psi = self.parameters.psi[0].get()
+        if self._device_parameters.object_options is not None:
+            self.parameters.object_options = self._device_parameters.object_options.copy_to_host(
+            )
 
-        self.parameters.scan = self.comm.pool.gather_host(
-            self.parameters.scan,
-            axis=-2,
-        )[reorder]
+        if self._device_parameters.position_options is not None:
+            host_position_options = self._device_parameters.position_options[
+                0].empty()
+            for x, o in zip(
+                    self.comm.pool.map(
+                        PositionOptions.copy_to_host,
+                        self._device_parameters.position_options,
+                    ),
+                    self.comm.order,
+            ):
+                host_position_options = host_position_options.join(x, o)
+            self.parameters.position_options = host_position_options
 
     def __exit__(self, type, value, traceback):
         self._get_result()
@@ -451,23 +462,23 @@ def __exit__(self, type, value, traceback):
 
     def get_psi(self) -> np.array:
         """Return the current object estimate as a numpy array."""
-        return self.parameters.psi[0].get()
+        return self._device_parameters.psi[0].get()
 
     def get_probe(self) -> typing.Tuple[np.array, np.array, np.array]:
         """Return the current probe, eigen_probe, weights as numpy arrays."""
         reorder = np.argsort(np.concatenate(self.comm.order))
-        if self.parameters.eigen_probe is None:
+        if self._device_parameters.eigen_probe is None:
             eigen_probe = None
         else:
-            eigen_probe = self.parameters.eigen_probe[0].get()
-        if self.parameters.eigen_weights is None:
+            eigen_probe = self._device_parameters.eigen_probe[0].get()
+        if self._device_parameters.eigen_weights is None:
             eigen_weights = None
         else:
             eigen_weights = self.comm.pool.gather(
-                self.parameters.eigen_weights,
+                self._device_parameters.eigen_weights,
                 axis=-3,
             )[reorder].get()
-        probe = self.parameters.probe[0].get()
+        probe = self._device_parameters.probe[0].get()
         return probe, eigen_probe, eigen_weights
 
     def peek(self) -> typing.Tuple[np.array, np.array, np.array, np.array]:
@@ -505,9 +516,9 @@ def append_new_data(
             new_data,
             axis=0,
         )
-        self.parameters.scan = self.comm.pool.map(
+        self._device_parameters.scan = self.comm.pool.map(
             cp.append,
-            self.parameters.scan,
+            self._device_parameters.scan,
             new_scan,
             axis=0,
         )
@@ -520,15 +531,15 @@ def append_new_data(
         # Rebatch on each device
         self.batches = self.comm.pool.map(
             getattr(tike.random,
-                    self.parameters.algorithm_options.batch_method),
-            self.parameters.scan,
-            num_cluster=self.parameters.algorithm_options.num_batch,
+                    self._device_parameters.algorithm_options.batch_method),
+            self._device_parameters.scan,
+            num_cluster=self._device_parameters.algorithm_options.num_batch,
         )
 
-        if self.parameters.eigen_weights is not None:
-            self.parameters.eigen_weights = self.comm.pool.map(
+        if self._device_parameters.eigen_weights is not None:
+            self._device_parameters.eigen_weights = self.comm.pool.map(
                 cp.pad,
-                self.parameters.eigen_weights,
+                self._device_parameters.eigen_weights,
                 pad_width=(
                     (0, len(new_scan)),  # position
                     (0, 0),  # eigen
@@ -537,10 +548,10 @@ def append_new_data(
                 mode='mean',
             )
 
-        if self.parameters.position_options is not None:
-            self.parameters.position_options = self.comm.pool.map(
+        if self._device_parameters.position_options is not None:
+            self._device_parameters.position_options = self.comm.pool.map(
                 PositionOptions.append,
-                self.parameters.position_options,
+                self._device_parameters.position_options,
                 new_scan,
             )
 
diff --git a/tests/ptycho/test_ptycho.py b/tests/ptycho/test_ptycho.py
index b0567842..a80a1fd1 100644
--- a/tests/ptycho/test_ptycho.py
+++ b/tests/ptycho/test_ptycho.py
@@ -397,7 +397,7 @@ def template_consistent_algorithm(self, *, params={}):
                     new_scan=s,
                 )
                 context.iterate(2)
-            result = context.get_result()
+        result = context.parameters
         print()
         print('\n'.join(f'{c:1.3e}' for c in result.algorithm_options.costs))
         return result

From 226d79be0361a421261217fc5832f1bbaccd033e Mon Sep 17 00:00:00 2001
From: Daniel Ching <carterbox@users.noreply.github.com>
Date: Thu, 19 May 2022 17:54:36 -0500
Subject: [PATCH 15/15] NEW: Get convergence criteria online

---
 src/tike/ptycho/ptycho.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/tike/ptycho/ptycho.py b/src/tike/ptycho/ptycho.py
index 40eef411..ec14cb7f 100644
--- a/src/tike/ptycho/ptycho.py
+++ b/src/tike/ptycho/ptycho.py
@@ -460,6 +460,12 @@ def __exit__(self, type, value, traceback):
         self.operator.__exit__(type, value, traceback)
         self.device.__exit__(type, value, traceback)
 
+    def get_convergence(self):
+        return (
+            self._device_parameters.algorithm_options.costs,
+            self._device_parameters.algorithm_options.times,
+        )
+
     def get_psi(self) -> np.array:
         """Return the current object estimate as a numpy array."""
         return self._device_parameters.psi[0].get()