def __init__(self, power, FWHM_ps, center_wavelength_nm, time_window_ps = 10., frep_MHz = 100., NPTS = 2**10, GDD = 0, TOD = 0, chirp2 = 0, chirp3 = 0, power_is_avg = False): """Generate sinc pulse A(t) = sqrt(peak_power[W]) * sin(t/T0)/(t/T0) centered at wavelength center_wavelength_nm (nm). The width is given by FWHM_ps, which is the full-width-at-half-maximum in picoseconds. T0 is equal th FWHM/3.7909885. time_window_ps sets temporal grid size. Optional GDD and TOD are in ps^2 and ps^3.""" Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS) # make sure we weren't passed mks units assert (center_wavelength_nm > 1.0) assert (time_window_ps > 1.0 ) self.set_center_wavelength_nm(center_wavelength_nm) self.set_time_window_ps(time_window_ps) T0_ps = FWHM_ps/3.7909885 ### Generate pulse if not power_is_avg: # numpy.sinc is sin(pi*x)/(pi*x), so we divide by pi self.set_AT( np.sqrt(power) * np.sinc(self.T_ps/(T0_ps*np.pi)) ) else: self.set_AT( 1 / np.sinc(np.pi * self.T_ps/(T0_ps*np.pi)) ) self.set_AT(self.AT * np.sqrt( power / ( frep_MHz*1.0e6 * self.calc_epp()) )) self.chirp_pulse_W(GDD, TOD) self.chirp_pulse_T(chirp2, chirp3, T0_ps)
def __init__(self, power, FWHM_ps, center_wavelength_nm, time_window_ps = 10., frep_MHz = 100., NPTS = 2**10, GDD = 0, TOD = 0, chirp2 = 0, chirp3 = 0, power_is_avg = False): """Generate sinc pulse A(t) = sqrt(peak_power[W]) * sin(t/T0)/(t/T0) centered at wavelength center_wavelength_nm (nm). The width is given by FWHM_ps, which is the full-width-at-half-maximum in picoseconds. T0 is equal th FWHM/3.7909885. time_window_ps sets temporal grid size. Optional GDD and TOD are in ps^2 and ps^3.""" Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS) # make sure we weren't passed mks units assert (center_wavelength_nm > 1.0) assert (time_window_ps > 1.0 ) self.set_center_wavelength_nm(center_wavelength_nm) self.set_time_window_ps(time_window_ps) T0_ps = FWHM_ps/3.7909885 ### Generate pulse if not power_is_avg: # numpy.sinc is sin(pi*x)/(pi*x), so we divide by pi self.set_AT( np.sqrt(power) * np.sinc(self.T_ps/(T0_ps*np.pi)) ) else: self.set_AT( 1 / np.sinc(np.pi * self.T_ps/(T0_ps*np.pi)) ) self.set_AT(self.AT * np.sqrt( power / ( frep_MHz*1.0e6 * self.calc_epp()) )) self.chirp_pulse_W(GDD, TOD) self.chirp_pulse_T(chirp2, chirp3, T0_ps)
def __init__(self, avg_power, center_wavelength_nm, time_window_ps = 10.0, NPTS = 2**8,offset_from_center_THz = None): Pulse.__init__(self, n = NPTS) # make sure we weren't passed mks units assert (center_wavelength_nm > 1.0) assert (time_window_ps > 1.0 ) if offset_from_center_THz is None: self.set_center_wavelength_nm(center_wavelength_nm) self.set_time_window_ps(time_window_ps) # Set the time domain to be CW, which should give us a delta function in # frequency. Then normalize that delta function (in frequency space) to # the average power. Note that frep does not factor in here. self.set_AT(np.ones(self.NPTS,)) self.set_AW(self.AW * np.sqrt(avg_power) / sum(abs(self.AW)) ) else: dF = 1.0/time_window_ps n_offset = np.round( offset_from_center_THz/dF) center_THz = self._c_nmps/center_wavelength_nm -\ n_offset * dF center_nm = self._c_nmps / center_THz self.set_time_window_ps(time_window_ps) self.set_center_wavelength_nm(center_nm) aws = np.zeros((self.NPTS, )) aws[int(self.NPTS/2.0) + int(n_offset) ] = 1.0 *np.sqrt(avg_power) self.set_AW(aws)
def __init__(self, power, T0_ps, center_wavelength_nm, time_window_ps = 10., frep_MHz = 100., NPTS = 2**10, GDD = 0, TOD = 0, chirp2 = 0, chirp3 = 0, power_is_avg = False): """Generate a squared-hyperbolic secant "sech" pulse A(t) = sqrt(P0 [W]) * sech(t/T0 [ps]) centered at wavelength center_wavelength_nm (nm). time_window (ps) sets temporal grid size. Optional GDD and TOD are in ps^2 and ps^3. Note: The full-width-at-half-maximum (FWHM) is given by T0_ps * 1.76 """ Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS) # make sure we weren't passed mks units assert (center_wavelength_nm > 1.0) assert (time_window_ps > 1.0 ) self.set_center_wavelength_nm(center_wavelength_nm) self.set_time_window_ps(time_window_ps) ### Generate pulse if not power_is_avg: # from https://www.rp-photonics.com/sech2_shaped_pulses.html self.set_AT( np.sqrt(power)/np.cosh(self.T_ps/T0_ps) ) else: self.set_AT( 1 / np.cosh(self.T_ps/T0_ps) ) self.set_AT(self.AT * np.sqrt( power / ( frep_MHz*1.0e6 * self.calc_epp()) )) self.chirp_pulse_W(GDD, TOD) self.chirp_pulse_T(chirp2, chirp3, T0_ps)
def __init__(self, power, T0_ps, center_wavelength_nm, time_window_ps = 10., frep_MHz = 100., NPTS = 2**10, GDD = 0, TOD = 0, chirp2 = 0, chirp3 = 0, power_is_avg = False): """Generate Gaussian pulse A(t) = sqrt(peak_power[W]) * exp( -(t/T0 [ps])^2 / 2 ) centered at wavelength center_wavelength_nm (nm). time_window (ps) sets temporal grid size. Optional GDD and TOD are in ps^2 and ps^3. Note: For this definition of a Gaussian pulse, T0_ps is the full-width-at-half-maximum (FWHM) of the pulse. """ Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS) # make sure we weren't passed mks units assert (center_wavelength_nm > 1.0) assert (time_window_ps > 1.0 ) self.set_center_wavelength_nm(center_wavelength_nm) self.set_time_window_ps(time_window_ps) GDD = GDD TOD = TOD # from https://www.rp-photonics.com/gaussian_pulses.html self.set_AT( np.sqrt(power) * np.exp(-2.77*0.5*self.T_ps**2/(T0_ps**2)) ) # input field (W^0.5) if power_is_avg: self.set_AT(self.AT * np.sqrt( power / ( frep_MHz*1.0e6 * self.calc_epp()) )) self.chirp_pulse_W(GDD, TOD) self.chirp_pulse_T(chirp2, chirp3, T0_ps)
def __init__(self, avg_power, center_wavelength_nm, time_window_ps = 10.0, NPTS = 2**8,offset_from_center_THz = None): Pulse.__init__(self, n = NPTS) # make sure we weren't passed mks units assert (center_wavelength_nm > 1.0) assert (time_window_ps > 1.0 ) if offset_from_center_THz is None: self.set_center_wavelength_nm(center_wavelength_nm) self.set_time_window_ps(time_window_ps) # Set the time domain to be CW, which should give us a delta function in # frequency. Then normalize that delta function (in frequency space) to # the average power. Note that frep does not factor in here. self.set_AT(np.ones(self.NPTS,)) self.set_AW(self.AW * np.sqrt(avg_power) / sum(abs(self.AW)) ) else: dF = 1.0/time_window_ps n_offset = np.round( offset_from_center_THz/dF) center_THz = self._c_nmps/center_wavelength_nm -\ n_offset * dF center_nm = self._c_nmps / center_THz self.set_time_window_ps(time_window_ps) self.set_center_wavelength_nm(center_nm) aws = np.zeros((self.NPTS, )) aws[int(self.NPTS/2.0) + int(n_offset) ] = 1.0 *np.sqrt(avg_power) self.set_AW(aws)
def __init__(self, center_wavelength_nm, time_window_ps = 10., NPTS = 2**8, frep_MHz = None): Pulse.__init__(self, n = NPTS, frep_MHz = frep_MHz) self.set_center_wavelength_nm(center_wavelength_nm) self.set_time_window_ps(time_window_ps) self.set_AW( 1e-30 * np.ones(self.NPTS) * np.exp(1j * 2 * np.pi * 1j * np.random.rand(self.NPTS)))
def __init__(self, center_wavelength_nm, time_window_ps = 10., NPTS = 2**8, frep_MHz = None): Pulse.__init__(self, n = NPTS, frep_MHz = frep_MHz) self.set_center_wavelength_nm(center_wavelength_nm) self.set_time_window_ps(time_window_ps) self.set_AW( 1e-30 * np.ones(self.NPTS) * np.exp(1j * 2 * np.pi * 1j * np.random.rand(self.NPTS)))
def __init__(self, time_window_ps, center_wavelength_nm, power,frep_MHz = 100., NPTS = 2**10, power_is_avg = False, fileloc = '', flip_phase = True): """Generate pulse from FROG data. Grid is centered at wavelength center_wavelength_nm (nm), but pulse properties are loaded from data file. If flip_phase is true, all phase is multiplied by -1 [useful for correcting direction of time ambiguity]. time_window (ps) sets temporal grid size. power sets the pulse energy: if power_is_epp is True then the number is pulse energy [J] if power_is_epp is False then the power is average power [W], and is multiplied by frep to calculate pulse energy""" Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS) try: self.fileloc = fileloc # make sure we weren't passed mks units assert (center_wavelength_nm > 1.0) assert (time_window_ps > 1.0 ) self.set_time_window_ps(time_window_ps) self.set_center_wavelength_nm(center_wavelength_nm) # reference wavelength (nm) # power -> EPP if power_is_avg: power = power / self.frep_mks # Read in retrieved FROG trace frog_data = np.genfromtxt(self.fileloc) wavelengths = frog_data[:,0]# (nm) intensity = frog_data[:,1]# (arb. units) phase = frog_data[:,2]# (radians) if flip_phase: phase = -1 * phase pulse_envelope = interp1d(wavelengths, intensity, kind='linear', bounds_error=False,fill_value=0) phase_envelope = interp1d(wavelengths, phase, kind='linear', bounds_error=False,fill_value=0) gridded_intensity = pulse_envelope(self.wl_nm) gridded_phase = phase_envelope(self.wl_nm) # Calculate time domain complex electric field A self.set_AW(gridded_intensity*np.exp(1j*gridded_phase)) # Calculate normalization factor to achieve requested # pulse energy e_scale = np.sqrt(power / self.calc_epp() ) self.set_AT(self.AT * e_scale ) except IOError: print ('File not found.' )
def __init__(self, time_window_ps, center_wavelength_nm, power,frep_MHz = 100., NPTS = 2**10, power_is_avg = False, fileloc = '', flip_phase = True): """Generate pulse from FROG data. Grid is centered at wavelength center_wavelength_nm (nm), but pulse properties are loaded from data file. If flip_phase is true, all phase is multiplied by -1 [useful for correcting direction of time ambiguity]. time_window (ps) sets temporal grid size. power sets the pulse energy: if power_is_epp is True then the number is pulse energy [J] if power_is_epp is False then the power is average power [W], and is multiplied by frep to calculate pulse energy""" Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS) try: self.fileloc = fileloc # make sure we weren't passed mks units assert (center_wavelength_nm > 1.0) assert (time_window_ps > 1.0 ) self.set_time_window_ps(time_window_ps) self.set_center_wavelength_nm(center_wavelength_nm) # reference wavelength (nm) # power -> EPP if power_is_avg: power = power / self.frep_mks # Read in retrieved FROG trace frog_data = np.genfromtxt(self.fileloc) wavelengths = frog_data[:,0]# (nm) intensity = frog_data[:,1]# (arb. units) phase = frog_data[:,2]# (radians) if flip_phase: phase = -1 * phase pulse_envelope = interp1d(wavelengths, intensity, kind='linear', bounds_error=False,fill_value=0) phase_envelope = interp1d(wavelengths, phase, kind='linear', bounds_error=False,fill_value=0) gridded_intensity = pulse_envelope(self.wl_nm) gridded_phase = phase_envelope(self.wl_nm) # Calculate time domain complex electric field A self.set_AW(gridded_intensity*np.exp(1j*gridded_phase)) # Calculate normalization factor to achieve requested # pulse energy e_scale = np.sqrt(power / self.calc_epp() ) self.set_AT(self.AT * e_scale ) except IOError: print 'File not found.'
def filter(self, pulse_in, band, fiber, output_power=None): self.band0 = band / (2 * np.sqrt(np.log(2))) pulse_out = Pulse() pulse_out.clone_pulse(pulse_in) self.setup_fftw(pulse_in, fiber, output_power, raman_plots=False) self.T_BP = np.exp(-(self.wl_nm - self.center_wavelength_nm)**2 / 2 / self.band0**2) pulse_out.set_AW(pulse_out.AW * self.T_BP) return pulse_out
def __init__(self, power, T0_ps, center_wavelength_nm, time_window_ps = 10., frep_MHz = 100., NPTS = 2**10, GDD = 0, TOD = 0, chirp2 = 0, chirp3 = 0, power_is_avg = False): """Generate Gaussian pulse A(t) = sqrt(peak_power[W]) * exp( -(t/T0 [ps])^2 / 2 ) centered at wavelength center_wavelength_nm (nm). time_window (ps) sets temporal grid size. Optional GDD and TOD are in ps^2 and ps^3.""" Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS) # make sure we weren't passed mks units assert (center_wavelength_nm > 1.0) assert (time_window_ps > 1.0 ) self.set_center_wavelength_nm(center_wavelength_nm) self.set_time_window_ps(time_window_ps) GDD = GDD TOD = TOD self.set_AT( np.sqrt(power) * np.exp(-2.77*self.T_ps**2/(T0_ps**2)) ) # input field (W^0.5) if power_is_avg: self.set_AT(self.AT * np.sqrt( power / ( frep_MHz*1.0e6 * self.calc_epp()) )) self.chirp_pulse_W(GDD, TOD) self.chirp_pulse_T(chirp2, chirp3, T0_ps)
def __init__(self, power, T0_ps, center_wavelength_nm, time_window_ps = 10., frep_MHz = 100., NPTS = 2**10, GDD = 0, TOD = 0, chirp2 = 0, chirp3 = 0, power_is_avg = False): """Generate sech pulse A(t) = sqrt(P0 [W]) * sech(t/T0 [ps]) centered at wavelength center_wavelength_nm (nm). time_window (ps) sets temporal grid size. Optional GDD and TOD are in ps^2 and ps^3.""" Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS) # make sure we weren't passed mks units assert (center_wavelength_nm > 1.0) assert (time_window_ps > 1.0 ) self.set_center_wavelength_nm(center_wavelength_nm) self.set_time_window_ps(time_window_ps) ### Generate pulse if not power_is_avg: self.set_AT( np.sqrt(power)/np.cosh(self.T_ps/T0_ps) ) else: self.set_AT( 1 / np.cosh(self.T_ps/T0_ps) ) self.set_AT(self.AT * np.sqrt( power / ( frep_MHz*1.0e6 * self.calc_epp()) )) self.chirp_pulse_W(GDD, TOD) self.chirp_pulse_T(chirp2, chirp3, T0_ps)
def get_run(self, run_num=None, z_num=None): """ Return tuple of (pump, signal, idler) pulses for run # n at z index z_num . By default, returns last z step of last run.""" if run_num is None: run_num = self.run_ctr - 1 if run_num < 0 or run_num >= self.run_ctr: raise IndexError(str(run_num) + ' not a valid run index.') if z_num is None: z_num = -1 run = self.root_name + '/run' + str(run_num) # Read in and generate pump pulse pump_field = self.tables_file.get_node(run + '/pump')[:, z_num] pump_Twind = self.tables_file.get_node(run + '/pump_Twind')[0] pump_center = self.tables_file.get_node(run + '/pump_center_nm')[0] p = Pulse() p.set_NPTS(len(pump_field)) p.set_center_wavelength_nm(pump_center) p.set_time_window_ps(pump_Twind) p.set_AW(pump_field) p.set_frep_MHz(self.frep_Hz * 1.0e-6) # Read in and generate signal pulse sgnl_field = self.tables_file.get_node(run + '/sgnl')[:, z_num] sgnl_Twind = self.tables_file.get_node(run + '/sgnl_Twind')[0] sgnl_center = self.tables_file.get_node(run + '/sgnl_center_nm')[0] s = Pulse() s.set_NPTS(len(sgnl_field)) s.set_center_wavelength_nm(sgnl_center) s.set_time_window_ps(sgnl_Twind) s.set_AW(sgnl_field) s.set_frep_MHz(self.frep_Hz * 1.0e-6) # Read in and generate idler pulse idlr_field = self.tables_file.get_node(run + '/idlr')[:, z_num] idlr_Twind = self.tables_file.get_node(run + '/idlr_Twind')[0] idlr_center = self.tables_file.get_node(run + '/idlr_center_nm')[0] i = Pulse() i.set_NPTS(len(idlr_field)) i.set_center_wavelength_nm(idlr_center) i.set_time_window_ps(idlr_Twind) i.set_AW(idlr_field) i.set_frep_MHz(self.frep_Hz * 1.0e-6) return (p, s, i)
def get_run(self, run_num = None, z_num = None): """ Return tuple of (pump, signal, idler) pulses for run # n at z index z_num . By default, returns last z step of last run.""" if run_num is None: run_num = self.run_ctr - 1 if run_num < 0 or run_num >= self.run_ctr: raise IndexError(str(run_num)+' not a valid run index.') if z_num is None: z_num = -1 run = self.root_name+'/run'+str(run_num) # Read in and generate pump pulse pump_field = self.tables_file.get_node(run+'/pump')[:,z_num] pump_Twind = self.tables_file.get_node(run+'/pump_Twind')[0] pump_center = self.tables_file.get_node(run+'/pump_center_nm')[0] p = Pulse() p.set_NPTS(len(pump_field)) p.set_center_wavelength_nm(pump_center) p.set_time_window_ps(pump_Twind) p.set_AW(pump_field) p.set_frep_MHz(self.frep_Hz * 1.0e-6) # Read in and generate signal pulse sgnl_field = self.tables_file.get_node(run+'/sgnl')[:,z_num] sgnl_Twind = self.tables_file.get_node(run+'/sgnl_Twind')[0] sgnl_center = self.tables_file.get_node(run+'/sgnl_center_nm')[0] s = Pulse() s.set_NPTS(len(sgnl_field)) s.set_center_wavelength_nm(sgnl_center) s.set_time_window_ps(sgnl_Twind) s.set_AW(sgnl_field) s.set_frep_MHz(self.frep_Hz * 1.0e-6) # Read in and generate idler pulse idlr_field = self.tables_file.get_node(run+'/idlr')[:,z_num] idlr_Twind = self.tables_file.get_node(run+'/idlr_Twind')[0] idlr_center = self.tables_file.get_node(run+'/idlr_center_nm')[0] i = Pulse() i.set_NPTS(len(idlr_field)) i.set_center_wavelength_nm(idlr_center) i.set_time_window_ps(idlr_Twind) i.set_AW(idlr_field) i.set_frep_MHz(self.frep_Hz * 1.0e-6) return (p, s, i)
def propagate(self, pulse_in, fiber, n_steps, output_power=None, reload_fiber_each_step=False): """ This is the main user-facing function that allows a pulse to be propagated along a fiber (or other nonlinear medium). Parameters ---------- pulse_in : pulse object this is an instance of the :class:`pynlo.light.PulseBase.Pulse` class. fiber : fiber object this is an instance of the :class:`pynlo.media.fibers.fiber.FiberInstance` class. n_steps : int the number of steps requested in the integrator output. Note: the RK4IP integrator uses an adaptive step size. It should pick the correct step size automatically, so setting n_steps should not affect the accuracy, just the number of points that are returned by this funciton. output_power : This parameter is a mystery reload_fiber_each_step : boolean This flag determines if the fiber parameters should be reloaded every step. It is necessary if the fiber dispersion or gamma changes along the fiber length. :func:`pynlo.media.fibers.fiber.FiberInstance.set_dispersion_function` and :func:`pynlo.media.fibers.fiber.FiberInstance.set_dispersion_function` should be used to specify how the dispersion and gamma change with the fiber length Returns ------- z_positions : array of float an array of z-positions along the fiber (in meters) AW : 2D array of complex128 A 2D numpy array corresponding to the intensities in each *frequency* bin for each step in the z-direction of the fiber. AT : 2D array of complex128 A 2D numpy array corresponding to the intensities in each *time* bin for each step in the z-direction of the fiber. pulse_out : PulseBase object the pulse after it has propagated through the fiber. This object is suitable for propagation through the next fiber! """ n_steps = int(n_steps) # Copy parameters from pulse and fiber into class-wide variables z_positions = np.linspace(0, fiber.length, n_steps + 1) if n_steps == 1: delta_z = fiber.length else: delta_z = z_positions[1] - z_positions[0] AW = np.complex64(np.zeros((pulse_in.NPTS, n_steps))) AT = np.complex64(np.copy(AW)) #print ("Pulse energy before", fiber.fibertype,":", \ # 1e9 * pulse_in.calc_epp(), 'nJ' ) pulse_out = Pulse() pulse_out.clone_pulse(pulse_in) self.setup_fftw(pulse_in, fiber, output_power, raman_plots=False) self.load_fiber_parameters(pulse_in, fiber, output_power) for i in range(n_steps): #print ("Step:", i, "Distance remaining:", fiber.length * (1 - np.float(i)/n_steps) ) if reload_fiber_each_step: self.load_fiber_parameters(pulse_in, fiber, output_power, z=i * delta_z) self.integrate_over_dz(delta_z) AW[:, i] = self.conditional_ifftshift(self.FFT_t_2(self.A)) AT[:, i] = self.conditional_ifftshift(self.A) pulse_out.set_AT(self.conditional_ifftshift(self.A)) #print ("Pulse energy after:", \ # 1e9 * pulse_out.calc_epp(), 'nJ' ) pulse_out.set_AT(self.conditional_ifftshift(self.A)) #print ( "Pulse energy after", fiber.fibertype,":", \ # 1e9 * pulse_out.calc_epp(), 'nJ' ) # print "alpha out:",self.alpha self.cleanup() return z_positions, AW, AT, pulse_out
roundtrip = 20 for i in range(roundtrip): print('正在运行第%s次循环,共%s循环' % (i + 1, roundtrip)) Et_1.append(evol.propagate(Et_8[i], Fiber1, n_steps=Steps)[3]) # PulseTemp = Pulse() # PulseTemp.clone_pulse(Et) # PulseTemp.set_AT(Et_1[i]) Et_2.append(evol.filter(Et_1[i], band, Fiber1)) Et_3.append(evol.propagate(Et_2[i], Fiber2, n_steps=Steps)[3]) Et_4.append(evol.propagate(Et_3[i], FiberYsfLo, n_steps=Steps)[3]) Et_5.append(evol.propagate(Et_4[i], Fiber3, n_steps=Steps)[3]) # NALM #clock Eclock0 = Pulse() Eclock0.clone_pulse(Et_5[i]) Eclock0.set_AT(np.sqrt(CRatio) * Eclock0.AT) Eclock1 = evol.propagate(Eclock0, FiberSmf1, n_steps=Steps)[3] Eclock2 = evol.propagate(Eclock1, FiberYsfHi, n_steps=Steps)[3] Eclock3 = evol.propagate(Eclock2, FiberSmf2, n_steps=Steps)[3] #anclock Eanclock0 = Pulse() Eanclock0.clone_pulse(Et_5[i]) Eanclock0.set_AT(1j * np.sqrt(1 - CRatio) * Eanclock0.AT) Eanclock1 = evol.propagate(Eanclock0, FiberSmf2, n_steps=Steps)[3] Eanclock2 = evol.propagate(Eanclock1, FiberYsfHi, n_steps=Steps)[3] Eanclock3 = evol.propagate(Eanclock2, FiberSmf1, n_steps=Steps)[3] E6 = Pulse() E6.clone_pulse(Et_5[i])