def test_make_empty_periodogram(self): ps = Powerspectrum() assert ps.norm == "frac" assert ps.freq is None assert ps.power is None assert ps.power_err is None assert ps.df is None assert ps.m == 1 assert ps.n is None
def test_make_periodogram_from_lightcurve(self): ps = Powerspectrum(lc=self.lc) assert ps.freq is not None assert ps.ps is not None assert ps.df == 1.0 / self.lc.tseg assert ps.norm == "rms" assert ps.m == 1 assert ps.n == self.lc.time.shape[0] assert ps.nphots == np.sum(self.lc.counts)
def test_rebin_uses_mean(self): """ Make sure the rebin-method uses "mean" to average instead of summing powers by default, and that this is not changed in the future! Note: function defaults come as a tuple, so the first keyword argument had better be 'method' """ ps = Powerspectrum(self.lc, norm="Leahy") assert ps.rebin.__defaults__[2] == "mean"
def test_leahy_norm_correct(self): time = np.linspace(0, 10.0, 1e6) counts = np.random.poisson(1000, size=time.shape[0]) lc = Lightcurve(time, counts) ps = Powerspectrum(lc, norm="leahy") print(np.mean(ps.power[1:])) assert np.isclose(np.mean(ps.power[1:]), 2.0, atol=0.01, rtol=0.01)
def test_classical_significances_trial_correction(self): ps = Powerspectrum(lc=self.lc, norm="leahy") # change the powers so that just one exceeds the threshold ps.power = np.zeros_like(ps.power) + 2.0 index = 1 ps.power[index] = 10.0 threshold = 0.01 pval = ps.classical_significances(threshold=threshold, trial_correction=True) assert np.size(pval) == 0
def test_rms_normalization_correct(self): """ In rms normalization, the integral of the powers should be equal to the variance of the light curve divided by the mean of the light curve squared. """ ps = Powerspectrum(lc=self.lc, norm="rms") ps_int = np.sum(ps.ps[:-1]*ps.df) + ps.ps[-1]*ps.df/2. std_lc = np.var(self.lc.counts)/np.mean(self.lc.counts)**2. assert np.isclose(ps_int, std_lc, atol=0.01, rtol=0.01)
def test_rebin(self, df): """ TODO: Not sure how to write tests for the rebin method! """ ps = Powerspectrum(lc=self.lc, norm="Leahy") bin_ps = ps.rebin(df) assert np.isclose(bin_ps.freq[1] - bin_ps.freq[0], bin_ps.df, atol=1e-4, rtol=1e-4) assert np.isclose(bin_ps.freq[0], (ps.freq[0] - ps.df * 0.5 + bin_ps.df * 0.5), atol=1e-4, rtol=1e-4)
def test_make_periodogram_from_lightcurve(self, legacy): ps = Powerspectrum(self.lc, legacy=legacy) assert ps.freq is not None assert ps.power is not None assert ps.power_err is not None assert np.isclose(ps.df, 1.0 / self.lc.tseg) assert ps.norm == "frac" assert ps.m == 1 assert ps.n == self.lc.time.shape[0] assert ps.nphots == np.sum(self.lc.counts)
def test_calibrate_lrt_works_with_sampling(self): m = 1 nfreq = 100 freq = np.linspace(1, 10, nfreq) rng = np.random.RandomState(100) noise = rng.exponential(size=nfreq) model = models.Const1D() model.amplitude = 2.0 p = model(freq) power = noise * p ps = Powerspectrum() ps.freq = freq ps.power = power ps.m = m ps.df = freq[1] - freq[0] ps.norm = "leahy" lpost = PSDPosterior(ps.freq, ps.power, model, m=1) p_amplitude_1 = lambda amplitude: \ scipy.stats.norm(loc=2.0, scale=1.0).pdf(amplitude) p_alpha_0 = lambda alpha: \ scipy.stats.uniform(0.0, 5.0).pdf(alpha) p_amplitude_0 = lambda amplitude: \ scipy.stats.norm(loc=self.a2_mean, scale=self.a2_var).pdf( amplitude) priors = {"amplitude": p_amplitude_1} priors2 = {"amplitude_1": p_amplitude_1, "amplitude_0": p_amplitude_0, "alpha_0": p_alpha_0} lpost.logprior = set_logprior(lpost, priors) model2 = models.PowerLaw1D() + models.Const1D() model2.x_0_0.fixed = True lpost2 = PSDPosterior(ps.freq, ps.power, model2, 1) lpost2.logprior = set_logprior(lpost2, priors2) pe = PSDParEst(ps) with catch_warnings(RuntimeWarning): pval = pe.calibrate_lrt(lpost, [2.0], lpost2, [2.0, 1.0, 2.0], sample=None, max_post=True, nsim=10, nwalkers=10, burnin=10, niter=10, seed=100) assert pval > 0.001
def setup_class(cls): m = 1 nfreq = 100 freq = np.arange(nfreq) noise = np.random.exponential(size=nfreq) power = noise * 2.0 ps = Powerspectrum() ps.freq = freq ps.power = power ps.m = m ps.df = freq[1] - freq[0] ps.norm = "leahy" cls.ps = ps cls.a_mean, cls.a_var = 2.0, 1.0 cls.model = models.Const1D() p_amplitude = lambda amplitude: \ scipy.stats.norm(loc=cls.a_mean, scale=cls.a_var).pdf( amplitude) cls.priors = {"amplitude": p_amplitude} cls.lpost = PSDPosterior(cls.ps.freq, cls.ps.power, cls.model, m=cls.ps.m) cls.lpost.logprior = set_logprior(cls.lpost, cls.priors) cls.fitmethod = "BFGS" cls.max_post = True cls.t0 = [2.0] cls.neg = True pe = ParameterEstimation() res = pe.fit(cls.lpost, cls.t0) cls.nwalkers = 50 cls.niter = 100 np.random.seed(200) p0 = np.array([ np.random.multivariate_normal(res.p_opt, res.cov) for i in range(cls.nwalkers) ]) cls.sampler = emcee.EnsembleSampler(cls.nwalkers, len(res.p_opt), cls.lpost, args=[False], threads=1) with catch_warnings(RuntimeWarning): _, _, _ = cls.sampler.run_mcmc(p0, cls.niter)
def test_leahy_norm_total_variance(self): """ In Leahy normalization, the total variance should be the sum of powers multiplied by the number of counts and divided by the square of the number of data points in the light curve """ ps = Powerspectrum(lc=self.lc, norm="Leahy") ps_var = (np.sum(self.lc.counts)/ps.n**2.) * \ (np.sum(ps.power[:-1]) + ps.power[-1]/2.) assert np.isclose(ps_var, np.var(self.lc.counts), atol=0.01)
def test_leahy_norm_Poisson_noise(self): """ In Leahy normalization, the poisson noise level (so, in the absence of a signal, the average power) should be equal to 2. """ time = np.linspace(0, 10.0, 1e5) counts = np.random.poisson(1000, size=time.shape[0]) lc = Lightcurve(time, counts) ps = Powerspectrum(lc, norm="leahy") assert np.isclose(np.mean(ps.power[1:]), 2.0, atol=0.01, rtol=0.01)
def test_fractional_rms_in_leahy_norm(self): """ fractional rms should only be *approximately* equal the standard deviation divided by the mean of the light curve. Therefore, we allow for a larger tolerance in np.isclose() """ ps = Powerspectrum(lc=self.lc, norm="Leahy") rms_ps, rms_err = ps.compute_rms(min_freq=ps.freq[0], max_freq=ps.freq[-1]) rms_lc = np.std(self.lc.counts) / np.mean(self.lc.counts) assert np.isclose(rms_ps, rms_lc, atol=0.01)
def test_load_and_save_pds(self): pds = Powerspectrum() pds.freq = np.linspace(0, 10, 15) pds.power = np.random.poisson(30, 15) pds.mjdref = 54385.3254923845 pds.gti = np.longdouble([[-0.5, 3.5]]) save_to_intermediate_file(pds, self.dum) pds2 = load_from_intermediate_file(self.dum) assert np.allclose(pds.gti, pds2.gti) assert np.allclose(pds.mjdref, pds2.mjdref) assert np.allclose(pds.gti, pds2.gti) assert pds.m == pds2.m
def get_lc_onesource(k,src_index,num_trials=2): k_trial =0 FP = []; period = []; cts_num=[]; peakP=[]; power_P=[] path = '/Users/baotong/Desktop/CDFS/txt_all_obs_0.5_8_ep{0}/'.format(k) epoch_file = np.loadtxt(path + 'CDFS_epoch_ep{0}.txt'.format(k)) tstart = epoch_file[:, 0];tstop = epoch_file[:, 1] ID=epoch_file[:,2];exptime = epoch_file[:, 3] evt_file = np.loadtxt(path + '{0}.txt'.format(src_index)) bkgevt_file = np.loadtxt(path + '{0}_bkg.txt'.format(src_index)) for i in range(len(ID)): index = len(np.where(evt_file[:,2] == ID[i])[0]) index_b=len(np.where(bkgevt_file[:,2] == ID[i])[0]) cts_num.append(index-index_b/12.) dt = 100 T_exp = 11000154.981141508 freq=np.arange(1/T_exp,0.5/dt,1/(5*T_exp)) freq=freq[np.where(freq > 1 / 20000.)] if os.path.exists(path+'/simulation/{0}_LS_simP.csv'.format(src_index)): print('caution! file exists') return None with open(path + '/simulation/{0}_LS_simP.csv'.format(src_index), 'a+') as csvfile: header = freq header = header.astype('str') writer = csv.writer(csvfile) while k_trial <num_trials: ev_all = EventList() for i in range(len(exptime)): cts_rate = cts_num[i]/(2*exptime[i]) * dt # 实际的cts-rate应为这个的2倍 num_bins = int(exptime[i] / dt) sim = simulator.Simulator(N=num_bins, mean=cts_rate, dt=dt) w = np.arange(1 / exptime[i], 0.5 / dt, 1 / exptime[i]) spectrum = bending_po(w, [2.3e-3, 3.4, 0.40, 4.3e-4]) # spectrum = bending_po(w, [2.3e-3, 3.4, 0.40, 4.3e-4]) + generalized_lorentzian(w, [1.0518215e-3,1.0518215e-3/16,200,2]) lc = sim.simulate(spectrum) # lc.counts += cts_rate lc.counts[np.where(lc.counts<0)]=0 ps = Powerspectrum(lc, norm='abs') ev = EventList() ev.time = sim_evtlist(lc) + tstart[i] ev_all = ev_all.join(ev) # print(len(ev_all.time)) lc_new = ev_all.to_lc(dt=dt, tstart=ev_all.time[0]-0.5*dt, tseg=ev_all.time[-1]-ev_all.time[0]) # T_exp=lc_new.time[-1]-lc_new.time[0] temp=get_LS(lc_new.time, lc_new.counts, freq=freq,trial=k_trial) writer.writerows([temp[-1]]) k_trial+=1
def test_rebin_makes_right_attributes(self): ps = Powerspectrum(lc = self.lc, norm="Leahy") ## replace powers ps.ps = np.ones_like(ps.ps)*2.0 rebin_factor = 2.0 bin_ps = ps.rebin(rebin_factor*ps.df) assert bin_ps.freq is not None assert bin_ps.ps is not None assert bin_ps.df == rebin_factor*1.0/self.lc.tseg assert bin_ps.norm.lower() == "leahy" assert bin_ps.m == 2 assert bin_ps.n == self.lc.time.shape[0] assert bin_ps.nphots == np.sum(self.lc.counts)
def test_total_variance(self): """ the integral of powers (or Riemann sum) should be close to the variance divided by twice the length of the light curve. Note: make sure the factors of ncounts match! Also, make sure to *exclude* the zeroth power! """ ps = Powerspectrum(lc=self.lc) nn = ps.n pp = ps.unnorm_power / np.float(nn)**2 p_int = np.sum(pp[:-1] * ps.df) + (pp[-1] * ps.df) / 2 var_lc = np.var(self.lc.counts) / (2. * self.lc.tseg) assert np.isclose(p_int, var_lc, atol=0.01, rtol=0.01)
def plot_psd(lc): ps = Powerspectrum(lc, norm='frac') fig, ax1 = plt.subplots(1, 1, figsize=(9, 6), sharex=True) ax1.loglog() ax1.step(ps.freq, ps.power, lw=2, color='blue') ax1.set_xlabel("Frequency (Hz)", fontproperties=font1) ax1.set_ylabel("Power ", fontproperties=font1) ax1.tick_params(axis='x', labelsize=16) ax1.tick_params(axis='y', labelsize=16) ax1.tick_params(which='major', width=1.5, length=7) ax1.tick_params(which='minor', width=1.5, length=4) for axis in ['top', 'bottom', 'left', 'right']: ax1.spines[axis].set_linewidth(1.5) plt.show() return ps
def test_classical_significances_threshold(self): ps = Powerspectrum(lc = self.lc, norm="leahy") ## change the powers so that just one exceeds the threshold ps.ps = np.zeros(ps.ps.shape[0])+2.0 index = 1 ps.ps[index] = 10.0 threshold = 0.01 pval = ps.classical_significances(threshold=threshold, trial_correction=False) assert pval[0,0] < threshold assert pval[1,0] == index
def test_multitaper_lombscargle_consistency(self, norm): mtp = Multitaper(self.lc, adaptive=False, norm=norm) mtp_ls = Multitaper(self.lc, lombscargle=True, adaptive=False, norm=norm) # Check if 99% of the points in the PSDs are within the set tolerance assert np.sum(np.isclose(mtp.power, mtp_ls.power, atol=0.022*np.max(mtp_ls.power))) >= 0.99*mtp_ls.power.size # Check if the freq vals are the same ps = Powerspectrum(self.lc, norm=norm) assert np.allclose(mtp.freq, mtp_ls.freq) assert np.allclose(mtp.freq, ps.freq) assert mtp.power.shape == ps.power.shape
def test_pvals_is_numpy_array(self): ps = Powerspectrum(lc=self.lc, norm="leahy") # change the powers so that just one exceeds the threshold ps.power = np.zeros_like(ps.power) + 2.0 index = 1 ps.power[index] = 10.0 threshold = 1.0 pval = ps.classical_significances(threshold=threshold, trial_correction=True) assert isinstance(pval, np.ndarray) assert pval.shape[0] == 2
def test_fitting_with_ties_and_bounds(self, capsys): double_f = lambda model: model.x_0_0 * 2 model = self.model.copy() model = self.model + models.Lorentz1D(amplitude=model.amplitude_0, x_0=model.x_0_0 * 2, fwhm=model.fwhm_0) model.x_0_0 = self.model.x_0_0 model.amplitude_0 = self.model.amplitude_0 model.amplitude_1 = self.model.amplitude_1 model.fwhm_0 = self.model.fwhm_0 model.x_0_2.tied = double_f model.fwhm_0.bounds = [0, 10] model.amplitude_0.fixed = True p = model(self.ps.freq) noise = np.random.exponential(size=len(p)) power = noise * p ps = Powerspectrum() ps.freq = self.ps.freq ps.power = power ps.m = self.ps.m ps.df = self.ps.df ps.norm = "leahy" pe = PSDParEst(ps) llike = PSDLogLikelihood(ps.freq, ps.power, model) true_pars = [ self.amplitude_0, self.x_0_0, self.fwhm_0, self.amplitude_1, model.amplitude_2.value, model.x_0_2.value, model.fwhm_2.value ] res = pe.fit(llike, true_pars) res.print_summary(llike) out, err = capsys.readouterr() assert "100.00000 (Fixed)" in out pattern = \ re.compile(r"5\) Parameter x_0_2\s+: [0-9]\.[0-9]{5}\s+\(Tied\)") assert pattern.search(out) compare_pars = [ self.x_0_0, self.fwhm_0, self.amplitude_1, model.amplitude_2.value, model.fwhm_2.value ] assert np.all(np.isclose(compare_pars, res.p_opt, rtol=0.5))
def plot_pds(time, flux): ## 画光变曲线,即光子流量随时间的变化 ## lc = Lightcurve(time, flux) fig, ax = plt.subplots(1, 1, figsize=(10, 6)) ax.plot(lc.time, lc.counts, lw=2, color='blue') ax.set_xlabel("Time (s)", fontproperties=font1) ax.set_ylabel("Counts (cts)/bin", fontproperties=font1) ax.tick_params(axis='x', labelsize=16) ax.tick_params(axis='y', labelsize=16) ax.tick_params(which='major', width=1.5, length=7) ax.tick_params(which='minor', width=1.5, length=4) plt.show() ## 画功率谱图 ## ps = Powerspectrum(lc, norm='leahy') fig, ax1 = plt.subplots(1, 1, figsize=(9, 6), sharex=True) ax1.loglog() ax1.step(ps.freq, ps.power, lw=2, color='blue') ax1.set_ylabel("Frequency (Hz)", fontproperties=font1) ax1.set_ylabel("Power ", fontproperties=font1) ax1.set_yscale('log') ax1.tick_params(axis='x', labelsize=16) ax1.tick_params(axis='y', labelsize=16) ax1.tick_params(which='major', width=1.5, length=7) ax1.tick_params(which='minor', width=1.5, length=4) for axis in ['top', 'bottom', 'left', 'right']: ax1.spines[axis].set_linewidth(1.5) plt.show() ## 画average的功率谱,对于绝大多数的源不需要做这张图,除非所给的参考文献中有做average power density spectrum ### avg_ps = AveragedPowerspectrum(lc, 500, dt=lc.time[1] - lc.time[0], norm='leahy') print("Number of segments: %d" % avg_ps.m) fig, ax1 = plt.subplots(1, 1, figsize=(9, 6)) ax1.loglog() ax1.step(avg_ps.freq, avg_ps.power, lw=2, color='blue') ax1.set_xlabel("Frequency (Hz)", fontproperties=font1) ax1.set_ylabel("Power ", fontproperties=font1) ax1.set_yscale('log') ax1.tick_params(axis='x', labelsize=16) ax1.tick_params(axis='y', labelsize=16) ax1.tick_params(which='major', width=1.5, length=7) ax1.tick_params(which='minor', width=1.5, length=4) for axis in ['top', 'bottom', 'left', 'right']: ax1.spines[axis].set_linewidth(1.5) plt.show()
def test_plotfits_log_pow(self): ps = Powerspectrum() ps.freq = self.ps.freq ps.power = self.ps.power ps.m = self.ps.m ps.df = self.ps.df ps.norm = "none" pe = PSDParEst(ps) t0 = [2.0, 1, 1, 1] res = pe.fit(self.lpost, t0) pe.plotfits(res, res2=res, save_plot=True, log=True) assert os.path.exists("test_ps_fit.png") os.unlink("test_ps_fit.png")
def test_rebin_makes_right_attributes(self, legacy): ps = Powerspectrum(self.lc, norm="Leahy", legacy=legacy) # replace powers ps.power = np.ones_like(ps.power) * 2.0 rebin_factor = 2 bin_ps = ps.rebin(rebin_factor*ps.df) assert bin_ps.freq is not None assert bin_ps.power is not None assert bin_ps.power is not None assert np.isclose(bin_ps.df, rebin_factor * 1.0 / self.lc.tseg) assert bin_ps.norm.lower() == "leahy" assert bin_ps.m == 2 assert bin_ps.n == self.lc.time.shape[0] assert bin_ps.nphots == np.sum(self.lc.counts)
def test_abs_norm_Poisson_noise(self): """ Poisson noise level for a light curve with absolute rms-squared normalization should be approximately 2 * the mean count rate of the light curve. """ np.random.seed(101) time = np.linspace(0, 1., 1e4) counts = np.random.poisson(0.01, size=time.shape[0]) lc = Lightcurve(time, counts) ps = Powerspectrum(lc, norm="abs") abs_noise = 2. * 100 # expected Poisson noise level; # hardcoded value from above assert np.isclose(np.mean(ps.power[1:]), abs_noise, atol=50)
def setup_class(cls): tstart = 0.0 tend = 10.0 cls.dt = 0.0001 cls.segment_size = tend - tstart times = np.sort(np.random.uniform(tstart, tend, 1000)) gti = np.array([[tstart, tend]]) cls.events = EventList(times, gti=gti) cls.lc = cls.events cls.leahy_pds = AveragedPowerspectrum( cls.lc, segment_size=cls.segment_size, dt=cls.dt, norm="leahy", silent=True) cls.leahy_pds_sng = Powerspectrum( cls.lc, dt=cls.dt, norm="leahy")
def setup_class(cls): np.random.seed(1000) m = 1 nfreq = 100 freq = np.arange(nfreq) noise = np.random.exponential(size=nfreq) power = noise * 2.0 ps = Powerspectrum() ps.freq = freq ps.power = power ps.m = m ps.n = freq.shape[0] ps.df = freq[1] - freq[0] ps.norm = "leahy" cls.ps = ps cls.a_mean, cls.a_var = 2.0, 1.0 cls.model = models.Const1D() p_amplitude = lambda amplitude: \ scipy.stats.norm(loc=cls.a_mean, scale=cls.a_var).pdf(amplitude) cls.priors = {"amplitude": p_amplitude} cls.lpost = PSDPosterior(cls.ps.freq, cls.ps.power, cls.model, m=cls.ps.m) cls.lpost.logprior = set_logprior(cls.lpost, cls.priors) cls.fitmethod = "powell" cls.max_post = True cls.t0 = np.array([2.0]) cls.neg = True cls.opt = scipy.optimize.minimize(cls.lpost, cls.t0, method=cls.fitmethod, args=cls.neg, tol=1.e-10) cls.opt.x = np.atleast_1d(cls.opt.x) cls.optres = OptimizationResultsSubclassDummy(cls.lpost, cls.opt, neg=True)
def test_plotfits_pow(self): t0 = [2.0, 1, 1, 1] ps = Powerspectrum() ps.freq = self.ps.freq ps.power = self.ps.power ps.m = self.ps.m ps.df = self.ps.df ps.norm = "none" pe = PSDParEst(ps) lpost = PSDPosterior(self.ps, self.model, self.priors) res = pe.fit(self.lpost, t0) pe.plotfits(res, res2=res, save_plot=True) assert os.path.exists("test_ps_fit.png") os.unlink("test_ps_fit.png")
def get_lc_byspec_1hr(k,j,num_trials=1000): k_trial=0 FP = []; period = []; while k_trial <num_trials: path = '/Users/baotong/Desktop/CDFS/txt_all_obs_0.5_8_ep{0}/'.format(k) epoch_file=np.loadtxt(path+'CDFS_epoch_ep{0}.txt'.format(k)) # path = '/Users/baotong/Desktop/CDFS/txt_all_obs_0.5_8/' # epoch_file = np.loadtxt(path + 'CDFS_epoch.txt') tstart=epoch_file[:,0];tstop=epoch_file[:,1];exptime=epoch_file[:,3] ev_all = EventList() for i in range(len(exptime)): dt=100 cts_rate=cr[j] *dt #实际的cts-rate应为这个的2倍 num_bins=int(exptime[i]/dt) sim = simulator.Simulator(N=num_bins, mean=cts_rate, dt=dt) w = np.arange(1 / exptime[i], 0.5 / dt, 1 / exptime[i]) # w = np.fft.rfftfreq(sim.N, d=sim.dt)[1:] # spectrum = smoothbknpo(w, [0.01, 2, 1e-2, 1e-3]) # spectrum = bending_po(w, [2.3e-3, 3.4, 0.40, 4.3e-4]) ## 这是RE J1034+396 的参数 # spectrum = bending_po(w, [2.3e-3, 3.4, 0.40, 4.3e-4]) + generalized_lorentzian(w, [6.68e-4 ,6.68e-4 /16,200,2]) spectrum = bending_po(w, [2.3e-3, 3.4, 0., 4.3e-4]) + generalized_lorentzian(w,[5.6e-4, 5.6e-4 / 16, 200,2]) # spectrum =powerlaw + generalized_lorentzian(w, [1 / 1000., 1 / 10000., 0.5*np.max(powerlaw), 2]) lc = sim.simulate(spectrum) lc.counts += cts_rate lc.counts[np.where(lc.counts<0)]=0 ps=Powerspectrum(lc,norm='abs') ev = EventList() # ev.simulate_times(use_spline=False,lc=lc,bin_time=dt) # ev.time+=tstart[i] ev.time=sim_evtlist(lc)+tstart[i] # print(ev.time)RX J1301.9+2747 ev_all=ev_all.join(ev) print('cts={0}'.format(len(ev_all.time))) lc_new = ev_all.to_lc(dt=dt, tstart=ev_all.time[0]-0.5*dt, tseg=ev_all.time[-1]-ev_all.time[0]) T_exp=lc_new.time[-1]-lc_new.time[0] freq = np.arange(1 / T_exp, 0.5 / dt, 1 / (5 * T_exp)) freq=freq[np.where(freq > 1 / 20000.)] # print(len(freq)) temp=get_LS(lc_new.time, lc_new.counts, freq=freq) FP.append(temp[0]);period.append(temp[1]) k_trial+=1 result=np.column_stack((FP,period)) np.savetxt(path+'simulation/'+'trial_out_1hr_{0}_REJ1034+396_test_noC.txt'.format(cr_str[j]),result,fmt="%10.5f %10.5f") return ev_all