xrt 1.5.0__zip → 1.6.1__zip

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

@@ -31,9 +31,9 @@ recursive-include examples\withShadow\03\tmp0 *
 recursive-include examples\withShadow\04_06 *.py
 recursive-include examples\withShadow\04_06\tmp0 *
 recursive-include tests *.py
-recursive-include tests\raycing\XOP-Reflectivities *
-recursive-include tests\raycing\XOP-RockingCurves *
 recursive-include tests\raycing\CXRO-Reflectivities *
+recursive-include tests\raycing\IR *
 recursive-include tests\raycing\misc *
-recursive-include tests\raycing\XOP-RockingCurves-Bent *
-recursive-include xrt\xrtQook *.py *.pyw
+recursive-include tests\raycing\RemoteOpenCLCalculation *
+recursive-include tests\raycing\XOP-Reflectivities *
+recursive-include tests\raycing\XOP-RockingCurves *

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xrt
-Version: 1.5.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,30 +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.5.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.5.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_crystal.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+__author__ = "Konstantin Klementiev, Roman Chernikov"
+__date__ = "22 Jan 2016"
+import numpy as np
+import matplotlib.pyplot as plt
+# path to xrt:
+import os, sys; sys.path.append(os.path.join('..', '..', '..'))  # analysis:ignore
+import xrt.backends.raycing.materials as rm
+
+try:
+    import pyopencl as cl
+    os.environ['PYOPENCL_COMPILER_OUTPUT'] = '1'
+    isOpenCL = True
+except ImportError:
+    isOpenCL = False
+
+if isOpenCL:
+    import xrt.backends.raycing.myopencl as mcl
+    matCL = mcl.XRT_CL(r'materials.cl',
+                       precisionOpenCL='float32',
+                       # precisionOpenCL='float64',
+                       # targetOpenCL='CPU'
+                       )
+else:
+    matCL = None
+
+crystal = rm.CrystalSi(hkl=(1, 1, 1), t=0.3)
+
+E = 9728
+dtheta = np.linspace(-120, 120, 1501)
+print(np.degrees(crystal.get_Bragg_angle(E)))
+theta = crystal.get_Bragg_angle(E) + dtheta*1e-6
+curS, curP = crystal.get_amplitude_pytte(E, -np.sin(theta), ucl=matCL, Ry=1e5,
+                                         alphaAsym=np.radians(5))
+#curS, curP = crystal.get_amplitude(E, -np.sin(theta))
+print(crystal.get_a())
+print(crystal.get_F_chi(E, 0.5/crystal.d))
+print(u'Darwin width at E={0:.0f} eV is {1:.5f} µrad for s-polarization'.
+      format(E, crystal.get_Darwin_width(E) * 1e6))
+
+plt.figure()
+plt.plot(dtheta, abs(curS)**2, 'r', dtheta, abs(curP)**2, 'b')
+plt.gca().set_xlabel(u'$\\theta - \\theta_{B}$ (µrad)')
+plt.gca().set_ylabel(r'reflectivity')
+plt.show()

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.5.0 → xrt-1.6.1}/examples/withRaycing/00_xRayCalculator/calc_undulator_power.py

@@ -5,10 +5,10 @@ import numpy as np
 import matplotlib.pyplot as plt
 import xrt.backends.raycing.sources as rs
 
-print("please wait...")
 source = rs.Undulator(eE=3.0, eI=0.5, eEpsilonX=0.263, eEpsilonZ=0.008,
                       betaX=9., betaZ=2., period=19.3, n=101, K=0.52,
                       eEspread=0*1e-3, distE='BW')
+print("please wait...")
 
 energy = np.linspace(1000, 31000, 1501)
 theta = np.linspace(-1, 1, 21) * 30e-6

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

@@ -8,10 +8,10 @@ import matplotlib.pyplot as plt
 from matplotlib.ticker import FormatStrFormatter
 import xrt.backends.raycing.sources as rs
 
-print("please wait...")
 source = rs.Undulator(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,
                       eEspread=0*8e-4, distE='BW', gIntervals=2)
+print("please wait...")
 
 energy = np.linspace(2000, 30000, 5601)
 theta = np.linspace(-1, 1, 11) * 30e-6  # 60 µrad opening
@@ -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)