class NGC6633Table(object): def __init__(self): ''' Constructor ''' try: self._fromfile() except: self._fromdatabase() self._tofile() def _fromdatabase(self): """ import the table from a database """ from datasource import DataSource from astropy.coordinates import SkyCoord # @UnresolvedImport from astropy import units as u self.wifsip = DataSource(database=config.dbname, user=config.dbuser, host=config.dbhost) self.stars = [] columns = self.wifsip.columns('ngc6633') params = {'columns': ', '.join(columns), 'key': columns[0]} query = "SELECT %(columns)s FROM ngc6633 ORDER BY %(key)s;" % params self._stars = self.wifsip.query(query) columns = self.wifsip.columns('ngc6633') data_types = self.wifsip.data_types('ngc6633') arraydata = [] c = columns.index('coord') for star in self._stars: starlist = list(star) coord = star[c] ra, dec = coord.strip('()').split(',') newcoord = SkyCoord(ra=float(ra)*u.deg, dec=float(dec)*u.deg) starlist[c] = newcoord arraydata.append(tuple(starlist)) dtype = zip(columns, data_types) #print dtype self.stars = np.array(arraydata, dtype = dtype) def _fromfile(self, filename=None): """ unpickle the data from a file """ import pickle if filename is None: filename = config.datapath+'/stars.pickle' with open(filename,'rb') as picklefile: self.stars = pickle.load(picklefile) def _tofile(self, filename=None): """ pickle the data to a file """ import pickle if filename is None: filename = config.datapath+'/stars.pickle' with open(filename, 'wb') as picklefile: pickle.dump(self.stars, picklefile)
class Analysis(object): def __init__(self): ''' Constructor ''' from datasource import DataSource self.wifsip = DataSource(database=config.dbname, user=config.dbuser, host=config.dbhost) self.stars = [] query = "SELECT starid, bv ,vmag ,vmag_err from ngc6633;" self._stars = self.wifsip.query(query) columns = self.wifsip.columns('ngc6633') data_types = self.wifsip.data_types('ngc6633') for c, d in zip(columns, data_types): print c, d arraydata = [] for star in self._stars: arraydata.append(tuple(star)) columns = ['starid', 'bv', 'vmag', 'vmag_err'] data_types = ['S25', np.float16, np.float16, np.float16] self.stars = np.array(arraydata, dtype=zip(columns, data_types)) # self.age = 10**8.557/1e6 # in Myr from Webda # self.ebv = 0.031 # from Webda # self.dm = 9.53 # from Webda def getstars(self): """ build up a list of stars, where we do not have periods yet """ query = "SELECT starid, vmag, bv" \ " FROM ngc6633 " \ " WHERE vmag<18 " \ " AND vmag < 10 + bv*5.4 " \ " AND vmag > 7.5 + bv*5.4" \ # " AND bv>0.4 " \ " AND NOT good IS NULL" \ " ORDER BY vmag LIMIT 100;" result = self.wifsip.query(query) print '... %d stars found' % len(result) self.stars = [s[0] for s in result] self.vmag = [s[1] for s in result] self.bv = [s[2] for s in result] def setperiod(self, starid, period, theta=1.0): self.starid = starid params = {'starid': starid, 'period': period, 'theta': theta} if np.isfinite(period): query = """UPDATE ngc6633 SET period = %(period)f, theta = %(theta)f WHERE starid='%(starid)s';""" % params else: query = """UPDATE ngc6633 SET period = NULL, theta=NULL WHERE starid='%(starid)s';""" % params self.wifsip.execute(query) def setamp(self, starid, amplitude): self.starid = starid params = {'starid': starid, 'amp': amplitude} if np.isfinite(amplitude): query = """UPDATE ngc6633 SET amp = %(amp)f WHERE starid='%(starid)s';""" % params else: query = """UPDATE ngc6633 SET amp = NULL WHERE starid='%(starid)s';""" % params self.wifsip.execute(query) def setbad(self, starid): self.starid = starid query = """UPDATE ngc6633 SET good = False WHERE starid='%s';""" % starid self.wifsip.execute(query) #def __setattr__(self, name, value): # params = {'starid': self.starid, 'name': name, 'value': str(value)} # # query = """UPDATE ngc6633 SET %(name)s = %(value)s WHERE starid='%(starid)s';""" % params # self.wifsip.execute(query) #def __getattribute__(self, name): # params = {'starid': self.starid, 'name': name} # query = "SELECT %(name)s from ngc6633 WHERE starid='%(starid)s';" % params # result = self.wifsip.query(query) # return result[0] def plot_lightcurve(self): """ plot the lightcurve for a given star """ mean = np.mean(self.mag) plt.hlines(mean, min(self.hjd), max(self.hjd), linestyle='--') plt.xlim(min(self.hjd), max(self.hjd)) plt.grid() plt.errorbar(self.hjd, self.mag, yerr=self.err * 0.5, fmt='o') ylim = plt.ylim() plt.ylim(ylim[1], ylim[0]) def plot_clean(self, periods, amplitudes): plt.plot(periods, amplitudes, 'k') i = np.argmax(amplitudes) period = periods[i] plt.axvline(x=period, color='red', alpha=0.5) plt.axhline(np.mean(amplitudes), color='b', ls='--') plt.axhline(5. * np.mean(amplitudes), color='g', ls='--') plt.xlim(min(periods), max(periods)) plt.minorticks_on() def plot_pdm(self, periods, thetas): #plt.plot(periods, thetas, 'k') from scipy import signal kernel = signal.gaussian(101, 2) n = len(thetas) / 2 padded_thetas = np.lib.pad(thetas, n, mode='constant', constant_values=(1.0, 1.0)) smoothed = signal.fftconvolve(padded_thetas, kernel, mode='same')[n:-n] / 5 plt.plot(periods, smoothed, 'k') i = np.argmin(smoothed) period = periods[i] plt.axvline(x=period, color='red', alpha=0.5) plt.axhline(0.8, color='b', ls='--') plt.xlim(min(periods), max(periods)) plt.ylim(0.0, 1.0) plt.minorticks_on() def plot_phase(self, period): from functions import phase tp, yp = phase(self.hjd, self.mag, period) s1 = np.sin(2 * np.pi * tp / period) c1 = np.cos(2 * np.pi * tp / period) s2 = np.sin(4 * np.pi * tp / period) c2 = np.cos(4 * np.pi * tp / period) A = np.column_stack((np.ones(tp.size), s1, c1, s2, c2)) c, _, _, _ = np.linalg.lstsq(A, yp) tp1 = np.linspace(0.0, 2 * period, 100) s1 = np.sin(2 * np.pi * tp1 / period) c1 = np.cos(2 * np.pi * tp1 / period) s2 = np.sin(4 * np.pi * tp1 / period) c2 = np.cos(4 * np.pi * tp1 / period) plt.scatter(tp, yp, edgecolor='none', alpha=0.75) plt.scatter(tp + period, yp, edgecolor='none', alpha=0.75) plt.plot(tp1, c[1] * s1 + c[2] * c1 + c[3] * s2 + c[4] * c2, 'k', linestyle='--', linewidth=2) plt.xlim(0.0, 2 * period) plt.ylim(max(yp - np.mean(yp)), min(yp - np.mean(yp))) plt.xlabel('P = %.4f' % period) def analysis(self, show=False): """perform a PDM analysis on each lightcurve""" from matplotlib import rcParams print 'Analysis' fig_width = 18.3 / 2.54 # width in inches, was 7.48in fig_height = 23.3 / 2.54 # height in inches, was 25.5 fig_size = [fig_width, fig_height] #set plot attributes params = { 'backend': 'Agg', 'axes.labelsize': 12, 'axes.titlesize': 12, 'font.size': 12, 'xtick.labelsize': 12, 'ytick.labelsize': 12, 'figure.figsize': fig_size, 'savefig.dpi': 300, 'font.family': 'sans-serif', 'axes.linewidth': 0.5, 'xtick.major.size': 2, 'ytick.major.size': 2, } rcParams.update(params) minperiod = 1.3 maxperiod = 15 for starid, vmag, bv in zip(self.stars, self.vmag, self.bv): print '%-24s ' % starid, try: lc = LightCurve(starid) except IOError: logger.error("Can't load lightcurve %s" % starid) print 'no lightcurve' self.setbad(starid) continue if len(lc) < 50: logger.warn("%s: not enough datapoints" % starid) print 'not enough datapoints' continue # perform a 3sigma clipping i = np.where(lc.hjd > 2456762)[0] lc.mag = lc.mag[i] lc.hjd = lc.hjd[i] lc.normalize() lc.clip() lc.detrend() lc.sigma_clip() lc.normalize() self.hjd = lc.hjd self.mag = lc.mag self.err = lc.err clean_periods, clean_amplitudes = lc.clean(minperiod, maxperiod) pdm_periods, pdm_thetas = lc.pdm(minperiod, maxperiod) #period = clean_periods[np.argmax(clean_amplitudes)] from scipy import interpolate i = np.argsort(clean_periods) c_periods = clean_periods[i] c_amps = clean_amplitudes[i] c_periods = np.insert(c_periods, 0, 0.0) c_amps = np.insert(c_amps, 0, 0.0) c_periods = np.insert(c_periods, -1, maxperiod) c_amps = np.insert(c_amps, -1, 0.0) c_int = interpolate.interp1d(c_periods, c_amps) # use interpolation function returned by `interp1d` sum_amp = c_int(pdm_periods) * (1. - pdm_thetas) sum_amp /= max(sum_amp) i = np.argmax(sum_amp) period = pdm_periods[i] theta = pdm_thetas[i] import functions as fx ci = np.argmax(c_amps) try: pgf_amp, pgf_mean, pgf_sigma = fx.gauss_fit( pdm_periods, 1. - pdm_thetas, pdm_thetas[i], period, 1.0) except: pgf_sigma = 0.0 try: cgf_amp, cgf_mean, cgf_sigma = fx.gauss_fit( c_periods, c_amps, c_amps[ci], c_periods[ci], 1.0) except: cfg_sigma = 0.0 sigma_limit = 5.3 theta_limit = 0.8 try: ci = np.argmax(c_amps) params = { 'period': period, 'period_err': pgf_sigma, 'clean_period': c_periods[ci], 'clean_amp': c_amps[ci], 'clean_sigma': cgf_sigma, 'theta': theta, 'freq': period, } keys = ', '.join(params.keys()) values = ', '.join([str(v) for v in params.values()]) query = """UPDATE ngc6633 SET (%s) = (%s) WHERE starid='%s';""" % ( keys, values, starid) self.wifsip.execute(query) except: print 'Cannot store params for starid %s' % starid mamp = np.mean(clean_amplitudes) if max(clean_amplitudes ) > sigma_limit * mamp and pdm_thetas[i] < theta_limit: print "%.2f %.1f" % (period, max(clean_amplitudes) / mamp) self.setperiod(starid, period) else: print '< %.1f sigmas or theta %.2f > %.2f' % ( sigma_limit, pdm_thetas[i], theta_limit) self.setperiod(starid, np.nan) continue amp, _ = lc.phased(period) self.setamp(starid, amp) star = {'tab': 0, 'bv': bv} plt.subplot( 411) ################################################## plt.title('%s (%d) V = %.2f B-V=%.2f' % (starid, star['tab'], vmag, bv)) self.plot_lightcurve() plt.subplot( 412) ################################################## self.plot_clean(clean_periods, clean_amplitudes) plt.subplot( 413) ################################################## plt.plot(pdm_periods, sum_amp, 'g') plt.axvline(period, color='b') self.plot_pdm(pdm_periods, pdm_thetas) plt.subplot( 414) ################################################## self.plot_phase(period) # plt.scatter(tp, yp-np.mean(yp), edgecolor='none', alpha=0.75) # plt.plot(tp1,c[1]*s1+c[2]*c1+c[3]*s2+c[4]*c2, 'k', # linestyle='--', linewidth=2) # plt.xlim(0.0,period) # plt.ylim(max(yp-np.mean(yp)),min(yp-np.mean(yp))) # plt.xlabel('P = %.4f' % period) # plt.grid() # #plt.show() # period_err = 0.0 # comment = 'P=%6.3f+-%.3f a=%.3f+-%.4f %.2f' % \ # (period, period_err, amp, amp_err, theta) # plt.savefig(config.plotpath+'%s(%d).pdf' % (starid,star['tab'])) # plt.close() # # logger.info( comment) # print comment if show: plt.show() else: plt.savefig(config.plotpath + '%s(%d).pdf' % (starid, star['tab'])) plt.close()