def create_magn_field_undulator_test(self, magnetic_structure, electron_beam,method_traj):
sim_test = create_simulation(magnetic_structure=magnetic_structure,electron_beam=electron_beam,
traj_method=method_traj,rad_method=RADIATION_METHOD_APPROX_FARFIELD)
print('create')
source_test=sim_test.source
Zo=sim_test.trajectory_fact.initial_condition[5]
Bo=source_test.magnetic_field_strength()
lambda_u=source_test.magnetic_structure.period_length
self.assertTrue(Zo<0.)
Zo_analitic=source_test.magnetic_structure.length*0.5
Z_test = np.linspace(-Zo_analitic, Zo_analitic, sim_test.trajectory_fact.Nb_pts)
diff_mf = np.abs(source_test.magnetic_field.By(z=Z_test, y=0.0, x=0.0) -
Bo * np.cos((2.0 * np.pi / lambda_u) * Z_test))
self.assertTrue(all(diff_mf < np.abs(Bo) * 1e-3))
print('integration 1')
int1 = integrate.quad((lambda z: source_test.magnetic_field.By(z=z, y=0.0, x=0.0)),Zo,-Zo
,limit=int(source_test.choose_nb_pts_trajectory(2)))
self.assertAlmostEqual(int1[0], 0.0, 2)
print('integration 2')#TODO marche pas donne tjr zeros meme qd c'est faux
int2 = integrate.quad((lambda z: z*source_test.magnetic_field.By(z=z, y=0.0, x=0.0)),Zo,-Zo
,limit=int(source_test.choose_nb_pts_trajectory(2)))
print(int2[0])
self.assertAlmostEqual(int2[0], 0.0)
def simul_undulator_traj_method(self, magnetic_struc, electron_beam,
method_rad):
sim_test = create_simulation(magnetic_structure=magnetic_struc,
electron_beam=electron_beam,
rad_method=method_rad,
distance=100)
sim_test.calculate_on_central_cone()
ref = sim_test.copy()
rad_max = (sim_test.radiation.max())
sim_test.change_trajectory_method(TRAJECTORY_METHOD_ODE)
rad_err = ref.radiation.error_max(sim_test.radiation)
traj_err = ref.trajectory.error_max(sim_test.trajectory)
self.assertLessEqual(
np.abs(sim_test.radiation.max() - rad_max) / rad_max, 5e-2, 4)
self.assertLessEqual(traj_err[1] / ref.trajectory.x.max(), 5e-3)
self.assertLessEqual(traj_err[3] / ref.trajectory.z.max(), 5e-3)
self.assertLessEqual(traj_err[4] / ref.trajectory.v_x.max(), 5e-3)
self.assertLessEqual(traj_err[6] / ref.trajectory.v_z.max(), 5e-3)
self.assertLessEqual(traj_err[7] / ref.trajectory.a_x.max(), 5e-3)
self.assertLessEqual(traj_err[9] / ref.trajectory.a_z.max(), 5e-3)
self.assertLessEqual(
np.abs(sim_test.radiation.max() - rad_max) / rad_max, 5e-2)
self.assertLessEqual(rad_err / rad_max, 5e-2)
def simul_undulator_theoric(self, magnetic_struc, electron_beam, method_rad, method_traj):
sim_test = create_simulation(magnetic_structure=magnetic_struc, electron_beam=electron_beam,
rad_method=method_rad, traj_method=method_traj,distance=100)
rad_axis=sim_test.radiation.intensity[0,0]
rad_theo=sim_test.source.theoretical_flux_on_axis(1)#sim_test.radiation_fact.omega)
print("rad axis %e , theo %e" % (rad_axis, rad_theo))
def test_simulation(self):
electron_beam_test = ElectronBeam(Electron_energy=1.3, I_current=1.0)
beam_ESRF = ElectronBeam(Electron_energy=6.0, I_current=0.2)
undulator_test = Undulator(K=1.87, period_length=0.035, length=0.035 * 14)
ESRF18 = Undulator(K=1.68, period_length=0.018, length=2.0)
sim_test = create_simulation(magnetic_structure=undulator_test,electron_beam=electron_beam_test,
traj_method=TRAJECTORY_METHOD_ANALYTIC,rad_method=RADIATION_METHOD_NEAR_FIELD)
self.assertFalse(sim_test.radiation.distance == None)
source_test=sim_test.source
self.assertFalse(all(sim_test.trajectory_fact.initial_condition==
source_test.choose_initial_contidion_automatic()))
ref=sim_test.copy()
rad_max = sim_test.radiation.max()
# test change
sim_test.change_radiation_method(RADIATION_METHOD_APPROX_FARFIELD)
self.assertEqual(sim_test.radiation_fact.method, RADIATION_METHOD_APPROX_FARFIELD)
self.assertFalse(ref.radiation_fact.method==sim_test.radiation_fact.method)
self.assertFalse(np.all(ref.radiation.intensity == sim_test.radiation.intensity))
self.assertAlmostEqual(ref.radiation.intensity[0][0]/rad_max, sim_test.radiation.intensity[0][0]/rad_max, 3)
sim_test.change_trajectory_method(TRAJECTORY_METHOD_ODE)
self.assertEqual(sim_test.trajectory_fact.method, TRAJECTORY_METHOD_ODE)
self.assertFalse(ref.trajectory_fact.method==sim_test.trajectory_fact.method)
time_diff=np.abs(ref.trajectory.t - sim_test.trajectory.t)
self.assertTrue(np.all(time_diff<=1e-19))
self.assertFalse(np.all(ref.trajectory.x == sim_test.trajectory.x))
self.assertFalse(np.all(ref.radiation.intensity == sim_test.radiation.intensity))
rad_max = sim_test.radiation.max()
self.assertAlmostEqual(ref.radiation.intensity[0][0]/rad_max, sim_test.radiation.intensity[0][0]/rad_max, 1)
sim_test.change_Nb_pts_trajectory(ref.trajectory_fact.Nb_pts+1)
self.assertEqual(sim_test.trajectory_fact.Nb_pts,ref.trajectory_fact.Nb_pts+1)
self.assertEqual(sim_test.trajectory.nb_points(), ref.trajectory_fact.Nb_pts+1)
self.assertFalse(ref.trajectory_fact.Nb_pts == sim_test.trajectory_fact.Nb_pts)
self.assertAlmostEqual(ref.radiation.intensity[0][0]/rad_max,sim_test.radiation.intensity[0][0]/rad_max,1)
sim_test.change_Nb_pts_radiation(100)
self.assertEqual(sim_test.radiation_fact.Nb_pts,100)
self.assertFalse(np.all(ref.radiation.X == sim_test.radiation.X))
self.assertTrue(ref.radiation.X.min() == sim_test.radiation.X.min())
self.assertTrue(ref.radiation.X.max() == sim_test.radiation.X.max())
self.assertTrue(ref.radiation.Y.min() == sim_test.radiation.Y.min())
self.assertTrue(ref.radiation.Y.max() == sim_test.radiation.Y.max())
self.assertFalse(len(ref.radiation.X) == len(sim_test.radiation.X))
sim_test.change_distance(50)
self.assertEqual(sim_test.radiation.distance,50)
self.assertFalse(ref.radiation.distance == sim_test.radiation.distance)
sim_test.change_photon_frequency(source_test.harmonic_frequency(1) * 0.8)
self.assertEqual(sim_test.radiation_fact.photon_frequency,source_test.harmonic_frequency(1)*0.8)
self.assertFalse(ref.radiation_fact.photon_frequency == sim_test.radiation_fact.photon_frequency)
def simul_undulator_theoric(self, magnetic_struc, electron_beam,
method_rad, method_traj):
sim_test = create_simulation(magnetic_structure=magnetic_struc,
electron_beam=electron_beam,
rad_method=method_rad,
traj_method=method_traj,
distance=100)
rad_axis = sim_test.radiation.intensity[0, 0]
rad_theo = sim_test.source.theoretical_flux_on_axis(
1) #sim_test.radiation_fact.omega)
print("rad axis %e , theo %e" % (rad_axis, rad_theo))
def simul_undulator_near_to_farfield(self,magnetic_struc,electron_beam, method_traj):
ref = create_simulation(magnetic_structure=magnetic_struc,electron_beam=electron_beam,
traj_method=method_traj,distance=100)
ref.calculate_on_central_cone()
rad_max=(ref.radiation.max())
sim_test=ref.copy()
sim_test.change_radiation_method(RADIATION_METHOD_NEAR_FIELD)
rad_err=ref.radiation.error_max(sim_test.radiation)
self.assertLessEqual(np.abs(sim_test.radiation.max()-rad_max)/rad_max,5e-2)
self.assertLessEqual(rad_err / rad_max, 5e-2)
def simul_undulator_near_to_farfield(self, magnetic_struc, electron_beam,
method_traj):
ref = create_simulation(magnetic_structure=magnetic_struc,
electron_beam=electron_beam,
traj_method=method_traj,
distance=100)
ref.calculate_on_central_cone()
rad_max = (ref.radiation.max())
sim_test = ref.copy()
sim_test.change_radiation_method(RADIATION_METHOD_NEAR_FIELD)
rad_err = ref.radiation.error_max(sim_test.radiation)
self.assertLessEqual(
np.abs(sim_test.radiation.max() - rad_max) / rad_max, 5e-2)
self.assertLessEqual(rad_err / rad_max, 5e-2)
def simul_undulator_traj_method(self, magnetic_struc,electron_beam, method_rad):
sim_test = create_simulation(magnetic_structure=magnetic_struc, electron_beam=electron_beam,
rad_method=method_rad,distance=100)
sim_test.calculate_on_central_cone()
ref = sim_test.copy()
rad_max = (sim_test.radiation.max())
sim_test.change_trajectory_method(TRAJECTORY_METHOD_ODE)
rad_err = ref.radiation.error_max(sim_test.radiation)
traj_err = ref.trajectory.error_max(sim_test.trajectory)
self.assertLessEqual(np.abs(sim_test.radiation.max() - rad_max) / rad_max, 5e-2,4)
self.assertLessEqual(traj_err[1] / ref.trajectory.x.max(), 5e-3)
self.assertLessEqual(traj_err[3] / ref.trajectory.z.max(), 5e-3)
self.assertLessEqual(traj_err[4] / ref.trajectory.v_x.max(), 5e-3)
self.assertLessEqual(traj_err[6] / ref.trajectory.v_z.max(), 5e-3)
self.assertLessEqual(traj_err[7] / ref.trajectory.a_x.max(), 5e-3)
self.assertLessEqual(traj_err[9] / ref.trajectory.a_z.max(), 5e-3)
self.assertLessEqual(np.abs(sim_test.radiation.max()-rad_max)/rad_max,5e-2)
self.assertLessEqual(rad_err / rad_max, 5e-2)
def create_magn_field_undulator_test(self, magnetic_structure,
electron_beam, method_traj):
sim_test = create_simulation(
magnetic_structure=magnetic_structure,
electron_beam=electron_beam,
traj_method=method_traj,
rad_method=RADIATION_METHOD_APPROX_FARFIELD)
print('create')
source_test = sim_test.source
Zo = sim_test.trajectory_fact.initial_condition[5]
Bo = source_test.magnetic_field_strength()
lambda_u = source_test.magnetic_structure.period_length
self.assertTrue(Zo < 0.)
Zo_analitic = source_test.magnetic_structure.length * 0.5
Z_test = np.linspace(-Zo_analitic, Zo_analitic,
sim_test.trajectory_fact.Nb_pts)
diff_mf = np.abs(
source_test.magnetic_field.By(z=Z_test, y=0.0, x=0.0) -
Bo * np.cos((2.0 * np.pi / lambda_u) * Z_test))
self.assertTrue(all(diff_mf < np.abs(Bo) * 1e-3))
print('integration 1')
int1 = integrate.quad(
(lambda z: source_test.magnetic_field.By(z=z, y=0.0, x=0.0)),
Zo,
-Zo,
limit=int(source_test.choose_nb_pts_trajectory(2)))
self.assertAlmostEqual(int1[0], 0.0, 2)
print('integration 2'
) #TODO marche pas donne tjr zeros meme qd c'est faux
int2 = integrate.quad(
(lambda z: z * source_test.magnetic_field.By(z=z, y=0.0, x=0.0)),
Zo,
-Zo,
limit=int(source_test.choose_nb_pts_trajectory(2)))
print(int2[0])
self.assertAlmostEqual(int2[0], 0.0)
def erreur_near_ff(und,beam):
sim_test_analy = create_simulation(magnetic_structure=und, electron_beam=beam,
traj_method=TRAJECTORY_METHOD_ANALYTIC,Nb_pts_radiation=31,
rad_method=RADIATION_METHOD_NEAR_FIELD,
Nb_pts_trajectory=5000,distance=100)
#sim_test_analy.change_harmonic_number(5.5)
#sim_test_analy.calculate_on_central_cone()
rad_max=sim_test_analy.radiation.max()
print(rad_max)
rad_max_theo=sim_test_analy.source.theoretical_flux_on_axis(frequency=sim_test_analy.radiation_fact.photon_frequency)
print(rad_max_theo)
d = np.linspace(20,60, 21)
error_rad=sim_test_analy.error_radiation_method_distance(method=RADIATION_METHOD_APPROX,D=d)
plt.plot(d,error_rad)
plt.xlabel("distance")
plt.ylabel("error")
plt.title('absolut error between two radiation method')
plt.show()
plt.plot(d,error_rad/rad_max)
plt.xlabel("distance")
plt.ylabel("error")
plt.title('relative error between two radiation method')
plt.show()
def erreur_nb_pts_traj(und,beam):
sim_test_analy = create_simulation(magnetic_structure=und, electron_beam=beam,
traj_method=TRAJECTORY_METHOD_ANALYTIC,Nb_pts_radiation=50,
rad_method=RADIATION_METHOD_NEAR_FIELD,
Nb_pts_trajectory=20000,distance=20)
rad_ref=sim_test_analy.radiation.intensity
rad_max=sim_test_analy.radiation.max()
print(rad_max)
rad_max_theo=sim_test_analy.source.theoretical_flux_on_axis(frequency=sim_test_analy.radiation_fact.photon_frequency)
# print(rad_max_theo)
# print((rad_max-rad_max_theo))
np_pts= np.arange(300,500,10)
error_rad=sim_test_analy.error_radiation_nb_pts_traj(good_value=rad_ref,nb_pts=np_pts)
plt.plot(np_pts,error_rad)
plt.xlabel("number of point")
plt.ylabel("error")
plt.title('absolut error, near field formula')
plt.show()
plt.plot(np_pts,error_rad/rad_max)
plt.xlabel("number of point")
plt.ylabel("error")
plt.title('relative error, near field formula')
plt.show()
beam_ESRF = ElectronBeam(Electron_energy=6.0, I_current=0.2)
# ESRF18 = Undulator(K=1.68, period_length=0.018, length=2.0)
ESRF18 = Undulator(K=1.0, period_length=0.1, length=1.0)
#
# radiation in a defined mesh with only one point to save time
#
distance = None
simulation_test = create_simulation(
magnetic_structure=ESRF18,
electron_beam=beam_ESRF,
magnetic_field=None,
photon_energy=None,
traj_method=TRAJECTORY_METHOD_ANALYTIC,
Nb_pts_trajectory=None,
rad_method=RADIATION_METHOD_APPROX_FARFIELD,
Nb_pts_radiation=101,
initial_condition=None,
distance=distance,
XY_are_list=False,
X=np.array([0]),
Y=np.array([0]))
simulation_test0 = simulation_test.copy()
#
# central cone
#
if False:
harmonic_number = 1
print(
beam_test=ElectronBeam(Electron_energy=1.3, I_current=1.0)
beam_ESRF=ElectronBeam(Electron_energy=6.0, I_current=0.2)
und_test=Undulator( K = 1.87, period_length= 0.035, length=0.035 * 14)
ESRF18=Undulator( K = 1.68, period_length = 0.018, length=2.0)
ESRFBM=BM(Bo=0.8,horizontale_divergeance=0.005,electron_energy=6.0)
vx= 2e-4
vz= np.sqrt(beam_test.electron_speed()**2-vx**2)*codata.c
# initial_cond=np.array([ vx*codata.c, 0.00000000e+00 ,vz , 0.0 , 0.0 ,-0.42,])
#X=np.linspace(-0.02,0.02,150)
#Y=np.linspace(-0.02,0.02,150)
sim_test = create_simulation(magnetic_structure=und_test, electron_beam=beam_test, traj_method=TRAJECTORY_METHOD_ANALYTIC,
rad_method=RADIATION_METHOD_APPROX_FARFIELD, Nb_pts_trajectory=1000,distance=100)
sim_test.calculate_on_central_cone()
sim_test.change_energy_eV(E=2000)
#sim_test.change_harmonic_number(5.5)
#print(sim_test.source.choose_nb_pts_trajectory())
#print(sim_test.source.choose_distance_automatic())
#sim_test.print_parameters()
#sim_test.trajectory.plot_3D(title="Analytical electron trajectory in bending magnet")
#sim_test.trajectory.plot(title="Analytical electron trajectory in undulator")
#sim_test.calculate_on_central_cone()
#sim_test.calculate_spectrum_on_axis()
# omega1=sim_test.source.harmonic_frequency(1)
# omega_array=np.arange(.9*omega1,3.06*omega1,0.01*omega1)
# sim_test.calculate_spectrum_central_cone(abscissas_array=omega_array)
def calculate_undulator_emission(cls,
electron_energy=6.04,
electron_current=0.2,
undulator_period=0.032,
undulator_nperiods=50,
K=0.25,
photon_energy=10490.0,
abscissas_interval_in_far_field=250e-6,
number_of_points=100,
distance_to_screen=100,
scan_direction="V"):
myelectronbeam = PysruElectronBeam(Electron_energy=electron_energy,
I_current=electron_current)
myundulator = PysruUndulator(K=K,
period_length=undulator_period,
length=undulator_period *
undulator_nperiods)
abscissas = np.linspace(-0.5 * abscissas_interval_in_far_field,
0.5 * abscissas_interval_in_far_field,
number_of_points)
if scan_direction == "H":
X = abscissas
Y = np.zeros_like(abscissas)
elif scan_direction == "V":
X = np.zeros_like(abscissas)
Y = abscissas
print(" photon energy %g eV" % photon_energy)
simulation_test = create_simulation(
magnetic_structure=myundulator,
electron_beam=myelectronbeam,
magnetic_field=None,
photon_energy=photon_energy,
traj_method=TRAJECTORY_METHOD_ANALYTIC,
Nb_pts_trajectory=None,
rad_method=RADIATION_METHOD_APPROX_FARFIELD,
initial_condition=None,
distance=distance_to_screen,
X=X,
Y=Y,
XY_are_list=True)
# TODO: this is not nice: I redo the calculations because I need the electric vectors to get polarization
# this should be avoided after refactoring pySRU to include electric field in simulations!!
electric_field = simulation_test.radiation_fact.calculate_electrical_field(
simulation_test.trajectory, simulation_test.source, X, Y,
distance_to_screen)
E = electric_field._electrical_field
pol_deg1 = (np.abs(E[:, 0]) / (np.abs(E[:, 0]) + np.abs(E[:, 1]))
).flatten() # SHADOW definition!!
intens1 = simulation_test.radiation.intensity.copy()
# Conversion from pySRU units (photons/mm^2/0.1%bw) to SHADOW units (photons/rad^2/eV)
intens1 *= (distance_to_screen *
1e3)**2 # photons/mm^2 -> photons/rad^2
intens1 /= 1e-3 * photon_energy # photons/o.1%bw -> photons/eV
# unpack trajectory
T0 = simulation_test.trajectory
T = np.vstack((T0.t, T0.x, T0.y, T0.z, T0.v_x, T0.v_y, T0.v_z, T0.a_x,
T0.a_y, T0.a_z))
return {
'intensity': intens1,
'polarization': pol_deg1,
'electric_field': E,
'trajectory': T,
'photon_energy': photon_energy,
"abscissas": abscissas,
"D": distance_to_screen,
"theta": abscissas / distance_to_screen,
}
def _buildForXY(self, electron_beam, x_0, y_0, xp_0, yp_0, z, X, Y):
#TODO: X dimension equals Y dimension?
Y = X
beam = ElectronBeam(Electron_energy=electron_beam.energy(),
I_current=electron_beam.averageCurrent())
undulator = Undulator(K=self._undulator.K_vertical(),
period_length=self._undulator.periodLength(),
length=self._undulator.length())
initial_conditions = SourceUndulatorPlane(
undulator=undulator, electron_beam=beam,
magnetic_field=None).choose_initial_contidion_automatic()
v_z = initial_conditions[2]
initial_conditions[0] = xp_0 * speed_of_light
initial_conditions[1] = yp_0 * speed_of_light
initial_conditions[2] = np.sqrt(beam.electron_speed()**2 - xp_0**2 -
yp_0**2) * speed_of_light
initial_conditions[3] = x_0
initial_conditions[4] = y_0
if self._source_position == VIRTUAL_SOURCE_CENTER:
initial_conditions[5] = 0.0
print("initial cond:", initial_conditions)
simulation = create_simulation(
magnetic_structure=undulator,
electron_beam=beam,
traj_method=TRAJECTORY_METHOD_ODE,
rad_method=RADIATION_METHOD_NEAR_FIELD, #RADIATION_METHOD_FARFIELD,
distance=z,
X=X,
Y=Y,
photon_energy=self._photon_energy,
initial_condition=initial_conditions)
#simulation.trajectory.plot_3D()
#simulation.trajectory.plot()
#simulation.radiation.plot()
electrical_field = simulation.radiation_fact.calculate_electrical_field(
trajectory=simulation.trajectory,
source=simulation.source,
distance=simulation.radiation.distance,
X_array=simulation.radiation.X,
Y_array=simulation.radiation.Y)
efield = electrical_field.electrical_field()[np.newaxis, :, :, :]
efield = efield[:, :, :, 0:2]
calc_wavefront = NumpyWavefront(
e_field=efield,
x_start=X.min(),
x_end=X.max(),
y_start=Y.min(),
y_end=Y.max(),
z=z,
energies=np.array([self._photon_energy]),
)
#calc_wavefront.showEField()
self._last_simulation = simulation
self._last_initial_conditions = initial_conditions.copy()
return calc_wavefront
def undul_phot(E_ENERGY, INTENSITY, LAMBDAU, NPERIODS, K, EMIN, EMAX, NG_E,
MAXANGLE, NG_T, NG_P):
myelectronbeam = PysruElectronBeam(Electron_energy=E_ENERGY,
I_current=INTENSITY)
myundulator = PysruUndulator(K=K,
period_length=LAMBDAU,
length=LAMBDAU * NPERIODS)
#
# polar grid matrix
#
photon_energy = np.linspace(EMIN, EMAX, NG_E, dtype=float)
intens = np.zeros((NG_E, NG_T, NG_P))
pol_deg = np.zeros_like(intens)
theta = np.linspace(0, MAXANGLE, NG_T, dtype=float)
phi = np.linspace(0, np.pi / 2, NG_P, dtype=float)
D = 100.0 # placed far away (100 m)
THETA = np.outer(theta, np.ones_like(phi))
PHI = np.outer(np.ones_like(theta), phi)
X = (D / np.cos(THETA)) * np.sin(THETA) * np.cos(PHI)
Y = (D / np.cos(THETA)) * np.sin(THETA) * np.sin(PHI)
for ie, e in enumerate(photon_energy):
print("Calculating energy %g eV (%d of %d)" %
(e, ie + 1, photon_energy.size))
simulation_test = create_simulation(
magnetic_structure=myundulator,
electron_beam=myelectronbeam,
magnetic_field=None,
photon_energy=e,
traj_method=TRAJECTORY_METHOD_ANALYTIC,
Nb_pts_trajectory=None,
rad_method=RADIATION_METHOD_APPROX_FARFIELD,
initial_condition=None,
distance=D,
X=X.flatten(),
Y=Y.flatten(),
XY_are_list=True)
# TODO: this is not nice: I redo the calculations because I need the electric vectors to get polarization
# this should be avoided after refactoring pySRU to include electric field in simulations!!
electric_field = simulation_test.radiation_fact.calculate_electrical_field(
simulation_test.trajectory, simulation_test.source,
X.flatten(), Y.flatten(), D)
E = electric_field._electrical_field
# pol_deg1 = (np.abs(E[:,0])**2 / (np.abs(E[:,0])**2 + np.abs(E[:,1])**2)).flatten()
pol_deg1 = (np.abs(E[:, 0]) / (np.abs(E[:, 0]) + np.abs(E[:, 1]))
).flatten() # SHADOW definition!!
intens1 = simulation_test.radiation.intensity.copy()
intens1.shape = (theta.size, phi.size)
pol_deg1.shape = (theta.size, phi.size)
# Conversion from pySRU units (photons/mm^2/0.1%bw) to SHADOW units (photons/rad^2/eV)
intens1 *= (D * 1e3)**2 # photons/mm^2 -> photons/rad^2
intens1 /= 1e-3 * e # photons/o.1%bw -> photons/eV
intens[ie] = intens1
pol_deg[ie] = pol_deg1
T0 = simulation_test.trajectory
T = np.vstack((T0.t, T0.x, T0.y, T0.z, T0.v_x, T0.v_y, T0.v_z,
T0.a_x, T0.a_y, T0.a_z))
return {
'radiation': intens,
'polarization': pol_deg,
'photon_energy': photon_energy,
'theta': theta,
'phi': phi,
'trajectory': T
}
def _buildForXY(self, electron_beam, x_0, y_0, xp_0, yp_0, z, X, Y):
#TODO: X dimension equals Y dimension?
Y = X
beam = ElectronBeam(Electron_energy=electron_beam.energy(), I_current=electron_beam.averageCurrent())
undulator = Undulator(K=self._undulator.K_vertical(),
period_length=self._undulator.periodLength(),
length=self._undulator.length())
initial_conditions = SourceUndulatorPlane(undulator=undulator, electron_beam=beam, magnetic_field=None).choose_initial_contidion_automatic()
v_z = initial_conditions[2]
initial_conditions[0] = xp_0 * speed_of_light
initial_conditions[1] = yp_0 * speed_of_light
initial_conditions[2] = np.sqrt(beam.electron_speed()**2-xp_0**2-yp_0**2) * speed_of_light
initial_conditions[3] = x_0
initial_conditions[4] = y_0
if self._source_position == VIRTUAL_SOURCE_CENTER:
initial_conditions[5] = 0.0
print("initial cond:", initial_conditions)
simulation = create_simulation(magnetic_structure=undulator,
electron_beam=beam,
traj_method=TRAJECTORY_METHOD_ODE,
rad_method=RADIATION_METHOD_NEAR_FIELD, #RADIATION_METHOD_FARFIELD,
distance=z,
X=X,
Y=Y,
photon_energy=self._photon_energy,
initial_condition=initial_conditions)
#simulation.trajectory.plot_3D()
#simulation.trajectory.plot()
#simulation.radiation.plot()
electrical_field = simulation.radiation_fact.calculate_electrical_field(trajectory=simulation.trajectory,
source=simulation.source,
distance=simulation.radiation.distance,
X_array=simulation.radiation.X,
Y_array=simulation.radiation.Y)
efield = electrical_field.electrical_field()[np.newaxis, :, :, :]
efield = efield[:, :, :, 0:2]
calc_wavefront = NumpyWavefront(e_field=efield,
x_start=X.min(),
x_end=X.max(),
y_start=Y.min(),
y_end=Y.max(),
z=z,
energies=np.array([self._photon_energy]),
)
#calc_wavefront.showEField()
self._last_simulation = simulation
self._last_initial_conditions = initial_conditions.copy()
return calc_wavefront