def calculate_laue_monochromator(energy_setup=8000.0,energies=numpy.linspace(7990,8010,200)):
diffraction_setup_r = DiffractionSetup(geometry_type=LaueDiffraction(), # GeometryType object
crystal_name="Si", # string
thickness=10e-6, # meters
miller_h=1, # int
miller_k=1, # int
miller_l=1, # int
asymmetry_angle=numpy.pi/2, # 10.0*numpy.pi/180., # radians
azimuthal_angle=0.0) # radians # int
diffraction = Diffraction()
scan = numpy.zeros_like(energies)
r = numpy.zeros_like(energies)
for i in range(energies.size):
#
# gets Bragg angle needed to create deviation's scan
#
energy = energies[i]
bragg_angle = diffraction_setup_r.angleBragg(energy_setup)
print("Bragg angle for E=%f eV is %f deg" % (energy, bragg_angle * 180.0 / numpy.pi))
# Create a Diffraction object (the calculator)
deviation = 0.0 # angle_deviation_min + ia * angle_step
angle = deviation + numpy.pi / 2 + bragg_angle
# calculate the components of the unitary vector of the incident photon scan
# Note that diffraction plane is YZ
yy = numpy.cos(angle)
zz = - numpy.abs(numpy.sin(angle))
photon = Photon(energy_in_ev=energy,direction_vector=Vector(0.0,yy,zz))
# perform the calculation
coeffs_r = diffraction.calculateDiffractedComplexAmplitudes(diffraction_setup_r, photon)
scan[i] = energy
r[i] = numpy.abs( coeffs_r['S'].complexAmplitude() )**4
return scan,r
def toDictionary(self):
"""
Returns this setup in InfoDictionary form.
:return: InfoDictionary form of this setup.
"""
info_dict = DiffractionSetup.toDictionary(self)
info_dict["Minimum energy"] = str(self.energyMin())
info_dict["Maximum energy"] = str(self.energyMax())
info_dict["Number of energy points"] = str(self.energyPoints())
info_dict["Angle deviation minimum"] = "%.2e" % (self.angleDeviationMin())
info_dict["Angle deviation maximum"] = "%.2e" % (self.angleDeviationMax())
info_dict["Angle deviation points"] = str(self.angleDeviationPoints())
return info_dict
def diffractionSetup():
directions = [Vector(0, 0, 1.0 / float(n)) for n in range(1, 176)]
photons = [Photon(10000, direction) for direction in directions]
diffraction_setup = DiffractionSetup(
BraggDiffraction(),
"Si",
thickness=0.0001,
miller_h=1,
miller_k=1,
miller_l=1,
asymmetry_angle=10 * numpy.pi / 180,
azimuthal_angle=0.0,
)
# incoming_photons=photons)
return diffraction_setup
def testOperatorNotEqual(self):
diffraction_setup_one = diffractionSetup()
diffraction_setup_two = DiffractionSetup(
BraggDiffraction(),
"Diamond",
thickness=0.001,
miller_h=1,
miller_k=1,
miller_l=1,
asymmetry_angle=10 * numpy.pi / 180,
azimuthal_angle=0.0,
)
# incoming_photons=None)
self.assertTrue(diffraction_setup_one != diffraction_setup_two)
self.assertFalse(diffraction_setup_one != diffractionSetup())
def __init__(self,
geometry_type, crystal_name, thickness,
miller_h, miller_k, miller_l,
asymmetry_angle,
azimuthal_angle,
energy_min,
energy_max,
energy_points,
angle_deviation_min,
angle_deviation_max,
angle_deviation_points):
"""
Constructor.
:param geometry_type: GeometryType (BraggDiffraction,...).
:param crystal_name: The name of the crystal, e.g. Si.
:param thickness: The crystal thickness.
:param miller_h: Miller index H.
:param miller_k: Miller index K.
:param miller_l: Miller index L.
:param asymmetry_angle: The asymmetry angle between surface normal and Bragg normal.
:param azimuthal_angle: The angle between the projection of the Bragg normal
on the crystal surface plane and the x axis.
:param energy_min: The minimum energy.
:param energy_max: The maximum energy.
:param energy_points: Number of energy points.
:param angle_deviation_min: Minimal angle deviation.
:param angle_deviation_max: Maximal angle deviation.
:param angle_deviation_points: Number of deviations points.
"""
energies = numpy.linspace(energy_min,
energy_max,
energy_points)
deviations = numpy.linspace(angle_deviation_min,
angle_deviation_max,
angle_deviation_points)
# Create an "info setup" solely for the determination of deviation angles.
info_setup = DiffractionSetup(geometry_type=geometry_type,
crystal_name=crystal_name,
thickness=thickness,
miller_h=miller_h,
miller_k=miller_k,
miller_l=miller_l,
asymmetry_angle=asymmetry_angle,
azimuthal_angle=azimuthal_angle,)
# incoming_photons=[Photon(energy_min, Vector(0, 0, -1))])
# Call base constructor.
DiffractionSetup.__init__(self,
geometry_type=geometry_type,
crystal_name=crystal_name,
thickness=thickness,
miller_h=miller_h,
miller_k=miller_k,
miller_l=miller_l,
asymmetry_angle=asymmetry_angle,
azimuthal_angle=azimuthal_angle,)
# incoming_photons=photons)
# Create photons according to sweeps.
photons = PhotonBunch() # list()
for energy in energies:
for deviation in deviations:
direction = info_setup.incomingPhotonDirection(energy, deviation)
incoming_photon = Photon(energy, direction)
# photons.append(incoming_photon)
photons.addPhoton(incoming_photon)
self._incoming_photons = photons
# [email protected]: in theory, not needed as this info is in _incoming_photons
# but buffering this accelerates a lot the calculations
self._deviations = None
self._energies = None
def calculate_with_polarized_photon(method=0):
# Create a diffraction setup.
print("\nCreating a diffraction setup...")
diffraction_setup = DiffractionSetup(
geometry_type=BraggDiffraction(), # GeometryType object
crystal_name="Si", # string
thickness=1e-2, # meters
miller_h=1, # int
miller_k=1, # int
miller_l=1, # int
asymmetry_angle=
0, #10.0*numpy.pi/180., # radians
azimuthal_angle=0.0) # radians # int
energy = 8000.0 # eV
angle_deviation_min = -100e-6 # radians
angle_deviation_max = 100e-6 # radians
angle_deviation_points = 500
angle_step = (angle_deviation_max -
angle_deviation_min) / angle_deviation_points
bunch_in = PolarizedPhotonBunch()
bragg_angle = diffraction_setup.angleBragg(energy)
print("Bragg angle for E=%f eV is %f deg" %
(energy, bragg_angle * 180.0 / numpy.pi))
# Create a Diffraction object.
diffraction = Diffraction()
#
# get wavevector with incident direction matching Bragg angle
#
K0 = diffraction_setup.getK0(energy)
K0unitary = K0.getNormalizedVector()
print("K0", K0.components())
# method = 0 # diffraction for individual photons
# method = 1 # diffraction for bunch
ZZ = numpy.zeros(angle_deviation_points)
if method == 0:
bunch_out = PolarizedPhotonBunch()
for ia in range(angle_deviation_points):
deviation = angle_deviation_min + ia * angle_step
# angle = deviation + bragg_angle
# yy = numpy.cos(angle)
# zz = - numpy.abs(numpy.sin(angle))
# photon = PolarizedPhoton(energy_in_ev=energy,direction_vector=Vector(0.0,yy,zz),
# stokes_vector=StokesVector([1,0,1,0]))
# minus sign in angle is to perform cw rotation when deviation increses
Vin = K0unitary.rotateAroundAxis(Vector(1, 0, 0), -deviation)
photon = PolarizedPhoton(energy_in_ev=energy,
direction_vector=Vin,
stokes_vector=StokesVector([1, 0, 1, 0]))
photon_out = diffraction.calculateDiffractedPolarizedPhoton(
diffraction_setup,
incoming_polarized_photon=photon,
inclination_angle=0.0)
bunch_out.addPhoton(photon_out)
ZZ[ia] = angle_deviation_min + ia * angle_step
elif method == 1: # diffraction for bunch
for ia in range(angle_deviation_points):
deviation = angle_deviation_min + ia * angle_step
# angle = deviation + bragg_angle
# yy = numpy.cos(angle)
# zz = - numpy.abs(numpy.sin(angle))
# photon = PolarizedPhoton(energy_in_ev=energy,direction_vector=Vector(0.0,yy,zz),
# stokes_vector=StokesVector([1,0,1,0]))
# minus sign in angle is to perform cw rotation when deviation increses
Vin = K0unitary.rotateAroundAxis(Vector(1, 0, 0), -deviation)
photon = PolarizedPhoton(energy_in_ev=energy,
direction_vector=Vin,
stokes_vector=StokesVector([1, 0, 1, 0]))
bunch_in.addPhoton(photon)
ZZ[ia] = angle_deviation_min + ia * angle_step
bunch_out = diffraction.calculateDiffractedPolarizedPhotonBunch(
diffraction_setup, bunch_in, 0.0)
bunch_out_dict = bunch_out.toDictionary()
plot(1e6 * ZZ,
bunch_out_dict["s0"],
1e6 * ZZ,
bunch_out_dict["s1"],
legend=["S0", "S1"],
xtitle="theta - thetaB [urad]",
title="Polarized reflectivity calculation using method %d" % method)
def calculate_with_crystalpy(
bragg_or_laue=0, #
diffracted_or_transmitted=0, #
crystal_name="Si", # string
thickness=1e-2, # meters
miller_h=1, # int
miller_k=1, # int
miller_l=1, # int
asymmetry_angle=0.0, # radians
energy=8000.0, # eV
angle_deviation_min=-100e-6, # radians
angle_deviation_max=100e-6, # radians
angle_deviation_points=500,
method=0, # 0=crystalpy input, 1=shadow4 preprocessor file
):
if bragg_or_laue == 0:
if diffracted_or_transmitted == 0:
geometry_type = BraggDiffraction()
elif diffracted_or_transmitted == 1:
geometry_type = BraggTransmission()
else:
raise Exception("Bad geometry type")
elif bragg_or_laue == 1:
if diffracted_or_transmitted == 0:
geometry_type = LaueDiffraction()
elif diffracted_or_transmitted == 1:
geometry_type = LaueTransmission()
else:
raise Exception("Bad geometry type")
else:
raise Exception("Bad geometry type")
# Create a diffraction setup.
# print("\nCreating a diffraction setup...")
if method == 0:
diffraction_setup = DiffractionSetup(geometry_type=geometry_type,
crystal_name=crystal_name,
thickness=thickness,
miller_h=miller_h,
miller_k=miller_k,
miller_l=miller_l,
asymmetry_angle=asymmetry_angle,
azimuthal_angle=0.0)
else:
create_bragg_preprocessor_file_v1(interactive=False,
DESCRIPTOR=crystal_name,
H_MILLER_INDEX=miller_h,
K_MILLER_INDEX=miller_k,
L_MILLER_INDEX=miller_l,
TEMPERATURE_FACTOR=1.0,
E_MIN=5000.0,
E_MAX=15000.0,
E_STEP=100.0,
SHADOW_FILE="bragg_xop.dat")
diffraction_setup = DiffractionSetupShadowPreprocessor(
geometry_type=geometry_type,
crystal_name=crystal_name,
thickness=thickness,
miller_h=miller_h,
miller_k=miller_k,
miller_l=miller_l,
asymmetry_angle=asymmetry_angle,
azimuthal_angle=0.0,
preprocessor_file="bragg_xop.dat")
angle_step = (angle_deviation_max -
angle_deviation_min) / angle_deviation_points
#
# gets Bragg angle needed to create deviation's scan
#
bragg_angle = diffraction_setup.angleBragg(energy)
# print("Bragg angle for E=%f eV is %f deg"%(energy,bragg_angle*180.0/numpy.pi))
# Create a Diffraction object (the calculator)
diffraction = Diffraction()
# initialize arrays for storing outputs
deviations = numpy.zeros(angle_deviation_points)
intensityS = numpy.zeros(angle_deviation_points)
intensityP = numpy.zeros(angle_deviation_points)
for ia in range(angle_deviation_points):
deviation = angle_deviation_min + ia * angle_step
# angle = deviation + bragg_angle + asymmetry_angle
# # calculate the components of the unitary vector of the incident photon scan
# # Note that diffraction plane is YZ
# yy = numpy.cos(angle)
# zz = - numpy.abs(numpy.sin(angle))
# photon = Photon(energy_in_ev=energy,direction_vector=Vector(0.0,yy,zz))
k_unitary = diffraction_setup.incomingPhotonDirection(
energy, deviation)
# or equivalently
# k_0_unitary = diffraction_setup.incomingPhotonDirection(energy, 0.0)
# k_unitary = k_0_unitary.rotateAroundAxis( Vector(1.0,0.0,0.0), -deviation)
photon = Photon(energy_in_ev=energy, direction_vector=k_unitary)
# perform the calculation
coeffs = diffraction.calculateDiffractedComplexAmplitudes(
diffraction_setup, photon)
# store results
deviations[ia] = deviation
intensityS[ia] = coeffs['S'].intensity()
intensityP[ia] = coeffs['P'].intensity()
return deviations, intensityS, intensityP
def calculate_external_Crystal(GEOMETRY_TYPE,
CRYSTAL_NAME,
THICKNESS,
MILLER_H,
MILLER_K,
MILLER_L,
ASYMMETRY_ANGLE,
AZIMUTHAL_ANGLE,
incoming_bunch,
INCLINATION_ANGLE,
DUMP_TO_FILE,
FILE_NAME="tmp.dat"):
# Create a GeometryType object:
# Bragg diffraction = 0
# Bragg transmission = 1
# Laue diffraction = 2
# Laue transmission = 3
if GEOMETRY_TYPE == 0:
GEOMETRY_TYPE_OBJECT = BraggDiffraction()
elif GEOMETRY_TYPE == 1:
GEOMETRY_TYPE_OBJECT = BraggTransmission()
elif GEOMETRY_TYPE == 2:
GEOMETRY_TYPE_OBJECT = LaueDiffraction()
elif GEOMETRY_TYPE == 3:
GEOMETRY_TYPE_OBJECT = LaueTransmission()
else:
raise Exception("Crystal: The geometry type could not be interpreted!\n")
# Create a diffraction setup.
# At this stage I translate angles in radians, energy in eV and all other values in SI units.
print("Crystal: Creating a diffraction setup...\n")
diffraction_setup = DiffractionSetup(geometry_type=GEOMETRY_TYPE_OBJECT, # GeometryType object
crystal_name=str(CRYSTAL_NAME), # string
thickness=float(THICKNESS) * 1e-2, # meters
miller_h=int(MILLER_H), # int
miller_k=int(MILLER_K), # int
miller_l=int(MILLER_L), # int
asymmetry_angle=float(ASYMMETRY_ANGLE) / 180 * np.pi, # radians
azimuthal_angle=float(AZIMUTHAL_ANGLE) / 180 * np.pi) # radians
# incoming_photons=incoming_bunch)
# Create a Diffraction object.
diffraction = Diffraction()
# Create a PolarizedPhotonBunch object holding the results of the diffraction calculations.
print("Crystal: Calculating the outgoing photons...\n")
outgoing_bunch = diffraction.calculateDiffractedPolarizedPhotonBunch(diffraction_setup,
incoming_bunch,
INCLINATION_ANGLE)
# Check that the result of the calculation is indeed a PolarizedPhotonBunch object.
if not isinstance(outgoing_bunch, PolarizedPhotonBunch):
raise Exception("Crystal: Expected PolarizedPhotonBunch as a result, found {}!\n".format(type(outgoing_bunch)))
# Dump data to file if requested.
if DUMP_TO_FILE == 0:
print("Crystal: Writing data in {file}...\n".format(file=FILE_NAME))
with open(FILE_NAME, "w") as file:
try:
file.write("#S 1 photon bunch\n"
"#N 8\n"
"#L Energy [eV] Vx Vy Vz S0 S1 S2 S3\n")
file.write(outgoing_bunch.toString())
file.close()
print("File written to disk: %s"%FILE_NAME)
except:
raise Exception("Crystal: The data could not be dumped onto the specified file!\n")
return outgoing_bunch
def calculate_simple_diffraction():
# Create a diffraction setup.
print("\nCreating a diffraction setup...")
diffraction_setup = DiffractionSetup(
geometry_type=BraggDiffraction(), # GeometryType object
crystal_name="Si", # string
thickness=1e-2, # meters
miller_h=1, # int
miller_k=1, # int
miller_l=1, # int
asymmetry_angle=
0, #10.0*numpy.pi/180., # radians
azimuthal_angle=0.0) # radians # int
energy = 8000.0 # eV
angle_deviation_min = -100e-6 # radians
angle_deviation_max = 100e-6 # radians
angle_deviation_points = 500
angle_step = (angle_deviation_max -
angle_deviation_min) / angle_deviation_points
#
# gets Bragg angle needed to create deviation's scan
#
bragg_angle = diffraction_setup.angleBragg(energy)
print("Bragg angle for E=%f eV is %f deg" %
(energy, bragg_angle * 180.0 / numpy.pi))
# Create a Diffraction object (the calculator)
diffraction = Diffraction()
# initialize arrays for storing outputs
deviations = numpy.zeros(angle_deviation_points)
intensityS = numpy.zeros(angle_deviation_points)
intensityP = numpy.zeros(angle_deviation_points)
for ia in range(angle_deviation_points):
deviation = angle_deviation_min + ia * angle_step
angle = deviation + bragg_angle
# calculate the components of the unitary vector of the incident photon scan
# Note that diffraction plane is YZ
yy = numpy.cos(angle)
zz = -numpy.abs(numpy.sin(angle))
photon = Photon(energy_in_ev=energy,
direction_vector=Vector(0.0, yy, zz))
# perform the calculation
coeffs = diffraction.calculateDiffractedComplexAmplitudes(
diffraction_setup, photon)
# store results
deviations[ia] = deviation
intensityS[ia] = coeffs['S'].intensity()
intensityP[ia] = coeffs['P'].intensity()
# plot results
import matplotlib.pylab as plt
plt.plot(1e6 * deviations, intensityS)
plt.plot(1e6 * deviations, intensityP)
plt.xlabel("deviation angle [urad]")
plt.ylabel("Reflectivity")
plt.legend(["Sigma-polarization", "Pi-polarization"])
plt.show()
material_constants_library=xraylib)
a = DiffractionSetupShadowPreprocessorV2(geometry_type=BraggDiffraction,
crystal_name="Si",
thickness=1e-5,
miller_h=1,
miller_k=1,
miller_l=1,
asymmetry_angle=0.0,
azimuthal_angle=0.0,
preprocessor_file="bragg.dat")
b = DiffractionSetup(geometry_type=BraggDiffraction,
crystal_name="Si",
thickness=1e-5,
miller_h=1,
miller_k=1,
miller_l=1,
asymmetry_angle=0.0,
azimuthal_angle=0.0)
energy = 8000.0
print("============ SHADOW / XRAYLIB ==============")
print("Photon energy: %g eV " % (energy))
print("d_spacing: %g %g A " % (a.dSpacing(), b.dSpacing()))
print("unitCellVolumw: %g %g A**3 " %
(a.unitcellVolume(), b.unitcellVolume()))
print("Bragg angle: %g %g deg " % (a.angleBragg(energy) * 180 / numpy.pi,
b.angleBragg(energy) * 180 / numpy.pi))
print("Asymmetry factor b: ", a.asymmetryFactor(energy),
b.asymmetryFactor(energy))
def align_crystal(self):
oe = self.get_optical_element()
coor = self.get_coordinates()
if oe._material_constants_library_flag == 0:
print("\nCreating a diffraction setup (XRAYLIB)...")
diffraction_setup = DiffractionSetup(
geometry_type=BraggDiffraction(
), # todo: use oe._diffraction_geometry
crystal_name=oe._material, # string
thickness=oe._thickness, # meters
miller_h=oe._miller_index_h, # int
miller_k=oe._miller_index_k, # int
miller_l=oe._miller_index_l, # int
asymmetry_angle=oe._asymmetry_angle, # radians
azimuthal_angle=0.0)
elif oe._material_constants_library_flag == 1:
print("\nCreating a diffraction setup (DABAX)...")
diffraction_setup = DiffractionSetupDabax(
geometry_type=BraggDiffraction(
), # todo: use oe._diffraction_geometry
crystal_name=oe._material, # string
thickness=oe._thickness, # meters
miller_h=oe._miller_index_h, # int
miller_k=oe._miller_index_k, # int
miller_l=oe._miller_index_l, # int
asymmetry_angle=oe._asymmetry_angle, # radians
azimuthal_angle=0.0)
elif oe._material_constants_library_flag == 2:
print(
"\nCreating a diffraction setup (shadow preprocessor file V1)..."
)
diffraction_setup = DiffractionSetupShadowPreprocessorV1(
geometry_type=BraggDiffraction(
), # todo: use oe._diffraction_geometry
crystal_name=oe._material, # string
thickness=oe._thickness, # meters
miller_h=oe._miller_index_h, # int
miller_k=oe._miller_index_k, # int
miller_l=oe._miller_index_l, # int
asymmetry_angle=oe._asymmetry_angle, # radians
azimuthal_angle=0.0,
preprocessor_file=oe._file_refl)
elif oe._material_constants_library_flag == 3:
print(
"\nCreating a diffraction setup (shadow preprocessor file V2)..."
)
diffraction_setup = DiffractionSetupShadowPreprocessorV2(
geometry_type=BraggDiffraction(
), # todo: use oe._diffraction_geometry
crystal_name=oe._material, # string
thickness=oe._thickness, # meters
miller_h=oe._miller_index_h, # int
miller_k=oe._miller_index_k, # int
miller_l=oe._miller_index_l, # int
asymmetry_angle=oe._asymmetry_angle, # radians
azimuthal_angle=0.0,
preprocessor_file=oe._file_refl)
else:
raise NotImplementedError
self._crystalpy_diffraction_setup = diffraction_setup
if oe._f_central:
if oe._f_phot_cent == 0:
energy = oe._phot_cent
else:
energy = codata.h * codata.c / codata.e * 1e2 / (
oe._phot_cent * 1e-8)
setting_angle = diffraction_setup.angleBraggCorrected(energy)
print("Bragg angle for E=%f eV is %f deg" %
(energy, setting_angle * 180.0 / numpy.pi))
coor.set_angles(angle_radial=numpy.pi / 2 - setting_angle,
angle_radial_out=numpy.pi / 2 - setting_angle,
angle_azimuthal=0.0)
else:
print("Info: nothing to align: f_central=0")
print(coor.info())
def calculate_simple_diffraction_energy_scan_accelerated():
# Create a diffraction setup.
print("\nCreating a diffraction setup...")
diffraction_setup = DiffractionSetup(
geometry_type=BraggDiffraction(), # GeometryType object
crystal_name="Si", # string
thickness=1e-2, # meters
miller_h=1, # int
miller_k=1, # int
miller_l=1, # int
asymmetry_angle=
0, #10.0*numpy.pi/180., # radians
azimuthal_angle=0.0) # radians # int
import socket
if socket.getfqdn().find("esrf") >= 0:
dx = DabaxXraylib(
dabax_repository="http://ftp.esrf.fr/pub/scisoft/DabaxFiles/")
else:
dx = DabaxXraylib()
diffraction_setup_dabax = DiffractionSetupDabax(
geometry_type=BraggDiffraction(), # GeometryType object
crystal_name="Si", # string
thickness=1e-2, # meters
miller_h=1, # int
miller_k=1, # int
miller_l=1, # int
asymmetry_angle=
0, #10.0*numpy.pi/180., # radians
azimuthal_angle=0.0,
dabax=dx) # radians
energy = 8000.0 # eV
angle_deviation_min = -100e-6 # radians
angle_deviation_max = 100e-6 # radians
angle_deviation_points = 50
angle_step = (angle_deviation_max -
angle_deviation_min) / angle_deviation_points
#
# gets Bragg angle needed to create deviation's scan
#
bragg_angle_corrected = diffraction_setup.angleBraggCorrected(energy)
print("Bragg angle corrected for E=%f eV is %f deg" %
(energy, bragg_angle_corrected * 180.0 / numpy.pi))
DeltaE = energy * 1e-4
npoints = 100
energies = numpy.linspace(energy - 3 * DeltaE, energy + 3 * DeltaE,
npoints)
# Create a Diffraction object (the calculator)
diffraction = Diffraction()
diffraction_dabax = Diffraction()
# initialize arrays for storing outputs
intensityS = numpy.zeros(npoints)
intensityP = numpy.zeros(npoints)
intensityS_dabax = numpy.zeros(npoints)
intensityP_dabax = numpy.zeros(npoints)
t0 = time.time()
for ia in range(npoints):
# calculate the components of the unitary vector of the incident photon scan
# Note that diffraction plane is YZ
yy = numpy.cos(bragg_angle_corrected)
zz = -numpy.abs(numpy.sin(bragg_angle_corrected))
photon = Photon(energy_in_ev=energies[ia],
direction_vector=Vector(0.0, yy, zz))
# perform the calculation
coeffs = diffraction.calculateDiffractedComplexAmplitudes(
diffraction_setup, photon)
# store results
intensityS[ia] = coeffs['S'].intensity()
intensityP[ia] = coeffs['P'].intensity()
COOR = []
ENER = []
for ia in range(npoints):
# calculate the components of the unitary vector of the incident photon scan
# Note that diffraction plane is YZ
yy = numpy.cos(bragg_angle_corrected)
zz = -numpy.abs(numpy.sin(bragg_angle_corrected))
COOR.append([0.0, yy, zz])
ENER.append(energies[ia])
t1 = time.time()
Psi_0, Psi_H, Psi_H_bar = diffraction_setup_dabax.psiAll(ENER)
for ia in range(npoints):
# perform the calculation
incoming_photon = Photon(energy_in_ev=ENER[ia],
direction_vector=Vector(
COOR[ia][0], COOR[ia][1], COOR[ia][2]))
energy = ENER[ia]
# psi_0, psi_H, psi_H_bar = diffraction_setup_dabax.psiAll(energy)
psi_0, psi_H, psi_H_bar = Psi_0[ia], Psi_H[ia], Psi_H_bar[ia]
# Create PerfectCrystalDiffraction instance.
perfect_crystal = PerfectCrystalDiffraction(
geometry_type=diffraction_setup_dabax.geometryType(),
bragg_normal=diffraction_setup_dabax.normalBragg(),
surface_normal=diffraction_setup_dabax.normalSurface(),
bragg_angle=diffraction_setup_dabax.angleBragg(energy),
psi_0=psi_0,
psi_H=psi_H,
psi_H_bar=psi_H_bar,
thickness=diffraction_setup_dabax.thickness(),
d_spacing=diffraction_setup_dabax.dSpacing() * 1e-10)
complex_amplitudes = perfect_crystal.calculateDiffraction(
incoming_photon)
intensityS_dabax[ia] = complex_amplitudes['S'].intensity(
) # 0.0 # coeffs_dabax['S'].intensity()
intensityP_dabax[ia] = complex_amplitudes['P'].intensity(
) # 0.0 # coeffs_dabax['P'].intensity()
t2 = time.time()
# plot results
import matplotlib.pylab as plt
plt.plot(energies, intensityS)
plt.plot(energies, intensityP)
plt.plot(energies, intensityS_dabax)
plt.plot(energies, intensityP_dabax)
plt.xlabel("photon energy [eV]")
plt.ylabel("Reflectivity")
plt.legend([
"Sigma-polarization XRAYLIB", "Pi-polarization XRAYLIB",
"Sigma-polarization DABAX", "Pi-polarization DABAX"
])
plt.show()
print("Total time, Time per points XRAYLIB: ", t1 - t0,
(t1 - t0) / npoints)
print("Total time, Time per points DABAX: ", t2 - t1, (t2 - t1) / npoints)
def calculate_simple_diffraction_angular_scan_accelerated():
# Create a diffraction setup.
print("\nCreating a diffraction setup...")
diffraction_setup = DiffractionSetup(
geometry_type=BraggDiffraction(), # GeometryType object
crystal_name="Si", # string
thickness=1e-2, # meters
miller_h=1, # int
miller_k=1, # int
miller_l=1, # int
asymmetry_angle=
0, #10.0*numpy.pi/180., # radians
azimuthal_angle=0.0) # radians # int
diffraction_setup_dabax = DiffractionSetupDabax(
geometry_type=BraggDiffraction(), # GeometryType object
crystal_name="Si", # string
thickness=1e-2, # meters
miller_h=1, # int
miller_k=1, # int
miller_l=1, # int
asymmetry_angle=
0, #10.0*numpy.pi/180., # radians
azimuthal_angle=0.0,
dabax=DabaxXraylib()) # radians
energy = 8000.0 # eV
angle_deviation_min = -100e-6 # radians
angle_deviation_max = 100e-6 # radians
angle_deviation_points = 50
angle_step = (angle_deviation_max -
angle_deviation_min) / angle_deviation_points
#
# gets Bragg angle needed to create deviation's scan
#
bragg_angle = diffraction_setup.angleBragg(energy)
print("Bragg angle for E=%f eV is %f deg" %
(energy, bragg_angle * 180.0 / numpy.pi))
# Create a Diffraction object (the calculator)
diffraction = Diffraction()
diffraction_dabax = Diffraction()
# initialize arrays for storing outputs
deviations = numpy.zeros(angle_deviation_points)
intensityS = numpy.zeros(angle_deviation_points)
intensityP = numpy.zeros(angle_deviation_points)
intensityS_dabax = numpy.zeros(angle_deviation_points)
intensityP_dabax = numpy.zeros(angle_deviation_points)
for ia in range(angle_deviation_points):
deviation = angle_deviation_min + ia * angle_step
angle = deviation + bragg_angle
# calculate the components of the unitary vector of the incident photon scan
# Note that diffraction plane is YZ
yy = numpy.cos(angle)
zz = -numpy.abs(numpy.sin(angle))
photon = Photon(energy_in_ev=energy,
direction_vector=Vector(0.0, yy, zz))
# perform the calculation
coeffs = diffraction.calculateDiffractedComplexAmplitudes(
diffraction_setup, photon)
# store results
deviations[ia] = deviation
intensityS[ia] = coeffs['S'].intensity()
intensityP[ia] = coeffs['P'].intensity()
psi_0, psi_H, psi_H_bar = diffraction_setup_dabax.psiAll(energy)
for ia in range(angle_deviation_points):
deviation = angle_deviation_min + ia * angle_step
angle = deviation + bragg_angle
# calculate the components of the unitary vector of the incident photon scan
# Note that diffraction plane is YZ
yy = numpy.cos(angle)
zz = -numpy.abs(numpy.sin(angle))
photon = Photon(energy_in_ev=energy,
direction_vector=Vector(0.0, yy, zz))
# perform the calculation
# coeffs_dabax = diffraction_dabax.calculateDiffractedComplexAmplitudes(diffraction_setup_dabax, photon)
#
# # store results
# deviations[ia] = deviation
# intensityS_dabax[ia] = coeffs_dabax['S'].intensity()
# intensityP_dabax[ia] = coeffs_dabax['P'].intensity()
# Create PerfectCrystalDiffraction instance.
perfect_crystal = PerfectCrystalDiffraction(
geometry_type=diffraction_setup_dabax.geometryType(),
bragg_normal=diffraction_setup_dabax.normalBragg(),
surface_normal=diffraction_setup_dabax.normalSurface(),
bragg_angle=diffraction_setup_dabax.angleBragg(energy),
psi_0=psi_0,
psi_H=psi_H,
psi_H_bar=psi_H_bar,
thickness=diffraction_setup_dabax.thickness(),
d_spacing=diffraction_setup_dabax.dSpacing() * 1e-10)
complex_amplitudes = perfect_crystal.calculateDiffraction(photon)
deviations[ia] = deviation
intensityS_dabax[ia] = complex_amplitudes['S'].intensity(
) # 0.0 # coeffs_dabax['S'].intensity()
intensityP_dabax[ia] = complex_amplitudes['P'].intensity(
) # 0.0 # coeffs_dabax['P'].intensity()
# plot results
import matplotlib.pylab as plt
plt.plot(1e6 * deviations, intensityS)
plt.plot(1e6 * deviations, intensityP)
plt.plot(1e6 * deviations, intensityS_dabax)
plt.plot(1e6 * deviations, intensityP_dabax)
plt.xlabel("deviation angle [urad]")
plt.ylabel("Reflectivity")
plt.legend([
"Sigma-polarization XRAYLIB", "Pi-polarization XRAYLIB",
"Sigma-polarization DABAX", "Pi-polarization DABAX"
])
plt.show()
from crystalpy.diffraction.GeometryType import BraggDiffraction
from crystalpy.diffraction.DiffractionSetup import DiffractionSetup
from crystalpy.diffraction.DiffractionSetupDabax import DiffractionSetupDabax
from crystalpy.diffraction.DiffractionSetupShadowPreprocessor import DiffractionSetupShadowPreprocessor
from dabax.dabax_xraylib import DabaxXraylib
import numpy
a = DiffractionSetup(
geometry_type=BraggDiffraction,
crystal_name="Si",
thickness=1e-5,
miller_h=1,
miller_k=1,
miller_l=1,
asymmetry_angle=0.0,
azimuthal_angle=0.0,
)
import socket
if socket.getfqdn().find("esrf") >= 0:
dx = DabaxXraylib(
dabax_repository="http://ftp.esrf.fr/pub/scisoft/DabaxFiles/")
else:
dx = DabaxXraylib()
a2 = DiffractionSetupDabax(geometry_type=BraggDiffraction,
crystal_name="Si",
thickness=1e-5,
miller_h=1,
miller_k=1,
def calculate_with_crystalpy(
bragg_or_laue=0, #
diffracted_or_transmitted=0, #
crystal_name="Si", # string
thickness=1e-2, # meters
miller_h=1, # int
miller_k=1, # int
miller_l=1, # int
asymmetry_angle=0.0, # radians
energy=8000.0, # eV
angle_deviation_min=-100e-6, # radians
angle_deviation_max=100e-6, # radians
angle_deviation_points=500,
):
if bragg_or_laue == 0:
if diffracted_or_transmitted == 0:
geometry_type = BraggDiffraction()
elif diffracted_or_transmitted == 1:
geometry_type = BraggTransmission()
else:
raise Exception("Bad geometry type")
elif bragg_or_laue == 1:
if diffracted_or_transmitted == 0:
geometry_type = LaueDiffraction()
elif diffracted_or_transmitted == 1:
geometry_type = LaueTransmission()
else:
raise Exception("Bad geometry type")
else:
raise Exception("Bad geometry type")
# Create a diffraction setup.
print("\nCreating a diffraction setup...")
diffraction_setup = DiffractionSetup(geometry_type=geometry_type,
crystal_name=crystal_name,
thickness=thickness,
miller_h=miller_h,
miller_k=miller_k,
miller_l=miller_l,
asymmetry_angle=asymmetry_angle,
azimuthal_angle=0.0)
# energy = 8000.0 # eV
# angle_deviation_min = -100e-6 # radians
# angle_deviation_max = 100e-6 # radians
# angle_deviation_points = 500
angle_step = (angle_deviation_max -
angle_deviation_min) / angle_deviation_points
#
# gets Bragg angle needed to create deviation's scan
#
bragg_angle = diffraction_setup.angleBragg(energy)
print("Bragg angle for E=%f eV is %f deg" %
(energy, bragg_angle * 180.0 / numpy.pi))
# Create a Diffraction object (the calculator)
diffraction = Diffraction()
# initialize arrays for storing outputs
deviations = numpy.zeros(angle_deviation_points)
intensityS = numpy.zeros(angle_deviation_points)
intensityP = numpy.zeros(angle_deviation_points)
k_0_unitary = diffraction_setup.incomingPhotonDirection(energy, 0.0)
# photon_0 = Photon(energy_in_ev=energy,direction_vector=k_0_unitary)
# k_H_unitary = diffraction_setup._
# print(">>>>>>>>>>>>>>>>>>>>>>>>k_0: ",k_0_unitary._components )
# plot_crystal_sketch(k_0_unitary,k_0_unitary,)
for ia in range(angle_deviation_points):
deviation = angle_deviation_min + ia * angle_step
# angle = deviation + bragg_angle + asymmetry_angle
# # calculate the components of the unitary vector of the incident photon scan
# # Note that diffraction plane is YZ
# yy = numpy.cos(angle)
# zz = - numpy.abs(numpy.sin(angle))
# photon = Photon(energy_in_ev=energy,direction_vector=Vector(0.0,yy,zz))
k_unitary = diffraction_setup.incomingPhotonDirection(
energy, deviation)
# or equivalently
# k_0_unitary = diffraction_setup.incomingPhotonDirection(energy, 0.0)
# k_unitary = k_0_unitary.rotateAroundAxis( Vector(1.0,0.0,0.0), -deviation)
photon = Photon(energy_in_ev=energy, direction_vector=k_unitary)
# perform the calculation
coeffs = diffraction.calculateDiffractedComplexAmplitudes(
diffraction_setup, photon)
# store results
deviations[ia] = deviation
intensityS[ia] = coeffs['S'].intensity()
intensityP[ia] = coeffs['P'].intensity()
# print(">>>>>>>>>>>>>>>>>>>>>>>>k_0: ",k_0_unitary._components,k_0_unitary.getNormalizedVector()._components )
return deviations, intensityS, intensityP
def calculate_simple_diffraction():
# Create a diffraction setup.
thickness = 2e-6
print("\nCreating a diffraction setup...")
diffraction_setup_r = DiffractionSetup(geometry_type = BraggDiffraction(), # GeometryType object
crystal_name = "Si", # string
thickness = thickness, # meters
miller_h = 1, # int
miller_k = 1, # int
miller_l = 1, # int
asymmetry_angle = 0,#10.0*numpy.pi/180., # radians
azimuthal_angle = 0.0) # radians # int
diffraction_setup_t = DiffractionSetup(geometry_type = BraggTransmission(), # GeometryType object
crystal_name = "Si", # string
thickness = thickness, # meters
miller_h = 1, # int
miller_k = 1, # int
miller_l = 1, # int
asymmetry_angle = 0,#10.0*numpy.pi/180., # radians
azimuthal_angle = 0.0) # radians
diffraction_setup_r_half = DiffractionSetup(geometry_type = BraggDiffraction(), # GeometryType object
crystal_name = "Si", # string
thickness = thickness/2, # meters
miller_h = 1, # int
miller_k = 1, # int
miller_l = 1, # int
asymmetry_angle = 0,#10.0*numpy.pi/180., # radians
azimuthal_angle = 0.0) # radians # int
diffraction_setup_t_half = DiffractionSetup(geometry_type = BraggTransmission(), # GeometryType object
crystal_name = "Si", # string
thickness = thickness/2, # meters
miller_h = 1, # int
miller_k = 1, # int
miller_l = 1, # int
asymmetry_angle = 0,#10.0*numpy.pi/180., # radians
azimuthal_angle = 0.0) # radians
energy = 8000.0 # eV
angle_deviation_min = -300e-6 # radians
angle_deviation_max = 300e-6 # radians
angle_deviation_points = 500
wavelength = codata.h * codata.c / codata.e / energy
print(">>>>>>>>>>>>", wavelength)
angle_step = (angle_deviation_max-angle_deviation_min)/angle_deviation_points
#
# gets Bragg angle needed to create deviation's scan
#
bragg_angle = diffraction_setup_r.angleBragg(energy)
print("Bragg angle for E=%f eV is %f deg"%(energy,bragg_angle*180.0/numpy.pi))
# Create a Diffraction object (the calculator)
diffraction = Diffraction()
# initialize arrays for storing outputs
deviations = numpy.zeros(angle_deviation_points)
intensityS_r = numpy.zeros(angle_deviation_points)
intensityS_r_half = numpy.zeros(angle_deviation_points)
intensityS_t = numpy.zeros(angle_deviation_points)
intensityS_rr = numpy.zeros(angle_deviation_points)
intensityS_tt = numpy.zeros(angle_deviation_points)
r = numpy.zeros(angle_deviation_points, dtype=complex)
r2um = numpy.zeros(angle_deviation_points, dtype=complex)
t = numpy.zeros(angle_deviation_points, dtype=complex)
for ia in range(angle_deviation_points):
deviation = angle_deviation_min + ia * angle_step
angle = deviation + bragg_angle
# calculate the components of the unitary vector of the incident photon scan
# Note that diffraction plane is YZ
yy = numpy.cos(angle)
zz = - numpy.abs(numpy.sin(angle))
photon = Photon(energy_in_ev=energy,direction_vector=Vector(0.0,yy,zz))
# perform the calculation
coeffs_r = diffraction.calculateDiffractedComplexAmplitudes(diffraction_setup_r, photon)
coeffs_t = diffraction.calculateDiffractedComplexAmplitudes(diffraction_setup_t, photon)
coeffs_r_half = diffraction.calculateDiffractedComplexAmplitudes(diffraction_setup_r_half, photon)
coeffs_t_half = diffraction.calculateDiffractedComplexAmplitudes(diffraction_setup_t_half, photon)
# coeffs_rr = \
# coeffs_r_half['S'] * \
# (coeffs_t_half['S']**0 + \
# coeffs_t_half['S']**2 * ( \
# coeffs_r_half['S'] ** 0 + \
# coeffs_r_half['S'] ** 2 + \
# coeffs_r_half['S'] ** 4 + \
# coeffs_r_half['S'] ** 6 + \
# coeffs_r_half['S'] ** 8 + \
# coeffs_r_half['S'] ** 10 + \
# coeffs_r_half['S'] ** 12 + \
# coeffs_r_half['S'] ** 14 + \
# coeffs_r_half['S'] ** 16 + \
# coeffs_r_half['S'] ** 18 \
# ) )
# a = coeffs_r_half['S']
# b = coeffs_t_half['S']
r[ia] = coeffs_r_half['S'].complexAmplitude()
# t[ia] = coeffs_t_half['S'].complexAmplitude() #* numpy.exp(1j * 2 * numpy.pi / wavelength * (0.5 * thickness / numpy.sin(bragg_angle)) )
t[ia] = coeffs_t_half['S'].complexAmplitude() * numpy.exp(-1j * 2 * numpy.pi / wavelength * numpy.cos(bragg_angle) * deviation * (thickness/2) )
r2um[ia] = coeffs_r['S'].complexAmplitude()
# # sum = a**0
# # for i in range(2,400,2):
# # sum += a**i
# sum = a**0 / (a**0 - a**2)
# # coeffs_rr = a * (b**0 + b**2 * sum)
# one = a**0
# coeffs_rr = a * ( one + b**2 / (one - a**2))
# coeffs_tt = b**2 * sum
#
# intensityS_rr[ia] = coeffs_rr.intensity()
# intensityS_tt[ia] = coeffs_tt.intensity()
#
# # print(coeffs_r)
# # print(coeffs_r['S'].complexAmplitude())
#
# # store results
deviations[ia] = deviation
# intensityS_r[ia] = coeffs_r['S'].intensity()
# intensityS_r_half[ia] = coeffs_r_half['S'].intensity()
# intensityS_t[ia] = coeffs_t['S'].intensity()
# print(">>>>>>>>>>", coeffs_r['S'].complexAmplitude() , coeffs_rr.complexAmplitude() )
# plot results
print(r, r.shape)
from srxraylib.plot.gol import plot
# plot(1e6 * deviations, numpy.abs(r)**2,
# 1e6 * deviations, numpy.abs(t)**2,
# )
#
plot(1e6 * deviations, numpy.abs(r)**2,
1e6 * deviations, numpy.abs(r+r*t*t/(1-r*r))**2,
1e6 * deviations, numpy.abs(r2um) ** 2,
1e6 * deviations, numpy.abs(r2um) ** 2 - numpy.abs(r+r*t*t/(1-r*r))**2,
legend=['r','r2','r 2um','r 2 um - r2']
)
