def layer_chi(energy, p_height, p_width, p_pos, p_step, ffre_os, m_height,
m_width, m_pos):
en = numpy.linspace(
600, 750, 301
) #define energy-range to model (from 600eV to 750eV in 301 steps), array of energies
ffim = Lorentzian(p_height, p_width, p_pos, en) + p_step * (
numpy.arctan((en - p_pos) / p_width) + numpy.pi / 2
) #model imaginary part of the formfactor as Lorentzian peak plus edge jump. FOR EXPLANATION of the strange constructions: You can perform arithmetic operations with Parameter type object. The result is another Parameter object. Here this is used to not evaluate only the result of Lorentzian and not every parameter individually.
ffre = SampleRepresentation.KramersKronig(
en, ffim
) + ffre_os #real part of formfactor as Kramers Kronig transformation of imag part + ffre_offset
ff = ffre + ffim * 1j
ff_func = scipy.interpolate.interp1d(
en, ff
) #create function for formfactor as interpolation of the calculated values
chi_diag = ff_func(
energy
) * atom_density * re * 4 * numpy.pi * energy**2 / hbar_times_c**2
#the same for magnetic contribution
ffmag_im = Lorentzian(m_height, m_width, m_pos, en)
ffmag_re = SampleRepresentation.KramersKronig(en, ffmag_im)
ffmag = -1j * (
ffmag_re + ffmag_im * 1j
) #no idea why there is the factor -1j, Martin did it like this
ffmag_func = scipy.interpolate.interp1d(en, ffmag)
chi_mag = ffmag_func(
energy
) * atom_density * re * 4 * numpy.pi * energy**2 / hbar_times_c**2
return [
chi_diag, chi_diag, chi_diag, chi_mag
] #return array for chi meaning a tensor with chi_diag on the diagonals and chi_mag and -chi_mag on two off-diagonal places depending on the magnetization direction
"""
Model funtion for the formfactor tensor. Sum of ff_real and ff_imag on the diagonal elements.
"""
ff = ff_real(energy, coeffs,
base_energies) + 1j * ff_imag(energy, coeffs, base_energies)
return numpy.array([ff, 0, 0, 0, ff, 0, 0, 0, ff])
#generate parameters as coefficients
pp = Parameters.ParameterPool()
suffix = "ff_coeff_"
coeff_pars_list = [
pp.newParameter(suffix + str(i)) for i in range(len(base_energies))
]
#generate parametrized Function
ff_tensor_parfunc = Parameters.ParametrizedFunction(ff_tensor,
*coeff_pars_list)
#generate Formfactor object with parametrized funtion
FF_Mn_fit = SampleRepresentation.FFfromFitableModel(ff_tensor_parfunc,
min(base_energies),
max(base_energies))
#generate parameter values for coeffients
fitpararray = [
numpy.exp(-(energy - 550)**2 / (2 * 5)**2) for energy in base_energies
]
FF_Mn_fit.plotFF(fitpararray)
mol_mass_Mn + 3 * mol_mass_O)
#density_MnO2=mdensity_MnO2/(mol_mass_Mn+2*mol_mass_O)
density_C = mdensity_C / mol_mass_C
start, l, u = pp.getStartLowerUpper(
) #read start values etc. to check for errors at beginnning of script
pp.writeToFile(
"parameters.txt"
) #write parameter file to get nice layout after changing values
#####################################################################################################################################
#Creation of Model
# set up heterostructure (with 5 layers)
print("... set up heterostructure")
hs = SampleRepresentation.Heterostructure(5)
###set up formfactors
print("... set up formfactors")
#at first create linereader functions to read the files
commentsymbol = '#'
def absorption_linereader(line):
line = (line.split(commentsymbol)
)[0] #ignore everything behind the commentsymbol #
if not line.isspace() and line: #ignore empty lines
linearray = line.split()
linearray = [float(item) for item in linearray]
return (linearray[0], linearray[2], linearray[4], linearray[6])
##This one here is important if you want to parallelize python in windows.
##This code will only be executed in the mother process.
if __name__ == '__main__':
#####################################################################################
#create a pool which handles all fitparameters (and connect it to a Parameter File)
pp = Parameters.ParameterPool("parameters.txt")
#####################################################################################
#### set up the MODEL for the sample
# it should consist of three layers: substrate, layer and cap
# substrate has a fixed susceptibility, the layers suscept is energy-dependent and fitted and cap has a constant but fitted suscept. For further paramters see below.
#create a Heterostructur object as sample representation, with 3 layers
hs = SampleRepresentation.Heterostructure(3)
##substrate
chi_substrate = Parameters.Parameter(
-0.0005 + 0.0005j
) #set fixed,isotropic and constant chi as instance of the Parameter class
substrate_roughness = pp.newParameter(
"substrate_roughness"
) #set substrate roughness as fittable parameter. Therefor create an instance of the Fitparameter class inside the ParameterPool pp
substrate = SampleRepresentation.LayerObject(
chitensor=[chi_substrate],
sigma=substrate_roughness) #create the layer object
hs.setLayer(0, substrate) #add layer to Heterostructure
##layer
layer_roughness = pp.newParameter(
import types
from PyXMRTool import Experiment
from PyXMRTool import Parameters
from PyXMRTool import SampleRepresentation
from PyXMRTool import Fitters
if __name__ == '__main__':
pp = Parameters.ParameterPool("partest.txt")
#set up layer system
#l=SampleRepresentation.LayerObject([pp.newParameter("chi_xx"),pp.newParameter("chi_xy"),pp.newParameter("chi_xz"),pp.newParameter("chi_yx"),pp.newParameter("chi_yy"),pp.newParameter("chi_yz"),pp.newParameter("chi_zx"),pp.newParameter("chi_zy"),pp.newParameter("chi_zz")],pp.newParameter("d"),Parameters.Parameter(0))
l = SampleRepresentation.LayerObject([
pp.newParameter("chi_xx"),
pp.newParameter("chi_yy"),
pp.newParameter("chi_zz")
], pp.newParameter("d"), Parameters.Parameter(0))
ar = [33, 0.0094, -0.444]
ar += list(range(36))
hs = SampleRepresentation.Heterostructure(
9, [0, 1, 2, [10, [3, 4, 5, 6]], 7, 8])
for i in range(7):
hs.setLayer(
i,
SampleRepresentation.LayerObject([pp.newParameter("chi" + str(i))],
pp.newParameter("d" + str(i))))
hs.setLayer(7, l)
import Pythonreflectivity
from PyXMRTool import SampleRepresentation
from PyXMRTool import Parameters
pp=Parameters.ParameterPool("partest-samplerep.txt")
#one LayerObject
l=SampleRepresentation.LayerObject([pp.newParameter("chi_xx"),pp.newParameter("chi_xy"),pp.newParameter("chi_xz"),pp.newParameter("chi_yx"),pp.newParameter("chi_yy"),pp.newParameter("chi_yz"),pp.newParameter("chi_zx"),pp.newParameter("chi_zy"),pp.newParameter("chi_zz")],pp.newParameter("d"),Parameters.Parameter(0))
print("One Layer")
ar,lower,upper=pp.getStartLowerUpper()
print("Sigma: " +str(l.getSigma(ar)))
print("D: "+str(l.getD(ar)))
print("Chi: "+str(l.getChi(ar,456)))
print("MagDir: " + l.getMagDir(ar))
transition_width=pp.newParameter("transition_width") #width of transition (sigma in error function erf(z/sqrt(2)/sigma)
decay_depth=pp.newParameter("decay_depth") #position at which the O density starts to decay, measured in nm from top
decay_rel_gradient=pp.newParameter("decay_rel_gradient") #gradient of the decay (defined as positiv number)
#############################
#some calculations
unit_cells_per_volume=1.0e-6/(0.52e-9)**3 #in mol/cm^3
density_O=Parameters.Parameter(unit_cells_per_volume/2.0) #number density of oxigen within SrO (in mol/cm^3)
density_Sr=Parameters.Parameter(unit_cells_per_volume/2.0) #number density of strontium within SrO (in mol/cm^3)
#calculate number of necessary transition zone layers and set up heterostructure
number_of_trans_layers=int(math.ceil(float(transzone_thickness)/lattice_const))
hs=SampleRepresentation.Heterostructure(1+number_of_trans_layers)
#create some formfactor object and register atoms
FF_Co=SampleRepresentation.FFfromFile("Co.F",SampleRepresentation.FFfromFile.createLinereader(complex_numbers=False))
FF_Sr=SampleRepresentation.FFfromFile("Sr.F",SampleRepresentation.FFfromFile.createLinereader(complex_numbers=False))
#FF_Ya=SampleRepresentation.FFfromScaledAbsorption('', E1=250, E2=400, E3=500, scaling_factor=pp.newParameter("Ya_scaling"), absorption_filename="C_imag.F",energyshift=pp.newParameter("Ya_eneryshift"),tabulated_filename="C_tabul.F",tabulated_linereaderfunction=SampleRepresentation.FFfromScaledAbsorption.createTabulatedLinereader(complex_numbers=False))
FF_Ya=SampleRepresentation.FFfromScaledAbsorption('C', E1=250, E2=400, E3=500, scaling_factor=pp.newParameter("Ya_scaling"), absorption_filename="C_imag.F",energyshift=pp.newParameter("Ya_eneryshift"),)
SampleRepresentation.AtomLayerObject.registerAtom("Co",FF_Co)
SampleRepresentation.AtomLayerObject.registerAtom("Sr",FF_Sr)
SampleRepresentation.AtomLayerObject.registerAtom("Ya",FF_Ya)
#create bottom layer and add it to heterostructure
bottom_layer=SampleRepresentation.AtomLayerObject({"Ya":density_O,"Sr":density_Sr},total_thickness-transzone_thickness)
return None
def ff_file_linereader(line):
line=(line.split(commentsymbol))[0] #ignore everything behind the commentsymbol #
if not line.isspace() and line: #ignore empty lines
linearray=line.split()
linearray=[float(item) for item in linearray]
return (linearray[0], -linearray[1]+1j*linearray[2], 0,0,0, -linearray[3]+1j*linearray[4], 0,0,0, -linearray[5]+1j*linearray[6]) #convert to the PyXMRTool sign convention. See :doc:`/definitions/formfactors`
else:
return None
#now create formfactor objects / register them at AtomLayerObject
f2=lambda energy,absorbtion, a, b, c: absorbtion*a+b+c*energy #function for imaginary part of formfactor from absorption measurement, which will be fitted to the off-resonant tabulated values
#usually f2 should rather be absorption*energy*a+b+c*energy. But what I used here for "absorption" has already been fit with this procedure and should not be scaled by energy again
Mn_FF=SampleRepresentation.FFfromScaledAbsorption('Mn', E1=600,E2=700,E3=710,scaling_factor=Parameters.Parameter(1), absorption_filename="data_for_comparison_from_Florian/Mn.aniso2", absorption_linereaderfunction=absorption_linereader, autofitfunction=f2, autofitrange=20)
#Mn_FF=SampleRepresentation.FFfromFile("data_for_comparison_from_Florian/Mn.aniso2", ff_file_linereader)
#print "... plot Mn formfactor to let user check"
#Mn_FF.plotFF(start)
SampleRepresentation.AtomLayerObject.registerAtom("Mn_XAS",Mn_FF)
### build layers from bottom
print("... build layers")
layer_LSMO = SampleRepresentation.AtomLayerObject({"La":0.7*density_LSMO, "Sr":0.3*density_LSMO, "Mn_XAS":density_LSMO, "O": 3* density_LSMO})
import numpy
import Pythonreflectivity
from PyXMRTool import Experiment
from PyXMRTool import Parameters
from PyXMRTool import SampleRepresentation
pp = Parameters.ParameterPool("partest_Experiment.txt")
#pp=Parameters.ParameterPool()
#set up layer system
#l=SampleRepresentation.LayerObject([pp.newParameter("chi_xx"),pp.newParameter("chi_xy"),pp.newParameter("chi_xz"),pp.newParameter("chi_yx"),pp.newParameter("chi_yy"),pp.newParameter("chi_yz"),pp.newParameter("chi_zx"),pp.newParameter("chi_zy"),pp.newParameter("chi_zz")],pp.newParameter("d"),Parameters.Parameter(0))
l = SampleRepresentation.LayerObject([
pp.newParameter("chi_xx"),
pp.newParameter("chi_yy"),
pp.newParameter("chi_zz")
], pp.newParameter("d"), Parameters.Parameter(0))
#ar=[33,0.0094,-0.444]
#ar+=range(39) #produce some arbitrary values
ar, low, up = pp.getStartLowerUpper()
hs = SampleRepresentation.Heterostructure(13)
for i in range(7):
hs.setLayer(
i,
SampleRepresentation.LayerObject([pp.newParameter("chi" + str(i))],
pp.newParameter("d" + str(i))))
hs.setLayer(7, l)
suscept_SrRuO3 = pp.newParameter("suscept_SrRuO3")
suscept_LSMO = pp.newParameter("suscept_LSMO")
suscept_MnO2 = pp.newParameter("suscept_MnO2")
suscept_C = pp.newParameter(
"suscept_C") #number density of C atoms in mol/cm^3
#pp.writeToFile("simplified-parameters.txt") #write parameter file to get nice layout after changing values
start, l, u = pp.getStartLowerUpper(
) #read start values etc. to check for errors at beginnning of script
#####################################################################################################################################
#Creation of Model
# set up heterostructure (with 6 layers)
print("... set up heterostructure")
hs = SampleRepresentation.Heterostructure(6)
### build layers from bottom
print("... build layers")
substrate_layer = SampleRepresentation.LayerObject(
[suscept_SrTiO3], d=None, sigma=pp.newParameter("substrate_roughness"))
layer_SrRuO3 = SampleRepresentation.LayerObject(
[suscept_SrRuO3],
d=pp.newParameter("SrRuO3_thickness"),
sigma=pp.newParameter("SrRuO3_roughness"))
layer_LSMO = SampleRepresentation.LayerObject(
[suscept_LSMO],
d=pp.newParameter("LSMO_thickness"),
#############################
pp.writeToFile("fitparameters.txt")
#some calculations
unit_cells_per_volume = 1.0e-6 / (0.52e-9)**3 #in mol/cm^3
density_O = Parameters.Parameter(
unit_cells_per_volume /
2.0) #number density of oxigen within SrO (in mol/cm^3)
density_Sr = Parameters.Parameter(
unit_cells_per_volume /
2.0) #number density of strontium within SrO (in mol/cm^3)
#calculate number of necessary transition zone layers and set up heterostructure
number_of_trans_layers = int(
math.ceil(float(transzone_thickness) / lattice_const))
hs = SampleRepresentation.Heterostructure(1 + number_of_trans_layers)
#create some formfactor object and register atoms
FF_Co = SampleRepresentation.FFfromFile(
"Co.F",
SampleRepresentation.FFfromFile.createLinereader(complex_numbers=False))
FF_Sr = SampleRepresentation.FFfromFile(
"Sr.F",
SampleRepresentation.FFfromFile.createLinereader(complex_numbers=False))
FF_O = SampleRepresentation.FFfromFile(
"O.F",
SampleRepresentation.FFfromFile.createLinereader(complex_numbers=False))
SampleRepresentation.AtomLayerObject.registerAtom("Co", FF_Co)
SampleRepresentation.AtomLayerObject.registerAtom("Sr", FF_Sr)
SampleRepresentation.AtomLayerObject.registerAtom("O", FF_O)