def fractional_transit(
duration,
maxwidth,
depth,
samples,
per,
rp,
a,
inc,
ecc,
w,
u,
limb_dark,
cached_reference_transit=None,
):
"""Returns a scaled reference transit with fractional width and depth"""
if cached_reference_transit is None:
reference_flux = reference_transit(
samples=samples,
per=per,
rp=rp,
a=a,
inc=inc,
ecc=ecc,
w=w,
u=u,
limb_dark=limb_dark,
)
else:
reference_flux = cached_reference_transit
# Interpolate to shorter interval
"""
reference_time = numpy.linspace(-0.5, 0.5, samples)
f = scipy.interpolate.interp1d(reference_time, reference_flux, assume_sorted=True)
occupied_samples = int((duration / maxwidth) * samples)
y_new = f(numpy.linspace(-0.5, 0.5, occupied_samples))
"""
# Interpolate to shorter interval - new method without scipy
reference_time = numpy.linspace(-0.5, 0.5, samples)
occupied_samples = int((duration / maxwidth) * samples)
x_new = numpy.linspace(-0.5, 0.5, occupied_samples)
f = interp1d(x_new, reference_time)
y_new = f(reference_flux)
# Patch ends with ones ("1")
missing_samples = samples - occupied_samples
emtpy_segment = numpy.ones(int(missing_samples * 0.5))
result = numpy.append(emtpy_segment, y_new)
result = numpy.append(result, emtpy_segment)
if numpy.size(result) < samples: # If odd number of samples
result = numpy.append(result, numpy.ones(1))
# Depth rescaling
result = 1 - ((1 - result) * depth)
return result
def resample(time, flux, factor):
# New method without scipy
time_grid = int(len(flux) / factor)
time_resampled = numpy.linspace(min(time), max(time), time_grid)
f = interp1d(time_resampled, time)
flux_resampled = f(flux)
return time_resampled, flux_resampled
def resample(time, flux, factor):
"""
import scipy
f = scipy.interpolate.interp1d(time, flux, assume_sorted=True)
time_grid = int(len(flux) / factor)
time_resampled = numpy.linspace(min(time), max(time), time_grid)
flux_resampled = f(time_resampled)
"""
# New method without scipy
time_grid = int(len(flux) / factor)
time_resampled = numpy.linspace(min(time), max(time), time_grid)
f = interp1d(time_resampled, time)
flux_resampled = f(flux)
return time_resampled, flux_resampled
def reference_transit(samples, per, rp, a, inc, ecc, w, u, limb_dark):
"""Returns an Earth-like transit of width 1 and depth 1"""
f = numpy.ones(tls_constants.SUPERSAMPLE_SIZE)
duration = 1 # transit duration in days. Increase for exotic cases
t = numpy.linspace(-duration * 0.5, duration * 0.5,
tls_constants.SUPERSAMPLE_SIZE)
ma = batman.TransitParams()
ma.t0 = 0 # time of inferior conjunction
ma.per = per # orbital period, use Earth as a reference
ma.rp = rp # planet radius (in units of stellar radii)
ma.a = a # semi-major axis (in units of stellar radii)
# orbital inclination (in degrees)
ma.inc = inc
ma.ecc = ecc # eccentricity
ma.w = w # longitude of periastron (in degrees)
ma.u = u # limb darkening coefficients
ma.limb_dark = limb_dark # limb darkening model
m = batman.TransitModel(ma, t) # initializes model
flux = m.light_curve(ma) # calculates light curve
# Determine start of transit (first value < 1)
idx_first = numpy.argmax(flux < 1)
intransit_flux = flux[idx_first:-idx_first + 1]
intransit_time = t[idx_first:-idx_first + 1]
# Downsample (bin) to target sample size
"""
f = scipy.interpolate.interp1d(intransit_time, intransit_flux, assume_sorted=True)
xnew = numpy.linspace(t[idx_first], t[-idx_first - 1], samples)
downsampled_intransit_flux = f(xnew)
"""
# Interpolate to shorter interval - new method without scipy
#reference_time = numpy.linspace(-0.5, 0.5, samples)
#occupied_samples = int((duration / maxwidth) * samples)
x_new = numpy.linspace(t[idx_first], t[-idx_first - 1], samples)
f = interp1d(x_new, intransit_time)
downsampled_intransit_flux = f(intransit_flux)
# Rescale to height [0..1]
rescaled = (numpy.min(downsampled_intransit_flux) -
downsampled_intransit_flux) / (
numpy.min(downsampled_intransit_flux) - 1)
return rescaled