SpyPlanet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "from tkinter import *\n",
    "\n",
    "\n",
    "root = Tk()\n",
    "root.geometry(\"1580x980\")\n",
    "root.title('SpyPlanet')\n",
    "#root.iconbitmap(r'C:\\Users\\User\\Downloads\\Πτυχιακή\\exe\\Planet.ico')\n",
    "root.configure(bg='black')\n",
    "\n",
    "#bg = PhotoImage(file=r\"C:\\Users\\User\\Downloads\\Πτυχιακή\\exe\\space1.png\")\n",
    "#mylabel522 = Label(root,image=bg)\n",
    "#mylabel522.place(x=0,y=0,relwidth=1,relheight=1)\n",
    "\n",
    "\n",
    "my_canvas = Canvas(root, width=1580, height=4, bg=\"black\", bd=1, highlightthickness=0, relief=FLAT)\n",
    "my_canvas.grid(row=4, column=0, columnspan=72, sticky=EW)\n",
    "my_canvas.create_line(0, 4, 1580, 4, fill=\"red\")\n",
    "\n",
    "my_canvas = Canvas(root, width=1000, height=4, bg=\"black\", bd=1, highlightthickness=0, relief=FLAT)\n",
    "my_canvas.grid(row=30, column=0, columnspan=36, sticky=EW)\n",
    "my_canvas.create_line(0, 4, 1000, 4, fill=\"red\")\n",
    "\n",
    "\n",
    "my_canvas = Canvas(root, width=4, height=900, bg=\"black\", bd=1, highlightthickness=0, relief=FLAT)\n",
    "my_canvas.grid(row=3, column=35, rowspan=67)\n",
    "my_canvas.create_line(4, 5, 4, 900, fill=\"red\")\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "import lightkurve as lk\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "matplotlib.use(\"TkAgg\")\n",
    "from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk\n",
    "from matplotlib.figure import Figure\n",
    "\n",
    "\n",
    "#Data downloading and tpf\n",
    "\n",
    "myLabel1 = Label(root,text=\"Enter the name of the star and\\n the mission:\",font='Helvetica 12 bold',fg=\"red\",bg=\"black\")\n",
    "myLabel1.grid(row=0, column=20, sticky=N)\n",
    "myLabel1 = Label(root,text=\"Enter the author(pipeline):\",font='Helvetica 12 bold',fg=\"red\",bg=\"black\")\n",
    "myLabel1.grid(row=2, column=20, sticky=N)\n",
    "\n",
    "\n",
    "star = Entry(root,width=20,bg=\"white\")\n",
    "star.grid(row=0, column=24)\n",
    "star.get()\n",
    "mission = Entry(root,width=20,bg=\"white\")\n",
    "mission.grid(row=0, column=30)\n",
    "mission.get()\n",
    "author = Entry(root,width=20,bg=\"white\")\n",
    "author.grid(row=2, column=24)\n",
    "author.get()\n",
    "\n",
    "from pandastable import Table\n",
    "from astropy.table import Table\n",
    "\n",
    "def Data_Mast():\n",
    "    \n",
    "    global search_result,target,miss\n",
    "    target = star.get()\n",
    "    miss = mission.get()\n",
    "    \n",
    "    search_result = lk.search_lightcurve(target, mission=miss, cadence=\"long\")\n",
    "    search_result1 = search_result.table.to_pandas()\n",
    "\n",
    "\n",
    "    pop = Toplevel(root)\n",
    "    pop.title(\"Data\")    \n",
    "    pop.config(bg=\"black\")\n",
    "    \n",
    "       \n",
    "    frame = tk.Frame(pop)\n",
    "    frame.grid(row=0, column=0)\n",
    "\n",
    "\n",
    "    pt = Table(frame,dataframe=search_result1,showtoolbar=True,showstatusbar=True)\n",
    "    pt.show()\n",
    "    return search_result\n",
    "\n",
    "\n",
    "r = IntVar()\n",
    "\n",
    "def Rb():\n",
    "    global r,v\n",
    "   \n",
    "    if r.get() == 1:\n",
    "        v = \"sap_flux\"\n",
    "    else: \n",
    "        v = \"pdcsap_flux\"\n",
    "  \n",
    "    return v\n",
    "        \n",
    "\n",
    "Radiobutton(root,text=\"SAP\",variable=r,value=1,bg=\"black\",fg=\"white\",\n",
    "                  activebackground='white', activeforeground='white',selectcolor=\"black\").grid(row=1, column=24)\n",
    "Radiobutton(root,text=\"PDCSAP\",variable=r,value=2,bg=\"black\",fg=\"white\",\n",
    "                  activebackground='white', activeforeground='white',selectcolor=\"black\").grid(row=1, column=30)\n",
    "\n",
    "myButton3a = Button(root, text=\"Define the LC\", padx=22, pady=5, command=Rb, fg=\"red\", bg=\"white\")\n",
    "myButton3a.grid(row=1, column=40)    \n",
    "    \n",
    "\n",
    "def Author_Pipe():\n",
    "    global search_result,auth,lc_collection\n",
    "    \n",
    "    auth = author.get()\n",
    "    \n",
    "    search_result = lk.search_lightcurve(target, mission=miss, author=auth, cadence=\"long\")    \n",
    "    lc_collection = search_result.download_all(flux_column=v)\n",
    "    lc_collection.plot();\n",
    "    plt.show()\n",
    "    \n",
    "    myLabel = Label(root,text=star.get() + \": Data \\n Downloaded\",font='Helvetica 10 bold',fg=\"red\",bg=\"black\")\n",
    "    myLabel.grid(row=2, column=30, sticky=N)\n",
    "    \n",
    "\n",
    "myLabel9= Label(root,text=\"Photometry\",font='Helvetica 25 bold',fg=\"red\",bg=\"black\")\n",
    "myLabel9.grid(row=5, column=0)\n",
    "    \n",
    "quarter1 = Entry(root,width=10,bg=\"white\")\n",
    "quarter1.grid(row=11, column=20)\n",
    "quarter1.get()\n",
    "\n",
    "myLabel45 = Label(root,text=\"(Optional)\",fg=\"white\",bg=\"black\")\n",
    "myLabel45.grid(row=11, column=20, sticky=W)\n",
    "\n",
    "def tpf_plot():\n",
    "    quart = quarter1.get()\n",
    "    \n",
    "    if miss==\"Kepler\":\n",
    "        tpf = lk.search_targetpixelfile(target, mission=\"Kepler\", quarter=quart, cadence=\"long\").download()\n",
    "    else:\n",
    "        tpf = lk.search_targetpixelfile(target, mission=\"TESS\", sector=quart, cadence=\"long\").download()\n",
    "    tpf.plot()\n",
    "    plt.show() \n",
    "        \n",
    "\n",
    "\n",
    "myLabel2 = Label(root,text=\"See the TPF of the star\",fg=\"white\",bg=\"black\")\n",
    "myLabel2.grid(row=11, column=0)\n",
    "    \n",
    "myButton1 = Button(root, text=\"Find Star\", padx=35, pady=5, command=Data_Mast, fg=\"red\", bg=\"white\")\n",
    "myButton1.grid(row=0, column=40, sticky=N)\n",
    "\n",
    "myButton1 = Button(root, text=\"Find Author's LC\", padx=14, pady=5, command=Author_Pipe, fg=\"red\", bg=\"white\")\n",
    "myButton1.grid(row=2, column=40, sticky=N)\n",
    "\n",
    "myButton2 = Button(root, text=\"TPF Plot\", padx=31, pady=5, command=tpf_plot, fg=\"blue\", bg=\"white\")\n",
    "myButton2.grid(row=11, column=10)\n",
    "\n",
    "\n",
    "#Light Curve and analysis\n",
    "\n",
    "\n",
    "q = IntVar()\n",
    "\n",
    "def Rb2():\n",
    "    global w,q\n",
    "   \n",
    "    if q.get() == 1:\n",
    "        w = 1\n",
    "    else: \n",
    "        w = 2\n",
    "  \n",
    "    return w\n",
    "        \n",
    "\n",
    "\n",
    "Radiobutton(root,text=\"One Quarter\",variable=q,value=1,bg=\"black\",fg=\"white\",\n",
    "                  activebackground='white', activeforeground='white',selectcolor=\"black\").grid(row=10, column=20)\n",
    "Radiobutton(root,text=\"All Quarters\",variable=q,value=2,bg=\"black\",fg=\"white\",\n",
    "                  activebackground='white', activeforeground='white',selectcolor=\"black\").grid(row=10, column=24)\n",
    "\n",
    "\n",
    "myButton3g = Button(root, text=\"Define Quarter\", padx=15, pady=5, command=Rb2, fg=\"blue\", bg=\"white\")\n",
    "myButton3g.grid(row=10, column=10) \n",
    "\n",
    "myLabel2 = Label(root,text=\"Choose the quarters you \\n  want to download\",fg=\"white\",bg=\"black\")\n",
    "myLabel2.grid(row=10, column=0)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "quarter2 = Entry(root,width=10,bg=\"white\")\n",
    "quarter2.grid(row=12, column=20)\n",
    "quarter2.get()\n",
    "\n",
    "\n",
    "\n",
    "def Light_Curve():\n",
    "    \n",
    "    global lc,QUAR,w,q,v\n",
    "    QUAR = quarter2.get()\n",
    "    target = star.get()\n",
    "   \n",
    "    \n",
    "    if w == 1:\n",
    "        if miss==\"Kepler\":\n",
    "            lc = lk.search_lightcurve(target, mission=\"Kepler\", author=auth, quarter=QUAR, cadence=\"long\").download(flux_column=v)\n",
    "        else:\n",
    "            lc = lk.search_lightcurve(target, mission=\"TESS\", author=auth, sector=QUAR, cadence=\"long\").download(flux_column=v) \n",
    "    else:\n",
    "        lc = lc_collection.stitch()\n",
    "    \n",
    "    lc = lc.remove_nans()\n",
    "    lc.plot()\n",
    "    plt.show()\n",
    "    \n",
    "myLabel3 = Label(root,text=\"See the Light Curve of the star\",fg=\"white\",bg=\"black\")\n",
    "myLabel3.grid(row=12, column=0)\n",
    "\n",
    "myButton3 = Button(root, text=\"Light Curve\", padx=21, pady=5, command=Light_Curve, fg=\"blue\", bg=\"white\")\n",
    "myButton3.grid(row=12, column=10)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "from lightkurve.correctors import SFFCorrector\n",
    "\n",
    "myLabel45 = Label(root,text=\"(Optional)\",fg=\"white\",bg=\"black\")\n",
    "myLabel45.grid(row=15, column=20, sticky=W)\n",
    "\n",
    "def SFF():\n",
    "    global lc\n",
    "    \n",
    "    lc = SFFCorrector(lc).correct(windows=20)\n",
    "    lc.plot()\n",
    "    plt.show()\n",
    "\n",
    "myLabel3b = Label(root,text=\"Self Flat Fielding Corrector\",fg=\"white\",bg=\"black\")\n",
    "myLabel3b.grid(row=15, column=0)\n",
    "\n",
    "myButton3b = Button(root, text=\"SFF\", padx=42, pady=5, command=SFF, fg=\"blue\", bg=\"white\")\n",
    "myButton3b.grid(row=15, column=10)\n",
    "\n",
    "\n",
    "\n",
    "wind = Entry(root,width=10,bg=\"white\")\n",
    "wind.grid(row=16, column=20, columnspan=2)\n",
    "wind.get()\n",
    "\n",
    "\n",
    "\n",
    "def Flat_lc():\n",
    "    \n",
    "    wind2 = wind.get()\n",
    "    \n",
    "    global lc\n",
    "    lc = lc.flatten(window_length=int(wind2))\n",
    "    lc.plot()\n",
    "    plt.show()\n",
    "    \n",
    "myLabel4 = Label(root,text=\"Flat the Light Curve \",fg=\"white\",bg=\"black\")\n",
    "myLabel4.grid(row=16, column=0)\n",
    "\n",
    "myButton4 = Button(root, text=\"Flatten\", padx=33, pady=5, command=Flat_lc, fg=\"blue\", bg=\"white\")\n",
    "myButton4.grid(row=16, column=10)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "orio1 = Entry(root,width=10,bg=\"white\")\n",
    "orio1.grid(row=17, column=20, columnspan=1)\n",
    "orio1.get()\n",
    "\n",
    "orio2 = Entry(root,width=10,bg=\"white\")\n",
    "orio2.grid(row=17, column=20, columnspan=1, sticky=E)\n",
    "orio2.get()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def Masked_lc():\n",
    "    global lc\n",
    "    \n",
    "    or1 = orio1.get()\n",
    "    or2 = orio2.get()\n",
    "    \n",
    "    mask = (lc.time.value < float(or1)) | (lc.time.value > float(or2))\n",
    "    lc = lc[mask]\n",
    "    lc.plot()\n",
    "    plt.show()\n",
    "\n",
    "    return lc\n",
    "    \n",
    "myLabel43 = Label(root,text=\"Cut part of the Light Curve \",fg=\"white\",bg=\"black\")\n",
    "myLabel43.grid(row=17, column=0)\n",
    "\n",
    "myButton4 = Button(root, text=\"Cut\", padx=41, pady=5, command=Masked_lc, fg=\"blue\", bg=\"white\")\n",
    "myButton4.grid(row=17, column=10)\n",
    "    \n",
    "\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "oriop = Entry(root,width=10,bg=\"white\")\n",
    "oriop.grid(row=19, column=20, columnspan=1)\n",
    "oriop.get()\n",
    "\n",
    "\n",
    "\n",
    "best_fit_period = 0.0\n",
    "def Periodogram_bls():\n",
    "    \n",
    "    global best_fit_period\n",
    "    global periodogram \n",
    "    orp = oriop.get()\n",
    "    \n",
    "    periodogram = lc.to_periodogram(method=\"bls\", period=np.arange(0.5, float(orp), 0.001))\n",
    "    periodogram.plot();\n",
    "    best_fit_period = periodogram.period_at_max_power\n",
    "    best_fit_period2 = \"{:.3f}\".format(best_fit_period)\n",
    "    plt.show()\n",
    "    \n",
    "    myLabel5b = Label(root,text=\"Best fit period: \" + str(best_fit_period2),fg=\"white\",bg=\"black\")\n",
    "    myLabel5b.grid(row=19, column=24)\n",
    "    \n",
    "    return best_fit_period\n",
    "    \n",
    "myLabel5 = Label(root,text=\"Periodogram with the BLS method\",fg=\"white\",bg=\"black\")\n",
    "myLabel5.grid(row=19, column=0)\n",
    "\n",
    "myButton5 = Button(root, text=\"Periodogram\", padx=18, pady=5, command=Periodogram_bls, fg=\"blue\", bg=\"white\")\n",
    "myButton5.grid(row=19, column=10)    \n",
    "    \n",
    "    \n",
    "import astropy.units as u\n",
    "\n",
    "\n",
    "def Fold_lc():\n",
    "    global lc,best_fit_period,lc2\n",
    "    \n",
    "    if not Period_fold.get():\n",
    "        lc2 = lc.fold(period=best_fit_period, epoch_time=periodogram.transit_time_at_max_power).errorbar();\n",
    "    else: \n",
    "        Period_Dimensionless = Period_fold.get()\n",
    "        best_fit_period = Period_Dimensionless*u.s*60.0 * 60.0 * 24.0\n",
    "        lc2 = lc.fold(period=best_fit_period, epoch_time=periodogram.transit_time_at_max_power).errorbar();\n",
    "    \n",
    "    lc2.plot()\n",
    "    plt.xlabel(\"Time [JD]\")\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    \n",
    "Period_fold = Entry(root,width=10,bg=\"white\")\n",
    "Period_fold.grid(row=20, column=20, columnspan=2)\n",
    "Period_fold.get()\n",
    "\n",
    "myLabel6 = Label(root,text=\"Fold the Light Curve\",fg=\"white\",bg=\"black\")\n",
    "myLabel6.grid(row=20, column=0)\n",
    "\n",
    "myButton6 = Button(root, text=\"Fold\", padx=41, pady=5, command=Fold_lc, fg=\"blue\", bg=\"white\")\n",
    "myButton6.grid(row=20, column=10)\n",
    "\n",
    "\n",
    "\n",
    "def Zoom_lc():\n",
    "    global lc, zoom1, zoom2, lc2, best_fit_period\n",
    "    \n",
    "    zoom1 = zoomxl.get()\n",
    "    zoom2 = zoomxr.get()\n",
    "    \n",
    "    lc2 = lc.fold(period=best_fit_period, epoch_time=periodogram.transit_time_at_max_power).errorbar();\n",
    "    lc2.plot()\n",
    "    lc2.set_xlim(float(zoom1), float(zoom2))\n",
    "    plt.xlabel(\"Time [JD]\")\n",
    "    plt.show()    \n",
    "    return zoom1,zoom2\n",
    "\n",
    "    \n",
    "    \n",
    "\n",
    "    \n",
    "\n",
    "zoomxl = Entry(root,width=10,bg=\"white\")\n",
    "zoomxl.grid(row=22, column=20)\n",
    "zoomxl.get()\n",
    "\n",
    "\n",
    "zoomxr = Entry(root,width=10,bg=\"white\")\n",
    "zoomxr.grid(row=22, column=20, sticky=E)\n",
    "zoomxr.get()\n",
    "\n",
    "myLabel7 = Label(root,text=\"Zoom in the Light Curve\",fg=\"white\",bg=\"black\")\n",
    "myLabel7.grid(row=22, column=0)\n",
    "\n",
    "myButton7 = Button(root, text=\"Zoom In\", padx=30, pady=5, command=Zoom_lc, fg=\"blue\", bg=\"white\")\n",
    "myButton7.grid(row=22, column=10)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "##############################################################################################################\n",
    "##############################################################################################################\n",
    "\n",
    "\n",
    "#Exoplanet MCMC\n",
    "\n",
    "\n",
    "myLabel9= Label(root,text=\"MCMC\",font='Helvetica 25 bold',fg=\"red\",bg=\"black\")\n",
    "myLabel9.grid(row=5, column=40)\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "import lightkurve as lk\n",
    "import matplotlib.pyplot as plt\n",
    "from astropy.io import fits\n",
    "from astropy.timeseries import BoxLeastSquares\n",
    "\n",
    "\n",
    "quarter = Entry(root,width=10,bg=\"white\")\n",
    "quarter.grid(row=10, column=60)\n",
    "quarter.get()\n",
    "\n",
    "def Prepare():\n",
    "    \n",
    "    global x,y,bls_t0,bls_period,bls_depth,texp,miss,quart,target\n",
    "    \n",
    "    quart = quarter.get()\n",
    "    target = star.get()\n",
    "    \n",
    "    if miss == \"Kepler\":\n",
    "        lc_file = lk.search_lightcurve(target, author=auth, cadence=\"long\", quarter=quart\n",
    "                      ).download(quality_bitmask=\"hardest\", flux_column=\"pdcsap_flux\")\n",
    "    \n",
    "    else:\n",
    "        lc_file = lk.search_lightcurve(target, author=auth, cadence=\"long\", sector=quart\n",
    "                      ).download(quality_bitmask=\"hardest\", flux_column=\"pdcsap_flux\")\n",
    "    \n",
    "    lc_file.plot()\n",
    "    plt.show()\n",
    "    \n",
    "    lc = lc_file.remove_nans().normalize()\n",
    "    time = lc.time.value\n",
    "    flux = lc.flux\n",
    "    m = lc.quality == 0\n",
    "    with fits.open(lc_file.filename) as hdu:\n",
    "        hdr = hdu[1].header\n",
    "\n",
    "    texp = hdr[\"FRAMETIM\"] * hdr[\"NUM_FRM\"]\n",
    "    texp /= 60.0 * 60.0 * 24.0\n",
    "\n",
    "    ref_time = 0.5 * (np.min(time) + np.max(time))\n",
    "    x = np.ascontiguousarray(time[m] - ref_time, dtype=np.float64)\n",
    "    y = np.ascontiguousarray(1e3 * (flux[m] - 1.0), dtype=np.float64) + 1\n",
    "\n",
    "\n",
    "    \n",
    "    period_grid = np.exp(np.linspace(np.log(1), np.log(15), 50000))\n",
    "\n",
    "    bls = BoxLeastSquares(x, y)\n",
    "    bls_power = bls.power(period_grid, 0.1, oversample=20)\n",
    "\n",
    "    # Save the highest peak as the planet candidate\n",
    "    index = np.argmax(bls_power.power)\n",
    "    bls_period = bls_power.period[index]\n",
    "    bls_t0 = bls_power.transit_time[index]\n",
    "    bls_depth = bls_power.depth[index]\n",
    "    transit_mask = bls.transit_mask(x, bls_period, 0.2, bls_t0)\n",
    "\n",
    "    # Plot the folded transit\n",
    "\n",
    "    x_fold = (x - bls_t0 + 0.5 * bls_period) % bls_period - 0.5 * bls_period\n",
    "    m = np.abs(x_fold) < 0.4\n",
    "    \n",
    "\n",
    "    \n",
    "\n",
    "myLabel9b= Label(root,text=\"Choose quarter and \\n prepare the Data for MCMC \",fg=\"white\",bg=\"black\")\n",
    "myLabel9b.grid(row=10, column=40)\n",
    "    \n",
    "\n",
    "myButton9b = Button(root, text=\"Prepare Data\", padx=34, pady=5, command=Prepare, fg=\"blue\", bg=\"white\")\n",
    "myButton9b.grid(row=10, column=50)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "import exoplanet as xo\n",
    "import pymc3 as pm\n",
    "import aesara_theano_fallback.tensor as tt\n",
    "\n",
    "import pymc3_ext as pmx\n",
    "from celerite2.theano import terms, GaussianProcess\n",
    "\n",
    "#βαλε μεταβλητες για stellar parameters\n",
    "\n",
    "\n",
    "\n",
    "global map_soln,map_soln0,model,model0,mask,y,x,build_model\n",
    "\n",
    "\n",
    "nn = IntVar()\n",
    "cb1 = Checkbutton(root, text=\"None\", variable=nn,bg=\"black\",fg=\"white\",\n",
    "                  activebackground='white', activeforeground='white',selectcolor=\"black\").grid(row=15, column=50)\n",
    "\n",
    "ee = IntVar()\n",
    "cb2 = Checkbutton(root, text=\"Eccentricity\", variable=ee,bg=\"black\",fg=\"white\",\n",
    "                  activebackground='white', activeforeground='white',selectcolor=\"black\").grid(row=15, column=60)\n",
    "\n",
    "bb = IntVar()\n",
    "cb3 = Checkbutton(root, text=\"Impact \\n Parameter\", variable=bb,bg=\"black\",fg=\"white\",\n",
    "                  activebackground='white', activeforeground='white',selectcolor=\"black\").grid(row=15, column=70)\n",
    "\n",
    "########\n",
    "\n",
    "bbb = IntVar()\n",
    "cb4 = Checkbutton(root, text=\"Impact Parameter\", variable=bbb,bg=\"black\",fg=\"white\",\n",
    "                  activebackground='white', activeforeground='white',selectcolor=\"black\").grid(row=16, column=50)\n",
    "\n",
    "ppp = IntVar()\n",
    "cb5 = Checkbutton(root, text=\"Planet Period(Days)\",bg=\"black\",fg=\"white\",\n",
    "                  activebackground='white', activeforeground='white',selectcolor=\"black\", variable=ppp).grid(row=17, column=50)\n",
    "\n",
    "rrr = IntVar()\n",
    "cb6 = Checkbutton(root, text=\"Planet Radius(Rsun)\",bg=\"black\",fg=\"white\",\n",
    "                  activebackground='white', activeforeground='white',selectcolor=\"black\", variable=rrr).grid(row=18, column=50)\n",
    "\n",
    "eee = IntVar()\n",
    "cb5 = Checkbutton(root, text=\"Eccentricity\",bg=\"black\",fg=\"white\",\n",
    "                  activebackground='white', activeforeground='white',selectcolor=\"black\", variable=eee).grid(row=19, column=50)\n",
    "\n",
    "ooo = IntVar()\n",
    "cb6 = Checkbutton(root, text=\"Omega\",bg=\"black\",fg=\"white\",\n",
    "                  activebackground='white', activeforeground='white',selectcolor=\"black\", variable=ooo).grid(row=20, column=50)\n",
    "    \n",
    "    \n",
    "def Optim1():\n",
    "    global map_soln,map_soln0,model,model0,mask,y,x,build_model\n",
    "    \n",
    "    rstar6 = rstar5.get()\n",
    "    mstar6 = mstar5.get()\n",
    "    #####\n",
    "    bmc6 = bmc.get()\n",
    "    permc6 = permc.get()\n",
    "    rplmc6 = rplmc.get()\n",
    "    eccnmc6 = eccnmc.get()\n",
    "    ommc6 = ommc.get()\n",
    "    \n",
    "    \n",
    "    if nn.get() == 1:     \n",
    "    \n",
    "        global map_soln,map_soln0,model,model0,mask,y,x,build_model\n",
    "    \n",
    "        def build_model(mask=None, start=None):\n",
    "            if mask is None:\n",
    "                mask = np.ones(len(x), dtype=bool)\n",
    "            with pm.Model() as model:\n",
    "\n",
    "                if bbb.get() == 1:\n",
    "                    b = float(bmc6)\n",
    "                # Parameters for the stellar properties\n",
    "                mean = pm.Normal(\"mean\", mu=0.0, sd=10.0)\n",
    "                u_star = xo.QuadLimbDark(\"u_star\")\n",
    "\n",
    "                # Stellar parameters \n",
    "                M_star_huang = float(mstar6), 0.06\n",
    "                R_star_huang = float(rstar6), 0.06\n",
    "                BoundedNormal = pm.Bound(pm.Normal, lower=0, upper=3)\n",
    "                m_star = BoundedNormal(\"m_star\", mu=M_star_huang[0], sd=M_star_huang[1])\n",
    "                r_star = BoundedNormal(\"r_star\", mu=R_star_huang[0], sd=R_star_huang[1])\n",
    "\n",
    "                # Orbital parameters for the planets                                          \n",
    "                t0 = pm.Normal(\"t0\", mu=bls_t0, sd=1)\n",
    "                log_period = pm.Normal(\"log_period\", mu=np.log(bls_period), sd=1)\n",
    "                log_r_pl = pm.Normal(\n",
    "                    \"log_r_pl\",\n",
    "                    sd=1.0,\n",
    "                    mu=0.5 * np.log(1e-3 * np.array(bls_depth))\n",
    "                    + np.log(R_star_huang[0]),\n",
    "                )\n",
    "                period = pm.Deterministic(\"period\", tt.exp(log_period))\n",
    "                r_pl = pm.Deterministic(\"r_pl\", tt.exp(log_r_pl))\n",
    "                ror = pm.Deterministic(\"ror\", r_pl / r_star)\n",
    "                b = xo.distributions.ImpactParameter(\"b\", ror=ror)\n",
    "                \n",
    "                \n",
    "                \n",
    "                ecs = pmx.UnitDisk(\"ecs\", testval=np.array([0.01, 0.0]))\n",
    "                ecc = pm.Deterministic(\"ecc\", tt.sum(ecs ** 2))\n",
    "                omega = pm.Deterministic(\"omega\", tt.arctan2(ecs[1], ecs[0]))\n",
    "                xo.eccentricity.kipping13(\"ecc_prior\", fixed=True, observed=ecc)\n",
    "\n",
    "                # Transit jitter & GP parameters\n",
    "                log_sigma_lc = pm.Normal(\"log_sigma_lc\", mu=np.log(np.std(y[mask])), sd=10)\n",
    "                log_rho_gp = pm.Normal(\"log_rho_gp\", mu=0, sd=10)\n",
    "                log_sigma_gp = pm.Normal(\"log_sigma_gp\", mu=np.log(np.std(y[mask])), sd=10)\n",
    "\n",
    "                ##########\n",
    "                               \n",
    "                if ppp.get() == 1:\n",
    "                    period = float(permc6)\n",
    "                \n",
    "                if rrr.get() == 1:\n",
    "                    r_pl = float(rplmc6)\n",
    "                               \n",
    "                if eee.get() == 1:\n",
    "                    ecc = float(eccnmc6)\n",
    "                \n",
    "                if ooo.get() == 1:\n",
    "                    omega = float(ommc6)\n",
    "                    \n",
    "                # Orbit model\n",
    "                orbit = xo.orbits.KeplerianOrbit(\n",
    "                    r_star=r_star,\n",
    "                    m_star=m_star,\n",
    "                    period=period,\n",
    "                    t0=t0,\n",
    "                    b=b,\n",
    "                    ecc=ecc,\n",
    "                    omega=omega,\n",
    "                )\n",
    "\n",
    "                # Compute the model light curve\n",
    "                light_curves = pm.Deterministic(\n",
    "                    \"light_curves\",\n",
    "                    xo.LimbDarkLightCurve(u_star).get_light_curve(\n",
    "                        orbit=orbit, r=r_pl, t=x[mask], texp=texp\n",
    "                    )\n",
    "                    * 1e3,\n",
    "                )\n",
    "                light_curve = tt.sum(light_curves, axis=-1) + mean\n",
    "                resid = y[mask] - light_curve\n",
    "\n",
    "                # GP model for the light curve\n",
    "                kernel = terms.SHOTerm(\n",
    "                    sigma=tt.exp(log_sigma_gp),\n",
    "                    rho=tt.exp(log_rho_gp),\n",
    "                    Q=1 / np.sqrt(2),\n",
    "                )\n",
    "                gp = GaussianProcess(kernel, t=x[mask], yerr=tt.exp(log_sigma_lc))\n",
    "                gp.marginal(\"gp\", observed=resid)\n",
    "                pm.Deterministic(\"gp_pred\", gp.predict(resid))\n",
    "\n",
    "                # Fit for the maximum a posteriori parameters, I've found that I can get\n",
    "                # a better solution by trying different combinations of parameters in turn\n",
    "                if start is None:\n",
    "                    start = model.test_point\n",
    "                map_soln = pmx.optimize(\n",
    "                    start=start, vars=[log_sigma_lc, log_sigma_gp, log_rho_gp]\n",
    "                )\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[log_r_pl])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[b])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[log_period, t0])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[u_star])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[log_r_pl])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[b])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[ecs])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[mean])\n",
    "                map_soln = pmx.optimize(\n",
    "                    start=map_soln, vars=[log_sigma_lc, log_sigma_gp, log_rho_gp]\n",
    "                )\n",
    "                map_soln = pmx.optimize(start=map_soln)\n",
    "\n",
    "            return model, map_soln\n",
    "\n",
    "\n",
    "        model0, map_soln0 = build_model()\n",
    "\n",
    "        \n",
    "\n",
    "    elif ee.get() == 1 and bb.get() == 1: \n",
    "        \n",
    "        \n",
    "    \n",
    "        def build_model(mask=None, start=None):\n",
    "            if mask is None:\n",
    "                mask = np.ones(len(x), dtype=bool)\n",
    "            with pm.Model() as model:\n",
    "\n",
    "                # Parameters for the stellar properties\n",
    "                mean = pm.Normal(\"mean\", mu=0.0, sd=10.0)\n",
    "                u_star = xo.QuadLimbDark(\"u_star\")\n",
    "\n",
    "                # Stellar parameters \n",
    "                M_star_huang = float(mstar6), 0.06\n",
    "                R_star_huang = float(rstar6), 0.06\n",
    "                BoundedNormal = pm.Bound(pm.Normal, lower=0, upper=3)\n",
    "                m_star = BoundedNormal(\"m_star\", mu=M_star_huang[0], sd=M_star_huang[1])\n",
    "                r_star = BoundedNormal(\"r_star\", mu=R_star_huang[0], sd=R_star_huang[1])\n",
    "\n",
    "                # Orbital parameters for the planets\n",
    "                t0 = pm.Normal(\"t0\", mu=bls_t0, sd=1)\n",
    "                log_period = pm.Normal(\"log_period\", mu=np.log(bls_period), sd=1)\n",
    "                log_r_pl = pm.Normal(\n",
    "                    \"log_r_pl\",\n",
    "                    sd=1.0,\n",
    "                    mu=0.5 * np.log(1e-3 * np.array(bls_depth))\n",
    "                    + np.log(R_star_huang[0]),\n",
    "                )\n",
    "                period = pm.Deterministic(\"period\", tt.exp(log_period))\n",
    "                r_pl = pm.Deterministic(\"r_pl\", tt.exp(log_r_pl))\n",
    "                ror = pm.Deterministic(\"ror\", r_pl / r_star)\n",
    "                \n",
    "\n",
    "            \n",
    "\n",
    "                # Transit jitter & GP parameters\n",
    "                log_sigma_lc = pm.Normal(\"log_sigma_lc\", mu=np.log(np.std(y[mask])), sd=10)\n",
    "                log_rho_gp = pm.Normal(\"log_rho_gp\", mu=0, sd=10)\n",
    "                log_sigma_gp = pm.Normal(\"log_sigma_gp\", mu=np.log(np.std(y[mask])), sd=10)\n",
    "\n",
    "                ##########\n",
    "                                \n",
    "                if ppp.get() == 1:\n",
    "                    period = float(permc6)\n",
    "                \n",
    "                if rrr.get() == 1:\n",
    "                    r_pl = float(rplmc6)\n",
    "                                                   \n",
    "                \n",
    "                # Orbit model\n",
    "                orbit = xo.orbits.KeplerianOrbit(\n",
    "                    r_star=r_star,\n",
    "                    m_star=m_star,\n",
    "                    period=period,\n",
    "                    t0=t0,                   \n",
    "                )\n",
    "\n",
    "                # Compute the model light curve\n",
    "                light_curves = pm.Deterministic(\n",
    "                    \"light_curves\",\n",
    "                    xo.LimbDarkLightCurve(u_star).get_light_curve(\n",
    "                        orbit=orbit, r=r_pl, t=x[mask], texp=texp\n",
    "                    )\n",
    "                    * 1e3,\n",
    "                )\n",
    "                light_curve = tt.sum(light_curves, axis=-1) + mean\n",
    "                resid = y[mask] - light_curve\n",
    "\n",
    "                # GP model for the light curve\n",
    "                kernel = terms.SHOTerm(\n",
    "                    sigma=tt.exp(log_sigma_gp),\n",
    "                    rho=tt.exp(log_rho_gp),\n",
    "                    Q=1 / np.sqrt(2),\n",
    "                )\n",
    "                gp = GaussianProcess(kernel, t=x[mask], yerr=tt.exp(log_sigma_lc))\n",
    "                gp.marginal(\"gp\", observed=resid)\n",
    "                pm.Deterministic(\"gp_pred\", gp.predict(resid))\n",
    "\n",
    "                # Fit for the maximum a posteriori parameters, I've found that I can get\n",
    "                # a better solution by trying different combinations of parameters in turn\n",
    "                if start is None:\n",
    "                    start = model.test_point\n",
    "                map_soln = pmx.optimize(\n",
    "                    start=start, vars=[log_sigma_lc, log_sigma_gp, log_rho_gp]\n",
    "                )\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[log_r_pl])\n",
    "               \n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[log_period, t0])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[u_star])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[log_r_pl])\n",
    "                \n",
    "                \n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[mean])\n",
    "                map_soln = pmx.optimize(\n",
    "                    start=map_soln, vars=[log_sigma_lc, log_sigma_gp, log_rho_gp]\n",
    "                )\n",
    "                map_soln = pmx.optimize(start=map_soln)\n",
    "\n",
    "            return model, map_soln\n",
    "\n",
    "\n",
    "        model0, map_soln0 = build_model()                     \n",
    "       \n",
    "           \n",
    "        \n",
    "    elif ee.get() == 1 and bb.get() == 0:\n",
    "        \n",
    "        \n",
    "    \n",
    "        def build_model(mask=None, start=None):\n",
    "            if mask is None:\n",
    "                mask = np.ones(len(x), dtype=bool)\n",
    "            with pm.Model() as model:\n",
    "\n",
    "                if bbb.get() == 1:\n",
    "                    b = float(bmc6)\n",
    "                # Parameters for the stellar properties\n",
    "                mean = pm.Normal(\"mean\", mu=0.0, sd=10.0)\n",
    "                u_star = xo.QuadLimbDark(\"u_star\")\n",
    "\n",
    "                # Stellar parameters \n",
    "                M_star_huang = float(mstar6), 0.06\n",
    "                R_star_huang = float(rstar6), 0.06\n",
    "                BoundedNormal = pm.Bound(pm.Normal, lower=0, upper=3)\n",
    "                m_star = BoundedNormal(\"m_star\", mu=M_star_huang[0], sd=M_star_huang[1])\n",
    "                r_star = BoundedNormal(\"r_star\", mu=R_star_huang[0], sd=R_star_huang[1])\n",
    "\n",
    "                # Orbital parameters for the planets\n",
    "                t0 = pm.Normal(\"t0\", mu=bls_t0, sd=1)\n",
    "                log_period = pm.Normal(\"log_period\", mu=np.log(bls_period), sd=1)\n",
    "                log_r_pl = pm.Normal(\n",
    "                    \"log_r_pl\",\n",
    "                    sd=1.0,\n",
    "                    mu=0.5 * np.log(1e-3 * np.array(bls_depth))\n",
    "                    + np.log(R_star_huang[0]),\n",
    "                )\n",
    "                period = pm.Deterministic(\"period\", tt.exp(log_period))\n",
    "                r_pl = pm.Deterministic(\"r_pl\", tt.exp(log_r_pl))\n",
    "                ror = pm.Deterministic(\"ror\", r_pl / r_star)\n",
    "                b = xo.distributions.ImpactParameter(\"b\", ror=ror)\n",
    "\n",
    "                \n",
    "\n",
    "                # Transit jitter & GP parameters\n",
    "                log_sigma_lc = pm.Normal(\"log_sigma_lc\", mu=np.log(np.std(y[mask])), sd=10)\n",
    "                log_rho_gp = pm.Normal(\"log_rho_gp\", mu=0, sd=10)\n",
    "                log_sigma_gp = pm.Normal(\"log_sigma_gp\", mu=np.log(np.std(y[mask])), sd=10)\n",
    "               \n",
    "                ##########\n",
    "\n",
    "                if ppp.get() == 1:\n",
    "                    period = float(permc6)\n",
    "                \n",
    "                if rrr.get() == 1:\n",
    "                    r_pl = float(rplmc6)\n",
    "\n",
    "                # Orbit model\n",
    "                orbit = xo.orbits.KeplerianOrbit(\n",
    "                    r_star=r_star,\n",
    "                    m_star=m_star,\n",
    "                    period=period,\n",
    "                    t0=t0,\n",
    "                    b=b,\n",
    "                    \n",
    "                )\n",
    "\n",
    "                # Compute the model light curve\n",
    "                light_curves = pm.Deterministic(\n",
    "                    \"light_curves\",\n",
    "                    xo.LimbDarkLightCurve(u_star).get_light_curve(\n",
    "                        orbit=orbit, r=r_pl, t=x[mask], texp=texp\n",
    "                    )\n",
    "                    * 1e3,\n",
    "                )\n",
    "                light_curve = tt.sum(light_curves, axis=-1) + mean\n",
    "                resid = y[mask] - light_curve\n",
    "\n",
    "                # GP model for the light curve\n",
    "                kernel = terms.SHOTerm(\n",
    "                    sigma=tt.exp(log_sigma_gp),\n",
    "                    rho=tt.exp(log_rho_gp),\n",
    "                    Q=1 / np.sqrt(2),\n",
    "                )\n",
    "                gp = GaussianProcess(kernel, t=x[mask], yerr=tt.exp(log_sigma_lc))\n",
    "                gp.marginal(\"gp\", observed=resid)\n",
    "                pm.Deterministic(\"gp_pred\", gp.predict(resid))\n",
    "\n",
    "                # Fit for the maximum a posteriori parameters, I've found that I can get\n",
    "                # a better solution by trying different combinations of parameters in turn\n",
    "                if start is None:\n",
    "                    start = model.test_point\n",
    "                map_soln = pmx.optimize(\n",
    "                    start=start, vars=[log_sigma_lc, log_sigma_gp, log_rho_gp]\n",
    "                )\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[log_r_pl])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[b])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[log_period, t0])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[u_star])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[log_r_pl])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[b])\n",
    "              \n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[mean])\n",
    "                map_soln = pmx.optimize(\n",
    "                    start=map_soln, vars=[log_sigma_lc, log_sigma_gp, log_rho_gp]\n",
    "                )\n",
    "                map_soln = pmx.optimize(start=map_soln)\n",
    "\n",
    "            return model, map_soln\n",
    "\n",
    "\n",
    "        model0, map_soln0 = build_model()                                \n",
    "        \n",
    "        \n",
    "        \n",
    "    elif bb.get()  == 1 and ee.get() == 0:\n",
    "       \n",
    "        \n",
    "        def build_model(mask=None, start=None):\n",
    "            if mask is None:\n",
    "                mask = np.ones(len(x), dtype=bool)\n",
    "            with pm.Model() as model:\n",
    "\n",
    "                # Parameters for the stellar properties\n",
    "                mean = pm.Normal(\"mean\", mu=0.0, sd=10.0)\n",
    "                u_star = xo.QuadLimbDark(\"u_star\")\n",
    "\n",
    "                # Stellar parameters \n",
    "                M_star_huang = float(mstar6), 0.06\n",
    "                R_star_huang = float(rstar6), 0.06\n",
    "                BoundedNormal = pm.Bound(pm.Normal, lower=0, upper=3)\n",
    "                m_star = BoundedNormal(\"m_star\", mu=M_star_huang[0], sd=M_star_huang[1])\n",
    "                r_star = BoundedNormal(\"r_star\", mu=R_star_huang[0], sd=R_star_huang[1])\n",
    "\n",
    "                # Orbital parameters for the planets\n",
    "                t0 = pm.Normal(\"t0\", mu=bls_t0, sd=1)\n",
    "                log_period = pm.Normal(\"log_period\", mu=np.log(bls_period), sd=1)\n",
    "                log_r_pl = pm.Normal(\n",
    "                    \"log_r_pl\",\n",
    "                    sd=1.0,\n",
    "                    mu=0.5 * np.log(1e-3 * np.array(bls_depth))\n",
    "                    + np.log(R_star_huang[0]),\n",
    "                )\n",
    "                period = pm.Deterministic(\"period\", tt.exp(log_period))\n",
    "                r_pl = pm.Deterministic(\"r_pl\", tt.exp(log_r_pl))\n",
    "                ror = pm.Deterministic(\"ror\", r_pl / r_star)\n",
    "                \n",
    "\n",
    "                ecs = pmx.UnitDisk(\"ecs\", testval=np.array([0.01, 0.0]))\n",
    "                ecc = pm.Deterministic(\"ecc\", tt.sum(ecs ** 2))\n",
    "                omega = pm.Deterministic(\"omega\", tt.arctan2(ecs[1], ecs[0]))\n",
    "                xo.eccentricity.kipping13(\"ecc_prior\", fixed=True, observed=ecc)\n",
    "\n",
    "                # Transit jitter & GP parameters\n",
    "                log_sigma_lc = pm.Normal(\"log_sigma_lc\", mu=np.log(np.std(y[mask])), sd=10)\n",
    "                log_rho_gp = pm.Normal(\"log_rho_gp\", mu=0, sd=10)\n",
    "                log_sigma_gp = pm.Normal(\"log_sigma_gp\", mu=np.log(np.std(y[mask])), sd=10)\n",
    "\n",
    "                ##########       \n",
    "                if ppp.get() == 1:\n",
    "                    period = float(permc6)\n",
    "                \n",
    "                if rrr.get() == 1:\n",
    "                    r_pl = float(rplmc6)\n",
    "                               \n",
    "                if eee.get() == 1:\n",
    "                    ecc = float(eccnmc6)\n",
    "                \n",
    "                if ooo.get() == 1:\n",
    "                    omega = float(ommc6)\n",
    "                    \n",
    "                # Orbit model\n",
    "                orbit = xo.orbits.KeplerianOrbit(\n",
    "                    r_star=r_star,\n",
    "                    m_star=m_star,\n",
    "                    period=period,\n",
    "                    t0=t0,\n",
    "                    ecc=ecc,\n",
    "                    omega=omega,\n",
    "                )\n",
    "\n",
    "                # Compute the model light curve\n",
    "                light_curves = pm.Deterministic(\n",
    "                    \"light_curves\",\n",
    "                    xo.LimbDarkLightCurve(u_star).get_light_curve(\n",
    "                        orbit=orbit, r=r_pl, t=x[mask], texp=texp\n",
    "                    )\n",
    "                    * 1e3,\n",
    "                )\n",
    "                light_curve = tt.sum(light_curves, axis=-1) + mean\n",
    "                resid = y[mask] - light_curve\n",
    "\n",
    "                # GP model for the light curve\n",
    "                kernel = terms.SHOTerm(\n",
    "                    sigma=tt.exp(log_sigma_gp),\n",
    "                    rho=tt.exp(log_rho_gp),\n",
    "                    Q=1 / np.sqrt(2),\n",
    "                )\n",
    "                gp = GaussianProcess(kernel, t=x[mask], yerr=tt.exp(log_sigma_lc))\n",
    "                gp.marginal(\"gp\", observed=resid)\n",
    "                pm.Deterministic(\"gp_pred\", gp.predict(resid))\n",
    "\n",
    "                # Fit for the maximum a posteriori parameters, I've found that I can get\n",
    "                # a better solution by trying different combinations of parameters in turn\n",
    "                if start is None:\n",
    "                    start = model.test_point\n",
    "                map_soln = pmx.optimize(\n",
    "                    start=start, vars=[log_sigma_lc, log_sigma_gp, log_rho_gp]\n",
    "                )\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[log_r_pl])\n",
    "               \n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[log_period, t0])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[u_star])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[log_r_pl])\n",
    "              \n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[ecs])\n",
    "                map_soln = pmx.optimize(start=map_soln, vars=[mean])\n",
    "                map_soln = pmx.optimize(\n",
    "                    start=map_soln, vars=[log_sigma_lc, log_sigma_gp, log_rho_gp]\n",
    "                )\n",
    "                map_soln = pmx.optimize(start=map_soln)\n",
    "\n",
    "            return model, map_soln\n",
    "\n",
    "\n",
    "        model0, map_soln0 = build_model()  \n",
    "        \n",
    "        \n",
    "\n",
    "\n",
    "\n",
    "        \n",
    "        \n",
    "rstar5 = Entry(root,width=20,bg=\"white\")\n",
    "rstar5.grid(row=11, column=50)\n",
    "rstar5.get()\n",
    "    \n",
    "mstar5 = Entry(root,width=20,bg=\"white\")\n",
    "mstar5.grid(row=12, column=50)\n",
    "mstar5.get()\n",
    "         \n",
    "myLabel10a = Label(root,text=\"Radius of Star(Rsun)\",fg=\"white\",bg=\"black\")\n",
    "myLabel10a.grid(row=11, column=40)\n",
    "\n",
    "myLabel0c = Label(root,text=\"Mass of Star(Msun)\",fg=\"white\",bg=\"black\")\n",
    "myLabel0c.grid(row=12, column=40)\n",
    "\n",
    "\n",
    "myLabel10b= Label(root,text=\"Define some parameters as zero\",fg=\"white\",bg=\"black\")\n",
    "myLabel10b.grid(row=15, column=40)\n",
    "        \n",
    "####### Σταθερες γιa MCMC\n",
    "\n",
    "bmc = Entry(root,width=20,bg=\"white\")\n",
    "bmc.grid(row=16, column=60)\n",
    "bmc.get()\n",
    "\n",
    "permc = Entry(root,width=20,bg=\"white\")\n",
    "permc.grid(row=17, column=60)\n",
    "permc.get()\n",
    "\n",
    "rplmc = Entry(root,width=20,bg=\"white\")\n",
    "rplmc.grid(row=18, column=60)\n",
    "rplmc.get()\n",
    "\n",
    "eccnmc = Entry(root,width=20,bg=\"white\")\n",
    "eccnmc.grid(row=19, column=60)\n",
    "eccnmc.get()\n",
    "\n",
    "ommc = Entry(root,width=20,bg=\"white\")\n",
    "ommc.grid(row=20, column=60)\n",
    "ommc.get()\n",
    "\n",
    "         \n",
    "myLabel22 = Label(root,text=\"Define constants for the MCMC\",fg=\"white\",bg=\"black\")\n",
    "myLabel22.grid(row=16, column=40)\n",
    "\n",
    "\n",
    "\n",
    "######\n",
    "\n",
    "myLabel10= Label(root,text=\"Optimize your parameters \\n through Gaussian Process\",fg=\"white\",bg=\"black\")\n",
    "myLabel10.grid(row=22, column=40)\n",
    "    \n",
    "\n",
    "myButton10 = Button(root, text=\"Optimization 1\", padx=27, pady=5, command=Optim1, fg=\"blue\", bg=\"white\")\n",
    "myButton10.grid(row=22, column=50)\n",
    "    \n",
    "    \n",
    "\n",
    "\n",
    "def Opt_Plot():\n",
    "    \n",
    "    global map_soln,map_soln0,model,model0,mask,y,x,plot_light_curve,gp_mod\n",
    "    \n",
    "    def plot_light_curve(soln, mask=None):\n",
    "        if mask is None:\n",
    "            mask = np.ones(len(x), dtype=bool)\n",
    "\n",
    "        fig, axes = plt.subplots(3, 1, figsize=(10, 7), sharex=True)\n",
    "\n",
    "        ax = axes[0]\n",
    "        ax.plot(x[mask], y[mask], \"k\", label=\"data\")\n",
    "        gp_mod = soln[\"gp_pred\"] + soln[\"mean\"]\n",
    "        ax.plot(x[mask], gp_mod, color=\"C2\", label=\"gp model\")\n",
    "        ax.legend(fontsize=10)\n",
    "        ax.set_ylabel(\"relative flux [ppt]\")\n",
    "\n",
    "        ax = axes[1]\n",
    "        ax.plot(x[mask], y[mask] - gp_mod, \"k\", label=\"de-trended data\")\n",
    "        for i, l in enumerate(\"b\"):\n",
    "            mod = soln[\"light_curves\"][:, i]\n",
    "            ax.plot(x[mask], mod, label=\"planet {0}\".format(l))\n",
    "        ax.legend(fontsize=10, loc=3)\n",
    "        ax.set_ylabel(\"de-trended flux [ppt]\")\n",
    "\n",
    "        ax = axes[2]\n",
    "        mod = gp_mod + np.sum(soln[\"light_curves\"], axis=-1)\n",
    "        ax.plot(x[mask], y[mask] - mod, \"k\")\n",
    "        ax.axhline(0, color=\"#aaaaaa\", lw=1)\n",
    "        ax.set_ylabel(\"residuals [ppt]\")\n",
    "        ax.set_xlim(x[mask].min(), x[mask].max())\n",
    "        ax.set_xlabel(\"time [days]\")\n",
    "\n",
    "        return fig\n",
    "\n",
    "\n",
    "    _ = plot_light_curve(map_soln0)\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "myLabel11= Label(root,text=\"Detrend the curve and plot it\\n with the optimized parameters\",fg=\"white\",bg=\"black\")\n",
    "myLabel11.grid(row=30, column=40)\n",
    "    \n",
    "\n",
    "myButton11 = Button(root, text=\"Optimized Lightcurve \", padx=7, pady=5, command=Opt_Plot, fg=\"blue\", bg=\"white\")\n",
    "myButton11.grid(row=30, column=50)\n",
    "    \n",
    "\n",
    "\n",
    "def Outliers():\n",
    "    \n",
    "    global map_soln,map_soln0,model,model0,mask,y,x\n",
    "    \n",
    "    mod = (\n",
    "        map_soln0[\"gp_pred\"]\n",
    "        + map_soln0[\"mean\"]\n",
    "        + np.sum(map_soln0[\"light_curves\"], axis=-1)\n",
    "    )\n",
    "    resid = y - mod\n",
    "    rms = np.sqrt(np.median(resid ** 2))\n",
    "    mask = np.abs(resid) < 5 * rms\n",
    "\n",
    "    plt.figure(figsize=(10, 5))\n",
    "    plt.plot(x, resid, \"k\", label=\"data\")\n",
    "    plt.plot(x[~mask], resid[~mask], \"xr\", label=\"outliers\")\n",
    "    plt.axhline(0, color=\"#aaaaaa\", lw=1)\n",
    "    plt.ylabel(\"residuals [ppt]\")\n",
    "    plt.xlabel(\"time [days]\")\n",
    "    plt.legend(fontsize=12, loc=3)\n",
    "    _ = plt.xlim(x.min(), x.max())\n",
    "    plt.show()    \n",
    "    \n",
    "    \n",
    "myLabel12= Label(root,text=\"Remove the outliers from your Data\",fg=\"white\",bg=\"black\")\n",
    "myLabel12.grid(row=35, column=40)\n",
    "    \n",
    "\n",
    "myButton12 = Button(root, text=\"Remove Outliers\", padx=22, pady=5, command=Outliers, fg=\"blue\", bg=\"white\")\n",
    "myButton12.grid(row=35, column=50)    \n",
    "    \n",
    " \n",
    "  \n",
    "def Optim2():\n",
    "    \n",
    "    global map_soln,map_soln0,model,model0,mask,y,x,build_model,plot_light_curve\n",
    "    \n",
    "    model, map_soln = build_model(mask, map_soln0)\n",
    "    _ = plot_light_curve(map_soln, mask)\n",
    "    plt.show()\n",
    "\n",
    "myLabel13= Label(root,text=\"Re-Optimize your parameters \\nwithout the outliers\",fg=\"white\",bg=\"black\")\n",
    "myLabel13.grid(row=40, column=40)\n",
    "    \n",
    "\n",
    "myButton13 = Button(root, text=\"Optimization 2\", padx=27, pady=5, command=Optim2, fg=\"blue\", bg=\"white\")\n",
    "myButton13.grid(row=40, column=50)  \n",
    "\n",
    "\n",
    "def Sampling_MCMC():\n",
    "\n",
    "    global map_soln,map_soln0,model,model0,mask,y,x,trace,omega,ecc,r_pl,b,period,r_star,u_star,m_star,t0,mean\n",
    "    \n",
    "    np.random.seed(4271579)\n",
    "    with model:\n",
    "        trace = pmx.sample(\n",
    "            tune=2500,\n",
    "            draws=2000,\n",
    "            start=map_soln,\n",
    "            cores=2,\n",
    "            chains=2,\n",
    "            initial_accept=0.8,\n",
    "            target_accept=0.96,\n",
    "            return_inferencedata=True,\n",
    "            progressbar=True,\n",
    "        )\n",
    "\n",
    "    \n",
    "\n",
    "\n",
    "myLabel14= Label(root,text=\"Run the Sampling for the MCMC\",fg=\"white\",bg=\"black\")\n",
    "myLabel14.grid(row=41, column=40)\n",
    "    \n",
    "myButton14 = Button(root, text=\"Sampling\", padx=41, pady=5, command=Sampling_MCMC, fg=\"blue\", bg=\"white\")\n",
    "myButton14.grid(row=41, column=50) \n",
    "        \n",
    "\n",
    "import arviz as az\n",
    "from pandastable import Table\n",
    "\n",
    "def Summary_MCMC():\n",
    "    global pop,arsum\n",
    "    \n",
    "    if nn.get() == 1:\n",
    "        arsum = az.summary(trace,var_names=[\"omega\",\"ecc\",\"r_pl\",\"b\",\"t0\",\"period\",\"r_star\",\"m_star\",\"u_star\",\"mean\"])\n",
    "    \n",
    "    elif ee.get() == 1 and bb.get() == 1:\n",
    "        arsum = az.summary(trace,var_names=[\"r_pl\",\"t0\",\"period\",\"r_star\",\"m_star\",\"u_star\",\"mean\"])\n",
    "        \n",
    "    elif ee.get() == 1 and bb.get() == 0:   \n",
    "        arsum = az.summary(trace,var_names=[\"r_pl\",\"b\",\"t0\",\"period\",\"r_star\",\"m_star\",\"u_star\",\"mean\"])\n",
    "    \n",
    "    elif ee.get() == 0 and bb.get() == 1:\n",
    "        arsum = az.summary(trace,var_names=[\"omega\",\"ecc\",\"r_pl\",\"t0\",\"period\",\"r_star\",\"m_star\",\"u_star\",\"mean\"])\n",
    "\n",
    "    pop = Toplevel(root)\n",
    "    pop.title(\"MCMC Summary\")    \n",
    "    pop.config(bg=\"black\")\n",
    "    \n",
    "       \n",
    "    frame = tk.Frame(pop)\n",
    "    frame.grid(row=0, column=0)\n",
    "    \n",
    "    pt = Table(frame,dataframe=arsum,showtoolbar=True,showstatusbar=True)\n",
    "    pt.show()\n",
    "    \n",
    "    arsum2 = str(arsum)\n",
    "    \n",
    "    myLabel15b= Label(pop,text=arsum2 + \" \",fg=\"white\",bg=\"black\")\n",
    "    myLabel15b.grid(row=0, column=10) \n",
    "    plt.show()\n",
    "    return arsum  \n",
    "\n",
    "myLabel15= Label(root,text=\"See your parameters after the MCMC\",fg=\"white\",bg=\"black\")\n",
    "myLabel15.grid(row=42, column=40)\n",
    "    \n",
    "\n",
    "myButton15 = Button(root, text=\"Summary\", padx=40, pady=5, command=Summary_MCMC, fg=\"blue\", bg=\"white\")\n",
    "myButton15.grid(row=42, column=50)     \n",
    "    \n",
    "\n",
    "    \n",
    "def Final_Plot():\n",
    "    \n",
    "    global map_soln,map_soln0,model,model0,mask,y,x,trace,x_fold,gp_mod,p\n",
    "    \n",
    "    flat_samps = trace.posterior.stack(sample=(\"chain\", \"draw\"))\n",
    "\n",
    "    # Compute the GP prediction\n",
    "    gp_mod = np.median(flat_samps[\"gp_pred\"].values + flat_samps[\"mean\"].values[None, :], axis=-1)\n",
    "\n",
    "    # Get the posterior median orbital parameters\n",
    "    p = np.median(flat_samps[\"period\"])\n",
    "    t0 = np.median(flat_samps[\"t0\"])\n",
    "\n",
    "\n",
    "    plt.figure(figsize=(8, 8))\n",
    "\n",
    "    # Plot the folded data\n",
    "    x_fold = (x[mask] - t0 + 0.5 * p) % p - 0.5 * p\n",
    "    plt.plot(x_fold, 1+(y[mask] - gp_mod)/1e3, \".k\", label=\"data\", zorder=-1000)\n",
    "\n",
    "    # Overplot the phase binned light curve\n",
    "    bins = np.linspace(-0.41, 0.41, 50)\n",
    "    denom, _ = np.histogram(x_fold, bins)\n",
    "    num, _ = np.histogram(x_fold, bins, weights=y[mask])\n",
    "    denom[num == 0] = 1.0\n",
    "    plt.plot(0.5 * (bins[1:] + bins[:-1]), 1+(num / denom-1)/1e3, \"o\", color=\"C2\", label=\"binned\")\n",
    "\n",
    "    # Plot the folded model\n",
    "    inds = np.argsort(x_fold)\n",
    "    inds = inds[np.abs(x_fold)[inds] < 0.3]\n",
    "    pred = np.percentile(flat_samps[\"light_curves\"][inds, 0], [16, 50, 84], axis=-1)\n",
    "    plt.plot(x_fold[inds], 1+(pred[1])/1e3, color=\"C1\", label=\"model\")\n",
    "\n",
    "\n",
    "    # Annotate the plot with the planet's period\n",
    "    txt = \"period = {0:.5f} +/- {1:.5f} d\".format(np.mean(flat_samps[\"period\"].values), np.std(flat_samps[\"period\"].values))\n",
    "\n",
    "    plt.annotate(\n",
    "        txt,\n",
    "        (0, 0),\n",
    "        xycoords=\"axes fraction\",\n",
    "        xytext=(5, 5),\n",
    "        textcoords=\"offset points\",\n",
    "        ha=\"left\",\n",
    "        va=\"bottom\",\n",
    "        fontsize=12,\n",
    "    )\n",
    "\n",
    "    plt.legend(fontsize=10, loc=4)\n",
    "    plt.xlim(-0.5 * p/6, 0.5 * p/6)\n",
    "    plt.xlabel(\"time since transit [days]\")\n",
    "    plt.ylabel(\"de-trended flux\")\n",
    "\n",
    "    plt.show()\n",
    "    return gp_mod,p\n",
    "    \n",
    "myLabel16 = Label(root,text=\"Plot your final model\",fg=\"white\",bg=\"black\")\n",
    "myLabel16.grid(row=43, column=40)\n",
    "    \n",
    "\n",
    "myButton16 = Button(root, text=\"Model Plot\", padx=37, pady=5, command=Final_Plot, fg=\"blue\", bg=\"white\")\n",
    "myButton16.grid(row=43, column=50)     \n",
    "    \n",
    "\n",
    "    \n",
    "import corner\n",
    "import astropy.units as u\n",
    "def Corner_Plot():\n",
    "\n",
    "    global map_soln,map_soln0,model,model0,mask,y,x,trace\n",
    "    \n",
    "    trace.posterior[\"r_earth\"] = (trace.posterior[\"r_pl\"].coords,(trace.posterior[\"r_pl\"].values * u.R_sun).to(u.R_earth).value)\n",
    "\n",
    "\n",
    "    if nn.get() == 1:\n",
    "        \n",
    "            _ = corner.corner(\n",
    "                trace,\n",
    "                var_names=[\"period\", \"r_earth\", \"b\", \"ecc\",\"omega\"],\n",
    "                labels=[\n",
    "                    \"period [days]\",\n",
    "                    \"radius [Earth radii]\",\n",
    "                    \"impact param\",\n",
    "                    \"eccentricity\",\n",
    "                    \"omega\"\n",
    "                ],\n",
    "            )\n",
    "                     \n",
    "            \n",
    "          \n",
    "    elif ee.get() == 1 and bb.get() == 1:\n",
    "        \n",
    "            _ = corner.corner(\n",
    "                trace,\n",
    "                var_names=[\"period\", \"r_earth\", \"r_star\"],\n",
    "                labels=[\n",
    "                    \"period [days]\",\n",
    "                    \"radius [Earth radii]\",\n",
    "                    \"star radius\"\n",
    "                    \n",
    "                ],\n",
    "            )\n",
    "                     \n",
    "            \n",
    "       \n",
    "    elif ee.get() == 1 and bb.get() == 0:\n",
    "        \n",
    "            _ = corner.corner(\n",
    "                trace,\n",
    "                var_names=[\"period\", \"r_earth\", \"b\",\"r_star\"],\n",
    "                labels=[\n",
    "                    \"period [days]\",\n",
    "                    \"radius [Earth radii]\",\n",
    "                    \"impact param\",\n",
    "                    \"star radius\"\n",
    "                ],\n",
    "            )\n",
    "                     \n",
    "            \n",
    "        \n",
    "\n",
    "    elif ee.get() == 0 and bb.get() == 1:\n",
    "        \n",
    "            _ = corner.corner(\n",
    "                trace,\n",
    "                var_names=[\"period\", \"r_earth\",\"r_star\", \"ecc\",\"omega\"],\n",
    "                labels=[\n",
    "                    \"period [days]\",\n",
    "                    \"radius [Earth radii]\",\n",
    "                    \"star radius\",\n",
    "                    \"eccentricity\",\n",
    "                    \"omega\"\n",
    "                ],\n",
    "            )\n",
    "                     \n",
    "    plt.show()      \n",
    "       \n",
    "            \n",
    "            \n",
    "            \n",
    "myLabel17 = Label(root,text=\"Plot the corner plot of your parameters\",fg=\"white\",bg=\"black\")\n",
    "myLabel17.grid(row=44, column=40)\n",
    "    \n",
    "\n",
    "myButton17 = Button(root, text=\"Corner Plot\", padx=36, pady=5, command=Corner_Plot, fg=\"blue\", bg=\"white\")\n",
    "myButton17.grid(row=44, column=50)  \n",
    "\n",
    "\n",
    "\n",
    "myLabel18g = Label(root,text=\"           \\n                \",fg=\"blue\",bg=\"black\")\n",
    "myLabel18g.grid(row=46, column=40)\n",
    "\n",
    "myLabel19g = Label(root,text=\"           \\n                \",fg=\"blue\",bg=\"black\")\n",
    "myLabel19g.grid(row=47, column=40)\n",
    "\n",
    "myLabel20g = Label(root,text=\"           \\n                \",fg=\"blue\",bg=\"black\")\n",
    "myLabel20g.grid(row=48, column=40)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "##############################################################################################################\n",
    "##############################################################################################################\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "import exoplanet as xo\n",
    "\n",
    "\n",
    "myLabel9= Label(root,text=\"Manual Simulation\",font='Helvetica 20 bold',fg=\"red\",bg=\"black\")\n",
    "myLabel9.grid(row=35, column=0)\n",
    "\n",
    "s = IntVar(0)\n",
    "\n",
    "def Rb():\n",
    "    global s,v\n",
    "   \n",
    "    if s.get() == 1:\n",
    "        v = 1\n",
    "    elif s.get() == 2:\n",
    "        v = 2\n",
    "    else: \n",
    "        v = 3\n",
    "  \n",
    "    return v\n",
    "        \n",
    "\n",
    "Radiobutton(root,text=\"Simulated model\",variable=s,value=1,bg=\"black\",fg=\"white\",\n",
    "                  activebackground='white', activeforeground='white',selectcolor=\"black\").grid(row=40, column=20)\n",
    "\n",
    "Radiobutton(root,text=\"Simulated model \\nwith observed data\",variable=s,value=2,bg=\"black\",fg=\"white\",\n",
    "                  activebackground='white', activeforeground='white',selectcolor=\"black\").grid(row=40, column=24)\n",
    "\n",
    "Radiobutton(root,text=\"Simulated model \\nwith data after MCMC\",variable=s,value=3,bg=\"black\",fg=\"white\",\n",
    "                  activebackground='white', activeforeground='white',selectcolor=\"black\").grid(row=40, column=30)\n",
    "\n",
    "myButton3a = Button(root, text=\"Define the Model\", padx=22, pady=5, command=Rb, fg=\"blue\", bg=\"white\")\n",
    "myButton3a.grid(row=41, column=24)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def Zografia():\n",
    "    global v,rstar2,b2,per2,sma2,rpl2,eccn2,om2,u12,u22,zoom1,zoom2,t02\n",
    "     \n",
    "    \n",
    "    \n",
    "    rstar2 = rstar.get()\n",
    "    b2 = b1.get()\n",
    "    per2 = per.get()\n",
    "    sma2 = sma.get()\n",
    "    rpl2 = rpl.get()\n",
    "    eccn2 = eccn.get()\n",
    "    om2 = om.get()\n",
    "    u12 = u1.get()\n",
    "    u22 = u2.get() \n",
    "    t02 = t0.get()\n",
    "    \n",
    "    if v==1:\n",
    "\n",
    "        orbit = xo.orbits.KeplerianOrbit(period=float(per2), a=float(sma2), r_star=float(rstar2), b=float(b2),\n",
    "                                     ecc=float(eccn2), omega=float(om2), t0=float(t02))\n",
    "        \n",
    "        zoom1 = -0.5*float(per2)\n",
    "        zoom2 = 0.5*float(per2)\n",
    "        t = np.linspace(float(zoom1), float(zoom2), 1000)\n",
    "        u = [float(u12), float(u22)]\n",
    "        light_curve = (xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit, r=float(rpl2), t=t).eval())\n",
    "\n",
    "        plt.plot(t, light_curve + 1, color=\"C0\", lw=2)\n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(t.min()/6, t.max()/6)\n",
    "        plt.show()\n",
    "        \n",
    "    elif v==2:\n",
    "        lc2 = lc.fold(period=best_fit_period, epoch_time=periodogram.transit_time_at_max_power).errorbar();\n",
    "        lc2.plot()\n",
    "        lc2.set_xlim(float(zoom1), float(zoom2))\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "\n",
    "        orbit = xo.orbits.KeplerianOrbit(period=float(per2), a=float(sma2), r_star=float(rstar2), b=float(b2),\n",
    "                                     ecc=float(eccn2), omega=float(om2), t0=float(t02))\n",
    "\n",
    "        t = np.linspace(float(zoom1), float(zoom2), 1000)\n",
    "        u = [float(u12), float(u22)]\n",
    "        light_curve = (xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit, r=float(rpl2), t=t).eval())\n",
    "\n",
    "        plt.plot(t, light_curve + 1, color=\"C0\", lw=2)\n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(float(zoom1), float(zoom2))\n",
    "        plt.show()\n",
    "\n",
    "    elif v==3:\n",
    "        plt.plot(x_fold, 1+(y[mask] - gp_mod)/1e3, \".k\", label=\"data\", zorder=-1000)\n",
    "        plt.xlim(-0.5 * p, 0.5 * p)\n",
    "        _ = plt.xlim(-0.5 * p/6, 0.5 * p/6)\n",
    "        \n",
    "\n",
    "        orbit = xo.orbits.KeplerianOrbit(period=float(per2), a=float(sma2), r_star=float(rstar2), b=float(b2),\n",
    "                                     ecc=float(eccn2), omega=float(om2), t0=float(t02))\n",
    "\n",
    "        t = np.linspace(-0.5 * p, 0.5 * p, 1000)\n",
    "        u = [float(u12), float(u22)]\n",
    "        light_curve = (xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit, r=float(rpl2), t=t).eval())\n",
    "\n",
    "        plt.plot(t, light_curve + 1, color=\"C0\", lw=2)\n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(-0.5 * p/6, 0.5 * p/6)\n",
    "        plt.show()   \n",
    "    return v,rstar2,b2,per2,sma2,rpl2,eccn2,om2,u12,u22,zoom1,zoom2\n",
    "        \n",
    "        \n",
    "        \n",
    "    \n",
    "rstar = Entry(root,width=10,bg=\"white\")\n",
    "rstar.grid(row=40, column=10, sticky=W)\n",
    "rstar.get()\n",
    "    \n",
    "b1 = Entry(root,width=10,bg=\"white\")\n",
    "b1.grid(row=41, column=10, sticky=W)\n",
    "b1.get()\n",
    "\n",
    "per = Entry(root,width=10,bg=\"white\")\n",
    "per.grid(row=42, column=10, sticky=W)\n",
    "per.get()\n",
    "\n",
    "sma = Entry(root,width=10,bg=\"white\")\n",
    "sma.grid(row=43, column=10, sticky=W)\n",
    "sma.get()\n",
    "\n",
    "rpl = Entry(root,width=10,bg=\"white\")\n",
    "rpl.grid(row=44, column=10, sticky=W)\n",
    "rpl.get()\n",
    "\n",
    "eccn = Entry(root,width=10,bg=\"white\")\n",
    "eccn.grid(row=45, column=10, sticky=W)\n",
    "eccn.get()\n",
    "\n",
    "om = Entry(root,width=10,bg=\"white\")\n",
    "om.grid(row=46, column=10, sticky=W)\n",
    "om.get()\n",
    "\n",
    "u1 = Entry(root,width=10,bg=\"white\")\n",
    "u1.grid(row=47, column=10, sticky=W)\n",
    "u1.get()\n",
    "\n",
    "u2 = Entry(root,width=10,bg=\"white\")\n",
    "u2.grid(row=48, column=10, sticky=W)\n",
    "u2.get()\n",
    "\n",
    "t0 = Entry(root,width=10,bg=\"white\")\n",
    "t0.grid(row=42, column=24)\n",
    "t0.get()\n",
    "\n",
    "myLabel8a = Label(root,text=\"Radius of Star(Rsun)\",fg=\"white\",bg=\"black\")\n",
    "myLabel8a.grid(row=40, column=0)\n",
    "\n",
    "myLabel8b = Label(root,text=\"Impact Parameter\",fg=\"white\",bg=\"black\")\n",
    "myLabel8b.grid(row=41, column=0)\n",
    "\n",
    "myLabel8c = Label(root,text=\"Planet Period(Days)\",fg=\"white\",bg=\"black\")\n",
    "myLabel8c.grid(row=42, column=0)\n",
    "\n",
    "myLabel8d = Label(root,text=\"Semi-major Axis(Rsun)\",fg=\"white\",bg=\"black\")\n",
    "myLabel8d.grid(row=43, column=0)\n",
    "\n",
    "myLabel8e = Label(root,text=\"Radius of Planet(Rsun)\",fg=\"white\",bg=\"black\")\n",
    "myLabel8e.grid(row=44, column=0)\n",
    "\n",
    "myLabel8f = Label(root,text=\"Eccentricity\",fg=\"white\",bg=\"black\")\n",
    "myLabel8f.grid(row=45, column=0)\n",
    "\n",
    "myLabel8g = Label(root,text=\"Omega(radians)\",fg=\"white\",bg=\"black\")\n",
    "myLabel8g.grid(row=46, column=0)\n",
    "\n",
    "myLabel8h = Label(root,text=\"Limb Darkening Coeff 1\",fg=\"white\",bg=\"black\")\n",
    "myLabel8h.grid(row=47, column=0)\n",
    "\n",
    "myLabel8i = Label(root,text=\"Limb Darkening Coeff 2\",fg=\"white\",bg=\"black\")\n",
    "myLabel8i.grid(row=48, column=0)\n",
    "\n",
    "myLabel8a = Label(root,text=\"Time of Reference(Days)\",fg=\"white\",bg=\"black\")\n",
    "myLabel8a.grid(row=42, column=20)\n",
    "\n",
    "\n",
    "myButton8 = Button(root, text=\"Exoplanet Model\", padx=30, pady=5, command=Zografia, fg=\"blue\", bg=\"white\")\n",
    "myButton8.grid(row=43, column=24)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "z = 1;\n",
    "def show(event):\n",
    "    global z\n",
    "\n",
    "    if clicked.get() == \"Planet Radius\":\n",
    "        z = 1\n",
    "    elif clicked.get() == \"Star Radius\" :    \n",
    "        z = 2\n",
    "    elif clicked.get() == \"Impact Parameter\" :    \n",
    "        z = 3\n",
    "    elif clicked.get() == \"Semi-Major Axis\":    \n",
    "        z = 4\n",
    "    elif clicked.get() == \"Eccentricity\" :    \n",
    "        z = 5\n",
    "    elif clicked.get() == \"Omega\":     \n",
    "        z = 6\n",
    "    \n",
    "    return z\n",
    "    \n",
    "options = [\"Planet Radius\", \"Star Radius\", \"Impact Parameter\", \"Semi-Major Axis\", \"Eccentricity\", \"Omega\"]\n",
    "\n",
    "clicked = StringVar()\n",
    "clicked.set(options[0])\n",
    "\n",
    "drop = OptionMenu(root, clicked, *options, command=show)\n",
    "drop.grid(row=44, column=24)\n",
    "\n",
    "\n",
    "myLabel90 = Label(root,text=\"Choose a parameter to see \\n how it affects the shape of the LC\",fg=\"white\",bg=\"black\")\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "myLabel4 = Label(root,text=\"First value,last value \\n and step of the parameter\",fg=\"white\",bg=\"black\")\n",
    "myLabel4.grid(row=45, column=20)\n",
    "\n",
    "param1 = Entry(root,width=10,bg=\"white\")\n",
    "param1.grid(row=45, column=24, columnspan=1, sticky=W)\n",
    "param1.get()\n",
    "\n",
    "param2 = Entry(root,width=10,bg=\"white\")\n",
    "param2.grid(row=45, column=24, columnspan=1)\n",
    "param2.get()\n",
    "\n",
    "param3 = Entry(root,width=10,bg=\"white\")\n",
    "param3.grid(row=45, column=24, columnspan=1,sticky=E)\n",
    "param3.get()\n",
    "\n",
    "\n",
    "import exoplanet as xo\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def Zog():\n",
    "    global v,rstar2,b2,per2,sma2,rpl2,eccn2,om2,u12,u22,zoom1,zoom2\n",
    "    \n",
    "    par1 = float(param1.get())*100;\n",
    "    par2 = float(param2.get())*100;\n",
    "    par3 = float(param3.get())*100;\n",
    "    \n",
    "    if z == 1 and v == 1:\n",
    "        u = [float(u12), float(u22)]\n",
    "        \n",
    "        zoom1 = -0.5*float(per2)\n",
    "        zoom2 = 0.5*float(per2)\n",
    "        t = np.linspace(float(zoom1), float(zoom2), 1000)\n",
    "        \n",
    "        for r_pl in np.arange(par1, par2+1, par3):\n",
    "            r_pl=r_pl/100;\n",
    "            \n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2),a=float(sma2),r_star=float(rstar2),b=float(b2),\n",
    "                                     ecc=float(eccn2),omega=float(om2), t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1,r=r_pl,t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$r_pl={r_pl}$\")\n",
    "            \n",
    "        \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(t.min()/6, t.max()/6)    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "    elif z == 1 and v == 2:\n",
    "        lc2 = lc.fold(period=best_fit_period, epoch_time=periodogram.transit_time_at_max_power).errorbar();\n",
    "        lc2.plot()\n",
    "        lc2.set_xlim(float(zoom1), float(zoom2))\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "\n",
    "        \n",
    "        u = [float(u12), float(u22)]\n",
    "        t = np.linspace(float(zoom1), float(zoom2), 1000)\n",
    "  \n",
    "\n",
    "        for r_pl in np.arange(par1, par2+1, par3):\n",
    "            r_pl=r_pl/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2), a=float(sma2), r_star=float(rstar2), b=float(b2),\n",
    "                                     ecc=float(eccn2), omega=float(om2), t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=r_pl, t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$r_pl={r_pl}$\")\n",
    " \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(float(zoom1), float(zoom2))    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "    elif z == 1 and v == 3:\n",
    "        plt.plot(x_fold, 1+(y[mask] - gp_mod)/1e3, \".k\", label=\"data\", zorder=-1000)\n",
    "        plt.xlim(-0.5 * p/6, 0.5 * p/6)\n",
    "       \n",
    "        \n",
    "        u = [float(u12), float(u22)]\n",
    "        t = np.linspace(-0.5 * p, 0.5 * p, 1000)\n",
    "  \n",
    "\n",
    "        for r_pl in np.arange(par1, par2+1, par3):\n",
    "            r_pl=r_pl/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2), a=float(sma2), r_star=float(rstar2), b=float(b2),\n",
    "                                     ecc=float(eccn2), omega=float(om2), t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=r_pl, t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$r_pl={r_pl}$\")\n",
    " \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(-0.5 * p/6, 0.5 * p/6)   \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "################################################################################################r_star\n",
    "    elif z == 2 and v == 1:\n",
    "        u = [float(u12), float(u22)]\n",
    "        zoom1 = -0.5*float(per2)\n",
    "        zoom2 = 0.5*float(per2)\n",
    "        t = np.linspace(float(zoom1), float(zoom2), 1000)\n",
    "        \n",
    "\n",
    "        for r_star in np.arange(par1, par2+1, par3):\n",
    "            r_star=r_star/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2), a=float(sma2), r_star=r_star,  b=float(b2),\n",
    "                                     ecc=float(eccn2), omega=float(om2), t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=float(rpl2), t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$r_star={r_star}$\")\n",
    " \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(t.min()/6, t.max()/6)    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "    elif z == 2 and v == 2:\n",
    "        lc2 = lc.fold(period=best_fit_period, epoch_time=periodogram.transit_time_at_max_power).errorbar();\n",
    "        lc2.plot()\n",
    "        lc2.set_xlim(float(zoom1), float(zoom2))\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "\n",
    "        \n",
    "        u = [float(u12), float(u22)]\n",
    "        t = np.linspace(float(zoom1), float(zoom2), 1000)\n",
    "  \n",
    "\n",
    "        for r_star in np.arange(par1, par2+1, par3):\n",
    "            r_star=r_star/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2), a=float(sma2), r_star=r_star,  b=float(b2),\n",
    "                                     ecc=float(eccn2), omega=float(om2), t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=float(rpl2), t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$r_star={r_star}$\")\n",
    " \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(float(zoom1), float(zoom2))    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "    elif z == 2 and v == 3:\n",
    "        plt.plot(x_fold, 1+(y[mask] - gp_mod)/1e3, \".k\", label=\"data\", zorder=-1000)\n",
    "        plt.xlim(-0.5 * p, 0.5 * p)\n",
    "        _ = plt.xlim(-0.5 * p/6, 0.5 * p/6)\n",
    "        \n",
    "\n",
    "\n",
    "        \n",
    "        u = [float(u12), float(u22)]\n",
    "        t = np.linspace(-0.5 * p, 0.5 * p, 1000)\n",
    "  \n",
    "\n",
    "        for r_star in np.arange(par1, par2+1, par3):\n",
    "            r_star=r_star/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2), a=float(sma2), r_star=r_star,  b=float(b2),\n",
    "                                     ecc=float(eccn2), omega=float(om2), t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=float(rpl2), t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$r_star={r_star}$\")\n",
    " \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(-0.5 * p/6, 0.5 * p/6)    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "\n",
    "################################################################################################impact_parameter\n",
    "    elif z == 3 and v == 1:\n",
    "        u = [float(u12), float(u22)]\n",
    "        zoom1 = -0.5*float(per2)\n",
    "        zoom2 = 0.5*float(per2)\n",
    "        t = np.linspace(float(zoom1), float(zoom2), 1000)\n",
    "  \n",
    "\n",
    "        for b in np.arange(par1, par2+1, par3):\n",
    "            b=b/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2), a=float(sma2), b=b,  r_star=float(rstar2),\n",
    "                                     ecc=float(eccn2), omega=float(om2), t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=float(rpl2), t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$b={b}$\")\n",
    " \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(t.min()/6, t.max()/6)    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "    elif z == 3 and v == 2:\n",
    "        lc2 = lc.fold(period=best_fit_period, epoch_time=periodogram.transit_time_at_max_power).errorbar();\n",
    "        lc2.plot()\n",
    "        lc2.set_xlim(float(zoom1), float(zoom2))\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "\n",
    "        \n",
    "        u = [float(u12), float(u22)]\n",
    "        t = np.linspace(float(zoom1), float(zoom2), 1000)\n",
    "  \n",
    "\n",
    "        for b in np.arange(par1, par2+1, par3):\n",
    "            b=b/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2), a=float(sma2), b=b, r_star=float(rstar2),\n",
    "                                     ecc=float(eccn2), omega=float(om2), t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=float(rpl2), t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$b={b}$\")\n",
    " \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(float(zoom1), float(zoom2))    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "    elif z == 3 and v == 3:\n",
    "        plt.plot(x_fold, 1+(y[mask] - gp_mod)/1e3, \".k\", label=\"data\", zorder=-1000)\n",
    "        plt.xlim(-0.5 * p, 0.5 * p)\n",
    "        _ = plt.xlim(-0.5 * p/6, 0.5 * p/6)\n",
    "        \n",
    "\n",
    "\n",
    "        \n",
    "        u = [float(u12), float(u22)]\n",
    "        t = np.linspace(-0.5 * p, 0.5 * p, 1000)\n",
    "  \n",
    "\n",
    "        for b in np.arange(par1, par2+1, par3):\n",
    "            b=b/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2), a=float(sma2), b=b, r_star=float(rstar2),\n",
    "                                     ecc=float(eccn2), omega=float(om2), t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=float(rpl2), t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$b={b}$\")\n",
    " \n",
    "        \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(-0.5 * p/6, 0.5 * p/6)    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "\n",
    "################################################################################################Semi-Major Axis\n",
    "    elif z == 4 and v == 1:\n",
    "        u = [float(u12), float(u22)]\n",
    "        zoom1 = -0.5*float(per2)\n",
    "        zoom2 = 0.5*float(per2)\n",
    "        t = np.linspace(float(zoom1), float(zoom2), 1000)\n",
    "  \n",
    "\n",
    "        for a in np.arange(par1, par2+1, par3):\n",
    "            a=a/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2),  b=float(b2), a=a, r_star=float(rstar2),\n",
    "                                     ecc=float(eccn2), omega=float(om2), t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=float(rpl2), t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$a={a}$\")\n",
    " \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(t.min()/6, t.max()/6)    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "    elif z == 4 and v == 2:\n",
    "        lc2 = lc.fold(period=best_fit_period, epoch_time=periodogram.transit_time_at_max_power).errorbar();\n",
    "        lc2.plot()\n",
    "        lc2.set_xlim(float(zoom1), float(zoom2))\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "\n",
    "        \n",
    "        u = [float(u12), float(u22)]\n",
    "        t = np.linspace(float(zoom1), float(zoom2), 1000)\n",
    "  \n",
    "\n",
    "        for a in np.arange(par1, par2+1, par3):\n",
    "            a=a/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2),  b=float(b2), a=a, r_star=float(rstar2),\n",
    "                                     ecc=float(eccn2), omega=float(om2), t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=float(rpl2), t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$a={a}$\")\n",
    " \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(float(zoom1), float(zoom2))    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "    elif z == 4 and v == 3:\n",
    "        plt.plot(x_fold, 1+(y[mask] - gp_mod)/1e3, \".k\", label=\"data\", zorder=-1000)\n",
    "        plt.xlim(-0.5 * p, 0.5 * p)\n",
    "        _ = plt.xlim(-0.5 * p/6, 0.5 * p/6)\n",
    "        \n",
    "\n",
    "\n",
    "        \n",
    "        u = [float(u12), float(u22)]\n",
    "        t = np.linspace(-0.5 * p, 0.5 * p, 1000)\n",
    "  \n",
    "\n",
    "        for a in np.arange(par1, par2+1, par3):\n",
    "            a=a/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2),  b=float(b2), a=a, r_star=float(rstar2),\n",
    "                                     ecc=float(eccn2), omega=float(om2), t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=float(rpl2), t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$a={a}$\")\n",
    " \n",
    "        \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(-0.5 * p/6, 0.5 * p/65)    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "\n",
    "################################################################################################Eccentricity\n",
    "    elif z == 5 and v == 1:\n",
    "        u = [float(u12), float(u22)]\n",
    "        zoom1 = -0.5*float(per2)\n",
    "        zoom2 = 0.5*float(per2)\n",
    "        t = np.linspace(float(zoom1), float(zoom2), 1000)\n",
    "  \n",
    "\n",
    "        for ecc in np.arange(par1, par2+1, par3):\n",
    "            ecc=ecc/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2),  b=float(b2), ecc=ecc, r_star=float(rstar2),\n",
    "                                     a=float(sma2), omega=float(om2), t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=float(rpl2), t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$ecc={ecc}$\")\n",
    " \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(t.min()/6, t.max()/6)    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "    elif z == 5 and v == 2:\n",
    "        lc2 = lc.fold(period=best_fit_period, epoch_time=periodogram.transit_time_at_max_power).errorbar();\n",
    "        lc2.plot()\n",
    "        lc2.set_xlim(float(zoom1), float(zoom2))\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "\n",
    "        \n",
    "        u = [float(u12), float(u22)]\n",
    "        t = np.linspace(float(zoom1), float(zoom2), 1000)\n",
    "  \n",
    "\n",
    "        for ecc in np.arange(par1, par2+1, par3):\n",
    "            ecc=ecc/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2),  b=float(b2), ecc=ecc, r_star=float(rstar2),\n",
    "                                     a=float(sma2), omega=float(om2), t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=float(rpl2), t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$ecc={ecc}$\")\n",
    " \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(float(zoom1), float(zoom2))    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "    elif z == 5 and v == 3:\n",
    "        plt.plot(x_fold, 1+(y[mask] - gp_mod)/1e3, \".k\", label=\"data\", zorder=-1000)\n",
    "        plt.xlim(-0.5 * p, 0.5 * p)\n",
    "        _ = plt.xlim(-0.5 * p/6, 0.5 * p/6)\n",
    "\n",
    "        \n",
    "        u = [float(u12), float(u22)]\n",
    "        t = np.linspace(-0.5 * p, 0.5 * p, 1000)\n",
    "  \n",
    "\n",
    "        for ecc in np.arange(par1, par2+1, par3):\n",
    "            ecc=ecc/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2),  b=float(b2), ecc=ecc, r_star=float(rstar2),\n",
    "                                     a=float(sma2), omega=float(om2), t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=float(rpl2), t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$ecc={ecc}$\")\n",
    " \n",
    "        \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(-0.5 * p/6, 0.5 * p/6)    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "\n",
    "################################################################################################Omega\n",
    "    elif z == 6 and v == 1:\n",
    "        u = [float(u12), float(u22)]\n",
    "        zoom1 = -0.5*float(per2)\n",
    "        zoom2 = 0.5*float(per2)\n",
    "        t = np.linspace(float(zoom1), float(zoom2), 1000)\n",
    "  \n",
    "        for omega in np.arange(par1, par2+1, par3):\n",
    "            omega=omega/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2),  b=float(b2),  r_star=float(rstar2),\n",
    "                                     a=float(sma2), ecc=float(eccn2), omega=omega, t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=float(rpl2), t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$omega={omega}$\")\n",
    " \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(t.min()/6, t.max()/6)    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "    elif z == 6 and v == 2:\n",
    "        lc2 = lc.fold(period=best_fit_period, epoch_time=periodogram.transit_time_at_max_power).errorbar();\n",
    "        lc2.plot()\n",
    "        lc2.set_xlim(float(zoom1), float(zoom2))\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "\n",
    "        \n",
    "        u = [float(u12), float(u22)]\n",
    "        t = np.linspace(float(zoom1), float(zoom2), 1000)\n",
    "  \n",
    "\n",
    "        for omega in np.arange(par1, par2+1, par3):\n",
    "            omega=omega/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2),  b=float(b2),  r_star=float(rstar2),\n",
    "                                     a=float(sma2), ecc=float(eccn2), omega=omega, t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=float(rpl2), t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$omega={omega}$\")\n",
    " \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(float(zoom1), float(zoom2))    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "    elif z == 6 and v == 3:\n",
    "        plt.plot(x_fold, 1+(y[mask] - gp_mod)/1e3, \".k\", label=\"data\", zorder=-1000)\n",
    "        plt.xlim(-0.5 * p, 0.5 * p)\n",
    "        _ = plt.xlim(-0.5 * p/6, 0.5 * p/6)\n",
    "        \n",
    "\n",
    "\n",
    "        \n",
    "        u = [float(u12), float(u22)]\n",
    "        t = np.linspace(-0.5 * p, 0.5 * p, 1000)\n",
    "  \n",
    "\n",
    "        for omega in np.arange(par1, par2+1, par3):\n",
    "            omega=omega/100;\n",
    "            orbit1 = xo.orbits.KeplerianOrbit(period=float(per2),  b=float(b2),  r_star=float(rstar2),\n",
    "                                     a=float(sma2), ecc=float(eccn2), omega=omega, t0=float(t02))\n",
    "            light_curve = xo.LimbDarkLightCurve(u).get_light_curve(orbit=orbit1, r=float(rpl2), t=t).eval()\n",
    "            plt.plot(t, light_curve+1, label=f\"$omega={omega}$\")\n",
    " \n",
    "        \n",
    "        \n",
    "        plt.ylabel(\"Flux\")\n",
    "        plt.xlabel(\"Time [JD]\")\n",
    "        _ = plt.xlim(-0.5 * p/6, 0.5 * p/6)    \n",
    "    \n",
    "        plt.legend(bbox_to_anchor=(1.32,0.95))\n",
    "        plt.show()       \n",
    "\n",
    "\n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "myLabel4 = Label(root,text=\"Multiple LC Model\",fg=\"white\",bg=\"black\")\n",
    "myLabel4.grid(row=46, column=20)\n",
    "\n",
    "myButton4 = Button(root, text=\"Multiple LC Model\", padx=33, pady=5, command=Zog, fg=\"blue\", bg=\"white\")\n",
    "myButton4.grid(row=46, column=24)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "root.mainloop()\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}