def s2(r, b):
if (b >= 1 + r):
return (2 * np.pi / 3)
elif (b <= r - 1):
return 0
r_ = np.array([r], dtype=float)
b_ = np.array([b], dtype=float)
flux = np.empty(1)
mu0 = np.empty(1)
try:
occultquad.occultquad(b_, 1.0, 0.0, r_, flux, mu0)
except:
print("FOO")
return (2 * np.pi / 3) * flux[0]
def simple_model(JD, period, inc, a_Rs, limbB1, limbB2,startpar0, startpar1):
phase = (JD - startpar1)/period
distance_vector = delta(phase,inc) * a_Rs
#model = occultation_fn(distance_vector,startpar0,limbB1,limbB2,show=False)
model = occultquad(distance_vector, limbB1, limbB2, startpar0, len(JD))
return model
def evaluate(self, time):
"""
Calculate a light curve according to the analytical models
given by Pal 2008.
Parameters
----------
time : array
An array of time points at which the light curve
shall be calculated.
.. note:: time = 0 -> Planet is exactly in the line of sight (phase = 0).
Returns
-------
Model : array
The analytical light curve is stored in the property `lightcurve`.
"""
# Translate the given parameters into an orbit and, finally,
# into a projected, normalized distance (z-parameter)
self._calcZList(time - self["T0"])
# Use occultquad Fortran library to compute flux decrease
df = numpy.zeros(len(time))
if len(self._intrans) > 0:
result = occultquad.occultquad(self._zlist[self._intrans],self["linLimb"],self["quadLimb"], \
self["p"],len(self._intrans))
df[self._intrans] = (1.0 - result[0])
self.lightcurve = (1.-df)*1./(1.+self["b"]) + self["b"]/(1.0+self["b"])
return self.lightcurve
def model_no_moon_nested_2(time,
ratio_P,
a_o_R,
impact_B,
phase_B,
period_B,
u1,
u2,
verbosity=0):
const = a_o_R
if verbosity > 1:
print(const)
z_B_x = const * np.sin(2.0 * np.pi * (time / period_B - phase_B))
z_B_y = impact_B * np.cos(2.0 * np.pi * (time / period_B - phase_B))
z_coord = np.cos(2.0 * np.pi * (time / period_B - phase_B))
z_B_y[z_coord < 0.0] = 10.0 * a_o_R #exclude if behind star
z_B = np.sqrt(z_B_x**2.0 + z_B_y**2.0)
transit_signal_P = np.ones(len(z_B))
transit_signal_P[z_B < 1.0 + ratio_P] = occultquad(
z_B[z_B < 1.0 + ratio_P], u1, u2, ratio_P)[0]
return transit_signal_P
def ModLC(timeIn, RpRs, b, tR, t0, u1, u2):
bsq = b**2
z0 = np.sqrt(bsq + ((timeIn-t0) / tR)**2)
nz = len(timeIn)
muo1 = np.zeros((nz))
mu0 = np.zeros((nz))
_ = occultquad.occultquad(z0,u1,u2,RpRs,muo1,mu0,nz)
return muo1
def distance():
planets = ["Mercury","Venus","Earth","Mars","Jupiter","Saturn","Uranus","Neptune"]
infile = "solarsystem.txt"
period = []; readcolumn(period,1,infile)
inc = []; readcolumn(inc,2,infile)
size = []; readcolumn(size,3,infile)
a = []; readcolumn(a,4,infile)
phase = -0.01+0.02*np.arange(10000)/10000.
disarr = np.logspace(np.log10(1.),np.log10(1.e4),100)
#plt.ion()
#plt.show()
time.sleep(1.0)
count=0
for dis in disarr:
magsun = cal_mag(dis)
sigma = cal_sigma(magsun)
fig = plt.figure(figsize=[8,8])
#plt.clf()
#fig.suptitle("offset from the eliptical = %.2f" % offset, color='red')
fig.suptitle("distance from sun = %.2f pc, Kepmag=%.2f, $\sigma$ = %.2f ppm" % (dis, magsun, sigma/1.e-6),color='red')
for i in xrange(len(planets)):
transit = tran()
transit.P = period[i]*365.
transit.inc = (90.)/180.*math.pi
transit.u1 = 0.4352
transit.u2= 0.2965
transit.sma = (a[i] / rsun*AU)
z = transit.calZ(phase)
#print z
#break
rmean = size[i]*6.378e8/rsun
circularflux = occultquad(z,transit.u1,transit.u2,rmean)[0]
circularmag = np.zeros(len(phase))+np.random.normal(loc=0,scale=sigma,size=phase.shape)+fluxtomag(circularflux)
#circularmag = fluxtomag(circularflux)
#print transit.inc,rmean
yformatter = matplotlib.ticker.ScalarFormatter(useOffset=False)
ax = fig.add_subplot(4,2,i+1)
ax.text(-48,1-rmean**2.*0.3,planets[i])
#if i%2==0:
# ax.set_title(planets[i],loc='left')
#else:
# ax.set_title(planets[i],loc='right')
ax.set_xlim([-60,60])
ax.set_ylim([1+rmean**2.*1.4,1-rmean**2.*0.5])
ax.plot(phase*transit.P*24.,1+circularmag)
ax.yaxis.set_major_formatter(yformatter)
#plt.plot(z,circularflux)
#plt.tight_layout()
plt.savefig('imgmag-%.3d.png' % count)
plt.savefig('solar.png')
#plt.show()
count+=1
plt.close()
#break
return
def simple_model(JD, startpar0, startpar1):
phase = (JD - startpar1) / period
distance_vector = delta(phase, inc) * a_Rs
# print distance_vector
#model = occultation_fn(distance_vector,startpar0,limbB1,limbB2,show=False)
model = occultquad(distance_vector, limbB1, limbB2,
startpar0) #, len(hjd))
model = model[0]
return model
def main():
planets = ["Mercury","Venus","Earth","Mars","Jupiter","Saturn","Uranus","Neptune"]
infile = "solarsystem.txt"
period = []; readcolumn(period,1,infile)
inc = []; readcolumn(inc,2,infile)
size = []; readcolumn(size,3,infile)
a = []; readcolumn(a,4,infile)
phase = -0.05+0.1*np.arange(10000)/10000.
offsetarr = np.linspace(-0.5,8,400)
#offsetarr = np.array([0.])
#plt.ion()
#plt.show()
time.sleep(1.0)
count=0
for offset in offsetarr:
fig = plt.figure(figsize=[8,8])
plt.clf()
fig.suptitle("offset from the eliptical = %.2f" % offset, color='red')
for i in xrange(len(planets)):
transit = tran()
transit.P = period[i]*365.
transit.inc = (90.-offset+inc[i])/180.*math.pi
transit.u1 = 0.4352
transit.u2= 0.2965
transit.sma = (a[i] / rsun*AU)
z = transit.calZ(phase)
#print z
#break
rmean = size[i]*6.378e8/rsun
circularflux = occultquad(z,transit.u1,transit.u2,rmean)[0]
#print transit.inc,rmean
yformatter = matplotlib.ticker.ScalarFormatter(useOffset=False)
ax = fig.add_subplot(4,2,i+1)
ax.text(-48,1+rmean**2.*0.1,planets[i])
#if i%2==0:
# ax.set_title(planets[i],loc='left')
#else:
# ax.set_title(planets[i],loc='right')
ax.set_xlim([-60,60])
ax.set_ylim([1-rmean**2.*1.4,1+rmean**2.*0.3])
ax.plot(phase*transit.P*24.,circularflux)
ax.yaxis.set_major_formatter(yformatter)
#plt.plot(z,circularflux)
#plt.tight_layout()
plt.savefig('img-%.3d.png' % count)
#plt.savefig('solar.png')
count+=1
plt.close()
#break
#plt.tight_layout()
#plt.draw()
#time.sleep(0.001)
return
def testgd(b,phi,theta):
#phi and theta should be in radiant
#parameters match Barnes 2009
rp = 0.1 #in solar radius units
a = 0.05
P = 3.04
beta = 0.19
#beta = 0.08
fratio = 0.1947
Ms = 1.8
Req = 2.029
#Req = 1.0
Rpole = Req*(1-fratio)
Tpole = 8450
u1 = 0.32; u2 = 0.32
Protot = 8.64
#derived parameters and compute circular flux
inc = np.arccos(Rpole*b*rsun/a/AU)
tarr = -10000+np.arange(1000)/1000.*20000.
t0 = 0.
phase = (tarr-t0)/P/day
sma = a*AU*np.sin(inc)/Req/rsun
#print sma
z=sma*np.sqrt(np.sin(phase*2*np.pi)*np.sin(phase*2*np.pi)+np.cos(phase*2*np.pi)*np.cos(phase*2*np.pi)*cos(inc)*cos(inc));
circularflux = occultquad(z,u1,u2,rp/Req)[0]
#derived parameters for gravity darkening bit
G_MRsun_hour = 4*math.pi**2*(1.5e3/7)**3./(365.*24.)**2
Omega = 2*math.pi/Protot
ggraveq0 = G_MRsun_hour*Ms/Req**2.
groteq0 = Omega**2.*Req
gpole = ggraveq0*Req**2./Rpole**2.
#inite Zeipel
#Warning, use beta to init Zeipel, instead of y; F = g**(4*beta)
#gdmodel = Zeipel(fratio,phi,Req,ggraveq0,groteq0,beta)
#the rp pass to code should be in solar units, I think
gdmodel = Zeipel(fratio,phi,Req,ggraveq0,groteq0,beta,rp)
F = np.zeros(len(phase))
Rpole = Req*(1-fratio)
#call Zeiple
#Warning, a is the semimajor axis in units of AU/rsun, instead of rstar;
#input b*Rpole(in rsun,see above) instead of b
gdmodel.Cal_F(phase,F,theta,a*AU/rsun,b*Rpole)
lum = gdmodel.Cal_Lum()
print lum/gpole**(4.*beta)/(4.*np.pi*Req**3.)
#correct the circular model
model = (circularflux-max(circularflux))*F+1
#model = (circularflux-max(circularflux))+1
#model = F
return model
def transitmodel(model_params,hjd,dummy1,dummy2,cadence):
### model_params t0 period rratio rsum inc u1 u2
#t0,period,rpol,rsum,inc,u1,u2 = model_params
edepth_i,rsum,rpol,u1,dummy,inc,ecosw_i,esinw_i,dummy,dummy,dummy,dummy,dummy,dummy,dummy,dummy,dummy,dummy,period,t0,u2,dummy=model_params
sma = rsum/(1+rpol)
sma = 1/sma
inc = inc * np.pi/180.
if cadence == "short":
phi = (hjd - t0)/period
z=sma*np.sqrt(np.sin(phi*2*np.pi)*np.sin(phi*2*np.pi)+np.cos(phi*2*np.pi)*np.cos(phi*2*np.pi)*cos(inc)*cos(inc));
circularflux = occultquad(z,u1,u2,rpol)[0]
index = np.cos(phi*2*np.pi)<0
circularflux[index]=1.0
flux = circularflux
if cadence == "long":
flux = []
for i in hjd:
delt = 0.00208
phi = np.arange(i-0.0104,i+0.0104+delt,delt)
phi_orig = phi
phi = (phi-t0)/period
z=sma*np.sqrt(np.sin(phi*2*np.pi)*np.sin(phi*2*np.pi)+np.cos(phi*2*np.pi)*np.cos(phi*2*np.pi)*cos(inc)*cos(inc));
circularflux = occultquad(z,u1,u2,rpol)[0]
index = np.cos(phi*2*np.pi)<0
circularflux[index]=1.0
flux.append(np.mean(circularflux))
flux = np.array(flux)
return flux
def evaluate(self, time):
"""
Calculate a light curve according to the analytical models
given by Mandel and Agol.
Parameters
----------
time : array
An array of time points at which the light curve
shall be calculated.
Returns
-------
Model : array
The analytical light curve is stored in the property `lightcurve`.
"""
# Translate the given parameters into an orbit and, finally,
# into a projected, normalized distance (z-parameter)
if self._orbit == "circular":
self._calcZList(time - self["T0"])
else:
# The orbit is keplerian
self._calcZList(time)
# Use occultquad Fortran library to compute flux decrease
df = numpy.zeros(len(time))
if len(self._intrans) > 0:
if self._ld == "quad":
# Use occultquad Fortran library to compute flux decrease
result = occultquad.occultquad(self._zlist[self._intrans],self["linLimb"],self["quadLimb"], \
self["p"],len(self._intrans))
else:
result = occultnl.occultnl(self["p"],self["a1"],self["a2"],self["a3"], \
self["a4"],self._zlist[self._intrans])
df[self._intrans] = (1.0 - result[0])
self.lightcurve = (1.-df)*1./(1.+self["b"]) + self["b"]/(1.0+self["b"])
return self.lightcurve
def simpletemp():
infile = 'HAT-266-0008524.tfalc'
time = []; readcolumn(time,2,infile); time = np.array(time)
mag = []; readcolumn(mag,18,infile); mag = np.array(mag)
period = 9.199166; epoch = 54774.2606359; q = 0.0243
epoch+=period*q/2.
rp = math.sqrt(0.0122)
inc = math.pi/2.
phase = abs((time-epoch)/period)-(abs((time-epoch)/period)).astype(int)
ind = phase>0.5
phase[ind]-=1.0
sma = 1./(q*math.pi)
#phase = phasefold(time,epoch,period)
z=sma*np.sqrt(np.sin(phase*2*math.pi)*np.sin(phase*2*math.pi)+np.cos(phase*2*math.pi)*np.cos(phase*2*math.pi)*np.cos(inc)*np.cos(inc))
circularflux = occultquad(z,0.0,0.0,rp)[0]
index = np.cos(phase*2*np.pi)<0
circularflux[index]=1.0
circularmag = fluxtomag(circularflux)
for i in xrange(len(time)):
print time[i],phase[i],circularmag[i]+np.median(mag),mag[i]
return
def trangen(time,mag,transit,lcflag=False):
'''functions to generate fake lightcurves'''
rmean = math.sqrt(transit.dip)
f = transit.f
inc = transit.inc*math.pi/180.
alpha = transit.alpha*np.pi/180.
u1 = transit.u1
u2 = transit.u2
sma = 1./transit.q/np.pi
#print sma,transit.P,transit.u1,transit.u2,transit.epoch,transit.q,transit.qg
req = rmean/math.sqrt(1-f)
rpol = math.sqrt(1-f)*rmean
ntran=int((max(time)-transit.epoch)/transit.P)-int((min(time)-transit.epoch)/transit.P)+1
tranwidth=transit.q*transit.P/2.
obl = Obl.Oblateness(req,rpol,alpha,sma,inc,u1,u2)
totalFlux = np.pi*(1.0-u1/3-u2/6)
intran = gentran(time,transit.P,transit.epoch,transit.q)
medianmag=np.median(mag[-intran])
if transit.stdmag==-1:
stdmag=np.std(mag[-intran])
else:
stdmag=transit.stdmag
#print rpol,medianmag
phase = (time-transit.epoch)/transit.P-((time-transit.epoch)/transit.P).astype(int)
ind = phase>0.5
phase[ind]-=1.0
fkmag=medianmag+np.random.randn(len(time))*stdmag
if(lcflag):
#initial short cadence data
circularfluxmeanlc=medianmag+np.random.randn(len(time))*stdmag
cadence = 1./60./24.
nt = (int)((max(time)-min(time))/cadence)
fktime = min(time)+np.arange(nt)*cadence
fkmagsc=medianmag+np.random.randn(len(fktime))*stdmag
#initial short cadence pahse
fkintran = gentran(fktime,transit.P,transit.epoch,transit.q)
fkphase = abs((fktime-transit.epoch)/transit.P)-(abs((fktime-transit.epoch)/transit.P)).astype(int)
ind = fkphase>0.5
fkphase[ind]-=1.0
z=sma*np.sqrt(np.sin(fkphase*2*np.pi)*np.sin(fkphase*2*np.pi)+np.cos(fkphase*2*np.pi)*np.cos(fkphase*2*np.pi)*np.cos(inc)*np.cos(inc))
#compute corrections
fkdflux = np.zeros(len(fktime[fkintran]))
obl.relativeFlux(fkphase[fkintran],fkdflux)
#fkdflux/=totalFlux
circularfluxmean = occultquad(z,u1,u2,rmean)[0]
circularfluxmean = 1-(1-circularfluxmean)/(totalFlux/np.pi)
circularflux = occultquad(z,u1,u2,rpol)[0]
circularflux = 1-(1-circularflux)/(totalFlux/np.pi)
index = np.cos(fkphase*2*np.pi)<0
circularflux[index]=1.0
circularfluxmean[index]=1.0
fkmagsc[fkintran] = medianmag
fkmagsc[fkintran]+=1-(circularflux[fkintran]-fkdflux)
circularfluxmean=1-circularfluxmean+medianmag
fkmag[intran] = binlc(time[intran],fktime[fkintran],fkmagsc[fkintran])
residual = (fkmagsc-circularfluxmean)/1.e-6
circularfluxmeanlc[intran] = binlc(time[intran],fktime[fkintran],circularfluxmean[fkintran]) + np.random.randn(len(time[intran]))*stdmag
circularfluxmean = circularfluxmeanlc
plt.plot(fkphase[fkintran],residual[fkintran],'r')
plt.xlim([-0.01,0.01])
else:
dflux = np.zeros(len(time[intran]))
obl.relativeFlux(phase[intran],dflux)
dflux/=totalFlux
z=sma*np.sqrt(np.sin(phase*2*np.pi)*np.sin(phase*2*np.pi)+np.cos(phase*2*np.pi)*np.cos(phase*2*np.pi)*np.cos(inc)*np.cos(inc))
circularflux = occultquad(z,u1,u2,rpol)[0]
index = np.cos(phase*2*np.pi)<0
circularflux[index]=1.0
circularfluxmean,check = occultquad(z,u1,u2,rmean)
circularfluxmean[index]=1.0
plt.plot(phase[intran],(circularfluxmean[intran]-circularflux[intran]+dflux)/1.e-6,'r')
plt.xlim([-0.01,0.01])
fkmag[intran] = medianmag+np.random.randn(len(fkmag[intran]))*stdmag
fkmag[intran]+=1-(circularflux[intran]-dflux)
circularfluxmean=1-circularfluxmean+medianmag+np.random.randn(len(fkmag))*stdmag
plt.plot(phase[intran],(-circularfluxmean[intran]+fkmag[intran])/1.e-6,'o',mec='b',mfc='None',ms=1.5,mew=1)
plt.show()
return [fkmag,circularfluxmean]
def trangen(time,mag,transit,lcflag=False):
'''functions to generate fake lightcurves'''
rmean = math.sqrt(transit.dip)
print rmean,transit.q*transit.P*24.
f = transit.f
inc = transit.inc*math.pi/180.
alpha = transit.alpha*np.pi/180.
u1 = transit.u1
u2 = transit.u2
sma = 1./transit.q/np.pi/np.sin(inc)
print sma
#print sma,transit.P,transit.u1,transit.u2,transit.epoch,transit.q,transit.qg
req = rmean/math.sqrt(1-f)
rpol = math.sqrt(1-f)*rmean
ntran=int((max(time)-transit.epoch)/transit.P)-int((min(time)-transit.epoch)/transit.P)+1
tranwidth=transit.q*transit.P/2.
obl = Obl.Oblateness(req,rpol,alpha,sma,inc,u1,u2)
totalFlux = np.pi*(1.0-u1/3-u2/6)
intran = gentran(time,transit.P,transit.epoch,transit.q)
medianmag=np.median(mag[-intran])
if transit.stdmag==-1:
stdmag=np.std(mag[-intran])
else:
stdmag=transit.stdmag
#print rpol,medianmag
phase = (time-transit.epoch)/transit.P-((time-transit.epoch)/transit.P).astype(int)
ind = phase>0.5
phase[ind]-=1.0
fkmag=medianmag+np.random.randn(len(time))*stdmag
fig=plt.figure()
ax = fig.add_subplot(111)
if(lcflag):
#initial short cadence data
circularfluxmeanlc=medianmag+np.random.randn(len(time))*stdmag
cadence = 1./60./24.
nt = (int)((max(time)-min(time))/cadence)
fktime = min(time)+np.arange(nt)*cadence
fkmagsc=medianmag+np.random.randn(len(fktime))*stdmag
#initial short cadence pahse
fkintran = gentran(fktime,transit.P,transit.epoch,transit.q)
fkphase = abs((fktime-transit.epoch)/transit.P)-(abs((fktime-transit.epoch)/transit.P)).astype(int)
ind = fkphase>0.5
fkphase[ind]-=1.0
z=sma*np.sqrt(np.sin(fkphase*2*np.pi)*np.sin(fkphase*2*np.pi)+np.cos(fkphase*2*np.pi)*np.cos(fkphase*2*np.pi)*np.cos(inc)*np.cos(inc))
#compute corrections
fkdflux = np.zeros(len(fktime[fkintran]))
obl.relativeFlux(fkphase[fkintran],fkdflux)
#fkdflux/=totalFlux
circularfluxmean = occultquad(z,u1,u2,rmean)[0]
circularfluxmean = 1-(1-circularfluxmean)/(totalFlux/np.pi)
circularflux = occultquad(z,u1,u2,rpol)[0]
circularflux = 1-(1-circularflux)/(totalFlux/np.pi)
index = np.cos(fkphase*2*np.pi)<0
circularflux[index]=1.0
circularfluxmean[index]=1.0
fkmagsc[fkintran] = medianmag
fkmagsc[fkintran]+=1-(circularflux[fkintran]-fkdflux)
circularfluxmean=1-circularfluxmean+medianmag
fkmag[intran] = binlc(time[intran],fktime[fkintran],fkmagsc[fkintran])
residual = (fkmagsc-circularfluxmean)/1.e-6
circularfluxmeanlc[intran] = binlc(time[intran],fktime[fkintran],circularfluxmean[fkintran]) + np.random.randn(len(time[intran]))*stdmag
circularfluxmean = circularfluxmeanlc
ax.plot(fkphase[fkintran],residual[fkintran],'r')
ax.set_xlim([-0.01,0.01])
else:
dflux = np.zeros(len(time[intran]))
obl.relativeFlux(phase[intran],dflux)
dflux/=totalFlux
z=sma*np.sqrt(np.sin(phase*2*np.pi)*np.sin(phase*2*np.pi)+np.cos(phase*2*np.pi)*np.cos(phase*2*np.pi)*np.cos(inc)*np.cos(inc))
circularflux = occultquad(z,u1,u2,rpol)[0]
index = np.cos(phase*2*np.pi)<0
circularflux[index]=1.0
circularfluxmean,check = occultquad(z,u1,u2,rmean)
circularfluxmean[index]=1.0
ax.plot(phase[intran],(circularfluxmean[intran]-circularflux[intran]+dflux)/1.e-6,'r')
ax.set_xlim([-0.01,0.01])
fkmag[intran] = medianmag+np.random.randn(len(fkmag[intran]))*stdmag
fkmag[intran]+=1-(circularflux[intran]-dflux)
circularfluxmean=1-circularfluxmean+medianmag+np.random.randn(len(fkmag))*stdmag
ax.plot(phase[intran],(-circularfluxmean[intran]+fkmag[intran])/1.e-6,'o',mec='b',mfc='None',ms=1.5,mew=1)
ax.set_xlabel('phase')
ax.set_ylabel('residual(ppm)')
plt.show()
fig=plt.figure()
ax = fig.add_subplot(111)
#ax.plot(phase[intran]*transit.P*24.,circularfluxmean[intran],'o',mec='b',mfc='None',ms=1.5,mew=1)
ax.plot(phase[intran]*transit.P*24.,fkmag[intran],'.',mec='r')
#ax.plot(phase[intran],-circularfluxmean[intran]+mag[intran],'o',mec='b',mfc='None',ms=1.5,mew=1)
#ax.set_xlabel('phase')
#ax.set_ylabel('relativemag(ppm)')
#yformatter = matplotlib.ticker.ScalarFormatter(useOffset=False)
#ax.yaxis.set_major_formatter(yformatter)
plt.show()
#fig=plt.figure()
#ax = fig.add_subplot(111)
#ax.plot(phase[intran],-circularfluxmean[intran]+mag[intran]+medianmag+1-(circularflux[intran]-dflux),'o',mec='b',mfc='None',ms=1.5,mew=1)
#ax.set_xlabel('phase')
#ax.set_ylabel('relativemag(ppm)')
#plt.show()
return [fkmag,circularfluxmean]
def main():
#rmean = 0.154679
rmean = 0.08453
f = 0.1
alpha =45./180.*np.pi
#sma = 8.924
sma = 49.584
#period = 2.218573
period = 110.3216229
#inc = 85.749/180.*np.pi
inc = 89.209/180.*np.pi
#inc = 90./180.*np.pi
u1 = 0.242
u2 = 0.289
Npoint = 1000
percent = 0.025
#percent = 1.0
dflux = np.zeros(Npoint)
dfluxF = np.zeros(Npoint)
req = rmean/sqrt(1-f)
rpol = sqrt(1-f)*rmean
#initial
start = time.clock()
#print '0',time.time(),time.clock()
obl = Obl.Oblateness(req,rpol,alpha,sma,inc,u1,u2)
oblf = OblF.Oblateness(req,rpol,alpha,sma,inc,u1,u2)
print '0',time.time(),time.clock()-start
b0 = sma*cos(inc)
if(b0>(1+req)):
print 'no transit happen'
return
dphi = 2*percent/(Npoint-1)
totalFlux = np.pi*(1.0-u1/3-u2/6)
phi=-1*percent+dphi*np.arange(Npoint)
#call
start = time.clock()
#print '1',time.time(),time.clock()-start
obl.relativeFlux(phi,dflux)
print '1old',time.time(),time.clock()-start
start = time.clock()
oblf.relativeFlux(phi,dfluxF)
print '1',time.time(),time.clock()-start
#print phi,dflux
z=sma*np.sqrt(np.sin(phi*2*np.pi)*np.sin(phi*2*np.pi)+np.cos(phi*2*np.pi)*np.cos(phi*2*np.pi)*cos(inc)*cos(inc));
#z = abs(np.sin(phi*np.pi))*sma#/abs(np.sin(inc))
#print '3',time.time(),time.clock()-start
start = time.clock()
circularflux = occultquad(z,u1,u2,rpol)[0]
print '3',time.time(),time.clock()-start
index = np.cos(phi*2*np.pi)<0
circularflux[index]=1.0
#print z.shape,circularflux.shape
#plt.plot(phi,circularflux)
#plt.plot(phi,z)
#plt.plot(phi,dflux/totalFlux)
#plt.xlim([-0.006,0.006])
start = time.clock()
#print '5',time.time(),time.clock()-start
circularfluxmean = occultquad(z,u1,u2,rmean)[0]
print '4',time.time(),time.clock()-start
#plt.plot(phi,circularflux-dflux/totalFlux)
plt.xlim([-0.01,0.01])
plt.plot(phi,(-circularfluxmean+circularflux-dflux/totalFlux)/1.e-6)
plt.plot(phi,(-circularfluxmean+circularflux-dfluxF/totalFlux)/1.e-6,'+')
plt.show()
return
def GenLC(lcfile,transit):
req = transit.rmean/sqrt(1-transit.f)
rpol = sqrt(1-transit.f)*transit.rmean
totalFlux = np.pi*(1.0-transit.u1/3-transit.u2/6)
if lcfile.cadence =='short':
wn = 24.*60.
minlen=transit.q*transit.P*24.*60.*4.
else:
wn = 24.*2.
minlen=transit.q*transit.P*24.*2.*4.
time,mag=readcol(lcfile.name,lcfile.coljd,lcfile.colmag)
time=np.array(time)
mag=np.array(mag)
#rm transit
newtime,newmag,newftime=windowtran(time,mag,transit.epoch,transit.P,transit.q)
fragtime=[]
print minlen,transit.q,transit.P,lcfile.cadence
#return
#generate random segment of lc
ideal = False
if(ideal):
fragtime = time
fragmag = np.zeros(len(mag))+np.median(newmag)
fragftime = phasefold(time,transit.epoch,transit.P)
ph=0.5
#fragtime,fragmag,fragftime=windowphase(newtime,newmag,epoch,period,qvar,ph)
else:
while len(fragtime)<minlen:
ph = random.random()
print ph,transit.q
while (abs(ph-0.5)<2.*transit.q):
ph = random.random()
fragtime,fragmag,fragftime=windowphase(newtime,newmag,transit.epoch,transit.P,transit.q,ph)
newepoch = transit.epoch+(ph-0.5)*transit.P
#print newepoch
#print 'reach here', transit.u1,transit.u2, transit.rmean,transit.sma,lcfile.cadence,transit.P,transit.epoch
if lcfile.cadence =='short':
fkintran = gentran(fragtime,transit.P,newepoch,transit.q)
fkphase = abs((fragtime-newepoch)/transit.P)-(abs((fragtime-newepoch)/transit.P)).astype(int)
ind = fkphase>0.5
fkphase[ind]-=1.0
#print fkphase
z = transit.calZ(fkphase)
#print z[abs(z)<2.216]
#compute corrections
fkdflux = np.zeros(len(fragtime[fkintran]))
#print req,rpol,transit.alpha,transit.sma,transit.inc,transit.u1,transit.u2
obl = Obl.Oblateness(req,rpol,transit.alpha,transit.sma,transit.inc,transit.u1,transit.u2)
obl.relativeFlux(fkphase[fkintran],1.+np.zeros(len(fkdflux)),fkdflux)
#print fkphase[fkintran]
circularfluxmean = occultquad(z,transit.u1,transit.u2,transit.rmean)[0]
#plt.plot(fkphase,z)
#plt.show()
circularflux = occultquad(z,transit.u1,transit.u2,rpol)[0]
index = np.cos(fkphase*2*np.pi)<0
circularflux[index]=1.0
circularflux[fkintran]-=fkdflux/totalFlux
circularfluxmean[index]=1.0
circularmag = fluxtomag(circularflux)
circularmagmean = fluxtomag(circularfluxmean)
fragmagcircular=fragmag+circularmagmean
#fragmagcircular=11.+np.zeros(len(fragmag))+np.random.normal(0,1.e-4,len(fragmag))+circularmagmean
fragmag+=circularmag
#fragmag=11.+circularmag+np.zeros(len(fragmag))+np.random.normal(0,1.e-4,len(fragmag))
residual = (fragmag-fragmagcircular)/1.e-6
elif lcfile.cadence=='long':
npoints = int(round((max(fragtime)-min(fragtime))*24.*60.))
fragtimesc = np.arange(npoints)*(1./24./60.)+min(fragtime)
fkintransc = gentran(fragtimesc,transit.P,newepoch,transit.q)
fkphasesc = abs((fragtimesc-newepoch)/transit.P)-(abs((fragtimesc-newepoch)/transit.P)).astype(int)
ind = fkphasesc>0.5
fkphasesc[ind]-=1.0
z = transit.calZ(fkphasesc)
print max(fragtime), min(fragtime)
#compute corrections
fkdfluxsc = np.zeros(len(fragtimesc[fkintransc]))
obl = Obl.Oblateness(req,rpol,transit.alpha,transit.sma,transit.inc,transit.u1,transit.u2)
obl.relativeFlux(fkphasesc[fkintransc],fkdfluxsc)
circularfluxmeansc = occultquad(z,transit.u1,transit.u2,transit.rmean)[0]
circularfluxsc = occultquad(z,transit.u1,transit.u2,rpol)[0]
index = np.cos(fkphasesc*2*np.pi)<0
circularfluxsc[index]=1.0
circularfluxmeansc[index]=1.0
circularfluxsc[fkintransc]-=fkdfluxsc/totalFlux
circularmagsc = fluxtomag(circularfluxsc)
circularflux=binlc(fragtime,fragtimesc,circularmagsc)
circularmagmean = fluxtomag(circularfluxmeansc)
circularfluxmean=binlc(fragtime,fragtimesc,circularmagmean)
fragmagcircular=fragmag+circularfluxmean
fragmag+=circularflux
residual = (fragmag-fragmagcircular)/1.e-6
fragtime -= (newepoch-transit.epoch)
return [fragtime,fragmag,residual,fragftime,fragmagcircular]
def main():
#rmean = 0.154679
rmean = 0.08453
f = 0.1
f2 = 0.12
#alpha =45./180.*np.pi
alpha = 30. / 180. * np.pi
alpha2 = 70. / 180. * np.pi
#sma = 8.924
sma = 49.584
#period = 2.218573
period = 110.3216229
#inc = 85.749/180.*np.pi
inc = 89.209 / 180. * np.pi
#inc = 90./180.*np.pi
u1 = 0.242
u2 = 0.289
Npoint = 1000
percent = 0.025
#percent = 1.0
dflux = np.zeros(Npoint)
dfluxF = np.zeros(Npoint)
req = rmean / sqrt(1 - f)
rpol = sqrt(1 - f) * rmean
req2 = rmean / sqrt(1 - f2)
rpol2 = sqrt(1 - f2) * rmean
#initial
start = time.clock()
#print '0',time.time(),time.clock()
obl = Obl.Oblateness(req, rpol, alpha, sma, inc, u1, u2)
oblf = OblF.Oblateness(req2, rpol2, alpha2, sma, inc, u1, u2)
print '0', time.time(), time.clock() - start
b0 = sma * cos(inc)
if (b0 > (1 + req)):
print 'no transit happen'
return
dphi = 2 * percent / (Npoint - 1)
totalFlux = np.pi * (1.0 - u1 / 3 - u2 / 6)
phi = -1 * percent + dphi * np.arange(Npoint)
#call
start = time.clock()
#print '1',time.time(),time.clock()-start
obl.relativeFlux(phi, dflux)
print '1old', time.time(), time.clock() - start
start = time.clock()
oblf.relativeFlux(phi, dfluxF)
print '1', time.time(), time.clock() - start
#print phi,dflux
z = sma * np.sqrt(
np.sin(phi * 2 * np.pi) * np.sin(phi * 2 * np.pi) +
np.cos(phi * 2 * np.pi) * np.cos(phi * 2 * np.pi) * cos(inc) *
cos(inc))
#z = abs(np.sin(phi*np.pi))*sma#/abs(np.sin(inc))
#print '3',time.time(),time.clock()-start
start = time.clock()
circularflux = occultquad(z, u1, u2, rpol)[0]
circularflux2 = occultquad(z, u1, u2, rpol2)[0]
print '3', time.time(), time.clock() - start
index = np.cos(phi * 2 * np.pi) < 0
circularflux[index] = 1.0
#print z.shape,circularflux.shape
#plt.plot(phi,circularflux)
#plt.plot(phi,z)
#plt.plot(phi,dflux/totalFlux)
#plt.xlim([-0.006,0.006])
start = time.clock()
#print '5',time.time(),time.clock()-start
circularfluxmean = occultquad(z, u1, u2, rmean)[0]
print '4', time.time(), time.clock() - start
#plt.plot(phi,circularflux-dflux/totalFlux)
plt.xlim([-0.01, 0.01])
plt.plot(phi,
(-circularfluxmean + circularflux - dflux / totalFlux) / 1.e-6)
plt.plot(phi,
(-circularfluxmean + circularflux2 - dfluxF / totalFlux) / 1.e-6,
'+')
plt.show()
return
def testgd(b):
rp = 0.1
a = 0.05
P = 3.04
beta = 0.19
fratio = 0.1947
Ms = 1.8
Req = 2.029
Rpole = Req*(1-fratio)
Tpole = 8450
#theta = 90.0
theta = 0.0
phi = 0.0
#phi = 30./180.*math.pi
#phi = 90./180.*math.pi
#inc = 90.0/180.*math.pi
#inc = np.arccos(Req*b*rsun/a/AU)
inc = np.arccos(Rpole*b*rsun/a/AU)
#print inc/math.pi*180.
tarr = -10000+np.arange(500)/500.*20000.
t0 = 0.
phase = (tarr-t0)/P/day
u1 = 0.32; u2 = 0.32
Protot = 8.64
sma = a*AU*np.sin(inc)/Req/rsun
#print sma
z=sma*np.sqrt(np.sin(phase*2*np.pi)*np.sin(phase*2*np.pi)+np.cos(phase*2*np.pi)*np.cos(phase*2*np.pi)*cos(inc)*cos(inc));
circularflux = occultquad(z,u1,u2,rp/Req)[0]
#plt.plot(phi,circularflux)
#plt.show()
theta = theta*math.pi/180.
#Protot = Protot #Protot is in hour
G_MRsun_hour = 4*math.pi**2*(1.5e3/7)**3./(365.*24.)**2
Omega = 2*math.pi/Protot
ggraveq0 = G_MRsun_hour*Ms/Req**2.
groteq0 = Omega**2.*Req
#ggraveq = 1.0
#groteq = ggraveq/ggraveq0*groteq0
Rpole = Req*(1-fratio)
#gpole=ggraveq*Req**2/Rpole**2.
#x = tarr*math.pi*a*AU*cos(theta)/P/day+b*sin(theta)
#y = -1*x*tan(theta)+rsun*Req*b*cos(theta)+rsun*Req*b*sin(theta)*tan(theta)
x = phase*2.*math.pi*a*AU*cos(theta)-Rpole*rsun*b*sin(theta)
#y = -1*x*tan(theta)+rsun*Rpole*b*cos(theta)+rsun*Rpole*b*sin(theta)*tan(theta)
y = -phase*2.*math.pi*a*AU*sin(theta)+rsun*Rpole*b*cos(theta)
#x = x/(rsun*Req)
#y = y/(rsun*Req)
x = x/(rsun)
y = y/(rsun)
#print x,y
#print phi,fratio,ggraveq,groteq
g = Zeipel.cal_geff(x,y,fratio,phi,Req,ggraveq0,groteq0)
#g = Zeipel.cal_geff(x,y,fratio,phi,1.,1,groteq/ggraveq)
#g0 = Zeipel.cal_geff(0,0,fratio,phi,1.,ggraveq,groteq)
def func(x,y):
#x,y is r, theta
x0 = x*cos(y)
y0 = x*sin(y)
#print x0,y0
g = Zeipel.cal_geff(x0,y0,fratio,phi,Req,ggraveq0,groteq0)
#g = Zeipel.cal_geff(x0,y0,fratio,phi,1.0,1.0,groteq/ggraveq)
return g**(4.*beta)
#F0 = dblquad(lambda x,y: x*f(x,y),0,2.*np.pi,lambda x: 0,lambda x: 1.0)
F0 = dblquad(lambda x,y: x*func(x,y),0,2.*np.pi,lambda x: 0,lambda x: Req)
feff = 1- ((1-fratio)**2.*np.cos(phi)**2.+np.sin(phi)**2.)**0.5
F = (g)**(4.*beta)/(F0[0]/np.pi/Req**2.*(1-feff))
#F = (g/gpole)**(4.*beta)
#model = (model-max(model))*(1-fratio_i)*F+1
#model = (circularflux-max(circularflux))*(1-fratio)*F+1
model = (circularflux-max(circularflux))*F+1
#print F
#model = circularflux
#model = (circularflux-max(circularflux))*F+1
#plt.plot(phi,circularflux)
#plt.show()
return model
def testgd(b,phi,theta):
#phi and theta should be in radiant
#parameters match Barnes 2009
rp = 0.1
a = 0.05
P = 3.04
beta = 0.19
fratio = 0.1947
Ms = 1.8
Req = 2.029
#Req = 1.0
Rpole = Req*(1-fratio)
Tpole = 8450
u1 = 0.32; u2 = 0.32
Protot = 8.2
#derived parameters and compute circular flux
inc = np.arccos(Rpole*b*rsun/a/AU)
tarr = -10000+np.arange(1000)/1000.*20000.
t0 = 0.
phase = (tarr-t0)/P/day
sma = a*AU*np.sin(inc)/Req/rsun
#print sma
z=sma*np.sqrt(np.sin(phase*2*np.pi)*np.sin(phase*2*np.pi)+np.cos(phase*2*np.pi)*np.cos(phase*2*np.pi)*cos(inc)*cos(inc));
circularflux = occultquad(z,u1,u2,rp/Req)[0]
#derived parameters for gravity darkening bit
G_MRsun_hour = 4*math.pi**2*(1.5e3/7)**3./(365.*24.)**2
Omega = 2*math.pi/Protot
ggraveq0 = G_MRsun_hour*Ms/Req**2.
groteq0 = Omega**2.*Req
gpole = ggraveq0*Req**2./Rpole**2.
w = (groteq0/ggraveq0)**0.5
fratio = 1.-(1./(0.5*w**2.+1))
#inite a gravity darkening model using Zeipel
#Warning, use beta to init Zeipel, instead of y; F = g**(4*beta)
gdmodel = Lara(fratio,phi,Req,ggraveq0,groteq0)
F = np.zeros(len(phase))
Rpole = Req*(1-fratio)
#use Zeiple to compute the flux correction for a transit
#Warning, a is the semimajor axis in units of AU/rsun, instead of rstar;
#input b*Rpole(in rsun,see above) instead of b
gdmodel.Cal_F(phase,F,theta,a*AU/rsun,b*Rpole)
F0 = np.array([0.])
#use Zeiple to compute the total Flux, integrated along line of sight
gdmodel.Cal_F0(F0)
#the ratio of total Flux compare to use the Teff at pole
F0ratio = F0/(np.pi*Req**2.)
print 'total Flux ratio along line of sight compare to piReq^2Tpole^4',F0ratio
#use Zeiple to compute the luminosity, integrated over the 3-d luminosity
lum = gdmodel.Cal_Lum()
#the ratio of total lum compare to use the Teff at pole
lumratio = lum/(4.*np.pi*Req**2.)
print 'total luminosity compare to 4piReq^2Tpole^4',lumratio
#print lum/gpole**(4.*beta)/(4./3*np.pi*Req**3.)
#correct the circular model
model = (circularflux-max(circularflux))*F+1
return model
def trangen(time,mag,transit,lcflag=0):
'''functions to generate fake lightcurves'''
rmean = math.sqrt(transit.dip)
print rmean,transit.q*transit.P*24.
f = transit.f
#inc = transit.inc*math.pi/180.
#alpha = transit.alpha*np.pi/180.
transit.calLD()
u1 = transit.u1
u2 = transit.u2
alpha = transit.alpha
sma = transit.sma
inc = transit.inc
req = rmean/math.sqrt(1-f)
rpol = math.sqrt(1-f)*rmean
print sma,transit.P,transit.u1,transit.u2,transit.epoch,transit.q,transit.qg,rpol
ntran=int((max(time)-transit.epoch)/transit.P)-int((min(time)-transit.epoch)/transit.P)+1
tranwidth=transit.q*transit.P/2.
#print req,rpol,alpha,transit.sma,transit.inc,transit.u1,transit.u2
#obl = Obl.Oblateness(req,rpol,alpha,transit.sma,transit.inc,transit.u1,transit.u2)
totalFlux = np.pi*(1.0-u1/3-u2/6)
intran = gentran(time,transit.P,transit.epoch,transit.q)
medianmag=np.median(mag[-intran])
transit.stdmag = 0.0012*np.sqrt(2.)
if transit.stdmag==-1:
stdmag=np.std(mag[-intran])
else:
stdmag=transit.stdmag
#print stdmag/np.sqrt(2.)
stdmag/=np.sqrt(2.)
print stdmag
#print rpol,medianmag
phase = (time-transit.epoch)/transit.P-((time-transit.epoch)/transit.P).astype(int)
ind = phase>0.5
phase[ind]-=1.0
fkmag=medianmag+np.random.randn(len(time))*stdmag
if(lcflag==0):
#initial short cadence data
fktime = time
fkmagsc=medianmag+np.random.randn(len(fktime))*stdmag
#print 'doing sc stuff'
#initial short cadence pahse
fkintran = gentran(fktime,transit.P,transit.epoch,transit.q)
fkphase = abs((fktime-transit.epoch)/transit.P)-(abs((fktime-transit.epoch)/transit.P)).astype(int)
ind = fkphase>0.5
fkphase[ind]-=1.0
z=sma*np.sqrt(np.sin(fkphase*2*np.pi)*np.sin(fkphase*2*np.pi)+np.cos(fkphase*2*np.pi)*np.cos(fkphase*2*np.pi)*np.cos(inc)*np.cos(inc))
#compute corrections
#fkdflux = np.zeros(len(fktime))
fkdflux = np.zeros(len(fktime[fkintran]))
obl.relativeFlux(fkphase[fkintran],fkdflux)
#obl.relativeFlux(fkphase,fkdflux)
#print (fkdflux==0).all()
#return
#print fkphase[fkintran]
#fkdflux/=totalFlux
circularfluxmean = occultquad(z,u1,u2,rmean)[0]
#circularfluxmean = 1-(1-circularfluxmean)/(totalFlux/np.pi)
circularflux = occultquad(z,u1,u2,rpol)[0]
circularflux[fkintran]-=fkdflux/totalFlux
#circularflux = 1-(1-circularflux)/(totalFlux/np.pi)
index = np.cos(fkphase*2*np.pi)<0
circularflux[index]=1.0
circularfluxmean[index]=1.0
#fkmagsc[fkintran] = medianmag
#fkmagsc[fkintran]+=1-(circularflux[fkintran]-fkdflux)
#print fkdflux
circularmag = fluxtomag(circularflux)
circularmagmean = fluxtomag(circularfluxmean)
#plt.plot(phase[fkintran],circularmag[fkintran])
#plt.show()
fkmag = fkmagsc+circularmag
circularfluxmean=circularmagmean+fkmagsc
#circularmagmean=circularmagmean+fkmagsc
#ax.plot(fkphase[fkintran],residual[fkintran],'r')
#ax.plot(fkphase[fkintran],fkmagsc[fkintran],'r')
#ax.set_xlim([-0.01,0.01])
#plt.show()
else:
#dflux = np.zeros(len(time[intran]))
#obl.relativeFlux(phase[intran],dflux)
#dflux/=totalFlux
z=sma*np.sqrt(np.sin(phase*2*np.pi)*np.sin(phase*2*np.pi)+np.cos(phase*2*np.pi)*np.cos(phase*2*np.pi)*np.cos(inc)*np.cos(inc))
circularflux = occultquad(z,u1,u2,rpol)[0]
index = np.cos(phase*2*np.pi)<0
circularflux[index]=1.0
circularfluxmean,check = occultquad(z,u1,u2,rmean)
circularfluxmean[index]=1.0
#circularflux = 1-(1-circularflux)/(totalFlux/np.pi)
#circularfluxmean = 1-(1-circularfluxmean)/(totalFlux/np.pi)
#ax.plot(phase[intran],circularfluxmean[intran],'r')
#ax.plot(phase[intran],(circularfluxmean[intran]-circularflux[intran]+dflux)/1.e-6,'r')
#ax.set_xlim([-0.01,0.01])
#plt.show()
fkmag = mag
print len(circularflux[intran])
#fkmag[intran] = medianmag+np.random.randn(len(fkmag[intran]))*stdmag
#fkmag[intran]+=1-(circularflux[intran]-dflux)
fkmag[intran]+=1-(circularflux[intran])
circularfluxmean=1-circularfluxmean+medianmag
#+np.random.randn(len(fkmag))*stdmag
#ax.plot(phase[intran],(-circularfluxmean[intran]+fkmag[intran])/1.e-6,'o',mec='b',mfc='None',ms=1.5,mew=1)
#ax.set_xlabel('phase')
#ax.set_ylabel('residual(ppm)')
#plt.show()
#fig=plt.figure()
#ax = fig.add_subplot(111)
#ax.plot(phase[intran]*transit.P*24.,circularfluxmean[intran],'o',mec='b',mfc='None',ms=1.5,mew=1)
#ax.plot(phase[intran]*transit.P*24.,fkmag[intran],'.',mec='r')
#ax.plot(phase[intran],-circularfluxmean[intran]+mag[intran],'o',mec='b',mfc='None',ms=1.5,mew=1)
#ax.set_xlabel('phase')
#ax.set_ylabel('relativemag(ppm)')
#yformatter = matplotlib.ticker.ScalarFormatter(useOffset=False)
#ax.yaxis.set_major_formatter(yformatter)
#plt.show()
#fig=plt.figure()
#ax = fig.add_subplot(111)
#ax.plot(phase[intran],-circularfluxmean[intran]+mag[intran]+medianmag+1-(circularflux[intran]-dflux),'o',mec='b',mfc='None',ms=1.5,mew=1)
#ax.set_xlabel('phase')
#ax.set_ylabel('relativemag(ppm)')
#plt.show()
return [phase,fkmag,circularfluxmean]
