def stetson_jindex(ftimes, fmags, ferrs, weightbytimediff=False):
'''This calculates the Stetson index for the magseries, based on consecutive
pairs of observations. Based on Nicole Loncke's work for her Planets and
Life certificate at Princeton.
This requires finite times, mags, and errs.
If weightbytimediff is True, the Stetson index for any pair of mags will be
reweighted by the difference in times between them using the scheme in
Fruth+ 2012 and Zhange+ 2003 (as seen in Sokolovsky+ 2017).
w_i = exp(- (t_i+1 - t_i)/ delta_t )
'''
ndet = len(fmags)
if ndet > 9:
# get the median and ndet
medmag = npmedian(fmags)
# get the stetson index elements
delta_prefactor = (ndet / (ndet - 1))
sigma_i = delta_prefactor * (fmags - medmag) / ferrs
sigma_j = nproll(sigma_i,
1) # Nicole's clever trick to advance indices
# by 1 and do x_i*x_(i+1)
if weightbytimediff:
time_i = ftimes
time_j = nproll(ftimes, 1)
difft = npdiff(ftimes)
deltat = npmedian(difft)
weights_i = npexp(-difft / deltat)
products = (weights_i * sigma_i[1:] * sigma_j[1:])
else:
# ignore first elem since it's actually x_0*x_n
products = (sigma_i * sigma_j)[1:]
stetsonj = (npsum(npsign(products) * npsqrt(npabs(products)))) / ndet
return stetsonj
else:
LOGERROR('not enough detections in this magseries '
'to calculate stetson J index')
return npnan
def pdw_worker(task):
'''
This is the parallel worker for the function below.
task[0] = frequency for this worker
task[1] = times array
task[2] = mags array
task[3] = fold_time
task[4] = j_range
task[5] = keep_threshold_1
task[6] = keep_threshold_2
task[7] = phasebinsize
we don't need errs for the worker.
'''
frequency = task[0]
times, modmags = task[1], task[2]
fold_time = task[3]
j_range = range(task[4])
keep_threshold_1 = task[5]
keep_threshold_2 = task[6]
phasebinsize = task[7]
try:
period = 1.0 / frequency
# use the common phaser to phase and sort the mag
phased = phase_magseries(times,
modmags,
period,
fold_time,
wrap=False,
sort=True)
# bin in phase if requested, this turns this into a sort of PDM method
if phasebinsize is not None and phasebinsize > 0:
bphased = pwd_phasebin(phased['phase'],
phased['mags'],
binsize=phasebinsize)
phase_sorted = bphased[0]
mod_mag_sorted = bphased[1]
j_range = range(len(mod_mag_sorted) - 1)
else:
phase_sorted = phased['phase']
mod_mag_sorted = phased['mags']
# now calculate the string length
rolledmags = nproll(mod_mag_sorted, 1)
rolledphases = nproll(phase_sorted, 1)
strings = ((rolledmags - mod_mag_sorted) *
(rolledmags - mod_mag_sorted) +
(rolledphases - phase_sorted) *
(rolledphases - phase_sorted))
strings[0] = (((mod_mag_sorted[0] - mod_mag_sorted[-1]) *
(mod_mag_sorted[0] - mod_mag_sorted[-1])) +
((phase_sorted[0] - phase_sorted[-1] + 1) *
(phase_sorted[0] - phase_sorted[-1] + 1)))
strlen = npsum(npsqrt(strings))
if (keep_threshold_1 < strlen < keep_threshold_2):
p_goodflag = True
else:
p_goodflag = False
return (period, strlen, p_goodflag)
except Exception as e:
LOGEXCEPTION('error in DWP')
return (period, npnan, False)
def stetson_jindex(ftimes, fmags, ferrs, weightbytimediff=False):
'''This calculates the Stetson index for the magseries, based on consecutive
pairs of observations.
Based on Nicole Loncke's work for her Planets and Life certificate at
Princeton in 2014.
Parameters
----------
ftimes,fmags,ferrs : np.array
The input mag/flux time-series with all non-finite elements removed.
weightbytimediff : bool
If this is True, the Stetson index for any pair of mags will be
reweighted by the difference in times between them using the scheme in
Fruth+ 2012 and Zhange+ 2003 (as seen in Sokolovsky+ 2017)::
w_i = exp(- (t_i+1 - t_i)/ delta_t )
Returns
-------
float
The calculated Stetson J variability index.
'''
ndet = len(fmags)
if ndet > 9:
# get the median and ndet
medmag = npmedian(fmags)
# get the stetson index elements
delta_prefactor = (ndet / (ndet - 1))
sigma_i = delta_prefactor * (fmags - medmag) / ferrs
# Nicole's clever trick to advance indices by 1 and do x_i*x_(i+1)
sigma_j = nproll(sigma_i, 1)
if weightbytimediff:
difft = npdiff(ftimes)
deltat = npmedian(difft)
weights_i = npexp(-difft / deltat)
products = (weights_i * sigma_i[1:] * sigma_j[1:])
else:
# ignore first elem since it's actually x_0*x_n
products = (sigma_i * sigma_j)[1:]
stetsonj = (npsum(npsign(products) * npsqrt(npabs(products)))) / ndet
return stetsonj
else:
LOGERROR('not enough detections in this magseries '
'to calculate stetson J index')
return npnan
def nonperiodic_lightcurve_features(times, mags, errs, magsarefluxes=False):
'''This calculates the following nonperiodic features of the light curve,
listed in Richards, et al. 2011):
- amplitude
- beyond1std
- flux_percentile_ratio_mid20
- flux_percentile_ratio_mid35
- flux_percentile_ratio_mid50
- flux_percentile_ratio_mid65
- flux_percentile_ratio_mid80
- linear_trend
- max_slope
- median_absolute_deviation
- median_buffer_range_percentage
- pair_slope_trend
- percent_amplitude
- percent_difference_flux_percentile
- skew
- stdev
- timelength
- mintime
- maxtime
Parameters
----------
times,mags,errs : np.array
The input mag/flux time-series to process.
magsarefluxes : bool
If True, will treat values in `mags` as fluxes instead of magnitudes.
Returns
-------
dict
A dict containing all of the features listed above.
'''
# remove nans first
finiteind = npisfinite(times) & npisfinite(mags) & npisfinite(errs)
ftimes, fmags, ferrs = times[finiteind], mags[finiteind], errs[finiteind]
# remove zero errors
nzind = npnonzero(ferrs)
ftimes, fmags, ferrs = ftimes[nzind], fmags[nzind], ferrs[nzind]
ndet = len(fmags)
if ndet > 9:
# calculate the moments
moments = lightcurve_moments(ftimes, fmags, ferrs)
# calculate the flux measures
fluxmeasures = lightcurve_flux_measures(ftimes,
fmags,
ferrs,
magsarefluxes=magsarefluxes)
# calculate the point-to-point measures
ptpmeasures = lightcurve_ptp_measures(ftimes, fmags, ferrs)
# get the length in time
mintime, maxtime = npmin(ftimes), npmax(ftimes)
timelength = maxtime - mintime
# get the amplitude
series_amplitude = 0.5 * (npmax(fmags) - npmin(fmags))
# calculate the linear fit to the entire mag series
fitcoeffs = nppolyfit(ftimes, fmags, 1, w=1.0 / (ferrs * ferrs))
series_linear_slope = fitcoeffs[1]
# roll fmags by 1
rolled_fmags = nproll(fmags, 1)
# calculate the magnitude ratio (from the WISE paper)
series_magratio = ((npmax(fmags) - moments['median']) /
(npmax(fmags) - npmin(fmags)))
# this is the dictionary returned containing all the measures
measures = {
'ndet': fmags.size,
'mintime': mintime,
'maxtime': maxtime,
'timelength': timelength,
'amplitude': series_amplitude,
'ndetobslength_ratio': ndet / timelength,
'linear_fit_slope': series_linear_slope,
'magnitude_ratio': series_magratio,
}
if moments:
measures.update(moments)
if ptpmeasures:
measures.update(ptpmeasures)
if fluxmeasures:
measures.update(fluxmeasures)
return measures
else:
LOGERROR('not enough detections in this magseries '
'to calculate non-periodic features')
return None
# Move Fader of the second channel down
dj.moves.move_fader_down(next_side)
print('Moved Fader -', next_side, 'down.')
sleep(2)
cue_point1 = playlist_db[0, 1][0]
mix_point1 = playlist_db[0, 1][2]
# Move down by one song on library panel
dj.pressings.scroll_down(1) # prepare for next song
# Setup the second song on the second deck
dj.get_next_song_ready(2, playlist_db[1])
# Move the playlist by two songs - Roll is used in order to have the correct number of loops
playlist_db = nproll(a=playlist_db, shift=-2, axis=0)
print(playlist_db)
# Press the 'Play'-button of the first deck
dj.pressings.press_play(current_side)
print('sleeping for:', mix_point1 - cue_point1)
sleep(mix_point1 - cue_point1)
for track in playlist_db:
latency = dj.pressings.press_play(next_side)
print('Pressed play (deck-' + str(next_side) + ')')
latency += dj.moves.move_fader_up(next_side)
print('Fader Up (channel-' + str(next_side) + ')')
latency += dj.pressings.press_beat_sync(next_side)
