xrt 1.5.0__zip → 1.6.1__zip

xrt-1.6.1/examples/withRaycing/01_SynchrotronSources/fluxThroughAperture.py

@@ -0,0 +1,354 @@
+# -*- coding: utf-8 -*-
+r"""
+.. _through-aperture:
+
+Undulator radiation through rectangular aperture
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The images below are produced by
+``\examples\withRaycing\01_SynchrotronSources\fluxThroughAperture.py``.
+
+This example illustrates the sampling concepts explained in Section
+:ref:`Sampling strategies <sampling-strategies>`.
+
+Grid sampling comes in two flavors: with a grid exactly matching the 100×100
+µrad² aperture and with the same grid plus extra 30% margins on each side.
+Adding margins is crucial for doing convolution with electron beam angular
+spread. Notice that for the sharp field distributions at zero emittance and
+zero energy spread, the grid has to be set with fine angular steps, otherwise
+the flux density spectrum gets unreal ripples. One may play with *ntheta* and
+*npsi* values to observe the effect.
+
+In this particular example (MAX IV Linac), eEspread value is four times bigger
+than a typical value for a storage ring and so the grid here needs a bigger
+number of gamma (relative electron beam energy) samples to obtain a smooth
+spectrum. One may play with *eSpreadNSamples* parameter to observe the effect.
+
+Ray tracing examples illustrate two different ways of field sampling: uniform
+reciprocal space sampling and sampling by intensity distribution. Energy can
+also be sampled variously: uniformly within a given range and on an equidistant
+mesh (energy scan). The latter case also delivers single energy field images,
+which also has some calculation overhead.
+
+The following cases are sorted in increased complexity (and calculation time)
+from top to bottom.
+
+.. list-table::
+   :widths: 50 50
+
+   * - |zeroEmittanceTxt|
+     - |zeroEmittance|
+   * - |fullEmittanceTxt|
+     - |fullEmittance|
+   * - |fullESpreadTxt|
+     - |fullESpread|
+
+.. |zeroEmittance| imagezoom:: _images/fluxThroughAperture-zeroEmittance.png
+   :loc: upper-right-corner
+.. |fullEmittance| imagezoom:: _images/fluxThroughAperture-fullEmittance.png
+   :loc: upper-right-corner
+.. |fullESpread| imagezoom:: _images/fluxThroughAperture-fulleEspread.png
+   :loc: upper-right-corner
+
+.. |zeroEmittanceTxt| replace:: Zero emittance, zero energy spread. Here,
+   angular mesh has to be very dense due to very sharp field features.
+.. |fullEmittanceTxt| replace:: Non-zero emittance, zero energy spread. Here,
+   extra margins have to be added to the angular mesh in order to be able to
+   convolve with electron beam divergence. In this example, adding 30% margins
+   (the orange curve) was not enough.
+.. |fullESpreadTxt| replace:: Non-zero emittance, non-zero energy spread. Here,
+   the number of energy spread samples has to be adjusted for a large energy
+   spread sigma otherwise the spectrum may have false sharp peaks.
+
+Finally, the standard ray tracing approach ("rays-b") should be the method of
+choice as it does not need any parameter adjustment (in contrast to the grid
+methods). For not extreme cases (not too small aperture or not to big emittance
+and not too big energy spread) grid methods can be most efficient but anyways
+need a sanity check by ray tracing.
+
+"""
+__author__ = "Konstantin Klementiev"
+__date__ = "15 Jan 2023"
+
+import os, sys; sys.path.append(os.path.join('..', '..', '..'))  # analysis:ignore
+import numpy as np
+import matplotlib.pyplot as plt
+
+import time
+import pickle
+
+import xrt.plotter as xrtp
+import xrt.runner as xrtr
+import xrt.backends.raycing as raycing
+import xrt.backends.raycing.sources as rs
+import xrt.backends.raycing.apertures as ra
+import xrt.backends.raycing.run as rr
+
+slitSize = 2., 2.
+slitPos = 20000.
+thetaMax = slitSize[0]*0.5 / slitPos
+psiMax = slitSize[1]*0.5 / slitPos
+
+energy = np.linspace(11800, 12600, 401)
+bins, ppb = len(energy), 1
+
+undulatorKwargs = dict(
+    eE=3.0, eI=0.1,
+    betaX=9.0, betaZ=9.0,  # [m]
+    # eEpsilonX=0.68, eEpsilonZ=0.51,  # [nmrad]
+    eEpsilonX=0, eEpsilonZ=0,
+    # eEspread=0.004,
+    eEspread=0,
+
+    period=15.0, n=328*2, K=2.1,
+    # R0=20000.,  # near field, takes very long!
+
+    xPrimeMax=2e3*thetaMax, zPrimeMax=2e3*psiMax,  # mrad
+    xPrimeMaxAutoReduce=False, zPrimeMaxAutoReduce=False,
+    eMin=energy[0], eMax=energy[-1],
+
+    targetOpenCL='GPU',
+    )
+
+# xPrimeMax = (undulatorKwargs['eEpsilonX']*1e-9/undulatorKwargs['betaX'])**0.5
+# undulatorKwargs['xPrimeMax'] = (2*xPrimeMax + thetaMax)*1e3
+# zPrimeMax = (undulatorKwargs['eEpsilonZ']*1e-9/undulatorKwargs['betaZ'])**0.5
+# undulatorKwargs['zPrimeMax'] = (2*zPrimeMax + psiMax)*1e3
+
+if undulatorKwargs['eEpsilonX'] == 0:
+    prefix = 'zeroEmittance-'
+else:
+    prefix = 'fullEmittance-'
+
+if undulatorKwargs['eEspread'] != 0:
+    prefix = 'fulleEspread-'
+
+if 'R0' in undulatorKwargs:
+    prefix = 'nearField-'
+
+
+def build_beamline(nrays):
+    beamLine = raycing.BeamLine()
+    beamLine.nrays = nrays
+    undulatorKwargs['distE'] = 'eV'
+    beamLine.source = rs.Undulator(beamLine, nrays=nrays, **undulatorKwargs)
+    opening = [-slitSize[0]*0.5, slitSize[0]*0.5,
+               -slitSize[1]*0.5, slitSize[1]*0.5]
+    beamLine.slit = ra.RectangularAperture(
+        beamLine, 'FE slit', [0, slitPos, 0],
+        ('left', 'right', 'bottom', 'top'), opening)
+    return beamLine
+
+
+def run_process(beamLine):
+    if beamLine.sampling == 'a':
+        waveSlit = beamLine.slit.prepare_wave(beamLine.source, beamLine.nrays)
+        beamSource = beamLine.source.shine(wave=waveSlit)
+        beamAp = waveSlit
+    elif beamLine.sampling == 'b':
+        beamSource = beamLine.source.shine()
+        beamAp = beamLine.slit.propagate(beamSource)
+    elif beamLine.sampling == 'c':
+        beamSource = beamLine.source.shine(fixedEnergy=beamLine.fixedEnergy)
+        beamAp = beamLine.slit.propagate(beamSource)
+
+    outDict = {'beamSource': beamSource, 'beamAp': beamAp}
+    return outDict
+rr.run_process = run_process  # analysis:ignore
+
+
+def define_plots(beamLine):
+    plots = []
+
+    caxis = xrtp.XYCAxis('energy', 'eV', bins=len(energy), ppb=1)
+    plot = xrtp.XYCPlot(
+        'beamAp', (1,),
+        xaxis=xrtp.XYCAxis('x', 'mm', bins=bins, ppb=ppb),
+        yaxis=xrtp.XYCAxis('z', 'mm', bins=bins, ppb=ppb),
+        caxis=caxis)
+    size = max(slitSize[0], slitSize[1])
+    plot.xaxis.limits = -size*0.6, size*0.6
+    plot.yaxis.limits = -size*0.6, size*0.6
+    plot.caxis.limits = energy[0], energy[-1]
+    plot.xaxis.fwhmFormatStr = '%.2f'
+    plot.yaxis.fwhmFormatStr = '%.2f'
+
+    plots.append(plot)
+    plot.baseName = prefix+beamLine.sampling+'-apertureIntensity'
+    plot.saveName = [plot.baseName + '.png', ]
+
+    return plots
+
+
+def after_script(plots, outName):
+    plot = plots[0]
+    print('total flux = {0:.3g} ph/s'.format(plot.flux))
+    dump = [plot.caxis.binCenters, plot.caxis.total1D, plot.flux]
+    with open(outName, 'wb') as f:
+        pickle.dump(dump, f, protocol=2)
+    print("Done")
+
+
+def energy_scan(beamLine, plots, outName):
+    flux = np.zeros_like(energy)
+    plot = plots[0]
+    for ie, e in enumerate(energy):
+        print(u'energy {0:.1f} eV, {1} of {2}'.format(e, ie+1, len(energy)))
+        beamLine.fixedEnergy = e
+        beamLine.source.eMin = e - 0.5  # i.e. per 1eV band
+        beamLine.source.eMax = e + 0.5
+        for plot in plots:
+            plot.saveName = [
+                plot.baseName + '-{0}-{1:.1f}eV.png'.format(ie, e), ]
+        yield
+        flux[ie] = plot.flux
+
+    totalPhPerS = np.trapz(flux, energy)
+    print('total flux = {0:.3g} ph/s'.format(totalPhPerS))
+    dump = [energy, flux, totalPhPerS]
+    outName = prefix+"ray_tracing_c.pickle"
+    with open(outName, 'wb') as f:
+        pickle.dump(dump, f, protocol=2)
+
+    plt.plot(energy, flux, lw=0.7)
+    plt.show()
+
+
+def grid_method(kind):
+    if undulatorKwargs['eEspread'] == 0:
+        ntheta, npsi = 501, 501
+        eSpreadNSamples = 36
+    else:
+        ntheta, npsi = 101, 101
+        eSpreadNSamples = 401
+    dtheta, dpsi = 2*thetaMax/(ntheta-1), 2*psiMax/(npsi-1)
+    # theta = np.linspace(-1, 1, ntheta) * thetaMax
+    # psi = np.linspace(-1, 1, npsi) * psiMax
+    if kind == 'b':  # add margins but keep the grid spacings
+        marginFactor = 1.3
+        # marginFactor = max(
+        #     undulatorKwargs['xPrimeMax']*1e-3/thetaMax,
+        #     undulatorKwargs['zPrimeMax']*1e-3/psiMax)
+        ntheta = int(ntheta*marginFactor)
+        npsi = int(npsi*marginFactor)
+    theta = np.arange(ntheta)*dtheta
+    psi = np.arange(npsi)*dpsi
+    theta -= theta[-1]*0.5
+    psi -= psi[-1]*0.5
+    whereTheta = (-thetaMax-1e-12 < theta) & (theta < thetaMax+1e-12)
+    wherePsi = (-psiMax-1e-12 < psi) & (psi < psiMax+1e-12)
+
+    source = rs.Undulator(**undulatorKwargs)
+    flux = np.zeros_like(energy)
+    for ie, e in enumerate(energy):
+        print(u'energy {0:.1f} eV, {1} of {2}'.format(e, ie+1, len(energy)))
+        I0, l1, l2, l3 = source.intensities_on_mesh(
+            [e], theta, psi, eSpreadNSamples=eSpreadNSamples)
+        # print(I0[:, :, wherePsi].shape, psi[wherePsi].shape)
+        flux[ie] = np.trapz(np.trapz(I0[:, :, wherePsi], psi[wherePsi])
+                            [:, whereTheta], theta[whereTheta])
+
+    integrand = flux/energy*1e3 if source.distE == 'BW' else flux
+    totalPhPerS = np.trapz(integrand, energy)
+    print('total flux = {0:.3g} ph/s'.format(totalPhPerS))
+    dump = [energy, integrand, totalPhPerS]
+    outName = prefix+"grid_method_{}.pickle".format(kind)
+    with open(outName, 'wb') as f:
+        pickle.dump(dump, f, protocol=2)
+
+    plt.plot(energy, flux, lw=0.7)
+    plt.show()
+
+
+def ray_tracing(kind, nrays, repeats):
+    outName = prefix+"ray_tracing_{0}.pickle".format(kind)
+    beamLine = build_beamline(nrays)
+    beamLine.sampling = kind
+    plots = define_plots(beamLine)
+    if kind in ['a', 'b']:
+        xrtr.run_ray_tracing(
+            plots, repeats=repeats, beamLine=beamLine,
+            afterScript=after_script, afterScriptArgs=[plots, outName])
+    if kind in ['c']:
+        raycing._VERBOSITY_ = 0
+        xrtr.run_ray_tracing(
+            plots, repeats=repeats, beamLine=beamLine,
+            # globalNorm=True,
+            generator=energy_scan, generatorArgs=[beamLine, plots, outName])
+
+
+def compare_methods(methods, distE='0.1%bw', wantOffset=False):
+    """
+    *distE* can be '0.1%bw' or 'eV', for calculating, correspondingly,
+    logarithmic or linear flux density.
+    """
+    data = []
+    for method in methods:
+        fname = '{0}{1}.pickle'.format(prefix, method)
+        with open(fname, 'rb') as f:
+            res = pickle.load(f)
+        if method == 'grid_method_a':
+            label = 'grid-a: equidistant mesh sampling'
+        elif method == 'grid_method_b':
+            label = 'grid-b: equidistant mesh sampling with margins'
+        elif method == 'ray_tracing_a':
+            label = 'rays-a: uniform MC sampling in full energy range'
+        elif method == 'ray_tracing_b':
+            label = 'rays-b: MC sampling by intensity in full energy range'
+        elif method == 'ray_tracing_c':
+            label = 'rays-c: MC sampling by intensity at scanning energy'
+        print(method, res[2])
+        res.append(label)
+        data.append(res)
+
+    fig = plt.figure(figsize=(7, 5))
+    rect = [0.12, 0.1, 0.85, 0.85]
+    ax = fig.add_axes(rect, aspect='auto')
+    title = 'Flux through aperture by xrt'
+    if wantOffset:
+        title += ', offsetted for clarity'
+    ax.set_title(title, fontsize=12)
+    ax.set_xlabel(r'Energy (eV)')
+    if distE == '0.1%bw':
+        ylabel = r'Flux (ph/s/0.1%bw)'
+    elif distE == 'eV':
+        ylabel = r'Flux (ph/s/eV)'
+    ax.set_ylabel(ylabel)
+
+    offset = 5e13 if wantOffset else 0
+    for imethod, (e, flux, fluxPhPerS, label) in enumerate(data):
+        flux_eV = flux / np.trapz(flux, e) * fluxPhPerS
+        if distE == '0.1%bw':
+            y = flux_eV * e * 1e-3
+        elif distE == 'eV':
+            y = flux_eV
+        ax.plot(e, y+imethod*offset, label=label)
+    ax.set_xlim(e[0], e[-1])
+    ax.legend()
+
+    fig.savefig(prefix+"FluxThroughAperture{0}.png".format(
+        '-offsetted' if wantOffset else ''))
+    plt.show()
+
+
+if __name__ == '__main__':
+    t0 = time.time()
+    raycing._VERBOSITY_ = 100
+
+    # select one at a time:
+    # Note: grid_method can take very long when eEspread>0
+    grid_method('a')  # intensities_on_mesh
+    # grid_method('b')  # intensities_on_mesh with margins
+    # ray_tracing('a', nrays=1e6, repeats=100)  # uniform ray sampling
+    # ray_tracing('b', nrays=1e5, repeats=25)  # ray sampling by intensity
+    # ray_tracing('c', nrays=2e4, repeats=1)  # energy scan
+
+    # when the above methods are done, run the comparison functions:
+    # compare_methods(
+    #     ('grid_method_a', 'grid_method_b',
+    #      'ray_tracing_a', 'ray_tracing_b', 'ray_tracing_c'), wantOffset=False)
+    # compare_methods(
+    #     ('grid_method_a', 'grid_method_b',
+    #      'ray_tracing_a', 'ray_tracing_b', 'ray_tracing_c'), wantOffset=True)
+
+    print("Done in {0} s".format(time.time()-t0))

{xrt-1.5.0 → xrt-1.6.1}/examples/withRaycing/01_SynchrotronSources/my_arbitrary_field_test.py

@@ -513,7 +513,7 @@ def iterate_rk():
         plt.savefig("z"+suffix+'.png')
 
         fig = plt.figure(9)
-        ax = fig.gca(projection='3d')
+        ax = fig.add_subplot(projection='3d')
         ax.plot(np.array(ztgrid[:-1]) / tgwmm / 1e3,
                 np.array(xgrid[:-1]) / tgwmm * 1e3,
                 np.array(ygrid[:-1]) / tgwmm * 1e3,

{xrt-1.5.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.5.0 → xrt-1.6.1}/examples/withRaycing/01_SynchrotronSources/undulatorHamed.py

@@ -9,9 +9,10 @@ import os, sys; sys.path.append(os.path.join('..', '..', '..'))  # analysis:igno
 import numpy as np
 import pickle
 import time
-#import matplotlib
+import matplotlib as mpl
 #matplotlib.use("Agg")
 import xrt.backends.raycing as raycing
+raycing._VERBOSITY_ = 80
 import xrt.backends.raycing.sources as rs
 import xrt.backends.raycing.screens as rsc
 import xrt.backends.raycing.run as rr
@@ -162,7 +163,7 @@ kwargs = dict(
     eEpsilonX=6.0, eEpsilonZ=0.06, betaX=5.66, betaZ=2.85,
     # period=84., n=36,
     xPrimeMax=xPrimeMax, zPrimeMax=zPrimeMax,
-#    targetOpenCL='CPU',
+    # targetOpenCL='CPU',
     filamentBeam=filamentBeam)
 xlimits = [-xPrimeMax*R0*1e-3, xPrimeMax*R0*1e-3]
 zlimits = [-zPrimeMax*R0*1e-3, zPrimeMax*R0*1e-3]
@@ -310,7 +311,7 @@ def afterScript(plots, complexPlotsPCA, beamLine):
         import matplotlib.pyplot as plt
         from mpl_toolkits.mplot3d import Axes3D
         fig = plt.figure()
-        ax = fig.gca(projection='3d')
+        ax = fig.add_subplot(projection='3d')
         tr = beamLine.source.trajectory
         ax.plot(tr[2]/1e3, tr[0]*1e3, tr[1]*1e3)
         ax.set_xlabel(r"$z$, m")
@@ -364,8 +365,7 @@ def main():
 
 def plotPCA():
     import matplotlib.pyplot as plt
-    import matplotlib.cm as cm
-    cmap = cm.get_cmap('cubehelix')
+    cmap = mpl.colormaps['cubehelix']
 
     pickleName = '{0}-{1}repeats.pickle'.format(prefix, repeats)
     with open(pickleName, 'rb') as f:
@@ -430,6 +430,7 @@ def plotPCA():
     print("Done")
     plt.show()
 
+
 if __name__ == '__main__':
     main()
 #    plotPCA()

{xrt-1.5.0 → xrt-1.6.1}/examples/withRaycing/01_SynchrotronSources/undulatorHamed_fromField.py

@@ -9,7 +9,7 @@ import os, sys; sys.path.append(os.path.join('..', '..', '..'))  # analysis:igno
 import numpy as np
 import pickle
 import time
-#import matplotlib
+import matplotlib as mpl
 #matplotlib.use("Agg")
 import xrt.backends.raycing as raycing
 raycing._VERBOSITY_ = 80
@@ -157,14 +157,12 @@ else:
     bins = 256  # Number of bins in the plot histogram
     ppb = 1  # Number of pixels per histogram bin
 
-#Source = rs.Undulator
 Source = rs.SourceFromField
 kwargs = dict(
     eE=1.5, eI=0.5, eEspread=8e-4,
     eEpsilonX=6.0, eEpsilonZ=0.06, betaX=5.66, betaZ=2.85,
 #    period=84., n=36,
     xPrimeMax=xPrimeMax, zPrimeMax=zPrimeMax,
-#    xPrimeMaxAutoReduce=False, zPrimeMaxAutoReduce=False,
 #    targetOpenCL='CPU',
     filamentBeam=filamentBeam)
 xlimits = [-xPrimeMax*R0*1e-3, xPrimeMax*R0*1e-3]
@@ -313,7 +311,7 @@ def afterScript(plots, complexPlotsPCA, beamLine):
         import matplotlib.pyplot as plt
         from mpl_toolkits.mplot3d import Axes3D
         fig = plt.figure()
-        ax = fig.gca(projection='3d')
+        ax = fig.add_subplot(projection='3d')
         tr = beamLine.source.trajectory
         ax.plot(tr[2]/1e3, tr[0]*1e3, tr[1]*1e3)
         ax.set_xlabel(r"$z$, m")
@@ -367,8 +365,7 @@ def main():
 
 def plotPCA():
     import matplotlib.pyplot as plt
-    import matplotlib.cm as cm
-    cmap = cm.get_cmap('cubehelix')
+    cmap = mpl.colormaps['cubehelix']
 
     pickleName = '{0}-{1}repeats.pickle'.format(prefix, repeats)
     with open(pickleName, 'rb') as f:
@@ -433,6 +430,7 @@ def plotPCA():
     print("Done")
     plt.show()
 
+
 if __name__ == '__main__':
     main()
 #    plotPCA()