diff --git a/.gitignore b/.gitignore index d1ff6ae3..3df2b513 100644 --- a/.gitignore +++ b/.gitignore @@ -3,7 +3,7 @@ *.egg build/ dist/ -opmd_viewer.egg-info/ +openpmd_viewer.egg-info/ .cache/ .eggs/ .vs/ diff --git a/.travis.yml b/.travis.yml index a1f55d69..4f82ca0b 100644 --- a/.travis.yml +++ b/.travis.yml @@ -43,7 +43,7 @@ install: before_script : # static code analysis # pyflakes: mainly warnings, unused code, etc. - - python -m pyflakes opmd_viewer + - python -m pyflakes openpmd_viewer script: - "python setup.py test" diff --git a/CHANGELOG.md b/CHANGELOG.md index 74c26e9a..cee1c6c5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,39 @@ # Change Log / Release Log for openPMD-viewer +## 1.0.0 + +This version introduces major changes and breaks backward compatibility. + +Here is a list of the changes: +- The import statement now uses `openpmd_viewer` instead of `opmd_viewer`, e.g. +``` +from openpmd_viewer import OpenPMDTimeSeries +``` +- For consistency, `ts.get_particle` now return particle positions in meters, +instead of microns. For instance, in the code below, `x`, `y`, `z` will be in +meters +``` +x, y, z = ts.get_particle(['x', 'y', 'z'], iteration=1000) +``` +- In `ts.get_field`, slicing can now be done in several directions, and for +1d, 2d, 3d, and circ geometries. As a consequence, this breaks backward +compatibility for 3d field: +```get_field(field=field, coord=coord, iteration=iteration)``` +used to return the central slice along `y` while it now returns the full 3d field. +In addition, the name of the argument of `get_field` that triggers slicing +has been changed from `slicing_dir` to `slice_across` (and `slicing` has been +changed to `slice_relative_position`). +- `openPMD-viewer` does not rely on Cython anymore. Instead, it uses `numba` +for functions that perform a substantial amount of computation. +- A new function (`ts.iterate`) was introduced in order to quickly apply a +given function to all iterations of a time series. See the docstring of +`ts.iterate` for more information. +- The function `get_laser_envelope` does not support the argument `index` anymore +(which was effectively used in order to perform slicing). Instead, users should use +the argument `slicing_dir`. In addition, `get_laser_envelope` now supports the +argument `plot_range`. +- The function `get_laser_waist` does not support the agument `slicing_dir` anymore. + ## 0.9.0 This release adds two features: @@ -106,7 +140,7 @@ This new version includes: - an additional option `use_field_mesh` when plotting the particle. When set to `True`, this option uses information from the field mesh to choose the parameters of the particle histograms (esp. the bins). This is useful in order to avoid plotting/binning artifacts (aliasing) when the particles are evenly spaced. -In addition, the package `opmd_viewer` now has an attribute `__version__`. +In addition, the module `openpmd_viewer` now has an attribute `__version__`. ## 0.3.3 diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 30c155af..4416758b 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -49,7 +49,7 @@ git pull git@github.com:openPMD/openPMD-viewer.git dev - Use [pyflakes](https://pypi.python.org/pypi/pyflakes) to detect any potential bug. ``` cd openPMD-viewer/ - pyflakes opmd_viewer + pyflakes openpmd_viewer ``` - Make sure that the tests pass (please install `wget` and `jupyter` before running the tests: `pip install wget jupyter`) ``` @@ -76,10 +76,10 @@ git push -u origin - Features that **modify** or **improve** the `OpenPMDTimeSeries` object should be implemented in the -`opmd_viewer/opempmd_timeseries` folder. Features that **build upon** the +`openpmd_viewer/opempmd_timeseries` folder. Features that **build upon** the `OpenPMDTimeSeries` object to create domain-specific analysis tools (e.g. laser diagnostics for PIC simulations) should be implemented in -the `opmd_viewer/addons` folder. +the `openpmd_viewer/addons` folder. - Document the functions and classes that you write, by using a [docstring](https://www.python.org/dev/peps/pep-0257/). List the diff --git a/MANIFEST.in b/MANIFEST.in index f229beb4..7e937e5c 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -1,5 +1,4 @@ include README.md include requirements.txt -include opmd_viewer/openpmd_timeseries/cython_function.pyx -include opmd_viewer/notebook_starter/openPMD_notebook -include opmd_viewer/notebook_starter/Template_notebook.ipynb +include openpmd_viewer/notebook_starter/openPMD_notebook +include openpmd_viewer/notebook_starter/Template_notebook.ipynb diff --git a/README.md b/README.md index b416b4ac..ecbfdb7f 100644 --- a/README.md +++ b/README.md @@ -52,12 +52,12 @@ browser**. To use this executable, simply type in a regular terminal: ### Installation on a local computer -#### Installation with conda (recommended) +#### Installation with conda In order to install `openPMD-viewer` with `conda`, please install the [Anaconda distribution](https://docs.anaconda.com/anaconda/install/), and then type ``` -conda install -c rlehe openpmd_viewer +conda install -c conda-forge openpmd-viewer ``` If you are using JupyterLab, please also install the `jupyter-matplotlib` extension (See installation instructions @@ -65,14 +65,9 @@ extension (See installation instructions #### Installation with pip -If you cannot install `openPMD-viewer` with `conda`, the alternative -is to use `pip`. However, you need to first make sure that `h5py` is -installed on your local computer. This can be done for instance by -typing `pip install h5py`, though this may require you to install `hdf5` separately. - -Once `h5py` is installed, simply type +You can also install `openPMD-viewer` using `pip` ``` -pip install openPMD-viewer +pip install openpmd-viewer ``` In addition, if you wish to use the interactive GUI, please type ``` diff --git a/RELEASING.md b/RELEASING.md index 588920d8..5a686632 100644 --- a/RELEASING.md +++ b/RELEASING.md @@ -32,7 +32,7 @@ username = ## Creating a release on Github -- Make sure that the version number in `opmd_viewer/__version__.py` **and** +- Make sure that the version number in `openpmd_viewer/__version__.py` **and** in `conda_recipe/meta.yaml` correspond to the new release, and that the corresponding changes have been documented in `CHANGELOG.md`. @@ -57,22 +57,3 @@ twine upload dist/* -r pypi (NB: You can also first test this by uploading the package to [test PyPI](https://testpypi.python.org/pypi) ; to do so, simply replace `pypi` by `pypitest` in the above set of commands) - -## Uploading the package to Anaconda.org - -- `cd` into the folder `conda_recipe`. - -- Still in the folder `conda_recipe`, run -``` -docker build -t openpmd_build . -docker run -it -v $PWD:/home/ openpmd_build -``` -This builds the conda packages for Python 2.7, 3.4, 3.5 and 3.6, using a -reproduceable environment. - -- After the build, the Docker container will **not** exit. From the container, type the following commands: -``` -anaconda login -anaconda upload osx-64/* -anaconda upload /opt/conda/conda-bld/linux-64/openpmd_viewer* -``` diff --git a/conda_recipe/Dockerfile b/conda_recipe/Dockerfile deleted file mode 100644 index e5cf7b31..00000000 --- a/conda_recipe/Dockerfile +++ /dev/null @@ -1,21 +0,0 @@ -FROM continuumio/miniconda -MAINTAINER Remi Lehe - -RUN apt-get update \ - && apt-get install -y \ - gcc \ - libgl1-mesa-glx \ - && rm -rf /var/lib/apt/lists/* - -RUN conda install --yes conda conda-build anaconda-client - -CMD cd /home/ \ - && conda build --python=2.7 . \ - && conda convert $(conda build --python=2.7 . --output) -p osx-64 \ - && conda build --python=3.4 . \ - && conda convert $(conda build --python=3.4 . --output) -f -p osx-64 \ - && conda build --python=3.5 . \ - && conda convert $(conda build --python=3.5 . --output) -f -p osx-64 \ - && conda build --python=3.6 . \ - && conda convert $(conda build --python=3.6 . --output) -f -p osx-64 \ - && /bin/bash diff --git a/conda_recipe/meta.yaml b/conda_recipe/meta.yaml deleted file mode 100644 index 2e6e2086..00000000 --- a/conda_recipe/meta.yaml +++ /dev/null @@ -1,40 +0,0 @@ -{% set version = "0.9.1" %} - -package: - name: openpmd_viewer - version: {{ version }} - -source: - git_rev: {{ version }} - git_url: https://github.com/openPMD/openPMD-viewer.git - -build: - script: python setup.py install - -requirements: - build: - - python - - setuptools - - cython - - numpy - - scipy - - matplotlib - - h5py - run: - - python - - cython - - numpy - - scipy - - matplotlib - - h5py - - jupyter - -test: - imports: - - opmd_viewer - -about: - home: https://github.com/openPMD/openPMD-viewer - license: BSD-3-clause - license_file: LICENSE.txt - summary: "Visualization tools for openPMD files" diff --git a/openpmd_viewer/__init__.py b/openpmd_viewer/__init__.py new file mode 100644 index 00000000..4a423d16 --- /dev/null +++ b/openpmd_viewer/__init__.py @@ -0,0 +1,15 @@ +""" +openPMD-viewer + +Usage +----- +See the class OpenPMDTimeSeries to open a set of openPMD files +""" +# Make the OpenPMDTimeSeries object accessible from outside the package +from .openpmd_timeseries import OpenPMDTimeSeries, FieldMetaInformation, \ + ParticleTracker + +# Define the version number +from .__version__ import __version__ +__all__ = ['OpenPMDTimeSeries', 'FieldMetaInformation', + 'ParticleTracker', '__version__'] diff --git a/openpmd_viewer/__version__.py b/openpmd_viewer/__version__.py new file mode 100644 index 00000000..5becc17c --- /dev/null +++ b/openpmd_viewer/__version__.py @@ -0,0 +1 @@ +__version__ = "1.0.0" diff --git a/opmd_viewer/addons/__init__.py b/openpmd_viewer/addons/__init__.py similarity index 100% rename from opmd_viewer/addons/__init__.py rename to openpmd_viewer/addons/__init__.py diff --git a/opmd_viewer/addons/pic/__init__.py b/openpmd_viewer/addons/pic/__init__.py similarity index 100% rename from opmd_viewer/addons/pic/__init__.py rename to openpmd_viewer/addons/pic/__init__.py diff --git a/opmd_viewer/addons/pic/lpa_diagnostics.py b/openpmd_viewer/addons/pic/lpa_diagnostics.py similarity index 82% rename from opmd_viewer/addons/pic/lpa_diagnostics.py rename to openpmd_viewer/addons/pic/lpa_diagnostics.py index 577ebfa1..f3ff8b90 100644 --- a/opmd_viewer/addons/pic/lpa_diagnostics.py +++ b/openpmd_viewer/addons/pic/lpa_diagnostics.py @@ -10,11 +10,12 @@ # Class that inherits from OpenPMDTimeSeries, and implements # some standard diagnostics (emittance, etc.) -from opmd_viewer import OpenPMDTimeSeries, FieldMetaInformation +from openpmd_viewer import OpenPMDTimeSeries, FieldMetaInformation import numpy as np import scipy.constants as const from scipy.optimize import curve_fit -from opmd_viewer.openpmd_timeseries.plotter import check_matplotlib +from openpmd_viewer.openpmd_timeseries.utilities import sanitize_slicing +from openpmd_viewer.openpmd_timeseries.plotter import check_matplotlib from scipy.signal import hilbert try: import matplotlib.pyplot as plt @@ -70,8 +71,8 @@ def get_mean_gamma( self, t=None, iteration=None, species=None, select : dict, optional Either None or a dictionary of rules to select the particles, of the form - 'x' : [-4., 10.] (Particles having x between -4 and 10 microns) - 'z' : [0, 100] (Particles having x between 0 and 100 microns) + 'x' : [-4., 10.] (Particles having x between -4 and 10 meters) + 'z' : [0, 100] (Particles having z between 0 and 100 meters) Returns ------- @@ -123,8 +124,8 @@ def get_sigma_gamma_slice(self, dz, t=None, iteration=None, species=None, select : dict, optional Either None or a dictionary of rules to select the particles, of the form - 'x' : [-4., 10.] (Particles having x between -4 and 10 microns) - 'z' : [0, 100] (Particles having x between 0 and 100 microns) + 'x' : [-4., 10.] (Particles having x between -4 and 10 meters) + 'z' : [0, 100] (Particles having z between 0 and 100 meters) plot : bool, optional Whether to plot the requested quantity @@ -161,12 +162,12 @@ def get_sigma_gamma_slice(self, dz, t=None, iteration=None, species=None, if plot: check_matplotlib() iteration = self.iterations[ self._current_i ] - time_fs = 1.e15 * self.t[ self._current_i ] + time_s = self.t[ self._current_i ] plt.plot(z_pos, spreads, **kw) - plt.title("Slice energy spread at %.1f fs (iteration %d)" - % (time_fs, iteration), fontsize=self.plotter.fontsize) - plt.xlabel('$z \;(\mu m)$', fontsize=self.plotter.fontsize) - plt.ylabel('$\sigma_\gamma (\Delta_z=%s\mu m)$' % dz, + plt.title("Slice energy spread at %.2e s (iteration %d)" + % (time_s, iteration), fontsize=self.plotter.fontsize) + plt.xlabel('$z \;(m)$', fontsize=self.plotter.fontsize) + plt.ylabel('$\sigma_\gamma (\Delta_z=%s m)$' % dz, fontsize=self.plotter.fontsize) return(spreads, z_pos) @@ -191,8 +192,8 @@ def get_charge( self, t=None, iteration=None, species=None, select=None ): select : dict, optional Either None or a dictionary of rules to select the particles, of the form - 'x' : [-4., 10.] (Particles having x between -4 and 10 microns) - 'z' : [0, 100] (Particles having x between 0 and 100 microns) + 'x' : [-4., 10.] (Particles having x between -4 and 10 meters) + 'z' : [0, 100] (Particles having z between 0 and 100 meters) Returns ------- @@ -228,8 +229,8 @@ def get_divergence( self, t=None, iteration=None, species=None, select : dict, optional Either None or a dictionary of rules to select the particles, of the form - 'x' : [-4., 10.] (Particles having x between -4 and 10 microns) - 'z' : [0, 100] (Particles having x between 0 and 100 microns) + 'x' : [-4., 10.] (Particles having x between -4 and 10 meters) + 'z' : [0, 100] (Particles having z between 0 and 100 meters) Returns ------- @@ -271,8 +272,8 @@ def get_emittance(self, t=None, iteration=None, species=None, select : dict, optional Either None or a dictionary of rules to select the particles, of the form: - 'x' : [-4., 10.] (Particles having x between -4 and 10 microns); - 'z' : [0, 100] (Particles having x between 0 and 100 microns). + 'x' : [-4., 10.] (Particles having x between -4 and 10 meters) + 'z' : [0, 100] (Particles having z between 0 and 100 meters). kind : string, optional Kind of emittance to be computed. Can be 'normalized' or 'trace'. @@ -387,8 +388,8 @@ def get_current( self, t=None, iteration=None, species=None, select=None, select : dict, optional Either None or a dictionary of rules to select the particles, of the form - 'x' : [-4., 10.] (Particles having x between -4 and 10 microns) - 'z' : [0, 100] (Particles having x between 0 and 100 microns) + 'x' : [-4., 10.] (Particles having x between -4 and 10 meters) + 'z' : [0, 100] (Particles having z between 0 and 100 meters) bins : int, optional Number of bins along the z-axis in which to calculate the current @@ -437,17 +438,19 @@ def get_current( self, t=None, iteration=None, species=None, select=None, if plot: check_matplotlib() iteration = self.iterations[ self._current_i ] - time_fs = 1.e15 * self.t[ self._current_i ] + time_s = self.t[ self._current_i ] plt.plot( info.z, current, **kw) - plt.title("Current at %.1f fs (iteration %d)" - % (time_fs, iteration ), fontsize=self.plotter.fontsize) - plt.xlabel('$z \;(\mu m)$', fontsize=self.plotter.fontsize) + plt.title("Current at %.2e s (iteration %d)" + % (time_s, iteration ), fontsize=self.plotter.fontsize) + plt.xlabel('$z \;(m)$', fontsize=self.plotter.fontsize) plt.ylabel('$I \;(A)$', fontsize=self.plotter.fontsize) # Return the current and bin centers return(current, info) def get_laser_envelope( self, t=None, iteration=None, pol=None, m='all', - index='center', theta=0, slicing_dir='y', plot=False, **kw ): + theta=0, slice_across=None, + slice_relative_position=None, plot=False, + plot_range=[[None, None], [None, None]], **kw ): """ Calculate a laser field by filtering out high frequencies. Can either return the envelope slice-wise or a full 2D envelope. @@ -471,23 +474,38 @@ def get_laser_envelope( self, t=None, iteration=None, pol=None, m='all', Either 'all' (for the sum of all the modes) or an integer (for the selection of a particular mode) - index : int or str, optional - Transversal index of the slice from which to calculate the envelope - Default is 'center', using the center slice. - Use 'all' to calculate a full 2D envelope - theta : float, optional Only used for thetaMode geometry The angle of the plane of observation, with respect to the x axis - slicing_dir : str, optional - Only used for 3dcartesian geometry - The direction along which to slice the data - Either 'x', 'y' + slice_across : str or list of str, optional + Direction(s) across which the data should be sliced + + In cartesian geometry, elements can be: + - 1d: 'z' + - 2d: 'x' and/or 'z' + - 3d: 'x' and/or 'y' and/or 'z' + + In cylindrical geometry, elements can be 'r' and/or 'z' + Returned array is reduced by 1 dimension per slicing. + If slice_across is None, the full grid is returned. + Default is None. + + slice_relative_position : float or list of float, optional + Number(s) between -1 and 1 that indicate where to slice the data, + along the directions in `slice_across` + -1 : lower edge of the simulation box + 0 : middle of the simulation box + 1 : upper edge of the simulation box + Default is 0. plot : bool, optional Whether to plot the requested quantity + plot_range : list of lists + A list containing 2 lists of 2 elements each + Indicates the values between which to clip the plot, + along the 1st axis (first list) and 2nd axis (second list) + Default: plots the full extent of the simulation box + **kw : dict, otional Additional options to be passed to matplotlib's `plot`(1D) or `imshow` (2D) method @@ -499,47 +517,56 @@ def get_laser_envelope( self, t=None, iteration=None, pol=None, m='all', - A FieldMetaInformation object """ # Check if polarization has been entered - if pol is None: + if pol not in ['x', 'y']: raise ValueError('The `pol` argument is missing or erroneous.') - # Get field data - field = self.get_field( t=t, iteration=iteration, field='E', - coord=pol, theta=theta, m=m, - slicing_dir=slicing_dir ) - info = field[1] - if index == 'all': - # Filter the full 2D array - e_complx = hilbert(field[0], axis=1) - elif index == 'center': - # Filter the central slice (1D array) - field_slice = field[0][int( field[0].shape[0] / 2), :] - e_complx = hilbert(field_slice) - else: - # Filter the requested slice (2D array) - field_slice = field[0][index, :] - e_complx = hilbert(field_slice) + + # Prevent slicing across z, when extracting the raw electric field + # (z axis is needed for calculation of envelope) + # but record whether the user asked for slicing across z, + # and whether a corresponding `slice_relative_position` coordinate + # along z was given, so as to perform this slicing later in this function. + slicing_coord_z = None + if slice_across is not None: + slice_across, slice_relative_position = \ + sanitize_slicing(slice_across, slice_relative_position) + if 'z' in slice_across: + index_slicing_z = slice_across.index('z') + slice_across.pop(index_slicing_z) + slicing_coord_z = slice_relative_position.pop(index_slicing_z) + # Get field data, and perform Hilbert transform + field, info = self.get_field( t=t, iteration=iteration, field='E', + coord=pol, theta=theta, m=m, + slice_across=slice_across, + slice_relative_position=slice_relative_position ) + e_complx = hilbert(field, axis=-1) envelope = np.abs(e_complx) - # Restrict the metainformation to 1d if needed - if index != 'all': - info.restrict_to_1Daxis( info.axes[1] ) + # If the user asked for slicing along z, do it now + if slicing_coord_z is not None: + inverted_axes_dict = {info.axes[key]: key for key in info.axes.keys()} + slicing_index = inverted_axes_dict['z'] + coord_array = getattr( info, 'z' ) + # Number of cells along the slicing direction + n_cells = len(coord_array) + # Index of the slice (prevent stepping out of the array) + i_cell = int( 0.5 * (slicing_coord_z + 1.) * n_cells ) + i_cell = max( i_cell, 0 ) + i_cell = min( i_cell, n_cells - 1) + envelope = np.take( envelope, [i_cell], axis=slicing_index ) + envelope = np.squeeze(envelope) + # Remove the sliced labels from the FieldMetaInformation + info._remove_axis('z') # Plot the result if needed if plot: - check_matplotlib() - iteration = self.iterations[ self._current_i ] - time_fs = 1.e15 * self.t[ self._current_i ] - if index != 'all': - plt.plot( 1.e6 * info.z, envelope, **kw) - plt.ylabel('$E_%s \;(V/m)$' % pol, - fontsize=self.plotter.fontsize) - else: - plt.imshow( envelope, extent=1.e6 * info.imshow_extent, - aspect='auto', **kw) - plt.colorbar() - plt.ylabel('$%s \;(\mu m)$' % pol, - fontsize=self.plotter.fontsize) - plt.title("Laser envelope at %.1f fs (iteration %d)" - % (time_fs, iteration ), fontsize=self.plotter.fontsize) - plt.xlabel('$z \;(\mu m)$', fontsize=self.plotter.fontsize) + geometry = self.fields_metadata['E']['geometry'] + field_label = 'E%s (envelope)' %pol + if envelope.ndim == 1: + self.plotter.show_field_1d(envelope, info, field_label, + self._current_i, plot_range=plot_range, **kw) + elif envelope.ndim == 2: + self.plotter.show_field_2d(envelope, info, slice_across, m, + field_label, geometry, self._current_i, + plot_range=plot_range, **kw) # Return the result return( envelope, info ) @@ -637,19 +664,12 @@ def get_spectrum( self, t=None, iteration=None, pol=None, # Check if polarization has been entered if pol not in ['x', 'y']: raise ValueError('The `pol` argument is missing or erroneous.') - if pol == 'x': - slicing_dir = 'y' - theta = 0 - else: - slicing_dir = 'x' - theta = np.pi / 2. + # Get a lineout along the 'z' axis, + slice_across = self._get_slicing_for_longitudinal_lineout() # Get field data - field, info = self.get_field( t=t, iteration=iteration, field='E', - coord=pol, theta=theta, m=m, - slicing_dir=slicing_dir ) - # Get central field lineout - field1d = field[ int( field.shape[0] / 2 ), :] + field1d, info = self.get_field( t=t, iteration=iteration, field='E', + coord=pol, m=m, slice_across=slice_across ) # FFT of 1d data dt = (info.z[1] - info.z[0]) / const.c # Integration step for the FFT fft_field = np.fft.fft(field1d) * dt @@ -665,13 +685,13 @@ def get_spectrum( self, t=None, iteration=None, pol=None, if plot: check_matplotlib() iteration = self.iterations[ self._current_i ] - time_fs = 1.e15 * self.t[ self._current_i ] + time_s = self.t[ self._current_i ] plt.plot( spect_info.omega, spectrum, **kw ) plt.xlabel('$\omega \; (rad.s^{-1})$', fontsize=self.plotter.fontsize ) plt.ylabel('Spectrum', fontsize=self.plotter.fontsize ) - plt.title("Spectrum at %.1f fs (iteration %d)" - % (time_fs, iteration ), fontsize=self.plotter.fontsize) + plt.title("Spectrum at %.2e s (iteration %d)" + % (time_s, iteration ), fontsize=self.plotter.fontsize) return( spectrum, spect_info ) def get_a0( self, t=None, iteration=None, pol=None ): @@ -696,19 +716,12 @@ def get_a0( self, t=None, iteration=None, pol=None ): ------- Float with normalized vector potential a0 """ - if pol not in ['x', 'y']: - raise ValueError('The `pol` argument is missing or erroneous.') + # Get a lineout along the 'z' axis, + slice_across = self._get_slicing_for_longitudinal_lineout() - if pol == 'x': - slicing_dir = 'y' - theta = 0 - else: - slicing_dir = 'x' - theta = np.pi / 2. # Get the peak field from field envelope Emax = np.amax(self.get_laser_envelope(t=t, iteration=iteration, - pol=pol, theta=theta, - slicing_dir=slicing_dir)[0]) + pol=pol, slice_across=slice_across)[0]) # Get mean frequency omega = self.get_main_frequency(t=t, iteration=iteration, pol=pol) # Calculate a0 @@ -744,18 +757,12 @@ def get_ctau( self, t=None, iteration=None, pol=None, method='fit' ): ------- Float with ctau in meters """ - if pol not in ['x', 'y']: - raise ValueError('The `pol` argument is missing or erroneous.') - if pol == 'x': - slicing_dir = 'y' - theta = 0 - else: - slicing_dir = 'x' - theta = np.pi / 2. + # Get a lineout along the 'z' axis, + slice_across = self._get_slicing_for_longitudinal_lineout() + # Get the field envelope E, info = self.get_laser_envelope(t=t, iteration=iteration, - pol=pol, theta=theta, - slicing_dir=slicing_dir) + pol=pol, slice_across=slice_across) # Calculate ctau with RMS value ctau = np.sqrt(2) * w_std(info.z, E) if method == 'rms': @@ -775,10 +782,13 @@ def get_ctau( self, t=None, iteration=None, pol=None, method='fit' ): raise ValueError('Unknown method: {:s}'.format(method)) def get_laser_waist( self, t=None, iteration=None, pol=None, theta=0, - slicing_dir='y', method='fit' ): + method='fit' ): """ Calculate the waist of a (gaussian) laser pulse. ( sqrt(2) * sigma_r) + In 3D, this function takes a slice across `y`, and thus computes the + waist in the `x-z` plane. + Parameters ---------- t : float (in seconds), optional @@ -797,11 +807,6 @@ def get_laser_waist( self, t=None, iteration=None, pol=None, theta=0, Only used for thetaMode geometry The angle of the plane of observation, with respect to the x axis - slicing_dir : str, optional - Only used for 3dcartesian geometry - The direction along which to slice the data - Either 'x', 'y' - method : str, optional The method which is used to compute the waist 'fit': Gaussian fit of the transverse profile @@ -812,11 +817,17 @@ def get_laser_waist( self, t=None, iteration=None, pol=None, theta=0, ------- Float with laser waist in meters """ - # Get the field envelope + # In 3D, slice across 'y' by default + geometry = self.fields_metadata['E']['geometry'] + if geometry == '3dcartesian': + slice_across = 'y' + else: + slice_across = None + + # Get the field envelope (as 2D array) field, info = self.get_laser_envelope(t=t, iteration=iteration, - pol=pol, index='all', - slicing_dir=slicing_dir, - theta=theta) + pol=pol, slice_across=slice_across, theta=theta) + assert field.ndim == 2 # Find the indices of the maximum field, and # pick the corresponding transverse slice itrans_max, iz_max = np.unravel_index( @@ -845,8 +856,8 @@ def get_laser_waist( self, t=None, iteration=None, pol=None, theta=0, else: raise ValueError('Unknown method: {:s}'.format(method)) - def get_spectrogram( self, t=None, iteration=None, pol=None, theta=0, - slicing_dir='y', plot=False, **kw ): + def get_spectrogram( self, t=None, iteration=None, pol=None, + plot=False, **kw ): """ Calculates the spectrogram of a laserpulse, by the FROG method. @@ -884,14 +895,15 @@ def get_spectrogram( self, t=None, iteration=None, pol=None, theta=0, - info : a FieldMetaInformation object (see the corresponding docstring) """ + # Get a lineout along the 'z' axis + slice_across = self._get_slicing_for_longitudinal_lineout() + # Get the field envelope - env, _ = self.get_laser_envelope(t=t, iteration=iteration, pol=pol) + env, _ = self.get_laser_envelope(t=t, iteration=iteration, + pol=pol, slice_across=slice_across) # Get the field E, info = self.get_field( t=t, iteration=iteration, field='E', - coord=pol, theta=theta, - slicing_dir=slicing_dir ) - # Get central slice - E = E[ int(E.shape[0] / 2), :] + coord=pol, slice_across=slice_across) Nz = len(E) # Get time domain of the data tmin = info.zmin / const.c @@ -929,17 +941,33 @@ def get_spectrogram( self, t=None, iteration=None, pol=None, theta=0, if plot: check_matplotlib() iteration = self.iterations[ self._current_i ] - time_fs = 1.e15 * self.t[ self._current_i ] + time_s = self.t[ self._current_i ] plt.imshow( spectrogram, extent=info.imshow_extent, aspect='auto', **kw) - plt.title("Spectrogram at %.1f fs (iteration %d)" - % (time_fs, iteration ), fontsize=self.plotter.fontsize) + plt.title("Spectrogram at %.2e s (iteration %d)" + % (time_s, iteration ), fontsize=self.plotter.fontsize) plt.xlabel('$t \;(s)$', fontsize=self.plotter.fontsize ) plt.ylabel('$\omega \;(rad.s^{-1})$', fontsize=self.plotter.fontsize ) return( spectrogram, info ) + def _get_slicing_for_longitudinal_lineout(self): + """ + Return the `slice_across` argument which results in a 1D slice + along `z`, for the current geometry. + """ + geometry = self.fields_metadata['E']['geometry'] + if geometry == "2dcartesian": + return 'x' + elif geometry == "3dcartesian": + return ['x', 'y'] + elif geometry == "thetaMode": + return 'r' + else: + raise ValueError('Unknown geometry: %s' %geometry) + + def w_ave( a, weights ): """ Calculate the weighted average of array `a` diff --git a/opmd_viewer/notebook_starter/Template_notebook.ipynb b/openpmd_viewer/notebook_starter/Template_notebook.ipynb similarity index 96% rename from opmd_viewer/notebook_starter/Template_notebook.ipynb rename to openpmd_viewer/notebook_starter/Template_notebook.ipynb index 7906bb3c..e41fa675 100644 --- a/opmd_viewer/notebook_starter/Template_notebook.ipynb +++ b/openpmd_viewer/notebook_starter/Template_notebook.ipynb @@ -20,7 +20,7 @@ "# or `%matplotlib inline` for non-interactive plots\n", "# or `%matplotlib widget` when using JupyterLab (github.com/matplotlib/jupyter-matplotlib)\n", "import matplotlib.pyplot as plt\n", - "from opmd_viewer import OpenPMDTimeSeries" + "from openpmd_viewer import OpenPMDTimeSeries" ] }, { diff --git a/opmd_viewer/notebook_starter/openPMD_notebook b/openpmd_viewer/notebook_starter/openPMD_notebook similarity index 94% rename from opmd_viewer/notebook_starter/openPMD_notebook rename to openpmd_viewer/notebook_starter/openPMD_notebook index 57883b0e..3be388ea 100755 --- a/opmd_viewer/notebook_starter/openPMD_notebook +++ b/openpmd_viewer/notebook_starter/openPMD_notebook @@ -12,7 +12,7 @@ from pkg_resources import resource_string # Use pkg_resources to retrieve the location and contents # of the pre-existing template notebook -notebook_text = resource_string('opmd_viewer', +notebook_text = resource_string('openpmd_viewer', 'notebook_starter/Template_notebook.ipynb') # Create a new notebook in the local directory and copy diff --git a/opmd_viewer/openpmd_timeseries/__init__.py b/openpmd_viewer/openpmd_timeseries/__init__.py similarity index 100% rename from opmd_viewer/openpmd_timeseries/__init__.py rename to openpmd_viewer/openpmd_timeseries/__init__.py diff --git a/opmd_viewer/openpmd_timeseries/data_reader/__init__.py b/openpmd_viewer/openpmd_timeseries/data_reader/__init__.py similarity index 100% rename from opmd_viewer/openpmd_timeseries/data_reader/__init__.py rename to openpmd_viewer/openpmd_timeseries/data_reader/__init__.py diff --git a/opmd_viewer/openpmd_timeseries/data_reader/field_metainfo.py b/openpmd_viewer/openpmd_timeseries/data_reader/field_metainfo.py similarity index 73% rename from opmd_viewer/openpmd_timeseries/data_reader/field_metainfo.py rename to openpmd_viewer/openpmd_timeseries/data_reader/field_metainfo.py index 8d8f3cde..e6b75e5c 100644 --- a/opmd_viewer/openpmd_timeseries/data_reader/field_metainfo.py +++ b/openpmd_viewer/openpmd_timeseries/data_reader/field_metainfo.py @@ -46,6 +46,7 @@ class FieldMetaInformation(object): then these variables will be called x, y. - imshow_extent: 1darray + (Only for 2D data) An array of 4 elements that can be passed as the `extent` in matplotlib's imshow function. Because of the API of the imshow function, the coordinates are @@ -67,7 +68,6 @@ def __init__(self, axes, shape, grid_spacing, """ # Register important initial information self.axes = axes - self.imshow_extent = [] # Create the elements for axis in sorted(axes.keys()): @@ -77,27 +77,19 @@ def __init__(self, axes, shape, grid_spacing, start = global_offset[axis] * grid_unitSI + position[axis] * step end = start + (n_points - 1) * step axis_points = np.linspace(start, end, n_points, endpoint=True) + # Create the points below the axis if thetaMode is true + if axes[axis] == 'r' and thetaMode: + axis_points = np.concatenate((-axis_points[::-1], axis_points)) + start = -end # Register the results in the object axis_name = axes[axis] setattr(self, axis_name, axis_points) setattr(self, 'd' + axis_name, step) setattr(self, axis_name + 'min', axis_points[0]) setattr(self, axis_name + 'max', axis_points[-1]) - # Fill the imshow_extent in reverse order, so as to match - # the syntax of imshow ; add a half step on each side since - # imshow plots a square of finite width for each field value - self.imshow_extent = \ - [start - 0.5 * step, end + 0.5 * step] + self.imshow_extent - - # Create the points below the axis if thetaMode is true - if thetaMode: - self.r = np.concatenate((-self.r[::-1], self.r)) - # The axis now extends from -rmax to rmax - self.rmin = -self.rmax - self.imshow_extent[2] = -self.imshow_extent[3] - - # Finalize imshow_extent by converting it from list to array - self.imshow_extent = np.array(self.imshow_extent) + + self._generate_imshow_extent() + def restrict_to_1Daxis(self, axis): """ @@ -115,15 +107,46 @@ def restrict_to_1Daxis(self, axis): 'that are present in this object.') # Loop through the coordinates and suppress them - for obsolete_axis in self.axes.values(): + for obsolete_axis in list(self.axes.values()): if obsolete_axis != axis: - delattr(self, obsolete_axis) - delattr(self, obsolete_axis + 'min') - delattr(self, obsolete_axis + 'max') + self._remove_axis(obsolete_axis) + + + def _generate_imshow_extent(self): + """ + Generate the list `imshow_extent`, which can be used directly + as the argument `extent` of matplotlib's `imshow` command + """ + if len(self.axes) == 2: + self.imshow_extent = [] + for label in [self.axes[1], self.axes[0]]: + coord_min = getattr( self, label+'min' ) + coord_max = getattr( self, label+'max' ) + coord_step = getattr( self, 'd'+label ) + self.imshow_extent += [ coord_min - 0.5*coord_step, + coord_max + 0.5*coord_step ] + self.imshow_extent = np.array(self.imshow_extent) + else: + if hasattr(self, 'imshow_extent'): + delattr(self, 'imshow_extent') + + + def _remove_axis(self, obsolete_axis): + """ + Remove the axis `obsolete_axis` from the MetaInformation object + """ + delattr(self, obsolete_axis) + delattr(self, obsolete_axis + 'min') + delattr(self, obsolete_axis + 'max') + # Rebuild the dictionary `axes`, by including the axis + # label in the same order, but omitting obsolete_axis + ndim = len(self.axes) + self.axes = dict( enumerate([ + self.axes[i] for i in range(ndim) \ + if self.axes[i] != obsolete_axis ])) + + self._generate_imshow_extent() - # Suppress imshow_extent and replace the dictionary - delattr(self, 'imshow_extent') - self.axes = {0: axis} def _convert_cylindrical_to_3Dcartesian(self): """ diff --git a/opmd_viewer/openpmd_timeseries/data_reader/field_reader.py b/openpmd_viewer/openpmd_timeseries/data_reader/field_reader.py similarity index 69% rename from opmd_viewer/openpmd_timeseries/data_reader/field_reader.py rename to openpmd_viewer/openpmd_timeseries/data_reader/field_reader.py index 465efa63..ceb005fa 100644 --- a/opmd_viewer/openpmd_timeseries/data_reader/field_reader.py +++ b/openpmd_viewer/openpmd_timeseries/data_reader/field_reader.py @@ -14,10 +14,11 @@ from .field_metainfo import FieldMetaInformation from ..utilities import construct_3d_from_circ -def read_field_1d( filename, field_path, axis_labels ): +def read_field_cartesian( filename, field_path, axis_labels, + slice_relative_position, slice_across ): """ Extract a given field from an HDF5 file in the openPMD format, - when the geometry is 1d cartesian. + when the geometry is cartesian (1d, 2d or 3d). Parameters ---------- @@ -26,15 +27,30 @@ def read_field_1d( filename, field_path, axis_labels ): field_path : string The relative path to the requested field, from the openPMD meshes path - (e.g. 'rho', 'E/r', 'B/x') + (e.g. 'rho', 'E/z', 'B/x') axis_labels: list of strings The name of the dimensions of the array (e.g. ['x', 'y', 'z']) + slice_across : list of str or None + Direction(s) across which the data should be sliced + Elements can be: + - 1d: 'z' + - 2d: 'x' and/or 'z' + - 3d: 'x' and/or 'y' and/or 'z' + Returned array is reduced by 1 dimension per slicing. + + slice_relative_position : list of float or None + Number(s) between -1 and 1 that indicate where to slice the data, + along the directions in `slice_across` + -1 : lower edge of the simulation box + 0 : middle of the simulation box + 1 : upper edge of the simulation box + Returns ------- A tuple with - F : a 1darray containing the required field + F : a ndarray containing the required field info : a FieldMetaInformation object (contains information about the grid; see the corresponding docstring) """ @@ -43,64 +59,57 @@ def read_field_1d( filename, field_path, axis_labels ): # Extract the dataset and and corresponding group group, dset = find_dataset( dfile, field_path ) - # Extract the data in 1D Cartesian - F = get_data( dset ) - - # Extract the metainformation - axes = { 0: axis_labels[0]} - info = FieldMetaInformation( axes, F.shape, - group.attrs['gridSpacing'], group.attrs['gridGlobalOffset'], - group.attrs['gridUnitSI'], dset.attrs['position'] ) - - # Close the file - dfile.close() - return( F, info ) - - -def read_field_2d( filename, field_path, axis_labels ): - """ - Extract a given field from an HDF5 file in the openPMD format, - when the geometry is 2d cartesian. - - Parameters - ---------- - filename : string - The absolute path to the HDF5 file - - field_path : string - The relative path to the requested field, from the openPMD meshes path - (e.g. 'rho', 'E/r', 'B/x') - - axis_labels: list of strings - The name of the dimensions of the array (e.g. ['x', 'y', 'z']) + # Dimensions of the grid + shape = list( get_shape( dset ) ) + grid_spacing = list( group.attrs['gridSpacing'] ) + global_offset = list( group.attrs['gridGlobalOffset'] ) - Returns - ------- - A tuple with - F : a 2darray containing the required field - info : a FieldMetaInformation object - (contains information about the grid; see the corresponding docstring) - """ - # Open the HDF5 file - dfile = h5py.File( filename, 'r' ) - # Extract the dataset and and corresponding group - group, dset = find_dataset( dfile, field_path ) + # Slice selection + if slice_across is not None: + # Get the integer that correspond to the slicing direction + list_slicing_index = [] + list_i_cell = [] + for count, slice_across_item in enumerate(slice_across): + slicing_index = axis_labels.index(slice_across_item) + list_slicing_index.append(slicing_index) + # Number of cells along the slicing direction + n_cells = shape[ slicing_index ] + # Index of the slice (prevent stepping out of the array) + i_cell = int( 0.5 * (slice_relative_position[count] + 1.) * n_cells ) + i_cell = max( i_cell, 0 ) + i_cell = min( i_cell, n_cells - 1) + list_i_cell.append(i_cell) - # Extract the data in 2D Cartesian - F = get_data( dset ) + # Remove metainformation relative to the slicing index + # Successive pops starting from last coordinate to slice + shape = [ x for index, x in enumerate(shape) + if index not in list_slicing_index ] + grid_spacing = [ x for index, x in enumerate(grid_spacing) + if index not in list_slicing_index ] + global_offset = [ x for index, x in enumerate(global_offset) + if index not in list_slicing_index ] + axis_labels = [ x for index, x in enumerate(axis_labels) + if index not in list_slicing_index ] - # Extract the metainformation - axes = { 0: axis_labels[0], 1: axis_labels[1] } - info = FieldMetaInformation( axes, F.shape, - group.attrs['gridSpacing'], group.attrs['gridGlobalOffset'], - group.attrs['gridUnitSI'], dset.attrs['position'] ) + axes = { i: axis_labels[i] for i in range(len(axis_labels)) } + # Extract data + F = get_data( dset, list_i_cell, list_slicing_index ) + info = FieldMetaInformation( axes, shape, grid_spacing, global_offset, + group.attrs['gridUnitSI'], dset.attrs['position'] ) + else: + F = get_data( dset ) + axes = { i: axis_labels[i] for i in range(len(axis_labels)) } + info = FieldMetaInformation( axes, F.shape, + group.attrs['gridSpacing'], group.attrs['gridGlobalOffset'], + group.attrs['gridUnitSI'], dset.attrs['position'] ) # Close the file dfile.close() return( F, info ) -def read_field_circ( filename, field_path, m=0, theta=0. ): +def read_field_circ( filename, field_path, slice_relative_position, + slice_across, m=0, theta=0. ): """ Extract a given field from an HDF5 file in the openPMD format, when the geometry is thetaMode @@ -123,6 +132,18 @@ def read_field_circ( filename, field_path, m=0, theta=0. ): corresponding to the plane of observation given by `theta` ; otherwise it returns a full 3D Cartesian array + slice_across : list of str or None + Direction(s) across which the data should be sliced + Elements can be 'r' and/or 'z' + Returned array is reduced by 1 dimension per slicing. + + slice_relative_position : list of float or None + Number(s) between -1 and 1 that indicate where to slice the data, + along the directions in `slice_across` + -1 : lower edge of the simulation box + 0 : middle of the simulation box + 1 : upper edge of the simulation box + Returns ------- A tuple with @@ -201,91 +222,29 @@ def read_field_circ( filename, field_path, m=0, theta=0. ): F_total[Nr:, :] = F[:, :] F_total[:Nr, :] = (-1) ** m * F[::-1, :] - # Close the file - dfile.close() - return( F_total, info ) - - -def read_field_3d( filename, field_path, axis_labels, - slicing=0., slicing_dir='y'): - """ - Extract a given field from an HDF5 file in the openPMD format, - when the geometry is 3d cartesian. - - Parameters - ---------- - filename : string - The absolute path to the HDF5 file - - field_path : string - The relative path to the requested field, from the openPMD meshes path - (e.g. 'rho', 'E/r', 'B/x') - - axis_labels: list of strings - The name of the dimensions of the array (e.g. ['x', 'y', 'z']) - - slicing : float, optional - Only used for 3dcartesian geometry - A number between -1 and 1 that indicates where to slice the data, - along the direction `slicing_dir` - -1 : lower edge of the simulation box - 0 : middle of the simulation box - 1 : upper edge of the simulation box - If slicing is None, the full 3D grid is returned. - - slicing_dir : str, optional - Only used for 3dcartesian geometry - The direction along which to slice the data - Either 'x', 'y' or 'z' - - Returns - ------- - A tuple with - F : a 3darray or 2darray containing the required field, - depending on whether `slicing` is None or not - info : a FieldMetaInformation object - (contains information about the grid; see the corresponding docstring) - """ - # Open the HDF5 file - dfile = h5py.File( filename, 'r' ) - # Extract the dataset and and corresponding group - group, dset = find_dataset( dfile, field_path ) - - # Dimensions of the grid - shape = list( get_shape( dset ) ) - grid_spacing = list( group.attrs['gridSpacing'] ) - global_offset = list( group.attrs['gridGlobalOffset'] ) - # Slice selection - if slicing is not None: - # Get the integer that correspond to the slicing direction - slicing_index = axis_labels.index(slicing_dir) - # Number of cells along the slicing direction - n_cells = shape[ slicing_index ] - # Index of the slice (prevent stepping out of the array) - i_cell = int( 0.5 * (slicing + 1.) * n_cells ) - i_cell = max( i_cell, 0 ) - i_cell = min( i_cell, n_cells - 1) - # Remove metainformation relative to the slicing index - shape.pop( slicing_index ) - grid_spacing.pop( slicing_index ) - global_offset.pop( slicing_index ) - new_labels = axis_labels[:slicing_index] + \ - axis_labels[slicing_index + 1:] - axes = { i: new_labels[i] for i in range(len(new_labels)) } - # Extraction of the data - F = get_data( dset, i_cell, slicing_index ) - info = FieldMetaInformation( axes, shape, grid_spacing, global_offset, - group.attrs['gridUnitSI'], dset.attrs['position'] ) - else: - F = get_data( dset ) - axes = { i: axis_labels[i] for i in range(len(axis_labels)) } - info = FieldMetaInformation( axes, F.shape, - group.attrs['gridSpacing'], group.attrs['gridGlobalOffset'], - group.attrs['gridUnitSI'], dset.attrs['position'] ) + # Perform slicing if needed + if slice_across is not None: + # Slice field and clear metadata + inverted_axes_dict = {info.axes[key]: key for key in info.axes.keys()} + for count, slice_across_item in enumerate(slice_across): + slicing_index = inverted_axes_dict[slice_across_item] + coord_array = getattr( info, slice_across_item ) + # Number of cells along the slicing direction + n_cells = len(coord_array) + # Index of the slice (prevent stepping out of the array) + i_cell = int( 0.5 * (slice_relative_position[count] + 1.) * n_cells ) + i_cell = max( i_cell, 0 ) + i_cell = min( i_cell, n_cells - 1) + F_total = np.take( F_total, [i_cell], axis=slicing_index ) + F_total = np.squeeze(F_total) + # Remove the sliced labels from the FieldMetaInformation + for slice_across_item in slice_across: + info._remove_axis(slice_across_item) # Close the file dfile.close() - return( F, info ) + + return( F_total, info ) def find_dataset( dfile, field_path ): diff --git a/opmd_viewer/openpmd_timeseries/data_reader/params_reader.py b/openpmd_viewer/openpmd_timeseries/data_reader/params_reader.py similarity index 100% rename from opmd_viewer/openpmd_timeseries/data_reader/params_reader.py rename to openpmd_viewer/openpmd_timeseries/data_reader/params_reader.py diff --git a/opmd_viewer/openpmd_timeseries/data_reader/particle_reader.py b/openpmd_viewer/openpmd_timeseries/data_reader/particle_reader.py similarity index 95% rename from opmd_viewer/openpmd_timeseries/data_reader/particle_reader.py rename to openpmd_viewer/openpmd_timeseries/data_reader/particle_reader.py index 0ecf9f6f..85afcd4e 100644 --- a/opmd_viewer/openpmd_timeseries/data_reader/particle_reader.py +++ b/openpmd_viewer/openpmd_timeseries/data_reader/particle_reader.py @@ -18,8 +18,6 @@ def read_species_data(file_handle, species, record_comp, extensions): """ Extract a given species' record_comp - In the case of positions, the result is returned in microns - Parameters ---------- file_handle: h5py.File object @@ -73,11 +71,10 @@ def read_species_data(file_handle, species, record_comp, extensions): w = get_data( species_grp[ 'weighting' ] ) data *= w ** (-weighting_power) - # - Return positions in microns, with an offset + # - Return positions, with an offset if record_comp in ['x', 'y', 'z']: offset = get_data(species_grp['positionOffset/%s' % record_comp]) data += offset - data *= 1.e6 # - Return momentum in normalized units elif record_comp in ['ux', 'uy', 'uz' ]: m = get_data(species_grp['mass']) diff --git a/opmd_viewer/openpmd_timeseries/data_reader/utilities.py b/openpmd_viewer/openpmd_timeseries/data_reader/utilities.py similarity index 72% rename from opmd_viewer/openpmd_timeseries/data_reader/utilities.py rename to openpmd_viewer/openpmd_timeseries/data_reader/utilities.py index 97dcc6a9..467f734f 100644 --- a/opmd_viewer/openpmd_timeseries/data_reader/utilities.py +++ b/openpmd_viewer/openpmd_timeseries/data_reader/utilities.py @@ -59,12 +59,12 @@ def get_data(dset, i_slice=None, pos_slice=None, output_type=np.float64): dset: an h5py.Dataset or h5py.Group (when constant) The object from which the data is extracted - i_slice: int, optional - The index of the slice to be taken + pos_slice: int or list of int, optional + Slice direction(s). + When None, no slicing is performed - pos_slice: int, optional - The position at which to slice the array - When None, no slice is performed + i_slice: int or list of int, optional + Indices of slices to be taken. output_type: a numpy type The type to which the returned array should be converted @@ -73,24 +73,41 @@ def get_data(dset, i_slice=None, pos_slice=None, output_type=np.float64): -------- An np.ndarray (non-constant dataset) or a single double (constant dataset) """ + # For back-compatibility: Convert pos_slice and i_slice to + # single-element lists if they are not lists (e.g. float + # and int respectively). + if pos_slice is not None and not isinstance(pos_slice, list): + pos_slice = [pos_slice] + if i_slice is not None and not isinstance(i_slice, list): + i_slice = [i_slice] # Case of a constant dataset if isinstance(dset, h5py.Group): shape = dset.attrs['shape'] # Restrict the shape if slicing is enabled if pos_slice is not None: - shape = shape[:pos_slice] + shape[pos_slice + 1:] + shape = [ x for index, x in enumerate(shape) if + index not in pos_slice ] # Create the corresponding dataset data = dset.attrs['value'] * np.ones(shape) + # Case of a non-constant dataset elif isinstance(dset, h5py.Dataset): if pos_slice is None: data = dset[...] - elif pos_slice == 0: - data = dset[i_slice, ...] - elif pos_slice == 1: - data = dset[:, i_slice, ...] - elif pos_slice == 2: - data = dset[:, :, i_slice] + else: + # Get largest element of pos_slice + max_pos = max(pos_slice) + # Create list of indices list_index of type + # [:, :, :, ...] where Ellipsis starts at max_pos + 1 + list_index = [np.s_[:]] * (max_pos + 2) + list_index[max_pos + 1] = np.s_[...] + # Fill list_index with elements of i_slice + for count, dir_index in enumerate(pos_slice): + list_index[dir_index] = i_slice[count] + # Convert list_index into a tuple + tuple_index = tuple(list_index) + # Slice dset according to tuple_index + data = dset[tuple_index] # Convert to the right type if data.dtype != output_type: diff --git a/opmd_viewer/openpmd_timeseries/interactive.py b/openpmd_viewer/openpmd_timeseries/interactive.py similarity index 93% rename from opmd_viewer/openpmd_timeseries/interactive.py rename to openpmd_viewer/openpmd_timeseries/interactive.py index e3a7e4c7..9b546755 100644 --- a/opmd_viewer/openpmd_timeseries/interactive.py +++ b/openpmd_viewer/openpmd_timeseries/interactive.py @@ -111,13 +111,19 @@ def refresh_field(change=None, force=False): plot_range = [ fld_hrange_button.get_range(), fld_vrange_button.get_range() ] + # Handle slicing direction + if slice_across_button.value == 'None': + slice_across = None + else: + slice_across = slice_across_button.value + # Call the method get_field - self.get_field( iteration=self.current_iteration, - output=False, plot=True, + self.get_field( iteration=self.current_iteration, plot=True, field=fieldtype_button.value, coord=coord_button.value, m=convert_to_int(mode_button.value), - slicing=slicing_button.value, theta=theta_button.value, - slicing_dir=slicing_dir_button.value, + slice_relative_position=slicing_button.value, + theta=theta_button.value, + slice_across=slice_across, plot_range=plot_range, **kw_fld ) def refresh_ptcl(change=None, force=False): @@ -164,7 +170,7 @@ def refresh_ptcl(change=None, force=False): if ptcl_yaxis_button.value == 'None': # 1D histogram self.get_particle( iteration=self.current_iteration, - output=False, var_list=[ptcl_xaxis_button.value], + var_list=[ptcl_xaxis_button.value], select=ptcl_select_widget.to_dict(), species=ptcl_species_button.value, plot=True, nbins=ptcl_bins_button.value, @@ -173,8 +179,8 @@ def refresh_ptcl(change=None, force=False): else: # 2D histogram self.get_particle( iteration=self.current_iteration, - output=False, var_list=[ptcl_xaxis_button.value, - ptcl_yaxis_button.value], + var_list=[ptcl_xaxis_button.value, + ptcl_yaxis_button.value], select=ptcl_select_widget.to_dict(), species=ptcl_species_button.value, plot=True, nbins=ptcl_bins_button.value, @@ -193,6 +199,11 @@ def refresh_field_type(change): whenever a change of a widget happens (see docstring of ipywidgets.Widget.observe) """ + # Deactivate the field refreshing to avoid callback + # while modifying the widgets + saved_refresh_value = fld_refresh_toggle.value + fld_refresh_toggle.value = False + new_field = change['new'] # Activate/deactivate vector fields if self.fields_metadata[new_field]['type'] == 'vector': @@ -206,13 +217,19 @@ def refresh_field_type(change): else: mode_button.disabled = True theta_button.disabled = True - # Activate/deactivate 3d-specific widgets + # Activate the right slicing options if self.fields_metadata[new_field]['geometry'] == '3dcartesian': - slicing_dir_button.disabled = False - slicing_button.disabled = False + slice_across_button.options = \ + self.fields_metadata[new_field]['axis_labels'] + slice_across_button.value = 'y' else: - slicing_dir_button.disabled = True - slicing_button.disabled = True + slice_across_button.options = ['None'] + \ + self.fields_metadata[new_field]['axis_labels'] + slice_across_button.value = 'None' + + # Put back the previous value of the refreshing button + fld_refresh_toggle.value = saved_refresh_value + # Show the fields refresh_field() @@ -337,10 +354,15 @@ def step_bw(b): min=-math.pi / 2, max=math.pi / 2) set_widget_dimensions( theta_button, width=190 ) theta_button.observe( refresh_field, 'value', 'change') - # Slicing buttons (for 3D) - slicing_dir_button = create_toggle_buttons( value='y', - options=['x', 'y', 'z'], description='Slice normal:') - slicing_dir_button.observe( refresh_field, 'value', 'change' ) + # Slicing buttons + axis_labels = self.fields_metadata[field]['axis_labels'] + if self.fields_metadata[field]['geometry'] == '3dcartesian': + slice_across_button = create_toggle_buttons( value='y', + options=axis_labels ) + else: + slice_across_button = create_toggle_buttons( value='None', + options=['None'] + axis_labels ) + slice_across_button.observe( refresh_field, 'value', 'change' ) slicing_button = widgets.FloatSlider( min=-1., max=1., value=0.) set_widget_dimensions( slicing_button, width=180 ) slicing_button.observe( refresh_field, 'value', 'change') @@ -371,16 +393,19 @@ def step_bw(b): # ---------- # Field type container field_widget_list = [fieldtype_button, coord_button] + container_fields = widgets.VBox( children=field_widget_list ) + set_widget_dimensions( container_fields, width=330 ) + # Slicing container + slices_widget_list = [ + add_description("Slice normal:", + slice_across_button, width=100), + add_description("Slicing position:", slicing_button) ] if "thetaMode" in self.avail_geom: # Add widgets specific to azimuthal modes - field_widget_list += [ mode_button, + slices_widget_list += [ mode_button, add_description('Theta:', theta_button)] - elif "3dcartesian" in self.avail_geom: - # Add widgets specific to cartesian 3d - field_widget_list += [ slicing_dir_button, - add_description("Slicing:", slicing_button) ] - container_fields = widgets.VBox( children=field_widget_list ) - set_widget_dimensions( container_fields, width=330 ) + container_slicing = widgets.VBox( children=slices_widget_list ) + set_widget_dimensions( container_slicing, width=330 ) # Plotting options container container_fld_cbar = fld_color_button.to_container() container_fld_hrange = fld_hrange_button.to_container() @@ -391,10 +416,11 @@ def step_bw(b): container_fld_hrange ]) set_widget_dimensions( container_fld_plots, width=330 ) # Accordion for the field widgets - accord1 = widgets.Accordion( - children=[container_fields, container_fld_plots]) + accord1 = widgets.Accordion( children=[container_fields, + container_slicing, container_fld_plots]) accord1.set_title(0, 'Field type') - accord1.set_title(1, 'Plotting options') + accord1.set_title(1, 'Slice selection') + accord1.set_title(2, 'Plotting options') # Complete field container container_fld = widgets.VBox( children=[accord1, widgets.HBox( children=[fld_refresh_toggle, fld_refresh_button])]) diff --git a/opmd_viewer/openpmd_timeseries/main.py b/openpmd_viewer/openpmd_timeseries/main.py similarity index 82% rename from opmd_viewer/openpmd_timeseries/main.py rename to openpmd_viewer/openpmd_timeseries/main.py index ea0e0072..ca1bd747 100644 --- a/opmd_viewer/openpmd_timeseries/main.py +++ b/openpmd_viewer/openpmd_timeseries/main.py @@ -10,14 +10,16 @@ import numpy as np import h5py as h5 +from tqdm import tqdm from .utilities import list_h5_files, apply_selection, fit_bins_to_grid, \ - combine_cylindrical_components + combine_cylindrical_components, try_array, \ + sanitize_slicing from .plotter import Plotter from .particle_tracker import ParticleTracker from .data_reader.params_reader import read_openPMD_params from .data_reader.particle_reader import read_species_data -from .data_reader.field_reader import read_field_1d, read_field_2d, \ - read_field_circ, read_field_3d, get_grid_parameters +from .data_reader.field_reader import read_field_cartesian, \ + read_field_circ, get_grid_parameters from .data_reader.utilities import join_infile_path from .interactive import InteractiveViewer @@ -112,7 +114,7 @@ def __init__(self, path_to_dir, check_all_files=True): self.plotter = Plotter(self.t, self.iterations) def get_particle(self, var_list=None, species=None, t=None, iteration=None, - select=None, output=True, plot=False, nbins=150, + select=None, plot=False, nbins=150, plot_range=[[None, None], [None, None]], use_field_mesh=True, histogram_deposition='cic', **kw): """ @@ -123,7 +125,6 @@ def get_particle(self, var_list=None, species=None, t=None, iteration=None, If two quantities are requested by the user, this plots a 2d histogram of these quantities. - In the case of positions, the result is returned in microns In the case of momenta, the result is returned as: - unitless momentum (i.e. gamma*beta) for particles with non-zero mass - in kg.m.s^-1 for particles with zero mass @@ -147,13 +148,10 @@ def get_particle(self, var_list=None, species=None, t=None, iteration=None, The iteration at which to obtain the data Either `t` or `iteration` should be given by the user. - output : bool, optional - Whether to return the requested quantity - select: dict or ParticleTracker object, optional - If `select` is a dictionary: then it lists a set of rules to select the particles, of the form - 'x' : [-4., 10.] (Particles having x between -4 and 10 microns) + 'x' : [-4., 10.] (Particles having x between -4 and 10 meters) 'ux' : [-0.1, 0.1] (Particles having ux between -0.1 and 0.1 mc) 'uz' : [5., None] (Particles with uz above 5 mc) - If `select` is a ParticleTracker object: @@ -353,13 +351,12 @@ def get_particle(self, var_list=None, species=None, t=None, iteration=None, # Close the file file_handle.close() - # Output - if output: - return(data_list) + # Output the data + return(data_list) def get_field(self, field=None, coord=None, t=None, iteration=None, - m='all', theta=0., slicing=0., slicing_dir='y', - output=True, plot=False, + m='all', theta=0., slice_across=None, + slice_relative_position=None, plot=False, plot_range=[[None, None], [None, None]], **kw): """ Extract a given field from an HDF5 file in the openPMD format. @@ -396,22 +393,24 @@ def get_field(self, field=None, coord=None, t=None, iteration=None, corresponding to the plane of observation given by `theta` ; otherwise it returns a full 3D Cartesian array - slicing : float, optional - Only used for 3dcartesian geometry - A number between -1 and 1 that indicates where to slice the data, - along the direction `slicing_dir` + slice_across : str or list of str, optional + Direction(s) across which the data should be sliced + + In cartesian geometry, elements can be: + - 1d: 'z' + - 2d: 'x' and/or 'z' + - 3d: 'x' and/or 'y' and/or 'z' + + In cylindrical geometry, elements can be 'r' and/or 'z' + Returned array is reduced by 1 dimension per slicing. + If slicing is None, the full grid is returned. + + slice_relative_position : float or list of float, optional + Number(s) between -1 and 1 that indicate where to slice the data, + along the directions in `slice_across` -1 : lower edge of the simulation box 0 : middle of the simulation box 1 : upper edge of the simulation box - If slicing is None, the full 3D grid is returned. - - slicing_dir : str, optional - Only used for 3dcartesian geometry - The direction along which to slice the data - Either 'x', 'y' or 'z' - - output : bool, optional - Whether to return the requested quantity + Default: None, which results in slicing at 0 in all direction + of `slice_across`. plot : bool, optional Whether to plot the requested quantity @@ -442,6 +441,19 @@ def get_field(self, field=None, coord=None, t=None, iteration=None, "The `field` argument is missing or erroneous.\n" "The available fields are: \n - %s\nPlease set the `field` " "argument accordingly." % field_list) + # Check slicing + slice_across, slice_relative_position = \ + sanitize_slicing(slice_across, slice_relative_position) + if slice_across is not None: + # Check that the elements are valid + axis_labels = self.fields_metadata[field]['axis_labels'] + for axis in slice_across: + if axis not in axis_labels: + axes_list = '\n - '.join(axis_labels) + raise OpenPMDException( + 'The `slice_across` argument is erroneous: contains %s\n' + 'The available axes are: \n - %s' % (axis, axes_list) ) + # Check the coordinate (for vector fields) if self.fields_metadata[field]['type'] == 'vector': available_coord = ['x', 'y', 'z'] @@ -480,44 +492,95 @@ def get_field(self, field=None, coord=None, t=None, iteration=None, # Get the field data geometry = self.fields_metadata[field]['geometry'] axis_labels = self.fields_metadata[field]['axis_labels'] - # - For 1D - if geometry == "1dcartesian": - F, info = read_field_1d(filename, field_path, axis_labels) - # - For 2D - elif geometry == "2dcartesian": - F, info = read_field_2d(filename, field_path, axis_labels) - # - For 3D - elif geometry == "3dcartesian": - F, info = read_field_3d( - filename, field_path, axis_labels, slicing, slicing_dir) + # - For cartesian + if geometry in ["1dcartesian", "2dcartesian", "3dcartesian"]: + F, info = read_field_cartesian( filename, field_path, + axis_labels, slice_relative_position, slice_across) # - For thetaMode elif geometry == "thetaMode": if (coord in ['x', 'y']) and \ (self.fields_metadata[field]['type'] == 'vector'): # For Cartesian components, combine r and t components - Fr, info = read_field_circ(filename, field + '/r', m, theta) - Ft, info = read_field_circ(filename, field + '/t', m, theta) + Fr, info = read_field_circ(filename, field + '/r', + slice_relative_position, slice_across, m, theta) + Ft, info = read_field_circ(filename, field + '/t', + slice_relative_position, slice_across, m, theta) F = combine_cylindrical_components(Fr, Ft, theta, coord, info) else: # For cylindrical or scalar components, no special treatment - F, info = read_field_circ(filename, field_path, m, theta) + F, info = read_field_circ(filename, field_path, + slice_relative_position, slice_across, m, theta) # Plot the resulting field # Deactivate plotting when there is no slice selection - if (geometry == "3dcartesian") and (slicing is None): - plot = False if plot: - if geometry == "1dcartesian": + if F.ndim == 1: self.plotter.show_field_1d(F, info, field_label, self._current_i, plot_range=plot_range, **kw) + elif F.ndim == 2: + self.plotter.show_field_2d(F, info, slice_across, m, + field_label, geometry, self._current_i, + plot_range=plot_range, **kw) else: - self.plotter.show_field_2d(F, info, slicing_dir, m, - field_label, geometry, self._current_i, - plot_range=plot_range, **kw) + raise OpenPMDException('Cannot plot %d-dimensional data.\n' + 'Use the argument `slice_across`, or set `plot=False`' % F.ndim) # Return the result return(F, info) + def iterate( self, called_method, *args, **kwargs ): + """ + Repeated calls the method `called_method` for every iteration of this + timeseries, with the arguments `*args` and `*kwargs`. + + The result of these calls is returned as a list, or, whenever possible + as an array, where the first axis corresponds to the iterations. + + If `called_method` returns a tuple/list, then `iterate` returns a + tuple/list of lists (or arrays). + + Parameters + ---------- + *args, **kwargs: arguments and keyword arguments + Arguments that would normally be passed to `called_method` for + a single iteration. Do not pass the argument `t` or `iteration`. + """ + # Add the iteration key in the keyword aguments + kwargs['iteration'] = self.iterations[0] + + # Check the shape of results + result = called_method(*args, **kwargs) + result_type = type( result ) + if result_type in [tuple, list]: + returns_iterable = True + iterable_length = len(result) + accumulated_result = [ [element] for element in result ] + else: + returns_iterable = False + accumulated_result = [ result ] + + # Call the method for all iterations + for iteration in tqdm(self.iterations[1:]): + kwargs['iteration'] = iteration + result = called_method( *args, **kwargs ) + if returns_iterable: + for i in range(iterable_length): + accumulated_result[i].append( result[i] ) + else: + accumulated_result.append( result ) + + # Try to stack the arrays + if returns_iterable: + for i in range(iterable_length): + accumulated_result[i] = try_array( accumulated_result[i] ) + if result_type == tuple: + return tuple(accumulated_result) + elif result_type == list: + return accumulated_result + else: + accumulated_result = try_array( accumulated_result ) + return accumulated_result + def _find_output(self, t, iteration): """ Find the output that correspond to the requested `t` or `iteration` diff --git a/openpmd_viewer/openpmd_timeseries/numba_wrapper.py b/openpmd_viewer/openpmd_timeseries/numba_wrapper.py new file mode 100644 index 00000000..f03ebc54 --- /dev/null +++ b/openpmd_viewer/openpmd_timeseries/numba_wrapper.py @@ -0,0 +1,30 @@ +""" +This file is part of the openPMD-viewer. + +It defines a wrapper around numba. + +Copyright 2019, openPMD-viewer contributors +Author: Remi Lehe +License: 3-Clause-BSD-LBNL +""" +import warnings + +try: + # Import jit decorator from numba + import numba + numba_installed = True + jit = numba.njit(cache=True) + +except ImportError: + numba_installed = False + # Create dummy decorator: warns about installing numba when calling + # the decorated function. + def jit(f): + def decorated_f(*args, **kwargs): + warnings.warn( + '\nOne of the functions called by openPMD-viewer ' +\ + '(%s)\n' %f.__name__ +\ + 'could have been faster if `numba` had been installed.\n' +\ + 'Please consider installing `numba` (e.g. `pip install numba`)') + return f(*args, **kwargs) + return decorated_f diff --git a/opmd_viewer/openpmd_timeseries/particle_tracker.py b/openpmd_viewer/openpmd_timeseries/particle_tracker.py similarity index 91% rename from opmd_viewer/openpmd_timeseries/particle_tracker.py rename to openpmd_viewer/openpmd_timeseries/particle_tracker.py index 868bc5e1..40150f3f 100644 --- a/opmd_viewer/openpmd_timeseries/particle_tracker.py +++ b/openpmd_viewer/openpmd_timeseries/particle_tracker.py @@ -7,15 +7,9 @@ Authors: Remi Lehe License: 3-Clause-BSD-LBNL """ -import warnings import numpy as np from .data_reader.particle_reader import read_species_data -try: - from .cython_function import extract_indices_cython - cython_function_available = True -except ImportError: - cython_function_available = False - +from .numba_wrapper import jit class ParticleTracker( object ): """ @@ -73,7 +67,7 @@ def __init__(self, ts, species=None, t=None, select: dict, optional Either None or a dictionary of rules to select the particles, of the form - 'x' : [-4., 10.] (Particles having x between -4 and 10 microns) + 'x' : [-4., 10.] (Particles having x between -4 and 10) 'ux' : [-0.1, 0.1] (Particles having ux between -0.1 and 0.1 mc) 'uz' : [5., None] (Particles with uz above 5 mc) @@ -104,14 +98,6 @@ def __init__(self, ts, species=None, t=None, self.species = species self.preserve_particle_index = preserve_particle_index - # Print a warning if the Cython function is unavailable - if not cython_function_available: - warnings.warn( - "\nUnable to compile particle tracking with Cython. \n" - "The ParticleTracker will still work, but will be slow. \n" - "For faster particle tracking: \n" - " - make sure that Cython is installed \n" - " - then reinstall openPMD-viewer") def extract_tracked_particles( self, file_handle, data_list, species, extensions ): @@ -245,8 +231,8 @@ def get_extraction_indices( self, pid ): return( selected_indices ) - -def extract_indices_python( original_indices, selected_indices, +@jit +def extract_indices( original_indices, selected_indices, pid, selected_pid, preserve_particle_index ): """ Go through the sorted arrays `pid` and `selected_pid`, and record @@ -280,12 +266,3 @@ def extract_indices_python( original_indices, selected_indices, i_fill += 1 return( i_fill ) - - -# The functions `extract_indices_python` and `extract_indices_cython` -# perform the same operations, but the cython version is much faster -# since it is compiled -if cython_function_available: - extract_indices = extract_indices_cython -else: - extract_indices = extract_indices_python diff --git a/opmd_viewer/openpmd_timeseries/plotter.py b/openpmd_viewer/openpmd_timeseries/plotter.py similarity index 68% rename from opmd_viewer/openpmd_timeseries/plotter.py rename to openpmd_viewer/openpmd_timeseries/plotter.py index 15af43dd..89d7a30f 100644 --- a/opmd_viewer/openpmd_timeseries/plotter.py +++ b/openpmd_viewer/openpmd_timeseries/plotter.py @@ -9,6 +9,7 @@ License: 3-Clause-BSD-LBNL """ import numpy as np +import math try: import warnings import matplotlib @@ -16,11 +17,68 @@ matplotlib_installed = True except ImportError: matplotlib_installed = False -try: - from .cython_function import histogram_cic_1d, histogram_cic_2d - cython_function_available = True -except ImportError: - cython_function_available = False + +from .numba_wrapper import numba_installed +if numba_installed: + from .utilities import histogram_cic_1d, histogram_cic_2d + +# Redefine the default matplotlib formatter for ticks +if matplotlib_installed: + from matplotlib.ticker import ScalarFormatter + + class PowerOfThreeFormatter( ScalarFormatter ): + """ + Formatter for matplotlib's axes ticks, + that prints numbers as e.g. 1.5e3, 3.2e6, 0.2e-9, + where the exponent is always a multiple of 3. + + This helps a human reader to quickly identify the closest units + (e.g. nanometer) of the plotted quantity. + + This class derives from `ScalarFormatter`, which + provides a nice `offset` feature. + """ + def __init__( self, *args, **kwargs ): + ScalarFormatter.__init__( self, *args, **kwargs ) + # Do not print the order of magnitude on the side of the axis + self.set_scientific(False) + # Reduce the threshold for printing an offset on side of the axis + self._offset_threshold = 2 + + def __call__(self, x, pos=None): + """ + Function called for each tick of an axis (for matplotlib>=3.1) + Returns the string that appears in the plot. + """ + return self.pprint_val( x, pos ) + + def pprint_val( self, x, pos=None): + """ + Function called for each tick of an axis (for matplotlib<3.1) + Returns the string that appears in the plot. + """ + # Calculate the exponent (power of 3) + xp = (x - self.offset) + if xp != 0: + exponent = 3 * math.floor( math.log10(abs(xp)) / 3 ) + else: + exponent = 0 + # Show 3 digits at most after decimal point + mantissa = round( xp * 10**(-exponent), 3) + # After rounding the exponent might change (e.g. 0.999 -> 1.) + if mantissa != 0 and math.log10(abs(mantissa)) == 3: + exponent += 3 + mantissa /= 1000 + string = "{:.3f}".format( mantissa ) + if '.' in string: + # Remove trailing zeros and ., for integer mantissa + string = string.rstrip('0') + string = string.rstrip('.') + if exponent != 0: + string += "e{:d}".format( exponent ) + return string + + tick_formatter = PowerOfThreeFormatter() class Plotter(object): @@ -95,10 +153,10 @@ def hist1d(self, q1, w, quantity1, species, current_i, nbins, hist_range, # Find the iteration and time iteration = self.iterations[current_i] - time_fs = 1.e15 * self.t[current_i] + time = self.t[current_i] # Check deposition method - if deposition == 'cic' and not cython_function_available: + if deposition == 'cic' and not numba_installed: print_cic_unavailable() deposition = 'ngp' @@ -119,8 +177,12 @@ def hist1d(self, q1, w, quantity1, species, current_i, nbins, hist_range, plt.xlim( hist_range[0] ) plt.ylim( hist_range[1] ) plt.xlabel(quantity1, fontsize=self.fontsize) - plt.title("%s: t = %.0f fs (iteration %d)" - % (species, time_fs, iteration), fontsize=self.fontsize) + plt.title("%s: t = %.2e s (iteration %d)" + % (species, time, iteration), fontsize=self.fontsize) + # Format the ticks + ax = plt.gca() + ax.get_xaxis().set_major_formatter( tick_formatter ) + ax.get_yaxis().set_major_formatter( tick_formatter ) def hist2d(self, q1, q2, w, quantity1, quantity2, species, current_i, nbins, hist_range, cmap='Blues', vmin=None, vmax=None, @@ -168,10 +230,10 @@ def hist2d(self, q1, q2, w, quantity1, quantity2, species, current_i, # Find the iteration and time iteration = self.iterations[current_i] - time_fs = 1.e15 * self.t[current_i] + time = self.t[current_i] # Check deposition method - if deposition == 'cic' and not cython_function_available: + if deposition == 'cic' and not numba_installed: print_cic_unavailable() deposition = 'ngp' @@ -195,8 +257,12 @@ def hist2d(self, q1, q2, w, quantity1, quantity2, species, current_i, plt.colorbar() plt.xlabel(quantity1, fontsize=self.fontsize) plt.ylabel(quantity2, fontsize=self.fontsize) - plt.title("%s: t = %.1f fs (iteration %d)" - % (species, time_fs, iteration), fontsize=self.fontsize) + plt.title("%s: t = %.2e s (iteration %d)" + % (species, time, iteration), fontsize=self.fontsize) + # Format the ticks + ax = plt.gca() + ax.get_xaxis().set_major_formatter( tick_formatter ) + ax.get_yaxis().set_major_formatter( tick_formatter ) def show_field_1d( self, F, info, field_label, current_i, plot_range, vmin=None, vmax=None, **kw ): @@ -226,16 +292,16 @@ def show_field_1d( self, F, info, field_label, current_i, plot_range, # Find the iteration and time iteration = self.iterations[current_i] - time_fs = 1.e15 * self.t[current_i] + time = self.t[current_i] # Get the title and labels - plt.title("%s at %.1f fs (iteration %d)" - % (field_label, time_fs, iteration), fontsize=self.fontsize) + plt.title("%s at %.2e s (iteration %d)" % (field_label, + time, iteration), fontsize=self.fontsize) # Add the name of the axes - plt.xlabel('$%s \;(\mu m)$' % info.axes[0], fontsize=self.fontsize) - # Get the x axis in microns - xaxis = 1.e6 * getattr( info, info.axes[0] ) + plt.xlabel('$%s \;(m)$' % info.axes[0], fontsize=self.fontsize) + # Get the x axis + xaxis = getattr( info, info.axes[0] ) # Plot the data plt.plot( xaxis, F ) # Get the limits of the plot @@ -247,8 +313,12 @@ def show_field_1d( self, F, info, field_label, current_i, plot_range, # - Along the second dimension if (plot_range[1][0] is not None) and (plot_range[1][1] is not None): plt.ylim( plot_range[1][0], plot_range[1][1] ) + # Format the ticks + ax = plt.gca() + ax.get_xaxis().set_major_formatter( tick_formatter ) + ax.get_yaxis().set_major_formatter( tick_formatter ) - def show_field_2d(self, F, info, slicing_dir, m, field_label, geometry, + def show_field_2d(self, F, info, slice_across, m, field_label, geometry, current_i, plot_range, **kw): """ Plot the given field in 2D @@ -261,9 +331,9 @@ def show_field_2d(self, F, info, slicing_dir, m, field_label, geometry, info: a FieldMetaInformation object Contains the information about the plotted field - slicing_dir : str, optional + slice_across : str, optional Only used for 3dcartesian geometry - The direction along which the data is sliced + The direction across which the data is sliced m: int Only used for thetaMode geometry @@ -284,33 +354,27 @@ def show_field_2d(self, F, info, slicing_dir, m, field_label, geometry, # Find the iteration and time iteration = self.iterations[current_i] - time_fs = 1.e15 * self.t[current_i] + time = self.t[current_i] # Get the title and labels # Cylindrical geometry if geometry == "thetaMode": mode = str(m) - plt.title("%s in the mode %s at %.1f fs (iteration %d)" - % (field_label, mode, time_fs, iteration), + plt.title("%s in the mode %s at %.2e s (iteration %d)" + % (field_label, mode, time, iteration), fontsize=self.fontsize) # 2D Cartesian geometry - elif geometry == "2dcartesian": - plt.title("%s at %.1f fs (iteration %d)" - % (field_label, time_fs, iteration), - fontsize=self.fontsize) - # 3D Cartesian geometry - elif geometry == "3dcartesian": - slice_plane = info.axes[0] + '-' + info.axes[1] - plt.title("%s sliced in %s at %.1f fs (iteration %d)" - % (field_label, slice_plane, time_fs, iteration), + else: + plt.title("%s at %.2e s (iteration %d)" + % (field_label, time, iteration), fontsize=self.fontsize) # Add the name of the axes - plt.xlabel('$%s \;(\mu m)$' % info.axes[1], fontsize=self.fontsize) - plt.ylabel('$%s \;(\mu m)$' % info.axes[0], fontsize=self.fontsize) + plt.xlabel('$%s \;(m)$' % info.axes[1], fontsize=self.fontsize) + plt.ylabel('$%s \;(m)$' % info.axes[0], fontsize=self.fontsize) # Plot the data - plt.imshow(F, extent=1.e6 * info.imshow_extent, origin='lower', + plt.imshow(F, extent=info.imshow_extent, origin='lower', interpolation='nearest', aspect='auto', **kw) plt.colorbar() @@ -321,15 +385,17 @@ def show_field_2d(self, F, info, slicing_dir, m, field_label, geometry, # - Along the second dimension if (plot_range[1][0] is not None) and (plot_range[1][1] is not None): plt.ylim( plot_range[1][0], plot_range[1][1] ) + # Format the ticks + ax = plt.gca() + ax.get_xaxis().set_major_formatter( tick_formatter ) + ax.get_yaxis().set_major_formatter( tick_formatter ) def print_cic_unavailable(): warnings.warn( "\nCIC particle histogramming is unavailable because \n" - "Cython is not installed. NGP histogramming is used instead.\n" - "For CIC histogramming: \n" - " - make sure that Cython is installed \n" - " - then reinstall openPMD-viewer") + "Numba is not installed. NGP histogramming is used instead.\n" + "Please considering installing numba (e.g. `pip install numba`)") def check_matplotlib(): diff --git a/opmd_viewer/openpmd_timeseries/utilities.py b/openpmd_viewer/openpmd_timeseries/utilities.py similarity index 60% rename from opmd_viewer/openpmd_timeseries/utilities.py rename to openpmd_viewer/openpmd_timeseries/utilities.py index 53395a7a..daced34a 100644 --- a/opmd_viewer/openpmd_timeseries/utilities.py +++ b/openpmd_viewer/openpmd_timeseries/utilities.py @@ -9,9 +9,50 @@ """ import os +import copy +import math import numpy as np import h5py from .data_reader.particle_reader import read_species_data +from .numba_wrapper import jit + +def sanitize_slicing(slice_across, slice_relative_position): + """ + Return standardized format for `slice_across` and `slice_relative_position`: + - either `slice_across` and `slice_relative_position` are both `None` (no slicing) + - or `slice_across` and `slice_relative_position` are both lists, + with the same number of elements + + Parameters + ---------- + slice_relative_position : float, or list of float, or None + + slice_across : str, or list of str, or None + Direction(s) across which the data should be sliced + """ + # Skip None and empty lists + if slice_across is None or slice_across == []: + return None, None + + # Convert to lists + if not isinstance(slice_across, list): + slice_across = [slice_across] + if slice_relative_position is None: + slice_relative_position = [0]*len(slice_across) + if not isinstance(slice_relative_position, list): + slice_relative_position = [slice_relative_position] + # Check that the length are matching + if len(slice_across) != len(slice_relative_position): + raise ValueError( + 'The argument `slice_relative_position` is erroneous: \nIt should have' + 'the same number of elements as `slice_across`.') + + # Return a copy. This is because the rest of the `openPMD-viewer` code + # sometimes modifies the objects returned by `sanitize_slicing`. + # Using a copy avoids directly modifying objects that the user may pass + # to this function (and live outside of openPMD-viewer, e.g. directly in + # a user's notebook) + return copy.copy(slice_across), copy.copy(slice_relative_position) def list_h5_files(path_to_dir): @@ -74,7 +115,7 @@ def apply_selection(file_handle, data_list, select, species, extensions): select: dict A dictionary of rules to select the particles - 'x' : [-4., 10.] (Particles having x between -4 and 10 microns) + 'x' : [-4., 10.] (Particles having x between -4 and 10) 'ux' : [-0.1, 0.1] (Particles having ux between -0.1 and 0.1 mc) 'uz' : [5., None] (Particles with uz above 5 mc) @@ -116,6 +157,18 @@ def apply_selection(file_handle, data_list, select, species, extensions): return(data_list) +def try_array( L ): + """ + Attempt to convert L to a single array. + """ + try: + # Stack the arrays + return np.stack( L, axis=0 ) + except ValueError: + # Do not stack + return L + + def fit_bins_to_grid( hist_size, grid_size, grid_range ): """ Given a tentative number of bins `hist_size` for a histogram over @@ -131,7 +184,7 @@ def fit_bins_to_grid( hist_size, grid_size, grid_range ): grid_size: integer The number of cells in the grid - grid_range: list of floats (in meters) + grid_range: list of floats (in) The extent of the grid Returns: @@ -139,7 +192,7 @@ def fit_bins_to_grid( hist_size, grid_size, grid_range ): hist_size: integer The new number of bins - hist_range: list of floats (in microns) + hist_range: list of floats The new range of the histogram """ # The new histogram range is the same as the grid range @@ -161,10 +214,6 @@ def fit_bins_to_grid( hist_size, grid_size, grid_range ): hist_size = int( ( hist_range[1] - hist_range[0] ) / hist_spacing ) hist_range[1] = hist_range[0] + hist_size * hist_spacing - # Convert the range to microns (since this is how particle positions - # are returned in the openPMD-viewer) - hist_range = [ 1.e6 * hist_range[0], 1.e6 * hist_range[1] ] - return( hist_size, hist_range ) @@ -185,16 +234,15 @@ def combine_cylindrical_components( Fr, Ft, theta, coord, info ): Contains info on the coordinate system """ if theta is not None: - # Fr and Fr are 2Darrays - assert (Fr.ndim == 2) and (Ft.ndim == 2) - if coord == 'x': F = np.cos(theta) * Fr - np.sin(theta) * Ft elif coord == 'y': F = np.sin(theta) * Fr + np.cos(theta) * Ft # Revert the sign below the axis - F[: int(F.shape[0] / 2)] *= -1 - + if info.axes[0] == 'r': + F[ : int(F.shape[0]/2) ] *= -1 + elif (F.ndim == 2) and (info.axes[1] == 'r'): + F[ : , : int(F.shape[1]/2) ] *= -1 else: # Fr, Ft are 3Darrays, info corresponds to Cartesian data assert (Fr.ndim == 3) and (Ft.ndim == 3) @@ -214,7 +262,85 @@ def combine_cylindrical_components( Fr, Ft, theta, coord, info ): return F - +@jit +def histogram_cic_1d( q1, w, nbins, bins_start, bins_end ): + """ + Return an 1D histogram of the values in `q1` weighted by `w`, + consisting of `nbins` evenly-spaced bins between `bins_start` + and `bins_end`. Contribution to each bins is determined by the + CIC weighting scheme (i.e. linear weights). + """ + # Define various scalars + bin_spacing = (bins_end-bins_start)/nbins + inv_spacing = 1./bin_spacing + n_ptcl = len(w) + + # Allocate array for histogrammed data + hist_data = np.zeros( nbins, dtype=np.float64 ) + + # Go through particle array and bin the data + for i in range(n_ptcl): + # Calculate the index of lower bin to which this particle contributes + q1_cell = (q1[i] - bins_start) * inv_spacing + i_low_bin = int( math.floor( q1_cell ) ) + # Calculate corresponding CIC shape and deposit the weight + S_low = 1. - (q1_cell - i_low_bin) + if (i_low_bin >= 0) and (i_low_bin < nbins): + hist_data[ i_low_bin ] += w[i] * S_low + if (i_low_bin + 1 >= 0) and (i_low_bin + 1 < nbins): + hist_data[ i_low_bin + 1 ] += w[i] * (1. - S_low) + + return( hist_data ) + + +@jit +def histogram_cic_2d( q1, q2, w, + nbins_1, bins_start_1, bins_end_1, + nbins_2, bins_start_2, bins_end_2 ): + """ + Return an 2D histogram of the values in `q1` and `q2` weighted by `w`, + consisting of `nbins_1` bins in the first dimension and `nbins_2` bins + in the second dimension. + Contribution to each bins is determined by the + CIC weighting scheme (i.e. linear weights). + """ + # Define various scalars + bin_spacing_1 = (bins_end_1-bins_start_1)/nbins_1 + inv_spacing_1 = 1./bin_spacing_1 + bin_spacing_2 = (bins_end_2-bins_start_2)/nbins_2 + inv_spacing_2 = 1./bin_spacing_2 + n_ptcl = len(w) + + # Allocate array for histogrammed data + hist_data = np.zeros( (nbins_1, nbins_2), dtype=np.float64 ) + + # Go through particle array and bin the data + for i in range(n_ptcl): + + # Calculate the index of lower bin to which this particle contributes + q1_cell = (q1[i] - bins_start_1) * inv_spacing_1 + q2_cell = (q2[i] - bins_start_2) * inv_spacing_2 + i1_low_bin = int( math.floor( q1_cell ) ) + i2_low_bin = int( math.floor( q2_cell ) ) + + # Calculate corresponding CIC shape and deposit the weight + S1_low = 1. - (q1_cell - i1_low_bin) + S2_low = 1. - (q2_cell - i2_low_bin) + if (i1_low_bin >= 0) and (i1_low_bin < nbins_1): + if (i2_low_bin >= 0) and (i2_low_bin < nbins_2): + hist_data[ i1_low_bin, i2_low_bin ] += w[i]*S1_low*S2_low + if (i2_low_bin+1 >= 0) and (i2_low_bin+1 < nbins_2): + hist_data[ i1_low_bin, i2_low_bin+1 ] += w[i]*S1_low*(1.-S2_low) + if (i1_low_bin+1 >= 0) and (i1_low_bin+1 < nbins_1): + if (i2_low_bin >= 0) and (i2_low_bin < nbins_2): + hist_data[ i1_low_bin+1, i2_low_bin ] += w[i]*(1.-S1_low)*S2_low + if (i2_low_bin+1 >= 0) and (i2_low_bin+1 < nbins_2): + hist_data[ i1_low_bin+1, i2_low_bin+1 ] += w[i]*(1.-S1_low)*(1.-S2_low) + + return( hist_data ) + + +@jit def construct_3d_from_circ( F3d, Fcirc, x_array, y_array, modes, nx, ny, nz, nr, nmodes, inv_dr, rmax ): """ diff --git a/opmd_viewer/__init__.py b/opmd_viewer/__init__.py index 4a423d16..f588b9a3 100644 --- a/opmd_viewer/__init__.py +++ b/opmd_viewer/__init__.py @@ -1,15 +1,30 @@ """ -openPMD-viewer +This is a stub that detects whether the user is attempting to use the +old import statement from openPMD-viewer 0.X (`import opmd_viewer`). -Usage ------ -See the class OpenPMDTimeSeries to open a set of openPMD files +In that case, an exception is raised that prompts the user to use the new API. """ -# Make the OpenPMDTimeSeries object accessible from outside the package -from .openpmd_timeseries import OpenPMDTimeSeries, FieldMetaInformation, \ - ParticleTracker - # Define the version number -from .__version__ import __version__ -__all__ = ['OpenPMDTimeSeries', 'FieldMetaInformation', - 'ParticleTracker', '__version__'] +from openpmd_viewer import __version__ +__all__ = ['__version__'] + +raise DeprecationWarning(""" +It looks like you are trying to use the API from openPMD-viewer version 0.X +but the installed version on your system is openPMD-viewer version 1.X. + +* If you wish to use the new openPMD-viewer version 1.X, the import statement +should use `openpmd_viewer` instead of `opmd_viewer`, e.g.: +``` +from openpmd_viewer import OpenPMDTimeSeries +``` +Please have a look at the list of the changes introduced in version 1.X here: +https://github.com/openPMD/openPMD-viewer/blob/upcoming-1.0/CHANGELOG.md#10 +In particular, note that `get_particle` now returns particle positions in +meters (not in microns anymore) and that the syntax for slicing fields has +changed. + +* If you wish to go back to the old openPMD-viewer version 0.X, use: +``` +pip install openPMD-viewer==0.9 +``` +""") diff --git a/opmd_viewer/__version__.py b/opmd_viewer/__version__.py deleted file mode 100644 index d69d16e9..00000000 --- a/opmd_viewer/__version__.py +++ /dev/null @@ -1 +0,0 @@ -__version__ = "0.9.1" diff --git a/opmd_viewer/openpmd_timeseries/cython_function.pyx b/opmd_viewer/openpmd_timeseries/cython_function.pyx deleted file mode 100644 index b76440a3..00000000 --- a/opmd_viewer/openpmd_timeseries/cython_function.pyx +++ /dev/null @@ -1,138 +0,0 @@ -import numpy as np -cimport numpy as np -from cpython cimport bool -cimport cython -from libc.math cimport floor - -@cython.boundscheck(False) -@cython.wraparound(False) -def extract_indices_cython( - np.ndarray[np.int64_t, ndim=1] original_indices, - np.ndarray[np.int64_t, ndim=1] selected_indices, - np.ndarray[np.uint64_t, ndim=1] pid, - np.ndarray[np.uint64_t, ndim=1] selected_pid, - bool preserve_particle_index ): - """ - Go through the sorted arrays `pid` and `selected_pid`, and record - the indices (of the array `pid`) where they match, by storing them - in the array `selected_indices` (this array is thus modified in-place) - - Return the number of elements that were filled in `selected_indices` - """ - cdef unsigned int i = 0 - cdef unsigned int i_select = 0 - cdef unsigned int i_fill = 0 - cdef unsigned int N = pid.shape[0] - cdef unsigned int N_selected = selected_pid.shape[0] - - # Go through both sorted arrays (pid and selected_pid) and match them. - # i.e. whenever the same number appears in both arrays, - # record the corresponding original index in selected_indices - while i < N and i_select < N_selected: - - if pid[i] < selected_pid[i_select]: - i += 1 - elif pid[i] == selected_pid[i_select]: - selected_indices[i_fill] = original_indices[i] - i_fill += 1 - i_select += 1 - elif pid[i] > selected_pid[i_select]: - i_select += 1 - if preserve_particle_index: - # Fill the index, to indicate that the particle is absent - selected_indices[i_fill] = -1 - i_fill += 1 - - return( i_fill ) - - -@cython.boundscheck(False) -@cython.wraparound(False) -def histogram_cic_1d( - np.ndarray[np.float64_t, ndim=1] q1, - np.ndarray[np.float64_t, ndim=1] w, - int nbins, double bins_start, double bins_end ): - """ - Return an 1D histogram of the values in `q1` weighted by `w`, - consisting of `nbins` evenly-spaced bins between `bins_start` - and `bins_end`. Contribution to each bins is determined by the - CIC weighting scheme (i.e. linear weights). - """ - # Define various scalars - cdef double bin_spacing = (bins_end-bins_start)/nbins - cdef double inv_spacing = 1./bin_spacing - cdef int n_ptcl = len(w) - cdef int i_low_bin - cdef double q1_cell - cdef double S_low - - # Allocate array for histogrammed data - hist_data = np.zeros( nbins, dtype=np.float64 ) - - # Go through particle array and bin the data - for i in xrange(n_ptcl): - # Calculate the index of lower bin to which this particle contributes - q1_cell = (q1[i] - bins_start) * inv_spacing - i_low_bin = floor( q1_cell ) - # Calculate corresponding CIC shape and deposit the weight - S_low = 1. - (q1_cell - i_low_bin) - if (i_low_bin >= 0) and (i_low_bin < nbins): - hist_data[ i_low_bin ] += w[i] * S_low - if (i_low_bin + 1 >= 0) and (i_low_bin + 1 < nbins): - hist_data[ i_low_bin + 1 ] += w[i] * (1. - S_low) - - return( hist_data ) - - -@cython.boundscheck(False) -@cython.wraparound(False) -def histogram_cic_2d( - np.ndarray[np.float64_t, ndim=1] q1, - np.ndarray[np.float64_t, ndim=1] q2, - np.ndarray[np.float64_t, ndim=1] w, - int nbins_1, double bins_start_1, double bins_end_1, - int nbins_2, double bins_start_2, double bins_end_2 ): - """ - Return an 2D histogram of the values in `q1` and `q2` weighted by `w`, - consisting of `nbins_1` bins in the first dimension and `nbins_2` bins - in the second dimension. - Contribution to each bins is determined by the - CIC weighting scheme (i.e. linear weights). - """ - # Define various scalars - cdef double bin_spacing_1 = (bins_end_1-bins_start_1)/nbins_1 - cdef double inv_spacing_1 = 1./bin_spacing_1 - cdef double bin_spacing_2 = (bins_end_2-bins_start_2)/nbins_2 - cdef double inv_spacing_2 = 1./bin_spacing_2 - cdef int n_ptcl = len(w) - cdef int i1_low_bin, i2_low_bin - cdef double q1_cell, q2_cell - cdef double S1_low, S2_low - - # Allocate array for histogrammed data - hist_data = np.zeros( (nbins_1, nbins_2), dtype=np.float64 ) - - # Go through particle array and bin the data - for i in xrange(n_ptcl): - - # Calculate the index of lower bin to which this particle contributes - q1_cell = (q1[i] - bins_start_1) * inv_spacing_1 - q2_cell = (q2[i] - bins_start_2) * inv_spacing_2 - i1_low_bin = floor( q1_cell ) - i2_low_bin = floor( q2_cell ) - - # Calculate corresponding CIC shape and deposit the weight - S1_low = 1. - (q1_cell - i1_low_bin) - S2_low = 1. - (q2_cell - i2_low_bin) - if (i1_low_bin >= 0) and (i1_low_bin < nbins_1): - if (i2_low_bin >= 0) and (i2_low_bin < nbins_2): - hist_data[ i1_low_bin, i2_low_bin ] += w[i]*S1_low*S2_low - if (i2_low_bin+1 >= 0) and (i2_low_bin+1 < nbins_2): - hist_data[ i1_low_bin, i2_low_bin+1 ] += w[i]*S1_low*(1.-S2_low) - if (i1_low_bin+1 >= 0) and (i1_low_bin+1 < nbins_1): - if (i2_low_bin >= 0) and (i2_low_bin < nbins_2): - hist_data[ i1_low_bin+1, i2_low_bin ] += w[i]*(1.-S1_low)*S2_low - if (i2_low_bin+1 >= 0) and (i2_low_bin+1 < nbins_2): - hist_data[ i1_low_bin+1, i2_low_bin+1 ] += w[i]*(1.-S1_low)*(1.-S2_low) - - return( hist_data ) diff --git a/requirements.txt b/requirements.txt index e2aed537..0905111e 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,5 @@ numpy scipy h5py +tqdm + diff --git a/setup.py b/setup.py index 89b80401..d4f95fc2 100644 --- a/setup.py +++ b/setup.py @@ -9,9 +9,9 @@ with open('./requirements.txt') as f: install_requires = [line.strip('\n') for line in f.readlines()] -# Read the version number, by executing the file opmd_viewer/__version__.py +# Read the version number, by executing the file openpmd_viewer/__version__.py # This defines the variable __version__ -with open('./opmd_viewer/__version__.py') as f: +with open('./openpmd_viewer/__version__.py') as f: exec( f.read() ) # Define a custom class to run the py.test with `python setup.py test` @@ -22,18 +22,6 @@ def run_tests(self): errcode = pytest.main([]) sys.exit(errcode) -# Try to compile the Cython function -try: - import numpy - include_dirs = [numpy.get_include()] - from Cython.Build import cythonize - ext_modules = cythonize( - "opmd_viewer/openpmd_timeseries/cython_function.pyx") -except ImportError: - # If the compilation fails, still install the package in a robust way - include_dirs = [] - ext_modules = [] - # Main setup command setup(name='openPMD-viewer', version=__version__, @@ -45,16 +33,14 @@ def run_tests(self): maintainer_email='remi.lehe@lbl.gov', license='BSD-3-Clause-LBNL', packages=find_packages('.'), - package_data={'opmd_viewer': ['notebook_starter/*.ipynb']}, - scripts=['opmd_viewer/notebook_starter/openPMD_notebook'], + package_data={'openpmd_viewer': ['notebook_starter/*.ipynb']}, + scripts=['openpmd_viewer/notebook_starter/openPMD_notebook'], tests_require=['pytest', 'jupyter'], - ext_modules=ext_modules, - include_dirs=include_dirs, install_requires=install_requires, extras_require = { - 'GUI': ["ipywidgets", "matplotlib", "cython"], - 'plot': ["matplotlib", "cython"], - 'tutorials': ["ipywidgets", "matplotlib", "wget", "cython"] + 'GUI': ["ipywidgets", "matplotlib"], + 'plot': ["matplotlib"], + 'tutorials': ["ipywidgets", "matplotlib", "wget"] }, cmdclass={'test': PyTest}, platforms='any', diff --git a/tutorials/1_Introduction-to-the-API.ipynb b/tutorials/1_Introduction-to-the-API.ipynb index 2f109317..8f5c58b8 100644 --- a/tutorials/1_Introduction-to-the-API.ipynb +++ b/tutorials/1_Introduction-to-the-API.ipynb @@ -62,7 +62,7 @@ "\n", "In order to start using the API:\n", "\n", - "- Load the class `OpenPMDTimeSeries` from the module `opmd_viewer`" + "- Load the class `OpenPMDTimeSeries` from the module `openpmd_viewer`" ] }, { @@ -71,7 +71,7 @@ "metadata": {}, "outputs": [], "source": [ - "from opmd_viewer import OpenPMDTimeSeries" + "from openpmd_viewer import OpenPMDTimeSeries" ] }, { diff --git a/tutorials/2_Specific-field-geometries.ipynb b/tutorials/2_Specific-field-geometries.ipynb index d10bfa5b..355e84b2 100644 --- a/tutorials/2_Specific-field-geometries.ipynb +++ b/tutorials/2_Specific-field-geometries.ipynb @@ -72,7 +72,7 @@ "metadata": {}, "outputs": [], "source": [ - "from opmd_viewer import OpenPMDTimeSeries" + "from openpmd_viewer import OpenPMDTimeSeries" ] }, { @@ -104,7 +104,7 @@ "## 3D Cartesian geometry\n", "\n", "For 3D Cartesian geometry, the `get_field` method has additional arguments, in order to select a 2D slice into the 3D volume:\n", - "- `slicing_dir` allows to choose the axis across which the slice is taken. See the examples below:" + "- `slice_across` allows to choose the axis across which the slice is taken. See the examples below:" ] }, { @@ -115,7 +115,7 @@ "source": [ "# Slice across y (i.e. in a plane parallel to x-z)\n", "Ez1, info_Ez1 = ts_3d.get_field( field='E', coord='z', iteration=500, \n", - " slicing_dir='y', plot=True )" + " slice_across='y', plot=True )" ] }, { @@ -126,14 +126,25 @@ "source": [ "# Slice across z (i.e. in a plane parallel to x-y)\n", "Ez2, info_Ez2 = ts_3d.get_field( field='E', coord='z', iteration=500,\n", - " slicing_dir='z', plot=True )" + " slice_across='z', plot=True )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Slice across x and y (i.e. along a line parallel to the z axis)\n", + "Ez2, info_Ez2 = ts_3d.get_field( field='E', coord='z', iteration=500,\n", + " slice_across=['x','y'], plot=True )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "- For one given slicing direction, `slicing` allows to select which slice to take: `slicing` is a number between -1 and 1, where -1 indicates to take the slice at the lower bound of the slicing range (e.g. $z_min$ if `slicing_dir` is `z`) and 1 indicates to take the slice at the upper bound of the slicing range (e.g. $z_max$ if `slicing_dir` is `z`). For example:" + "- For one given slicing direction, `slice_relative_position` allows to select which slice to take: `slice_relative_position` is a number between -1 and 1, where -1 indicates to take the slice at the lower bound of the slicing range (e.g. $z_{min}$ if `slice_across` is `z`) and 1 indicates to take the slice at the upper bound of the slicing range (e.g. $z_{max}$ if `slice_across` is `z`). For example:" ] }, { @@ -144,14 +155,14 @@ "source": [ "# Slice across z, very close to zmin.\n", "Ez2, info_Ez2 = ts_3d.get_field( field='E', coord='z', iteration=500, \n", - " slicing_dir='z', slicing=-0.9, plot=True )" + " slice_across='z', slice_relative_position=-0.9, plot=True )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "When passing `slicing=None`, `get_field` returns a full 3D Cartesian array. This can be useful for further analysis by hand, with `numpy` (e.g. calculating the total energy in the field)." + "When passing `slice_across=None`, `get_field` returns a full 3D Cartesian array. This can be useful for further analysis by hand, with `numpy` (e.g. calculating the total energy in the field)." ] }, { @@ -161,7 +172,7 @@ "outputs": [], "source": [ "# Get the full 3D Cartesian array\n", - "Ez_3d, info_Ez_3d = ts_3d.get_field( field='E', coord='z', iteration=500, slicing=None )\n", + "Ez_3d, info_Ez_3d = ts_3d.get_field( field='E', coord='z', iteration=500, slice_across=None )\n", "print( Ez_3d.ndim )" ] }, @@ -209,7 +220,7 @@ "source": [ "The argument `theta` (in radians) selects the plane of observation: this plane contains the $z$ axis and has an angle `theta` with respect to the $x$ axis.\n", "\n", - "When passing `slicing=None`, `get_field` returns a full 3D Cartesian array. This can be useful for further analysis by hand, with `numpy` (e.g. calculating the total energy in the field), or for comparison with Cartesian simulations." + "When passing `theta=None`, `get_field` returns a full 3D Cartesian array. This can be useful for further analysis by hand, with `numpy` (e.g. calculating the total energy in the field), or for comparison with Cartesian simulations." ] }, { @@ -227,7 +238,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "- Finally, in cylindrical geometry, the users can also choose the coordinates `r` and `t` for the radial and azimuthal components of the fields. For instance:" + "- In cylindrical geometry, the users can also choose the coordinates `r` and `t` for the radial and azimuthal components of the fields. For instance:" ] }, { @@ -239,6 +250,31 @@ "Er, info_Er = ts_circ.get_field( field='E', coord='r', iteration=500, m=0, \n", " plot=True, theta=0.5)" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Finally, in cylindrical geometry, fields can also be sliced, by using the `r` and `z` direction. (Keep in mind that `slice_across` is the direction **orthogonal** to the slice.)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Er_slice, info = ts_circ.get_field( field='E', coord='r', iteration=500, plot=True, slice_across='r' )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Er_slice, info = ts_circ.get_field( field='E', coord='r', iteration=500, plot=True, slice_across='z' )" + ] } ], "metadata": { @@ -257,7 +293,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/tutorials/3_Introduction-to-the-GUI.ipynb b/tutorials/3_Introduction-to-the-GUI.ipynb index d3a4768f..43afe4c5 100644 --- a/tutorials/3_Introduction-to-the-GUI.ipynb +++ b/tutorials/3_Introduction-to-the-GUI.ipynb @@ -65,7 +65,7 @@ "## Prepare and use the GUI \n", "\n", "In order to start using the GUI:\n", - "- Load the class `OpenPMDTimeSeries` from the module `opmd_viewer`" + "- Load the class `OpenPMDTimeSeries` from the module `openpmd_viewer`" ] }, { @@ -74,7 +74,7 @@ "metadata": {}, "outputs": [], "source": [ - "from opmd_viewer import OpenPMDTimeSeries" + "from openpmd_viewer import OpenPMDTimeSeries" ] }, { diff --git a/tutorials/4_Particle_selection.ipynb b/tutorials/4_Particle_selection.ipynb index 699f380f..5e1b38e1 100644 --- a/tutorials/4_Particle_selection.ipynb +++ b/tutorials/4_Particle_selection.ipynb @@ -68,7 +68,7 @@ "metadata": {}, "source": [ "As usual, in order to use openPMD-viewer, we:\n", - "- load the class `OpenPMDTimeSeries` from the module `opmd_viewer`\n", + "- load the class `OpenPMDTimeSeries` from the module `openpmd_viewer`\n", "- create a time series object by pointing to the folder which contains the corresponding openPMD data" ] }, @@ -78,7 +78,7 @@ "metadata": {}, "outputs": [], "source": [ - "from opmd_viewer import OpenPMDTimeSeries\n", + "from openpmd_viewer import OpenPMDTimeSeries\n", "ts = OpenPMDTimeSeries('./example-2d/hdf5/')" ] }, @@ -99,7 +99,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 4, @@ -110,7 +110,7 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -147,7 +147,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 5, @@ -158,7 +158,7 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -172,7 +172,7 @@ "# Select only particles that have uz between 0.05 and 0.2 AND z between 22 and 26\n", "# and plot them as green dots, on top of the phase space\n", "z_selected, uz_selected = ts.get_particle( ['z', 'uz'], species='electrons', \n", - " iteration=300, select={'uz':[0.05, 0.2], 'z':[22,26]} )\n", + " iteration=300, select={'uz':[0.05, 0.2], 'z':[22e-6,26e-6]} )\n", "plt.plot(z_selected, uz_selected, 'g.')" ] }, @@ -195,9 +195,9 @@ "metadata": {}, "outputs": [], "source": [ - "from opmd_viewer import ParticleTracker\n", + "from openpmd_viewer import ParticleTracker\n", "# Select particles to be tracked, at iteration 300\n", - "pt = ParticleTracker( ts, iteration=300, select={'uz':[0.05,0.2], 'z':[22,26]}, species='electrons' )" + "pt = ParticleTracker( ts, iteration=300, select={'uz':[0.05,0.2], 'z':[22e-6,26e-6]}, species='electrons' )" ] }, { @@ -215,7 +215,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 7, @@ -226,7 +226,7 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -259,7 +259,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 8, @@ -270,7 +270,7 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -305,7 +305,7 @@ "metadata": {}, "outputs": [], "source": [ - "pt = ParticleTracker( ts, iteration=300, select={'uz':[0.05,0.1], 'z':[22,26]}, \n", + "pt = ParticleTracker( ts, iteration=300, select={'uz':[0.05,0.1], 'z':[22e-6,26e-6]}, \n", " species='electrons', preserve_particle_index=True )" ] }, @@ -357,7 +357,7 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -373,6 +373,64 @@ "plt.ylabel('Longitudinal momentum uz')" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that reconstructing the trajectories can also be done with the method `ts.iterate`, in order to avoid having to explicitly write the above loops:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 29/29 [00:00<00:00, 166.88it/s]\n" + ] + } + ], + "source": [ + "z_trajectories, uz_trajectories = ts.iterate( ts.get_particle, ['z', 'uz'], select=pt, species='electrons' )" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 4))\n", + "plt.subplot(121)\n", + "plt.plot( ts.iterations, z_trajectories[:,0], '-o' )\n", + "plt.plot( ts.iterations, z_trajectories[:,10], '-o' )\n", + "plt.plot( ts.iterations, z_trajectories[:,19], '-o' )\n", + "plt.ylabel('Longitudinal position z')\n", + "plt.xlabel('Iteration')\n", + "\n", + "plt.subplot(122)\n", + "plt.plot( ts.iterations, uz_trajectories[:,0], '-o' )\n", + "plt.plot( ts.iterations, uz_trajectories[:,10], '-o' )\n", + "plt.plot( ts.iterations, uz_trajectories[:,19], '-o' )\n", + "plt.ylabel('Longitudinal momentum uz')\n", + "plt.xlabel('Iteration')\n", + "plt.tight_layout()" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/tutorials/5_Laser-plasma_tools.ipynb b/tutorials/5_Laser-plasma_tools.ipynb index 2c3d50ba..c4821194 100644 --- a/tutorials/5_Laser-plasma_tools.ipynb +++ b/tutorials/5_Laser-plasma_tools.ipynb @@ -62,7 +62,7 @@ "## The LpaDiagnostics class\n", "\n", "To use the laser-plasma acceleration (LPA) tools:\n", - "- Load the class `LpaDiagnostics` from the module `opmd_viewer.addons`" + "- Load the class `LpaDiagnostics` from the module `openpmd_viewer.addons`" ] }, { @@ -71,7 +71,7 @@ "metadata": {}, "outputs": [], "source": [ - "from opmd_viewer.addons import LpaDiagnostics" + "from openpmd_viewer.addons import LpaDiagnostics" ] }, { @@ -155,8 +155,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Mean gamma\n", - "To calculate the mean energy and standard deviation of the selected particles `get_mean_gamma` can be used. In the example below, only the particles with $u_z > 0.05$ are selected." + "#### Charge\n", + "`get_charge` calculates the charge of the given particle selection in Coulomb." ] }, { @@ -165,15 +165,14 @@ "metadata": {}, "outputs": [], "source": [ - "ts_2d.get_mean_gamma(iteration=300, species='electrons', select={'uz' : [0.05, None]})" + "ts_2d.get_charge(iteration=300, species='electrons')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Charge\n", - "`get_charge` calculates the charge of the given particle selection in Coulomb." + "Note that the evolution of the charge (or of any of the quantities below) can be easily obtained with `ts.iterate`:" ] }, { @@ -182,7 +181,24 @@ "metadata": {}, "outputs": [], "source": [ - "ts_2d.get_charge(iteration=300, species='electrons')" + "ts_2d.iterate( ts_2d.get_charge, species='electrons' )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Mean gamma\n", + "To calculate the mean energy and standard deviation of the selected particles `get_mean_gamma` can be used. In the example below, only the particles with $u_z > 0.05$ are selected." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ts_2d.get_mean_gamma(iteration=300, species='electrons', select={'uz' : [0.05, None]})" ] }, {