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 measure_eqw(wav,
flux,
z,
continuum_region=[[6000., 6250.] * u.AA,
[6800., 7000.] * u.AA],
eqw_region=[6400, 6800] * u.AA):
# Test if wav has units. If it does convert to Angstroms. If it doesn't
# then give it units. This might be a bit hacky.
try:
wav.unit
wav = wav.to(u.AA)
except AttributeError:
wav = wav * u.AA
wav = wav / (1.0 + z)
# eqw region
eqw_inds = (wav > eqw_region[0]) & (wav < eqw_region[1])
# index is true in the region where we fit the continuum
blue_inds = (wav > continuum_region[0][0]) & (wav < continuum_region[0][1])
red_inds = (wav > continuum_region[1][0]) & (wav < continuum_region[1][1])
xdat = np.array(
[continuum_region[0].mean().value, continuum_region[1].mean().value])
ydat = np.array([np.median(flux[blue_inds]), np.median(flux[red_inds])])
# fit power-law to continuum region
mod = PowerLawModel()
pars = mod.make_params()
pars['exponent'].value = 1.0
pars['amplitude'].value = 1.0
out = minimize(resid, pars, args=(xdat, mod, ydat), method='leastsq')
# Normalised flux
f = flux / mod.eval(params=pars, x=wav.value)
eqw = (f[eqw_inds][:-1] - 1.0) * np.diff(wav[eqw_inds])
# fig, ax = plt.subplots()
#
# ax.scatter(wav[blue_inds] , flux[blue_inds], c='red')
# ax.scatter(wav[red_inds] , flux[red_inds], c='red')
# ax.scatter(wav[eqw_inds], flux[eqw_inds])
# ax.scatter(xdat, ydat, c='yellow', s=70)
# xs = np.arange( xdat.min(), xdat.max(), 1)
# ax.plot( xs, mod.eval(params=pars, x=xs) , c='red')
# plt.show()
# plt.close()
return eqw.sum()
def MTF(Y, X):
"""
Fit a polynomial to the MTF curve
"""
pow_mod = PowerLawModel(prefix='pow_')
lin_mod = LinearModel(prefix="lin_")
const_mod = Model(sigmoid)
poly_mod = PolynomialModel(3)
#X = list(reversed(X))
pars = poly_mod.guess(Y, x=X) + lin_mod.guess(Y, x=X)
model = poly_mod + lin_mod
result = model.fit(Y, pars, x=X)
# write error report
print result.fit_report()
c0 = result.best_values['c0']
c1 = result.best_values['c1']
c2 = result.best_values['c2']
slop = result.best_values['lin_slope']
inter = result.best_values['lin_intercept']
# c3 = result.best_values['c3']
# c4 = result.best_values['c4']
# c5 = result.best_values['c5']
# c6 = result.best_values['c6']
# A = result.best_values["amplitude"]
# k = result.best_values["exponent"]
limit = polynomial(c0,c1,c2,inter,slop,10.)
# limit = A*9**k
return result.best_fit, limit
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
if re.match(GRB, x):
z = j[1]
d_l = j[2]
# call on luminosity function to plot lum curves
lum = L(flux, d_l, z, beta)
lum_err = L_err(flux_err, d_l, z, beta)
# calculating best fit parameters and covariances for the data lmfit
# call on weight function to get the weights of the luminosity errorss
weight_lum = weight(lum_err)
# making power law model for linear fits
model1 = PowerLawModel(prefix='pow_')
# make parameters with starting values
par1 = model1.make_params(pow_amplitude=1e30,
pow_exponent=-1.0)
# create results for these parameters using the weights
result1 = model1.fit(lum, par1, x=time, weights=weight_lum)
# get a and N from the results
a1, N1 = result1.best_values[
'pow_exponent'], result1.best_values['pow_amplitude']
# call on power law function to create line with these parameters
decay_line = power_law1(time, N1, a1)
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
"""DROP DATA ASSOCIATED WITH ZERO TAU ERRORS (i.e. zeros in the last column)"""
#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)
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
w2 = 1 / lum_err[idx2]
else:
lum1 = lum[idx2]
lum2 = lum[idx1]
T1 = T[idx2]
T2 = T[idx1]
w1 = 1 / lum_err[idx2]
w2 = 1 / lum_err[idx1]
log_T = np.log10(T)
log_lum = np.log10(lum)
log_Ts = np.log10(Ts)
#calculating best fit parameters and covariances for the data lmfit
#making powerlaw model for linear fits
model1 = PowerLawModel(prefix='pow_')
#making powerlaw model for log fits
model2 = LinearModel(independent_vars=['x'])
# make parameters with starting values:
par1 = model1.make_params(pow_amplitude=1e55,
pow_exponent=-1.0) #linear powerlaw
par2 = model2.make_params(m=1, c=55) #log
par3 = model1.make_params(pow_amplitude=1e5, pow_exponent=-1.0)
par4 = model1.make_params(pow_amplitude=1e52,
pow_exponent=-1.0)
np.nan_to_num(weight_lum_new, copy=False)
#running sets of fits
result1 = model1.fit(
w2 = 1 / lum_err[idx2]
else:
lum1 = lum[idx2]
lum2 = lum[idx1]
T1 = T[idx2]
T2 = T[idx1]
w1 = 1 / lum_err[idx2]
w2 = 1 / lum_err[idx1]
log_T = np.log10(T)
log_lum = np.log10(lum)
log_Ts = np.log10(Ts)
#calculating best fit parameters and covariances for the data lmfit
#making powerlaw model for linear fits
model1 = PowerLawModel(prefix='pow_')
#making powerlaw model for log fits
model2 = LinearModel(independent_vars=['x'])
# make parameters with starting values:
par1 = model1.make_params(pow_amplitude=1e55,
pow_exponent=-1.0)
par2 = model2.make_params(m=1, c=55)
np.nan_to_num(weight_lum_new, copy=False)
#running both sets of fits
result1 = model1.fit(
lum, par1, x=T,
weights=weight_lum) #linear whole with weights
result2 = model1.fit(
pulsar = filename[0:10]
freqtaufile = np.loadtxt(os.path.join(txtpath_iso, filename))
freqtaus.append(freqtaufile)
pulsars.append(pulsar)
freqtaus_1D = []
pulsars_1D = []
for filename in os.listdir(txtpath_1D):
pulsar_1D = filename[0:10]
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
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