def get_Wavefront1D_from_profile(self, axis, coordinate):
# swap axis - changed giovanni+manuel
if axis == 1: # fixed X
index = numpy.argmin(numpy.abs(self._electric_field_matrix.x_coord - coordinate))
return GenericWavefront1D(wavelength=self._wavelength,
electric_field_array=ScaledArray(scale=self._electric_field_matrix.y_coord,
np_array=self._electric_field_matrix.z_values[index, :]))
elif axis == 0:
index = numpy.argmin(numpy.abs(self._electric_field_matrix.y_coord - coordinate))
return GenericWavefront1D(wavelength=self._wavelength,
electric_field_array=ScaledArray(scale=self._electric_field_matrix.x_coord,
np_array=self._electric_field_matrix.z_values[:, index]))
def duplicate(self):
if self.is_polarized():
return GenericWavefront1D(
wavelength=self._wavelength,
electric_field_array=ScaledArray(
np_array=copy.copy(self._electric_field_array.np_array),
scale=copy.copy(self._electric_field_array.scale)),
electric_field_array_pi=ScaledArray(
np_array=copy.copy(self._electric_field_array_pi.np_array),
scale=copy.copy(self._electric_field_array_pi.scale)))
else:
return GenericWavefront1D(
wavelength=self._wavelength,
electric_field_array=ScaledArray(
np_array=copy.copy(self._electric_field_array.np_array),
scale=copy.copy(self._electric_field_array.scale)))
def sh_readsurface(filename, dimension):
if dimension == 1:
values = np.loadtxt(congruence.checkFile(filename))
return ScaledArray(values[:, 1], values[:, 0])
elif dimension == 2:
x_coords, y_coords, z_values = ShadowPreProcessor.read_surface_error_file(filename)
return ScaledMatrix(x_coords, y_coords, z_values)
def hy_findrmsslopefromheight(wmirror_l):
array_first_derivative = np.gradient(wmirror_l.np_array, wmirror_l.delta())
return hy_findrmserror(ScaledArray(array_first_derivative, wmirror_l.scale))
def propagate_2D(calculation_parameters, input_parameters):
shadow_oe = calculation_parameters.shadow_oe_end
if calculation_parameters.do_ff_z and calculation_parameters.do_ff_x:
global_phase_shift_profile = None
if shadow_oe._oe.F_MOVE == 1 and shadow_oe._oe.X_ROT != 0.0:
if input_parameters.ghy_calcType == 3 or input_parameters.ghy_calcType == 4:
global_phase_shift_profile = calculation_parameters.w_mirr_2D_values
elif input_parameters.ghy_calcType == 2:
global_phase_shift_profile = ScaledMatrix.initialize_from_range(numpy.zeros((3, 3)),
shadow_oe._oe.RWIDX2, shadow_oe._oe.RWIDX1,
shadow_oe._oe.RLEN2, shadow_oe._oe.RLEN1)
for x_index in range(global_phase_shift_profile.size_x()):
global_phase_shift_profile.z_values[x_index, :] += global_phase_shift_profile.get_y_values()*numpy.sin(numpy.radians(-shadow_oe._oe.X_ROT))
elif input_parameters.ghy_calcType == 3 or input_parameters.ghy_calcType == 4:
global_phase_shift_profile = calculation_parameters.w_mirr_2D_values
# only tangential slopes
if input_parameters.ghy_calcType == 3 or input_parameters.ghy_calcType == 4:
rms_slope = hy_findrmsslopefromheight(ScaledArray(np_array=global_phase_shift_profile.z_values[int(global_phase_shift_profile.size_x()/2), :],
scale=global_phase_shift_profile.get_y_values()))
print("Using RMS slope = " + str(rms_slope))
# ------------------------------------------
# far field calculation
# ------------------------------------------
focallength_ff = calculate_focal_length_ff_2D(calculation_parameters.ghy_x_min,
calculation_parameters.ghy_x_max,
calculation_parameters.ghy_z_min,
calculation_parameters.ghy_z_max,
input_parameters.ghy_npeak,
calculation_parameters.gwavelength)
if (input_parameters.ghy_calcType == 3 or input_parameters.ghy_calcType == 4) and rms_slope != 0:
focallength_ff = min(focallength_ff,(calculation_parameters.ghy_z_max-calculation_parameters.ghy_z_min) / 16 / rms_slope ) #xshi changed
elif input_parameters.ghy_calcType == 2 and not global_phase_shift_profile is None:
focallength_ff = min(focallength_ff, input_parameters.ghy_distance*4) #TODO: PATCH to be found with a formula
print("FF: calculated focal length: " + str(focallength_ff))
fftsize_x = int(calculate_fft_size(calculation_parameters.ghy_x_min,
calculation_parameters.ghy_x_max,
calculation_parameters.gwavelength,
focallength_ff,
input_parameters.ghy_fftnpts,
factor=20))
fftsize_z = int(calculate_fft_size(calculation_parameters.ghy_z_min,
calculation_parameters.ghy_z_max,
calculation_parameters.gwavelength,
focallength_ff,
input_parameters.ghy_fftnpts,
factor=20))
print("FF: creating plane wave begin, fftsize_x = " + str(fftsize_x) + ", fftsize_z = " + str(fftsize_z))
wavefront = Wavefront2D.initialize_wavefront_from_range(wavelength=calculation_parameters.gwavelength,
number_of_points=(fftsize_x, fftsize_z),
x_min=calculation_parameters.ghy_x_min,
x_max=calculation_parameters.ghy_x_max,
y_min=calculation_parameters.ghy_z_min,
y_max=calculation_parameters.ghy_z_max)
try:
for i in range(0, len(wavefront.electric_field_array.x_coord)):
for j in range(0, len(wavefront.electric_field_array.y_coord)):
interpolated = calculation_parameters.wIray_2d.interpolate_value(wavefront.electric_field_array.x_coord[i],
wavefront.electric_field_array.y_coord[j])
wavefront.electric_field_array.set_z_value(i, j, numpy.sqrt(0.0 if interpolated < 0 else interpolated))
except IndexError:
raise Exception("Unexpected Error during interpolation: try reduce Number of bins for I(Tangential) histogram")
wavefront.apply_ideal_lens(focallength_ff, focallength_ff)
shadow_oe = calculation_parameters.shadow_oe_end
if input_parameters.ghy_calcType == 3 or \
(input_parameters.ghy_calcType == 2 and not global_phase_shift_profile is None):
print("FF: calculating phase shift due to Height Error Profile")
phase_shifts = numpy.zeros(wavefront.size())
for index in range(0, phase_shifts.shape[0]):
np_array = numpy.zeros(global_phase_shift_profile.shape()[1])
for j in range(0, len(np_array)):
np_array[j] = global_phase_shift_profile.interpolate_value(wavefront.get_coordinate_x()[index], calculation_parameters.w_mirr_2D_values.get_y_value(j))
global_phase_shift_profile_z = ScaledArray.initialize_from_steps(np_array,
global_phase_shift_profile.y_coord[0],
global_phase_shift_profile.y_coord[1] - global_phase_shift_profile.y_coord[0])
phase_shifts[index, :] = get_mirror_phase_shift(wavefront.get_coordinate_y(),
calculation_parameters.gwavelength,
calculation_parameters.wangle_z,
calculation_parameters.wl_z,
global_phase_shift_profile_z)
wavefront.add_phase_shifts(phase_shifts)
elif input_parameters.ghy_calcType == 4:
print("FF: calculating phase shift due to Height Error Profile")
phase_shifts = numpy.zeros(wavefront.size())
for index in range(0, phase_shifts.shape[0]):
global_phase_shift_profile_z = ScaledArray.initialize_from_steps(global_phase_shift_profile.z_values[index, :],
global_phase_shift_profile.y_coord[0],
global_phase_shift_profile.y_coord[1] - global_phase_shift_profile.y_coord[0])
phase_shifts[index, :] = get_grating_phase_shift(wavefront.get_coordinate_y(),
calculation_parameters.gwavelength,
calculation_parameters.wangle_z,
calculation_parameters.wangle_ref_z,
calculation_parameters.wl_z,
global_phase_shift_profile_z)
wavefront.add_phase_shifts(phase_shifts)
elif input_parameters.ghy_calcType == 6:
for w_mirr_2D_values in calculation_parameters.w_mirr_2D_values:
phase_shift = get_crl_phase_shift(w_mirr_2D_values,
input_parameters,
calculation_parameters,
[wavefront.get_coordinate_x(), wavefront.get_coordinate_y()])
wavefront.add_phase_shift(phase_shift)
print("calculated plane wave: begin FF propagation (distance = " + str(focallength_ff) + ")")
propagated_wavefront = propagator2D.propagate_2D_fresnel(wavefront, focallength_ff)
print("dif_zp: begin calculation")
imagesize_x = min(abs(calculation_parameters.ghy_x_max), abs(calculation_parameters.ghy_x_min)) * 2
imagesize_x = min(imagesize_x,
input_parameters.ghy_npeak*2*0.88*calculation_parameters.gwavelength*focallength_ff/abs(calculation_parameters.ghy_x_max-calculation_parameters.ghy_x_min))
# TODO: this is a patch: to be rewritten
if shadow_oe._oe.F_MOVE==1 and not shadow_oe._oe.Y_ROT==0:
imagesize_x = max(imagesize_x, 8*(focallength_ff*numpy.tan(numpy.radians(numpy.abs(shadow_oe._oe.Y_ROT))) + numpy.abs(shadow_oe._oe.OFFX)))
delta_x = propagated_wavefront.delta()[0]
imagenpts_x = int(round(imagesize_x/delta_x/2) * 2 + 1)
imagesize_z = min(abs(calculation_parameters.ghy_z_max), abs(calculation_parameters.ghy_z_min)) * 2
imagesize_z = min(imagesize_z,
input_parameters.ghy_npeak*2*0.88*calculation_parameters.gwavelength*focallength_ff/abs(calculation_parameters.ghy_z_max-calculation_parameters.ghy_z_min))
# TODO: this is a patch: to be rewritten
if shadow_oe._oe.F_MOVE==1 and not shadow_oe._oe.X_ROT==0:
imagesize_z = max(imagesize_z, 8*(focallength_ff*numpy.tan(numpy.radians(numpy.abs(shadow_oe._oe.X_ROT))) + numpy.abs(shadow_oe._oe.OFFZ)))
delta_z = propagated_wavefront.delta()[1]
imagenpts_z = int(round(imagesize_z/delta_z/2) * 2 + 1)
dif_xpzp = ScaledMatrix.initialize_from_range(numpy.ones((imagenpts_x, imagenpts_z)),
min_scale_value_x = -(imagenpts_x - 1) / 2 * delta_x,
max_scale_value_x =(imagenpts_x - 1) / 2 * delta_x,
min_scale_value_y = -(imagenpts_z - 1) / 2 * delta_z,
max_scale_value_y =(imagenpts_z - 1) / 2 * delta_z)
for i in range(0, dif_xpzp.shape()[0]):
for j in range(0, dif_xpzp.shape()[1]):
dif_xpzp.set_z_value(i, j, numpy.absolute(propagated_wavefront.get_interpolated_complex_amplitude(
dif_xpzp.x_coord[i],
dif_xpzp.y_coord[j]))**2
)
dif_xpzp.set_scale_from_range(0,
-(imagenpts_x - 1) / 2 * delta_x / focallength_ff,
(imagenpts_x - 1) / 2 * delta_x / focallength_ff)
dif_xpzp.set_scale_from_range(1,
-(imagenpts_z - 1) / 2 * delta_z / focallength_ff,
(imagenpts_z - 1) / 2 * delta_z / focallength_ff)
calculation_parameters.dif_xpzp = dif_xpzp
