def main():
import rating
import harmonic_rating
import pfd_ratings
import profile_ratings
import gaussian_ratings
if options.where is not None:
print "Using 'where clause':", options.where
D = rating.usual_database()
rating.run(D,
[gaussian_ratings.GaussianWidth(D),
gaussian_ratings.GaussianHeight(D),
gaussian_ratings.GaussianPhase(D),
gaussian_ratings.GaussianSignificance(D),
harmonic_rating.HarmonicRating(D),
profile_ratings.DutyCycle(D),
profile_ratings.PrepfoldSigmaRating(D),
pfd_ratings.RatioRating(D),
pfd_ratings.RatioRatingPeak(D),
],
where_clause=options.where,
scramble=options.scramble,
limit=options.n)
def compare_ratings(ratings):
DBconn = rating.usual_database()
DBcursor = MySQLdb.cursors.DictCursor(DBconn)
ids = []
for rr in ratings:
if isinstance(rr,basestring):
DBcursor.execute("SELECT * FROM rating_type_current_versions WHERE name=%s", rr)
ids.append(DBcursor.fetchone()["rating_id"])
else:
r,v = rr
DBcursor.execute("SELECT * FROM rating_types WHERE name=%s and version=%s", (r,v))
ids.append(DBcursor.fetchone()["rating_id"])
id1, id2 = ratings
fields = ", ".join(["rating%d.value" % i for i in range(len(ids))])
join = " JOIN ".join(["ratings AS rating%d" % i for i in range(len(ids))])
ands = " AND ".join(["rating1.pdm_cand_id=rating%d.pdm_cand_id AND rating%d.rating_id = %%s" % (i,i) for i in range(len(ids))])
command = "SELECT " + fields + " FROM " + join + " WHERE " + ands
print command
DBcursor.execute(command, ids)
rs = []
for match in DBcursor.fetchall():
v = []
for i in range(len(ids)):
if not i:
v.append(match["value"])
else:
v.append(match["rating%d.value" % i])
rs.append(v)
return rs
# Un-dedispersed profile
p0 = pfd.time_vs_phase().sum(axis=0)
p1 = profile_ratings.get_profile(cache, pfd)
return np.std(p0)/np.std(p1)
class RatioRatingPeak(rating.DatabaseRater):
def __init__(self,DBconn):
rating.DatabaseRater.__init__(self,DBconn,version=5,
name="Ratio Rating Peak",
description="""Compare DM 0 and "best" DM
Computes the ratio of peak height for the profile dedispersed at
DM 0 divided by that for the profile dedispersed at the best-fit DM.
""",
with_files=True)
def rate_candidate(self, hdr, candidate, pfd, cache=None):
p0 = pfd.time_vs_phase().sum(axis=0)
p1 = profile_ratings.get_profile(cache, pfd)
return (np.amax(p0)-np.median(p0))/(np.amax(p1)-np.median(p1))
if __name__=='__main__':
D = rating.usual_database()
rating.run(D,
[RatioRating(D),
])
def main():
import upload_rating
D = rating.usual_database()
rating.run(D, [upload_rating.UploadRating(D)])
description="""Determines whether candidates with nearly identical period are RFI based on their sky position.
Compares each candidate with database of candidates. If the differences in RA and Dec. are both greater than 0.2 degrees, the fractional difference in period is computed. For fractional differences less than 0.001, the value is exponentiated by the number of candidates that fall within that 0.001.
In general, if a candidate gets a rating less than ~1e-4 it's very likely RFI.
""",
with_files=False)
def rate_candidate(self, hdr, candidate, file=None):
p = candidate["bary_period"] # get candidate P_bary
ra = hdr["ra_deg"] # get candidate R.A.
decl = hdr["dec_deg"] # get candidate Dec.
pdiff_min = 10
c.execute("""SELECT pdm_candidates.period,headers.ra_deg,headers.dec_deg from pdm_candidates,headers where pdm_candidates.header_id=headers.header_id AND abs(pdm_candidates.period-%s)/(pdm_candidates.period+%s) < 0.0002 AND abs(ra_deg-%s) > 0.2 AND abs(dec_deg-%s) > 0.2;""", (p,p,ra,decl))
results = c.fetchall()
pdiff_min=3.0/(np.size(results)+1.0)
return pdiff_min
if __name__=='__main__':
PulsarRating(rating.usual_database()).run()
self.plot("period","dm")
pylab.gca().set_xscale("log")
pylab.ylim(0,1000)
pylab.xlim(1e-4,10)
pylab.legend(loc="best")
def plot(self,xaxis,yaxis):
def p(s,sz,color,label=""):
x,y = zip(*[(c[xaxis],c[yaxis]) for c in [self.candidates[id] for id in s]])
print "%s: %d points" % (label, len(s))
pylab.scatter(x,y,sz,color=color,edgecolor=color,facecolor=color,label=label)
rated = self.rated_harmonic.union(self.rated_ratio)
p(self.unclassified.difference(rated),1,"gray","unclassified")
p(self.classified_notreal.difference(rated),1,"black","not real")
p(self.classified_RFI.difference(rated),1,"red","RFI")
p(self.rated_harmonic,1,"yellow","60 Hz")
p(self.rated_ratio,1,"orange","stronger at DM 0")
p(self.classified_maybe,1,"green","maybe")
p(self.classified_real,2,"green","likely")
p(self.classified_known,2,"blue","known")
if __name__=='__main__':
rp = RatingPlotter(rating.usual_database())
rp.run()
rp.plot_p_vs_DM()
rp.plot_p_vs_sigma()
pylab.show()
pdm_cand_ids = {
7891: "Known pulsar, bright nuller",
7922: "Known pulsar, fainter",
4441: "New pulsar, 487 ms",
4443: "New pulsar, half frequency",
21775: "RFI wrapped at nonzero DM",
26526: "Narrowband RFI",
759: "Just noise, no peak, 250 ms",
31164: "Just noise, no peak, 12 ms",
}
def demo_rating(rating):
for (n,i) in sorted([(n,i) for (i,n) in pdm_cand_ids.items()]):
r = rating.rate_by_cand_id(i)
print "\t%s:\t%g" % (n,r)
if __name__=='__main__':
import rating
import profile_ratings
import harmonic_rating
import pfd_ratings
for R in [profile_ratings.GaussianWidth, profile_ratings.GaussianHeight, profile_ratings.PeakOverRMS,harmonic_rating.HarmonicRating, profile_ratings.DutyCycle, pfd_ratings.RatioRating]:
r = R(rating.usual_database())
print r.name
demo_rating(r)