def combine_flux(src_all,src_g,accepted_inds,num_matches):
'''Takes a src_group() class that contains all group info. Indentifies which catalogue is repeated, combines
the fluxes and fits a new line. Returns the reduced frequency list, the combined flux and flux error
arrays, as well as the line_fit object and residuals'''
##Find repeated catalogues
repeated_cats = set([src_all.cats[ind] for ind in accepted_inds if src_all.cats.count(src_all.cats[ind])>1])
##This won't neccesarily be in the that the cats appear in src_all.cats so reorder
repeat_indexs = [src_all.cats.index(cat) for cat in repeated_cats]
repeated_cats = [cat for ind,cat in sorted(zip(repeat_indexs,repeated_cats),key=lambda pair: pair[0])]
##These are used to test the combined spectrum
temp_freqs = [src_all.freqs[i] for i in xrange(len(src_all.freqs)) if src_all.cats[i] not in repeated_cats]
temp_fluxs = [src_all.fluxs[i] for i in xrange(len(src_all.fluxs)) if src_all.cats[i] not in repeated_cats]
temp_ferrs = [src_all.ferrs[i] for i in xrange(len(src_all.ferrs)) if src_all.cats[i] not in repeated_cats]
##Will need these for fitting/passing on to plotting function
comb_freqs = []
comb_fluxs = []
comb_ferrs = []
ra_ws = []
dec_ws = []
rerr_ws = []
derr_ws = []
##Need these in case of doing the split test
resolved_diff_inds = []
unrepeat_dists = []
num_of_repeats = []
for repeat_cat in repeated_cats:
num_of_repeat = [i for i in xrange(len(src_all.names)) if (src_all.cats[i]==repeat_cat) and (i in accepted_inds)]
num_of_repeats.append(num_of_repeat)
for cat,name in zip(src_g.cats[1:],src_g.names[1:]):
if cat not in repeated_cats and cat != '100000.0':
if cat == 'vlssr':
src_g.vlssr = name
elif cat == 'mrc':
src_g.mrc = name
elif cat == 'sumss':
src_g.sumss = name
elif cat == 'nvss':
src_g.nvss = name
else:
pass
##For each repeated catalogue:
for repeat_cat in repeated_cats:
##Find the frequency/ies of repeated cat
comb_freq = src_all.freqs[src_all.cats.index(repeat_cat)]
##Find the flux/es of the repeat_cat sources that were accepted by retained_sources()
flux_to_comb = [src_all.fluxs[i] for i in xrange(len(src_all.fluxs)) if (src_all.cats[i]==repeat_cat) and (i in accepted_inds)]
##Find the flux error/s of the repeat_cat sources that were accepted by retained_sources()
ferr_to_comb = [src_all.ferrs[i] for i in xrange(len(src_all.ferrs)) if (src_all.cats[i]==repeat_cat) and (i in accepted_inds)]
##ALso find all of the positional information to combine
ras_to_comb = [src_all.ras[i] for i in xrange(len(src_all.ras)) if (src_all.cats[i]==repeat_cat) and (i in accepted_inds)]
rerrs_to_comb = [src_all.rerrs[i] for i in xrange(len(src_all.rerrs)) if (src_all.cats[i]==repeat_cat) and (i in accepted_inds)]
decs_to_comb = [src_all.decs[i] for i in xrange(len(src_all.decs)) if (src_all.cats[i]==repeat_cat) and (i in accepted_inds)]
derrs_to_comb = [src_all.derrs[i] for i in xrange(len(src_all.derrs)) if (src_all.cats[i]==repeat_cat) and (i in accepted_inds)]
##This is to write down all the names of the sources combined
names_to_comb = [src_all.names[i] for i in xrange(len(src_all.names)) if (src_all.cats[i]==repeat_cat) and (i in accepted_inds)]
name_string = ''
for name in names_to_comb: name_string += ','+name
if repeat_cat == 'vlssr':
src_g.vlssr = name_string[1:]
elif repeat_cat == 'mrc':
src_g.mrc = name_string[1:]
elif repeat_cat == 'sumss':
src_g.sumss = name_string[1:]
elif repeat_cat == 'nvss':
src_g.nvss = name_string[1:]
elif repeat_cat == 'atg20':
src_g.atg20 = name_string[1:]
else:
pass
##TEST TO SEE IF THE REPEATED SOURCES ARE RESOLVED (BY A GIVEN RESOLUTION THRESHOLD)
##Need to do the split test here even if not propagating to the final catalogue
##-------------------------------------------------------------------------------------------------------
##Give it a value even if not splitting
dist_test = 0.020833333 ##1.25 arcmin
big_inds = []
n = len(ras_to_comb)
for i in range(0,n+1):
for j in range(i+1,n):
dist = mkl.arcdist(ras_to_comb[i],ras_to_comb[j],decs_to_comb[i],decs_to_comb[j])
if dist>dist_test:
big_inds.append([i,j])
resolved_diff_inds.append(big_inds)
##-------------------------------------------------------------------------------------------------------
comb_flux = sum(flux_to_comb) #Sum the fluxes
comb_ferr = np.zeros(1)
for ferr in ferr_to_comb: comb_ferr+= ferr**2 #Add the errors in quadrature
comb_ferr = comb_ferr**0.5
##Need these later to fit the combined flux and to populate a new src_g if
##the fit passes
temp_freqs.append(comb_freq)
temp_fluxs.append([comb_flux])
temp_ferrs.append([comb_ferr[0]])
comb_freqs.append(comb_freq)
comb_fluxs.append(comb_flux)
comb_ferrs.append(comb_ferr)
##Weight by the first flux in the flux list (in case catalogue has multiple frequencies)
flux_s = [flux[0] for flux in flux_to_comb]
##A a little code in case sources are very close to RA=0, and some are reporting 359.9,
##and others 0.001 - if you don't account for this, the weigthed position goes mental
wrap = 'no'
for combo in combinations(ras_to_comb,2):
diff = combo[0]-combo[1]
if abs(diff)>180.0:
wrap='yes'
if wrap=='yes':
for i in xrange(len(ras_to_comb)):
if ras_to_comb[i]<180.0:
ras_to_comb[i]+=360.0
##Weight the sources by their flux
weights = [flux/sum(flux_s) for flux in flux_s]
##Do the weighting, if weighted RA is above 360 deg, rescale,
##add the errors as shown in the write up
ra_w = np.dot(ras_to_comb,weights)
if ra_w>360.0: ra_w-=360.0
dec_w = np.dot(decs_to_comb,weights)
rerr_w = (np.dot(rerrs_to_comb,weights)**2)**0.5
derr_w = (np.dot(derrs_to_comb,weights)**2)**0.5
ra_ws.append(ra_w)
dec_ws.append(dec_w)
rerr_ws.append(rerr_w)
derr_ws.append(derr_w)
##Flag distance between repeated cats as being larger than designated resolution
big_flags = [0 for i in xrange(len(resolved_diff_inds))]
for i in xrange(len(resolved_diff_inds)):
if len(resolved_diff_inds[i])>0: big_flags[i] = 1
##Now each repeat_cat has a 1 flag if large separation, 0 if not
set_freqs = []
set_fluxs = []
set_ferrs = []
set_fits = []
set_jstat = []
set_bse = []
set_red = []
set_cats = []
set_names = []
big_sep = 'no'
##If all repeated cats have large separation, and they have the same amount of repeated sources:
if 0 not in big_flags and len(list(set([len(reap) for reap in num_of_repeats])))==1:
##If more than one repeated cat (need more than one data point to get some spectral info)
if len(repeated_cats)>1:
##Find the 'sub' set matches, so sources that could be combined to make components
sets = []
#name_sets = []
for src in num_of_repeats[0]:
match = [src]
#names = [src_all.names[src]]
for other_srcs in num_of_repeats[1:]:
for other_src in other_srcs:
if mkl.arcdist(src_all.ras[src],src_all.ras[other_src],src_all.decs[src],src_all.decs[other_src])<dist_test:
match.append(other_src)
#names.append(src_all.names[other_src])
sets.append(match)
#name_sets.append(names)
##If all the sets found have the same amount of components, and only have one source from
##each repeated catalogue
if len(list(set([len(sset) for sset in sets])))==1 and len(sets[0])==len(repeated_cats):
big_sep = 'yes'
for sset in sets:
freqs = [src_all.freqs[src][0] for src in sset]
fluxs = [src_all.fluxs[src][0] for src in sset]
ferrs = [src_all.ferrs[src][0] for src in sset]
names = [src_all.names[src] for src in sset]
cats = [src_all.cats[src] for src in sset]
set_freqs.append(freqs)
set_fluxs.append(fluxs)
set_ferrs.append(ferrs)
set_names.append(names)
set_cats.append(cats)
flux_to_weight = [src_all.fluxs[i][0] for i in xrange(len(src_all.fluxs)) if (src_all.cats[i] not in repeated_cats)]
freq_to_weight = [src_all.freqs[i][0] for i in xrange(len(src_all.freqs)) if (src_all.cats[i] not in repeated_cats)]
ferr_to_weight = [src_all.ferrs[i][0] for i in xrange(len(src_all.ferrs)) if (src_all.cats[i] not in repeated_cats)]
cats_to_weight = [src_all.cats[i] for i in xrange(len(src_all.cats)) if (src_all.cats[i] not in repeated_cats)]
names_to_weight = [src_all.names[i] for i in xrange(len(src_all.names)) if (src_all.cats[i] not in repeated_cats)]
##Find all the fluxs of the repeated cats, come up with weights for the single sources based on each
##individual repeated catalogue, then take an average of these weights
fluxs_for_weights = [[src_all.fluxs[sset[src]][0] for sset in sets] for src in xrange(len(sets[0]))]
fluxs_weights = [[flux/sum(fluxs) for flux in fluxs] for fluxs in fluxs_for_weights]
flux_weights = np.array([np.mean([[weights[weight]] for weights in fluxs_weights]) for weight in xrange(len(fluxs_weights[0]))])
##For each set of freq,fluxs in the new set matched, append the weighted freq, flux and ferr of the
##sources that have been split up
for i in xrange(len(set_freqs)):
weighted_fluxs = np.array(flux_to_weight)*flux_weights[i]
weighted_errs = np.array(ferr_to_weight)*flux_weights[i]
for j in xrange(len(weighted_fluxs)):
set_freqs[i].append(freq_to_weight[j])
set_fluxs[i].append(weighted_fluxs[j])
set_ferrs[i].append(weighted_errs[j])
set_cats[i].append(cats_to_weight[j])
set_names[i].append(names_to_weight[j])
##For every set of frequencies, ferrs, names and fluxes in the set, order the fluxes, names and ferrs by the frequencies
set_fluxs = [[flux for flux,freq in sorted(zip(fluxs,freqs), key=lambda pair: pair[1]) ] for fluxs,freqs in zip(set_fluxs,set_freqs)]
set_ferrs = [[ferr for ferr,freq in sorted(zip(ferrs,freqs), key=lambda pair: pair[1]) ] for ferrs,freqs in zip(set_ferrs,set_freqs)]
set_cats = [[cat for cat,freq in sorted(zip(cats,freqs), key=lambda pair: pair[1]) ] for cats,freqs in zip(set_cats,set_freqs)]
set_names = [[name for name,freq in sorted(zip(names,freqs), key=lambda pair: pair[1]) ] for names,freqs in zip(set_names,set_freqs)]
set_freqs = [sorted(freq) for freq in set_freqs]
for i in xrange(len(set_fluxs)):
freqs = set_freqs[i]
fluxs = set_fluxs[i]
ferrs = set_ferrs[i]
fit,jstat,bse,red = mkl.fit_line(np.log(freqs),np.log(fluxs),np.array(ferrs)/np.array(fluxs))
set_fits.append(fit)
set_jstat.append(jstat)
set_bse.append(bse)
set_red.append(red)
log_temp_freqs = []
log_temp_fluxs = []
log_temp_ferrs = []
#Get the sources out of the array in list format (which is used later when making the sources
##to add to the final table)
for i in xrange(len(temp_freqs)):
for j in xrange(len(temp_freqs[i])):
if temp_fluxs[i][j] == -100000.0 or np.isnan(temp_fluxs[i][j])==True:
pass
else:
log_temp_freqs.append(np.log(temp_freqs[i][j]))
for i in xrange(len(temp_freqs)):
for j in xrange(len(temp_freqs[i])):
if temp_fluxs[i][j] == -100000.0 or np.isnan(temp_fluxs[i][j])==True:
pass
else:
log_temp_fluxs.append(np.log(temp_fluxs[i][j]))
for i in xrange(len(temp_freqs)):
for j in xrange(len(temp_freqs[i])):
if temp_fluxs[i][j] == -100000.0 or np.isnan(temp_fluxs[i][j])==True:
pass
else:
log_temp_ferrs.append(temp_ferrs[i][j]/temp_fluxs[i][j])
##Fit and find residuals to the combined spectrum
comb_fit,comb_jstat,comb_bse,comb_chi_red = mkl.fit_line(np.array(log_temp_freqs),np.array(log_temp_fluxs),np.array(log_temp_ferrs))
##Find out where in srg_g the repeated cats appear
repeat_cat_inds = [src_g.cats.index(cat) for cat in repeated_cats]
split_flag=''
##Make labels for when we're plotting a put in combined_names
combined_names = []
#if comb_jstat<=jstat_thresh or comb_chi_red<=chi_thresh:
##Create the combined source no matter what for plotting purposes
##Loop over all the combined sources and repopulate the entries of a src_g
##at the point where the repeated catalogues appear
for i in xrange(len(comb_fluxs)):
srcg_ind = repeat_cat_inds[i]
src_g.ras[srcg_ind] = ra_ws[i]
src_g.rerrs[srcg_ind] = rerr_ws[i]
src_g.decs[srcg_ind] = dec_ws[i]
src_g.derrs[srcg_ind] = derr_ws[i]
src_g.PAs[srcg_ind] = -100000.0
src_g.majors[srcg_ind] = -100000.0
src_g.minors[srcg_ind] = -100000.0
src_g.names[srcg_ind] = "Combined-%s" %src_g.cats[srcg_ind]
combined_names.append("Combined-%s" %src_g.cats[srcg_ind])
src_g.fluxs[srcg_ind] = [comb_fluxs[i]]
src_g.ferrs[srcg_ind] = comb_ferrs[i]
#srg_g.freqs = temp_freqs
src_g.SI = float(comb_fit.params[0])
src_g.intercept = comb_fit.params[1]
src_g.SI_err = comb_bse[0]
src_g.intercept_err = comb_bse[1]
src_g.chi_resid = comb_chi_red
src_g.epsilon_red = comb_jstat
##If good fit, report that in the final stats object
if comb_chi_red<=2:
src_g.low_resids = 0
else:
src_g.low_resids = 1
dom_crit = 'Accepted -\ncombined'
return [src_g]
def plot_ind(match,ax,ind_ax,ax_spectral,ra_bottom,ra_top,dec_bottom,dec_top,dom_crit,comb_crit):
'''Takes a string of information of a particular combination and uses it
to create a plot of the single combination, and fit and plot a line to
the spectral information. Returns the positional probability, fitted paramaters
and the residuals of the fit'''
##Get the information from the particular match given
info = match.split()
indexes = [(14+((i-1)*3)) for i in num_freqs]
starts = [0]
for i in xrange(len(indexes)-1): starts.append(sum(indexes[:i+1]))
fluxs = []
freqs = []
ferrs = []
for j in xrange(len(starts)):
ind = starts[j]
cat = info[ind]
if cat!='-100000.0':
#num_freq = num_freqs[j]
freq = num_freqs[j]
name = info[ind+1]
ra = float(info[ind+2])
rerr = float(info[ind+3])
dec = float(info[ind+4])
derr = float(info[ind+5])
nu = float(info[ind+6])
#flux = float(info[ind+7])
#ferr = float(info[ind+8])/flux
for k in xrange(freq):
if info[7+ind+(3*k)]!='-100000.0':
if np.isnan(float(info[7+ind+(3*k)])) == False:
freqs.append(float(info[6+ind+(3*k)]))
fluxs.append(float(info[7+ind+(3*k)]))
ferrs.append(float(info[8+ind+(3*k)])/float(info[7+ind+(3*k)]))
major = info[ind+9+((freq-1)*3)]
minor = info[ind+10+((freq-1)*3)]
PA = info[ind+11+((freq-1)*3)]
#fluxs.append(flux)
#freqs.append(nu)
#ferrs.append(ferr)
##Plot each source on the individual combo plot
plot_all(cat,name,ra,rerr,dec,derr,major,minor,PA,ax,1.0)
##Sort the frequencies, fluxes and log them
log_fluxs = np.log([flux for (freq,flux) in sorted(zip(freqs,fluxs),key=lambda pair: pair[0])])
sorted_ferrs = np.array([ferr for (freq,ferr) in sorted(zip(freqs,ferrs),key=lambda pair: pair[0])])
log_freqs = np.log(sorted(freqs))
ferrs = np.array(ferrs)
prob = info[-1]
##Fit a line using weighted least squares and plot it
lin_fit,jstat,bse,chi_red = mkl.fit_line(log_freqs,log_fluxs,sorted_ferrs)
ax.text(0.5,0.925, 'P$_{%d}$=%.2f' %(ind_ax+1,float(prob)), transform=ax.transAxes,verticalalignment='center',horizontalalignment='center',fontsize=16)
ax.text(0.5,0.06, '$\epsilon_{%d}$=%.2f $\chi_{%d}$=%.1f' %(ind_ax+1,jstat,ind_ax+1,chi_red),
transform=ax.transAxes,verticalalignment='center',horizontalalignment='center',fontsize=16)
ax.set_xlim(ra_bottom,ra_top)
ax.set_ylim(dec_bottom,dec_top)
##Plot RA backwards
ax.invert_xaxis()
##Plot the fitted spectral line, and return the plot object so we can create a legend from it
if dom_crit=='No dom. source':
if 'split' in comb_crit:
spec_plot = 'na'
else:
spec_plot, = ax_spectral.plot(np.exp(log_freqs),np.exp(lin_fit.fittedvalues),linestyle='-',linewidth=1,alpha=0.3)
else:
spec_plot, = ax_spectral.plot(np.exp(log_freqs),np.exp(lin_fit.fittedvalues),linestyle='-',linewidth=1,alpha=1)
return prob,jstat,spec_plot,lin_fit.params
def combine_all_flux(src_all,src_g):
'''Takes a src_group() class that contains all group info. Indentifies which catalogue is repeated, combines
the fluxes and fits a new line. Returns the reduced frequency list, the combined flux and flux error
arrays, as well as the line_fit object and residuals'''
accepted_inds = xrange(len(src_all.names))
##Find repeated catalogues
repeated_cats = set([src_all.cats[ind] for ind in accepted_inds if src_all.cats.count(src_all.cats[ind])>1])
##This won't neccesarily be in the that the cats appear in src_all.cats so reorder
repeat_indexs = [src_all.cats.index(cat) for cat in repeated_cats]
repeated_cats = [cat for ind,cat in sorted(zip(repeat_indexs,repeated_cats),key=lambda pair: pair[0])]
##These are used to test the combined spectrum
temp_freqs = [src_all.freqs[i] for i in xrange(len(src_all.freqs)) if src_all.cats[i] not in repeated_cats]
temp_fluxs = [src_all.fluxs[i] for i in xrange(len(src_all.fluxs)) if src_all.cats[i] not in repeated_cats]
temp_ferrs = [src_all.ferrs[i] for i in xrange(len(src_all.ferrs)) if src_all.cats[i] not in repeated_cats]
base_freqs = [src_all.freqs[i] for i in xrange(len(src_all.freqs)) if src_all.cats[i] not in repeated_cats]
base_fluxs = [src_all.fluxs[i] for i in xrange(len(src_all.fluxs)) if src_all.cats[i] not in repeated_cats]
base_ferrs = [src_all.ferrs[i] for i in xrange(len(src_all.ferrs)) if src_all.cats[i] not in repeated_cats]
base_cats = [src_all.cats[i] for i in xrange(len(src_all.ferrs)) if src_all.cats[i] not in repeated_cats]
base_ras = [src_all.ras[i] for i in xrange(len(src_all.ferrs)) if src_all.cats[i] not in repeated_cats]
base_rerrs = [src_all.rerrs[i] for i in xrange(len(src_all.ferrs)) if src_all.cats[i] not in repeated_cats]
base_decs = [src_all.decs[i] for i in xrange(len(src_all.ferrs)) if src_all.cats[i] not in repeated_cats]
base_derrs = [src_all.derrs[i] for i in xrange(len(src_all.ferrs)) if src_all.cats[i] not in repeated_cats]
base_majors = [src_all.majors[i] for i in xrange(len(src_all.ferrs)) if src_all.cats[i] not in repeated_cats]
base_minors = [src_all.minors[i] for i in xrange(len(src_all.ferrs)) if src_all.cats[i] not in repeated_cats]
base_PAs = [src_all.PAs[i] for i in xrange(len(src_all.ferrs)) if src_all.cats[i] not in repeated_cats]
base_names = [src_all.names[i] for i in xrange(len(src_all.ferrs)) if src_all.cats[i] not in repeated_cats]
##Will need these for fitting/passing on to plotting function
comb_freqs = []
comb_fluxs = []
comb_ferrs = []
ra_ws = []
dec_ws = []
rerr_ws = []
derr_ws = []
##Need these in case of doing the split test
resolved_diff_inds = []
unrepeat_dists = []
num_of_repeats = []
for repeat_cat in repeated_cats:
num_of_repeat = [i for i in xrange(len(src_all.names)) if (src_all.cats[i]==repeat_cat) and (i in accepted_inds)]
num_of_repeats.append(num_of_repeat)
for cat,name in zip(src_g.cats[1:],src_g.names[1:]):
if cat not in repeated_cats and cat != '100000.0':
if cat == 'vlssr':
src_g.vlssr = name
elif cat == 'mrc':
src_g.mrc = name
elif cat == 'sumss':
src_g.sumss = name
elif cat == 'nvss':
src_g.nvss = name
elif cat == 'atg20':
src_g.atg20 = name
else:
pass
##For each repeated catalogue:
for repeat_cat in repeated_cats:
##Find the frequency/ies of repeated cat
comb_freq = src_all.freqs[src_all.cats.index(repeat_cat)]
##Find the flux/es of the repeat_cat sources that were accepted by retained_sources()
flux_to_comb = [src_all.fluxs[i] for i in xrange(len(src_all.fluxs)) if (src_all.cats[i]==repeat_cat) and (i in accepted_inds)]
##Find the flux error/s of the repeat_cat sources that were accepted by retained_sources()
ferr_to_comb = [src_all.ferrs[i] for i in xrange(len(src_all.ferrs)) if (src_all.cats[i]==repeat_cat) and (i in accepted_inds)]
##ALso find all of the positional information to combine
ras_to_comb = [src_all.ras[i] for i in xrange(len(src_all.ras)) if (src_all.cats[i]==repeat_cat) and (i in accepted_inds)]
rerrs_to_comb = [src_all.rerrs[i] for i in xrange(len(src_all.rerrs)) if (src_all.cats[i]==repeat_cat) and (i in accepted_inds)]
decs_to_comb = [src_all.decs[i] for i in xrange(len(src_all.decs)) if (src_all.cats[i]==repeat_cat) and (i in accepted_inds)]
derrs_to_comb = [src_all.derrs[i] for i in xrange(len(src_all.derrs)) if (src_all.cats[i]==repeat_cat) and (i in accepted_inds)]
##This is to write down all the names of the sources combined
names_to_comb = [src_all.names[i] for i in xrange(len(src_all.names)) if (src_all.cats[i]==repeat_cat) and (i in accepted_inds)]
name_string = ''
for name in names_to_comb: name_string += ','+name
if repeat_cat == 'vlssr':
src_g.vlssr = name_string[1:]
elif repeat_cat == 'mrc':
src_g.mrc = name_string[1:]
elif repeat_cat == 'sumss':
src_g.sumss = name_string[1:]
elif repeat_cat == 'nvss':
src_g.nvss = name_string[1:]
elif repeat_cat == 'atg20':
src_g.atg20 = name_string[1:]
else:
pass
##TEST TO SEE IF THE REPEATED SOURCES ARE RESOLVED (BY A GIVEN RESOLUTION THRESHOLD)
##Need to do the split test here even if not propagating to the final catalogue
##-------------------------------------------------------------------------------------------------------
comb_flux = sum(flux_to_comb) #Sum the fluxes
comb_ferr = np.zeros(1)
for ferr in ferr_to_comb: comb_ferr+= ferr**2 #Add the errors in quadrature
comb_ferr = comb_ferr**0.5
##Need these later to fit the combined flux and to populate a new src_g if
##the fit passes
temp_freqs.append(comb_freq)
temp_fluxs.append([comb_flux])
temp_ferrs.append([comb_ferr[0]])
comb_freqs.append(comb_freq)
comb_fluxs.append(comb_flux)
comb_ferrs.append(comb_ferr)
##Weight by the first flux in the flux list (in case catalogue has multiple frequencies)
flux_s = [flux[0] for flux in flux_to_comb]
##A a little code in case sources are very close to RA=0, and some are reporting 359.9,
##and others 0.001 - if you don't account for this, the weigthed position goes mental
wrap = 'no'
for combo in combinations(ras_to_comb,2):
diff = combo[0]-combo[1]
if abs(diff)>180.0:
wrap='yes'
if wrap=='yes':
for i in xrange(len(ras_to_comb)):
if ras_to_comb[i]<180.0:
ras_to_comb[i]+=360.0
##Weight the sources by their flux
weights = [flux/sum(flux_s) for flux in flux_s]
##Do the weighting, if weighted RA is above 360 deg, rescale,
##add the errors as shown in the write up
ra_w = np.dot(ras_to_comb,weights)
if ra_w>360.0: ra_w-=360.0
dec_w = np.dot(decs_to_comb,weights)
rerr_w = (np.dot(rerrs_to_comb,weights)**2)**0.5
derr_w = (np.dot(derrs_to_comb,weights)**2)**0.5
ra_ws.append(ra_w)
dec_ws.append(dec_w)
rerr_ws.append(rerr_w)
derr_ws.append(derr_w)
log_temp_freqs = []
log_temp_fluxs = []
log_temp_ferrs = []
#Get the sources out of the array in list format (which is used later when making the sources
##to add to the final table)
for i in xrange(len(temp_freqs)):
for j in xrange(len(temp_freqs[i])):
if temp_fluxs[i][j] == -100000.0 or np.isnan(temp_fluxs[i][j])==True:
pass
else:
log_temp_freqs.append(np.log(temp_freqs[i][j]))
for i in xrange(len(temp_freqs)):
for j in xrange(len(temp_freqs[i])):
if temp_fluxs[i][j] == -100000.0 or np.isnan(temp_fluxs[i][j])==True:
pass
else:
log_temp_fluxs.append(np.log(temp_fluxs[i][j]))
for i in xrange(len(temp_freqs)):
for j in xrange(len(temp_freqs[i])):
if temp_fluxs[i][j] == -100000.0 or np.isnan(temp_fluxs[i][j])==True:
pass
else:
log_temp_ferrs.append(temp_ferrs[i][j]/temp_fluxs[i][j])
##Fit and find residuals to the combined spectrum
comb_fit,comb_jstat,comb_bse,comb_chi_red = mkl.fit_line(np.array(log_temp_freqs),np.array(log_temp_fluxs),np.array(log_temp_ferrs))
##Find out where in srg_g the repeated cats appear
repeat_cat_inds = [src_g.cats.index(cat) for cat in repeated_cats]
split_flag=''
##Make labels for when we're plotting a put in combined_names
combined_names = []
#if comb_jstat<=jstat_thresh or comb_chi_red<=chi_thresh:
##Create the combined source no matter what for plotting purposes
##Loop over all the combined sources and repopulate the entries of a src_g
##at the point where the repeated catalogues appear
for i in xrange(len(comb_fluxs)):
srcg_ind = repeat_cat_inds[i]
src_g.ras[srcg_ind] = ra_ws[i]
src_g.rerrs[srcg_ind] = rerr_ws[i]
src_g.decs[srcg_ind] = dec_ws[i]
src_g.derrs[srcg_ind] = derr_ws[i]
src_g.PAs[srcg_ind] = -100000.0
src_g.majors[srcg_ind] = -100000.0
src_g.minors[srcg_ind] = -100000.0
src_g.names[srcg_ind] = "Combined-%s" %src_g.cats[srcg_ind]
combined_names.append("Combined-%s" %src_g.cats[srcg_ind])
src_g.fluxs[srcg_ind] = [comb_fluxs[i]]
src_g.ferrs[srcg_ind] = comb_ferrs[i]
##Need to make sure the single sources in src_all are used rather than
##whatever was in src_g
for i in xrange(len(base_fluxs)):
srcg_ind = src_g.cats.index(base_cats[i])
src_g.ras[srcg_ind] = base_ras[i]
src_g.rerrs[srcg_ind] = base_rerrs[i]
src_g.decs[srcg_ind] = base_decs[i]
src_g.derrs[srcg_ind] = base_derrs[i]
src_g.PAs[srcg_ind] = base_PAs[i]
src_g.majors[srcg_ind] = base_majors[i]
src_g.minors[srcg_ind] = base_minors[i]
src_g.names[srcg_ind] = base_names[i]
src_g.fluxs[srcg_ind] = base_fluxs[i]
src_g.ferrs[srcg_ind] = base_ferrs[i]
#srg_g.freqs = temp_freqs
src_g.SI = float(comb_fit.params[0])
src_g.intercept = comb_fit.params[1]
src_g.SI_err = comb_bse[0]
src_g.intercept_err = comb_bse[1]
src_g.chi_resid = comb_chi_red
src_g.epsilon_red = comb_jstat
##If good fit, report that in the final stats object
if comb_chi_red<=2:
src_g.low_resids = 0
else:
src_g.low_resids = 1
return src_g
def plot_ind(match,ax,ind_ax,ax_spectral,ra_bottom,ra_top,dec_bottom,dec_top,dom_crit,comb_crit):
'''Takes a string of information of a particular combination and uses it
to create a plot of the single combination, and fit and plot a line to
the spectral information. Returns the positional probability, fitted paramaters
and the residuals of the fit'''
##Get the information from the particular match given
info = match.split()
indexes = [(14+((i-1)*3)) for i in num_freqs]
starts = [0]
for i in np.arange(len(indexes)-1): starts.append(sum(indexes[:i+1]))
fluxs = []
freqs = []
ferrs = []
for j in np.arange(len(starts)):
ind = starts[j]
cat = info[ind]
if cat!='-100000.0':
#num_freq = num_freqs[j]
freq = num_freqs[j]
name = info[ind+1]
ra = float(info[ind+2])
rerr = float(info[ind+3])
dec = float(info[ind+4])
derr = float(info[ind+5])
nu = float(info[ind+6])
#flux = float(info[ind+7])
#ferr = float(info[ind+8])/flux
for k in np.arange(freq):
if info[7+ind+(3*k)]!='-100000.0':
if np.isnan(float(info[7+ind+(3*k)])) == False:
freqs.append(float(info[6+ind+(3*k)]))
fluxs.append(float(info[7+ind+(3*k)]))
ferrs.append(float(info[8+ind+(3*k)])/float(info[7+ind+(3*k)]))
major = info[ind+9+((freq-1)*3)]
minor = info[ind+10+((freq-1)*3)]
PA = info[ind+11+((freq-1)*3)]
#fluxs.append(flux)
#freqs.append(nu)
#ferrs.append(ferr)
##Plot each source on the individual combo plot
plot_all(cat,name,ra,rerr,dec,derr,major,minor,PA,ax,1.0)
#plot_all(cat,name,ra,rerr,dec,derr,major_RA,minor,PA,ax,1.0)
##Sort the frequencies, fluxes and log them
log_fluxs = np.log([flux for (freq,flux) in sorted(zip(freqs,fluxs),key=lambda pair: pair[0])])
sorted_ferrs = np.array([ferr for (freq,ferr) in sorted(zip(freqs,ferrs),key=lambda pair: pair[0])])
log_freqs = np.log(sorted(freqs))
ferrs = np.array(ferrs)
prob = info[-1]
##Fit a line using weighted least squares and plot it
lin_fit,jstat,bse,chi_red = mkl.fit_line(log_freqs,log_fluxs,sorted_ferrs)
ax.text(0.5,0.925, 'P$_{%d}$=%.2f' %(ind_ax+1,float(prob)), transform=ax.transAxes,verticalalignment='center',horizontalalignment='center',fontsize=16)
ax.text(0.5,0.06, '$\epsilon_{%d}$=%.2f $\chi_{%d}$=%.1f' %(ind_ax+1,jstat,ind_ax+1,chi_red),
transform=ax.transAxes,verticalalignment='center',horizontalalignment='center',fontsize=16)
ax.set_xlim(ra_bottom,ra_top)
ax.set_ylim(dec_bottom,dec_top)
##Plot RA backwards
ax.invert_xaxis()
##Plot the fitted spectral line, and return the plot object so we can create a legend from it
if dom_crit=='No dom. source':
if 'split' in comb_crit:
spec_plot = 'na'
else:
spec_plot, = ax_spectral.plot(np.exp(log_freqs),np.exp(lin_fit.fittedvalues),linestyle='-',linewidth=1,alpha=0.3)
else:
spec_plot, = ax_spectral.plot(np.exp(log_freqs),np.exp(lin_fit.fittedvalues),linestyle='-',linewidth=1,alpha=1)
return prob,jstat,spec_plot,lin_fit.params,bse
