def xoppy_calc_wigg(FIELD=0,NPERIODS=12,ULAMBDA=0.125,K=14.0,ENERGY=6.04,PHOT_ENERGY_MIN=100.0,\
PHOT_ENERGY_MAX=100100.0,NPOINTS=100,NTRAJPOINTS=101,CURRENT=200.0,FILE="?"):
print("Inside xoppy_calc_wigg. ")
outFileTraj = "xwiggler_traj.spec"
outFile = "xwiggler.spec"
if FIELD == 0:
t0,p = srfunc.wiggler_trajectory(b_from=0, nPer=NPERIODS, nTrajPoints=NTRAJPOINTS, \
ener_gev=ENERGY, per=ULAMBDA, kValue=K, \
trajFile=outFileTraj)
if FIELD == 1:
# magnetic field from B(s) map
t0,p = srfunc.wiggler_trajectory(b_from=1, nPer=NPERIODS, nTrajPoints=NTRAJPOINTS, \
ener_gev=ENERGY, inData=FILE, trajFile=outFileTraj)
if FIELD == 2:
# magnetic field from harmonics
# hh = srfunc.wiggler_harmonics(b_t,Nh=41,fileOutH="tmp.h")
t0,p = srfunc.wiggler_trajectory(b_from=2, nPer=NPERIODS, nTrajPoints=NTRAJPOINTS, \
ener_gev=ENERGY, per=ULAMBDA, inData="", trajFile=outFileTraj)
print(p)
#
# now spectra
#
e, f0, p0 = srfunc.wiggler_spectrum(t0, enerMin=PHOT_ENERGY_MIN, enerMax=PHOT_ENERGY_MAX, nPoints=NPOINTS, \
electronCurrent=CURRENT*1e-3, outFile=outFile, elliptical=False)
try:
cumulated_power = p0.cumsum() * numpy.abs(e[0] - e[1])
except:
cumulated_power = 0.0
print("\nPower from integral of spectrum (sum rule): %8.3f W" % (cumulated_power[-1]))
return e, f0, p0 , cumulated_power
def xoppy_calc_xwiggler(FIELD=0,NPERIODS=12,ULAMBDA=0.125,K=14.0,ENERGY=6.04,PHOT_ENERGY_MIN=100.0,\
PHOT_ENERGY_MAX=100100.0,NPOINTS=100,NTRAJPOINTS=101,CURRENT=200.0,FILE="?"):
print("Inside xoppy_calc_xwiggler. ")
outFileTraj = "xwiggler_traj.spec"
outFile = "xwiggler.spec"
if FIELD == 0:
t0,p = srfunc.wiggler_trajectory(b_from=0, nPer=NPERIODS, nTrajPoints=NTRAJPOINTS, \
ener_gev=ENERGY, per=ULAMBDA, kValue=K, \
trajFile=outFileTraj)
if FIELD == 1:
# magnetic field from B(s) map
t0,p = srfunc.wiggler_trajectory(b_from=1, nPer=NPERIODS, nTrajPoints=NTRAJPOINTS, \
ener_gev=ENERGY, inData=FILE, trajFile=outFileTraj)
if FIELD == 2:
# magnetic field from harmonics
# hh = srfunc.wiggler_harmonics(b_t,Nh=41,fileOutH="tmp.h")
t0,p = srfunc.wiggler_trajectory(b_from=2, nPer=NPERIODS, nTrajPoints=NTRAJPOINTS, \
ener_gev=ENERGY, per=ULAMBDA, inData="", trajFile=outFileTraj)
print(p)
#
# now spectra
#
e, f0, p0 = srfunc.wiggler_spectrum(t0, enerMin=PHOT_ENERGY_MIN, enerMax=PHOT_ENERGY_MAX, nPoints=NPOINTS, \
electronCurrent=CURRENT*1e-3, outFile=outFile, elliptical=False)
print("\nPower from integral of spectrum: %8.3f W" %
(f0.sum() * 1e3 * codata.e * (e[1] - e[0])))
return e, f0, p0
def wiggler_preprocessor(ener_gev=6.0,e_min=5000.0,e_max=5005.0,file_field="",plot_trajectories=0,
shift_x_flag=0,shift_x_value=0.0,shift_betax_flag=0,shift_betax_value=0.0):
(traj, pars) = srfunc.wiggler_trajectory(b_from=1,
inData=file_field,
nPer=1,
nTrajPoints=501,
ener_gev=ener_gev,
per=None,
kValue=None,
trajFile="tmp.traj",
shift_x_flag=shift_x_flag,
shift_x_value=shift_x_value,
shift_betax_flag=shift_betax_flag,
shift_betax_value=shift_betax_value)
data = numpy.loadtxt("tmp.traj",skiprows=15)
fig = plt.figure(1)
fig.add_subplot(221)
plt.plot(data[:,1],data[:,7])
plt.title("Magnetic Field "+file_field)
plt.xlabel("Y [m]")
plt.ylabel("B [T]")
fig.add_subplot(222)
plt.plot(data[:,1],data[:,0])
plt.title("Electron trajectory")
plt.xlabel("Y [m]")
plt.ylabel("X [m]")
fig.add_subplot(223)
plt.plot(data[:,1],data[:,3])
plt.title("Electron velocity")
plt.xlabel("Y [m]")
plt.ylabel("betaX")
fig.add_subplot(224)
plt.plot(data[:,1],data[:,6])
plt.title("Electron curvature")
plt.xlabel("Y [m]")
plt.ylabel("curvature [m^-1]")
if plot_trajectories:
plt.show()
fig.savefig('sw_'+file_field+'.png')
plt.close(fig)
srfunc.wiggler_cdf(traj,
enerMin=e_min,
enerMax=e_max,
enerPoints=1001,
outFile="xshwig.sha",
elliptical=False)
def run_python_preprocessors(e_min=1000.0,e_max=10000.0 ):
import srxraylib.sources.srfunc as srfunc
wigFile = "xshwig.sha"
inData = ""
nPer = 5 # 50
nTrajPoints = 501
ener_gev = 6.04
per = 0.040
kValue = 7.85
trajFile = "tmp.traj"
shift_x_flag = 0
shift_x_value = 0.0
shift_betax_flag = 0
shift_betax_value = 0.0
# "Calculate electron trajectory"
(traj, pars) = srfunc.wiggler_trajectory(b_from=0,
inData=inData,
nPer=nPer,
nTrajPoints=nTrajPoints,
ener_gev=ener_gev,
per=per,
kValue=kValue,
trajFile=trajFile,
shift_x_flag=shift_x_flag,
shift_x_value=shift_x_value,
shift_betax_flag=shift_betax_flag,
shift_betax_value=shift_betax_value)
# traj[0,ii] = yx[i]
# traj[1,ii] = yy[i]+j * per - start_len
# traj[2,ii] = 0.0
# traj[3,ii] = betax[i]
# traj[4,ii] = betay[i]
# traj[5,ii] = 0.0
# traj[6,ii] = curv[i]
# traj[7,ii] = bz[i]
# plot(traj[1,:],traj[0,:])
# print(pars)
#
# calculate cdf and write file for Shadow/Source
#
srfunc.wiggler_cdf(traj,
enerMin=e_min,
enerMax=e_max,
enerPoints=1001,
outFile=wigFile,
elliptical=False)
print("CDF written to file %s \n"%(str(wigFile)))
def calc_wiggler_spectrum(ener_gev=6.0,e_min=100.0,e_max=100000.00,file_field="",output_file=""):
(traj, pars) = srfunc.wiggler_trajectory(b_from=1,
inData=file_field,
nPer=1,
nTrajPoints=501,
ener_gev=ener_gev,
per=None,
kValue=None,
trajFile="tmp.traj")
x,y = srfunc.wiggler_spectrum(traj, enerMin=e_min, enerMax=e_max,nPoints=500, \
electronCurrent=0.2, outFile="", elliptical=False)
#
tmp = (numpy.vstack((x,y)))
print(tmp.shape)
numpy.savetxt(output_file,tmp.T)
xx = numpy.array((5000.,10000,20000,40000,80000))
return numpy.interp(xx,x,y)
def runShadowSource(self):
#self.error(self.error_id)
self.setStatusMessage("")
self.progressBarInit()
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
if self.trace_shadow:
grabber = TTYGrabber()
grabber.start()
try:
self.checkFields()
###########################################
# TODO: TO BE ADDED JUST IN CASE OF BROKEN
# ENVIRONMENT: MUST BE FOUND A PROPER WAY
# TO TEST SHADOW
self.fixWeirdShadowBug()
###########################################
wigFile = bytes(congruence.checkFileName("xshwig.sha"), 'utf-8')
if self.type_combo == 0:
inData = ""
elif self.type_combo == 1:
inData = congruence.checkUrl(self.file_with_b_vs_y)
elif self.type_combo == 2:
inData = congruence.checkUrl(self.file_with_harmonics)
self.progressBarSet(10)
#self.information(0, "Calculate electron trajectory")
self.shadow_output.setText("")
self.setStatusMessage("Calculate electron trajectory")
(traj, pars) = srfunc.wiggler_trajectory(b_from=self.type_combo,
inData=inData,
nPer=self.number_of_periods,
nTrajPoints=501,
ener_gev=self.energy,
per=self.id_period,
kValue=self.k_value,
trajFile=congruence.checkFileName("tmp.traj"),
shift_x_flag=self.shift_x_flag,
shift_x_value=self.shift_x_value,
shift_betax_flag=self.shift_betax_flag,
shift_betax_value=self.shift_betax_value)
#
# calculate cdf and write file for Shadow/Source
#
self.progressBarSet(20)
#self.information(0, "Calculate cdf and write file for Shadow/Source")
self.setStatusMessage("Calculate cdf and write file for Shadow/Source")
srfunc.wiggler_cdf(traj,
enerMin=self.e_min,
enerMax=self.e_max,
enerPoints=1001,
outFile=wigFile,
elliptical=False)
#self.information(0, "CDF written to file %s \n"%(wigFile))
self.setStatusMessage("CDF written to file %s \n"%(str(wigFile)))
self.progressBarSet(40)
#self.information(0, "Set the wiggler parameters in the wiggler container")
self.setStatusMessage("Set the wiggler parameters in the wiggler container")
shadow_src = ShadowSource.create_wiggler_src()
self.populateFields(shadow_src)
shadow_src.src.FILE_TRAJ = wigFile
self.progressBarSet(50)
self.setStatusMessage("Running Shadow/Source")
write_begin_file, write_start_file, write_end_file = self.get_write_file_options()
beam_out = ShadowBeam.traceFromSource(shadow_src,
write_begin_file=write_begin_file,
write_start_file=write_start_file,
write_end_file=write_end_file)
if self.trace_shadow:
grabber.stop()
for row in grabber.ttyData:
self.writeStdOut(row)
#self.information(0, "Plotting Results")
self.setStatusMessage("Plotting Results")
self.progressBarSet(80)
self.plot_results(beam_out, progressBarValue=80)
self.setStatusMessage("Plotting Wiggler Data")
self.plot_wiggler_results()
#self.information()
self.setStatusMessage("")
self.send("Beam", beam_out)
#
# create python script for the preprocessors and display in the standard output
#
dict_parameters = {
"b_from" : self.type_combo,
"inData" : inData,
"nPer" : self.number_of_periods,
"nTrajPoints" : 501,
"ener_gev" : self.energy,
"per" : self.id_period,
"kValue" : self.k_value,
"trajFile" : "tmp.traj",
"shift_x_flag" : self.shift_x_flag,
"shift_x_value" : self.shift_x_value,
"shift_betax_flag" : self.shift_betax_flag,
"shift_betax_value" : self.shift_betax_value,
"enerMin" : self.e_min,
"enerMax" : self.e_max,
"enerPoints" : 1001,
"outFile" : wigFile,
"elliptical" : False,
"electron_current_mA" : self.electron_current,
}
# write python script in standard output
print(self.script_template().format_map(dict_parameters))
except Exception as exception:
QtWidgets.QMessageBox.critical(self, "Error",
str(exception),
QtWidgets.QMessageBox.Ok)
#self.error_id = self.error_id + 1
#self.error(self.error_id, "Exception occurred: " + str(exception))
self.progressBarFinished()
def runShadowSource(self):
#self.error(self.error_id)
self.setStatusMessage("")
self.progressBarInit()
try:
self.checkFields()
###########################################
# TODO: TO BE ADDED JUST IN CASE OF BROKEN
# ENVIRONMENT: MUST BE FOUND A PROPER WAY
# TO TEST SHADOW
self.fixWeirdShadowBug()
###########################################
wigFile = bytes(congruence.checkFileName("xshwig.sha"), 'utf-8')
if self.type_combo == 0:
inData = ""
elif self.type_combo == 1:
inData = congruence.checkFileName(self.file_with_b_vs_y)
elif self.type_combo == 2:
inData = congruence.checkFileName(self.file_with_harmonics)
self.progressBarSet(10)
#self.information(0, "Calculate electron trajectory")
self.setStatusMessage("Calculate electron trajectory")
(traj, pars) = srfunc.wiggler_trajectory(b_from=self.type_combo,
inData=inData,
nPer=self.number_of_periods,
nTrajPoints=501,
ener_gev=self.energy,
per=self.id_period,
kValue=self.k_value,
trajFile=congruence.checkFileName("tmp.traj"),
shift_x_flag=self.shift_x_flag,
shift_x_value=self.shift_x_value,
shift_betax_flag=self.shift_betax_flag,
shift_betax_value=self.shift_betax_value)
#
# calculate cdf and write file for Shadow/Source
#
self.progressBarSet(20)
#self.information(0, "Calculate cdf and write file for Shadow/Source")
self.setStatusMessage("Calculate cdf and write file for Shadow/Source")
srfunc.wiggler_cdf(traj,
enerMin=self.e_min,
enerMax=self.e_max,
enerPoints=1001,
outFile=wigFile,
elliptical=False)
#self.information(0, "CDF written to file %s \n"%(wigFile))
self.setStatusMessage("CDF written to file %s \n"%(str(wigFile)))
self.progressBarSet(40)
#self.information(0, "Set the wiggler parameters in the wiggler container")
self.setStatusMessage("Set the wiggler parameters in the wiggler container")
shadow_src = ShadowSource.create_wiggler_src()
self.populateFields(shadow_src)
shadow_src.src.FILE_TRAJ = wigFile
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
if self.trace_shadow:
grabber = TTYGrabber()
grabber.start()
self.progressBarSet(50)
self.setStatusMessage("Running Shadow/Source")
write_begin_file, write_start_file, write_end_file = self.get_write_file_options()
beam_out = ShadowBeam.traceFromSource(shadow_src,
write_begin_file=write_begin_file,
write_start_file=write_start_file,
write_end_file=write_end_file)
if self.trace_shadow:
grabber.stop()
for row in grabber.ttyData:
self.writeStdOut(row)
#self.information(0, "Plotting Results")
self.setStatusMessage("Plotting Results")
self.progressBarSet(80)
self.plot_results(beam_out, 80)
self.setStatusMessage("Plotting Wiggler Data")
self.plot_wiggler_results()
#self.information()
self.setStatusMessage("")
self.send("Beam", beam_out)
except Exception as exception:
QtGui.QMessageBox.critical(self, "Error",
str(exception),
QtGui.QMessageBox.Ok)
#self.error_id = self.error_id + 1
#self.error(self.error_id, "Exception occurred: " + str(exception))
self.progressBarFinished()
def run_source_wiggler():
from srxraylib.sources import srfunc
(traj,
pars) = srfunc.wiggler_trajectory(b_from=1,
inData="/home/manuel/Oasys/BM_only7.b",
nPer=1,
nTrajPoints=501,
ener_gev=2.0,
per=0.01,
kValue=1.0,
trajFile="tmp.traj",
shift_x_flag=4,
shift_x_value=0.042,
shift_betax_flag=4,
shift_betax_value=0.035)
#
# calculate cdf and write file for Shadow/Source
#
srfunc.wiggler_cdf(traj,
enerMin=1000.0,
enerMax=1000.1,
enerPoints=1001,
outFile=b'/home/manuel/Oasys/xshwig.sha',
elliptical=False)
calculate_spectrum = False
if calculate_spectrum:
e, f, w = srfunc.wiggler_spectrum(traj,
enerMin=1000.0,
enerMax=1000.1,
nPoints=500,
electronCurrent=500.0 * 1e-3,
outFile="spectrum.dat",
elliptical=False)
from srxraylib.plot.gol import plot
plot(e,
f,
xlog=False,
ylog=False,
show=False,
xtitle="Photon energy [eV]",
ytitle="Flux [Photons/s/0.1%bw]",
title="Flux")
plot(e,
w,
xlog=False,
ylog=False,
show=True,
xtitle="Photon energy [eV]",
ytitle="Spectral Power [E/eV]",
title="Spectral Power")
#
# end script
#
# write (1) or not (0) SHADOW files start.xx end.xx star.xx
iwrite = 0
#
# initialize shadow3 source (oe0) and beam
#
beam = Shadow.Beam()
oe0 = Shadow.Source()
#
# Define variables. See meaning of variables in:
# https://raw.githubusercontent.com/srio/shadow3/master/docs/source.nml
# https://raw.githubusercontent.com/srio/shadow3/master/docs/oe.nml
#
oe0.BENER = 2.0
oe0.CONV_FACT = 1.0
oe0.EPSI_X = 70e-12
oe0.EPSI_Z = 70e-12
oe0.FDISTR = 0
oe0.FILE_TRAJ = b'/home/manuel/Oasys/xshwig.sha'
oe0.FSOUR = 0
oe0.FSOURCE_DEPTH = 0
oe0.F_COLOR = 0
oe0.F_PHOT = 0
oe0.F_WIGGLER = 1
oe0.HDIV1 = 1.0
oe0.HDIV2 = 1.0
oe0.IDO_VX = 0
oe0.IDO_VZ = 0
oe0.IDO_X_S = 0
oe0.IDO_Y_S = 0
oe0.IDO_Z_S = 0
oe0.ISTAR1 = 5676561
oe0.NCOL = 0
oe0.NPOINT = 50000
oe0.N_COLOR = 0
oe0.PH1 = 1000.0
oe0.PH2 = 1000.1
oe0.POL_DEG = 0.0
oe0.SIGMAX = 7e-06
oe0.SIGMAY = 0.0
oe0.SIGMAZ = 1e-05
oe0.VDIV1 = 1.0
oe0.VDIV2 = 1.0
oe0.WXSOU = 0.0
oe0.WYSOU = 0.0
oe0.WZSOU = 0.0
#Run SHADOW to create the source
if iwrite:
oe0.write("start.00")
beam.genSource(oe0)
if iwrite:
oe0.write("end.00")
beam.write("begin.dat")
return beam
def xoppy_calc_wiggler_radiation(
ELECTRONENERGY=3.0,
ELECTRONCURRENT=0.1,
PERIODID=0.120,
NPERIODS=37.0,
KV=22.416,
DISTANCE=30.0,
HSLITPOINTS=500,
VSLITPOINTS=500,
PHOTONENERGYMIN=100.0,
PHOTONENERGYMAX=100100.0,
PHOTONENERGYPOINTS=101,
NTRAJPOINTS=1001,
FIELD=0,
FILE="/Users/srio/Oasys/Bsin.txt",
POLARIZATION=0, # 0=total, 1=parallel (s), 2=perpendicular (p)
SHIFT_X_FLAG=0,
SHIFT_X_VALUE=0.0,
SHIFT_BETAX_FLAG=0,
SHIFT_BETAX_VALUE=0.0,
CONVOLUTION=1,
PASSEPARTOUT=3.0,
h5_file="wiggler_radiation.h5",
h5_entry_name="XOPPY_RADIATION",
h5_initialize=True,
h5_parameters=None,
do_plot=False,
):
# calculate wiggler trajectory
if FIELD == 0:
(traj, pars) = srfunc.wiggler_trajectory(
b_from=0,
inData="",
nPer=int(NPERIODS), #37,
nTrajPoints=NTRAJPOINTS,
ener_gev=ELECTRONENERGY,
per=PERIODID,
kValue=KV,
trajFile="",
shift_x_flag=SHIFT_X_FLAG,
shift_x_value=SHIFT_X_VALUE,
shift_betax_flag=SHIFT_BETAX_FLAG,
shift_betax_value=SHIFT_BETAX_VALUE)
if FIELD == 1:
# magnetic field from B(s) map
(traj,
pars) = srfunc.wiggler_trajectory(b_from=1,
nPer=1,
nTrajPoints=NTRAJPOINTS,
ener_gev=ELECTRONENERGY,
inData=FILE,
trajFile="",
shift_x_flag=SHIFT_X_FLAG,
shift_x_value=SHIFT_X_VALUE,
shift_betax_flag=SHIFT_BETAX_FLAG,
shift_betax_value=SHIFT_BETAX_FLAG)
if FIELD == 2:
raise ("Not implemented")
energy, flux, power = srfunc.wiggler_spectrum(
traj,
enerMin=PHOTONENERGYMIN,
enerMax=PHOTONENERGYMAX,
nPoints=PHOTONENERGYPOINTS,
electronCurrent=ELECTRONCURRENT,
outFile="",
elliptical=False,
polarization=POLARIZATION)
try:
cumulated_power = power.cumsum() * numpy.abs(energy[0] - energy[1])
except:
cumulated_power = 0.0
print("\nPower from integral of spectrum (sum rule): %8.3f W" %
(cumulated_power[-1]))
try:
cumulated_power = cumtrapz(power, energy, initial=0)
except:
cumulated_power = 0.0
print("Power from integral of spectrum (trapezoid rule): %8.3f W" %
(cumulated_power[-1]))
codata_mee = 1e-6 * codata.m_e * codata.c**2 / codata.e # electron mass in meV
gamma = ELECTRONENERGY * 1e3 / codata_mee
Y = traj[1, :].copy()
divX = traj[3, :].copy()
By = traj[7, :].copy()
# rho = (1e9 / codata.c) * ELECTRONENERGY / By
# Ec0 = 3 * codata.h * codata.c * gamma**3 / (4 * numpy.pi * rho) / codata.e
# Ec = 665.0 * ELECTRONENERGY**2 * numpy.abs(By)
# Ecmax = 665.0 * ELECTRONENERGY** 2 * (numpy.abs(By)).max()
coeff = 3 / (
4 *
numpy.pi) * codata.h * codata.c**2 / codata_mee**3 / codata.e # ~665.0
Ec = coeff * ELECTRONENERGY**2 * numpy.abs(By)
Ecmax = coeff * ELECTRONENERGY**2 * (numpy.abs(By)).max()
# approx formula for divergence (first formula in pag 43 of Tanaka's paper)
sigmaBp = 0.597 / gamma * numpy.sqrt(Ecmax / PHOTONENERGYMIN)
# we use vertical interval 6*sigmaBp and horizontal interval = vertical + trajectory interval
divXX = numpy.linspace(divX.min() - PASSEPARTOUT * sigmaBp,
divX.max() + PASSEPARTOUT * sigmaBp, HSLITPOINTS)
divZZ = numpy.linspace(-PASSEPARTOUT * sigmaBp, PASSEPARTOUT * sigmaBp,
VSLITPOINTS)
e = numpy.linspace(PHOTONENERGYMIN, PHOTONENERGYMAX, PHOTONENERGYPOINTS)
p = numpy.zeros((PHOTONENERGYPOINTS, HSLITPOINTS, VSLITPOINTS))
for i in range(e.size):
Ephoton = e[i]
# vertical divergence
intensity = srfunc.sync_g1(Ephoton / Ec, polarization=POLARIZATION)
Ecmean = (Ec * intensity).sum() / intensity.sum()
fluxDivZZ = srfunc.sync_ang(1,
divZZ * 1e3,
polarization=POLARIZATION,
e_gev=ELECTRONENERGY,
i_a=ELECTRONCURRENT,
hdiv_mrad=1.0,
energy=Ephoton,
ec_ev=Ecmean)
if do_plot:
from srxraylib.plot.gol import plot
plot(divZZ,
fluxDivZZ,
title="min intensity %f" % fluxDivZZ.min(),
xtitle="divZ",
ytitle="fluxDivZZ",
show=1)
# horizontal divergence after Tanaka
if False:
e_over_ec = Ephoton / Ecmax
uudlim = 1.0 / gamma
uud = numpy.linspace(-uudlim * 0.99, uudlim * 0.99, divX.size)
uu = e_over_ec / numpy.sqrt(1 - gamma**2 * uud**2)
plot(uud, 2 * numpy.pi / numpy.sqrt(3) * srfunc.sync_g1(uu))
# horizontal divergence
# intensity = srfunc.sync_g1(Ephoton / Ec, polarization=POLARIZATION)
intensity_interpolated = interpolate_multivalued_function(
divX,
intensity,
divXX,
Y,
)
if CONVOLUTION: # do always convolution!
intensity_interpolated.shape = -1
divXX_window = divXX[-1] - divXX[0]
divXXCC = numpy.linspace(-0.5 * divXX_window, 0.5 * divXX_window,
divXX.size)
fluxDivZZCC = srfunc.sync_ang(1,
divXXCC * 1e3,
polarization=POLARIZATION,
e_gev=ELECTRONENERGY,
i_a=ELECTRONCURRENT,
hdiv_mrad=1.0,
energy=Ephoton,
ec_ev=Ecmax)
fluxDivZZCC.shape = -1
intensity_convolved = numpy.convolve(
intensity_interpolated / intensity_interpolated.max(),
fluxDivZZCC / fluxDivZZCC.max(),
mode='same')
else:
intensity_convolved = intensity_interpolated
if i == 0:
print(
"\n\n============ sizes vs photon energy ======================="
)
print(
"Photon energy/eV FWHM X'/urad FWHM Y'/urad FWHM X/mm FWHM Z/mm "
)
print("%16.3f %12.3f %12.3f %9.2f %9.2f" %
(Ephoton, 1e6 * get_fwhm(intensity_convolved, divXX)[0],
1e6 * get_fwhm(fluxDivZZ, divZZ)[0],
1e3 * get_fwhm(intensity_convolved, divXX)[0] * DISTANCE,
1e3 * get_fwhm(fluxDivZZ, divZZ)[0] * DISTANCE))
if do_plot:
plot(divX,
intensity / intensity.max(),
divXX,
intensity_interpolated / intensity_interpolated.max(),
divXX,
intensity_convolved / intensity_convolved.max(),
divXX,
fluxDivZZCC / fluxDivZZCC.max(),
title="min intensity %f, Ephoton=%6.2f" %
(intensity.min(), Ephoton),
xtitle="divX",
ytitle="intensity",
legend=["orig", "interpolated", "convolved", "kernel"],
show=1)
# combine H * V
INTENSITY = numpy.outer(
intensity_convolved / intensity_convolved.max(),
fluxDivZZ / fluxDivZZ.max())
p[i, :, :] = INTENSITY
if do_plot:
from srxraylib.plot.gol import plot_image, plot_surface, plot_show
plot_image(INTENSITY,
divXX,
divZZ,
aspect='auto',
title="E=%6.2f" % Ephoton,
show=1)
# to create oasys icon...
# plot_surface(INTENSITY, divXX, divZZ, title="", show=0)
# import matplotlib.pylab as plt
# plt.xticks([])
# plt.yticks([])
# plt.axis('off')
# plt.tick_params(axis='both', left='off', top='off', right='off', bottom='off', labelleft='off',
# labeltop='off', labelright='off', labelbottom='off')
#
# plot_show()
#
h = divXX * DISTANCE * 1e3 # in mm for the h5 file
v = divZZ * DISTANCE * 1e3 # in mm for the h5 file
print("\nWindow size: %f mm [H] x %f mm [V]" %
(h[-1] - h[0], v[-1] - v[0]))
print("Window size: %g rad [H] x %g rad [V]" %
(divXX[-1] - divXX[0], divZZ[-1] - divZZ[0]))
# normalization and total flux
for i in range(e.size):
INTENSITY = p[i, :, :]
# norm = INTENSITY.sum() * (h[1] - h[0]) * (v[1] - v[0])
norm = trapezoidal_rule_2d_1darrays(INTENSITY, h, v)
p[i, :, :] = INTENSITY / norm * flux[i]
# fit
fit_ok = False
try:
power = p.sum(axis=0) * (e[1] - e[0]) * codata.e * 1e3
print(
"\n\n============= Fitting power density to a 2D Gaussian. ==============\n"
)
print(
"Please use these results with care: check if the original data looks like a Gaussian."
)
fit_parameters = fit_gaussian2d(power, h, v)
print(info_params(fit_parameters))
H, V = numpy.meshgrid(h, v)
data_fitted = twoD_Gaussian((H, V), *fit_parameters)
print(" Total power (sum rule) in the fitted data [W]: ",
data_fitted.sum() * (h[1] - h[0]) * (v[1] - v[0]))
# plot_image(data_fitted.reshape((h.size,v.size)),h, v,title="FIT")
print("====================================================\n")
fit_ok = True
except:
pass
# output file
if h5_file != "":
try:
if h5_initialize:
h5w = H5SimpleWriter.initialize_file(
h5_file, creator="xoppy_wigglers.py")
else:
h5w = H5SimpleWriter(h5_file, None)
h5w.create_entry(h5_entry_name, nx_default=None)
h5w.add_stack(e,
h,
v,
p,
stack_name="Radiation",
entry_name=h5_entry_name,
title_0="Photon energy [eV]",
title_1="X gap [mm]",
title_2="Y gap [mm]")
h5w.create_entry("parameters",
root_entry=h5_entry_name,
nx_default=None)
if h5_parameters is not None:
for key in h5_parameters.keys():
h5w.add_key(key,
h5_parameters[key],
entry_name=h5_entry_name + "/parameters")
h5w.create_entry("trajectory",
root_entry=h5_entry_name,
nx_default="transversal trajectory")
h5w.add_key("traj", traj, entry_name=h5_entry_name + "/trajectory")
h5w.add_dataset(traj[1, :],
traj[0, :],
dataset_name="transversal trajectory",
entry_name=h5_entry_name + "/trajectory",
title_x="s [m]",
title_y="X [m]")
h5w.add_dataset(traj[1, :],
traj[3, :],
dataset_name="transversal velocity",
entry_name=h5_entry_name + "/trajectory",
title_x="s [m]",
title_y="Vx/c")
h5w.add_dataset(traj[1, :],
traj[7, :],
dataset_name="Magnetic field",
entry_name=h5_entry_name + "/trajectory",
title_x="s [m]",
title_y="Bz [T]")
if fit_ok:
h5w.add_image(power,
h,
v,
image_name="PowerDensity",
entry_name=h5_entry_name,
title_x="X [mm]",
title_y="Y [mm]")
h5w.add_image(data_fitted.reshape(h.size, v.size),
h,
v,
image_name="PowerDensityFit",
entry_name=h5_entry_name,
title_x="X [mm]",
title_y="Y [mm]")
h5w.add_key("fit_info",
info_params(fit_parameters),
entry_name=h5_entry_name + "/PowerDensityFit")
print("File written to disk: %s" % h5_file)
except:
print("ERROR initializing h5 file")
return e, h, v, p, traj
def calculate_flux(y, B, select_mode=0, energy_GeV=2.0, do_plot=False):
# analyse M1
B3 = B.copy()
# if M==1:
# ibad = numpy.argwhere(y > -0.2)
# B3[ibad] = 0.0
# elif M==2:
# ibad = numpy.argwhere( numpy.abs(y) > 0.2)
# B3[ibad] = 0.0
# elif M==3:
# ibad = numpy.argwhere(y < 0.2)
# B3[ibad] = 0.0
# else:
# pass
# select_mode = 2 # 0=all, 1=Mag7, 2=Mag8, 3=both RB only, 4=RB1, 5=RB2
if select_mode == 0:
pass
elif select_mode == 1:
ibad = numpy.where(y < -0.3)
B3[ibad] = 0.0
ibad = numpy.where(y > 0.3)
B3[ibad] = 0.0
elif select_mode == 2:
ibad = numpy.where(y < 0.66)
B3[ibad] = 0.0
elif select_mode == 3:
ibad = numpy.where(numpy.abs(y) < 0.3)
B3[ibad] = 0.0
ibad = numpy.where(y > 0.66)
B3[ibad] = 0.0
elif select_mode == 4:
ibad = numpy.where(y > -0.3)
B3[ibad] = 0.0
elif select_mode == 5:
ibad = numpy.where(y < 0.3)
B3[ibad] = 0.0
ibad = numpy.where(y > 0.66)
B3[ibad] = 0.0
if do_plot:
from srxraylib.plot.gol import plot, set_qt
plot(y, B3, title="select_mode=%d" % select_mode)
tmp = numpy.vstack((y, B3)).T
print(">>>>", tmp.shape, tmp[:, 0])
(traj, pars) = srfunc.wiggler_trajectory(
b_from=1,
inData=tmp, #"BM_first.b",
nPer=1,
nTrajPoints=501,
ener_gev=energy_GeV,
per=0.01,
kValue=1.0,
trajFile="tmp.traj",
shift_x_flag=5,
shift_x_value=0.042,
shift_betax_flag=4,
shift_betax_value=0.0324)
calculate_spectrum = True
if calculate_spectrum:
e, f, w = srfunc.wiggler_spectrum(traj,
enerMin=0.0010,
enerMax=10000.1,
nPoints=500,
electronCurrent=500.0 * 1e-3,
outFile="spectrum.dat",
elliptical=False)
from srxraylib.plot.gol import plot
return e, f, w
def __calculate_radiation(self):
wiggler = self.get_magnetic_structure()
electron_beam = self.get_electron_beam()
if wiggler._magnetic_field_periodic == 1:
(traj, pars) = wiggler_trajectory(
b_from=0,
inData="",
nPer=wiggler.number_of_periods(),
nTrajPoints=wiggler._NG_J,
ener_gev=electron_beam._energy_in_GeV,
per=wiggler.period_length(),
kValue=wiggler.K_vertical(),
trajFile="",
)
elif wiggler._magnetic_field_periodic == 0:
print(">>>>>>>>>>>>>>>>>>>>>>", "shift_x_flag = ",
wiggler._shift_x_flag, "shift_x_value = ",
wiggler._shift_x_value, "shift_betax_flag = ",
wiggler._shift_betax_flag, "shift_betax_value = ",
wiggler._shift_betax_value)
(traj, pars) = wiggler_trajectory(
b_from=1,
inData=wiggler._file_with_magnetic_field,
nPer=1,
nTrajPoints=wiggler._NG_J,
ener_gev=electron_beam._energy_in_GeV,
# per=self.syned_wiggler.period_length(),
# kValue=self.syned_wiggler.K_vertical(),
trajFile="",
shift_x_flag=wiggler._shift_x_flag,
shift_x_value=wiggler._shift_x_value,
shift_betax_flag=wiggler._shift_betax_flag,
shift_betax_value=wiggler._shift_betax_value,
)
self.__result_trajectory = traj
self.__result_parameters = pars
# print(">>>>>>>>>> traj pars: ",traj.shape,pars)
#
# plot(traj[1, :], traj[0, :], xtitle="Y", ytitle="X")
# plot(traj[1, :], traj[3, :], xtitle="Y", ytitle="BetaX")
# plot(traj[1, :], traj[6, :], xtitle="Y", ytitle="Curvature")
# plot(traj[1, :], traj[7, :], xtitle="Y", ytitle="B")
# traj[0,ii] = yx[i]
# traj[1,ii] = yy[i]+j * per - start_len
# traj[2,ii] = 0.0
# traj[3,ii] = betax[i]
# traj[4,ii] = betay[i]
# traj[5,ii] = 0.0
# traj[6,ii] = curv[i]
# traj[7,ii] = bz[i]
#
# calculate cdf and write file for Shadow/Source
#
print(
">>>>>>>>>>>>>>>>>>>> wiggler._EMIN,wiggler._EMAX,wiggler._NG_E",
wiggler._EMIN, wiggler._EMAX, wiggler._NG_E)
self.__result_cdf = wiggler_cdf(self.__result_trajectory,
enerMin=wiggler._EMIN,
enerMax=wiggler._EMAX,
enerPoints=wiggler._NG_E,
outFile="tmp.cdf",
elliptical=False)
#
from srxraylib.sources import srfunc
from srxraylib.plot.gol import plot, plot_image
from srxraylib.sources.srfunc import sync_g1, sync_f
import numpy
import scipy.constants as codata
ener_gev = 2.0
current = 0.5
(traj, pars) = srfunc.wiggler_trajectory(b_from=0,
inData="",
nPer=137,
nTrajPoints=501,
ener_gev=ener_gev,
per=0.0288,
kValue=3.07,
trajFile="tmp.traj",
shift_x_flag=0,
shift_x_value=0.0,
shift_betax_flag=0,
shift_betax_value=0.0)
# 0 1 2 3 4 5 6 7
#L x[m] y[m] z[m] BetaX BetaY BetaZ Curvature B[T]
print(traj.shape)
xp = traj[3, :]
b0 = traj[7, :]
# plot(1e6*xp,numpy.abs(b0),xtitle="xp")
def calculate_spectrum(emin, emax, npoints=500, do_plot=False):
#
# script to run the wiggler preprocessor (created by ShadowOui:Wiggler)
#
(traj, pars) = srfunc.wiggler_trajectory(b_from=1,
inData="Bz_Alba_rev3.dat",
nPer=1,
nTrajPoints=501,
ener_gev=2.5,
per=0.755,
kValue=211.0,
trajFile="tmp.traj",
shift_x_flag=4,
shift_x_value=0.0,
shift_betax_flag=4,
shift_betax_value=0.0)
#
# calculate cdf and write file for Shadow/Source
#
srfunc.wiggler_cdf(traj,
enerMin=emin,
enerMax=emax,
enerPoints=1001,
outFile=b'xshwig.sha',
elliptical=False)
calculate_spectrum = True
if calculate_spectrum:
e, f, w = srfunc.wiggler_spectrum(traj,
enerMin=emin,
enerMax=emax,
nPoints=npoints,
electronCurrent=400 * 1e-3,
outFile="spectrum.dat",
elliptical=False)
if do_plot:
from srxraylib.plot.gol import plot
plot(e,
f,
xlog=False,
ylog=False,
show=False,
xtitle="Photon energy [eV]",
ytitle="Flux [Photons/s/0.1%bw]",
title="Flux")
plot(e,
w,
xlog=False,
ylog=False,
show=False,
xtitle="Photon energy [eV]",
ytitle="Spectral Power [W/eV]",
title="Spectral Power")
#
# end script
#
return e, w
def run_shadow3(photon_energy, n_rays=5e5, emittance=True):
#
# script to run the wiggler preprocessor (created by ShadowOui:Wiggler)
#
(traj, pars) = srfunc.wiggler_trajectory(b_from=1,
inData="Bz_Alba_rev3.dat",
nPer=1,
nTrajPoints=501,
ener_gev=2.5,
per=0.755,
kValue=211.0,
trajFile="tmp.traj",
shift_x_flag=4,
shift_x_value=0.0,
shift_betax_flag=4,
shift_betax_value=0.0)
#
# calculate cdf and write file for Shadow/Source
#
srfunc.wiggler_cdf(
traj,
enerMin=photon_energy, # 5000.0,
enerMax=photon_energy + 1.0,
enerPoints=1001,
outFile=b'xshwig.sha',
elliptical=False)
#
# end script
#
#
#
# Python script to run shadow3. Created automatically with ShadowTools.make_python_script_from_list().
# write (1) or not (0) SHADOW files start.xx end.xx star.xx
iwrite = 0
#
# initialize shadow3 source (oe0) and beam
#
beam = Shadow.Beam()
oe0 = Shadow.Source()
oe1 = Shadow.OE()
#
# Define variables. See meaning of variables in:
# https://raw.githubusercontent.com/srio/shadow3/master/docs/source.nml
# https://raw.githubusercontent.com/srio/shadow3/master/docs/oe.nml
#
oe0.BENER = 2.5
oe0.CONV_FACT = 1000.0
# oe0.EPSI_X = 2.574e-05
# oe0.EPSI_Z = 2.574e-07
if emittance:
oe0.EPSI_X = 2.574e-05
oe0.EPSI_Z = 2.574e-07
oe0.FDISTR = 0
oe0.FILE_TRAJ = b'xshwig.sha'
oe0.FSOUR = 0
oe0.FSOURCE_DEPTH = 0
oe0.F_COLOR = 0
oe0.F_PHOT = 0
oe0.F_WIGGLER = 1
oe0.HDIV1 = 1.0
oe0.HDIV2 = 1.0
oe0.IDO_VX = 0
oe0.IDO_VZ = 0
oe0.IDO_X_S = 0
oe0.IDO_Y_S = 0
oe0.IDO_Z_S = 0
oe0.ISTAR1 = 420024
oe0.NCOL = 0
oe0.NPOINT = n_rays
oe0.N_COLOR = 0
oe0.POL_DEG = 0.0
# oe0.PH1 = 40000.0
# oe0.PH2 = 40001.0
oe0.SIGMAX = 0.8208
oe0.SIGMAZ = 0.014
if emittance:
oe0.SIGMAX = 0.8208
oe0.SIGMAZ = 0.0142
else:
oe0.SIGMAX = 0.0
oe0.SIGMAZ = 0.0
oe0.SIGMAY = 0.0
oe0.VDIV1 = 1.0
oe0.VDIV2 = 1.0
oe0.WXSOU = 0.0
oe0.WYSOU = 0.0
oe0.WZSOU = 0.0
oe1.DUMMY = 0.1
oe1.FWRITE = 3
oe1.F_REFRAC = 2
oe1.F_SCREEN = 1
oe1.N_SCREEN = 1
oe1.T_IMAGE = 0.0
oe1.T_INCIDENCE = 0.0
oe1.T_REFLECTION = 180.0
oe1.T_SOURCE = 30000.0
# Run SHADOW to create the source
if iwrite:
oe0.write("start.00")
beam.genSource(oe0)
if iwrite:
oe0.write("end.00")
beam.write("begin.dat")
return beam, oe0