Esempio n. 1
0
    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]))
Esempio n. 2
0
    def initialize_wavefront(cls,
                             wavelength=1e-10,
                             number_of_points=1000,
                             polarization=Polarization.SIGMA):

        sA = ScaledArray.initialize(
            np_array=numpy.full(number_of_points, (1.0 + 0.0j), dtype=complex))

        if ((polarization == Polarization.PI)
                or (polarization == Polarization.TOTAL)):
            sA_pi = ScaledArray.initialize(np_array=numpy.full(
                number_of_points, (0.0 + 0.0j), dtype=complex))
        else:
            sA_pi = None

        return GenericWavefront1D(wavelength, sA, sA_pi)
Esempio n. 3
0
 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)))
Esempio n. 4
0
def propagate_1D_fresnel_radius(wavefront, propagation_distance, eta):
    """
    1D Fresnel propagator using convolution via Fourier transform
    :param wavefront:
    :param propagation_distance: propagation distance
    :return: a new 1D wavefront object with propagated wavefront
    """
    fft_scale = numpy.fft.fftfreq(wavefront.size()) / wavefront.delta()

    fft = numpy.fft.fft(wavefront.get_complex_amplitude())
    fft *= numpy.exp(1.0j * numpy.pi * wavefront.get_wavelength() *
                     propagation_distance *
                     (-fft_scale**2 + eta * fft_scale**2))
    H = numpy.fft.ifft(fft)
    H *= -1.0j * eta * propagation_distance / wavefront.get_wavelength(
    ) * numpy.exp(1.0j * numpy.pi / eta / propagation_distance /
                  wavefront.get_wavelength() * wavefront.get_abscissas()**2)
    ifft = numpy.fft.fft(H)
    ifft *= numpy.exp(1.0j * numpy.pi / eta / propagation_distance /
                      wavefront.get_wavelength() *
                      wavefront.get_abscissas()**2)

    return Wavefront1D(
        wavefront.get_wavelength(),
        ScaledArray.initialize_from_steps(ifft, wavefront.offset(),
                                          wavefront.delta()))
Esempio n. 5
0
def propagator1d_fourier_rescaling(wavefront, propagation_distance, m=1):

    wf = wavefront.duplicate()  # todo: cambiato da giovanni, controllare
    shape = wf.size()
    delta = wf.delta()
    wavenumber = wf.get_wavenumber()
    wavelength = wf.get_wavelength()

    fft_scale = numpy.fft.fftfreq(shape, d=delta)

    x = wf.get_abscissas()

    x_rescaling = wf.get_abscissas() * m

    r1sq = x**2 * (1 - m)
    r2sq = x_rescaling**2 * ((m - 1) / m)
    fsq = (fft_scale**2 / m)

    Q1 = wavenumber / 2 / propagation_distance * r1sq
    Q2 = numpy.exp(-1.0j * numpy.pi * wavelength * propagation_distance * fsq)
    Q3 = numpy.exp(1.0j * wavenumber / 2 / propagation_distance * r2sq)

    wf.add_phase_shift(Q1)

    fft = numpy.fft.fft(wf.get_complex_amplitude())

    ifft = numpy.fft.ifft(fft * Q2) * Q3 / numpy.sqrt(m)

    return Wavefront1D(
        wf.get_wavelength(),
        ScaledArray.initialize_from_steps(ifft, m * wf.offset(),
                                          m * wf.delta()))
Esempio n. 6
0
def propagate_1D_integral(wavefront, propagation_distance, detector_abscissas=[None]):
    """
    1D Fresnel-Kirchhoff propagator via simplified integral
    :param wavefront:
    :param propagation_distance: propagation distance
    :param detector_abscissas: a numpy array with the anscissas at the image position. If undefined ([None])
                            it uses the same abscissas present in input wavefront.
    :return: a new 1D wavefront object with propagated wavefront
    """

    if detector_abscissas[0] == None:
        detector_abscissas = wavefront.get_abscissas()

    # calculate via outer product, it spreads over a lot of memory, but it is OK for 1D
    x1 = numpy.outer(wavefront.get_abscissas(),numpy.ones(detector_abscissas.size))
    x2 = numpy.outer(numpy.ones(wavefront.size()),detector_abscissas)
    r = numpy.sqrt( numpy.power(x1-x2,2) + numpy.power(propagation_distance,2) )
    wavenumber = numpy.pi*2/wavefront.get_wavelength()
    distances_matrix  = numpy.exp(1.j * wavenumber *  r)


    fieldComplexAmplitude = numpy.dot(wavefront.get_complex_amplitude(),distances_matrix)

    return Wavefront1D(wavefront.get_wavelength(), ScaledArray.initialize_from_steps(fieldComplexAmplitude, \
                            detector_abscissas[0], detector_abscissas[1]-detector_abscissas[0] ))
Esempio n. 7
0
    def propagate_wavefront(cls,
                            wavefront,
                            propagation_distance,
                            magnification_x=1.0,
                            magnification_N=1.0):
        method = 0

        wavenumber = numpy.pi * 2 / wavefront.get_wavelength()

        x = wavefront.get_abscissas()

        if magnification_N != 1.0:
            npoints_exit = int(magnification_N * x.size)
        else:
            npoints_exit = x.size

        detector_abscissas = numpy.linspace(magnification_x * x[0],
                                            magnification_x * x[-1],
                                            npoints_exit)

        if method == 0:
            # calculate via loop pver detector coordinates
            x1 = wavefront.get_abscissas()
            x2 = detector_abscissas
            fieldComplexAmplitude = numpy.zeros_like(x2, dtype=complex)
            for ix, x in enumerate(x2):
                r = numpy.sqrt(
                    numpy.power(x1 - x, 2) +
                    numpy.power(propagation_distance, 2))
                distances_array = numpy.exp(1.j * wavenumber * r)
                fieldComplexAmplitude[ix] = (
                    wavefront.get_complex_amplitude() * distances_array).sum()
        elif method == 1:
            # calculate via outer product, it spreads over a lot of memory, but it is OK for 1D
            x1 = numpy.outer(wavefront.get_abscissas(),
                             numpy.ones(detector_abscissas.size))
            x2 = numpy.outer(numpy.ones(wavefront.size()), detector_abscissas)
            r = numpy.sqrt(
                numpy.power(x1 - x2, 2) + numpy.power(propagation_distance, 2))

            distances_matrix = numpy.exp(1.j * wavenumber * r)
            fieldComplexAmplitude = numpy.dot(
                wavefront.get_complex_amplitude(), distances_matrix)

        wavefront_out = GenericWavefront1D(
            wavefront.get_wavelength(),
            ScaledArray.initialize_from_steps(
                fieldComplexAmplitude, detector_abscissas[0],
                detector_abscissas[1] - detector_abscissas[0]))

        # added [email protected] 2018-03-23 to conserve energy - TODO: review method!
        # wavefront_out.rescale_amplitude( numpy.sqrt(wavefront.get_intensity().sum() /
        #                                             wavefront_out.get_intensity().sum()
        #                                             / magnification_x))

        wavefront_out.rescale_amplitude( (1/numpy.sqrt(1j*wavefront.get_wavelength()*propagation_distance))*(x1[1]-x1[0]) * \
                                         numpy.exp(1j * wavenumber * propagation_distance))

        return wavefront_out
Esempio n. 8
0
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)
Esempio n. 9
0
 def initialize_wavefront_from_range(cls, x_min=0.0, x_max=0.0, number_of_points=1000, wavelength=1e-10):
     return Wavefront1D(
         wavelength,
         ScaledArray.initialize_from_range(
             np_array=numpy.full(number_of_points, (1.0 + 0.0j), dtype=complex),
             min_scale_value=x_min,
             max_scale_value=x_max,
         ),
     )
Esempio n. 10
0
 def initialize_wavefront_from_steps(cls, x_start=0.0, x_step=0.0, number_of_points=1000, wavelength=1e-10):
     return Wavefront1D(
         wavelength,
         ScaledArray.initialize_from_steps(
             np_array=numpy.full(number_of_points, (1.0 + 0.0j), dtype=complex),
             initial_scale_value=x_start,
             scale_step=x_step,
         ),
     )
Esempio n. 11
0
    def initialize_wavefront_from_arrays(cls, x_array, y_array, wavelength=1e-10):
        if x_array.size != y_array.size:
            raise Exception("Unmatched shapes for x and y")

        return Wavefront1D(
            wavelength,
            ScaledArray.initialize_from_steps(
                np_array=y_array, initial_scale_value=x_array[0], scale_step=numpy.abs(x_array[1] - x_array[0])
            ),
        )
Esempio n. 12
0
def propagate_1D_integral(wavefront,
                          propagation_distance,
                          detector_abscissas=[None],
                          method=0,
                          magnification=1.0,
                          npoints_exit=None):
    """
    1D Fresnel-Kirchhoff propagator via integral implemented as sum
    :param wavefront:
    :param propagation_distance: propagation distance
    :param detector_abscissas: a numpy array with the abscissas at the image position. If undefined ([None])
                            it uses the same abscissas present in input wavefront.
    :param method: 0 (default_ makes a loop over detector coordinates, 1: makes matrices (outer products) so
                            it is more memory hungry.
    :param magnification: if detector_abscissas is [None], the detector abscissas range is the input
                            wavefront range times this magnification factor. Default =1
    :param npoints_exit: if detector_abscissas is [None], the number of points of detector abscissas.
                            Default=None meaning that the same number of points than wavefront are used.
    :return: a new 1D wavefront object with propagated wavefront
    """

    if detector_abscissas[0] == None:

        x = wavefront.get_abscissas()
        if npoints_exit is None:
            npoints_exit = x.size
        detector_abscissas = numpy.linspace(magnification * x[0],
                                            magnification * x[-1],
                                            npoints_exit)

    wavenumber = numpy.pi * 2 / wavefront.get_wavelength()
    if method == 0:
        x1 = wavefront.get_abscissas()
        x2 = detector_abscissas
        fieldComplexAmplitude = numpy.zeros_like(x2, dtype=complex)
        for ix, x in enumerate(x2):
            r = numpy.sqrt(
                numpy.power(x1 - x, 2) + numpy.power(propagation_distance, 2))
            distances_array = numpy.exp(1.j * wavenumber * r)
            fieldComplexAmplitude[ix] = (wavefront.get_complex_amplitude() *
                                         distances_array).sum()
    elif method == 1:
        # calculate via outer product, it spreads over a lot of memory, but it is OK for 1D
        x1 = numpy.outer(wavefront.get_abscissas(),
                         numpy.ones(detector_abscissas.size))
        x2 = numpy.outer(numpy.ones(wavefront.size()), detector_abscissas)
        r = numpy.sqrt(
            numpy.power(x1 - x2, 2) + numpy.power(propagation_distance, 2))
        distances_matrix = numpy.exp(1.j * wavenumber * r)
        fieldComplexAmplitude = numpy.dot(wavefront.get_complex_amplitude(),
                                          distances_matrix)

    return Wavefront1D(wavefront.get_wavelength(), ScaledArray.initialize_from_steps(fieldComplexAmplitude, \
                            detector_abscissas[0], detector_abscissas[1]-detector_abscissas[0] ))
Esempio n. 13
0
 def initialize_wavefront_from_steps(cls,
                                     x_start=0.0,
                                     x_step=0.0,
                                     number_of_points=1000,
                                     wavelength=1e-10):
     return Wavefront1D(
         wavelength,
         ScaledArray.initialize_from_steps(np_array=numpy.full(
             number_of_points, (1.0 + 0.0j), dtype=complex),
                                           initial_scale_value=x_start,
                                           scale_step=x_step))
Esempio n. 14
0
 def initialize_wavefront_from_range(cls,
                                     x_min=0.0,
                                     x_max=0.0,
                                     number_of_points=1000,
                                     wavelength=1e-10):
     return Wavefront1D(
         wavelength,
         ScaledArray.initialize_from_range(np_array=numpy.full(
             number_of_points, (1.0 + 0.0j), dtype=complex),
                                           min_scale_value=x_min,
                                           max_scale_value=x_max))
Esempio n. 15
0
    def initialize_wavefront_from_range(cls,
                                        x_min=0.0,
                                        x_max=0.0,
                                        number_of_points=1000,
                                        wavelength=1e-10,
                                        polarization=Polarization.SIGMA):

        sA = ScaledArray.initialize_from_range(np_array=numpy.full(
            number_of_points, (1.0 + 0.0j), dtype=complex),
                                               min_scale_value=x_min,
                                               max_scale_value=x_max)

        if ((polarization == Polarization.PI)
                or (polarization == Polarization.TOTAL)):
            sA_pi = ScaledArray.initialize_from_range(np_array=numpy.full(
                number_of_points, (0.0 + 0.0j), dtype=complex),
                                                      min_scale_value=x_min,
                                                      max_scale_value=x_max)
        else:
            sA_pi = None
        return GenericWavefront1D(wavelength, sA, sA_pi)
Esempio n. 16
0
    def initialize_wavefront_from_arrays(cls,
                                         x_array,
                                         y_array,
                                         y_array_pi=None,
                                         wavelength=1e-10):
        if x_array.size != y_array.size:
            raise Exception("Unmatched shapes for x and y")

        sA = ScaledArray.initialize_from_steps(
            np_array=y_array,
            initial_scale_value=x_array[0],
            scale_step=numpy.abs(x_array[1] - x_array[0]))

        if y_array_pi is not None:
            sA_pi = ScaledArray.initialize_from_steps(
                np_array=y_array_pi,
                initial_scale_value=x_array[0],
                scale_step=numpy.abs(x_array[1] - x_array[0]))
        else:
            sA_pi = None

        return GenericWavefront1D(wavelength, sA, sA_pi)
Esempio n. 17
0
    def initialize_wavefront_from_steps(cls,
                                        x_start=-1.0,
                                        x_step=0.002,
                                        number_of_points=1000,
                                        wavelength=1e-10,
                                        polarization=Polarization.SIGMA):

        sA = ScaledArray.initialize_from_steps(np_array=numpy.full(
            number_of_points, (1.0 + 0.0j), dtype=complex),
                                               initial_scale_value=x_start,
                                               scale_step=x_step)
        if ((polarization == Polarization.PI)
                or (polarization == Polarization.TOTAL)):
            sA_pi = ScaledArray.initialize_from_steps(
                np_array=numpy.full(number_of_points, (0.0 + 0.0j),
                                    dtype=complex),
                initial_scale_value=x_start,
                scale_step=x_step)
        else:
            sA_pi = None

        return GenericWavefront1D(wavelength, sA, sA_pi)
Esempio n. 18
0
    def propagate_wavefront(cls, wavefront, propagation_distance):

        fft_scale = numpy.fft.fftfreq(wavefront.size()) / wavefront.delta()

        fft = numpy.fft.fft(wavefront.get_complex_amplitude())
        fft *= numpy.exp((-1.0j) * numpy.pi * wavefront.get_wavelength() *
                         propagation_distance * fft_scale**2)
        ifft = numpy.fft.ifft(fft)

        return GenericWavefront1D(
            wavefront.get_wavelength(),
            ScaledArray.initialize_from_steps(ifft, wavefront.offset(),
                                              wavefront.delta()))
Esempio n. 19
0
def propagate_1D_fresnel(wavefront, propagation_distance):
    """
    1D Fresnel propagator using convolution via Fourier transform
    :param wavefront:
    :param propagation_distance: propagation distance
    :return: a new 1D wavefront object with propagated wavefront
    """
    fft_scale = numpy.fft.fftfreq(wavefront.size())/wavefront.delta()

    fft = numpy.fft.fft(wavefront.get_complex_amplitude())
    fft *= numpy.exp((-1.0j) * numpy.pi * wavefront.get_wavelength() * propagation_distance * fft_scale**2)
    ifft = numpy.fft.ifft(fft)

    return Wavefront1D(wavefront.get_wavelength(), ScaledArray.initialize_from_steps(ifft, wavefront.offset(), wavefront.delta()))
Esempio n. 20
0
    def initialize_wavefront_from_arrays(
        cls,
        x_array,
        y_array,
        wavelength=1e-10,
    ):
        if x_array.size != y_array.size:
            raise Exception("Unmatched shapes for x and y")

        return Wavefront1D(
            wavelength,
            ScaledArray.initialize_from_steps(
                np_array=y_array,
                initial_scale_value=x_array[0],
                scale_step=numpy.abs(x_array[1] - x_array[0])))
Esempio n. 21
0
def propagate_1D_fresnel_convolution(wavefront, propagation_distance):
    """
    1D Fresnel propagator using direct convolution
    :param wavefront:
    :param propagation_distance:
    :return:
    """

    # instead of numpy.convolve, this can be used:
    # from scipy.signal import fftconvolve

    kernel = numpy.exp(1j*2*numpy.pi/wavefront.get_wavelength() * wavefront.get_abscissas()**2 / 2 / propagation_distance)
    kernel *= numpy.exp(1j*2*numpy.pi/wavefront.get_wavelength() * propagation_distance)
    kernel /=  1j * wavefront.get_wavelength() * propagation_distance
    tmp = numpy.convolve(wavefront.get_complex_amplitude(),kernel,mode='same')

    return Wavefront1D(wavefront.get_wavelength(), ScaledArray.initialize_from_steps(tmp, wavefront.offset(), wavefront.delta()))
Esempio n. 22
0
    def propagate_wavefront(cls, wavefront, propagation_distance):

        kernel = numpy.exp(1j * 2 * numpy.pi / wavefront.get_wavelength() *
                           wavefront.get_abscissas()**2 / 2 /
                           propagation_distance)
        kernel *= numpy.exp(1j * 2 * numpy.pi / wavefront.get_wavelength() *
                            propagation_distance)
        kernel /= 1j * wavefront.get_wavelength() * propagation_distance
        tmp = numpy.convolve(wavefront.get_complex_amplitude(),
                             kernel,
                             mode='same')

        wavefront_out = GenericWavefront1D(
            wavefront.get_wavelength(),
            ScaledArray.initialize_from_steps(tmp, wavefront.offset(),
                                              wavefront.delta()))

        # added [email protected] 2018-03-23 to conserve energy - TODO: review method!
        wavefront_out.rescale_amplitude(
            numpy.sqrt(wavefront.get_intensity().sum() /
                       wavefront_out.get_intensity().sum()))

        return wavefront_out
Esempio n. 23
0
def propagate_1D_fresnel_convolution(wavefront, propagation_distance):
    """
    1D Fresnel propagator using direct convolution
    :param wavefront:
    :param propagation_distance:
    :return:
    """

    # instead of numpy.convolve, this can be used:
    # from scipy.signal import fftconvolve

    kernel = numpy.exp(1j * 2 * numpy.pi / wavefront.get_wavelength() *
                       wavefront.get_abscissas()**2 / 2 / propagation_distance)
    kernel *= numpy.exp(1j * 2 * numpy.pi / wavefront.get_wavelength() *
                        propagation_distance)
    kernel /= 1j * wavefront.get_wavelength() * propagation_distance
    tmp = numpy.convolve(wavefront.get_complex_amplitude(),
                         kernel,
                         mode='same')

    return Wavefront1D(
        wavefront.get_wavelength(),
        ScaledArray.initialize_from_steps(tmp, wavefront.offset(),
                                          wavefront.delta()))
Esempio n. 24
0
 def initialize_wavefront(cls, wavelength=1e-10, number_of_points=1000):
     return Wavefront1D(
         wavelength, ScaledArray.initialize(np_array=numpy.full(number_of_points, (1.0 + 0.0j), dtype=complex))
     )
Esempio n. 25
0
def calculate_function_average_value(function, x_min, x_max, sampling=100):
    sampled_function = ScaledArray.initialize_from_range(np.zeros(sampling), x_min, x_max)
    sampled_function.np_array = function(sampled_function.scale)

    return np.average(sampled_function.np_array)
Esempio n. 26
0
def propagate_1D_x_direction(calculation_parameters, input_parameters):

    scale_factor = 1.0

    shadow_oe = calculation_parameters.shadow_oe_end

    global_phase_shift_profile = None

    if shadow_oe._oe.F_MOVE == 1 and shadow_oe._oe.Y_ROT != 0.0:
        if input_parameters.ghy_calcType == 3 or input_parameters.ghy_calcType == 4:
            global_phase_shift_profile = calculation_parameters.w_mirror_lx
        elif input_parameters.ghy_calcType == 2:
            global_phase_shift_profile = ScaledArray.initialize_from_range(numpy.zeros(3), shadow_oe._oe.RWIDX2, shadow_oe._oe.RWIDX1)

        global_phase_shift_profile.set_values(global_phase_shift_profile.get_values() +
                                              global_phase_shift_profile.get_abscissas()*numpy.sin(numpy.radians(-shadow_oe._oe.Y_ROT)))
    elif input_parameters.ghy_calcType == 3 or input_parameters.ghy_calcType == 4:
        global_phase_shift_profile = calculation_parameters.w_mirror_lx

    if input_parameters.ghy_calcType == 3 or input_parameters.ghy_calcType == 4:
        rms_slope = hy_findrmsslopefromheight(global_phase_shift_profile)

        print("Using RMS slope = " + str(rms_slope))

        average_incident_angle = numpy.radians(90-calculation_parameters.shadow_oe_end._oe.T_INCIDENCE)*1e3
        average_reflection_angle = numpy.radians(90-calculation_parameters.shadow_oe_end._oe.T_REFLECTION)*1e3

        if calculation_parameters.beam_not_cut_in_x:
            dp_image = numpy.std(calculation_parameters.xx_focal_ray)/input_parameters.ghy_focallength
            dp_se = 2 * rms_slope * numpy.sin(average_incident_angle/1e3)	# different in x and z
            dp_error = calculation_parameters.gwavelength/2/(calculation_parameters.ghy_x_max-calculation_parameters.ghy_x_min)

            scale_factor = max(1, 5*min(dp_error/dp_image, dp_error/dp_se))

    # ------------------------------------------
    # far field calculation
    # ------------------------------------------
    if calculation_parameters.do_ff_x:
        focallength_ff = calculate_focal_length_ff(calculation_parameters.ghy_x_min,
                                                   calculation_parameters.ghy_x_max,
                                                   input_parameters.ghy_npeak,
                                                   calculation_parameters.gwavelength)

        if input_parameters.ghy_calcType == 3:
            if not (rms_slope == 0.0 or average_incident_angle == 0.0):
                focallength_ff = min(focallength_ff,(calculation_parameters.ghy_x_max-calculation_parameters.ghy_x_min) / 16 / rms_slope / numpy.sin(average_incident_angle / 1e3))#xshi changed
        elif input_parameters.ghy_calcType == 4:
            if not (rms_slope == 0.0 or average_incident_angle == 0.0):
                focallength_ff = min(focallength_ff,(calculation_parameters.ghy_x_max-calculation_parameters.ghy_x_min) / 8 / rms_slope / (numpy.sin(average_incident_angle / 1e3) + numpy.sin(average_reflection_angle / 1e3)))#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

        fftsize = int(scale_factor * calculate_fft_size(calculation_parameters.ghy_x_min,
                                                        calculation_parameters.ghy_x_max,
                                                        calculation_parameters.gwavelength,
                                                        focallength_ff,
                                                        input_parameters.ghy_fftnpts))
        
        print("FF: creating plane wave begin, fftsize = " +  str(fftsize))

        wavefront = Wavefront1D.initialize_wavefront_from_range(wavelength=calculation_parameters.gwavelength,
                                                                number_of_points=fftsize,
                                                                x_min=scale_factor * calculation_parameters.ghy_x_min,
                                                                x_max=scale_factor * calculation_parameters.ghy_x_max)

        if scale_factor == 1.0:
            try:
                wavefront.set_plane_wave_from_complex_amplitude(numpy.sqrt(calculation_parameters.wIray_x.interpolate_values(wavefront.get_abscissas())))
            except IndexError:
                raise Exception("Unexpected Error during interpolation: try reduce Number of bins for I(Sagittal) histogram")

        wavefront.apply_ideal_lens(focallength_ff)

        if input_parameters.ghy_calcType == 3 or \
                (input_parameters.ghy_calcType == 2 and not global_phase_shift_profile is None):
           wavefront.add_phase_shifts(get_mirror_phase_shift(wavefront.get_abscissas(),
                                                             calculation_parameters.gwavelength,
                                                             calculation_parameters.wangle_x,
                                                             calculation_parameters.wl_x,
                                                             global_phase_shift_profile))
        elif input_parameters.ghy_calcType == 4:
           wavefront.add_phase_shifts(get_grating_phase_shift(wavefront.get_abscissas(),
                                                              calculation_parameters.gwavelength,
                                                              calculation_parameters.wangle_x,
                                                              calculation_parameters.wangle_ref_x,
                                                              calculation_parameters.wl_x,
                                                              global_phase_shift_profile))

        print("calculated plane wave: begin FF propagation (distance = " +  str(focallength_ff) + ")")

        propagated_wavefront = propagator.propagate_1D_fresnel(wavefront, focallength_ff)

        print("dif_xp: begin calculation")

        shadow_oe = calculation_parameters.shadow_oe_end

        imagesize = min(abs(calculation_parameters.ghy_x_max), abs(calculation_parameters.ghy_x_min)) * 2
        # 2017-01 Luca Rebuffi
        imagesize = min(imagesize,
                        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 = max(imagesize, 8*(focallength_ff*numpy.tan(numpy.radians(numpy.abs(shadow_oe._oe.Y_ROT))) + numpy.abs(shadow_oe._oe.OFFX)))

        imagenpts = int(round(imagesize / propagated_wavefront.delta() / 2) * 2 + 1)

        dif_xp = ScaledArray.initialize_from_range(numpy.ones(propagated_wavefront.size()),
                                                   -(imagenpts - 1) / 2 * propagated_wavefront.delta(),
                                                   (imagenpts - 1) / 2 * propagated_wavefront.delta())


        dif_xp.np_array = numpy.absolute(propagated_wavefront.get_interpolated_complex_amplitudes(dif_xp.scale))**2

        dif_xp.set_scale_from_range(-(imagenpts - 1) / 2 * propagated_wavefront.delta() / focallength_ff,
                                    (imagenpts - 1) / 2 * propagated_wavefront.delta() / focallength_ff)

        calculation_parameters.dif_xp = dif_xp

    # ------------------------------------------
    # near field calculation
    # ------------------------------------------
    if input_parameters.ghy_nf >= 1 and input_parameters.ghy_calcType > 1:  # near field calculation
        focallength_nf = input_parameters.ghy_focallength

        fftsize = int(scale_factor * calculate_fft_size(calculation_parameters.ghy_x_min,
                                                        calculation_parameters.ghy_x_max,
                                                        calculation_parameters.gwavelength,
                                                        numpy.abs(focallength_nf),
                                                        input_parameters.ghy_fftnpts))

        print("NF: creating plane wave begin, fftsize = " +  str(fftsize))

        wavefront = Wavefront1D.initialize_wavefront_from_range(wavelength=calculation_parameters.gwavelength,
                                                                number_of_points=fftsize,
                                                                x_min=scale_factor*calculation_parameters.ghy_x_min,
                                                                x_max=scale_factor*calculation_parameters.ghy_x_max)

        if scale_factor == 1.0:
            try:
                wavefront.set_plane_wave_from_complex_amplitude(numpy.sqrt(calculation_parameters.wIray_x.interpolate_values(wavefront.get_abscissas())))
            except IndexError:
                raise Exception("Unexpected Error during interpolation: try reduce Number of bins for I(Sagittal) histogram")

        wavefront.apply_ideal_lens(focallength_nf)

        if input_parameters.ghy_calcType == 3 or \
                (input_parameters.ghy_calcType == 2 and not global_phase_shift_profile is None):
           wavefront.add_phase_shifts(get_mirror_phase_shift(wavefront.get_abscissas(),
                                                             calculation_parameters.gwavelength,
                                                             calculation_parameters.wangle_x,
                                                             calculation_parameters.wl_x,
                                                             global_phase_shift_profile))
        elif input_parameters.ghy_calcType == 4:
           wavefront.add_phase_shifts(get_grating_phase_shift(wavefront.get_abscissas(),
                                                              calculation_parameters.gwavelength,
                                                              calculation_parameters.wangle_x,
                                                              calculation_parameters.wangle_ref_x,
                                                              calculation_parameters.wl_x,
                                                              global_phase_shift_profile))

        print("calculated plane wave: begin NF propagation (distance = " + str(input_parameters.ghy_distance) + ")")

        propagated_wavefront = propagator.propagate_1D_fresnel(wavefront, input_parameters.ghy_distance)

        # ghy_npeak in the wavefront propagation image
        imagesize = (input_parameters.ghy_npeak * 2 * 0.88 * calculation_parameters.gwavelength * numpy.abs(focallength_nf) / abs(calculation_parameters.ghy_x_max - calculation_parameters.ghy_x_min))
        imagesize = max(imagesize,
                        2 * abs((calculation_parameters.ghy_x_max - calculation_parameters.ghy_x_min) * (input_parameters.ghy_distance - numpy.abs(focallength_nf))) / numpy.abs(focallength_nf))

        if input_parameters.ghy_calcType == 3:
            imagesize = max(imagesize,
                            16 * rms_slope * numpy.abs(focallength_nf) * numpy.sin(average_incident_angle / 1e3))
        elif input_parameters.ghy_calcType == 4:
            imagesize = max(imagesize,
                            8 * rms_slope * numpy.abs(focallength_nf) * (numpy.sin(average_incident_angle / 1e3) + numpy.sin(average_reflection_angle / 1e3)))

        # TODO: this is a patch: to be rewritten
        if shadow_oe._oe.F_MOVE==1 and not shadow_oe._oe.Y_ROT==0:
            imagesize = max(imagesize, 8*(input_parameters.ghy_distance*numpy.tan(numpy.radians(numpy.abs(shadow_oe._oe.Y_ROT))) + numpy.abs(shadow_oe._oe.OFFX)))

        imagenpts = int(round(imagesize / propagated_wavefront.delta() / 2) * 2 + 1)

        print("dif_x: begin calculation")

        dif_x = ScaledArray.initialize_from_range(numpy.ones(imagenpts),
                                                  -(imagenpts - 1) / 2 * propagated_wavefront.delta(),
                                                  (imagenpts - 1) / 2 * propagated_wavefront.delta())

        dif_x.np_array *= numpy.absolute(propagated_wavefront.get_interpolated_complex_amplitudes(dif_x.scale))**2

        calculation_parameters.dif_x = dif_x
Esempio n. 27
0
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
    def test_ScaledArray(self,do_plot=do_plot):



        #
        # ScaledArray.initialize + set_scale_from_steps
        #
        test_array = numpy.arange(15.0, 18.8, 0.2)


        print("\nTesting ScaledArray.initialize + set_scale_from_steps...")


        scaled_array = ScaledArray.initialize(test_array)
        scaled_array.set_scale_from_steps(test_array[0],0.2)

        print("Using array: ",test_array)
        print("Stored array: ",scaled_array.get_values())

        print("Using array: ",test_array)
        print("Stored abscissas: ",scaled_array.get_abscissas())

        numpy.testing.assert_almost_equal(test_array,scaled_array.get_values(),11)
        numpy.testing.assert_almost_equal(test_array,scaled_array.get_abscissas(),11)
        self.assertAlmostEqual(0.2,scaled_array.delta(),11)
        self.assertAlmostEqual(15.0,scaled_array.offset(),11)

        x_in =   (18.80,16.22,22.35)
        x_good = (18.80,16.22,18.8)

        for i,x in enumerate(x_in):
            print("interpolated at %3.2f is: %3.2f (must give %3.2f)"%( x,scaled_array.interpolate_value(x), x_good[i] ))
            self.assertAlmostEqual(scaled_array.interpolate_value(x), x_good[i], 2)


        #
        # ScaledArray.initialize + set_scale_from_range ; interpolate vectorized
        #
        print("\nTesting ScaledArray.initialize + set_scale_from_range ; interpolate vectorized...")
        scaled_array = ScaledArray.initialize(test_array)
        scaled_array.set_scale_from_range(test_array[0],test_array[-1])

        x_in =   (18.80,16.22,22.35)
        x_good = (18.80,16.22,18.8)

        for i,x in enumerate(x_in):
            print("interpolated at %3.2f is: %3.2f (must give %3.2f)"%( x,scaled_array.interpolate_value(x), x_good[i] ))
            self.assertAlmostEqual(scaled_array.interpolate_value(x), x_good[i], 2)


        #
        # ScaledArray.initialize_from_steps
        #
        print("\nTesting ScaledArray.initialize_from_steps...")
        scaled_array = ScaledArray.initialize_from_steps(test_array, test_array[0], 0.2)

        x_in =   (18.80,16.22,22.35)
        x_good = (18.80,16.22,18.8)

        for i,x in enumerate(x_in):
            print("interpolated at %3.2f is: %3.2f (must give %3.2f)"%( x,scaled_array.interpolate_value(x), x_good[i] ))
            self.assertAlmostEqual(scaled_array.interpolate_value(x), x_good[i], 2)

        #
        # ScaledArray.initialize_from_steps
        #
        print("\nTesting ScaledArray.initialize_from_range...")
        scaled_array = ScaledArray.initialize_from_range(test_array,test_array[0], test_array[-1])

        x_in =   (18.80,16.22,22.35)
        x_good = (18.80,16.22,18.8)

        for i,x in enumerate(x_in):
            print("interpolated at %3.2f is: %3.2f (must give %3.2f)"%( x,scaled_array.interpolate_value(x), x_good[i] ))
            self.assertAlmostEqual(scaled_array.interpolate_value(x), x_good[i], 2)


        #
        # interpolator
        #
        print("\nTesting interpolator...")
        x = numpy.arange(-5.0, 18.8, 3)
        y = x**2

        scaled_array = ScaledArray.initialize_from_range(y,x[0],x[-1])

        print("for interpolation; x=",x)
        print("for interpolation; offset, delta:=",scaled_array.offset(),scaled_array.delta())
        print("for interpolation; abscissas:=",scaled_array.get_abscissas())

        x1 = numpy.concatenate( ( numpy.arange(-6, -4, 0.1) , [0], numpy.arange(11, 20.0, 0.1) ) )

        y1 = scaled_array.interpolate_values(x1)

        if do_plot:
            from srxraylib.plot.gol import plot
            plot(x,y,x1,y1,legend=["Data",'Interpolated'],legend_position=[0.4,0.8],
                 marker=['','o'],linestyle=['-',''],xrange=[-6,21],yrange=[-5,375])

        for i in range(len(x1)):
            y2 = x1[i]**2

            if x1[i] <= x[0]:
                y2 = y[0]

            if x1[i] >= x[-1]:
                y2 = y[-1]

            print("   interpolated at x=%g is: %g (expected: %g)"%(x1[i],y1[i],y2))
            self.assertAlmostEqual(1e-3*y1[i], 1e-3*y2, 2)


        # interpolate on same grid
        print("\nTesting interpolation on the same grid...")



        y1 = scaled_array.interpolate_values(scaled_array.get_abscissas())
        if do_plot:
            from srxraylib.plot.gol import plot
            plot(scaled_array.get_abscissas(),scaled_array.get_values(),
                 scaled_array.get_abscissas(),y1,legend=["Data",'Interpolated on same grid'],legend_position=[0.4,0.8],
                 marker=['','o'],linestyle=['-',''])

        numpy.testing.assert_almost_equal(scaled_array.get_values(),y1,5)
Esempio n. 29
0
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))
Esempio n. 30
0
 def initialize_wavefront(cls, wavelength=1e-10, number_of_points=1000):
     return Wavefront1D(
         wavelength,
         ScaledArray.initialize(np_array=numpy.full(
             number_of_points, (1.0 + 0.0j), dtype=complex)))