def parse_params(self): p = u.Param() p.scan = u.Param() p.scan.data = u.Param() p.scan.data.center = self.parameters['data_center'] p.scan.data.orientation = self.parameters['data_orientation'] p.scan.data.auto_center = self.parameters['data_auto_center'] p.scan.illumination = u.Param() p.scan.illumination.photons = self.parameters['illumination_photons'] p.scan.illumination.diversity = u.Param() p.scan.illumination.diversity.noise = self.parameters[ 'illumination_diversity_noise'] p.scan.illumination.diversity.power = self.parameters[ 'illumination_diversity_power'] p.scan.illumination.diversity.shift = self.parameters[ 'illumination_diversity_shift'] p.scan.sample = u.Param() p.scan.sample.model = self.parameters['sample_model'] p.scan.sample.fill = self.parameters['sample_fill'] p.scan.sample.recon = u.Param() p.scan.sample.diversity = u.Param() p.scan.sample.diversity.noise = self.parameters[ 'sample_diversity_noise'] p.scan.sample.diversity.power = self.parameters[ 'sample_diversity_power'] p.scan.sample.diversity.shift = self.parameters[ 'sample_diversity_shift'] p.scan.coherence = u.Param() p.scan.coherence.num_probe_modes = self.parameters[ 'coherence_num_probe_modes'] p.scan.coherence.num_object_modes = self.parameters[ 'coherence_num_object_modes'] p.scan.coherence.spectrum = self.parameters['coherence_spectrum'] p.scan.coherence.object_dispersion = self.parameters[ 'coherence_object_dispersion'] p.scan.coherence.probe_dispersion = self.parameters[ 'coherence_probe_dispersion'] p.scan.geometry = u.Param() p.scan.geometry.shape = self.parameters['geometry_shape'] p.engine = u.Param() p.engine.common = u.Param() p.engine.common.probe_support = self.parameters['common_probe_support'] p.engine.common.clip_object = self.parameters[ 'common_clip_object'] # turn off all of the output things p.io = u.Param() p.io.home = "./" ## (05) Base directory for all I/O p.io.rfile = False ## (06) Reconstruction file name (or format string) p.io.autosave = u.Param() p.io.autosave.active = False ## (08) Activation switch p.io.autosave.interval = -1 ## (09) Auto-save interval # p.io.autosave.rfile = "dumps/%(run)s/%(run)s_%(engine)s_%(iterations)04d.ptyr" ## (10) Auto-save file name (or format string) ## (11) Server / Client parameters p.io.interaction = u.Param() p.io.interaction.active = True p.io.autoplot = u.Param() p.io.autoplot.imfile = "./" ## (17) Plot images file name (or format string) p.io.autoplot.interval = 5 ## (18) Number of iterations between plot updates p.io.autoplot.threaded = True ## (19) Live plotting switch p.io.autoplot.layout = u.Param( ) ## (20) Options for default plotter or template name p.io.autoplot.dump = False ## (21) Switch to dump plots as image files p.io.autoplot.make_movie = False if self.parameters['DM_num_iter'] is not None: p.engine.DM = u.Param() p.engine.DM.name = "DM" p.engine.DM.alpha = self.parameters['DM_alpha'] p.engine.DM.probe_update_start = self.parameters[ 'DM_probe_update_start'] p.engine.DM.update_object_first = self.parameters[ 'DM_update_object_first'] p.engine.DM.overlap_converge_factor = self.parameters[ 'DM_overlap_converge_factor'] p.engine.DM.overlap_max_iterations = self.parameters[ 'DM_overlap_max_iterations'] p.engine.DM.probe_inertia = self.parameters['DM_probe_inertia'] p.engine.DM.object_inertia = self.parameters['DM_object_inertia'] p.engine.DM.fourier_relax_factor = self.parameters[ 'DM_fourier_relax_factor'] p.engine.DM.obj_smooth_std = self.parameters['DM_obj_smooth_std'] p.engines = u.Param() p.engines.engine_00 = u.Param() p.engines.engine_00.name = 'DM' p.engines.engine_00.numiter = self.parameters['DM_num_iter'] if self.parameters['ML_num_iter'] is not None: p.engine.ML = u.Param() p.engine.ML.name = "ML" p.engine.ML.type = self.parameters['ML_type'] p.engine.ML.floating_intensities = self.parameters[ 'ML_floating_intensities'] p.engine.ML.intensity_renormalization = self.parameters[ 'ML_intensity_renormalization'] p.engine.ML.reg_del2 = self.parameters['ML_reg_del2'] p.engine.ML.reg_del2_amplitude = self.parameters[ 'ML_reg_del2_amplitude'] p.engine.ML.smooth_gradient = self.parameters['ML_smooth_gradient'] p.engine.ML.scale_precond = self.parameters['ML_scale_precond'] p.engine.ML.scale_probe_object = self.parameters[ 'ML_scale_probe_object'] p.engine.ML.probe_update_start = self.parameters[ 'ML_probe_update_start'] # p.engines = u.Param() p.engines.engine_01 = u.Param() p.engines.engine_01.name = 'ML' p.engines.engine_01.numiter = self.parameters['ML_num_iter'] p.scans = u.Param() p.scans.savu = u.Param() p.scans.savu.if_conflict_use_meta = True p.scans.savu.data = u.Param() p.scans.savu.data.source = 'savu' p.scans.savu.data.dfile = None p.scans.savu.data.shape = self.parameters['geometry_shape'] p.scans.savu.data.save = None p.ipython_kernel = False r = u.Param() r.positions = self.get_positions( ).T ### this stuff can come out of the nexus file p.scans.savu.data.psize = 55e-6 p.scans.savu.data.distance = 1.59 p.scans.savu.data.orientation = 2 p.scans.savu.data.energy = 9.1 p.scan.illumination = u.Param() p.scan.illumination.model = None p.scan.illumination.photons = 1e8 p.scan.illumination.aperture = u.Param() p.scan.illumination.aperture.form = "circ" p.scan.illumination.aperture.size = 400e-6 p.scan.illumination.propagation = u.Param() p.scan.illumination.propagation.focussed = 440.5e-3 p.scan.illumination.propagation.parallel = 2.3e-3 r.mask = np.ones((p.scans.savu.data.shape, p.scans.savu.data.shape)) # probe_size = tuple(u.expect2(p.scan.geometry.shape)) + (p.scan.coherence.num_probe_modes, ) # self.set_size_probe(probe_size) return p, r
def _initialize(self, pars=None, **kwargs): # Starting parameters p = u.Param(DEFAULT) if pars is not None: p.update(pars) for k, v in kwargs.iteritems(): if p.has_key(k): p[k] = v self.p = p self.interact = False # set distance if self.p.z is None or self.p.z == 0: raise ValueError('Distance (geometry.z) must not be None or 0') # set frame shape if self.p.N is None or (np.array(self.p.N) == 0).any(): raise ValueError('Frame size (geometry.N) must not be None or 0') else: self.p.N = u.expect2(p.N) # Set energy and wavelength if p.energy is None: if p.lam is None: raise ValueError( 'Wavelength (geometry.lam) and energy (geometry.energy)\n must not both be None' ) else: self.lam = p.lam # also sets energy else: if p.lam is not None: logger.debug( 'Energy and wavelength both specified. Energy takes precedence over wavelength' ) self.energy = p.energy # set initial geometrical misfit to 0 self.p.misfit = u.expect2(0.) # Pixel size self.p.psize_det_is_fix = p.psize_det is not None self.p.psize_sam_is_fix = p.psize_sam is not None if not self.p.psize_det_is_fix and not self.p.psize_sam_is_fix: raise ValueError( 'Pixel size in sample plane (geometry.psize_sam) and detector plane \n(geometry.psize_det) must not both be None' ) # fill pixel sizes self.p.psize_sam = u.expect2( p.psize_sam) if self.p.psize_sam_is_fix else u.expect2(1.0) self.p.psize_det = u.expect2( p.psize_det) if self.p.psize_det_is_fix else u.expect2(1.0) # update other values self.update(False) # attach propagator self._propagator = self._get_propagator() self.interact = True
import sys import numpy as np import ptypy from ptypy.core import Ptycho from ptypy import utils as u from distutils.version import LooseVersion ## simplest possible input ############################################# detector = 'pilatus' # or 'merlin' or 'pilatus' folder = '/data/staff/nanomax/commissioning_2020-1/20200130/raw/sample' scannr = int(sys.argv[1]) distance = 4.05 ######################################################################## # General parameters p = u.Param() p.verbose_level = 3 p.run = 'scan%d' % scannr # Scan parameters p.scans = u.Param() p.scans.scan00 = u.Param() p.scans.scan00.name = 'Full' p.scans.scan00.data = u.Param() p.scans.scan00.coherence = u.Param() p.scans.scan00.coherence.num_probe_modes = 5 p.scans.scan00.data.name = 'NanomaxContrast' p.scans.scan00.data.path = folder p.scans.scan00.data.detector = detector p.scans.scan00.data.maskfile = { 'merlin': '/data/visitors/nanomax/common/masks/merlin/latest.h5',
* fix the 0002 calulation pf strain. should be ~5.93E-10m # Want to know the change of Q in reciprocal space, that is, the orthogonal space reciprocal to real space. # use ptypy coordinate shifting systems to shift the data from skewed to orthogonal reciprocal space """ import ptypy from ptypy.core import Ptycho from ptypy import utils as u import numpy as np import matplotlib.pyplot as plt import matplotlib.animation as animation from ptypy.experiment.nanomax3d import NanomaxBraggMarch2019 # after update need to update spec ptyScan class p = u.Param() p.run = 'XRD_LCBP31_AB' ##############323 is OK sample = 'LCBP31_AB' #scans = [244,245,283] # Whole set of scans. no multiples only the better one of the doublets scans = np.arange(244,324+1).tolist() + np.arange(326,329+1).tolist() + \ np.arange(331,333+1).tolist() + np.arange(335,339+1).tolist() + \ np.arange(340,343+1).tolist() p.verbose_level = 5 # use special plot layout for 3d data (but the io.home part tells ptypy where to save recons and dumps) p.io = u.Param() p.io.home = './' p.io.autoplot = u.Param()
# for in package use ##### from .. import utils as u from ..utils.verbose import logger from classes import Base, GEO_PREFIX import numpy as np __all__ = ['Geo'] DEFAULT = u.Param( energy=7.2, # Incident photon energy (in keV) lam=None, # Wavelength (in meters) z=2.19, # Distance from object to screen psize_det=172e-6, # Pixel size (in meters) at detector plane psize_sam=None, # Pixel sixe (in meters) at sample plane N=220, # Number of detector pixels #rebin = 1, # Rebinning (!! not implemented) prop_type='farfield', # propagation type #antialiasing = 2 # use antialiasing when generating diffraction misfit=0, origin_det='fftshift', origin_sam='fftshift', ) class Geo(Base): """ Interactive Geometry class! Bam! switch resolution, shape etc. and provide the propagator too. """
import ptypy from ptypy.core import Ptycho from ptypy import utils as u from distutils.version import LooseVersion ## simplest possible input ############################################# detector = 'eiger' # or 'merlin' or 'pilatus' folder = '../../raw/sample' distance_m = 3.512 # distance between the sample and the detector in meters defocus_um = 600 # distance between the focus and the sample plane in micro meters -> used for inital probe scannr = int(sys.argv[1]) ######################################################################## # General parameters p = u.Param() p.verbose_level = 3 p.run = 'scan%d' % scannr p.io = u.Param() p.io.rfile = 'recons/%(run)s_%(engine)s.ptyr' p.io.autoplot = u.Param() p.io.autoplot.active = False # Scan parameters p.scans = u.Param() p.scans.scan00 = u.Param() p.scans.scan00.name = 'Full' p.scans.scan00.coherence = u.Param() p.scans.scan00.coherence.num_probe_modes = 1 # Number of probe modes p.scans.scan00.data = u.Param()
from matplotlib import pyplot as plt from ptypy import utils as u from ptypy import * import numpy as np from pyE17 import utils as U import os import subprocess import sys import time """ import ptypy from ptypy.core import Ptycho from ptypy import utils as u import ptypy.simulations as sim import numpy as np p = u.Param() def RGB_to_HSV(rgb): eps = 1e-6 rgb = np.asarray(rgb).astype(float) maxc = rgb.max(axis=-1) minc = rgb.min(axis=-1) v = maxc s = (maxc - minc) / maxc s[maxc == 0.0] = 0.0 rc = (maxc - rgb[:, :, 0]) / (maxc - minc + eps) gc = (maxc - rgb[:, :, 1]) / (maxc - minc + eps) bc = (maxc - rgb[:, :, 2]) / (maxc - minc + eps) h = 4.0 + gc - rc
# -*- coding: utf-8 -*- """ Created on Tue Nov 13 2013 @author: benders """ ################ LOAD MODULES ########################################## from pyE17 import utils as U import ptypy from ptypy import utils as u import sys import numpy as np import os ######################################################################## p = u.Param() ##### GENERAL #################################################### #plt.interactive(True) #verbose.set_level(3) p.base_path = '/data/CDI/simulations/test' ##### PARAMETER INPUT ################################################## # Please also define here what additional parameter means what # As a default all parameters will form the simulation ID # First parameter is ALWAYS understood as stack index and will not be part of an id. pyfile = os.path.basename(sys.argv[0]) pars = [] if len(sys.argv) > 1: pars += sys.argv[1:] index_string = pars.pop(0) """ Use pars[ind] to pass changes through the script Example:
Want to know the change of Q in reciprocal space, that is, the orthogoanl space reciprocal to real space. # XRD analysis: use ptypy coordinate shifting systems to shift the data """ import ptypy from ptypy.core import Ptycho from ptypy.core.classes import Container, Storage, View from ptypy import utils as u import numpy as np import matplotlib.pyplot as plt import matplotlib.animation as animation from ptypy.experiment.nanomax3d import NanomaxBraggJune2017 # after update need to update spec ptyScan class from matplotlib import ticker p = u.Param() p.run = 'XRD_29A_inP_realprobe' # 'XRD_InP' #sample = 'JWX33_NW2'; scans = range(192, 200+1)+range(205, 222+1) #range(192, 195)# #sample = 'JWX29A_NW1'; scans = [483,484,485] # ~~central rotations sample = 'JWX29A_NW1' scans = [ 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 518, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 519, 488, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515 ] # new scan list with few scans removed to increase roi scans = [ 458, 463, 464, 466, 467, 468, 469, 470, 471, 518, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 519, 488, 496, 497, 498, 499,
import numpy as np import os import time from ptypy import utils as u import ptypy from detector import Detector, conv from ptysim_utils import * DEFAULT = u.Param( pos_noise= 1e-10, # (float) unformly distributed noise in xy experimental positions pos_scale= 0, # (float, list) amplifier for noise. Will be extended to match number of positions. Maybe used to only put nois on individual points pos_drift= 0, # (float, list) drift or offset paramter. Noise independent drift. Will be extended like pos_scale. detector='PILATUS_300K', frame_size= None, # (None, or float, 2-tuple) final frame size when saving if None, no cropping/padding happens psf= None, # (None or float, 2-tuple, array) Parameters for gaussian convolution or convolution kernel after propagation # use it for simulating partial coherence ) __all__ = ['simulate_basic_with_pods'] def simulate_basic_with_pods(ptypy_pars_tree=None, sim_pars=None, save=False): """ Basic Simulation """ p = DEFAULT.copy()
import sys import os # for solo use ########## if __name__ == "__main__": from ptypy import utils as u from ptypy.utils.verbose import logger else: # for in package use ##### from .. import utils as u from ..utils.verbose import logger __all__ = ['Paths'] DEFAULT = u.Param() DEFAULT.base_dir = "./" # (03) Relative base path for all other paths DEFAULT.run = None # (04) Name of reconstruction run DEFAULT.plot_dir = "plots/%(run)s/" # (06) directory to dump plot images DEFAULT.plot_file = "%(run)s_%(engine)s_%(iteration)04d.png" # (07) filename for dumping plots DEFAULT.plot_interval = 2 # (08) iteration interval for dumping plots DEFAULT.save_dir = "recons/%(run)s/" # (10) directory to save final reconstruction DEFAULT.save_file = "test.pty" #"%(run)s_%(algorithm)s_%(it)04d.h5"# (11) filename for saving DEFAULT.dump_dir = "dumps/%(run)s/" # (12) directory to save intermediate results DEFAULT.dump_file = "%(run)s_%(engine)s_%(iteration)04d.pty" # (13) DEFAULT.data_dir = "analysis/%(run)s/" DEFAULT.data_file = "%(label)s.h5" # runtime parameters DEFAULT.engine = "Dummy" DEFAULT.iteration = 0 DEFAULT.args = ""
def prepare(self, scan=None, filename=None, dtype=np.uint32, **kwargs): self.p.update( kwargs) #rebin = rebin if rebin is not None else self.p.rebin scan = scan if scan is not None else self.p.scan self.read(scan, **kwargs) DS = u.Param() dark = self.dark data = self.data if dark is not None: if dark.ndim == 3: dark = dark.mean(0) dark = np.resize(dark, data.shape) flat = self.flat if flat is not None: if flat.ndim == 3: flat = flat.mean(0) flat = np.resize(flat, self.data.shape) #plt.ion(); #plt.figure();plt.imshow(dark[0]);plt.colorbar() #plt.figure();plt.imshow((flat-dark)[0]);plt.colorbar() #plt.figure();plt.imshow(data[0]);plt.colorbar() if flat is not None and dark is not None: data = (data - dark) / (flat - dark) elif dark is not None: data = data - dark else: data = data # remove negative values data[data < 0] = 0 # #plt.figure();plt.imshow(DS.data[0],vmin=0);plt.colorbar() # if self.mask is None: mask = np.ones_like(data, dtype=np.bool) # #DS.flat = self.flat #DS.dark = self.dark DS.scan_info = u.Param() s = DS.scan_info p = self.p #s.scan_number = p.scan_number s.scan_label = 'S' + self.label #'S%05d' % p.scan_number s.data_filename = self.scan #scandict['data_filename'] s.wavelength = u.keV2m(p.energy) s.energy = p.energy rebin = self.p.rebin s.detector_pixel_size = p.detector_pixel_size * rebin if p.detector_pixel_size is not None else None p.dpsize = p.dpsize / rebin s.detector_distance = p.detector_distance s.initial_ctr = self.ctr / rebin if rebin != 1: sh = data.shape data = u.rebin(data, sh[0], sh[1] / rebin, sh[2] / rebin) mask = u.rebin(mask.astype(int), sh[0], sh[1] / rebin, sh[2] / rebin).astype(bool) data = flip(data, self.p.flip) mask = flip(mask, self.p.flip) DS.data = data.astype(dtype) DS.mask = mask DS.data[np.invert(DS.mask)] = 0 #s.date_collected = scandict['date'] s.date_processed = time.asctime() s.exposure_time = self.exp #if meta is not None: s.raw_filenames = meta['filename'] s.preparation_basepath = self.base_path s.preparation_other = {} s.shape = DS.data.shape s.positions_theory = None s.scan_command = self.command motors = p.motors if self.motors is not None: Nmotors = len(motors) logger.debug('Motors are : %s' % str(p.motors)) mmult = u.expect2(p.motors_multiplier) pos_list = [ mmult[i] * np.array(self.motors[motors[i]]) for i in range(Nmotors) ] s.positions = np.array(pos_list).T else: s.positions = None self.p.scan_label = s.scan_label if filename is None: p.write_path = WRITE_PATH_PATTERN.format(**p) filename = SAVE_FILENAME_PATTERN.format(**p) s.data_filename = u.clean_path(filename) io.h5write(filename, DS) return DS
def __init__( self, pars=None ): #base_path, experimentID=None, mask=None, flat=None, dark=None): """\ I13 DLS data reading class. The only mendatory argument for this constructor are 'base_path' and 'user'. Mask, flat or dark should be either None, scan numbers (interger) or file paths """ # Semi-smart base path detection: we are looking for a "raw" directory p = u.Param(DEFAULT) if pars is not None: p.update(pars) try: verbose_level = p.verbose_level verbose.set_level(verbose_level) except: pass self.p = p base_path = p.base_path if p.base_path.endswith( '/') else p.base_path + '/' experimentID = p.experimentID if base_path is None: d = os.getcwd() while True: if 'raw' in os.listdir(d): base_path = d break d, rest = os.path.split(d) if not rest: break if base_path is None: raise RuntimeError('Could not figure out base_path') logger.debug('base_path: "%s" (automatically set).' % base_path) else: logger.debug('base_path: "%s".' % base_path) self.base_path = base_path self.nxs = u.Param() self.nxs.frame = FRAME_IN_NEXUS_FILE.format(**p) self.nxs.exp = EXPOSURE_IN_NEXUS_FILE.format(**p) self.nxs.motors = MOTORS_IN_NEXUS_FILE.format(**p) self.nxs.command = COMMAND_IN_NEXUS_FILE.format(**p) self.nxs.experiment = EXPERIMENT_IN_NEXUS_FILE.format(**p) self.nxs.label = LABEL_IN_NEXUS_FILE.format(**p) # Load mask, flat and dark try: self.mask = load(self.get_nexus_file(p.mask), self.nxs.frame) except: self.mask = p.mask #assert self.mask.shape[-2:] == sh try: self.dark = load(self.get_nexus_file(p.dark), self.nxs.frame) except: self.dark = p.dark #assert self.dark.shape[-2:] == sh try: self.flat = load(self.get_nexus_file(p.flat), self.nxs.frame) except: self.flat = p.flat
EXPERIMENT_IN_NEXUS_FILE = 'entry1/experiment_identifier' #FILENAME_PATTERN = '{read_path}/{index}.{file_extension}' #INDEX_REPLACEMENT_STRING = '????' # Standard parameter stucture for prepare_data DEFAULT = u.Param( verbose_level=2, # Verbosity level base_path= None, #'The root directory where all experiment information can be found' detector_name=None, # That is the name of the detector in the nexus file experimentID=None, #'Experiment identifier' scan=None, #'Scan number' or file dpsize=None, #'Cropped array size for one frame' ctr=None, #'Center of the diffraction pattern.' energy=None, #'Nominal Radiation energy in keV' detector_pixel_size=None, #'Detector pixel size in meters' detector_distance=None, #'Detector distance to sample in meters' motors=['t1_sy', 't1_sx'], #'Motor names to determine the sample translation' motors_multiplier=1e-6, #'Motor conversion factor to meters' mask=None, #'Mask or name or number of the file containing the mask' dark=None, #'Dark frame or name or number of the file containing the dark' flat=None, #'Flat frame or name of number the file containing the flat' flip=None, #None, 'lr','ud' rebin=1, rotate=False, ) def flip(A, what): if what is None: return A
from matplotlib import pyplot as plt from ptypy import utils as u from ptypy import * import numpy as np from pyE17 import utils as U import os import subprocess import sys import time """ import ptypy from ptypy.core import Ptycho from ptypy import utils as u import ptypy.simulations as sim import numpy as np p = u.Param() ### PTYCHO PARAMETERS p.verbose_level = 3 # (00) Verbosity level p.data_type = "single" # (01) Reconstruction floatine number precision p.paths = u.Param() p.paths.base_dir = "./" # (03) Relative base path for all other paths p.paths.run = None # (04) Name of reconstruction run p.paths.data_dir = "analysis/%(run)s/" # (05) directory where diffraction data is stored p.paths.data_file = "%(label)s.ptyd" p.paths.plot_dir = "plots/%(run)s/" # (06) directory to dump plot images p.paths.plot_file = "%(run)s_%(engine)s_%(iterations)04d.png" # (07) filename for dumping plots p.paths.plot_interval = 2 # (08) iteration interval for dumping plots p.paths.save_dir = "recons/%(run)s/" # (09) directory to save final reconstruction
""" import ptypy from ptypy.core import Ptycho from ptypy import utils as u import numpy as np import matplotlib.pyplot as plt import matplotlib.animation as animation #from ptypy.experiment.nanomax3d import NanomaxBraggJune2017 # after update need to update spec ptyScan class from ptypy.experiment.I13_Bragg3d import I13Bragg3d # after update need to update spec ptyScan class # TODO # if InP # choose InP roi and change name p = u.Param() p.run = 'I13Bragg3d' # 'XRD_InP' sample = 'name'; scans = [155248, 155249] #range(192, 200+1)+range(205, 222+1) #sample = 'JWX29A_NW1' #; scans =[458,459] #scans = [458,459,460,461,462,463,464,465,466,467,468,469,470,471,518,473,474,475,476,477,478,479,480,481,482,483,484,485,486,519,488, 496,497,498, 499, 500, 501, 502, 503, 504, 505, 506,507, 508, 509, 510, 511, 512, 513, 514, 515] p.data_type = "single" #or "double" # for verbose output p.verbose_level = 5 # use special plot layout for 3d data (but the io.home part tells ptypy where to save recons and dumps) p.io = u.Param() p.io.home = './' p.io.autosave = u.Param() p.io.autosave.interval = 1 # does not work