xrt 1.6.0__zip → 1.6.1__zip

{xrt-1.6.0 → xrt-1.6.1}/MANIFEST.in

@@ -37,4 +37,3 @@ recursive-include tests\raycing\misc *
 recursive-include tests\raycing\RemoteOpenCLCalculation *
 recursive-include tests\raycing\XOP-Reflectivities *
 recursive-include tests\raycing\XOP-RockingCurves *
-recursive-include tests\raycing\XOP-RockingCurves-Bent *

{xrt-1.6.0 → xrt-1.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xrt
-Version: 1.6.0
+Version: 1.6.1
 Summary: Ray tracing and wave propagation in x-ray regime, primarily meant for modeling synchrotron sources, beamlines and beamline elements. Includes a GUI for creating a beamline and viewing it in 3D.
 Home-page: http://xrt.readthedocs.io
 Author: Konstantin Klementiev, Roman Chernikov
@@ -18,6 +18,19 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Scientific/Engineering :: Visualization
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
+Requires-Dist: numpy>=1.8.0
+Requires-Dist: scipy>=0.17.0
+Requires-Dist: matplotlib>=2.0.0
+Requires-Dist: sphinx>=1.6.2
+Requires-Dist: sphinxcontrib-jquery
+Requires-Dist: distro
+Requires-Dist: colorama
+Requires-Dist: pyopencl
+Requires-Dist: pyopengl
+Requires-Dist: siphash24
+Provides-Extra: pyqt5
+Requires-Dist: pyqt5; extra == "pyqt5"
+Requires-Dist: PyQtWebEngine; extra == "pyqt5"
 
 
 Package xrt is a python software library for ray tracing and wave propagation
@@ -159,28 +172,18 @@ The primary purpose of xrtGlow is to demonstrate the alignment correctness
 given the fact that xrtQook can automatically calculate several positional and
 angular parameters.
 
-Dependencies
+Installation
 ------------
 
-numpy, scipy and matplotlib are required. If you use OpenCL for calculations on
-GPU or CPU, you need AMD/NVIDIA drivers, ``Intel CPU only OpenCL runtime``
-(these are search key words), pytools and pyopencl. PyQt4 or PyQt5 are needed
-for xrtQook. Spyder (as library of Spyder IDE) is highly recommended for nicer
-view of xrtQook. OpenGL is required for xrtGlow.
+Install it by pip or conda or get xrt from `GitHub` and use it with or without
+installation.
 
-Get xrt
--------
-
-xrt is available as source distribution from `pypi.python.org
-<https://pypi.python.org/pypi/xrt>`_ and from `GitHub
-<https://github.com/kklmn/xrt>`_. The distribution archive also includes tests
-and examples. The complete documentation is available online at
-`Read the Docs <http://xrt.readthedocs.io>`_ and offline as
-`zip file at GitHub <https://github.com/kklmn/xrt-docs>`_.
+The distribution archive also includes tests and examples. The complete
+documentation is available online on `Read the Docs` and offline as zip file on
+GitHub`.
 
 Get help
 --------
 
-For getting help and/or reporting a bug please use `GitHub xrt Issues
-<https://github.com/kklmn/xrt/issues>`_.
+For getting help and/or reporting a bug please use `GitHub xrt Issues`.
 

{xrt-1.6.0 → xrt-1.6.1}/examples/withDummy/__init__.py

@@ -8,16 +8,20 @@ File: `\\examples\\withDummy\\logo_xrt.py`
 :mod:`xrt` logo (on the right, in two versions) created from a "flat" python
 logo (on the left).
 
- |ini_image|  -------------->  |logo_image|     |logo_image_inv|
++------------------+------------------+------------------+
+|   |ini_image|    |   |logo_image|   | |logo_image_inv| |
++------------------+------------------+------------------+
 
 .. |ini_image| imagezoom:: _images/logo-python.*
+   :alt:  "flat" python logo
    :scale: 50 %
-
 .. |logo_image| imagezoom:: _images/logo-xrt.*
+   :alt:  xrt logo with white background
    :scale: 50 %
-
 .. |logo_image_inv| imagezoom:: _images/logo-xrt-inv.*
+   :alt:  xrt logo with black background
    :scale: 50 %
+   :loc: upper-right-corner
 
 """
 pass

{xrt-1.6.0 → xrt-1.6.1}/examples/withRaycing/00_xRayCalculator/__init__.py

@@ -19,7 +19,12 @@ Each script consists of:
    energy, angles etc. and
 4) plotting.
 
-.. rubric:: Example 1a: Undulator
+Example 1a: Undulator
+~~~~~~~~~~~~~~~~~~~~~
+
+.. imagezoomhover:: _images/calc_undulator.png
+   :align: right
+
 .. code-block:: python
     :emphasize-lines: 6,7,12
 
@@ -41,14 +46,11 @@ Each script consists of:
     plt.plot(energy, flux)
     plt.show()
 
-.. imagezoomhover:: _images/calc_undulator.png
-   :width: 400
-   :height: 298
-   :loc: top: -400px; left: 400px;
-
-.. rubric:: Example 1b: Undulator, tuning curves
+Example 1b: Undulator, tuning curves
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Use the method:
+.. imagezoomhover:: _images/calc_undulator_tune.png
+   :align: right
 
 .. code-block:: python
 
@@ -57,12 +59,16 @@ Use the method:
 See the script
 ``\examples\withRaycing\00_xRayCalculator\calc_undulator_tune.py``.
 
-.. imagezoomhover:: _images/calc_undulator_tune.png
-   :width: 400
-   :height: 300
-   :loc: top: -400px; left: 400px;
+.. raw:: html
+
+    <div class="clearer"> </div>
+
+Example 2a: Crystal reflectivity
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. imagezoomhover:: _images/calc_crystal.png
+   :align: right
 
-.. rubric:: Example 2a: Crystal reflectivity
 .. code-block:: python
     :emphasize-lines: 6,11
 
@@ -81,22 +87,28 @@ See the script
     plt.plot(dtheta, abs(curS)**2, 'r', dtheta, abs(curP)**2, 'b')
     plt.show()
 
-.. imagezoomhover:: _images/calc_crystal.png
-   :width: 400
-   :height: 298
-   :loc: top: -400px; left: 400px;
+.. raw:: html
 
-.. rubric:: Example 2b: Crystal reflectivity: Single and double crystal
+    <div class="clearer"> </div>
+
+Example 2b: Crystal reflectivity: Single and double crystal
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. imagezoomhover:: _images/calc_crystal_rocking_curve.png
 
 See the script
 ``\examples\withRaycing\00_xRayCalculator\calc_crystal_rocking_curve.py``.
 
-.. imagezoomhover:: _images/calc_crystal_rocking_curve.png
-   :width: 400
-   :height: 300
-   :loc: top: -400px; left: 400px;
+.. raw:: html
+
+    <div class="clearer"> </div>
+
+Example 3: Multilayer reflectivity
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. imagezoomhover:: _images/calc_multilayer.png
+   :align: right
 
-.. rubric:: Example 3: Multilayer reflectivity
 .. code-block:: python
     :emphasize-lines: 1,2,3,7
 
@@ -111,12 +123,16 @@ See the script
     plt.plot(theta, abs(rs)**2, 'r', theta, abs(rp)**2, 'b')
     plt.show()
 
-.. imagezoomhover:: _images/calc_multilayer.png
-   :width: 400
-   :height: 298
-   :loc: top: -400px; left: 400px;
+.. raw:: html
+
+    <div class="clearer"> </div>
+
+Example 4: Mirror reflectivity
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. imagezoomhover:: _images/calc_mirror.png
+   :align: right
 
-.. rubric:: Example 4: Mirror reflectivity
 .. code-block:: python
     :emphasize-lines: 1,5
 
@@ -130,12 +146,17 @@ See the script
     plt.gca().set_xlim(E[0], E[-1])
     plt.show()
 
-.. imagezoomhover:: _images/calc_mirror.png
-   :width: 400
-   :height: 298
-   :loc: top: -400px; left: 400px;
+.. raw:: html
+
+    <div class="clearer"> </div>
+
+Example 5: Material absorption
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. imagezoomhover:: _images/calc_absorption.png
+   :align: right
+   :loc: lower-right-corner
 
-.. rubric:: Example 5: Material absorption
 .. code-block:: python
     :emphasize-lines: 1,4
 
@@ -148,10 +169,9 @@ See the script
     plt.gca().set_xlim(E[0], E[-1])
     plt.show()
 
-.. imagezoomhover:: _images/calc_absorption.png
-   :width: 400
-   :height: 298
-   :loc: top: -500px; left: 400px;
+.. raw:: html
+
+    <div class="clearer"> </div>
 
 """
 pass

xrt-1.6.1/examples/withRaycing/00_xRayCalculator/calc_undulator.py

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+"""Select one of the 3 functions at the end of main()"""
+__author__ = "Konstantin Klementiev, Roman Chernikov"
+__date__ = "22 Jan 2016"
+import numpy as np
+import matplotlib.pyplot as plt
+import time
+# path to xrt:
+import os, sys; sys.path.append(os.path.join('..', '..', '..'))  # analysis:ignore
+import xrt.backends.raycing.sources as rs
+
+wantUrgentUndulator = False
+
+
+def flux_through_aperture(energy, theta, psi, I0):
+    dtheta, dpsi = theta[1] - theta[0], psi[1] - psi[0]
+    flux = I0.sum(axis=(1, 2)) * dtheta * dpsi
+    plt.plot(energy, flux)
+
+
+def intensity_in_transverse_plane(energy, theta, psi, I0):
+    fig = plt.figure()
+    ax = fig.add_subplot(111)
+    ax.imshow(I0[len(energy)//2, :, :], origin="lower",
+              extent=[theta[0]*1e6, theta[-1]*1e6, psi[0]*1e6, psi[-1]*1e6])
+
+
+def colored_intensity_in_transverse_plane(energy, theta, psi, I0):
+    import matplotlib as mpl
+    fig = plt.figure(figsize=(7, 6))
+    ax = fig.add_axes([0.15*6/7, 0.15, 0.7*6/7, 0.7])
+    ax.set_xlabel(u'$\\theta$ (µrad)')
+    ax.set_ylabel(u'$\\psi$ (µrad)')
+    axC = fig.add_axes([0.95*6/7, 0.15, 0.05, 0.7])
+    plt.setp(axC.get_xticklabels(), visible=False)
+    axC.yaxis.set_label_position("right")
+    axC.yaxis.tick_right()
+    axC.set_xlim([0, 1])
+    axC.set_ylim([energy[0], energy[-1]])
+    axC.set_ylabel('energy (eV)')
+
+    hue, tmp, tmp = np.meshgrid(energy, theta, psi, indexing='ij')
+    hue -= hue.min()
+    hue /= hue.max()
+    sat = np.ones_like(hue)
+    val = I0 / I0.max()
+    # hsvI0 = np.stack((hue, sat, val), axis=3) # numpy1.10
+    hsvI0 = np.zeros([d for d in hue.shape] + [3])
+    hsvI0[:, :, :, 0] = hue
+    hsvI0[:, :, :, 1] = sat
+    hsvI0[:, :, :, 2] = val
+
+    rgbI0 = mpl.colors.hsv_to_rgb(hsvI0)
+    rgbI0sum = rgbI0.sum(axis=0)
+    ax.imshow(rgbI0sum / rgbI0sum.max(), origin="lower",
+              extent=[theta[0]*1e6, theta[-1]*1e6, psi[0]*1e6, psi[-1]*1e6])
+
+    hue = np.array(energy)[:, np.newaxis]
+    hue -= hue.min()
+    hue /= hue.max()
+    sat = np.ones_like(hue)
+    val = np.ones_like(hue)
+    # hsvC = np.stack((hue, sat, val), axis=2) # numpy1.10
+    hsvC = np.zeros([d for d in hue.shape] + [3])
+    hsvC[:, :, 0] = hue
+    hsvC[:, :, 1] = sat
+    hsvC[:, :, 2] = val
+    rgbC = mpl.colors.hsv_to_rgb(hsvC)
+    axC.imshow(rgbC / rgbC.max(), aspect='auto', origin='lower',
+               extent=[0, 1, energy[0], energy[-1]])
+
+
+def main():
+    energy = np.linspace(3850, 4150, 601)
+    theta = np.linspace(-1, 1, 51) * 30e-6
+    psi = np.linspace(-1, 1, 51) * 30e-6
+    kwargs = dict(eE=3.0, eI=0.5, eEpsilonX=0.263, eEpsilonZ=0.008,
+                  betaX=9.539, betaZ=1.982, period=18.5, n=108, K=0.52,
+                  xPrimeMax=theta[-1]*1e3, zPrimeMax=psi[-1]*1e3,
+                  # targetOpenCL='CPU',
+                  distE='BW')
+
+    source = rs.Undulator(**kwargs)
+    I0, l1, l2, l3 = source.intensities_on_mesh(energy, theta, psi)
+
+    flux_through_aperture(energy, theta, psi, I0)
+
+    if wantUrgentUndulator:
+        kwargs['eSigmaX'] = (kwargs['eEpsilonX']*kwargs['betaX']*1e3)**0.5
+        kwargs['eSigmaZ'] = (kwargs['eEpsilonZ']*kwargs['betaZ']*1e3)**0.5
+        del kwargs['distE']
+        del kwargs['betaX']
+        del kwargs['betaZ']
+        kwargs['eMin'] = energy[0]
+        kwargs['eMax'] = energy[-1]
+        kwargs['eN'] = len(energy)
+        kwargs['icalc'] = 3
+        kwargs['nx'] = len(theta)//2
+        kwargs['nz'] = len(psi)//2
+        import xrt.backends.raycing as raycing
+        beamLine = raycing.BeamLine(azimuth=0, height=0)
+        sourceU = rs.UndulatorUrgent(beamLine, **kwargs)
+
+        I0, l1, l2, l3 = sourceU.intensities_on_mesh()
+        I0 = np.concatenate((I0[:, :0:-1, :], I0), axis=1)
+        I0 = np.concatenate((I0[:, :, :0:-1], I0), axis=2)
+        urgentEnergy = sourceU.Es
+        flux_through_aperture(urgentEnergy, theta, psi, I0*1e6)
+
+    # intensity_in_transverse_plane(energy, theta, psi, I0)
+    # colored_intensity_in_transverse_plane(energy, theta, psi, I0)
+
+
+if __name__ == '__main__':
+    t0 = time.time()
+    main()
+    print("Done in {0} s".format(time.time()-t0))
+    plt.show()

{xrt-1.6.0 → xrt-1.6.1}/examples/withRaycing/00_xRayCalculator/calc_undulator_tune.py

@@ -31,7 +31,7 @@ for tuneE, tuneF, harmonic, color in zip(tunesE, tunesF, harmonics, colors):
                color=color)
 # format the graph:
 ax = plt.gca()
-ax.set_xlabel(u'energy (eV)')
+ax.set_xlabel(u'energy (keV)')
 ax.set_ylabel(u'flux through (60 µrad)² (ph/s/0.1% bw)')
 ax.set_xlim(xlims)
 ax.set_ylim(ylims)

{xrt-1.6.0 → xrt-1.6.1}/examples/withRaycing/01_SynchrotronSources/synchrotronSources.py

@@ -117,26 +117,29 @@ sources in 2D and 3D. This is especially useful for undulators because they
 have sharp peaks, which requires a proper selection of angular and energy
 meshes.
 
-|I0_x'E|  |I0_z'E|  |IpPol|
++------------+------------+------------+
+|  |I0_x'E|  |  |I0_z'E|  |   |IpPol|  |
++------------+------------+------------+
 
 .. |I0_x'E| imagezoom:: _images/I0_x'E-1-und-xrt.png
 .. |I0_z'E| imagezoom:: _images/I0_z'E-1-und-xrt.png
 .. |IpPol| imagezoom:: _images/Itot
+   :loc: upper-right-corner
 
 The ray traced images of an undulator source (produced by
 ``\examples\withRaycing\01_SynchrotronSources\synchrotronSources.py``)
 are feature-rich. The polarization is primarily horizontal. The off-plane
 radiation has non-zero projection to the vertical polarization plane.
 
-+---------+----------------+----------------+----------------+----------------+
-| source  |   total flux   | hor. pol. flux | ver. pol. flux |  deg. of pol.  |
-+=========+================+================+================+================+
-| using   |                |                |                |                |
-| Urgent  | |uTotalUr|     |   |uHorizUr|   |    |uVertUr|   | |uDegPolUr|    |
-+---------+----------------+----------------+----------------+----------------+
-| internal|                |                |                |                |
-| xrt     | |uTotalXRT|    |  |uHorizXRT|   |    |uVertXRT|  | |uDegPolXRT|   |
-+---------+----------------+----------------+----------------+----------------+
++--------+----------------+----------------+----------------+----------------+
+| source |   total flux   | hor. pol. flux | ver. pol. flux |  deg. of pol.  |
++========+================+================+================+================+
+| using  |                |                |                |                |
+| Urgent | |uTotalUr|     |   |uHorizUr|   |    |uVertUr|   | |uDegPolUr|    |
++--------+----------------+----------------+----------------+----------------+
+|        |                |                |                |                |
+| xrt    | |uTotalXRT|    |  |uHorizXRT|   |    |uVertXRT|  | |uDegPolXRT|   |
++--------+----------------+----------------+----------------+----------------+
 
 .. |uTotalUr| imagezoom:: _images/1u_urgent3-n-monoE-1TotalFlux.png
 .. |uHorizUr| imagezoom:: _images/1u_urgent3-n-monoE-2horizFlux.png
@@ -308,8 +311,8 @@ __date__ = "08 Mar 2016"
 import os, sys; sys.path.append(os.path.join('..', '..', '..'))  # analysis:ignore
 import time
 import numpy as np
-#import matplotlib
-#matplotlib.use("Agg")
+# import matplotlib
+# matplotlib.use("Agg")
 import xrt.backends.raycing as raycing
 import xrt.backends.raycing.sources as rs
 import xrt.backends.raycing.screens as rsc
@@ -323,11 +326,11 @@ showIn3D = False
 sourceType = 'u'
 # one of 'mono', '1harmonic', 'smaller', 'wide'
 energyRange = '1harmonic'
-#energyRange = 'mono'
-#energyRange = 'wide'
+# energyRange = 'mono'
+# energyRange = 'wide'
 what = 'rays'
-#what = 'wave'  # only for rs.Undulator
-#suffix = '_fullLength_emittance_NF'
+# what = 'wave'  # only for rs.Undulator
+# suffix = '_fullLength_emittance_NF'
 suffix = ''
 isInternalSource = True  # xrt source or (Urgent or WS)
 limitsFSM0X = 'symmetric'
@@ -344,7 +347,7 @@ if sourceType == 'u':
     Kmax = 1.92
     kwargs = dict(
         eE=3., eI=0.5,  # Parameters of the synchrotron ring [GeV], [Ampere]
-        #eEspread=0.001,  # Energy spread of the electrons in the ring
+        # eEspread=0.001,  # Energy spread of the electrons in the ring
         period=30., n=40,  # Parameters of the undulator, period in [mm]
         K=1.45,  # Deflection parameter (ignored if targetE is not None)
         # targetE=[6940, 5, False],  # [energy [eV], harmonic]
@@ -358,11 +361,11 @@ if sourceType == 'u':
         # gIntervals=5,  # Number of the integration intervals. Should be
         # increased for the near field and custom magnetic field cases.
         # gp=1e-2,  # Precision of the integration.
-#        targetOpenCL=(0, 0),
-#        targetOpenCL='CPU',
-#        precisionOpenCL='float32',
-        #taper = [0 ,10],
-        #eEpsilonX=0.0, eEpsilonZ=0.0)  # Emittance [nmrad]
+        # targetOpenCL=(0, 0),
+        # targetOpenCL='CPU',
+        # precisionOpenCL='float32',
+        # taper = [0 ,10],
+        # eEpsilonX=0.0, eEpsilonZ=0.0)  # Emittance [nmrad]
         eEpsilonX=0.263, eEpsilonZ=0.008)  # Emittance [nmrad]
     xlimits = [-10, 10]  # Horizontal limits of the plot [mm]
     zlimits = [-10, 10]  # Vertical limits of the plot [mm]
@@ -518,7 +521,7 @@ def define_plots(beamLine):
     plotsE = []
 
     xaxis = xrtp.XYCAxis(r'$y$', 'mm', bins=256)
-    yaxis = xrtp.XYCAxis(r'$x$', '$\mu$m', limits='symmetric')
+    yaxis = xrtp.XYCAxis(r'$x$', r'$\mu$m', limits='symmetric')
     caxis = xrtp.XYCAxis('energy', eUnit, fwhmFormatStr=None)
     plot = xrtp.XYCPlot(
         'beamSource', (1,), xaxis=xaxis, yaxis=yaxis, caxis=caxis,
@@ -529,7 +532,7 @@ def define_plots(beamLine):
     plotsE.append(plot)
 
     xaxis = xrtp.XYCAxis(r'$y$', 'mm', bins=256)
-    yaxis = xrtp.XYCAxis(r'$z$', '$\mu$m', limits='symmetric')
+    yaxis = xrtp.XYCAxis(r'$z$', r'$\mu$m', limits='symmetric')
     caxis = xrtp.XYCAxis('energy', eUnit, fwhmFormatStr=None)
     plot = xrtp.XYCPlot(
         'beamSource', (1,), xaxis=xaxis, yaxis=yaxis, caxis=caxis,
@@ -539,9 +542,9 @@ def define_plots(beamLine):
     plots.append(plot)
     plotsE.append(plot)
 
-    xaxis = xrtp.XYCAxis(r'$x$', '$\mu$m', limits=limitsFSM0X,
+    xaxis = xrtp.XYCAxis(r'$x$', r'$\mu$m', limits=limitsFSM0X,
                          bins=bins, ppb=ppb)
-    yaxis = xrtp.XYCAxis(r'$z$', '$\mu$m', limits=limitsFSM0Z,
+    yaxis = xrtp.XYCAxis(r'$z$', r'$\mu$m', limits=limitsFSM0Z,
                          bins=bins, ppb=ppb)
     caxis = xrtp.XYCAxis('energy', eUnit, fwhmFormatStr=None,
                          bins=bins, ppb=ppb)
@@ -554,7 +557,7 @@ def define_plots(beamLine):
     plotsE.append(plot)
 
     beam = 'beamFSM0'
-    xaxis = xrtp.XYCAxis(r'$x$', '$\mu$m', limits=limitsFSM0X)
+    xaxis = xrtp.XYCAxis(r'$x$', r'$\mu$m', limits=limitsFSM0X)
     yaxis = xrtp.XYCAxis(r"$x'$", 'mrad', limits=xPrimelimits)
     caxis = xrtp.XYCAxis('energy', eUnit, fwhmFormatStr=None)
     plot = xrtp.XYCPlot(
@@ -565,7 +568,7 @@ def define_plots(beamLine):
     plots.append(plot)
     plotsE.append(plot)
 
-    xaxis = xrtp.XYCAxis(r'$x$', '$\mu$m', limits=[-80, 80])
+    xaxis = xrtp.XYCAxis(r'$x$', r'$\mu$m', limits=[-80, 80])
     yaxis = xrtp.XYCAxis(r"$x'$", 'mrad', limits=[-0.15, 0.15])
     caxis = xrtp.XYCAxis('energy', eUnit, fwhmFormatStr=None)
     plot = xrtp.XYCPlot(
@@ -585,7 +588,7 @@ def define_plots(beamLine):
         aspect='auto', title='total flux')
     plot.caxis.fwhmFormatStr = None
     plot.saveName = prefix + '1TotalFlux' + suffix + '.png'
-    #plot.persistentName = prefix + '1TotalFlux' + suffix + '.mat'
+    # plot.persistentName = prefix + '1TotalFlux' + suffix + '.mat'
     plots.append(plot)
     plotsE.append(plot)
     ax = plot.xaxis
@@ -741,5 +744,6 @@ def main():
                              # afterScript=afterScript, afterScriptArgs=plots,
                              beamLine=beamLine)
 
+
 if __name__ == '__main__':
     main()

{xrt-1.6.0 → xrt-1.6.1}/examples/withRaycing/01_SynchrotronSources/undulatorVortex.py

@@ -50,7 +50,7 @@ correct incoherent averaging. The image brightness represents intensity.
 |              |   zero emittance,      |   true emittance,      |
 |              |   zero energy spread   |   true energy spread   |
 +==============+========================+========================+
-|   |resTxt|   |       .. centered::  |U48results|               |
+|   |resTxt|   |                 |U48results|                    |
 +--------------+------------------------+------------------------+
 | 1st harmonic |      |U48Esh1-00|      |      |U48Esh1-ff|      |
 +--------------+------------------------+------------------------+
@@ -63,6 +63,7 @@ correct incoherent averaging. The image brightness represents intensity.
 
 .. |resTxt| replace:: Flux and vorticity
 .. |U48results| imagezoom:: _images/U48-flux-vorticity.png
+   :align: center
 .. |U48Esh1-00| imagezoom:: _images/U48-00-Es-OAM-transverse-image-140-352.727eV.png
 .. |U48Esh1-ff| imagezoom:: _images/U48-ff-Es-OAM-transverse-image-140-352.727eV.png
    :loc: upper-right-corner
@@ -99,7 +100,11 @@ import xrt.backends.raycing.sources as rs
 period, n = 48., 83
 Kx = Ky = 2  # E1 = 356.1 eV
 
-prefix = 'U48-ff'
+prefix = 'U48-00'  # 0 emittance, 0 eSpread
+# prefix = 'U48-f0'  # true emittance, 0 eSpread
+# prefix = 'U48-ff'  # true emittance, true eSpread
+# also comment/uncomment right parameters in undulatorKwargs
+
 thetaMax, psiMax = 180e-6, 180e-6  # rad
 energy = np.linspace(200., 1400., 1101)
 imageEnergy = [352., 621., 919., 1220.]
@@ -111,10 +116,10 @@ undulatorKwargs = dict(
     eE=3., eI=0.3,
     betaX=9., betaZ=2.,  # m
 
-    # eEpsilonX=0., eEpsilonZ=0.,
-    eEpsilonX=0.300, eEpsilonZ=0.008,  # nmrad
-    # eEspread=0.,
-    eEspread=0.001,
+    eEpsilonX=0., eEpsilonZ=0.,
+    # eEpsilonX=0.300, eEpsilonZ=0.008,  # nmrad
+    eEspread=0.,
+    # eEspread=0.001,
 
     period=period, n=n, Ky=Ky, Kx=Kx,
 
@@ -159,7 +164,7 @@ def plot_results():
     with open(outName, 'rb') as f:
         energy, fluxFF, vEssFF = pickle.load(f)[0:3]
 
-    fig = plt.figure(figsize=(6, 6))
+    fig = plt.figure(figsize=(6, 4))
     ax = fig.add_subplot(111)
     ax.set_xlabel(r'Energy (eV)')
     ax.set_ylabel(r'Flux (ph/s/0.1%bw)')
@@ -173,15 +178,17 @@ def plot_results():
     y = fluxFF * energy * 1e-3
     ax.plot(energy, y, label='flux, true emittance, true eSpread')
     ax.set_ylim(0, None)
-    ax.legend(loc=(0.22, 0.84))
+    ax.legend(loc=(0., 0.78))
 
-    ax2.plot(energy, vEss00, '--', label='vort, 0 emittance, 0 eSpread')
-    ax2.plot(energy, vEssF0, '--', label='vort, true emittance, 0 eSpread')
-    ax2.plot(energy, vEssFF, '--', label='vort, true emittance, true eSpread')
+    ax2.plot(energy, vEss00, '--', label='vorticity, 0 emittance, 0 eSpread')
+    ax2.plot(energy, vEssF0, '--', label='vorticity, true emittance, 0 eSpread')
+    ax2.plot(energy, vEssFF, '--', label='vorticity, true emittance, true eSpread')
     ax2.set_ylim(0, 3.7)
-    ax2.legend(loc=(0.22, 0.68))
+    ax2.legend(loc=(0., 0.56))
+    plt.tight_layout()
 
-    fig.savefig(prefix+"-flux-vorticity.png")
+    fig.savefig("flux-vorticity.png")
+    fig.savefig("flux-vorticity.pdf")
     plt.show()
 
 
@@ -191,7 +198,7 @@ def intensity_in_transverse_plane(ie, theta, psi, I0):
     ax.set_xlabel(r'θ (µrad)')
     ax.set_ylabel(r'ψ (µrad)')
     e = energy[ie]
-    ax.imshow(I0[:, :].T,
+    ax.imshow(I0[:, :].T, origin="lower",
               extent=[theta[0]*1e6, theta[-1]*1e6, psi[0]*1e6, psi[-1]*1e6])
     ax.text(0.98, 0.98, '@E={0:.1f}eV'.format(e),
             ha='right', va='top', color='white', transform=ax.transAxes)
@@ -220,7 +227,7 @@ def colored_intensity_in_transverse_plane(energy, theta, psi, I0):
     hsvI0 = np.stack((hue, sat, val), axis=3)  # (len(energy), ntheta, npsi, 3)
     rgbI0 = mpl.colors.hsv_to_rgb(hsvI0)
     rgbI0sum = rgbI0.sum(axis=0)
-    ax.imshow(np.swapaxes(rgbI0sum, 0, 1) / rgbI0sum.max(),
+    ax.imshow(np.swapaxes(rgbI0sum, 0, 1) / rgbI0sum.max(), origin="lower",
               extent=[theta[0]*1e6, theta[-1]*1e6, psi[0]*1e6, psi[-1]*1e6])
 
     hue = np.array(energy)[:, np.newaxis]
@@ -257,7 +264,7 @@ def colored_phase_in_transverse_plane(ie, theta, psi, I0, phase, vorticity,
     hue = (phase/np.pi + 1) * 0.5
     hsvI0 = np.stack((hue, sat, val), axis=2)
     rgbI0 = mpl.colors.hsv_to_rgb(hsvI0)  # (len(energy), ntheta, npsi, 3)
-    ax.imshow(np.swapaxes(rgbI0, 0, 1) / rgbI0.max(),
+    ax.imshow(np.swapaxes(rgbI0, 0, 1) / rgbI0.max(), origin="lower",
               extent=[theta[0]*1e6, theta[-1]*1e6, psi[0]*1e6, psi[-1]*1e6])
     ax.text(0, 1.01, '@E={0:.1f}eV'.format(e),
             ha='left', va='bottom', color='k', transform=ax.transAxes)
@@ -359,6 +366,7 @@ def grid_method():
 if __name__ == '__main__':
     t0 = time.time()
     # raycing._VERBOSITY_ = 100
-    grid_method()
-    # plot_results()
+
+    grid_method()  # first run this with 3 settings, see prefix
+    # plot_results()  # ... then this
     print("Done in {0} s".format(time.time()-t0))