ptypy.engines package

Submodules

ptypy.engines.projectional module

Difference Map reconstruction engine.

This file is part of the PTYPY package.

copyright:

Copyright 2014 by the PTYPY team, see AUTHORS.

license:

see LICENSE for details.

class ptypy.engines.projectional.DM(ptycho_parent, pars=None)

Bases: _ProjectionEngine, DMMixin

A full-fledged Difference Map engine.

Difference map reconstruction engine.

DEFAULT = {'alpha': 1.0, 'clip_object': None, 'compute_log_likelihood': True, 'fourier_power_bound': None, 'fourier_relax_factor': 0.05, 'name': 'DM', 'numiter': 20, 'numiter_contiguous': 1, 'obj_smooth_std': None, 'object_inertia': 0.0001, 'overlap_converge_factor': 0.05, 'overlap_max_iterations': 10, 'position_refinement': {'amplitude': 1e-06, 'amplitude_decay': True, 'interval': 1, 'max_shift': 2e-06, 'method': 'Annealing', 'metric': 'fourier', 'nshifts': 4, 'record': False, 'start': None, 'stop': None}, 'probe_center_tol': None, 'probe_fourier_support': None, 'probe_inertia': 1e-09, 'probe_support': 0.7, 'probe_update_start': 2, 'record_local_error': False, 'subpix': 'linear', 'subpix_start': 0, 'update_object_first': True}

class ptypy.engines.projectional.RAAR(ptycho_parent, pars=None)

Bases: _ProjectionEngine, RAARMixin

A RAAR engine.

Difference map reconstruction engine.

DEFAULT = {'beta': 0.75, 'clip_object': None, 'compute_log_likelihood': True, 'fourier_power_bound': None, 'fourier_relax_factor': 0.05, 'name': 'RAAR', 'numiter': 20, 'numiter_contiguous': 1, 'obj_smooth_std': None, 'object_inertia': 0.0001, 'overlap_converge_factor': 0.05, 'overlap_max_iterations': 10, 'position_refinement': {'amplitude': 1e-06, 'amplitude_decay': True, 'interval': 1, 'max_shift': 2e-06, 'method': 'Annealing', 'metric': 'fourier', 'nshifts': 4, 'record': False, 'start': None, 'stop': None}, 'probe_center_tol': None, 'probe_fourier_support': None, 'probe_inertia': 1e-09, 'probe_support': 0.7, 'probe_update_start': 2, 'record_local_error': False, 'subpix': 'linear', 'subpix_start': 0, 'update_object_first': True}

ptypy.engines.ML module

Maximum Likelihood reconstruction engine.

TODO.

• Implement other regularizers

This file is part of the PTYPY package.

copyright:

Copyright 2014 by the PTYPY team, see AUTHORS.

license:

see LICENSE for details.

class ptypy.engines.ML.ML(ptycho_parent, pars=None)

Bases: PositionCorrectionEngine

Maximum likelihood reconstruction engine.

Maximum likelihood reconstruction engine.

DEFAULT = {'ML_type': 'gaussian', 'floating_intensities': False, 'intensity_renormalization': 1.0, 'name': 'ML', 'numiter': 20, 'numiter_contiguous': 1, 'poly_line_coeffs': 'quadratic', 'position_refinement': {'amplitude': 1e-06, 'amplitude_decay': True, 'interval': 1, 'max_shift': 2e-06, 'method': 'Annealing', 'metric': 'fourier', 'nshifts': 4, 'record': False, 'start': None, 'stop': None}, 'probe_fourier_support': None, 'probe_support': 0.7, 'probe_update_start': 2, 'record_local_error': False, 'reg_del2': False, 'reg_del2_amplitude': 0.01, 'scale_precond': False, 'scale_probe_object': 1.0, 'smooth_gradient': 0.0, 'smooth_gradient_decay': 0.0}

SUPPORTED_MODELS = [<class 'ptypy.core.manager.Full'>, <class 'ptypy.core.manager.Vanilla'>, <class 'ptypy.core.manager.Bragg3dModel'>, <class 'ptypy.core.manager.BlockVanilla'>, <class 'ptypy.core.manager.BlockFull'>, <class 'ptypy.core.manager.GradFull'>, <class 'ptypy.core.manager.BlockGradFull'>]

engine_finalize()

Delete temporary containers.

engine_initialize()

Prepare for ML reconstruction.

engine_iterate(num=1)

Compute num iterations.

engine_prepare()

Last minute initialization, everything, that needs to be recalculated, when new data arrives.

ptypy.engines.stochastic module

Stochastic reconstruction engine.

This file is part of the PTYPY package.

copyright:

Copyright 2014 by the PTYPY team, see AUTHORS.

license:

see LICENSE for details.

class ptypy.engines.stochastic.EPIE(ptycho_parent, pars=None)

Bases: _StochasticEngine, EPIEMixin

The ePIE algorithm.

Stochastic Douglas-Rachford reconstruction engine.

DEFAULT = {'alpha': 1.0, 'beta': 1.0, 'compute_log_likelihood': True, 'name': 'EPIE', 'numiter': 20, 'numiter_contiguous': 1, 'object_norm_is_global': False, 'position_refinement': {'amplitude': 1e-06, 'amplitude_decay': True, 'interval': 1, 'max_shift': 2e-06, 'method': 'Annealing', 'metric': 'fourier', 'nshifts': 4, 'record': False, 'start': None, 'stop': None}, 'probe_center_tol': None, 'probe_fourier_support': None, 'probe_support': 0.7, 'probe_update_start': 0, 'record_local_error': False}

class ptypy.engines.stochastic.SDR(ptycho_parent, pars=None)

Bases: _StochasticEngine, SDRMixin

The stochastic Douglas-Rachford algorithm.

Stochastic Douglas-Rachford reconstruction engine.

DEFAULT = {'beta_object': 0.9, 'beta_probe': 0.1, 'compute_log_likelihood': True, 'name': 'SDR', 'numiter': 20, 'numiter_contiguous': 1, 'position_refinement': {'amplitude': 1e-06, 'amplitude_decay': True, 'interval': 1, 'max_shift': 2e-06, 'method': 'Annealing', 'metric': 'fourier', 'nshifts': 4, 'record': False, 'start': None, 'stop': None}, 'probe_center_tol': None, 'probe_fourier_support': None, 'probe_support': 0.7, 'probe_update_start': 0, 'record_local_error': False, 'sigma': 1, 'tau': 1}

ptypy.engines.base module

Base engine. Used to define reconstruction parameters that are shared by all engines.

This file is part of the PTYPY package.

copyright:

Copyright 2014 by the PTYPY team, see AUTHORS.

license:

see LICENSE for details.

class ptypy.engines.base.Base3dBraggEngine(ptycho, pars=None)

Bases: BaseEngine

3d Bragg engines need a slightly different prepare() method, because a 2d probe support makes no sense (at least not yet…)

Defaults:

[probe_support] default = None

Base reconstruction engine. :param ptycho: The parent Ptycho object. :type ptycho: Ptycho :param pars: Initialization parameters :type pars: Param or dict

prepare()

Last-minute preparation before iterating.

class ptypy.engines.base.BaseEngine(ptycho, pars=None)

Bases: object

Base reconstruction engine. In child classes, overwrite the following methods for custom behavior : engine_initialize engine_prepare engine_iterate engine_finalize

Defaults:

[numiter] default = 20 type = int lowlim = 1 help = Total number of iterations doc = For on-the-fly (live) processing, the reconstruction engine will iterate at least this many times after all data has been loaded.

[numiter_contiguous] default = 1 type = int lowlim = 1 help = Number of iterations without interruption doc = The engine will not return control to the caller until this number of iterations is completed (not processing server requests, I/O operations, …).

[probe_support] default = 0.7 type = float, None lowlim = 0.0 help = Valid probe area as fraction of the probe frame doc = Defines a circular area centered on the probe frame, in which the probe is allowed to be nonzero.

[probe_fourier_support] default = None type = float, None lowlim = 0.0 help = Valid probe area in frequency domain as fraction of the probe frame doc = Defines a circular area centered on the probe frame (in frequency domain), in which the probe is allowed to be nonzero.

[record_local_error] default = False type = bool help = If True, save the local map of errors into the runtime dictionary. userlevel = 2

Base reconstruction engine. :param ptycho: The parent Ptycho object. :type ptycho: Ptycho :param pars: Initialization parameters :type pars: Param or dict

COMPATIBLE_MODELS = []

engine_finalize()

Engine-specific finalization. Used to wrap-up engine-specific stuff. Called at the end of self.finalize()

engine_initialize()

Engine-specific initialization. Called at the end of self.initialize().

engine_iterate(num)

Engine single-step iteration. All book-keeping is done in self.iterate(), so this routine only needs to implement the “core” actions.

engine_prepare()

Engine-specific preparation. Last-minute initialization providing up-to-date information for reconstruction. Called at the end of self.prepare()

finalize()

Clean up after iterations are done.

initialize()

Prepare for reconstruction.

iterate(num=None)

Compute one or several iterations.

numNone, int number of iterations.

If None or num<1, a single iteration is performed.

prepare()

Last-minute preparation before iterating.

support_constraint(storage=None)

Enforces 2D support contraint on probe.

class ptypy.engines.base.PositionCorrectionEngine(ptycho_parent, pars)

Bases: BaseEngine

A sub class engine that supports position correction

Defaults:

[position_refinement] default = False type = Param, bool help = If True refine scan positions

[position_refinement.method] default = Annealing type = str help = Annealing or GridSearch

[position_refinement.start] default = None type = int help = Number of iterations until position refinement starts doc = If None, position refinement starts at first iteration

[position_refinement.stop] default = None type = int help = Number of iterations after which positon refinement stops doc = If None, position refinement stops after last iteration

[position_refinement.interval] default = 1 type = int help = Frequency of position refinement

[position_refinement.nshifts] default = 4 type = int help = Number of random shifts calculated in each position refinement step (has to be multiple of 4)

[position_refinement.amplitude] default = 0.000001 type = float help = Distance from original position per random shift [m]

[position_refinement.amplitude_decay] default = True type = bool help = After each interation, multiply amplitude by factor (stop - iteration) / (stop - start)

[position_refinement.max_shift] default = 0.000002 type = float help = Maximum distance from original position [m]

[position_refinement.metric] default = “fourier” type = str help = Error metric, can choose between “fourier” and “photon” choices = [“fourier”, “photon”]

[position_refinement.record] default = False type = bool help = record movement of positions

Position Correction engine.

POSREF_ENGINES = {'Annealing': <class 'ptypy.engines.posref.AnnealingRefine'>, 'GridSearch': <class 'ptypy.engines.posref.GridSearchRefine'>}

engine_finalize()

Synchronize positions

engine_initialize()

Prepare the position refinement object for use further down the line.

position_update()

Position refinement update.

ptypy.engines.utils module

Engine-specific utilities. This could be compiled, or GPU accelerated.

This file is part of the PTYPY package.

copyright:

Copyright 2014 by the PTYPY team, see AUTHORS.

license:

see LICENSE for details.

ptypy.engines.utils.Cdot(c1, c2)

Compute the dot product on two containers c1 and c2. No check is made to ensure they are of the same kind.

Parameters:

c2 (Container c1,) – Input

Returns:

The dot product (scalar)

ptypy.engines.utils.Cnorm2(c)

Computes a norm2 on whole container c.

Parameters:

c (Container) – Input

Returns:

The norm2 (scalar)

See also

ptypy.utils.math_utils.norm2

ptypy.engines.utils.basic_fourier_update(diff_view, pbound=None, alpha=1.0, LL_error=True)

* DEPRECATED * Backwards compatible function, for reference only. Contains LL error. Please replace with log_likelihood and projection_update_DM_AP

See also

basic_fourier_update_LEGACY

ptypy.engines.utils.basic_fourier_update_LEGACY(diff_view, pbound=None, alpha=1.0, LL_error=True)

* DEPRECATED * Fourier update a single view using its associated pods. Updates on all pods’ exit waves.

Parameters:

• diff_view (View) – View to diffraction data

• alpha (float, optional) – Mixing between old and new exit wave. Valid interval [0, 1]

• pbound (float, optional) – Power bound. Fourier update is bypassed if the quadratic deviation between diffraction data and diff_view is below this value. If None, fourier update always happens.

• LL_error (bool) – If True, calculates log-likelihood and puts it in the last entry of the returned error vector, else puts in 0.0

Returns:

error – 1d array, error = np.array([err_fmag, err_phot, err_exit]).

• err_fmag, Fourier magnitude error; quadratic deviation from root of experimental data

• err_phot, quadratic deviation from experimental data (photons)

• err_exit, quadratic deviation of exit waves before and after Fourier iteration

Return type:

ndarray

ptypy.engines.utils.dynamic_load(path, baselist, fail_silently=True)

Load an derivatives of baselist dynamically from .py files in the given path.

Parameters:

path – Path to Python files.

ptypy.engines.utils.log_likelihood(diff_view)

Calculates the log-likelihood for a diffraction view.

Parameters:

diff_view (View) – View to diffraction data

Returns:

ll_error – Log-likelihood error

Return type:

float

ptypy.engines.utils.projection_update_DM_AP(diff_view, alpha=1.0, pbound=None)

Linear interpolation between Difference Map algorithm (a,b,c = -1,1,2) and Alternating Projections algorithm (a,b,c = 0,1,1) with coefficients a = -alpha, b = 1, c = 1 + alpha. Alpha = 1.0 corresponds to DM and alpha = 0.0 to AP.

Parameters:

• diff_view (View) – View to diffraction data

• alpha (float, optional) – Blend between AP (alpha=0.0 and DM (alpha=1.0) . Valid interval [0, 1]

• pbound (float, optional) – Power bound. Fourier update is bypassed if the quadratic deviation between diffraction data and diff_view is below this value. If None, fourier update always happens.

Returns:

err_fmag, err_exit –

• err_fmag, Fourier magnitude error; quadratic deviation from root of experimental data

• err_exit, quadratic deviation between exit waves before and after projection

Return type:

float

ptypy.engines.utils.projection_update_generalized(diff_view, a, b, c, pbound=None)

Generalized projection update of a single view using its associated pods. Updates on all pods’ exit waves. We assume here that the current state is held in pod.exit, while the product of pod.probe & pod.object hold the state after overlap constraint has been applied. With O() denoting the overlap constraint and F() denoting the Data/Fourier constraint, the general projection update can be expressed with four coefficients

\[\psi^{j+1} = [x 1 + a O + b F (c O + y 1)](\psi^{j})\]

However, the coefficients aren’t all independent as the sum of x+a+b and d+y must be 1, thus we choose

\[x = 1 - a - b\]

and

\[y = 1 - c\]

The choice of a,b,c should enable a wide range of projection based algorithms.

For memory efficiency, this projection update includes the Fourier update which is why the power bound mechanism is included but deactivated by default.

Parameters:

• diff_view (View) – View to diffraction data

• a (float) – Coefficients for Overlap, Fourier and Fourier * Overlap constraints, respectively

• b (float) – Coefficients for Overlap, Fourier and Fourier * Overlap constraints, respectively

• c (float) – Coefficients for Overlap, Fourier and Fourier * Overlap constraints, respectively

• pbound (float, optional) – Power bound. Fourier update is bypassed if the quadratic deviation between diffraction data and diff_view is below this value. If None, fourier update always happens.

Returns:

err_fmag, err_exit –

• err_fmag, Fourier magnitude error; quadratic deviation from root of experimental data

• err_exit, quadratic deviation between exit waves before and after projection

Return type:

float

ptypy.engines.utils.reduce_dimension(a, dim, local_indices=None)

Apply a low-rank approximation on a.

Parameters:

• a (ndarray) – 3D numpy array

• dim (int) – The number of dimensions to retain. The case dim=0 (which would just reduce all layers to a mean) is not implemented.

• local_indices – Used for Containers distributed across nodes. Local indices of the current node.

Returns:

where:

• reduced array is the result of dimensionality reduction (same shape as a)

• modes: 3D array of length dim containing eigenmodes (aka singular vectors)

• coefficients: 2D matrix representing the decomposition of a.

Return type:

reduced array, modes, coefficients

Module contents

Engines module.

Implements the difference map (DM) and maximum likelihood (ML) reconstruction algorithms for ptychography.

This file is part of the PTYPY package.

copyright:

Copyright 2014 by the PTYPY team, see AUTHORS.

license:

see LICENSE for details.

ptypy.engines.by_name(name)

ptypy.engines.register(name=None)

Engine registration decorator