xrt 1.6.0__zip → 1.6.1__zip

{xrt-1.6.0 → xrt-1.6.1}/examples/withRaycing/11_Waves/waveGrating.py

@@ -7,6 +7,15 @@ r"""
 Diffraction from grating
 ------------------------
 
+.. imagezoom:: _images/1-LEG_E-orders-tr1.*
+   :align: right
+
+.. imagezoom:: _images/1-LEG_E-orders-x.*
+   :align: right
+
+.. imagezoom:: _images/1-LEG_E-orders-z.*
+   :align: right
+
 Various gratings described in [Boots]_ have been tested with xrt for
 diffraction efficiency. The efficiency curves in [Boots]_ were calculated by
 means of the code ``peg`` which provides almost identical results to those by
@@ -32,16 +41,6 @@ ray tracing approach. In that approach the rays were deflected according to the
 grating equation. Here, in wave propagation, the grating equation was only used
 to position the screen.
 
-.. imagezoom:: _images/1-LEG_E-orders-tr1.*
-
-\
-
-.. imagezoom:: _images/1-LEG_E-orders-x.*
-
-\
-
-.. imagezoom:: _images/1-LEG_E-orders-z.*
-
 Notice that in contrast to the conventional grating theories (also used in
 ``REFLEC``), the diffraction orders here have the sagittal dimension. And that
 dimension has diffraction fringes and a variable width, too!
@@ -60,12 +59,16 @@ rapid low-energy decrease. It seems that the detector had a pinhole that might
 cut the beam at low energies as the diffracted beam becomes wider there (see
 the transverse pictures above), which may explain lower measured efficiency.
 
-.. imagezoom:: _images/1-LEG_E-eff.*
-
-For the IMP grating ("impurity", see its properties in the figure below), the
+For the IMP grating ("impurity", see its properties in the figure), the
 difference is bigger.
 
-.. imagezoom:: _images/2-IMP_E-eff.*
++------------+------------+
+|  |greff1|  |  |greff2|  |
++------------+------------+
+
+.. |greff1| imagezoom:: _images/1-LEG_E-eff.*
+.. |greff2| imagezoom:: _images/2-IMP_E-eff.*
+   :loc: upper-right-corner
 
 We believe that ``REFLEC`` is essentially wrong at high energies. If we
 mentally translate the working terraces of a blazed grating to form a
@@ -80,8 +83,13 @@ portion of the front side behind it stay in the shadow. We compare the two
 gratings shown below, one is with 90 degree anti-blaze angle and the other is
 with *pitch* as anti-blaze angle.
 
-.. imagezoom:: _images/1-LEG_profile-adhoc.*
-.. imagezoom:: _images/1-LEG_profile-anti.*
++------------+------------+
+|  |greff3|  |  |greff4|  |
++------------+------------+
+
+.. |greff3| imagezoom:: _images/1-LEG_profile-adhoc.*
+.. |greff4| imagezoom:: _images/1-LEG_profile-anti.*
+   :loc: upper-right-corner
 
 ``REFLEC`` gives different efficiencies for these two cases (see above) whereas
 xrt cannot distinguish them. We tried to artificially remove the shadows by
@@ -91,9 +99,6 @@ high-energy efficiency, similarly to the ``REFLEC``'s behaviour.
 The factors which definitely will affect the efficiency are (1) restricted
 coherence radius and (2) roughness. Both will be added into this example in a
 later release of xrt.
-
-We are open for further discussion on the above results with interested
-scientists.
 """
 #Set proper setting for the grating and comment/uncomment one of the three main
 #invoked functions (at the very bottom).

{xrt-1.6.0 → xrt-1.6.1}/examples/withRaycing/11_Waves/waveMirrors.py

@@ -18,12 +18,14 @@ difference in the calculated flux between the rays and the waves.
 
 .. |mirrorWR| imagezoom:: _images/mirror-256-01flat-01-beamFSMrays_f.*
 .. |mirrorWW| imagezoom:: _images/mirror-256-01flat-02-beamFSMwave_f.*
+   :loc: upper-right-corner
 
 The flux losses are not due to the integration errors, as was proven by
 variously dense meshes. The losses are solely caused by cutting the tails, as
 proven by a wider image shown below.
 
 .. imagezoom:: _images/mirror-256wide-01flat-02-beamFSMwave_f.*
+   :align: center
 
 """
 __author__ = "Konstantin Klementiev", "Roman Chernikov"

xrt-1.6.1/examples/withRaycing/13_Warping/ExampleOfSlopeErrorMapToParametricMirror.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+__date__ = "20 Jan 2024"
+# import sys
+# sys.path.append(r"C:\Ray-tracing")
+import numpy as np
+from scipy import ndimage
+# import pickle
+
+import xrt.backends.raycing.oes as roe
+
+
+class EllipticalMirrorParamNOM(roe.EllipticalMirrorParam):
+    def __init__(self, *args, **kwargs):
+        kwargs = self.__pop_kwargs(**kwargs)
+        super().__init__(*args, **kwargs)
+        self.nom_read()
+
+    def __pop_kwargs(self, **kwargs):
+        self.waviness = kwargs.pop('figureError')  # file name
+        return kwargs
+
+    def nom_read(self):
+        # here, the file self.waviness has this structure:
+        # x[mm]  y[mm]  z[nm]
+        # 30.00  29.75  -31.498373
+        # 30.50  29.75  -32.992258
+        # 31.00  29.75  -33.864061
+        # 31.50  29.75  -34.240630
+        # ...
+        xL, yL, zL = np.loadtxt(self.waviness, unpack=True)
+        nX = (yL == yL[0]).sum()
+        nY = (xL == xL[0]).sum()
+        x = xL[:nX]
+        y = yL[::nX]
+        z = zL.reshape((nY, nX))
+        dx = x[1] - x[0]
+        dy = y[1] - y[0]
+        b, a = np.gradient(z)  # NOM x is along (our y) and y is across (our x)
+        # a, b = np.gradient(z)  # NOM x is across and y is along
+        a = np.arctan(a/dy)
+        b = np.arctan(b/dx)
+        self.nom_rmsA = ((a**2).sum() / (nX * nY))**0.5
+        self.nom_rmsB = ((b**2).sum() / (nX * nY))**0.5
+        self.nom_splineZ = ndimage.spline_filter(z.T) * 1e-6  # mm to nm
+        self.nom_splineA = ndimage.spline_filter(a.T) * 1e-6  # rad to µrad
+        self.nom_splineB = ndimage.spline_filter(b.T) * 1e-6  # rad to µrad
+        self.nom_nX = nX
+        self.nom_nY = nY
+        self.nom_x = x
+        self.nom_y = y
+
+    def local_r_distorted(self, s, phi):
+        r = self.local_r(s, phi)
+        x, y, z = self.param_to_xyz(s, phi, r)
+        # if NOM x is along (our y) and y is across (our x):
+        coords = np.array([
+            (y/(self.nom_x[-1]-self.nom_x[0]) + 0.5) * (self.nom_nX-1),
+            (x/(self.nom_y[-1]-self.nom_y[0]) + 0.5) * (self.nom_nY-1)])
+        # coords.shape = (2, self.nrays)
+        z += ndimage.map_coordinates(self.nom_splineZ, coords, prefilter=True)
+        s1, phi1, r1 = self.xyz_to_param(x, y, z)
+        return r1 - r
+
+    def local_n_distorted(self, s, phi):
+        r = self.local_r(s, phi)
+        x, y, z = self.param_to_xyz(s, phi, r)
+        # if NOM x is along (our y) and y is across (our x):
+        coords = np.array([
+            (y/(self.nom_x[-1]-self.nom_x[0]) + 0.5) * (self.nom_nX-1),
+            (x/(self.nom_y[-1]-self.nom_y[0]) + 0.5) * (self.nom_nY-1)])
+        # coords.shape = (2, self.nrays)
+        a = ndimage.map_coordinates(self.nom_splineA, coords, prefilter=True)
+        b = ndimage.map_coordinates(self.nom_splineB, coords, prefilter=True)
+        return -a, -b

{xrt-1.6.0 → xrt-1.6.1}/examples/withRaycing/13_Warping/warp.py

@@ -69,7 +69,6 @@ focusing case.
 .. |warp_rtG| animation:: _images/warp_rtG
 .. |warp_rtw| animation:: _images/warp_rtw
 .. |warp_rtN| animation:: _images/warp_rtN
-   :loc: lower-left-corner
 .. |warp_wp0| animation:: _images/warp_wp0
    :loc: upper-right-corner
 .. |warp_wpG| animation:: _images/warp_wpG
@@ -393,7 +392,7 @@ def define_plots(beamLine):
             ePos=0, title='2-refl')
         Rstr = '{0:.1f}km'.format(R*1e-6) if R < 1e19 else 'inf'
         plotRefl.saveName = '{0}-{1}-R={2}.png'.format(prefix, iR, Rstr)
-        Rstr = '{0:.1f} km'.format(R*1e-6) if R < 1e19 else '$\infty$'
+        Rstr = '{0:.1f} km'.format(R*1e-6) if R < 1e19 else r'$\infty$'
         plotRefl.textPanel = plotRefl.ax2dHist.text(
             0.01, 0.01, 'R = {0}'.format(Rstr),
             transform=plotRefl.ax2dHist.transAxes, size=12,
@@ -423,5 +422,5 @@ def main():
 
 
 if __name__ == '__main__':
-    # see_the_bump()
-    main()
+    see_the_bump()
+    # main()

{xrt-1.6.0 → xrt-1.6.1}/examples/withRaycing/14_SoftiMAX/__init__.py

@@ -5,6 +5,9 @@ r"""
 SoftiMAX at MAX IV
 ------------------
 
+.. imagezoom:: _images/softiMAX_layout.*
+   :align: right
+
 The images below are produced by scripts in
 ``\examples\withRaycing\14_SoftiMAX``.
 
@@ -12,10 +15,11 @@ The beamline will have two branches:
 - STXM (Scanning Transmission X-ray Microscopy) and
 - CXI (Coherent X-ray Imaging),
 
-see the scheme provided by K. Thånell.
+see the scheme provided by Karina Thånell.
 
-.. imagezoom:: _images/softiMAX_layout.*
+.. raw:: html
 
+    <div class="clearer"> </div>
 
 STXM branch
 ~~~~~~~~~~~
@@ -34,6 +38,7 @@ end (FE) slit, to M1, to M2 and to plane grating (PG) – is done with rays:
 .. |st_rFE| imagezoom:: _images/stxm-2D-1-rays-0emit-0enSpread-monoE-00-FE.*
 .. |st_rM1| imagezoom:: _images/stxm-2D-1-rays-0emit-0enSpread-monoE-01-M1local.*
 .. |st_rM2| imagezoom:: _images/stxm-2D-1-rays-0emit-0enSpread-monoE-02-M2local.*
+   :loc: upper-right-corner
 .. |st_rPG| imagezoom:: _images/stxm-2D-1-rays-0emit-0enSpread-monoE-02a-PGlocal.*
    :loc: upper-right-corner
 
@@ -229,6 +234,7 @@ below. This is in contrast to *ray* propagation, where the angular ray
 distribution is invariant at any position between two optical elements.
 
 .. imagezoom:: _images/cxi_waveFronts.*
+   :align: center
 
 .. rubric:: Rays, waves and hybrid
 
@@ -312,6 +318,7 @@ coherent fraction.
 
 .. |cxi-coh1-0emit| animation:: _images/cxi-coh1-0emit
 .. |cxi-coh1-non0e| animation:: _images/cxi-coh1-non0e
+   :loc: upper-right-corner
 .. |cxi-coh3-0emit| animation:: _images/cxi-coh3-0emit
 .. |cxi-coh3-non0e| animation:: _images/cxi-coh3-non0e
    :loc: upper-right-corner

{xrt-1.6.0 → xrt-1.6.1}/setup.py

@@ -143,36 +143,26 @@ 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`.
 
 """
 
 setup(
     name='xrt',
-    version='1.6.0',
+    version='1.6.1',
     description='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 '
@@ -203,8 +193,15 @@ setup(
     install_requires=['numpy>=1.8.0', 'scipy>=0.17.0', 'matplotlib>=2.0.0',
                       'sphinx>=1.6.2', 'sphinxcontrib-jquery', 'distro',
                       'colorama',
+                      # GPU support
+                      'pyopencl',
+                      # glow support
+                      'pyopengl', 'siphash24'
                       # 'openpyxl',
                       ],
+    extras_require={
+                    'pyqt5': ['pyqt5', 'PyQtWebEngine']
+                    },
     classifiers=['Development Status :: 5 - Production/Stable',
                  'Intended Audience :: Science/Research',
                  'Natural Language :: English',

xrt-1.6.1/tests/raycing/_SynchrotronSources/MAX-IV-IDs-Flux.py

@@ -0,0 +1,204 @@
+# -*- coding: utf-8 -*-
+import os, sys; 
+newCode = True
+codePath = r"c:\github\xrt" if newCode else os.path.join('..', '..', '..')
+sys.path.append(codePath)
+#import matplotlib as mpl
+import copy
+import numpy as np
+import matplotlib.pyplot as plt
+try:
+    import xlwt
+except ImportError:
+    xlwt = None
+
+import xrt.backends.raycing as raycing
+raycing._VERBOSITY_ = 80
+import xrt.backends.raycing.sources as rs
+from xrt.backends.raycing.physconsts import SIE0
+
+suffix = '_new' if newCode else '_old'
+withUndulator = True
+#withUndulator = False
+#withUrgentUndulator = True
+withUrgentUndulator = False
+#withSRWUndulator = True
+withSRWUndulator = False
+
+
+def run(case):
+    eMax = 200100.
+    eN = 201
+    thetaMax, psiMax = 500e-6, 500e-6
+    if case == 'Balder':
+        Kmax = 8.446
+#        Kmax = 3
+        thetaMax, psiMax = 200e-6, 50e-6
+#        thetaMax, psiMax = 1130e-6/2, 1180e-6/2  # asked by Magnus
+        eMax, eN = 400100, 401
+        kwargs = dict(name='SoleilW50', eE=3.0, eI=0.5,
+                      eEpsilonX=0.263, eEpsilonZ=0.008, betaX=9., betaZ=2.,
+                      period=50., n=39, K=Kmax, eMax=eMax,
+                      xPrimeMax=thetaMax*1e3, zPrimeMax=psiMax*1e3, distE='BW')
+    elif case == 'BioMAX & NanoMAX':
+        Kmax = 1.92
+        thetaMax, psiMax = 100e-6, 50e-6
+        kwargs = dict(name='IVU18.5', eE=3.0, eI=0.5,
+                      eEpsilonX=0.263, eEpsilonZ=0.008, betaX=9., betaZ=2.,
+                      period=18.5, n=108, K=Kmax, eMax=eMax,
+                      xPrimeMax=thetaMax*1e3, zPrimeMax=psiMax*1e3, distE='BW')
+    elif case == 'Veritas' or case == 'Hippie':
+        thetaMax, psiMax = 100e-6, 50e-6
+#        thetaMax, psiMax = 100e-6, 200e-6  # asked by Magnus
+#        thetaMax, psiMax = 500e-6, 500e-6  # asked by Magnus
+        kwargs = dict(name='U48', eE=3.0, eI=0.5,
+                      eEpsilonX=0.263, eEpsilonZ=0.008, betaX=9., betaZ=2.,
+                      eMax=eMax,
+                      xPrimeMax=thetaMax*1e3, zPrimeMax=psiMax*1e3, distE='BW')
+        if case == 'Veritas':
+            kwargs['period'] = 48.
+            kwargs['n'] = 81
+            kwargs['K'] = 4.51
+        if case == 'Hippie':
+            kwargs['period'] = 53.
+            kwargs['n'] = 73
+            kwargs['K'] = 5.28
+
+    sourceW = rs.Wiggler(**kwargs)
+    energy = np.linspace(100., eMax, eN)
+    theta = np.linspace(-1, 1, 101) * thetaMax
+    psi = np.linspace(-1, 1, 101) * psiMax
+#    theta = np.linspace(-1, 1, 15) * thetaMax
+#    psi = np.linspace(-1, 1, 15) * psiMax
+    dtheta, dpsi = theta[1] - theta[0], psi[1] - psi[0]
+    I0W = sourceW.intensities_on_mesh(energy, theta, psi)[0]
+    fluxW = I0W.sum(axis=(1, 2)) * dtheta * dpsi
+    dE = energy[1] - energy[0]
+    power = fluxW.sum()*dE*SIE0*1e3
+    print('total power = {} W'.format(power))
+    cumpower = np.cumsum(fluxW)*dE*SIE0*1e3 / power
+    ind = np.argwhere(cumpower > 0.5)[0]
+    y1, y2 = cumpower[ind-1], cumpower[ind]
+    x1, x2 = energy[ind-1], energy[ind]
+    Ec = (0.5*(x2-x1) - (y1*x2-y2*x1)) / (y2-y1)
+    print('Ec = {0} eV'.format(Ec))
+
+    if withUrgentUndulator:
+        ukwargs = copy.copy(kwargs)
+        del(ukwargs['distE'])
+        del(ukwargs['betaX'])
+        del(ukwargs['betaZ'])
+        ukwargs['eSigmaX'] = (kwargs['eEpsilonX']*kwargs['betaX']*1e3)**0.5
+        ukwargs['eSigmaZ'] = (kwargs['eEpsilonZ']*kwargs['betaZ']*1e3)**0.5
+        ukwargs['eMin'] = energy[0]
+        ukwargs['eMax'] = energy[-1]
+        ukwargs['eN'] = len(energy)-1
+        ukwargs['nx'] = len(theta)//2
+        ukwargs['nz'] = len(psi)//2
+        ukwargs['icalc'] = 3
+        sourceU = rs.UndulatorUrgent(**ukwargs)
+        I0U = sourceU.intensities_on_mesh()[0]
+        fluxUU = I0U.sum(axis=(1, 2)) * dtheta * dpsi * 4e6
+        fluxUU[fluxUU <= 0] = 1
+        fluxUU[np.isnan(fluxUU)] = 1
+
+    if withSRWUndulator:
+        import pickle
+        with open('c:\Ray-tracing\srw\SRWres.pickle', 'rb') as f:
+            energySRW, thetaSRW, psiSRW, I0SRW = pickle.load(f)[0:4]
+        dtheta = thetaSRW[1] - thetaSRW[0]
+        dpsi = psiSRW[1] - psiSRW[0]
+        fluxSRWU = I0SRW.sum(axis=(1, 2)) * dtheta * dpsi
+
+    if withUndulator:
+#        kwargs['targetOpenCL'] = None
+#        kwargs['taper'] = 0, 4.2
+#        kwargs['gp'] = 1e-4  # needed if does not converge
+#        if newCode:
+#            kwargs['gIntervals'] = 4
+##            kwargs['gp'] = 1e-7
+        sourceU = rs.Undulator(**kwargs)
+        I0U = sourceU.intensities_on_mesh(energy, theta, psi)[0]
+        fluxU = I0U.sum(axis=(1, 2)) * dtheta * dpsi
+
+    fig = plt.figure(figsize=(8, 6))
+    fig.suptitle(case, fontsize=14)
+    rect2d1 = [0.12, 0.12, 0.85, 0.8]
+    ax1 = fig.add_axes(rect2d1, aspect='auto')
+    rect2d2 = [0.22, 0.19, 0.33, 0.5]
+    ax2 = fig.add_axes(rect2d2, aspect='auto')
+    ax2.spines['top'].set_visible(False)
+    ax2.spines['right'].set_visible(False)
+    ax2.xaxis.set_ticks_position('bottom')
+    ax2.yaxis.set_ticks_position('left')
+    ax2.patch.set_visible(False)
+    for ax, lw in zip([ax1, ax2], [2, 2]):
+    #    plot = ax.plot
+        plot = ax.semilogy
+    #    plot = ax.loglog
+        plot(energy/1000., fluxW, '-', lw=lw, alpha=0.7,
+             label='xrt, as wiggler')
+        if withUndulator:
+            plot(energy/1000., fluxU, '-', lw=lw, alpha=0.7,
+                 label='xrt, as undulator')
+            if withUrgentUndulator:
+                plot(energy/1000., fluxUU, '-', lw=lw, alpha=0.7,
+                     label='Urgent')
+            if withSRWUndulator:
+                plot(energySRW/1000., fluxSRWU, '-', lw=lw, alpha=0.7,
+                     label='SRW (zero emittance)')
+            if case == 'BioMAX & NanoMAX':  # Spectra results
+    #            fnames = ['bionano2.dc0', 'bionano3.dc0']
+    #            labels = ['Spectra, accuracy {0}'.format(i) for i in [2, 3]]
+                fnames = ['bionano3.dc0']
+                labels = ['Spectra']
+                for fname, label in zip(fnames, labels):
+                    e, f = np.loadtxt(fname, skiprows=10, usecols=(0, 1),
+                                      unpack=True)
+                    plot(e/1000, f, lw=lw, alpha=0.7, label=label)
+    ax1.set_xlabel(u'energy (keV)')
+    ax1.set_ylabel(u'flux through {0:.0f}×{1:.0f} µrad² (ph/s/0.1%BW)'.format(
+                   theta[-1]*2e6, psi[-1]*2e6))
+    ax1.set_xlim(1, eMax/1e3)
+    if case == 'Veritas' or case == 'Hippie':
+        ax1.set_ylim(1e1, None)
+    else:
+        ax1.set_ylim(1e3, None)
+    ax2.set_xlim(1, 30)
+    ax2.set_ylim(1e12, 2e15)
+    if withUndulator:
+        ax1.legend(loc='upper right')
+
+    plt.savefig(u'flux_{0}_{1:.0f}×{2:.0f}µrad²_{3}.png'.format(
+        case, theta[-1]*2e6, psi[-1]*2e6, suffix))
+
+    if xlwt is not None:
+        wb = xlwt.Workbook()
+        ws = wb.add_sheet('flux')
+        ws.write(0, 0, u'energy (eV)')
+        ws.write(
+            0, 1, u'fluxW through {0:.0f}×{1:.0f} µrad² (ph/s/0.1%BW)'.format(
+                theta[-1]*2e6, psi[-1]*2e6))
+        if withUndulator:
+            ws.write(
+                0, 2,
+                u'fluxU through {0:.0f}×{1:.0f} µrad² (ph/s/0.1%BW)'.format(
+                    theta[-1]*2e6, psi[-1]*2e6))
+
+        for i, e in enumerate(energy):
+            ws.write(i+1, 0, e)
+            ws.write(i+1, 1, fluxW[i])
+            if withUndulator:
+                ws.write(i+1, 2, fluxW[i])
+
+        wb.save(u'flux_{0}_{1:.0f}×{2:.0f}µrad².xls'.format(
+            case, theta[-1]*2e6, psi[-1]*2e6))
+
+    plt.show()
+
+
+if __name__ == '__main__':
+    run('Balder')
+#    run('BioMAX & NanoMAX')
+#    run('Veritas')
+#    run('Hippie')

{xrt-1.6.0/examples/withRaycing/00_xRayCalculator → xrt-1.6.1/tests/raycing/_SynchrotronSources}/calc_undulator.py

@@ -6,7 +6,10 @@ 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 os, sys; 
+newCode = False
+codePath = r"c:\github\xrt" if newCode else os.path.join('..', '..', '..')
+sys.path.append(codePath)
 import xrt.backends.raycing.sources as rs
 
 wantUrgentUndulator = False
@@ -16,12 +19,13 @@ 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)
+    plt.savefig("01 - Flux_ap_{}.png".format("new" if newCode else "old"))
 
 
 def intensity_in_transverse_plane(energy, theta, psi, I0):
     plt.imshow(I0[len(energy)//2, :, :],
                extent=[theta[0]*1e6, theta[-1]*1e6, psi[0]*1e6, psi[-1]*1e6])
-
+    plt.savefig("02 - Intensity_tr_plane_{}.png".format("new" if newCode else "old"))
 
 def colored_intensity_in_transverse_plane(energy, theta, psi, I0):
     import matplotlib as mpl
@@ -66,6 +70,7 @@ def colored_intensity_in_transverse_plane(energy, theta, psi, I0):
     rgbC = mpl.colors.hsv_to_rgb(hsvC)
     axC.imshow(rgbC / rgbC.max(), aspect='auto', origin='lower',
                extent=[0, 1, energy[0], energy[-1]])
+    plt.savefig("03 - Intensity_tr_plane_color_{}.png".format("new" if newCode else "old"))
 
 
 def main():

xrt-1.6.1/tests/raycing/_SynchrotronSources/calc_undulator_power.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+# path to xrt:
+import os, sys; 
+newCode = True
+codePath = r"c:\github\xrt" if newCode else os.path.join('..', '..', '..')
+sys.path.append(codePath)
+import numpy as np
+import matplotlib.pyplot as plt
+import xrt.backends.raycing.sources as rs
+import time
+
+print("please wait...")
+t0 = time.time()
+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')
+
+energy = np.linspace(1000, 31000, 1501)
+theta = np.linspace(-1, 1, 21) * 30e-6
+psi = np.linspace(-1, 1, 21) * 30e-6
+Ks = np.linspace(0.3, 2.2, 20)
+Kmax, gmin = 2.2, 4.2
+gaps = np.log(Kmax/Ks) / np.pi * source.L0 + gmin
+harmonics = range(1, 17)
+
+powers = source.power_vs_K(energy, theta, psi, harmonics, Ks)
+
+plt.plot(gaps, powers, 'o-')
+ax = plt.gca()
+ax.set_xlabel(u'magnetic gap (mm)')
+ax.set_ylabel(u'total power through (60 µrad)² (W)')
+
+maxPower = powers.max()
+for i, (power, K, gap) in enumerate(zip(powers, Ks, gaps)):
+    ax.text(gap, power + maxPower*0.03 * (i % 2 * 2 - 1),
+            '{0}{1:.1f}'.format('K=' if i == 0 else '', K), fontsize=9,
+            ha='center', va='center')
+print("done in {:.3f}s!".format(time.time()-t0))
+
+plt.savefig('undulator_power_CoSAXS_{}.png'.format("new" if newCode else "old"))
+plt.show()

xrt-1.6.1/tests/raycing/_SynchrotronSources/calc_undulator_tune.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+__author__ = "Konstantin Klementiev, Roman Chernikov"
+__date__ = "22 Jan 2016"
+# path to xrt:
+import os, sys; 
+newCode = False
+codePath = r"c:\github\xrt" if newCode else os.path.join('..', '..', '..')
+sys.path.append(codePath)
+import numpy as np
+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)
+
+energy = np.linspace(2000, 30000, 5601)
+theta = np.linspace(-1, 1, 11) * 30e-6  # 60 µrad opening
+psi = np.linspace(-1, 1, 11) * 30e-6  # 60 µrad opening
+xlims, ylims = (3, 24), (1e14, 5e15)
+Ks = np.linspace(0.3, 2.2, 20)
+Kmax, gmin = 1.92, 4.2  # needed to calculate gap(K)
+gaps = np.log(Kmax/Ks) / np.pi * source.L0 + gmin
+harmonics = [1, 2, 3, 4, 5, 7, 9]
+colors = ['b', 'g', 'r', 'c', 'm', 'y', 'k']
+
+tunesE, tunesF = source.tuning_curves(energy, theta, psi, harmonics, Ks)
+
+# plot:
+for tuneE, tuneF, harmonic, color in zip(tunesE, tunesF, harmonics, colors):
+    plt.loglog(tuneE, tuneF, 'o-', label='{0}'.format(harmonic),
+               color=color)
+# format the graph:
+ax = plt.gca()
+ax.set_xlabel(u'energy (eV)')
+ax.set_ylabel(u'flux through (60 µrad)² (ph/s/0.1% bw)')
+ax.set_xlim(xlims)
+ax.set_ylim(ylims)
+ax.xaxis.set_minor_formatter(FormatStrFormatter("%.0f"))
+ax.xaxis.set_major_formatter(FormatStrFormatter("%.0f"))
+plt.grid(which='both')
+ax.legend(loc='upper right', title='harmonics')
+
+# labels of K and gap:
+for tuneE, tuneF, harmonic in zip(tunesE, tunesF, harmonics):
+    if harmonic == 3:
+        ax.text(tuneE[-1], tuneF[-1]*1.05, 'K=', fontsize=8,
+                ha='right', va='bottom')
+        ax.text(tuneE[-1]/1.05, tuneF[-1]/1.2, 'gap=\n(mm)', fontsize=8,
+                color='b', ha='right', va='center')
+    for x, y, K, gap in zip(tuneE, tuneF, Ks, gaps):
+        if xlims[0] < x < xlims[1] and ylims[0] < y < ylims[1]:
+            ax.text(x, y*1.05, '{0:.2f}'.format(K), fontsize=8)
+            if harmonic == 3:
+                ax.text(x/1.05, y/1.2, '{0:.2f}'.format(gap), fontsize=8,
+                        color='b')
+print("done!")
+
+plt.savefig('calc_undulator_tune_{}.png'.format("new" if newCode else "old"))
+plt.show()