def model_pangenome_curve(dfout, Column): ''' This function models the panganome, core, and new gene curves''' # Initialize dictionary to store model results params = {} # PowerLawModel for Pangenome curve # Model the Pangenome curve using a Powerlaw function: Ps = κn^γ print('\n\nFitting PowerLaw function to {Column}') print('Using Power Law Function K*N^\u03B3 ...') PLM = PowerLawModel() # Initialize the model # Guess starting values from the data PLM_Guess_Start = PLM.guess( dfout[Column], x=dfout['n'], ) # Fit model to the data (optimize parameters) PLM_Fit = PLM.fit( dfout[Column], PLM_Guess_Start, x=dfout['n'] ) # Add modeled data to dfout data frame dfout[f'{Column}_PLM'] = PLM_Fit.best_fit # Store K and Gamma parameters params['K'] = float(PLM_Fit.best_values['amplitude']) params['Gamma'] = float(PLM_Fit.best_values['exponent']) return dfout, params
def produce_tauspectrum_noplot(freqMHz,taus,tauserr): freqGHz = freqMHz/1000. powmod = PowerLawModel() powparstau = powmod.guess(taus,x=freqGHz) tauserr = tauserr[np.nonzero(tauserr)] taus = taus[np.nonzero(tauserr)] freqGHz = freqGHz[np.nonzero(tauserr)] freqMHz = freqMHz[np.nonzero(tauserr)] powout = powmod.fit(taus,powparstau,x=freqGHz,weights=1/(np.power(tauserr,2))) print(fit_report(powout.params)) fit = powout.best_fit alpha = -powout.best_values['exponent'] alphaerr = powout.params['exponent'].stderr return freqMHz, alpha, alphaerr, fit
def produce_tauspectrum(freqMHz, taus, tauserr): freqGHz = freqMHz / 1000. powmod = PowerLawModel() powparstau = powmod.guess(taus, x=freqGHz) #remove tauserr = 0 entries tauserr = tauserr[np.nonzero(tauserr)] taus = taus[np.nonzero(tauserr)] freqGHz = freqGHz[np.nonzero(tauserr)] freqMHz = freqMHz[np.nonzero(tauserr)] powout = powmod.fit(taus, powparstau, x=freqGHz, weights=1 / (np.power(tauserr, 2))) print(fit_report(powout.params)) fit = powout.best_fit alpha = -powout.best_values['exponent'] alphaerr = powout.params['exponent'].stderr fig = plt.figure() plt.errorbar(freqMHz, taus, yerr=tauserr, fmt='k*', markersize=9.0, capthick=2, linewidth=1.5, label=r'$\alpha = %.1f \pm %.1f$' % (alpha, alphaerr)) plt.plot(freqMHz, fit, 'k--', linewidth=1.5) plt.xscale('log') plt.yscale('log') plt.yticks(fontsize=11) ticksMHz = (freqMHz).astype(np.int)[0:len(freqMHz):2] plt.xticks(ticksMHz, ticksMHz, fontsize=11) plt.legend(fontsize=11, numpoints=None) plt.xlabel(r'$\nu$ (MHz)', fontsize=11, labelpad=15.0) plt.ylabel(r'$\tau$ (sec)', fontsize=11) plt.xlim(xmin=0.95 * freqMHz[0], xmax=1.05 * freqMHz[-1]) plt.gcf().subplots_adjust(bottom=0.15) return alpha, alphaerr
def produce_tauspectrum_highHBA(freqMHz,taus,tauserr,freqMHzhigh,tauhigh,tauerrhigh): freqGHz = freqMHz/1000. powmod = PowerLawModel() powparstau = powmod.guess(taus,x=freqGHz) #remove tauserr = 0 entries tauserr = tauserr[np.nonzero(tauserr)] taus = taus[np.nonzero(tauserr)] freqGHz = freqGHz[np.nonzero(tauserr)] freqMHz = freqMHz[np.nonzero(tauserr)] powout = powmod.fit(taus,powparstau,x=freqGHz,weights=1/(np.power(tauserr,2))) print(fit_report(powout.params)) fit = powout.best_fit alpha = -powout.best_values['exponent'] alphaerr = powout.params['exponent'].stderr amp = powout.params['amplitude'] allfreq = np.append(freqMHz,freqMHzhigh) fithigh = amp*np.power(allfreq/1000, -alpha) fig = plt.figure(figsize=(12,6)) plt.errorbar(freqMHz,taus,yerr=tauserr,fmt='*-',markersize=10.0,capthick=2,linewidth=1.5,label=r'$\alpha = %.1f \pm %.1f$'%(alpha,alphaerr)) plt.errorbar(freqMHzhigh,tauhigh,yerr=tauerrhigh,fmt='o') plt.plot(freqMHz,fit,'k--',linewidth=1.5) plt.xscale('log') plt.yscale('log') plt.yticks(fontsize=12) ticksMHz = (freqMHz).astype(np.int)[0:len(freqMHz):2] plt.xticks(ticksMHz,ticksMHz,fontsize=12) plt.legend(fontsize=12,numpoints=None) plt.xlabel(r'$\nu$ (MHz)',fontsize=14, labelpad=15.0) plt.ylabel(r'$\tau$ (sec)',fontsize=14) plt.xlim(xmin = 0.95*freqMHz[0],xmax=1.05*freqMHzhigh[-1]) plt.gcf().subplots_adjust(bottom=0.15) return freqMHZ, alpha, alphaerr, fit, fithigh
def CurveFitting(self, frec, Pxx, iaf, ax): 'Non-Linear Least-Squares Minimization and Curve-Fitting for Python' # ----- adjusting a model to the obtained PSD ----- # model 1: constante g1 = ConstantModel(prefix = 'g1_') pars = g1.guess(Pxx, x = frec) pars['g1_c'].set(0) # model 2: k2/f^-1 g2 = PowerLawModel(prefix = 'g2_') pars += g2.guess(Pxx, x = frec) pars['g2_exponent'].set(-1) #model 3: probability density function g3 = GaussianModel(prefix = 'g3_') pars += g3.guess(Pxx, x = frec) pars['g3_center'].set(iaf, min = iaf-2, max = iaf+2) # model 4: probability density function g4 = GaussianModel(prefix = 'g4_') pars += g4.guess(Pxx, x = frec) pars['g4_center'].set(20, min = 16, max = 25) # final model gA = g1 + g2 + g3 + g4 outA = gA.fit(Pxx, pars, x = frec) diffA= np.sum(Pxx - outA.best_fit) gB = g1 + g2 + g3 outB = gB.fit(Pxx, pars, x = frec) diffB= np.sum(Pxx - outB.best_fit) gC = g1 + g2 outC = gC.fit(Pxx, pars, x = frec) diffC= np.sum(Pxx - outC.best_fit) diffs= np.abs([diffA, diffB, diffC]) idx = np.where(diffs == np.min(diffs))[0][0] out = [outA, outB, outC][idx] # ----- plotting the desire PSD ----- # original and fitted curves ax.plot(frec, Pxx, 'k', linewidth = 2, label = 'PSD') ax.plot(frec, out.best_fit, 'b.-', linewidth = 2, markersize = 9, label ='BestModel') ax.set_xlim(frec[0], 32) ax.set_ylim(ymin = 0) ax.tick_params(axis = 'both', labelsize = 16) ax.set_xlabel('Frequency [Hz]', fontsize = 'x-large') ax.grid() # components of the fitted curved comps = out.eval_components(x = frec) g12 = comps['g1_'] + comps['g2_'] ax.plot(frec, g12, 'g--', linewidth = 2, label = 'PowerLawModel') idx1, idx2 = np.where(frec >= 5)[0][0], np.where(frec <= 15)[0][-1] # final value on the subplot if out != outC: diffs = out.best_fit[idx1:idx2] - g12[idx1:idx2] peak1 = np.amax(diffs) idx = np.where(diffs == peak1)[0] idx+= len(out.best_fit[:idx1]) ax.plot((frec[idx],frec[idx]), (g12[idx],out.best_fit[idx]), 'r-o', linewidth = 3, markersize = 9) ax.text(frec[idx], g12[idx], str(np.around(peak1, decimals=2)), horizontalalignment='right', verticalalignment='top', color='r', fontsize='xx-large') else: peak1 = 0 # optional valued on the subplot diffs = Pxx[idx1:idx2] - g12[idx1:idx2] peak2 = np.amax(diffs) idx = np.where(peak2 == diffs)[0] idx+= len(Pxx[:idx1]) ax.plot((frec[idx],frec[idx]), (g12[idx], Pxx[idx]), 'r-*', linewidth = 3, markersize = 11) ax.text(frec[idx], Pxx[idx], str(np.around(peak2, decimals=2)), horizontalalignment='left', verticalalignment='top', color='r', fontsize='xx-large') ax.legend(loc='upper right', shadow=True) return peak1, peak2
#print data if np.shape(data)[1]>= 3: row_col2iszero = np.equal(data[:,2], 0) data = data[~row_col2iszero] taus = data[:,1] tauserr = data[:,2] freqMHz = data[:,0] freqGHz = freqMHz/1000 print data #print freqMHz[0] """CALCULATE FITS TO TAUS""" powmod = PowerLawModel() powparstau = powmod.guess(taus,x=freqGHz) if np.shape(data)[1] >= 3: powout = powmod.fit(taus,powparstau,x=freqGHz,weights=1/(tauserr)**2) else: powout = powmod.fit(taus,powparstau,x=freqGHz,weights=1) print(fit_report(powout.params)) fit = powout.best_fit alpha = -powout.best_values['exponent'] alphaerr = powout.params['exponent'].stderr amp = powout.best_values['amplitude'] amperr = powout.params['amplitude'].stderr if 'aniso' in filepath: powparstau2 = powmod.guess(tau2s,x=freqGHz) powout2 = powmod.fit(tau2s,powparstau2,x=freqGHz,weights=1/(tau2serr)**2)
def produce_tauspectrum(freqMHz,taus,tauserr,log=True, plotspecevo=False, savefigure=False): if len(taus) < 2: print "Can't perform power law fit on single value. Returning spectral index = 0.0" alpha=0 alphaerr=0 fit=taus else: freqGHz = freqMHz/1000. powmod = PowerLawModel() powparstau = powmod.guess(taus,x=freqGHz) #remove tauserr = 0 entries tauserr = tauserr[np.nonzero(tauserr)] taus = taus[np.nonzero(tauserr)] freqGHz = freqGHz[np.nonzero(tauserr)] freqMHz = freqMHz[np.nonzero(tauserr)] if len(taus) < 3: raise RuntimeError("Two or fewer tau-values. Cannot compute tau-spectrum.") powout = powmod.fit(taus,powparstau,x=freqGHz,weights=1.0/(np.power(tauserr,2))) print "\nPlotting fitted tau-spectrum\n" print(fit_report(powout.params)) fit = powout.best_fit alpha = -powout.best_values['exponent'] alphaerr = powout.params['exponent'].stderr plt.figure(figsize=(10,6)) plt.errorbar(freqMHz,taus,yerr=tauserr,fmt='*-', markersize=10.0,capthick=2,linewidth=1.5, label='data') plt.plot(freqMHz,fit,ls='dashed',linewidth=1.5,label=r'$\alpha = %.1f \pm %.1f$' %(alpha,alphaerr)) if log: plt.xscale('log') plt.yscale('log') plt.yticks(fontsize=12) #ticksMHz = (freqMHz).astype(np.int)[0:len(freqMHz):2] #plt.xticks(ticksMHz,ticksMHz,fontsize=11) plt.xticks(fontsize=11) leg = plt.legend(fontsize=12,numpoints=None) plt.xlabel(r'$\nu$ (MHz)',fontsize=14, labelpad=15.0) plt.ylabel(r'$\tau$ (sec)',fontsize=14) plt.xlim(xmin = 0.95*freqMHz[0],xmax=1.05*freqMHz[-1]) plt.gcf().subplots_adjust(bottom=0.15) if savefigure == True: figname = '%s_%s.png' %(os.path.basename(filepath),'tau_spectrum') plt.savefig(figname, dpi=200) print "Saved figure %s in ./" %figname if noshow == False: plt.show() if plotspecevo == True: """Calculate spectral index evolution with addition of lowwer freq. channels""" npch = len(freqMHz) spec_sec = np.zeros(npch-1) spec_std_sec = np.zeros(npch-1) for i in range(npch-1): bb = npch - (i+2) ##index begin ee = npch ## index end # print freqms[bb:ee] powparstau_sec = powmod.guess(taus[bb:ee],x=freqMHz[bb:ee]) powouttau_sec = powmod.fit(taus[bb:ee],powparstau_sec, x=freqMHz[bb:ee],weights=1/(tauserr[bb:ee]**2)) spec_sec[i] = -powouttau_sec.best_values['exponent'] spec_std_sec[i] = powouttau_sec.params['exponent'].stderr freq_incl = freqMHz[::-1][1:] plt.figure(figsize=(10,6)) plt.errorbar(freq_incl,spec_sec,yerr=spec_std_sec, fmt='*',alpha=0.6,markersize=12.0,capthick=2,linewidth=0.5) plt.title(r'Change in spectral index', fontsize=12) for x,y in zip(freq_incl[0::2], spec_sec[0::2]): plt.annotate('%.2f' %y, xy=(x,1.08*y), xycoords='data',textcoords='data') plt.ylim(plt.ylim()[0],1.1*plt.ylim()[1]) plt.yticks(fontsize=12) plt.xticks(fontsize=12) plt.xlabel(r'Lowest freq included (MHz)',fontsize=12) plt.ylabel(r'$\alpha$',fontsize=12) if savefigure == True: figname = '%s_%s.png' %(os.path.basename(filepath),'alpha_evolution') plt.savefig(figname, dpi=200) print "Saved figure %s in ./" %figname if noshow == False: plt.show() return freqMHz, alpha, alphaerr, fit
def produce_taufits(filepath,meth='iso',pulseperiod=None,snr_cut=None, verbose=True, plotparams=False, plotflux=False, savefigure=False): pulsar, nch, nbins,nsub, lm_rms, tsub = read_headerfull(filepath) if verbose == True: verboseTag = True else: verboseTag = False print0 = "Pulsar name: %s" %pulsar print1 = "Number of freq. channels: %d \nFreq channels will be labeled 0 - %d" %(nch, nch-1) print2 = "Number of bins: %d" %nbins print3 = "RMS: %.2f" %lm_rms print4 = "Tsub: %.2f sec" %tsub for k in range(5): print eval('print{0}'.format(k)) print"--------------------------------------------------------" if pulseperiod==None: ## Define time axis, and time/bins conversions print ("Using Tsub in header to convert bins to time. Assumption is that tsub corresponds to 1.0 phase, corresponding to nbins. This should be adapted for search data.") pulseperiod = tsub else: pulseperiod = pulseperiod #set to provided pulseperiod in seconds profilexaxis = np.linspace(0,pulseperiod,nbins) pbs = pulseperiod/nbins tbs = tsub/nbins """Initialise vector outputs""" obtainedtaus, lmfittausstds = [], [] """freqmsMHz will correctly associate scattering time values (tau) with frequency, taking into account frequency integration across a sub-band. Whereas freqcsMHz is the centre freq. to the subband""" freqmsMHz, freqcsMHz = [], [] noiselessmodels =[] results, datas, comp_SNRs, comp_rmss = [], [], [], [] redchis, paramset, paramset_std, correls = [], [], [], [] halfway = nbins/2. for i in range(nch): print"--------------------------------------------------------" print "Channel %d" %i """Read in (pdv) data""" data, freqc, freqm = read_data(filepath,i,nbins) freqmsMHz.append(freqm) freqcsMHz.append(freqc) # roll the data of lowest freq channel to middle of bins if i ==0: peakbin = np.argmax(data) shift = int(halfway -int(peakbin)) if verboseTag: print 'peak bin at lowest freq channel:%d' %peakbin else: peakbin = peakbin shift = int(halfway - int(peakbin)) data = np.roll(data,shift) if verboseTag: print "Rolling data by -%d bins" %shift comp_rms = find_rms(data,nbins) if meth is None: print "No fitting method was chosen. Will default to an isotropic fitting model. \n Use option -m with 'onedim' to change." result, noiselessmodel, besttau, taustd, bestparams, bestparams_std, redchi, corsig = tau_fitter(data,nbins,verbose=verboseTag) elif meth == 'iso': result, noiselessmodel, besttau, taustd, bestparams, bestparams_std, redchi, corsig = tau_fitter(data,nbins,verbose=verboseTag) elif meth == 'onedim': result, noiselessmodel, besttau, taustd, bestparams, bestparams_std, redchi, corsig = tau_1D_fitter(data,nbins) comp_SNR_model = find_peaksnr(noiselessmodel,comp_rms) if verboseTag: print 'Estimated SNR (from model peak and data rms): %.2f' % comp_SNR_model comp_SNR = find_peaksnr_smooth(data,comp_rms) print 'Estimated SNR (from data peak and rms): %.2f' % comp_SNR print 'Channel Tau (ms): %.2f \pm %.2f ms' %(besttau,taustd) obtainedtaus.append(besttau) lmfittausstds.append(taustd) noiselessmodels.append(noiselessmodel) results.append(result) datas.append(data) comp_SNRs.append(comp_SNR) #new: comp_rmss.append(comp_rms) redchis.append(redchi) paramset.append(bestparams) paramset_std.append(bestparams_std) # if plotflux == True: # correls.append(corsig) #if plotflux == True: # cor_sigA = np.zeros(len(correls)) # for i in range(len(correls)): # cor_sigA[i] = correls[i]['A'] paramset = np.transpose(paramset) paramset_std = np.transpose(paramset_std) """Next check if any of the subbands contain only zeros. This happens with high RFI excision in LOFAR bands""" zero_ch = [] for i in range(nch): all_zeros = not np.any(datas[i]) if all_zeros: zero_ch.append(i) print"--------------------------------------------------------" if zero_ch: print "\n" print "%d channels have all zeroes (channels(s):" %len(zero_ch), zero_ch, ") and will be removed." if verboseTag: print "All zero channels are assigned SNR of 0" if snr_cut: print "Using SNR cutoff of %.2f" %snr_cut comp_SNRs = np.nan_to_num(comp_SNRs) (ind_lowSNR,) = np.where(np.array(comp_SNRs) < snr_cut) print "SNR cutoff will exclude %d channels (channel(s): %s)" %(len(ind_lowSNR), ind_lowSNR) data_highsnr = np.delete(np.array(datas),ind_lowSNR,0) model_highsnr = np.delete(np.array(noiselessmodels),ind_lowSNR,0) taus_highsnr = np.delete(np.array(obtainedtaus),ind_lowSNR) lmfitstds_highsnr = np.delete(np.array(lmfittausstds),ind_lowSNR) freqMHz_highsnr = np.delete(np.array(freqmsMHz),ind_lowSNR) #New: comp_rmss_highsnr = np.delete(np.array(comp_rmss),ind_lowSNR) redchis_highsnr = np.delete(np.array(redchis),ind_lowSNR) #corsigA_highsnr = np.delete(np.array(cor_sigA),ind_lowSNR) paramset_highsnr = np.zeros([len(paramset),len(data_highsnr)]) paramsetstd_highsnr = np.zeros([len(paramset),len(data_highsnr)]) for i in range(len(paramset)): paramset_highsnr[i]= np.delete(paramset[i],ind_lowSNR) paramsetstd_highsnr[i]= np.delete(paramset_std[i],ind_lowSNR) elif (snr_cut == None) and (zero_ch != []): print "Used no SNR cutoff" """Rename array to be same as when cut-off is used""" """If no SNR cutoff is used, remove channels with all zeroes -- these will automatically be removed by any snr_cut > 0""" data_highsnr = np.delete(np.array(datas),zero_ch,0) model_highsnr = np.delete(np.array(noiselessmodels),zero_ch,0) taus_highsnr = np.delete(np.array(obtainedtaus),zero_ch) lmfitstds_highsnr = np.delete(np.array(lmfittausstds),zero_ch) freqMHz_highsnr = np.delete(np.array(freqmsMHz),zero_ch) # New: comp_rmss_highsnr = np.delete(np.array(comp_rmss),zero_ch) redchis_highsnr = np.delete(np.array(redchis),zero_ch) #corsigA_highsnr = np.delete(np.array(cor_sigA),zero_ch) paramset_highsnr = np.zeros([len(paramset),len(data_highsnr)]) paramsetstd_highsnr = np.zeros([len(paramset),len(data_highsnr)]) for i in range(len(paramset)): paramset_highsnr[i]= np.delete(paramset[i],zero_ch) paramsetstd_highsnr[i]= np.delete(paramset_std[i],zero_ch) else: print "Used no SNR cutoff and there are no empty channels" data_highsnr = np.array(datas) model_highsnr = np.array(noiselessmodels) taus_highsnr = np.array(obtainedtaus) lmfitstds_highsnr = np.array(lmfittausstds) freqMHz_highsnr = np.array(freqmsMHz) # New: comp_rmss_highsnr = np.array(comp_rmss) redchis_highsnr = np.array(redchis) paramset_highsnr = np.array(paramset) paramsetstd_highsnr = np.array(paramset_std) taussec_highsnr = taus_highsnr*pbs lmfitstdssec_highsnr = lmfitstds_highsnr*pbs number_of_plotted_channels = len(data_highsnr) npch = number_of_plotted_channels print "Will plot remaining %d/%d channels" %(npch, nch) """Plotting starts""" #plot onedim in blue dashed #else plot in red if meth == 'onedim': prof = 'b--' lcol='b' else: prof = 'r-' lcol ='r' """1. PLOT PROFILES""" dimx, dimy = 3., 3. numsubplots = dimx*dimy numplots = int(np.ceil(npch/numsubplots)) print "Num profile plots:", numplots """Compute residuals""" #"""Plot 1: Pulse profiles and fits""" if npch > 0: resdata = data_highsnr - model_highsnr resnormed = (resdata-resdata.mean())/resdata.std() if taussec_highsnr[0] > 1: taulabel = taussec_highsnr taulabelerr = lmfitstdssec_highsnr taustring = 'sec' else: taulabel = taussec_highsnr*1000 taulabelerr = lmfitstdssec_highsnr*1000 taustring = 'ms' for k in range(numplots): j = int(numsubplots*k) figg = plt.figure(k+1,figsize=(int(4*dimx),int(3*dimy))) plots_remaining = int(npch - numsubplots*k) #print "Plots remaining", plots_remaining for i in range(np.min([int(numsubplots),int(plots_remaining)])): figg.subplots_adjust(left = 0.08, right = 0.98, wspace=0.35,hspace=0.35,bottom=0.15) #plt.rc('text', usetex=True) plt.rc('font', family='serif') plt.subplot(dimx,dimy,i+1) plt.plot(profilexaxis,data_highsnr[j+i],alpha = 0.20) plt.plot(profilexaxis,model_highsnr[j+i],lw = 2.0, alpha = 0.85, label=r'$\tau: %.2f \pm%.2f$ %s' %(taulabel[j+i], taulabelerr[j+i], taustring)) plt.title('%s at %.1f MHz' %(pulsar, freqMHz_highsnr[j+i])) plt.ylim(ymax=1.3*np.max(data_highsnr[j+i])) plt.xlim(xmax=pulseperiod) plt.xticks(fontsize=11) plt.yticks(fontsize=11) plt.xlabel('time (s)',fontsize=11) plt.legend(fontsize=11,numpoints=1) plt.ylabel('normalized intensity',fontsize=11) plt.tight_layout() if savefigure == True: figname = '%s_%s_%s_%d.png' %(os.path.basename(filepath),'fitted_profiles', meth, k) plt.savefig(figname, dpi=200) print "Saved figure %s in ./" %figname if noshow == False: plt.show() if verboseTag: for i in range(npch): print "Channel %d" %i print'Tau (ms): %.2f' %(1000*taussec_highsnr[i]) tau1GHz = tauatfreq(freqMHz_highsnr[i]/1000.,taussec_highsnr[i],1.0,4) print 'tau1GHz_alpha_4 (ms) ~ %.4f' %(tau1GHz*1000) lmfitstdssec_highsnr = lmfitstdssec_highsnr[np.nonzero(lmfitstdssec_highsnr)] taussec_highsnr = taussec_highsnr[np.nonzero(lmfitstdssec_highsnr)] freqMHz_highsnr = freqMHz_highsnr[np.nonzero(lmfitstdssec_highsnr)] """Plot 2: Plot Gaussian fitting parameters and DM if selected""" if plotparams==True: print "\nPlotting Gaussian fit parameters w.r.t frequency\n" """Set plotting parameters""" alfval = 0.6 markr= '*' msize=12 plt.figure(numplots+1, figsize=(12,8)) plt.subplots_adjust(left = 0.055, right=0.98,wspace=0.35,hspace=0.4,bottom=0.08) """Fit models to sigma""" powmod = PowerLawModel() powpars = powmod.guess(paramset_highsnr[0], x=freqMHz_highsnr) powout = powmod.fit(paramset_highsnr[0], powpars, x=freqMHz_highsnr, weights=1/((paramsetstd_highsnr[0])**2)) linmod = LinearModel() if len(freqMHz_highsnr) < 3: raise RuntimeError("plotparams == True: Less than three frequency channels. Cannot compute quadratic or exponential fit for width evolution. Consider lowering snr_cut.") else: quadmod = QuadraticModel() quadpars = quadmod.guess(paramset_highsnr[0], x=freqMHz_highsnr) quadout = quadmod.fit(paramset_highsnr[0], quadpars, x=freqMHz_highsnr, weights=1/((paramsetstd_highsnr[0])**2)) expmod = ExponentialModel() exppars = expmod.guess(paramset_highsnr[0], x=freqMHz_highsnr) expout = expmod.fit(paramset_highsnr[0], exppars, x=freqMHz_highsnr, weights=1/((paramsetstd_highsnr[0])**2)) """Fit a DM model to delta mu""" delnuarray = [-(1/freqMHz_highsnr[-1]**2-1/freqMHz_highsnr[i]**2) for i in range(npch)] ##in MHz delmuarray = [(paramset_highsnr[1][-1] - paramset_highsnr[1][i])*pbs for i in range(npch)] ##in seconds delmu_stdarray = [(paramsetstd_highsnr[1][-1] - paramsetstd_highsnr[1][i])*pbs for i in range(npch)] DM_linpars = linmod.guess(delmuarray, x=delnuarray) DM_linout = linmod.fit(delmuarray, DM_linpars, x=delnuarray) DM_CCval = DM_linout.best_values['slope'] DM_CCvalstd = DM_linout.params['slope'].stderr DMmodelfit = DM_linout.best_fit ##model gives deltime in seconds (used to shift data) DMconstant = 4148.808 #uncertainty in the constant is 0.003 - only affects the Delta DM value in the 9th decimal DMval = (DM_CCval/DMconstant) DMvalstd = (DM_CCvalstd/DMconstant) #DMcheck = psr.DM_checker(freqmsMHz,bestpT_highSNR[1]*pbs) ## Plot reduced chi square: plt.subplot(2,3,1) plt.plot(freqMHz_highsnr, redchis_highsnr/np.power(comp_rmss_highsnr,2), markr,alpha=alfval,markersize = msize) plt.title(r'Reduced $\chi^2$ values', fontsize=12) plt.yticks(fontsize=12) plt.xticks(fontsize=12) plt.xlabel(r'$\nu$ MHz',fontsize=12) plt.ylabel(r'$\chi^2$',fontsize=12) ## Plot sigma: plt.subplot(2,3,2) #plt.errorbar(freqMHz_highsnr,paramset_highsnr[0]*pbs) plt.errorbar(freqMHz_highsnr,paramset_highsnr[0]*pbs,yerr =paramsetstd_highsnr[0]*pbs, fmt = markr,markersize=msize,capthick=2,linewidth=1.5,alpha=alfval) plt.plot(freqMHz_highsnr,powout.best_fit*pbs,'-', alpha=alfval,label='pow = %.2f' %powout.best_values['exponent']) plt.plot(freqMHz_highsnr,quadout.best_fit*pbs,'-',alpha=alfval, label='quad: a,b = %.3f,%.3f' %(quadout.best_values['a'],quadout.best_values['b'])) plt.ylabel(r'$\sigma$ (sec)') plt.title(r'Width evolution', fontsize=12) plt.yticks(fontsize=12) plt.xticks(fontsize=12) plt.xlabel(r'$\nu$ MHz',fontsize=14) plt.legend(fontsize = 10, loc='best') ## Plot mean: plt.subplot(2,3,3) #plt.errorbar(freqMHz_highsnr,paramset_highsnr[1]*pbs) plt.errorbar(freqMHz_highsnr,paramset_highsnr[1]*pbs,yerr =paramsetstd_highsnr[1]*pbs, fmt = markr,markersize=msize,capthick=2,linewidth=1.5,alpha=alfval) plt.ylabel(r'$\mu$ (sec)') plt.title(r'Centroid evolution', fontsize=12) plt.yticks(fontsize=12) plt.xticks(fontsize=12) plt.xlabel(r'$\nu$ MHz',fontsize=14) #plt.legend(fontsize = 9, loc='best') ## Plot amplitude: plt.subplot(2,3,4) #plt.errorbar(freqMHz_highsnr,paramset_highsnr[2]*pbs) plt.errorbar(freqMHz_highsnr,paramset_highsnr[2]*pbs,yerr =paramsetstd_highsnr[2]*pbs, fmt = markr,markersize=msize,capthick=2,linewidth=1.5,alpha=alfval) plt.ylabel(r'$\mu$ (sec)') plt.title(r'Amplitude evolution', fontsize=12) plt.yticks(fontsize=12) plt.xticks(fontsize=12) plt.xlabel(r'$\nu$ MHz',fontsize=14) #plt.legend(fontsize = 9, loc='best') ## Plot DC: plt.subplot(2,3,5) #plt.errorbar(freqMHz_highsnr,paramset_highsnr[2]*pbs) plt.errorbar(freqMHz_highsnr,paramset_highsnr[3]*pbs,yerr =paramsetstd_highsnr[3]*pbs, fmt = markr,markersize=msize,capthick=2,linewidth=1.5,alpha=alfval) plt.ylabel(r'$\mu$ (sec)') plt.title(r'DC offset', fontsize=12) plt.yticks(fontsize=12) plt.xticks(fontsize=12) plt.xlabel(r'$\nu$ MHz',fontsize=14) #plt.legend(fontsize = 9, loc='best') ## Plot DM: plt.subplot(2,3,6) plt.errorbar(delmuarray,freqMHz_highsnr, fmt = markr, xerr=delmu_stdarray, alpha = alfval, markersize=msize) plt.plot(DMmodelfit,freqMHz_highsnr, '-', label=r'DM: $%.3f \pm %.3f$ $\rm{pc.cm}^{-3}$' %(DMval,DMvalstd), alpha = alfval) plt.xlabel(r'$\Delta \mu$ (sec)', fontsize =12) plt.yticks(fontsize=12) plt.xticks(fontsize=12) plt.title('Delta DM', fontsize=12) plt.ylabel(r'$\nu$ (MHz)',fontsize=14) plt.ticklabel_format(style='sci', axis='x',scilimits=(0,0)) plt.legend(fontsize = 10, loc='best') plt.tight_layout() if savefigure == True: figname2 = '%s_%s.png' %(os.path.basename(filepath),'fitting_parameters') plt.savefig(figname2, dpi=200) print "Saved figure %s in ./" %figname2 if noshow == False: plt.show() if plotflux == True: ##Flux section needs debugging ls = 'solid' """Plot flux, and corrected flux spectrum""" """Create unscattered profiles, i.e. Guassians""" bins, profiles = [],[makeprofile(nbins = nbins, ncomps = 1, amps = paramset_highsnr[2][j], means = paramset_highsnr[1][j], sigmas = paramset_highsnr[0][j]) for j in range(npch)] unscatflux = [] for i in range(npch): unscatfl = np.sum(profiles[j])/nbins unscatflux.append(unscatfl) #smootheddata = smooth(data_highsnr[j],int(0.05*nbins)) scatflux = [find_modelflux(model_highsnr[i],nbins) for i in range(npch)] climbvals = [] for i in range(npch): climb = returnclimb(np.linspace(1,nbins,nbins),paramset_highsnr[1][i],paramset_highsnr[0][i],paramset_highsnr[2][i],taussec_highsnr[i],paramset_highsnr[3][i],nbins) climbvals.append(climb) correctedflux = np.array([scatflux[i] + climbvals[i] for i in range(npch)]) print scatflux print climbvals #per bin meancorflux = np.mean(correctedflux) meancorfluxerr = np.sqrt(np.sum(correctedflux**2))/len(correctedflux) """Calculate error in Flux""" sigmaWIDTH = paramsetstd_highsnr[0]*pbs #in seconds sigmaAMP = paramsetstd_highsnr[2] #in mJy WIDTHS =paramset_highsnr[0]*pbs #in seconds AMPS =paramset_highsnr[2] #in mJy Expr1 = np.sqrt(2*np.pi)*AMPS Expr2 = np.sqrt(WIDTHS) AreaExpression = Expr1*Expr2 sigmaEx1 = np.sqrt(2*np.pi)*sigmaAMP sigmaEx2 = Expr2*0.5*sigmaWIDTH/WIDTHS sigmaFlux =AreaExpression*np.sqrt(np.power(sigmaEx1/Expr1,2)+ np.power(sigmaEx2/Expr2,2))#+ 2*corsigA_highsnr*sigmaEx1*sigmaEx2/(Expr1*Expr2) plt.figure(figsize=(10,6)) plt.plot(freqMHz_highsnr, correctedflux,'k-', linewidth=2.0) plt.plot(freqMHz_highsnr, scatflux,'r--', linewidth=2.0) plt.fill_between(freqMHz_highsnr,scatflux,correctedflux, alpha=alfval,facecolor='r') eb = plt.errorbar(freqMHz_highsnr,correctedflux,yerr=sigmaFlux, fmt=markr,markersize=10.0, alpha=1.0,capthick=2,linewidth=1.5) eb[-1][0].set_linestyle(ls) #plt.errorbar(freqMHz_highsnr, unscatflux,yerr=sigmaFlux, fmt=markr,markersize=10.0, alpha=alfval) plt.title('Flux Spectrum', fontsize=12) plt.xticks(fontsize=12) plt.yticks(fontsize=12) plt.xlabel(r'$\nu$ (MHz)',fontsize=12) plt.ylabel(r'Calibrated flux (mJy)',fontsize=12) return freqMHz_highsnr, taussec_highsnr, lmfitstdssec_highsnr
freqtaufile_1D = np.loadtxt(os.path.join(txtpath_1D, filename)) freqtaus_1D.append(freqtaufile_1D) pulsars_1D.append(pulsar_1D) """Do tau fits with power law model""" powmod = PowerLawModel() alphas = [] alphaerrs = [] fits = [] alphas1D = [] alphaerrs1D = [] fits1D = [] for i in range(len(pulsars)): powpars = powmod.guess(freqtaus[i][:, 1], x=freqtaus[i][:, 0]) powout = powmod.fit(freqtaus[i][:, 1], powpars, x=freqtaus[i][:, 0], weights=1 / ((freqtaus[i][:, 2])**2)) fit = powout.best_fit alpha = -powout.best_values['exponent'] alphaerr = powout.params['exponent'].stderr alphas.append(alpha) alphaerrs.append(alphaerr) fits.append(fit) powpars1D = powmod.guess(freqtaus_1D[i][:, 1], x=freqtaus_1D[i][:, 0]) powout1D = powmod.fit(freqtaus_1D[i][:, 1], powpars1D, x=freqtaus_1D[i][:, 0],
def CurveFitting(self, frec, Pxx, iaf, ax): 'Non-Linear Least-Squares Minimization and Curve-Fitting for Python' # ----- adjusting a model to the obtained PSD ----- # model 1: constante g1 = ConstantModel(prefix='g1_') pars = g1.guess(Pxx, x=frec) pars['g1_c'].set(0) # model 2: k2/f^-1 g2 = PowerLawModel(prefix='g2_') pars += g2.guess(Pxx, x=frec) pars['g2_exponent'].set(-1) #model 3: probability density function g3 = GaussianModel(prefix='g3_') pars += g3.guess(Pxx, x=frec) pars['g3_center'].set(iaf, min=iaf - 2, max=iaf + 2) # model 4: probability density function g4 = GaussianModel(prefix='g4_') pars += g4.guess(Pxx, x=frec) pars['g4_center'].set(20, min=16, max=25) # final model gA = g1 + g2 + g3 + g4 outA = gA.fit(Pxx, pars, x=frec) diffA = np.sum(Pxx - outA.best_fit) gB = g1 + g2 + g3 outB = gB.fit(Pxx, pars, x=frec) diffB = np.sum(Pxx - outB.best_fit) gC = g1 + g2 outC = gC.fit(Pxx, pars, x=frec) diffC = np.sum(Pxx - outC.best_fit) diffs = np.abs([diffA, diffB, diffC]) idx = np.where(diffs == np.min(diffs))[0][0] out = [outA, outB, outC][idx] # ----- plotting the desire PSD ----- # original and fitted curves ax.plot(frec, Pxx, 'k', linewidth=2, label='PSD') ax.plot(frec, out.best_fit, 'b.-', linewidth=2, markersize=9, label='BestModel') ax.set_xlim(frec[0], 32) ax.set_ylim(ymin=0) ax.tick_params(axis='both', labelsize=16) ax.set_xlabel('Frequency [Hz]', fontsize='x-large') ax.grid() # components of the fitted curved comps = out.eval_components(x=frec) g12 = comps['g1_'] + comps['g2_'] ax.plot(frec, g12, 'g--', linewidth=2, label='PowerLawModel') idx1, idx2 = np.where(frec >= 5)[0][0], np.where(frec <= 15)[0][-1] # final value on the subplot if out != outC: diffs = out.best_fit[idx1:idx2] - g12[idx1:idx2] peak1 = np.amax(diffs) idx = np.where(diffs == peak1)[0] idx += len(out.best_fit[:idx1]) ax.plot((frec[idx], frec[idx]), (g12[idx], out.best_fit[idx]), 'r-o', linewidth=3, markersize=9) ax.text(frec[idx], g12[idx], str(np.around(peak1, decimals=2)), horizontalalignment='right', verticalalignment='top', color='r', fontsize='xx-large') else: peak1 = 0 # optional valued on the subplot diffs = Pxx[idx1:idx2] - g12[idx1:idx2] peak2 = np.amax(diffs) idx = np.where(peak2 == diffs)[0] idx += len(Pxx[:idx1]) ax.plot((frec[idx], frec[idx]), (g12[idx], Pxx[idx]), 'r-*', linewidth=3, markersize=11) ax.text(frec[idx], Pxx[idx], str(np.around(peak2, decimals=2)), horizontalalignment='left', verticalalignment='top', color='r', fontsize='xx-large') ax.legend(loc='upper right', shadow=True) return peak1, peak2