def compare_reflectivity():
"""A comparison subroutine used in the module test suit."""
def for_one_material(stripe, refs, refp, theta, reprAngle):
fig = plt.figure(figsize=(8, 6), dpi=100)
fig.subplots_adjust(right=0.86)
ax = fig.add_subplot(111)
ax.set_xlabel('energy (eV)')
ax.set_ylabel('reflectivity')
ax.set_xlim(30, 5e4)
fig.suptitle(stripe.name + ' ' + reprAngle, fontsize=16)
x, R2s = np.loadtxt(refs, unpack=True)
p1, = ax.plot(x, R2s, '-k', label='s xf1f2')
x, R2s = np.loadtxt(refp, unpack=True)
p2, = ax.plot(x, R2s, '--k', label='p xf1f2')
refl = stripe.get_amplitude(E, math.sin(theta))
rs, rp = refl[0], refl[1]
p3, = ax.semilogx(E, abs(rs)**2, '-r')
p4, = ax.semilogx(E, abs(rp)**2, '--r')
l1 = ax.legend([p1, p2], ['s', 'p'], loc=3)
ax.legend([p1, p3], ['Xf1f2/XOP', 'xrt'], loc=6)
ax.add_artist(l1)
# phases:
ax2 = ax.twinx()
ax2.set_ylabel(r'$\phi_s - \phi_p$', color='c')
phi = np.unwrap(np.angle(rs * rp.conj()))
p9, = ax2.plot(E, phi, 'c', lw=2, yunits=math.pi, zorder=0)
formatter = mpl.ticker.FormatStrFormatter('%g' + r'$ \pi$')
ax2.yaxis.set_major_formatter(formatter)
for tl in ax2.get_yticklabels():
tl.set_color('c')
fname = 'MirrorRefl' + stripe.name + "".join(reprAngle.split())
fig.savefig(fname + '.png')
dataDir = os.path.join('', 'XOP-Reflectivities')
E = np.logspace(1.+math.log10(3.), 4.+math.log10(5.), 500)
stripeSi = rm.Material('Si', rho=2.33)
for_one_material(stripeSi,
os.path.join(dataDir, "Si05deg_s.xf1f2.gz"),
os.path.join(dataDir, "Si05deg_p.xf1f2.gz"),
math.radians(0.5), '@ 0.5 deg')
stripePt = rm.Material('Pt', rho=21.45)
for_one_material(stripePt,
os.path.join(dataDir, "Pt4mrad_s.xf1f2.gz"),
os.path.join(dataDir, "Pt4mrad_p.xf1f2.gz"),
4e-3, '@ 4 mrad')
stripeSiO2 = rm.Material(('Si', 'O'), quantities=(1, 2), rho=2.2)
for_one_material(stripeSiO2,
os.path.join(dataDir, "SiO205deg_s.xf1f2.gz"),
os.path.join(dataDir, "SiO205deg_p.xf1f2.gz"),
math.radians(0.5), '@ 0.5 deg')
stripeRh = rm.Material('Rh', rho=12.41)
for_one_material(stripeRh,
os.path.join(dataDir, "Rh2mrad_s.xf1f2.gz"),
os.path.join(dataDir, "Rh2mrad_p.xf1f2.gz"),
2e-3, '@ 2 mrad')
def get_material(atom="Pt", rho=None):
"""
use rho='bulk' for bulk density
use rho=None for default density of coating (90% of bulk for Pt)
"""
if isinstance(rho,str) and rho == "bulk":
rho = _bulk_densities[atom]
elif rho is None:
rho = _bulk_densities[atom] * _density_factor[atom]
return rm.Material(atom, rho=rho)
def compare_reflectivity_slab():
"""A comparison subroutine used in the module test suit."""
def for_one_material(stripe, refs, refp, E, reprEnergy):
fig = plt.figure(figsize=(8, 6), dpi=100)
fig.subplots_adjust(right=0.86)
ax = fig.add_subplot(111)
ax.set_xlabel('grazing angle (deg)')
ax.set_ylabel('reflectivity')
ax.set_xlim(0, 10)
fig.suptitle(stripe.name + ' ' + reprEnergy, fontsize=16)
x, R2s = np.loadtxt(refs, unpack=True)
p1, = ax.plot(x, R2s, '-k', label='s Mlayer')
x, R2s = np.loadtxt(refp, unpack=True)
p2, = ax.plot(x, R2s, '--k', label='p Mlayer')
refl = stripe.get_amplitude(E, np.sin(np.deg2rad(theta)))
rs, rp = refl[0], refl[1]
p3, = ax.semilogy(theta, abs(rs)**2, '-r')
p4, = ax.semilogy(theta, abs(rp)**2, '--r')
l1 = ax.legend([p1, p2], ['s', 'p'], loc=3)
ax.legend([p1, p3], ['Mlayer/XOP', 'xrt'], loc=1)
ax.add_artist(l1)
ylim = ax.get_ylim()
ax.set_ylim([ylim[0], 1])
# phases:
ax2 = ax.twinx()
ax2.set_ylabel(r'$\phi_s - \phi_p$', color='c')
phi = np.unwrap(np.angle(rs * rp.conj()))
p9, = ax2.plot(theta, phi, 'c', lw=2, yunits=math.pi, zorder=0)
formatter = mpl.ticker.FormatStrFormatter('%g' + r'$ \pi$')
ax2.yaxis.set_major_formatter(formatter)
for tl in ax2.get_yticklabels():
tl.set_color('c')
ax2.set_zorder(-1)
ax.patch.set_visible(False) # hide the 'canvas'
fname = 'SlabRefl' + stripe.name + ' ' + reprEnergy
fig.savefig(fname + '.png')
dataDir = os.path.join('', 'XOP-Reflectivities')
theta = np.linspace(0, 10, 500) # degrees
layerW = rm.Material('W', kind='thin mirror', rho=19.3, t=2.5e-6)
for_one_material(layerW,
os.path.join(dataDir, "W25A_10kev_s.mlayer.gz"),
os.path.join(dataDir, "W25A_10kev_p.mlayer.gz"), 1e4,
u'slab, t = 25 Å, @ 10 keV')
def compare_absorption_coeff():
"""A comparison subroutine used in the module test suit."""
def for_one_material(m):
rf = os.path.join(dataDir, "{0}_absCoeff.xcrosssec.gz".format(m.name))
title = u'Absorption in {0}'.format(mat.name)
fig = plt.figure(figsize=(8, 6), dpi=100)
ax = fig.add_subplot(111)
ax.set_xlabel('energy (eV)')
ax.set_ylabel(r'$\mu_0$ (cm$^{-1}$)')
fig.suptitle(title, fontsize=16)
x, mu0 = np.loadtxt(rf, unpack=True)
p1, = ax.loglog(x, mu0, '-k', lw=2, label='XCrossSec')
calcmu0 = m.get_absorption_coefficient(E)
p3, = ax.loglog(E, calcmu0, '-r', label='xrt')
ax.legend(loc=1)
ax.set_xlim(E[0], E[-1])
fname = title
fig.savefig(fname + '.png')
dataDir = os.path.join('', 'XOP-Reflectivities')
E = np.logspace(1+math.log10(2.), 4.+math.log10(3.), 500)
# mat = rm.Material('Be', rho=1.848)
# for_one_material(mat)
# mat = rm.Material('Ag', rho=10.50)
# mat = rm.Material('Ag', rho=10.50, table='Henke')
# for_one_material(mat)
mat = rm.Material('Al', rho=2.6989)
for_one_material(mat)
# mat = rm.Material('Au', rho=19.3)
# for_one_material(mat)
# mat = rm.Material('Ni', rho=8.902)
# for_one_material(mat)
E = 30000
print("abs coeff at {0} keV = {1} 1/cm".format(
E*1e-3, mat.get_absorption_coefficient(E)))
print("refr index at {0} keV = {1}".format(
E*1e-3, mat.get_refractive_index(E)))
def compare_transmittivity():
"""A comparison subroutine used in the module test suit."""
def for_one_material(mat, thickness, ref1, title, sname):
fig = plt.figure(figsize=(8, 6), dpi=100)
ax = fig.add_subplot(111)
ax.set_xlabel('energy (eV)')
ax.set_ylabel('transmittivity')
fig.suptitle(title, fontsize=16)
x, tr = np.loadtxt(ref1, unpack=True)
p1, = ax.semilogx(x, tr, '-k', lw=2, label='XPower/XOP')
calcmu0 = mat.get_absorption_coefficient(E)
transm = np.exp(-calcmu0 * thickness)
p3, = ax.semilogx(E, transm, '-r', label='xrt')
ax.legend(loc=2)
ax.set_xlim(E[0], E[-1])
fname = 'Transm' + sname
fig.savefig(fname + '.png')
dataDir = os.path.join('', 'XOP-Reflectivities')
E = np.logspace(2.+math.log10(3.), 4.+math.log10(3.), 500)
matDiamond = rm.Material('C', rho=3.52)
for_one_material(matDiamond, 60*1e-4,
os.path.join(dataDir, "Diamond60mum.xpower.gz"),
r'Transmittivity of 60-$\mu$m-thick diamond', 'Diamond')
# -*- 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
matDiamond = rm.Material('C', rho=3.52)
E = np.logspace(2 + np.log10(3), 4 + np.log10(3), 501)
thickness = 0.06 # mm
mu = matDiamond.get_absorption_coefficient(E) # in cm^-1
transm = np.exp(-mu * thickness * 0.1)
plt.semilogx(E, transm)
plt.gca().set_xlim(E[0], E[-1])
plt.show()
__date__ = "08 Mar 2016"
import os, sys
sys.path.append(os.path.join('..', '..', '..')) # analysis:ignore
import numpy as np
import xrt.backends.raycing as raycing
import xrt.backends.raycing.sources as rs
#import xrt.backends.raycing.apertures as ra
import xrt.backends.raycing.oes as roe
import xrt.backends.raycing.run as rr
import xrt.backends.raycing.materials as rm
import xrt.plotter as xrtp
import xrt.runner as xrtr
import xrt.backends.raycing.screens as rsc
mGold = rm.Material('Au', rho=19.3, kind='FZP')
E0, dE = 400, 5
def build_beamline(nrays=1e5):
beamLine = raycing.BeamLine(height=0)
# source=rs.GeometricSource(
# beamLine, 'GeometricSource', (0, 0, 0),
# nrays=nrays, distx='flat', dx=0.12, distz='flat', dz=0.12,
# dxprime=0, dzprime=0,
# distE='flat', energies=(E0-dE, E0+dE), polarization='horizontal')
rs.GeometricSource(beamLine,
'GeometricSource', (0, 0, 0),
nrays=nrays,
distx='annulus',
dx=(0, 0.056),
def build_beamline(nrays=1e4,
hkl=(1, 1, 1),
stripe='Si',
eMinRays=2400,
eMaxRays=45000):
filterDiamond = rm.Material('C', rho=3.52, kind='plate')
if stripe.startswith('S'):
materialVCM = stripeSi
materialVFM = stripeSiO2
elif stripe.startswith('I'):
materialVCM = stripeIr
materialVFM = stripeIr
else:
raise ('Don' 't know the mirror material')
height = 0
beamLine = raycing.BeamLine(azimuth=0, height=height)
wigglerToStraightSection = 0
xWiggler = wigglerToStraightSection * beamLine.sinAzimuth
yWiggler = wigglerToStraightSection * beamLine.cosAzimuth
# rs.WigglerWS(
# beamLine, name='SoleilW50', center=(xWiggler, yWiggler, height),
# nrays=nrays, period=50., K=8.446, n=39, eE=3., eI=0.5,
# eSigmaX=48.66, eSigmaZ=6.197, eEpsilonX=0.263, eEpsilonZ=0.008,
# eMin=50, eMax=60050, eMinRays=eMinRays, eMaxRays=eMaxRays, eN=2000,
# xPrimeMax=0.22, zPrimeMax=0.06, nx=40, nz=10)
rs.Wiggler(beamLine,
name='SoleilW50',
center=(xWiggler, yWiggler, height),
nrays=nrays,
period=50.,
K=8.446,
n=39,
eE=3.,
eI=0.5,
eSigmaX=48.66,
eSigmaZ=6.197,
eEpsilonX=0.263,
eEpsilonZ=0.008,
eMin=eMinRays,
eMax=eMaxRays,
xPrimeMax=0.22,
zPrimeMax=0.06)
beamLine.fsm0 = rsc.Screen(beamLine, 'FSM0', (0, 15000, height))
beamLine.feFixedMask = ra.RectangularAperture(
beamLine, 'FEFixedMask', (0, 15750, height),
('left', 'right', 'bottom', 'top'), [-3.15, 3.15, -0.7875, 0.7875])
beamLine.fsmFE = rsc.Screen(beamLine, 'FSM-FE', (0, 16000, height))
beamLine.filter1 = roe.Plate(beamLine,
'Filter1', (0, 23620, height),
pitch=math.pi / 2,
limPhysX=(-9., 9.),
limPhysY=(-4., 4.),
surface='diamond 60 $\mu$m',
material=filterDiamond,
t=0.06,
alarmLevel=0.)
if stripe.startswith('I'):
beamLine.filter2 = roe.Plate(beamLine,
'Filter2', (0, 23720, height),
pitch=math.pi / 2,
limPhysX=(-9., 9.),
limPhysY=(-4., 4.),
surface='diamond 0.4 mm',
material=filterDiamond,
t=0.4,
alarmLevel=0.)
beamLine.vcm = roe.SimpleVCM(beamLine,
'VCM', [0, 25290, height],
surface=('Si', ),
material=(materialVCM, ),
limPhysX=(-15., 15.),
limPhysY=(-680., 680.),
limOptX=(-6, 6),
limOptY=(-670., 670.),
R=5.0e6,
pitch=2e-3,
alarmLevel=0.)
beamLine.fsmVCM = rsc.Screen(beamLine, 'FSM-VCM', (0, 26300, height))
beamLine.dmm = roe.DCM(
beamLine,
'DMM',
[0, 27060, height],
surface=('mL1', ),
material=(mL, ),
material2=(mL, ),
limPhysX=(-12, 12),
limPhysY=(-150, 150),
cryst2perpTransl=20,
cryst2longTransl=100,
limPhysX2=(-12, 12),
limPhysY2=(-200, 200),
# targetOpenCL='auto',
targetOpenCL='CPU',
alarmLevel=0.05)
beamLine.BSBlock = ra.RectangularAperture(beamLine,
'BSBlock', (0, 29100, height),
('bottom', ), (22, ),
alarmLevel=0.)
beamLine.slitAfterDCM = ra.RectangularAperture(
beamLine,
'SlitAfterDCM', (0, 29200, height), ('left', 'right', 'bottom', 'top'),
[-7, 7, -2, 2],
alarmLevel=0.5)
beamLine.fsmDCM = rsc.Screen(beamLine, 'FSM-DCM', (0, 29400, height))
beamLine.vfm = roe.SimpleVFM(beamLine,
'VFM', [0, 30575, height],
surface=('SiO2', ),
material=(materialVFM, ),
limPhysX=(-20., 20.),
limPhysY=(-700., 700.),
limOptX=(-10, 10),
limOptY=(-700, 700),
positionRoll=math.pi,
R=5.0e6,
r=40.77,
alarmLevel=0.2)
beamLine.slitAfterVFM = ra.RectangularAperture(
beamLine,
'SlitAfterVFM', (0, 31720, height), ('left', 'right', 'bottom', 'top'),
[-7, 7, -2, 2],
alarmLevel=0.5)
beamLine.fsmVFM = rsc.Screen(beamLine, 'FSM-VFM', (0, 32000, height))
beamLine.ohPS = ra.RectangularAperture(beamLine,
'OH-PS', (0, 32070, height),
('left', 'right', 'bottom', 'top'),
(-20, 20, 25, 55),
alarmLevel=0.2)
beamLine.slitEH = ra.RectangularAperture(
beamLine,
'slitEH', (0, 43000, height), ('left', 'right', 'bottom', 'top'),
[-20, 20, -7, 7],
alarmLevel=0.5)
beamLine.fsmSample = rsc.Screen(beamLine, 'FSM-Sample', (0, 45863, height))
return beamLine
E0 = 9000. # eV
p = 1000. # source to 1st lens
q = 5000. # 1st lens to focus
xyLimits = -5, 5
#Lens = roe.ParaboloidFlatLens
Lens = roe.DoubleParaboloidLens
#Lens = roe.ParabolicCylinderFlatLens
if Lens == roe.DoubleParaboloidLens:
lensName = '2-'
elif Lens == roe.ParaboloidFlatLens:
lensName = '1-'
else:
lensName = '3-'
mBeryllium = rm.Material('Be', rho=1.848, kind='lens')
#mDiamond = rm.Material('C', rho=3.52, kind='lens')
mAluminum = rm.Material('Al', rho=2.7, kind='lens')
#mSilicon = rm.Material('Si', rho=2.33, kind='lens')
#mNickel = rm.Material('Ni', rho=8.9, kind='lens')
#mLead = rm.Material('Pb', rho=11.35, kind='lens')
def build_beamline(nrays=1e4):
beamLine = raycing.BeamLine(height=0)
# rs.CollimatedMeshSource(beamLine, 'CollimatedMeshSource', dx=2, dz=2,
# nx=21, nz=21, energies=(E0,), withCentralRay=False, autoAppendToBL=True)
rs.GeometricSource(beamLine,
'CollimatedSource',
nrays=nrays,
dx=0.5,
# -*- 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
substrate = rm.Material('Si', rho=2.33)
coating = rm.Material('Rh', rho=12.41, kind='mirror')
cMirror = rm.Coated(coating=coating, cThickness=300, substrate=substrate,
surfaceRoughness=30, substRoughness=30)
# E = np.logspace(1 + np.log10(3), 4 + np.log10(5), 501)
E = np.linspace(100, 29999, 1001)
theta = 4e-3
rs, rp = cMirror.get_amplitude(E, np.sin(theta))[0:2]
rs0, rp0 = coating.get_amplitude(E, np.sin(theta))[0:2]
# plt.semilogx(E, abs(rs)**2, 'r', E, abs(rp)**2, 'b')
refs, refp = plt.plot(E, abs(rs)**2, 'r', E, abs(rp)**2, 'b--')
refs0, refp0 = plt.plot(E, abs(rs0)**2, 'm', E, abs(rp0)**2, 'c--')
plt.legend([refs, refp, refs0, refp0],
['coated s-pol', 'coated p-pol', 'pure s-pol', 'pure p-pol'])
plt.gca().set_xlim(E[0], E[-1])
plt.show()
#import matplotlib as mpl
import numpy as np
import matplotlib.pyplot as plt
import xlwt
import xrt.backends.raycing as raycing
import xrt.backends.raycing.sources as rs
#import xrt.backends.raycing.apertures as ra
#import xrt.backends.raycing.oes as roe
#import xrt.backends.raycing.run as rr
import xrt.backends.raycing.materials as rm
#import xrt.backends.raycing.screens as rsc
#stripeSi = rm.Material('Si', rho=2.33)
#stripeSiO2 = rm.Material(('Si', 'O'), quantities=(1, 2), rho=2.2)
stripePt = rm.Material('Pt', rho=21.45)
#filterDiamond = rm.Material('C', rho=3.52, kind='plate')
#si = rm.CrystalSi(hkl=(1, 1, 1), tK=-171+273.15)
eMax = 200 # keV
def run(case):
myBalder = raycing.BeamLine(azimuth=0, height=0)
kwargs = dict(name='SoleilW50',
center=(0, 0, 0),
period=50.,
K=8.446,
n=39,
eE=3.,
eI=0.5,
# -*- 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
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()
def compare_reflectivity_coated():
"""A comparison subroutine used in the module test suit."""
def for_one_material(stripe, strOnly, refs, refp, theta, reprAngle):
fig = plt.figure(figsize=(8, 6), dpi=100)
fig.subplots_adjust(right=0.86)
ax = fig.add_subplot(111)
ax.set_xlabel('energy (keV)')
ax.set_ylabel('reflectivity')
# ax.set_xlim(100, 4e4)
ax.set_ylim(1e-7, 2)
fig.suptitle(stripe.name + ' ' + reprAngle, fontsize=16)
x, R2s = np.loadtxt(refs, unpack=True, skiprows=2, usecols=(0, 1))
p1, = ax.semilogy(x*1e-3, R2s, '-k', label='s CXRO')
x, R2s = np.loadtxt(refp, unpack=True, skiprows=2, usecols=(0, 1))
p2, = ax.semilogy(x*1e-3, R2s, '--k', label='p CXRO')
refl = stripe.get_amplitude(E, math.sin(theta))
rs, rp = refl[0], refl[1]
rs0, rp0 = strOnly.get_amplitude(E, math.sin(theta))[0:2]
p3, = ax.semilogy(E*1e-3, abs(rs)**2, '-r')
p4, = ax.semilogy(E*1e-3, abs(rp)**2, '--r')
p5, = ax.semilogy(E*1e-3, abs(rs0)**2, '-m')
p6, = ax.semilogy(E*1e-3, abs(rp0)**2, '--c')
l1 = ax.legend([p1, p2], ['s', 'p'], loc=3)
ax.legend([p1, p3, p5], ['CXRO', 'xrt', 'bulk coating'], loc=1)
ax.add_artist(l1)
# phases:
ax2 = ax.twinx()
ax2.set_ylabel(r'$\phi_s - \phi_p$', color='c')
phi = np.unwrap(np.angle(rs * rp.conj()))
p9, = ax2.plot(E*1e-3, phi, 'c', lw=2, yunits=math.pi, zorder=0)
formatter = mpl.ticker.FormatStrFormatter('%g' + r'$ \pi$')
ax2.yaxis.set_major_formatter(formatter)
for tl in ax2.get_yticklabels():
tl.set_color('c')
ax2.set_zorder(-1)
ax.patch.set_visible(False) # hide the 'canvas'
fname = 'MirrorRefl' + stripe.name + "".join(reprAngle.split())
fig.savefig(fname + '.png')
dataDir = os.path.join('', 'CXRO-Reflectivities')
E = np.logspace(2., 4.+math.log10(4.), 1000)
mSi = rm.Material('Si', rho=2.33)
mSiO2 = rm.Material(('Si', 'O'), quantities=(1, 2), rho=2.65)
# mB4C = rm.Material(('B', 'C'), quantities=(4, 1), rho=2.52)
mRh = rm.Material('Rh', rho=12.41, kind='mirror')
mC = rm.Material('C', rho=3.5, kind='mirror')
cRhSi = rm.Coated(coating=mRh, cThickness=300,
substrate=mSi, surfaceRoughness=20,
substRoughness=20, name='30 nm Rh on Si')
cCSiO2 = rm.Coated(coating=mC, cThickness=200,
substrate=mSiO2, surfaceRoughness=10,
substRoughness=10, name='20 nm Diamond on Quartz')
for_one_material(cRhSi, mRh,
os.path.join(dataDir, "RhSi_s_rough2.CXRO.gz"),
os.path.join(dataDir, "RhSi_p_rough2.CXRO.gz"),
4e-3, '@ 4 mrad,\nRMS roughness 2 nm')
for_one_material(cCSiO2, mC,
os.path.join(dataDir, "CSiO2_s_rough1.CXRO.gz"),
os.path.join(dataDir, "CSiO2_p_rough1.CXRO.gz"),
np.radians(0.2), '@ 0.2 deg,\nRMS roughness 1 nm')
#import matplotlib as mpl
import matplotlib.pyplot as plt
import xrt.backends.raycing as raycing
import xrt.backends.raycing.sources as rs
import xrt.backends.raycing.apertures as ra
import xrt.backends.raycing.oes as roe
import xrt.backends.raycing.run as rr
import xrt.backends.raycing.materials as rm
import xrt.plotter as xrtp
import xrt.runner as xrtr
import xrt.backends.raycing.screens as rsc
showIn3D = False
mGold = rm.Material('Au', rho=19.3)
mGoldenGrating = rm.Material('Au',
rho=19.3,
kind='grating',
efficiency=[(1, 2)],
efficiencyFile='efficiency1-LEG.txt')
# efficiency=[(1, 1)], efficiencyFile='efficiency1-LEG.pickle')
# efficiency=[(1, 0.3)])
# )
E0 = 80.
dE = 0.01
#distE = 'lines'
#energies = np.linspace(E0-dE, E0+dE, 5)
distE = 'flat'
# -*- coding: utf-8 -*-
__author__ = "Konstantin Klementiev"
__date__ = "14 Mar 2019"
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
mSi = rm.Material('Si', rho=2.33)
mAu = rm.Material('Au', rho=19.3)
mC = rm.Material('C', rho=2.26)
mAuCont = rm.Multilayer(
tLayer=mC,
tThickness=10, # in Å
bLayer=mAu,
bThickness=400,
substrate=mSi,
nPairs=1,
idThickness=2)
E = np.linspace(10, 120, 110) # degrees
theta = np.radians(7) * np.ones_like(E)
rs, rp = mAu.get_amplitude(E, np.sin(theta))[0:2]
plt.plot(E, abs(rs)**2, label='s-pol Au')
plt.plot(E, abs(rp)**2, label='p-pol Au')
rs, rp = mAuCont.get_amplitude(E, np.sin(theta))[0:2]
plt.plot(E, abs(rs)**2, label='s-pol Au with 4 nm C')
plt.plot(E, abs(rp)**2, label='p-pol Au with 4 nm C')
__date__ = "08 Mar 2016"
import os, sys; sys.path.append(os.path.join('..', '..', '..')) # analysis:ignore
import numpy as np
import xrt.backends.raycing as raycing
import xrt.backends.raycing.sources as rs
#import xrt.backends.raycing.apertures as ra
import xrt.backends.raycing.oes as roe
import xrt.backends.raycing.run as rr
import xrt.backends.raycing.materials as rm
import xrt.plotter as xrtp
import xrt.runner as xrtr
import xrt.backends.raycing.screens as rsc
showIn3D = False
mGold = rm.Material('Au', rho=19.3, kind='grating')
gratingKind = 'y-grating'
if gratingKind == 'x-grating':
rho, fsm2pos = 3000., 15880.
elif gratingKind == 'y-grating':
rho, fsm2pos = -100., 25000.
else:
raise
class Grating(roe.OE):
def local_g(self, x, y, rho=rho):
"""Must be directed toward the positive oreder direction!"""
if gratingKind == 'x-grating':
return rho, 0, 0 # constant line spacing along x
#Materials and crystal planes
import sys
# sys.path.append(r'C:\Users\espov\Documents\Python\xrt')
sys.path.append('/mnt/c/Users/espov/Documents/Python/xrt')
import xrt.backends.raycing.materials as rmats
matRh = rmats.Material(elements=r"Rh",
kind=r"mirror",
rho=12.41,
table=r"Chantler",
name=None)
Si111_300K = rmats.CrystalSi(tK=300.0, name=None)
Si111_125K = rmats.CrystalSi(tK=125.0, name=None)
Si555_300K = rmats.CrystalSi(tK=300.0, hkl=[5, 5, 5], name=None)
Quartz102_300K = rmats.CrystalFromCell(
name=r"alphaQuartz",
hkl=[1, 0, 2],
a=4.91304,
c=5.40463,
gamma=120,
atoms=[14, 14, 14, 8, 8, 8, 8, 8, 8],
atomsXYZ=[[0.4697, 0.0, 0.0], [-0.4697, -0.4697, 0.3333333333333333],
[0.0, 0.4697, 0.6666666666666666], [0.4125, 0.2662, 0.1188],
[-0.1463, -0.4125, 0.4521], [-0.2662, 0.1463, -0.2145],
[0.1463, -0.2662, -0.1188], [-0.4125, -0.1463, 0.2145],
[0.2662, 0.4125, 0.5479]],
def compare_reflectivity_multilayer():
"""A comparison subroutine used in the module test suit."""
# cl_list = None
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')
# cl_list = matCL.cl_ctx[0], matCL.cl_queue[0], matCL.cl_program[0]
else:
matCL = None
def for_one_material(ml, refs, E, label, flabel=''):
fig = plt.figure(figsize=(8, 6), dpi=100)
fig.subplots_adjust(right=0.86)
ax = fig.add_subplot(111)
ax.set_xlabel('grazing angle (deg)')
ax.set_ylabel('reflectivity')
ax.set_xlim(theta[0], theta[-1])
fig.suptitle(label, fontsize=14)
x, R2s = np.loadtxt(refs, unpack=True)
p1, = ax.plot(x, R2s, '-k', label='s Mlayer')
refl = ml.get_amplitude(E, np.sin(np.deg2rad(theta)), ucl=matCL)
rs, rp = refl[0], refl[1]
p3, = ax.plot(theta, abs(rs)**2, '-r', lw=1)
p4, = ax.plot(theta, abs(rp)**2, '--r')
l1 = ax.legend([p3, p4], ['s', 'p'], loc=3)
ax.legend([p1, p3], ['Mlayer/XOP', 'xrt'], loc=1)
ax.add_artist(l1)
ylim = ax.get_ylim()
ax.set_ylim([ylim[0], 1])
# phases:
ax2 = ax.twinx()
ax2.set_ylabel(r'$\phi_s - \phi_p$', color='c')
phi = np.unwrap(np.angle(rs * rp.conj()))
p9, = ax2.plot(theta, phi, 'c', lw=1, yunits=math.pi, zorder=0)
formatter = mpl.ticker.FormatStrFormatter('%g' + r'$ \pi$')
ax2.yaxis.set_major_formatter(formatter)
for tl in ax2.get_yticklabels():
tl.set_color('c')
ax2.set_xlim(theta[0], theta[-1])
ax2.set_zorder(-1)
ax.patch.set_visible(False) # hide the 'canvas'
fname = 'Multilayer' + ml.tLayer.name + ml.bLayer.name
fig.savefig(fname + flabel)
dataDir = os.path.join('', 'XOP-Reflectivities')
theta = np.linspace(0, 1.6, 801) # degrees
mSi = rm.Material('Si', rho=2.33)
mW = rm.Material('W', rho=19.3)
mL = rm.Multilayer(mSi, 27, mW, 18, 40, mSi)
for_one_material(mL, os.path.join(dataDir, "WSi45A04.mlayer.gz"), 8050,
u'40 × [27 Å Si + 18 Å W] multilayer @ 8.05 keV')
mL = rm.Multilayer(mSi, 27*2, mW, 18*2, 40, mSi, 27, 18, 2)
for_one_material(mL, os.path.join(dataDir, "WSi45_100A40.mlayer.gz"), 8050,
u'Depth graded multilayer \n 40 × [54 Å Si + 36 Å W]'
u' to [27 Å Si + 18 Å W] @ 8.05 keV', '-graded')
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
import xrt.backends.raycing as raycing
import xrt.backends.raycing.sources as rs
#import xrt.backends.raycing.apertures as ra
import xrt.backends.raycing.oes as roe
import xrt.backends.raycing.run as rr
import xrt.backends.raycing.materials as rm
import xrt.plotter as xrtp
import xrt.runner as xrtr
import xrt.backends.raycing.screens as rsc
#mGold = rm.Material('Au', rho=19.3)
mGlass = rm.Material(('Si', 'O'), quantities=(1, 2), rho=2.2)
class BentCapillary(roe.OE):
def __init__(self, *args, **kwargs):
self.rSample = kwargs.pop('rSample')
self.entranceAlpha = kwargs.pop('entranceAlpha')
self.f = kwargs.pop('f')
self.r0in = kwargs.pop('rIn')
self.r0out = kwargs.pop('rOut')
roe.OE.__init__(self, *args, **kwargs)
s0 = self.f - self.rSample * np.cos(self.entranceAlpha)
self.a0 = -np.tan(self.entranceAlpha) / 2 / s0
self.b0 = self.rSample * np.sin(self.entranceAlpha) - self.a0 * s0**2
self.s0 = s0
def compare_reflectivity_multilayer_interdiffusion():
"""A comparison subroutine used in the module test suit."""
# cl_list = None
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')
# cl_list = matCL.cl_ctx[0], matCL.cl_queue[0], matCL.cl_program[0]
else:
matCL = None
def for_one_material(ml, refs, E, label, flabel=''):
fig = plt.figure(figsize=(8, 6), dpi=100)
fig.subplots_adjust(right=0.86)
ax = fig.add_subplot(111)
ax.set_xlabel('grazing angle (deg)')
ax.set_ylabel('reflectivity')
ax.set_xlim(theta[0], theta[-1])
fig.suptitle(label, fontsize=14)
x, R2s = np.loadtxt(refs, unpack=True, skiprows=2, usecols=(0, 1))
refl = ml.get_amplitude(E, np.sin(np.deg2rad(theta)), ucl=matCL)
rs, rp = refl[0], refl[1]
# amplitudes:
p1, = ax.plot(x, R2s, '-k', label='s CXRO')
p3, = ax.plot(theta, abs(rs)**2, '-r', lw=1)
p4, = ax.plot(theta, abs(rp)**2, '--r')
l1 = ax.legend([p3, p4], ['s', 'p'], loc=3)
ax.legend([p1, p3], ['CXRO-Multilayer', 'xrt'], loc=1)
ax.add_artist(l1)
ylim = ax.get_ylim()
ax.set_ylim([ylim[0], 1])
# phases:
ax2 = ax.twinx()
ax2.set_ylabel(r'$\phi_s - \phi_p$', color='c')
phi = np.unwrap(np.angle(rs * rp.conj()))
p9, = ax2.plot(theta, phi, 'c', lw=1, yunits=math.pi)
ax2.set_ylim(-0.001, 0.001)
formatter = mpl.ticker.FormatStrFormatter('%g' + r'$ \pi$')
ax2.yaxis.set_major_formatter(formatter)
for tl in ax2.get_yticklabels():
tl.set_color('c')
ax2.set_xlim(theta[0], theta[-1])
ax2.set_zorder(-1)
ax.patch.set_visible(False) # hide the 'canvas'
fname = 'Multilayer' + ml.tLayer.name + ml.bLayer.name
fig.savefig(fname + flabel)
dataDir = os.path.join('', 'CXRO-Reflectivities')
theta = np.linspace(0, 1.6, 1001) # degrees
mSi = rm.Material('Si', rho=2.33)
mW = rm.Material('W', rho=19.3)
mL = rm.Multilayer(mSi, 17.82, mW, 11.88, 300, mSi, idThickness=0)
for_one_material(mL, os.path.join(dataDir, "WSi300id0.CXRO.gz"), 24210,
u'300 × [17.82 Å Si + 11.88 Å W] multilayer @ 24.21 keV\nInterdiffusion RMS 0 Å',
'CXRO_id0')
mL = rm.Multilayer(mSi, 17.82, mW, 11.88, 300, mSi, idThickness=6)
for_one_material(mL, os.path.join(dataDir, "WSi300id6.CXRO.gz"), 24210,
u'300 × [17.82 Å Si + 11.88 Å W] multilayer @ 24.21 keV\nInterdiffusion RMS 6 Å',
'CXRO_id6')
# -*- 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
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, theta, abs(rp)**2)
plt.show()
__author__ = "Konstantin Klementiev", "Roman Chernikov"
__date__ = "08 Mar 2016"
import os, sys
sys.path.append(os.path.join('..', '..', '..')) # analysis:ignore
import numpy as np
import xrt.backends.raycing as raycing
import xrt.backends.raycing.sources as rs
#import xrt.backends.raycing.apertures as ra
import xrt.backends.raycing.oes as roe
import xrt.backends.raycing.run as rr
import xrt.backends.raycing.materials as rm
import xrt.plotter as xrtp
import xrt.runner as xrtr
import xrt.backends.raycing.screens as rsc
mGold = rm.Material('Au', rho=19.3)
E0 = 9000.
L = 1200.
W = 10.
gap = 0.2
pitchVFM = 4e-3
pVFM = 20000.
qVFM = 400000000.
pitchHFM = 4e-3
pHFM = 20000.
qHFM = 400000000.
p = pVFM
q = 2000
#Select a case:
def plot_generator(plots, plotsFSM2, beamLine):
if Lens == roe.DoubleParaboloidLens:
nFactor = 0.5
elif Lens == roe.ParaboloidFlatLens:
nFactor = 1.
else:
nFactor = 2.
mBeryllium = rm.Material('Be', rho=1.848, kind='lens')
get_nCRL(mBeryllium, parabolaParam, q, E0, nFactor)
mDiamond = rm.Material('C', rho=3.52, kind='lens')
get_nCRL(mDiamond, parabolaParam, q, E0, nFactor)
mAluminum = rm.Material('Al', rho=2.7, kind='lens')
get_nCRL(mAluminum, parabolaParam, q, E0, nFactor)
mSilicon = rm.Material('Si', rho=2.33, kind='lens')
get_nCRL(mSilicon, parabolaParam, q, E0, nFactor)
mNickel = rm.Material('Ni', rho=8.9, kind='lens')
get_nCRL(mNickel, parabolaParam, q, E0, nFactor)
mLead = rm.Material('Pb', rho=11.35, kind='lens')
get_nCRL(mLead, parabolaParam, q, E0, nFactor)
# materials = mBeryllium, mDiamond, mAluminum, mSilicon, mNickel, mLead
materials = mBeryllium, mDiamond
print('At E = {0} eV and parabola focus = {1} mm:'.format(
E0, parabolaParam))
for material in materials:
print(' n({0}) = {1}'.format(material.elements[0].name, material.nCRL))
# polarization = [
# 'horizontal', 'vertical', '+45', '-45', 'right', 'left', None]
polarization = 'hor',
figDF = plt.figure(figsize=(7, 5), dpi=72)
ax1 = plt.subplot(111)
ax1.set_title(r'FWHM size of beam cross-section near focal position')
ax1.set_xlabel(r'd$q$ (mm)', fontsize=14)
ax1.set_ylabel(u'FWHM size (µm)', fontsize=14)
figI = plt.figure(figsize=(7, 5), dpi=72)
ax2 = plt.subplot(111)
ax2.set_title(r'relative flux at sample position')
ax2.set_xlabel('material', fontsize=14)
ax2.set_ylabel(u'flux (a.u.)', fontsize=14)
prefix = 'CRL-indiv-'
for pol in polarization:
beamLine.sources[0].polarization = pol
suffix = pol
if suffix is None:
suffix = 'none'
xMaterials = []
yFlux = []
for material in materials:
beamLine.curMaterial = material
beamLine.lens.material = material
beamLine.lens.center = [0, p, 0]
elem = material.elements[0].name
print(elem)
for plot in plots:
fileName = '{0}{1}{2}-{3}-{4}'.format(prefix, lensName, elem,
suffix, plot.title)
plot.saveName = fileName + '.png'
# plot.persistentName = fileName + '.pickle'
try:
plot.textPanel.set_text(
plot.textPanelTemplate.format(elem))
except AttributeError:
pass
yield
xCurve = []
yCurve = []
for dq, plot in zip(beamLine.fsm2.dqs, plotsFSM2):
if plot.dx < (xyLimits[1] - xyLimits[0]) * 0.5:
# print(dq, plot.dx)
xCurve.append(dq)
yCurve.append(plot.dx)
yFlux.append(plotsFSM2[-1].intensity)
ax1.plot(xCurve,
yCurve,
'o',
label='{0}, n={1:.0f}'.format(elem, round(material.nCRL)))
xMaterials.append(elem)
ax1.legend(loc=4) # lower right
figDF.savefig(prefix + lensName + 'depthOfFocus.png')
# plt.close(figDF)
rects = ax2.bar(np.arange(len(materials)) + 0.1,
np.array(yFlux) / max(yFlux),
bottom=1e-3,
log=True)
for rect, material in zip(rects, materials):
height = rect.get_height()
ax2.text(rect.get_x() + rect.get_width() / 2.,
0.9 * height,
'n=%d' % material.nCRL,
ha='center',
va='top',
color='w')
ax2.set_xticks(np.arange(len(materials)) + 0.5)
ax2.set_xticklabels(xMaterials)
ax2.set_ylim(1e-3, 1)
figI.savefig(prefix + lensName + 'Flux.png')
# -*- coding: utf-8 -*-
__author__ = "Konstantin Klementiev, Roman Chernikov"
__date__ = "1 Nov 2019"
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
#mSi = rm.Material('Si', rho=2.33)
#mW = rm.Material('W', rho=19.3)
#mL = rm.Multilayer(mSi, 27, mW, 18, 40, mSi)
mSi = rm.Material('Si', rho=2.33)
mW = rm.Material('W', rho=19.3)
mB4C = rm.Material(['B', 'C'], [4, 1], rho=2.52)
mL = rm.Multilayer(mB4C, 16, mW, 8, 150, mSi)
theta = 1.5
plt.subplot(121)
E = np.linspace(9.5, 10.5, 1001) * 1e3 # eV
rs, rp = mL.get_amplitude(E, np.sin(np.deg2rad(theta)))[0:2]
plt.plot(E * 1e-3, abs(rs)**2, '-')
plt.subplot(122)
E *= 2
rs, rp = mL.get_amplitude(E, np.sin(np.deg2rad(theta)))[0:2]
plt.plot(E * 1e-3, abs(rs)**2, '-')
import math
import numpy as np
import os, sys
sys.path.append(os.path.join('..', '..', '..')) # analysis:ignore
import xrt.backends.raycing as raycing
import xrt.backends.raycing.sources as rs
import xrt.backends.raycing.apertures as ra
import xrt.backends.raycing.oes as roe
import xrt.backends.raycing.run as rr
import xrt.backends.raycing.materials as rm
import xrt.backends.raycing.screens as rsc
showIn3D = False
stripeSi = rm.Material('Si', rho=2.33)
stripeSiO2 = rm.Material(('Si', 'O'), quantities=(1, 2), rho=2.2)
stripeIr = rm.Material('Ir', rho=22.42)
mSi = rm.Material('Si', rho=2.33)
mW = rm.Material('W', rho=19.3)
mL = rm.Multilayer(mSi, 27, mW, 18, 40, mSi)
def build_beamline(nrays=1e4,
hkl=(1, 1, 1),
stripe='Si',
eMinRays=2400,
eMaxRays=45000):
filterDiamond = rm.Material('C', rho=3.52, kind='plate')
if stripe.startswith('S'):
materialVCM = stripeSi
def build_beamline(nrays=raycing.nrays, eMinRays=550, eMaxRays=30550):
x0, y0 = -30095.04, -30102.65 # straight section center
xFar, yFar = -59999.67, -198.017
height = 1400.
azimuth = np.arctan2(xFar - x0, yFar - y0)
stripeSi = rm.Material('Si', rho=2.33)
stripeRh = rm.Material('Rh', rho=12.41)
stripePt = rm.Material('Pt', rho=21.45)
si111_1 = rm.CrystalSi(hkl=(1, 1, 1), tK=-171+273.15)
si311_1 = rm.CrystalSi(hkl=(3, 1, 1), tK=-171+273.15)
si111_2 = rm.CrystalSi(hkl=(1, 1, 1), tK=-140+273.15)
si311_2 = rm.CrystalSi(hkl=(3, 1, 1), tK=-140+273.15)
filterDiamond = rm.Material('C', rho=3.52, kind='plate')
beamLine = raycing.BeamLine(azimuth=azimuth, height=height)
wigglerToStraightSection = 645.0
xWiggler = x0 + wigglerToStraightSection * beamLine.sinAzimuth
yWiggler = y0 + wigglerToStraightSection * beamLine.cosAzimuth
rs.Wiggler(beamLine, name='MPW80', center=(
xWiggler, yWiggler, height),
nrays=nrays, period=80., K=13, n=12, eE=3., eI=0.4,
eSigmaX=200, eSigmaZ=15, eEpsilonX=4.3, eEpsilonZ=0.043,
eMin=eMinRays, eMax=eMaxRays,
xPrimeMax=1.5, zPrimeMax=0.25)
# rs.GeometricSource(beamLine, 'Source', (xWiggler, yWiggler, height),
# nrays=nrays, distE='flat', energies=(2000, 25000),
# polarization='horizontal')
sampleToStraightSection = 36554.1
beamLine.xSample = x0 + sampleToStraightSection * beamLine.sinAzimuth
beamLine.ySample = y0 + sampleToStraightSection * beamLine.cosAzimuth
beamLine.feFixedMask = ra.RectangularAperture(
beamLine, 'FEFixedMask', (-36876.69, -23321.01, height),
('left', 'right', 'bottom', 'top'), [-8.3, 8.3, -2.35, 2.35])
beamLine.fePhotonShutter = ra.RectangularAperture(
beamLine, 'FEPhotonShutter', (-37133.37, -23064.33, height),
('left', 'right', 'bottom', 'top'), [-10.5, 10.5, -8.0, 8.0],
alarmLevel=0.)
beamLine.feMovableMaskLT = ra.RectangularAperture(
beamLine, 'FEMovableMaskLT', (-38979.62, -21218.07, height),
('left', 'top'), [-10, 3.], alarmLevel=0.5)
beamLine.feMovableMaskRB = ra.RectangularAperture(
beamLine, 'FEMovableMaskRB', (-39262.47, -20935.23, height),
('right', 'bottom'), [10, -3.], alarmLevel=0.5)
beamLine.filter1 = roe.Plate(
beamLine, 'Filter1',
(-42740.918, -17456.772, height), pitch=np.pi/2,
limPhysX=(-20., 20.), limPhysY=(-9., 9.),
surface=('diamond 90 $\mu$m',), material=(filterDiamond,), t=0.09,
targetOpenCL=targetOpenCL,
alarmLevel=0.)
beamLine.fsm1 = rsc.Screen(
beamLine, 'DiamondFSM1', (-42920.68, -17277.01, height),
compressX=1./2.44)
beamLine.vcm = roe.VCM(
beamLine, 'VCM', [-43819.49, -16378.20, height],
surface=('Rh', 'Si', 'Pt'), material=(stripeRh, stripeSi, stripePt),
limPhysX=(-53., 53.), limPhysY=(-655., 655.),
limOptX=((-47., -15.5, 16.), (-16., 15.5, 47.)),
limOptY=((-650., -655., -650.), (650., 655., 650.)),
R=5.0e6,
jack1=[-43328.05, -16869.64, 973.0732],
jack2=[-44403.38, -15964.02, 973.0732],
jack3=[-44233.68, -15794.31, 973.0732],
tx1=[0.0, -695.], tx2=[0.0, 705.75],
targetOpenCL=targetOpenCL,
alarmLevel=0.)
beamLine.fsm2 = rsc.Screen(
beamLine, 'NormalFSM2', (-44745.34, -15452.36, height),
compressX=1./2.44)
beamLine.dcm = roe.DCMOnTripodWithOneXStage(
beamLine, 'DCM',
[-45342.09, -14855.6, 1415.], surface=('Si311', 'Si111'),
material=(si311_1, si111_1), material2=(si311_2, si111_2),
limPhysX=((-51.1, 6.1), (-6.1, 51.1)), limPhysY=(-30., 30.),
cryst2perpTransl=20., cryst2longTransl=95.,
limPhysX2=((8.6, -48.6), (48.6, -8.6)), limPhysY2=(-90., 90.),
jack1=[-45052.88, -15079.04, 702.4973],
jack2=[-44987.82, -14490.02, 702.4973],
jack3=[-45576.85, -14555.08, 702.4973],
targetOpenCL=targetOpenCL,
alarmLevel=0.)
beamLine.fsm3 = rsc.Screen(
beamLine, 'DiamondFSM3', (-46625.89, -13571.81, height),
compressX=1./2.44)
beamLine.BSBlock = ra.RectangularAperture(
beamLine, 'BSBlock',
(-45988.52, -14209.17, height), ('bottom',), (22,), alarmLevel=0.)
beamLine.slitAfterDCM_LR = ra.RectangularAperture(
beamLine, 'SlitAfterDCM_LR', (-46095.65, -14102.04, height),
('left', 'right'), [-25.0, 25.0], alarmLevel=0.5)
beamLine.slitAfterDCM_BT = ra.RectangularAperture(
beamLine, 'SlitAfterDCM_BT', (-46107.67, -14090.02, height),
('bottom', 'top'), [27.0, 77.0], alarmLevel=0.5)
foilsZActuatorOffset = 0
beamLine.xbpm4foils = ra.SetOfRectangularAperturesOnZActuator(
beamLine, 'XBPM4foils', (-46137.73, -14059.97, height),
(u'Cu5µm', u'Al7µm', u'Al0.8µm', 'top-edge'),
(1344.607 + foilsZActuatorOffset, 1366.607 + foilsZActuatorOffset,
1388.607 + foilsZActuatorOffset, 1400. + foilsZActuatorOffset),
(45, 45, 45), (8, 8, 8), alarmLevel=0.)
beamLine.vfm = roe.DualVFM(
beamLine, 'VFM', [-47491.364, -12706.324, 1449.53],
surface=('Rh', 'Pt'), material=(stripeRh, stripePt),
limPhysX=(-56., 56.), limPhysY=(-714., 714.),
limOptX=((1., -46.), (46., -4.)),
limOptY=((-712., -712.), (712., 712.)),
positionRoll=np.pi, R=5.0e6,
r1=70., xCylinder1=23.5, hCylinder1=3.7035,
r2=35.98, xCylinder2=-25.0, hCylinder2=6.9504,
jack1=[-46987.20, -13210.49, 1272.88],
jack2=[-48062.53, -12304.87, 1272.88],
jack3=[-47892.83, -12135.16, 1272.88],
tx1=[0.0, -713.], tx2=[0.0, 687.75],
targetOpenCL=targetOpenCL,
alarmLevel=0.2)
beamLine.fsm4 = rsc.Screen(
beamLine, 'DiamondFSM4', (-48350.17, -11847.53, height),
compressX=1./2.44)
beamLine.ohPSFront = ra.RectangularAperture(
beamLine, 'OH-PS-FrontCollimator', (-48592.22, -11605.47, height),
('left', 'right', 'bottom', 'top'), (-23., 23., 30.48, 79.92),
alarmLevel=0.2)
beamLine.ohPSBack = ra.RectangularAperture(
beamLine, 'OH-PS-BackCollimator', (-48708.19, -11489.51, height),
('left', 'right', 'bottom', 'top'), (-23., 23., 31.1, 81.1),
alarmLevel=0.)
beamLine.eh100To40Flange = ra.RoundAperture(
beamLine, 'eh100To40Flange', [-53420.63, -6777.058, height], 19.,
alarmLevel=0.)
eh100To40FlangeToslit = 1159.
slitX = beamLine.eh100To40Flange.center[0] +\
eh100To40FlangeToslit * np.sin(azimuth)
slitY = beamLine.eh100To40Flange.center[1] +\
eh100To40FlangeToslit * np.cos(azimuth)
beamLine.slitEH = ra.RectangularAperture(
beamLine, 'slitEH', (slitX, slitY, height),
('left', 'right', 'bottom', 'top'), [-5, 5, -2.5, 2.5], alarmLevel=0.5)
beamLine.fsmAtSample = rsc.Screen(
beamLine, 'FocusAtSample',
(beamLine.xSample, beamLine.ySample, height))
return beamLine
def mono_kwargs(E0,
dE,
hkl,
miscut,
crystal_pitch_corr=[0, 0, 0, 0],
withLens=True,
screens=None):
FWHM_x = 1000
FWHM_z = 300
screens_kwargs = []
# SOURCE
d_source = 200
source_kwargs = {
'name': 'source',
'center': [0, -d_source, 0],
'nrays': 1e5,
'dx': FWHM_x / 1000 / 2.634, # mm
'dz': FWHM_z / 1000 / 2.634, # mm
'dxprime': 0.03 / 1e6, # rad
'dzprime': 0.03 / 1e6, # rad
'distE': 'flat', # lines, normal, flat
'energies': [E0 - dE, E0 + dE],
# 'polarization': 'h'
'polarization': 'v'
}
angle = 0
# CRYSTAL 0
Si_kwargs = {
'hkl': hkl,
# 'tK': 300 # [K]
'tK': 120 # [K]
}
Si_crystal = rm.CrystalSi(**Si_kwargs)
Si_tth = 2 * Si_crystal.get_Bragg_angle(E0)
n = np.array([0, np.cos(angle), np.sin(angle)])
center = [0, 0, 0]
crystal0_kwargs = {
'name': 'crystal0',
'center': center,
'pitch': 'auto',
'positionRoll': 0,
'material': Si_crystal,
'alpha': 0
}
if (screens is None) or ('crystal0' in screens):
screens_kwargs.append({
'name': 's_crystal0',
'center': center,
'z': get_perpendicular_vector(n)
})
angle = angle + (Si_tth - 2 * Si_crystal.get_dtheta(E0, 0) +
crystal_pitch_corr[0])
# CRYSTAL 1
center = crystal0_kwargs['center'] + \
np.array([0, np.cos(angle), np.sin(angle)])*200
crystal1_kwargs = {
'name': 'crystal1',
'center': center,
'pitch': 'auto',
'positionRoll': np.pi,
'material': Si_crystal,
'alpha': miscut
}
if (screens is None) or ('crystal1' in screens):
screens_kwargs.append({
'name': 's_crystal1',
'center': center,
'z': get_perpendicular_vector(n)
})
angle = angle - (Si_tth - 2 * Si_crystal.get_dtheta(E0, miscut) +
crystal_pitch_corr[1])
# CRL 1
mBeryllium = rm.Material('Be', rho=1.848, kind='lens')
q = 10000 # mm
zmax = 0.2
n = np.array([0, np.cos(angle), np.sin(angle)])
center = crystal1_kwargs['center'] + n * q
crl1_kwargs = {
'name': 'crl1',
'center': center,
'material': mBeryllium,
'zmax': zmax,
'nCRL': (q, E0),
}
if (screens is None) or ('crl1' in screens):
screens_kwargs.append({
'name': 's_crl1',
'center': center,
'z': get_perpendicular_vector(n)
})
angle = angle + 0
# SLITS
n = np.array([0, np.cos(angle), np.sin(angle)])
center = crl1_kwargs['center'] + n * q
slit_kwargs = {
'name': 'slits',
'center': center,
'kind': ['left', 'right', 'bottom', 'top'],
# 'opening': [-5, 5, -.0035, .0035]
'opening': [-5, 5, -5, 5]
}
if (screens is None) or ('slits' in screens):
screens_kwargs.append({
'name': 's_slits',
'center': center,
'z': get_perpendicular_vector(n)
})
angle = angle + 0
# CRL 2
n = np.array([0, np.cos(angle), np.sin(angle)])
center = slit_kwargs['center'] + n * q
crl2_kwargs = {
'name': 'crl2',
'center': center,
'material': mBeryllium,
'zmax': zmax,
'nCRL': (q, E0),
}
if (screens is None) or ('crl2' in screens):
screens_kwargs.append({
'name': 's_crl2',
'center': center,
'z': get_perpendicular_vector(n)
})
angle = angle + 0
# CRYSTAL 2
n = np.array([0, np.cos(angle), np.sin(angle)])
center = crl2_kwargs['center'] + n * (q - 200)
crystal2_kwargs = {
'name': 'crystal2',
'center': center,
'pitch': 'auto',
'positionRoll': np.pi,
'material': Si_crystal,
'alpha': 0
}
if (screens is None) or ('crystal2' in screens):
screens_kwargs.append({
'name': 's_crystal2',
'center': center,
'z': get_perpendicular_vector(n)
})
angle = angle - (Si_tth - 2 * Si_crystal.get_dtheta(E0, 0) +
crystal_pitch_corr[2])
# CRYSTAL 3
n = np.array([0, np.cos(angle), np.sin(angle)])
center = crystal2_kwargs['center'] + n * 200
crystal3_kwargs = {
'name': 'crystal3',
'center': center,
'pitch': 'auto',
'positionRoll': 0,
'material': Si_crystal,
'alpha': -miscut
}
if (screens is None) or ('crystal3' in screens):
screens_kwargs.append({
'name': 's_crystal3',
'center': center,
'z': get_perpendicular_vector(n)
})
angle = angle + (Si_tth - 2 * Si_crystal.get_dtheta(E0, -miscut) +
crystal_pitch_corr[3])
# DETECTOR
n = np.array([0, np.cos(angle), np.sin(angle)])
center = crystal3_kwargs['center'] + n * 300
screens_kwargs.append({
'name': 'detector',
'center': center,
'z': get_perpendicular_vector(n)
})
if withLens is True:
oes_kwargs = [source_kwargs, crystal0_kwargs, crystal1_kwargs, crl1_kwargs, \
slit_kwargs, crl2_kwargs, crystal2_kwargs, crystal3_kwargs]
else:
oes_kwargs = [source_kwargs, crystal0_kwargs, crystal1_kwargs, \
slit_kwargs, crystal2_kwargs, crystal3_kwargs]
screens_kwargs.pop(2)
screens_kwargs.pop(3)
return oes_kwargs, screens_kwargs
import numpy as np
import itertools
import xrt.runner as xrtr
import xrt.backends.raycing.screens as rsc
import xrt.plotter as xrtp
import xrt.backends.raycing.run as rr
import xrt.backends.raycing.materials as rm
import xrt.backends.raycing as raycing
from lenses import polycapillary as pl
from utils import beam as ub
# Constant materials FIXME - wrap this up
mGold = rm.Material('Au', rho=19.3)
mGlass = rm.Material(('Si', 'O'), quantities=(1, 2), rho=2.2)
class StraightCapillaryTest(object):
""" Implement shining through a single pipe-like object """
def __init__(self):
""" Tania przestrzen reklamowa """
# This is neccessary
self.beamLine = raycing.BeamLine()
self.beamTotal = None
# This is supposed to be an atomic iterator
self.beam_iterator = itertools.count()
# Process that many photons in one raytraycing_run
self.beam_chunk_size = 1000
sys.path.append(os.path.join('..', '..', '..')) # analysis:ignore
import numpy as np
import pickle
import xrt.backends.raycing as raycing
import xrt.backends.raycing.sources as rs
import xrt.backends.raycing.apertures as ra
import xrt.backends.raycing.oes as roe
import xrt.backends.raycing.run as rr
import xrt.backends.raycing.materials as rm
import xrt.plotter as xrtp
import xrt.runner as xrtr
import xrt.backends.raycing.screens as rsc
#import xrt.backends.raycing.waves as rw
mRhodium = rm.Material('Rh', rho=12.41)
mRhodiumGrating = rm.Material('Rh', rho=12.41, kind='grating')
mGolden = rm.Material('Au', rho=19.32)
mGoldenGrating = rm.Material('Au', rho=19.32, kind='grating')
acceptanceHor = 2.2e-4 # FE acceptance, full angle, mrad
acceptanceVer = 4.2e-4 # FE acceptance
pFE = 19250.
pM1 = 24000.
pPG = 2000.
pM3 = 2800. # distance to PG
qM3mer = 12000.
qM3sag = 12000.
dM4ES = 2200.
dM45 = 3200.
# -*- 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
layerW = rm.Material('W', kind='thin mirror', rho=19.3, t=2.5e-6)
E = 10000
theta = np.linspace(0, 10, 501) # degrees
rs, rp = layerW.get_amplitude(E, np.sin(np.deg2rad(theta)))[0:2]
plt.semilogy(theta, abs(rs)**2, 'r', theta, abs(rp)**2, 'b')
plt.show()
