def lnprob_func(parmfree,parmfix,namefree,namefix,data,eventinfo,t0par,isspitz,ischi2,use_color,I_minus_L,qnqe,get_chi2_obs=False):
alpha,delta,oblats,oblongs,obgammas = eventinfo
parmfit,parmflx = getparmfit(parmfree,parmfix,namefree,namefix)
# namefit = np.array(['t0','u0','te','rho','pien','piee'])
# u0 = parmfit[namefit=='u0'][0]
dof,chi2 = [],[]
## apply the color constraint (2-sigma limit) ##
chi2_color = 0.
if use_color==True:
fsogle = parmflx[0][0]
fsspit = parmflx[isspitz==True][0][0]
I_minus_L_trial = 2.5*np.log10(fsspit/fsogle)
if (I_minus_L_trial-I_minus_L[0])*(I_minus_L_trial-I_minus_L[1]) > 0:
chi2_color = np.inf
## negative blending (fb<-0.2) should be avoided: only apply to OGLE ##
if parmflx[0][1] < -0.2:
chi2_blend = np.inf
else:
chi2_blend = 0.
######################
for iob in range(len(data)):
date,flux,ferr = data[iob][:3]
qnqe_iob = qnqe[iob]
itraj,ifmod = genlc.getslc(alpha,delta,oblats[iob],oblongs[iob],date,parmfit,parmflx[iob],obgammas[iob],t0par,isspitz[iob],False,True,qne=qnqe_iob)
chi2.append(np.sum((flux-ifmod)**2/ferr**2))
dof.append(len(date))
if get_chi2_obs == True:
return np.array(chi2),np.array(dof),parmflx
chi2tot = np.sum(chi2)
if ischi2 == True:
# print chi2tot+chi2_color+chi2_blend
return chi2tot+chi2_color+chi2_blend
else:
return -0.5*chi2tot
def massfit_obj(q,s,thetas,lcs,lcs_full,eventinfo,parms_names,isspitz,use_color,I_minus_L,outputlc):
alpha,delta,oblats,oblongs,obgammas = eventinfo
parmfit,namefit,parmflx,nameflx,parmref = parms_names
tbegin,talert,t0par,t0base,mjd = parmref
parmfree,namefree,parmfix,namefix = initialization(parms_names,isspitz)
sinlcs,chi2all = [],[]
nlc = len(lcs)
bestfits = []
for i in range(nlc):
data = lcs[i]
iparmfree,parmfix,chi2,dof,fsfb = downhill(lnprob_func,namefree,parmfree,namefix,parmfix,data,eventinfo,parmref,isspitz,use_color=use_color,I_minus_L=I_minus_L)
### find best-fit model ###
if outputlc == True:
iparmfit,iparmflx = getparmfit(iparmfree,parmfix,namefree,namefix)
iparmflx = fsfb
for iob in range(len(data)):
date,flux,ferr = data[iob][:3]
itraj,ifmod = genlc.getslc(alpha,delta,oblats[iob],oblongs[iob],date,iparmfit,iparmflx[iob],obgammas[iob],t0par,isspitz[iob],False,True)
# plt.errorbar(date,flux,yerr=ferr,linestyle='none')
# plt.plot(date,ifmod)
# plt.show()
np.savetxt('output/models/fit-ilc=%d-iob=%d.dat'%((i+1),(iob+1)),np.vstack([lcs_full[i][iob],ifmod]),fmt='%f',header='fs=%f, fb=%f'%(iparmflx[iob][0],iparmflx[iob][1]))
bestfits.append(np.hstack([q,s,thetas[i],chi2.reshape(-1),iparmfree,parmfix]))
print '##########',q,s,thetas[i],chi2[0],'############'
return bestfits
def getchi2(parmfree,parmfix,namefree,namefix,data,eventinfo,t0par,isspitz,ischi2,use_color,I_minus_L,qnqe,get_chi2_obs=False):
alpha,delta,oblats,oblongs,obgammas = eventinfo
parmfit,parmflx = getparmfit(parmfree,parmfix,namefree,namefix)
dof,chi2 = [],[]
errs = []
######################
for iob in range(len(data)):
date,flux,ferr = data[iob][:3]
qnqe_iob = qnqe[iob]
itraj,ifmod = genlc.getslc(alpha,delta,oblats[iob],oblongs[iob],date,parmfit,parmflx[iob],obgammas[iob],t0par,isspitz[iob],False,False,qne=qnqe_iob)
ichi2,fs,fb,fserr,fberr = getfsfb(flux,ferr,ifmod)
chi2.append(ichi2)
parmflx[iob][0] = fs
parmflx[iob][1] = fb
dof.append(len(date))
errs.append([fserr,fberr])
## apply the color constraint (2-sigma limit) ##
chi2_color = 0.
if use_color==True:
fsogle = parmflx[0][0]
fsspit = parmflx[isspitz==True][0][0]
I_minus_L_trial = 2.5*np.log10(fsspit/fsogle)
if (I_minus_L_trial-I_minus_L[0])*(I_minus_L_trial-I_minus_L[1]) > 0:
chi2_color = np.inf
## negative blending (fb<-0.2) should be avoided: only apply to OGLE ##
if parmflx[0][1] < -0.2:
chi2_blend = np.inf
else:
chi2_blend = 0.
if get_chi2_obs == True:
print errs
return np.array(chi2),np.array(dof),parmflx
chi2tot = np.sum(chi2)
if ischi2 == True:
# print chi2tot+chi2_color+chi2_blend
return chi2tot+chi2_color+chi2_blend
else:
return -0.5*chi2tot
def main():
eventname = 'ob140939'
### find event information, input data, program setup ###
alpha,delta,datfiles,oblat,oblong,obgamma = getparm.getEventInfo(eventname)
parmref,parmfit,parmflx,efacs = getparm.getFitSetting(eventname)
t0par = parmref[0]
t0base= parmref[1]
HMJD = parmref[2]
nobs = len(datfiles)
parmfit[0] += t0base
print 'Total number of obs: ',nobs
print 'Parameters (ref): ',parmref
print 'Parameters (sfit): ',parmfit
print 'Parameters (flux): ',parmflx
print 'Errfacs: ',efacs
# isspit = np.zeros(nobs).astype(bool)
isspit = np.zeros(nobs-1).astype(bool)
isspit = np.hstack([isspit,True])
linestrs = ['-','--']
date,flux,ferr,magr,merr = getdat.getdat1(nobs,datfiles,efacs,isspit,HMJD)
#############################################################
### use more intensive time sequence ###
date_mod = np.linspace(6800,6900,1000)
#### choose s and q for sensitivity mapping ###
# plot_opt = False
# finmod_opt = False
# ntheta = 300
# qList = np.logspace(np.log10(1e-4),np.log10(1e-2),50)
# sList = np.logspace(np.log10(0.1),np.log10(10),50)
# ### five parallel programs ###
# ncore = 6
# each = 50/ncore
## qList = qList[:each]
## qList = qList[each:2*each]
## qList = qList[2*each:3*each]
## qList = qList[3*each:4*each]
## qList = qList[4*each:5*each]
# qList = qList[5*each:]
#################################################
### for test purpose ###
plot_opt = True
finmod_opt = True
ntheta = 6
qList = [1e-2]
sList = [1.1]
########################
for q in qList:
trials = []
for s in sList:
theta = np.linspace(0,360,ntheta+1)
xtrajs,ytrajs,binlcs = [],[],[]
binlcs_mod = []
use_fsfb = True
start = time.clock()
############################
### fake data generation ###
############################
for i in range(ntheta):
itheta = theta[i]
parmbfit = np.hstack([parmfit,[itheta,q,s]])
parmbflx = parmflx
iobxtraj,iobytraj,iobbinlc = [],[],[]
iobbinlc_mod = []
for iob in range(nobs):
ibinlc,xcau,ycau = genlc.getbinlc(alpha,delta,oblat[iob],oblong[iob],date[iob],parmbfit,parmbflx[iob],obgamma[iob],t0par,isspit[iob],use_fsfb)
iobxtraj.append(ibinlc[:,0])
iobytraj.append(ibinlc[:,1])
iobbinlc.append(ibinlc[:,2])
### find the fine input model ###
if finmod_opt == True:
ibinlc_mod,xcau,ycau = genlc.getbinlc(alpha,delta,oblat[iob],oblong[iob],date_mod,parmbfit,parmbflx[iob],obgamma[iob],t0par,isspit[iob],use_fsfb)
iobbinlc_mod.append(ibinlc_mod[:,2])
xtrajs.append(iobxtraj)
ytrajs.append(iobytraj)
binlcs.append(iobbinlc)
binlcs_mod.append(iobbinlc_mod)
xtrajs = np.array(xtrajs)
ytrajs = np.array(ytrajs)
binlcs = np.array(binlcs)
print 'binary lcs generated: ',time.clock()-start
########################################################
################################
### employ sfit to fake data ###
################################
########################################################
sinlcs,chi2all = [],[]
parmfit0 = parmfit
parmflx0 = parmflx
for i in range(ntheta):
itheta = theta[i]
########################################
############# SFITPY MODULE ############
########################################
### if sfit.getchi2 is used, the plotted
### light curve will not be right, beca-
### -use fs, fb are still the input vals
########################################
######## Downhill minimization only ###
iparmfit,iparmflx,chi2 = sfit.downhill(sfit.lnprob_func,parmfit,parmflx,[date,binlcs[i],ferr],nobs,[alpha,delta,oblat,oblong,obgamma],t0par,isspit)
# iparmfit,iparmflx,chi2 = sfit.downhill(sfit.getchi2,parmfit,parmflx,[date,binlcs[i],ferr],nobs,[alpha,delta,oblat,oblong,obgamma],t0par,isspit)
######## MCMC minimization only ###
# iparmfit,iparmflx,chi2 = sfit.mcmcfit(sfit.getchi2,parmfit,parmflx,[date,binlcs[i],ferr],nobs,[alpha,delta,oblat,oblong,obgamma],t0par,isspit)
######## Downhill + MCMC ####
# iparmfit,iparmflx,chi2 = sfit.downhill(sfit.getchi2,parmfit,parmflx,[date,binlcs[i],ferr],nobs,[alpha,delta,oblat,oblong,obgamma],t0par,isspit)
# if chi2[0] > 200:
# iparmfit,iparmflx,chi2 = sfit.mcmcfit(sfit.getchi2,iparmfit,iparmflx,[date,binlcs[i],ferr],nobs,[alpha,delta,oblat,oblong,obgamma],t0par,isspit)
########################################
if chi2[0] < 100:
parmfit0 = iparmfit
parmflx0 = iparmflx
### find best-fit model ###
isinlc = []
for iob in range(nobs):
itraj,ifmod = genlc.getslc(alpha,delta,oblat[iob],oblong[iob],date_mod,iparmfit,iparmflx[iob],obgamma[iob],t0par,isspit[iob],False,True)
isinlc.append(ifmod)
###########################
temp = np.hstack([q,s,theta[i],chi2.reshape(-1),iparmfit,iparmflx.reshape(-1)])
trials.append(temp)
sinlcs.append(isinlc)
chi2all.append(chi2[0])
print '##########',q,s,theta[i],chi2[0],'############'
sinlcs = np.array(sinlcs)
############################################################
###############################
### fake data demonstration ###
###############################
if plot_opt == True:
color1 = ['#99d8c9','#66c2a4','#41ae76','#238b45','#005824'] #green
color2 = ['#fdbb84','#fc8d59','#ef6548','#d7301f','#990000'] #red
color3 = ['#a6bddb','#74a9cf','#3690c0','#0570b0','#034e7b'] #blue
color4 = ['#bdbdbd','#969696','#737373','#525252','#252525'] #black
colors = np.array([color1,color2,color3,color4]).reshape(-1)
fig1 = plt.figure(figsize=(8.5,11))
nax1 = ntheta/2
axs = []
fig2 = plt.figure(figsize=(8.6,8))
ax0 = fig2.add_subplot(111) # axis to plot the trajectories
ax0.plot(xcau,ycau,linestyle='none',color='k',marker='o',markersize=1)
ax0.axis('equal')
for i in range(ntheta):
itheta = theta[i]
axi = fig1.add_subplot(nax1,2,i+1)
axs.append(axi)
for iob in range(nobs):
### plot fake data ###
# iflux,iferr = binlcs[i][iob],ferr[iob] #do not convert to OGLE system
iflux,iferr = getdat.convert_to_ogle_dat(binlcs[i][iob],ferr[iob],parmflx[iob],parmflx[0]) #convert to OGLE system
axi.errorbar(date[iob],iflux,yerr=iferr,color=colors[i],linestyle='none',marker='o')
if finmod_opt == True:
# ifmod = binlcs_mod[i][iob] #do not convert to OGLE system
ifmod = getdat.convert_to_ogle_mod(binlcs_mod[i][iob],parmflx[iob],parmflx[0]) #convert to OGLE system
axi.plot(date_mod,ifmod,color=colors[i],linestyle='--')
### plot best-fit smod ###
# ifmod = sinlcs[i][iob] #do not convert to OGLE system
ifmod = getdat.convert_to_ogle_mod(sinlcs[i][iob],parmflx[iob],parmflx[0]) #convert to OGLE system
axi.plot(date_mod,ifmod,color=colors[i])
### plot trajectory ###
ax0.plot(xtrajs[i][iob],ytrajs[i][iob],color=colors[i],linestyle=linestrs[iob])
axi.set_xlim(6800,6900)
x1,x2,y1,y2 = axs[i].axis()
xpos = x1+(x2-x1)/10.
ypos = y2-(y2-y1)/10.
axi.text(xpos,ypos,r'$\theta=%3.1f^\circ, \chi^2=%3.1f$'%(itheta,chi2all[i]),va='center')
axi.invert_yaxis()
plt.show()
### save parameters and chi2 ###
np.savetxt('output/grid-%s-%e.dat'%(eventname,q),np.array(trials),fmt='%f')
return
def main():
eventname = 'ob150448'
# eventname = raw_input('Please give the event name (eg, ob140124): ')
alpha,delta,datfiles,oblats,oblongs,obgammas,isspitz,parmref,parmfit,parmflx,errfacs,namefit,nameflx,use_color,I_minus_L = getparm.getEventInfo(eventname)
data = getdat.getalldat(datfiles,errfacs,isspitz,parmref)
tbegin,talert,t0par,t0base,mjd = parmref
parms_names = [parmfit,namefit,parmflx,nameflx,parmref]
parmfree,namefree,parmfix,namefix = sfitpy.initialization(parms_names,isspitz)
## generating fake data ##
q,s,theta = 1e-6,10,0.
parmbfit = np.hstack([parmfit,[theta,q,s]])
parmbflx = parmflx
# data_fake = []
# for iob in range(len(data)):
# date,flux,ferr,mag,merr = data[iob]
# ibinlc,xcau,ycau = genlc.getbinlc(alpha,delta,oblats[iob],oblongs[iob],date,parmbfit,parmbflx[iob],obgammas[iob],t0par,isspitz[iob],True)
# imag = 18-2.5*np.log10(ibinlc[:,2])
# ## save the fake data sets ##
# np.savetxt('fake-data-%d.dat'%(iob+1),np.vstack([date,imag,merr,np.ones_like(date),np.ones_like(date)]).T,fmt='%f')
# data_fake.append([date,ibinlc[:,2],ferr,imag,merr])
# data = data_fake
# ## change (pien,piee) ##
# parmfree[namefree=='pien'] = 0.2
# parmfree[namefree=='piee'] = 1.
# print parmfree
### Downhill simplex method ###
# parmfit,parmflx,chi2s,dof = sfitpy.downhill(sfitpy.lnprob_func,namefree,parmfree,namefix,parmfix,data,[alpha,delta,oblats,oblongs,obgammas],parmref,isspitz,use_color=use_color,I_minus_L=I_minus_L)
### MCMC to minimize the chisq ###
# parmfit,parmflx,chi2s,dof = sfitpy.mcmc(sfitpy.lnprob_func,eventname,namefree,parmfree,namefix,parmfix,data,[alpha,delta,oblats,oblongs,obgammas],parmref,isspitz,use_color=use_color,I_minus_L=I_minus_L)
#### use getchi2 instead of lnprob_func: TBD ###
### Downhill simplex method ###
parmfit,parmflx,chi2s,dof = sfitpy.downhill(sfitpy.getchi2,namefree,parmfree,namefix,parmfix,data,[alpha,delta,oblats,oblongs,obgammas],parmref,isspitz,use_color=use_color,I_minus_L=I_minus_L)
### MCMC to minimize the chisq ###
# parmfit,parmflx,chi2s,dof = sfitpy.mcmc(sfitpy.getchi2,eventname,namefree,parmfree,namefix,parmfix,data,[alpha,delta,oblats,oblongs,obgammas],parmref,isspitz,use_color=use_color,I_minus_L=I_minus_L)
#### Find the model according to the given parameters ###
fmod,mmod = [],[] ## model in flux and magnitude
trajmod = []
fmod_fin,mmod_fin = [],[]
trajmod_fin = []
# parmfit,parmflx = sfitpy.getparmfit(parmfree,parmfix,namefree,namefix)
te = parmfit[namefit=='te']
npts = (7300-6500)*10000./te
npts = min([npts,100000])
tmod = np.linspace(6500,7300,int(npts))
for iob in range(len(data)):
## find model ##
date,flux,ferr = data[iob][:3]
itraj,ifmod = genlc.getslc(alpha,delta,oblats[iob],oblongs[iob],date,parmfit,parmflx[iob],obgammas[iob],t0par,isspitz[iob],False,True)
immod = 18.-2.5*np.log10(ifmod)
fmod.append(ifmod)
mmod.append(immod)
trajmod.append(itraj)
## find a finer light curve ##
date = tmod
itraj,ifmod = genlc.getslc(alpha,delta,oblats[iob],oblongs[iob],date,parmfit,parmflx[iob],obgammas[iob],t0par,isspitz[iob],False,True)
immod = 18.-2.5*np.log10(ifmod)
fmod_fin.append(ifmod)
mmod_fin.append(immod)
trajmod_fin.append(itraj)
# fmod = np.array(fmod)
# mmod = np.array(mmod)
trajmod = np.array(trajmod)
trajmod_fin = np.array(trajmod_fin)
print 'Total chisq = ',chi2s[0]
print ['%.2f/%d'%(chi2s[i+1],dof[i]) for i in range(len(dof))]
