test_likelihood.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import multiprocessing\n",
    "import time\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "import emcee\n",
    "import testkit\n",
    "import ciamod\n",
    "import settings\n",
    "import os\n",
    "import gc\n",
    "import sys\n",
    "import pickle\n",
    "from scipy.io.idl import readsav\n",
    "from scipy import interpolate\n",
    "from scipy.interpolate import interp1d\n",
    "from scipy.interpolate import InterpolatedUnivariateSpline\n",
    "\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mgimg\n",
    "import TPmod\n",
    "import forwardmodel\n",
    "from IPython.display import display\n",
    "%matplotlib inline\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# First get data and parameters for object\n",
    "\n",
    "# get the observed spectrum\n",
    "obspec = np.asfortranarray(np.loadtxt(\"G570D_2MHcalib.dat\",dtype='d',unpack='true'))\n",
    "\n",
    "# start with the wavelength range\n",
    "w1 = 1.0\n",
    "w2 = 2.5\n",
    "\n",
    "\n",
    "# How many patches & clouds do we want??\n",
    "# Must be at least 1 of each, but can turn off cloud below\n",
    "npatches = 2\n",
    "nclouds = 1\n",
    "\n",
    "# set up array for setting patchy cloud answers\n",
    "do_clouds = np.zeros([npatches],dtype='i')\n",
    "\n",
    "# Which patches are cloudy\n",
    "do_clouds[0] = 0\n",
    "do_clouds[1] = 1\n",
    "# set up cloud detail arrays\n",
    "cloudnum = np.zeros([npatches,nclouds],dtype='i')\n",
    "cloudtype =np.zeros([npatches,nclouds],dtype='i')\n",
    "\n",
    "print(cloudtype.size)\n",
    "# Now fill cloud details. What kind of clouds and shape are they?\n",
    "# Cloud types\n",
    "# 1:  slab cloud\n",
    "# 2: deep thick cloud , we only see the top\n",
    "# 3: slab with fixed thickness log dP = 0.005 (i.e. fits within a single layer)\n",
    "# 4: deep thick cloud with fixed height (i.e. appears in a single layer)\n",
    "# In both cases the cloud properties are density, rg, rsig for real clouds\n",
    "# and dtau, w0, and power law for cloudnum = 89 or 99 for grey\n",
    "cloudnum[:,0] = 5\n",
    "cloudtype[:,0] = 1\n",
    "\n",
    "#cloudnum[:,1] = 2\n",
    "#cloudtype[:,1] = 1\n",
    "\n",
    "#cloudnum[:,2] = 2\n",
    "#cloudtype[:,2] = 2\n",
    "\n",
    "# second patch turn off top cloud\n",
    "#cloudnum[1,0] = 5\n",
    "#cloudtype[1,0] = 0\n",
    "\n",
    "#cloudnum[1,1] = 5\n",
    "#cloudtype[1,1] = 0\n",
    "\n",
    "\n",
    "# gravity??\n",
    "logg = 4.0\n",
    "\n",
    "# distance (parsecs)\n",
    "dist =5.882\n",
    "\n",
    "# scale factor r2d2 from distance 1 Rj radius\n",
    "r2d2 = (71492e3)**2. / (dist * 3.086e+16)**2.\n",
    "\n",
    "# Are we doing H- bound-free, free-free continuum opacities?\n",
    "# (Is the profile going above approx 3000K in the photosphere?)\n",
    "do_bff = 1\n",
    "\n",
    "chemeq = 0\n",
    "\n",
    "# Set the profile type. If we're using a fixed one. Give the file name\n",
    "proftype = 9\n",
    "pfile = \"t1700g1000f3.dat\"\n",
    "\n",
    "\n",
    "# set up pressure grids in bar cos its intuitive\n",
    "logcoarsePress = np.arange(-4.0, 2.5, 0.53)\n",
    "logfinePress = np.arange(-4.0, 2.4, 0.1)\n",
    "# forward model wants pressure in bar\n",
    "#logcoarsePress = np.arange(-4.0, 3.0, 0.5)\n",
    "coarsePress = pow(10,logcoarsePress)\n",
    "press = pow(10,logfinePress)\n",
    "nlayers = press.size\n",
    "\n",
    "# Where are the cross sections?\n",
    "# give the full path\n",
    "xpath = \"../Linelists/\"\n",
    "\n",
    "# now the cross sections\n",
    "\n",
    "# Now list the gases.\n",
    "# If Na is after K, at the end of the list, alkalis will be tied\n",
    "# together at Asplund solar ratio. See Line at al (2015)\n",
    "# Else if K is after Na, they'll be separate\n",
    "\n",
    "gaslist = ['h2o','ch4']\n",
    "ngas = len(gaslist)\n",
    "\n",
    "# some switches for alternative cross sections\n",
    "# Use Mike's Alkalis?\n",
    "malk = 1\n",
    "# Use Mike's CH4?\n",
    "mch4 = 0\n",
    "\n",
    "fwhm = 0\n",
    "# Are we using DISORT for radiative transfer?\n",
    "# (HINT: Not in this century)\n",
    "use_disort = 0 \n",
    "\n",
    "# use the fudge factor?\n",
    "do_fudge = 1\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 371)\n",
      "[1.00000000e-04 1.25892541e-04 1.58489319e-04 1.99526231e-04\n",
      " 2.51188643e-04 3.16227766e-04 3.98107171e-04 5.01187234e-04\n",
      " 6.30957344e-04 7.94328235e-04 1.00000000e-03 1.25892541e-03\n",
      " 1.58489319e-03 1.99526231e-03 2.51188643e-03 3.16227766e-03\n",
      " 3.98107171e-03 5.01187234e-03 6.30957344e-03 7.94328235e-03\n",
      " 1.00000000e-02 1.25892541e-02 1.58489319e-02 1.99526231e-02\n",
      " 2.51188643e-02 3.16227766e-02 3.98107171e-02 5.01187234e-02\n",
      " 6.30957344e-02 7.94328235e-02 1.00000000e-01 1.25892541e-01\n",
      " 1.58489319e-01 1.99526231e-01 2.51188643e-01 3.16227766e-01\n",
      " 3.98107171e-01 5.01187234e-01 6.30957344e-01 7.94328235e-01\n",
      " 1.00000000e+00 1.25892541e+00 1.58489319e+00 1.99526231e+00\n",
      " 2.51188643e+00 3.16227766e+00 3.98107171e+00 5.01187234e+00\n",
      " 6.30957344e+00 7.94328235e+00 1.00000000e+01 1.25892541e+01\n",
      " 1.58489319e+01 1.99526231e+01 2.51188643e+01 3.16227766e+01\n",
      " 3.98107171e+01 5.01187234e+01 6.30957344e+01 7.94328235e+01\n",
      " 1.00000000e+02 1.25892541e+02 1.58489319e+02 1.99526231e+02]\n"
     ]
    }
   ],
   "source": [
    "print(obspec.shape)\n",
    "print(press)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['../Linelists/h2o_ucl2017_xsecs_R10K.pic', '../Linelists/ch4_xsecs_R10K.pic']\n",
      "[1 2]\n"
     ]
    }
   ],
   "source": [
    "# Now we'll get the opacity files into an array\n",
    "totgas = 24\n",
    "gasdata = []\n",
    "with open('gaslistR10K.dat') as fa:\n",
    "     for line_aa in fa.readlines()[1:totgas+1]:\n",
    "        line_aa = line_aa.strip()\n",
    "        gasdata.append(line_aa.split())\n",
    "list1 = []    \n",
    "for i in range(0,ngas):\n",
    "    for j in range(0,totgas):\n",
    "            if (gasdata[j][1].lower() == gaslist[i].lower()):\n",
    "                list1.append(gasdata[j])\n",
    "\n",
    "\n",
    "    \n",
    "if (malk == 1):\n",
    "    for i in range (0,ngas):    \n",
    "        list1[i] = [w.replace('K_xsecs.pic', 'K_Mike_xsecs.pic') for w in list1[i]]\n",
    "        list1[i] = [w.replace('Na_xsecs.pic', 'Na_Mike_xsecs.pic') for w in list1[i]]\n",
    "\n",
    "if (mch4 ==1):\n",
    "    for i in range (0,ngas):    \n",
    "        list1[i] = [w.replace('CH4_xsecs.pic', 'CH4_Mike_xsecs.pic') for w in list1[i]]\n",
    "    \n",
    "\n",
    "lists = [xpath+i[3] for i in list1[0:ngas]]\n",
    "gasnum = np.asfortranarray(np.array([i[0] for i in list1[0:ngas]],dtype='i'))\n",
    "print(lists)\n",
    "print(gasnum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the basic framework from water list\n",
    "rawwavenum, inpress, inlinetemps, inlinelist = pickle.load( open(xpath+'/crh_xsecs_R10K.pic', \"rb\" ) )\n",
    "\n",
    "wn1 = 10000./w2\n",
    "wn2 = 10000. / w1\n",
    "inwavenum = np.asfortranarray(rawwavenum[np.where(np.logical_not(np.logical_or(rawwavenum[:] > wn2, rawwavenum[:] < wn1)))],dtype='float64')\n",
    "ntemps = inlinetemps.size\n",
    "npress= press.size\n",
    "nwave = inwavenum.size\n",
    "r1 = np.amin(np.where(np.logical_not(np.logical_or(rawwavenum[:] > wn2, rawwavenum[:] < wn1))))\n",
    "r2 = np.amax(np.where(np.logical_not(np.logical_or(rawwavenum[:] > wn2, rawwavenum[:] < wn1))))\n",
    "\n",
    "# Here we are interpolating the linelist onto our fine pressure scale.\n",
    "# pickles have linelist as 4th entry....\n",
    "linelist = (np.ones([ngas,npress,ntemps,nwave],order='F')).astype('float64', order='F')\n",
    "for gas in range (0,ngas):\n",
    "    inlinelist= pickle.load( open(lists[gas], \"rb\" ) )[3]\n",
    "    for i in range (0,ntemps):\n",
    "        for j in range (r1,r2+1):\n",
    "            pfit = interp1d(np.log10(inpress),np.log10(inlinelist[:,i,j]))\n",
    "            linelist[gas,:,i,(j-r1)] = np.asfortranarray(pfit(np.log10(press)))\n",
    "\n",
    "linelist[np.isnan(linelist)] = -50.0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2,)\n",
      "(2, 64, 27, 9163)\n"
     ]
    }
   ],
   "source": [
    "print(gasnum.shape)\n",
    "print(linelist.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the cia bits\n",
    "tmpcia, ciatemps = ciamod.read_cia(\"CIA_DS_aug_2015.dat\",inwavenum)\n",
    "cia = np.asfortranarray(np.empty((4,ciatemps.size,nwave)),dtype='float32')\n",
    "cia[:,:,:] = tmpcia[:,:,:nwave] \n",
    "ciatemps = np.asfortranarray(ciatemps, dtype='float32')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sort out the BFF opacity stuff and chemical equilibrium tables:\n",
    "metscale,coscale,Tgrid,Pgrid,gasnames,abunds = pickle.load(open(\"chem_eq_tables_P3K.pic\", \"rb\"))\n",
    "nlayers = press.shape[0]\n",
    "nabpress = Pgrid.size\n",
    "nabtemp = Tgrid.size\n",
    "nabgas = abunds.shape[4]\n",
    "nmet = metscale.size\n",
    "nco = coscale.size\n",
    "\n",
    "\n",
    "\n",
    "bff_raw = np.zeros([nabtemp,nlayers,3])\n",
    "gases_myP = np.zeros([nmet,nco,nabtemp,nlayers,ngas+3])\n",
    "gases = np.zeros([nmet,nco,nabtemp,nabpress,ngas+3])\n",
    "\n",
    "if (chemeq == 0):\n",
    "    # Just want the ion fractions for solar metallicity in this case\n",
    "    ab_myP = np.empty([nabtemp,nlayers,nabgas])\n",
    "    i1 = np.where(metscale == 0.0)\n",
    "    i2 = np.where(coscale == 1.0)\n",
    "    for gas in range (0,nabgas):\n",
    "        for i in range (0,nabtemp):\n",
    "            pfit = InterpolatedUnivariateSpline(Pgrid,np.log10(abunds[i1[0],i2[0],i,:,gas]),k=1)\n",
    "            ab_myP[i,:,gas] = pfit(np.log10(press))\n",
    "            \n",
    "            bff_raw = np.zeros([nabtemp,nlayers,3])\n",
    "            bff_raw[:,:,0] = ab_myP[:,:,0]\n",
    "            bff_raw[:,:,1] = ab_myP[:,:,2]\n",
    "            bff_raw[:,:,2] = ab_myP[:,:,4]\n",
    "\n",
    "else:\n",
    "    # In this case we need the rows for the gases we're doing and ion fractions\n",
    "    gases[:,:,:,:,0] = abunds[:,:,:,:,0]\n",
    "    gases[:,:,:,:,1] = abunds[:,:,:,:,2]\n",
    "    gases[:,:,:,:,2] = abunds[:,:,:,:,4]\n",
    "    nmatch = 0 \n",
    "    for i in range(0,ngas):\n",
    "        for j in range(0,nabgas):\n",
    "            if (gasnames[j].lower() == gaslist[i].lower()):\n",
    "                gases[:,:,:,:,i+3] = abunds[:,:,:,:,j]\n",
    "                nmatch = nmatch + 1\n",
    "    if (nmatch != ngas):\n",
    "        print(\"you've requested a gas that isn't in the Vischer table. Please chaeck and try again.\")\n",
    "        exit\n",
    "    \n",
    "    for i in range(0,nmet):\n",
    "        for j in range(0,nco):\n",
    "            for k in range(0,ngas+3):\n",
    "                for l in range(0,nabtemp):\n",
    "                    pfit = InterpolatedUnivariateSpline(Pgrid,np.log10(gases[i,j,l,:,k]),k=1)\n",
    "                    gases_myP[i,j,l,:,k] = pfit(np.log10(press))\n",
    "    \n",
    "\n",
    "\n",
    "ceTgrid = Tgrid\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17\n"
     ]
    }
   ],
   "source": [
    "# for proftype = 2 with no clouds, ndim = nprof + ngas-1, + (dlam,beta,logg, r2d2)\n",
    "ndim = 17 #(nprof + (ngas-1) + 9)\n",
    "p0 = np.empty(ndim)\n",
    "print(ndim)\n",
    "theta = p0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "p0[0] = (0.5*np.random.randn()) - 3.5 # H2O\n",
    "p0[1] = (0.5*np.random.randn()) - 4.0 # CO\n",
    "#p0[2] = (0.5*np.random.randn()) - 4.0 # CO2\n",
    "#p0[3] = (0.5*np.random.randn()) - 4.0 # CH4\n",
    "#p0[4] = (0.5*np.random.randn()) - 8.0 # TiO\n",
    "#p0[5] = (0.5*np.random.randn()) - 8.0 # VO\n",
    "#p0[6] = (0.5*np.random.randn()) - 8.0 # CrH\n",
    "#p0[7] = (1.0*np.random.randn()) - 8.0 # FeH\n",
    "#p0[8] = (0.5*np.random.randn()) - 8.0 # H2S\n",
    "#p0[9] = (0.5*np.random.randn()) - 5.5 # Na+K\n",
    "p0[2] = 0.1*np.random.randn() + 4.9  # gravity\n",
    "p0[3] = r2d2 + (np.random.randn() * (0.1*r2d2))  # scale factor\n",
    "p0[4] = np.random.randn() * 0.001  # dlambda\n",
    "p0[5] = np.log10((np.random.rand() * (max(obspec[2,:]**2)*(0.1 - 0.01))) + (0.01*min(obspec[2,10::3]**2)))\n",
    "# patch\n",
    "p0[6] = np.random.rand()\n",
    "# Slab cloud params\n",
    "p0[7] = np.random.rand()\n",
    "p0[8] = np.random.randn()\n",
    "p0[9] = np.random.rand()\n",
    "p0[10] = 0.1*np.random.randn()\n",
    "p0[11] = np.random.rand()\n",
    "# Slab cloud params\n",
    "#p0[12] = np.random.rand()\n",
    "#p0[13] = np.random.randn()\n",
    "#p0[14] = np.random.rand()\n",
    "#p0[15] = np.random.randn()\n",
    "#p0[16] = 0.1*np.random.rand()\n",
    "#\n",
    "# Deck cloud params\n",
    "#p0[17] = np.random.randn()\n",
    "#p0[18] = np.random.rand()\n",
    "#p0[19] = np.random.randn()\n",
    "#p0[20] = np.abs(0.1 + 0.01*np.random.randn())\n",
    "p0[12] = 0.39 + 0.1*np.random.randn()\n",
    "p0[13] = 0.14 +0.05*np.random.randn()\n",
    "p0[14] = -1.2 + 0.2*np.random.randn()\n",
    "p0[15] = 2.25+ 0.2*np.random.randn()\n",
    "p0[16] = 4200. + (500.*  np.random.randn())\n",
    "\n",
    "#while True:\n",
    "#    Tcheck = TPmod.set_prof(proftype, coarsePress, press, p0[ndim-5:])\n",
    "#    if min(Tcheck) > 1.0:\n",
    "#        break\n",
    "#    else:\n",
    "#        p0[ndim-5] = 0.39 + 0.01*np.random.randn()\n",
    "#        p0[ndim-4] = 0.14 + 0.01*np.random.randn()\n",
    "#        p0[ndim-3] = -1.2 + 0.2*np.random.randn()\n",
    "#        p0[ndim-2] = 2. + 0.2*np.random.randn()\n",
    "#        p0[ndim-1] = 4200. + (200.*np.random.randn())\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-3.79582214e+00 -3.52088822e+00  4.75791362e+00  1.50222647e-19\n",
      "  7.90806763e-04 -3.25301000e+01  8.74101361e-02  8.57659143e-01\n",
      "  8.31325451e-01  6.03416682e-01 -3.60590744e-01  4.45131318e-01\n",
      "  4.26940890e-01  1.86882973e-01 -1.32010167e+00  2.36017001e+00\n",
      "  3.97249631e+03]\n"
     ]
    }
   ],
   "source": [
    "print(theta) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "prof = theta[ndim-5:]\n",
    "if (proftype == 9):\n",
    "    modP,modT = np.loadtxt(pfile,skiprows=1,usecols=(1,2),unpack=True)\n",
    "    tfit = InterpolatedUnivariateSpline(np.log10(modP),modT,k=1)\n",
    "    prof = tfit(logcoarsePress)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "settings.init()\n",
    "settings.runargs = gases_myP,chemeq,dist, cloudtype,do_clouds,gasnum,cloudnum,inlinetemps,coarsePress,press,inwavenum,linelist,cia,ciatemps,use_disort,fwhm,obspec,proftype,do_fudge, prof,do_bff,bff_raw,ceTgrid,metscale,coscale\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1]\n",
      "[1 2]\n",
      "[[5]\n",
      " [5]]\n",
      "[[1]\n",
      " [1]]\n",
      "1.0050568006199632 22.39076173838315\n"
     ]
    }
   ],
   "source": [
    "print(do_clouds)\n",
    "print(gasnum)\n",
    "print(cloudnum)\n",
    "print(cloudtype)\n",
    "#print theta[15]\n",
    "#print theta[16]\n",
    "r2d2= theta[3]\n",
    "logg = theta[2]\n",
    "D = 3.086e+16 * dist\n",
    "R = np.sqrt(r2d2) * D\n",
    "g = (10.**logg)/100.\n",
    "M = (R**2 * g/(6.67E-11))/1.898E27\n",
    "print(R/70000e3, M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'T/K')"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1920x1280 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rc('font',family='Times New Roman')\n",
    "fig=plt.figure(dpi=320)\n",
    "plt.axis([-500., 6000.,3.0,-5.0])\n",
    "#plt.plot(prof,logcoarsePress,'k-')\n",
    "plt.plot(modT,np.log10(modP),'g-')\n",
    "logP = np.log10(press)\n",
    "plotT = TPmod.set_prof(proftype,coarsePress,press,prof)\n",
    "plt.plot(plotT,logP, \"r-\")\n",
    "\n",
    "plt.ylabel(r'log(P)')\n",
    "plt.xlabel('T/K')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rj =  1.0063362853255915\n",
      "M =  22.39076173838315\n",
      "[M/H] =  0.0\n",
      "[C/O] =  1.0\n",
      "logg =  4.757913617535738\n",
      "R2D2 =  1.5022264668593613e-19\n",
      "scale1 =  1.0\n",
      "scale2 =  1.0\n",
      "Rj =  1.0063362853255915\n",
      "dlam =  0.0007908067630957387\n",
      "logf =  -32.53009998493603\n",
      "logf1 =  -32.03178537666361\n",
      "logf2 =  -32.03178537666361\n",
      "logf3 =  -32.03178537666361\n",
      "2.9023761981744357e-37\n",
      "9.294255847363244e-30\n",
      "VMRs =  [-3.79582214 -3.52088822]\n",
      "ng =  2\n",
      "sum VMRs =  0.0004613994833024365\n",
      "cloud_top =  [[-4.        ]\n",
      " [ 0.83132545]]\n",
      "cloud_bot =  [[2.3       ]\n",
      " [1.43474213]]\n",
      "cloud_height =  [[0.1       ]\n",
      " [0.60341668]]\n",
      "loga =  [[ 0.        ]\n",
      " [-0.36059074]]\n",
      "b =  [[0.5       ]\n",
      " [0.44513132]]\n",
      "cloud_tau0 =  [[1.        ]\n",
      " [0.85765914]]\n",
      "w0 =  [[0.5]\n",
      " [0.5]]\n",
      "taupow =  [[0.]\n",
      " [0.]]\n",
      "pcover =  [0.08741014 0.91258986]\n",
      "sum(pcover) =  1.0\n",
      "metscale =  [-1.   -0.75 -0.7  -0.5  -0.3  -0.25  0.    0.5   0.7   1.    1.5   1.7\n",
      "  2.  ]\n",
      "coscale =  [0.25 0.5  1.   1.5  2.   2.5 ]\n",
      "press[press.size-1]  =  199.52623149689074\n",
      "press[0] =  0.0001\n",
      "-51891996.889177926\n"
     ]
    }
   ],
   "source": [
    "LP = testkit.lnprob(theta) #* -2. / (obspec.shape[1] /3.)\n",
    "#print testkit.lnprob(theta2,*runargs) * -2. / (obspec.shape[1] /3.)\n",
    "print(LP)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[ 0.          0.          0.          0.          0.          0.          0.\n",
    "  0.          0.          0.          0.          0.          0.          0.\n",
    "  0.          0.          0.          0.          0.          0.\n",
    "  0.44268837  0.55731163  0.          0.          0.          0.          0.\n",
    "  0.          0.          0.          0.          0.          0.          0.\n",
    "  0.          0.          0.          0.          0.          0.          0.\n",
    "  0.          0.          0.          0.          0.          0.          0.\n",
    "  0.          0.          0.          0.          0.          0.          0.\n",
    "  0.          0.          0.          0.          0.          0.          0.\n",
    "  0.          0.        ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pickle.compatible_formats\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#for gas in range (0,ngas):\n",
    "##    test= pickle.load( open(lists[gas], \"rb\" ) )[3]\n",
    "#    test[np.isnan(test)] = 1.0\n",
    "#    print test[np.where(np.less(test,0))]\n",
    "print forwardmodel.marv.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rc('font',family='Times New Roman')\n",
    "fig=plt.figure(dpi=320)\n",
    "plt.axis([-8., 2.,3.0,-5.0])\n",
    "logP = np.log10(press)\n",
    "plt.plot(np.log10(cloudprof[0,:,0]),logP, \"r-\")\n",
    "\n",
    "plt.ylabel(r'log(P)')\n",
    "plt.xlabel('log10(dtau)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import forwardmodel\n",
    "print forwardmodel.marv.__doc__"
   ]
  },
  {
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}