xrt 1.6.2__tar.gz

xrt-1.6.2/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License
+---------------
+
+Copyright (c) 2014 Konstantin Klementiev, Roman Chernikov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

xrt-1.6.2/MANIFEST.in

@@ -0,0 +1,39 @@
+include README.txt
+include LICENSE.txt
+include xrt\xrt_logo.ico
+include examples\__init__.py
+include examples\withDummy\logo-python.png
+recursive-include examples\withDummy *.py
+include examples\withRaycing\__init__.py
+recursive-include examples\withRaycing\_QookBeamlines *
+recursive-include examples\withRaycing\00_xRayCalculator *.py
+recursive-include examples\withRaycing\01_SynchrotronSources *.py B*.xlsx b*.dc0 *.gz
+recursive-include examples\withRaycing\02_Balder_BL *.py
+recursive-include examples\withRaycing\03_LaueMono *.py
+recursive-include examples\withRaycing\04_Lenses *.py
+recursive-include examples\withRaycing\05_QWP *.py
+recursive-include examples\withRaycing\06_AnalyzerBent1D *.py
+recursive-include examples\withRaycing\07_AnalyzerBent2D *.py
+recursive-include examples\withRaycing\08_CLAESS_BL *.py
+recursive-include examples\withRaycing\09_Gratings *.py *.txt
+recursive-include examples\withRaycing\10_MultipleReflect *.py
+recursive-include examples\withRaycing\11_Waves *.py *.dat
+recursive-include examples\withRaycing\12_Multilayer *.py
+recursive-include examples\withRaycing\13_Warping *.py *.dat
+recursive-include examples\withRaycing\14_SoftiMAX *.py
+recursive-include examples\withRaycing\15_XRD *
+recursive-include examples\withRaycing\16_ParametricOptimization *.py
+include examples\withShadow\__init__.py
+recursive-include examples\withShadow\00_02 *.py
+recursive-include examples\withShadow\00_02\tmp0 *
+recursive-include examples\withShadow\03 *.py
+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\CXRO-Reflectivities *
+recursive-include tests\raycing\IR *
+recursive-include tests\raycing\misc *
+recursive-include tests\raycing\RemoteOpenCLCalculation *
+recursive-include tests\raycing\XOP-Reflectivities *
+recursive-include tests\raycing\XOP-RockingCurves *

xrt-1.6.2/PKG-INFO

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: xrt
+Version: 1.6.2
+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
+Author-email: konstantin.klementiev@gmail.com, rchernikov@gmail.com
+License: MIT License
+Platform: OS Independent
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+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: sphinx-tabs>=3.4.7
+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"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: platform
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
+
+
+Package xrt is a python software library for ray tracing and wave propagation
+in x-ray regime. It is primarily meant for modeling synchrotron sources,
+beamlines and beamline elements. Includes a GUI for creating a beamline and
+interactively viewing it in 3D.
+
+Features of xrt
+---------------
+
+* *Rays and waves*. Classical ray tracing and wave propagation via Kirchhoff
+  integrals, also freely intermixed. No further approximations, such as thin
+  lens or paraxial. The optical surfaces may have figure errors, analytical or
+  measured. In wave propagation, partially coherent radiation is treated by
+  incoherent addition of coherently diffracted fields generated per electron.
+  Propagation of _individual_ coherent source modes is possible as waves,
+  hybrid waves (i.e. partially as rays and then as waves) and only rays.
+
+* *Publication quality graphics*. 1D and 2D position histograms are
+  *simultaneously* coded by hue and brightness. Typically, colors represent
+  energy and brightness represents beam intensity. The user may select other
+  quantities to be encoded by colors: angular and positional distributions,
+  various polarization properties, beam categories, number of reflections,
+  incidence angle etc. Brightness can also encode partial flux for a selected
+  polarization and incident or absorbed power. Publication quality plots are
+  provided by matplotlib with image formats PNG, PostScript, PDF and SVG.
+
+* *Unlimited number of rays*. The colored histograms are *cumulative*. The
+  accumulation can be stopped and resumed.
+
+* *Parallel execution*. xrt can be run in parallel in several threads or
+  processes (can be opted), which accelerates the execution on multi-core
+  computers. Alternatively, xrt can use the power of GPUs via OpenCL for
+  running special tasks such as the calculation of an undulator source or
+  performing wave propagation.
+
+* *Scripting in Python*. xrt can be run within Python scripts to generate a
+  series of images under changing geometrical or physical parameters. The image
+  brightness and 1D histograms can be normalized to the global maximum
+  throughout the series.
+
+* *Synchrotron sources*. Bending magnet, wiggler, undulator and elliptic
+  undulator are calculated internally within xrt. Please look the section
+  "Comparison of synchrotron source codes" for the comparison other popular
+  codes. If the photon source is one of the synchrotron sources, the total flux
+  in the beam is reported not just in number of rays but in physical units of
+  ph/s. The total power or absorbed power can be opted instead of flux and is
+  reported in W. The power density can be visualized by isolines. The magnetic
+  gap of undulators can be tapered. Undulators can be calculated in near field.
+  Custom magnetic field is also possible. Undulators can be calculated on GPU,
+  with a high gain in computation speed, which is important for tapering and
+  near field calculations.
+
+* *Shapes*. There are several predefined shapes of optical elements implemented
+  as python classes. The python inheritance mechanism simplifies creation of
+  other shapes: the user specifies methods for surface height and surface
+  normal. The surface and the normal are defined either in local Cartesian
+  coordinates or in user-defined parametric coordinates. Parametric
+  representation enables closed shapes such as capillaries or wave guides. It
+  also enables exact solutions for complex shapes (e.g. a logarithmic spiral or
+  an ellipsoid) without any expansion. The methods of finding the intersections
+  of rays with the surface are very robust and can cope with pathological cases
+  such as sharp surface kinks. Notice that the search for intersection points
+  does not involve any approximation and has only numerical inaccuracy which is
+  set by default as 1 fm. Any surface can be combined with a (differently and
+  variably oriented) crystal structure and/or (variable) grating vector.
+  Surfaces can be faceted.
+
+* *Energy dispersive elements*. Implemented are crystals in dynamical
+  diffraction, gratings (also with efficiency calculations), Fresnel zone
+  plates, Bragg-Fresnel optics and multilayers in dynamical diffraction.
+  Crystals can work in Bragg or Laue cases, in reflection or in transmission.
+  The two-field polarization phenomena are fully preserved, also within the
+  Darwin diffraction plateau, thus enabling the ray tracing of crystal-based
+  phase retarders.
+
+* *Materials*. The material properties are incorporated using three different
+  tabulations of the scattering factors, with differently wide and differently
+  dense energy meshes. Refractive index and absorption coefficient are
+  calculated from the scattering factors. Two-surface bodies, such as plates or
+  refractive lenses, are treated with both refraction and absorption.
+
+* *Multiple reflections*. xrt can trace multiple reflections in a single
+  optical element. This is useful, for example in 'whispering gallery' optics
+  or in Montel or Wolter mirrors.
+
+* *Non-sequential optics*. xrt can trace non-sequential optics where different
+  parts of the incoming beam meet different surfaces. Examples of such optics
+  are poly-capillaries and Wolter mirrors.
+
+* *Singular optics*. xrt correctly propagates vortex beams, which can be used
+  for studying the creation of vortex beams by transmissive or reflective
+  optics.
+
+* *Global coordinate system*. The optical elements are positioned in a global
+  coordinate system. This is convenient for modeling a real synchrotron
+  beamline. The coordinates in this system can be directly taken from a CAD
+  library. The optical surfaces are defined in their local systems for the
+  user's convenience.
+
+* *Beam categories*. xrt discriminates rays by several categories: `good`,
+  `out`, `over` and `dead`. This distinction simplifies the adjustment of
+  entrance and exit slits. An alarm is triggered if the fraction of dead rays
+  exceeds a specified level.
+
+* *Portability*. xrt runs on Windows and Unix-like platforms, wherever you can
+  run python.
+
+* *Examples*. xrt comes with many examples; see the galleries, the links are at
+  the top bar.
+
+xrtQook -- a GUI for creating scripts
+-------------------------------------
+
+The main interface to xrt is through a python script. Many examples of such
+scripts can be found in the supplied folders 'examples' and 'tests'. The script
+imports the modules of xrt, instantiates beamline parts, such as synchrotron or
+geometric sources, various optical elements, apertures and screens, specifies
+required materials for reflection, refraction or diffraction, defines plots and
+sets job parameters.
+
+The Qt tool xrtQook takes these ingredients as GUI elements and prepares a
+ready to use script that can be run within the tool itself or in an external
+Python context. xrtQook has a parallelly updated help panel that provides a
+complete list of parameters for the used objects. xrtQook writes/reads the
+recipes of beamlines into/from xml files.
+
+xrtGlow -- an interactive 3D beamline viewer
+--------------------------------------------
+
+The beamline created in xrtQook can be interactively viewed in an OpenGL based
+widget xrtGlow. It visualizes beams, footprints, surfaces, apertures and
+screens. The brightness represents intensity and the color represents an
+auxiliary user-selected distribution, typically energy. A virtual screen can be
+put at any position and dragged by mouse with simultaneous observation of the
+beam distribution on it.
+
+The primary purpose of xrtGlow is to demonstrate the alignment correctness
+given the fact that xrtQook can automatically calculate several positional and
+angular parameters.
+
+Installation
+------------
+
+Install it by pip or conda or get xrt from `GitHub` and use it with or without
+installation.
+
+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`.
+

xrt-1.6.2/README.txt

@@ -0,0 +1,15 @@
+Installation
+------------
+
+Unzip the .zip file into a suitable directory and use
+sys.path.append(path-to-xrt)
+in your script. You can also install xrt to the standard location by running 
+python setup.py install from the directory where you have unzipped the archive,
+which is less convenient if you try different versions of xrt and/or different
+versions of python.
+
+To run xrtQook, simply start xrtQookStart.pyw from xrt/gui or, if you have
+installed xrt by running setup.py, type `xrtQookStart.pyw` from any location.
+
+Note that python-64-bit is by ~20% faster than the 32-bit version (tested with
+WinPython).

xrt-1.6.2/examples/__init__.py

@@ -0,0 +1 @@
+pass

xrt-1.6.2/examples/withDummy/__init__.py

@@ -0,0 +1,27 @@
+r"""
+Logo
+----
+
+Uses :mod:`dummy` backend.
+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| 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.2/examples/withDummy/logo_xrt.py

@@ -0,0 +1,93 @@
+__author__ = "Konstantin Klementiev"
+__date__ = "1 Mar 2012"
+
+import sys
+sys.path.append(r"c:\Ray-tracing")
+#sys.path.append(r"/media/sf_Ray-tracing")
+import numpy as np
+#import matplotlib as mpl
+#mpl.use('agg')
+import matplotlib.pyplot as plt
+
+import xrt.plotter as xrtp
+import xrt.runner as xrtr
+import xrt.backends.dummy as dummy
+import copy
+
+
+def main():
+    logo = plt.imread('logo-python.png')  # load 2D template
+#    logo = plt.imread('logo_test0.png')  # load 2D template
+    logo_mono = logo[:, :, 0] + logo[:, :, 1] + logo[:, :, 2]*2
+    logo_blue = copy.deepcopy(logo_mono)
+    logo_blue[logo[:, :, 2] < 0.4] = 0
+    logo_yellow = copy.deepcopy(logo_mono)
+    logo_yellow[logo[:, :, 0] < 0.4] = 0
+    xrtp.height1d = 64
+    xrtp.heightE1d = 64
+    xrtp.xspace1dtoE1d = 4
+    xrtp.xOrigin2d = 4
+    xrtp.yOrigin2d = 4
+    xrtp.xSpaceExtra = 6
+    xrtp.ySpaceExtra = 4
+
+#    make "ray-tracing" arrays: x, y, intensity and cData
+    locNrays = logo.shape[0] * logo.shape[1]
+    xy = np.mgrid[0:logo.shape[1], 0:logo.shape[0]]
+    x = xy[0, ...].flatten()
+    y = logo.shape[0] - xy[1, ...].flatten()
+    print(logo.shape)
+    intensity = logo_mono.T.flatten()
+    cData = y * np.log(abs(x)+1.5)
+    cDatamax = np.max(cData)
+
+    def local_output():
+        return x, y, intensity, cData, locNrays
+    dummy.run_process = local_output  # invoked by pyXRayTrcaer to get the rays
+
+    blue_area = logo_blue.T.flatten() > 0.1
+    cData[blue_area] = cDatamax*0.5 + (y[blue_area] - logo.shape[0]*0.5)*1.2
+    yellow_area = logo_yellow.T.flatten() > 0.1
+    cData[yellow_area] = cDatamax*0.15 - \
+        (y[yellow_area] - logo.shape[0]*0.5)*1.2
+    intensity[~blue_area & ~yellow_area] = 0.
+
+    plot1 = xrtp.XYCPlot(
+        'dummy',
+        saveName=['logo-xrt.png', 'logo_xrt.pdf'],
+#        saveName=['logo-xrt-inv.png', 'logo_xrt-inv.pdf'],
+        xaxis=xrtp.XYCAxis('', '', fwhmFormatStr=None, bins=logo.shape[1],
+                           ppb=1, limits=[0.5, logo.shape[1]+0.5]),
+        yaxis=xrtp.XYCAxis('', '', fwhmFormatStr=None, bins=logo.shape[0],
+                           ppb=1, limits=[0.5, logo.shape[0]+0.5]),
+        caxis=xrtp.XYCAxis(
+            '', '', fwhmFormatStr=None, bins=logo.shape[0]/2, ppb=2,
+            limits=[10, cDatamax*0.8]),
+        negative=True, invertColorMap=True,
+        aspect='auto')
+    plot1.textPanel = plot1.fig.text(
+        0.75, 0.74, 'xrt', transform=plot1.fig.transFigure, size=70, color='r',
+        ha='center', fontname='times new roman', weight=660)
+#     with no labels:
+    plot1.textNrays = None
+    plot1.textGoodrays = None
+    plot1.textI = None
+#    ... and no tick labels:
+    plt.setp(
+        plot1.ax1dHistEbar.get_yticklabels() +
+        plot1.ax2dHist.get_xticklabels() + plot1.ax2dHist.get_yticklabels(),
+        visible=False)
+#    ... and no ticks:
+    allAxes = [plot1.ax1dHistX, plot1.ax1dHistY, plot1.ax2dHist,
+               plot1.ax1dHistE, plot1.ax1dHistEbar]
+    for ax in allAxes:
+        for axXY in (ax.xaxis, ax.yaxis):
+            plt.setp(axXY.get_ticklines(), visible=False)
+#     end of no ticks:
+
+    xrtr.run_ray_tracing(plot1, repeats=2, backend='dummy')
+
+#this is necessary to use multiprocessing in Windows, otherwise the new Python
+#contexts cannot be initialized:
+if __name__ == '__main__':
+    main()

xrt-1.6.2/examples/withDummy/xrt_demo.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+"""
+Module :mod:`demo` represents the simplest example of xrt. Its main objective
+is to demonstrate the output graphics, where the user can play with several
+options given by the parameters of :class:`XYCPlot` constructors. The default
+ray distributions provided by the 'dummy' backend have no physical meaning but
+can be changed in module :mod:`dummy`.
+"""
+#import matplotlib as mpl
+#mpl.use('wx')
+import sys
+sys.path.append(r"c:\Ray-tracing")
+
+import xrt.plotter as plotter
+import xrt.runner as runner
+
+
+def demo():
+    """The main body of demo."""
+    plots = []
+
+#create a plot...
+    plot = plotter.XYCPlot(title='normal energy distribution')
+#notice the energy offset and how it is displayed
+    plot.caxis.offset = 5000
+#    plot1.persistentName='01.pickle' #for saving and restoring
+    plot.xaxis.limits = [-2.5, 2.5]
+    plot.yaxis.limits = [-2.5, 2.5]
+    filename = 'offset5000'
+    plot.saveName = [filename + '.pdf', filename + '.png']
+#an example of creating a label:
+#the first 2 values are x and y in figure coordinates
+    plot.textPanel = plot.fig.text(
+        0.76, 0.8, '', transform=plot.fig.transFigure, size=12, color='r')
+    plot.caxis.fwhmFormatStr = '%.1f'
+    plots.append(plot)
+
+#... and another plot. The 2nd plot is negative and of inverted colors (i.e.
+#the energy color map is inverted back to that of plot1 after making the graph
+#negative)
+    plot = plotter.XYCPlot(
+        invertColorMap=True, negative=True, title='normal energy distribution,\
+         negative+{inverted colors}')
+    plot.xaxis.limits = [-1, 1]
+    plot.yaxis.limits = [-1, 1]
+#an example of creating a label:
+    plot.textPanel = plot.fig.text(
+        0.76, 0.8, '', transform=plot.fig.transFigure, size=12, color='b')
+    plot.xaxis.fwhmFormatStr = '%.1f'
+    plots.append(plot)
+
+#a dummy text:
+    for plot in plots:
+        plot.textPanel.set_text(
+            'test label1 = {0}\ntest label2 = {1}'.format(0.1, r'$e^{i\pi}$'))
+
+    runner.run_ray_tracing(
+        plots, repeats=40, updateEvery=2, backend='dummy', processes='all')
+
+if __name__ == '__main__':
+    demo()

xrt-1.6.2/examples/withRaycing/00_xRayCalculator/__init__.py

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+r"""
+.. _calc:
+
+Using xrt as x-ray calculator
+-----------------------------
+
+xrt can be used as a library for calculations of synchrotron sources and
+material properties related to x-ray scattering, diffraction and propagation:
+reflectivity, transmittivity, refractive index, absorption coefficient etc.
+
+See the scripts in ``\examples\withRaycing\00_xRayCalculator\``.
+Each script consists of:
+
+1) imports, with possibly defining a path to xrt if it is installed in a
+   non-standard location,
+2) a definition of a source or a material object,
+3) invocation of a corresponding method of interest for a specified range of
+   energy, angles etc. and
+4) plotting.
+
+Example 1a: Undulator
+~~~~~~~~~~~~~~~~~~~~~
+
+.. imagezoomhover:: _images/calc_undulator.png
+   :align: right
+
+.. code-block:: python
+    :emphasize-lines: 6,7,12
+
+    import numpy as np
+    import matplotlib.pyplot as plt
+    import sys; sys.path.append(r"c:\Ray-tracing")
+    import xrt.backends.raycing.sources as rs
+
+    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, distE='BW')
+
+    energy = np.linspace(3850, 4150, 601)
+    theta = np.linspace(-1, 1, 51) * 30e-6
+    psi = np.linspace(-1, 1, 51) * 30e-6
+    I0, l1, l2, l3 = source.intensities_on_mesh(energy, theta, psi)
+    dtheta, dpsi = theta[1] - theta[0], psi[1] - psi[0]
+    flux = I0.sum(axis=(1, 2)) * dtheta * dpsi
+
+    plt.plot(energy, flux)
+    plt.show()
+
+Example 1b: Undulator, tuning curves
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. imagezoomhover:: _images/calc_undulator_tune.png
+   :align: right
+
+.. code-block:: python
+
+    tunesE, tunesF = source.tuning_curves(energy, theta, psi, harmonics, Ks)
+
+See the script
+``\examples\withRaycing\00_xRayCalculator\calc_undulator_tune.py``.
+
+.. raw:: html
+
+    <div class="clearer"> </div>
+
+Example 2a: Crystal reflectivity
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. imagezoomhover:: _images/calc_crystal.png
+   :align: right
+
+.. code-block:: python
+    :emphasize-lines: 6,11
+
+    import numpy as np
+    import matplotlib.pyplot as plt
+    import sys; sys.path.append(r"c:\Ray-tracing")
+    import xrt.backends.raycing.materials as rm
+
+    crystal = rm.CrystalSi(hkl=(1, 1, 1))
+
+    E = 9000
+    dtheta = np.linspace(-20, 80, 501)
+    theta = crystal.get_Bragg_angle(E) + dtheta*1e-6
+    curS, curP = crystal.get_amplitude(E, np.sin(theta))
+
+    plt.plot(dtheta, abs(curS)**2, 'r', dtheta, abs(curP)**2, 'b')
+    plt.show()
+
+.. raw:: html
+
+    <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``.
+
+.. raw:: html
+
+    <div class="clearer"> </div>
+
+Example 3: Multilayer reflectivity
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. imagezoomhover:: _images/calc_multilayer.png
+   :align: right
+
+.. code-block:: python
+    :emphasize-lines: 1,2,3,7
+
+    mSi = rm.Material('Si', rho=2.33)
+    mW = rm.Material('W', rho=19.3)
+    mL = rm.Multilayer(mSi, 27, mW, 18, 40, mSi)
+
+    E = 10000
+    theta = np.linspace(0, 2.0, 1001)  # degrees
+    rs, rp = mL.get_amplitude(E, np.sin(np.deg2rad(theta)))[0:2]
+
+    plt.plot(theta, abs(rs)**2, 'r', theta, abs(rp)**2, 'b')
+    plt.show()
+
+.. raw:: html
+
+    <div class="clearer"> </div>
+
+Example 4: Mirror reflectivity
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. imagezoomhover:: _images/calc_mirror.png
+   :align: right
+
+.. code-block:: python
+    :emphasize-lines: 1,5
+
+    stripe = rm.Material(('Si', 'O'), quantities=(1, 2), rho=2.2)
+
+    E = np.logspace(1 + np.log10(3), 4 + np.log10(5), 501)
+    theta = 7e-3
+    rs, rp = stripe.get_amplitude(E, np.sin(theta))[0:2]
+
+    plt.semilogx(E, abs(rs)**2, 'r', E, abs(rp)**2, 'b')
+    plt.gca().set_xlim(E[0], E[-1])
+    plt.show()
+
+.. raw:: html
+
+    <div class="clearer"> </div>
+
+Example 5: Material absorption
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. imagezoomhover:: _images/calc_absorption.png
+   :align: right
+   :loc: lower-right-corner
+
+.. code-block:: python
+    :emphasize-lines: 1,4
+
+    mat = rm.Material('Be', rho=1.848)
+
+    E = np.logspace(1, 4 + np.log10(3), 501)
+    mu = mat.get_absorption_coefficient(E)
+
+    plt.loglog(E, mu)
+    plt.gca().set_xlim(E[0], E[-1])
+    plt.show()
+
+.. raw:: html
+
+    <div class="clearer"> </div>
+
+"""
+pass

xrt-1.6.2/examples/withRaycing/00_xRayCalculator/calc_absorption.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+__author__ = "Konstantin Klementiev, Roman Chernikov"
+__date__ = "5 Jun 2018"
+import numpy as np
+import matplotlib.pyplot as plt
+# path to xrt:
+import os, sys; sys.path.append(os.path.join(*['..']*3))  # analysis:ignore
+import xrt.backends.raycing.materials as rm
+
+E = np.logspace(1, 4 + np.log10(5), 501)
+for table in ['Chantler', 'Chantler total']:
+    mat = rm.Material('Be', rho=1.848, table=table)
+    mu = mat.get_absorption_coefficient(E)
+    plt.loglog(E, mu)
+
+plt.gca().set_xlim(E[0], E[-1])
+plt.show()