Bicone_emcee.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is code from ~2016-2018.\n",
    "# It is used to carry out an MCMC (emcee) in order to estimate the parameters of a biconical outflow.\n",
    "# The input is the velocity and velocity error of the two components of a double-peaked profile.\n",
    "# The output is the position of the walkers at various points in time.\n",
    "# The parameters of the bicone are phi, the inclination, theta, the PA on the sky, r_t, the turnover radius\n",
    "# for the velocity law, the half opening angle and the maximum velocity.\n",
    "# I've rewritten it to more generally apply to any grid you place over it.\n",
    "# ~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "                                                                                                                                                                                     \n",
    "import matplotlib as plt\n",
    "from pylab import *\n",
    "import numpy as np\n",
    "from decimal import *\n",
    "import numpy\n",
    "from scipy.optimize import curve_fit\n",
    "from scipy.integrate import quad\n",
    "import matplotlib.pyplot as plt\n",
    "#from astropy.modeling import models, fitting                                                                                                                                                      \n",
    "from pylab import *\n",
    "import math\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from shapely.geometry import Point\n",
    "from shapely.geometry.polygon import Polygon\n",
    "import matplotlib.gridspec as grid_spec\n",
    "from sklearn.neighbors import KernelDensity\n",
    "\n",
    "\n",
    "def order_points(pts):\n",
    "        # initialize a list of coordinates that will be ordered                                                                                                                                            \n",
    "        # such that the first entry in the list is the top-left,                                                                                                                                           \n",
    "        # the second entry is the top-right, the third is the                                                                                                                                              \n",
    "        # bottom-right, and the fourth is the bottom-left                                                                                                                                                  \n",
    "        rect = np.zeros((4, 2), dtype=\"float32\")\n",
    "        # the top-left point will have the smallest sum, whereas                                                                                                                                           \n",
    "        # the bottom-right point will have the largest sum                                                                                                                                                 \n",
    "        s = pts.sum(axis=1)\n",
    "        rect[0] = pts[np.argmin(s)]\n",
    "        rect[2] = pts[np.argmax(s)]\n",
    "        # now, compute the difference between the points, the                                                                                                                                              \n",
    "        # top-right point will have the smallest difference,                                                                                                                                               \n",
    "        # whereas the bottom-left will have the largest difference                                                                                                                                         \n",
    "        diff = np.diff(pts, axis=1)\n",
    "        rect[1] = pts[np.argmin(diff)]\n",
    "        rect[3] = pts[np.argmax(diff)]\n",
    "        # return the ordered coordinates                                                                                                                                                                   \n",
    "        return rect\n",
    "\n",
    "#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~TIME TO DO THE BICONE                                                                                                                                            \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# These fxns construct the various bicones based on the input parameters\n",
    "# The output is the 3-dimensional construction of x, y, and z coordinates and the LOS velocity\n",
    "# at that point.\n",
    "\n",
    "# There are three different 'construction' fxns, one for the bicone,\n",
    "# one for the cocone, and one for the nesting cone, all of which\n",
    "# have different geometries, see Nevin et al. 2018 for more\n",
    "# details about how I build these.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# This code constructs a three dimensional bicone that will be fed into lnlike_bicone \n",
    "# where it will be projected down to 2D\n",
    "def bicone_construction_plot(bounds, phi,theta,r_t, half_angle, vel_max, verbose, xs_proj, ys_proj,name):\n",
    "    #print('these are the input parameters',phi,theta,r_t, half_angle, vel_max)\n",
    "    # the five input parameters determine the geometry of the bicone,\n",
    "    # phi is the inclination, theta, is the position angle on the sky in 2D,\n",
    "    # r_t is the turnover radius, or point at which the material moving along\n",
    "    # the walls begins to decelerate,\n",
    "    # half_angle, is the half opening angle,\n",
    "    # and vel_max is the maximum intrinsic (meaning 3D) velocity along the walls\n",
    "    # of the cone.\n",
    "    \n",
    "    # The model only moves material along the walls of the cone, so it could\n",
    "    # be called an 'evacuated bicone'\n",
    "    \n",
    "    half_angle_r=math.radians(half_angle)\n",
    "    phi_1=math.radians(phi)\n",
    "    theta_1=math.radians(theta)\n",
    "    psi_1=math.radians(0)\n",
    "\n",
    "    # the total heigh is twice the effective radius because\n",
    "    # the velocity decays linearly from vmax to zero\n",
    "    h=2*r_t\n",
    "    # to get the radius of the cone, you need to do some trig\n",
    "    # this is the radius across the opening\n",
    "    r=math.tan(half_angle_r)*h\n",
    "    \n",
    "    # this is your sampling around the cone, here I'm taking 50 points\n",
    "    theta_para=(np.asarray(np.linspace(0,2*np.pi,75)))\n",
    "    \n",
    "    # This is the sampling along the heigh of the cone\n",
    "    u1_orig=np.asarray(np.linspace(-h,0,60))+h#\n",
    "    u2_orig=-np.asarray(np.linspace(-h,0,60))-h\n",
    "    u=-np.asarray(np.linspace(-h,0,60))\n",
    "\n",
    "    \n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "    #R is the rotation matrix\n",
    "    R=np.matrix([[np.cos(theta_1)*np.cos(psi_1),np.cos(phi_1)*np.sin(psi_1)+np.sin(phi_1)*np.sin(theta_1)*np.cos(psi_1),\n",
    "                  np.sin(phi_1)*np.sin(psi_1)-np.cos(phi_1)*np.sin(theta_1)*np.cos(psi_1)],\n",
    "                     [-np.cos(theta_1)*np.sin(psi_1),\n",
    "                      np.cos(phi_1)*np.cos(psi_1)-np.sin(phi_1)*np.sin(theta_1)*np.sin(psi_1),\n",
    "                      np.sin(phi_1)*np.cos(psi_1)+np.cos(phi_1)*np.sin(theta_1)*np.sin(psi_1)],\n",
    "                     [np.sin(theta_1), -np.sin(phi_1)*np.cos(theta_1), np.cos(phi_1)*np.cos(theta_1)]])\n",
    "    #x is going to be the front facing side (blueshifted) and x_2 is the rear cone\n",
    "    x=[]\n",
    "    x_2=[]\n",
    "    y=[]\n",
    "    y_2=[]\n",
    "    z=[]\n",
    "    z_2=[]\n",
    "    \n",
    "    vel_radial_bottom=[]\n",
    "    vel_radial_top=[]\n",
    "    \n",
    "    x_totes=[]\n",
    "    y_totes=[]\n",
    "    z_totes=[]\n",
    "    x_plane=[]\n",
    "    y_plane=[]\n",
    "    z_plane=[]\n",
    "    x_plane_2=[]\n",
    "    y_plane_2=[]\n",
    "    z_plane_2=[]\n",
    "    \n",
    "    if verbose=='yes':\n",
    "        from mpl_toolkits import mplot3d\n",
    "\n",
    "        plt.clf()\n",
    "        fig = plt.figure()\n",
    "        ax = plt.axes(projection='3d')\n",
    "        ax.scatter3D(0,0,0,marker='*', color='orange')\n",
    "    \n",
    "    for i in range(len(theta_para)):\n",
    "        for j in range(len(u)):\n",
    "            if i==0:\n",
    "                i=1\n",
    "            if j==0:\n",
    "                j=1\n",
    "\n",
    "            #here's the parametric equation for a bicone\n",
    "            X=((h-u[j])*r*np.cos((theta_para[i])))/h\n",
    "            Y=((h-u[j])*r*np.sin((theta_para[i])))/h\n",
    "\n",
    "          \n",
    "\n",
    "            #blue cone above is Z_1\n",
    "            #red cone below is Z_2\n",
    "            Z_1=u2_orig[j]#was u2\n",
    "            Z_2=u1_orig[j]#was u1\n",
    "            \n",
    "            \n",
    "            \n",
    "            y_plane_into=0\n",
    "\n",
    "            pos=np.matrix([X,Y,Z_1])\n",
    "            pos_2=np.matrix([X,Y,Z_2])\n",
    "            \n",
    "            # so the 'plane' positions are all at y=0, because they are projected\n",
    "            # onto the plane of the sky\n",
    "            pos_plane=np.matrix([X,y_plane_into,Z_1])\n",
    "            pos_plane_2=np.matrix([X,y_plane_into, Z_2])\n",
    "            \n",
    "            # take the dot product of the rotation matrix and the current position\n",
    "            # in order to move to the location on the cone\n",
    "            new_pos=np.dot(R,pos.transpose())\n",
    "            new_pos_2=np.dot(R,pos_2.transpose())\n",
    "            new_pos_plane=np.dot(R,pos_plane.transpose())\n",
    "            x_plane.append(new_pos_plane[0])\n",
    "            \n",
    "            y_plane.append(new_pos_plane[1])\n",
    "            z_plane.append(new_pos_plane[2])\n",
    "            new_pos_plane_2=np.dot(R, pos_plane_2.transpose())\n",
    "            x_plane_2.append(new_pos_plane_2[0])\n",
    "            y_plane_2.append(new_pos_plane_2[1])\n",
    "            z_plane_2.append(new_pos_plane_2[2])\n",
    "            \n",
    "            \n",
    "            #Z_2=u1[j]\n",
    "            x.append(new_pos[0])\n",
    "            x_2.append(new_pos_2[0])\n",
    "            y.append(new_pos[1])\n",
    "            y_2.append(new_pos_2[1])\n",
    "            \n",
    "            z.append(new_pos[2])\n",
    "            z_2.append(new_pos_2[2])\n",
    "            \n",
    "            \n",
    "            if np.sqrt(np.array(new_pos[0]).ravel()**2+np.array(new_pos[1]).ravel()**2+np.array(new_pos[2]).ravel()**2)<r_t:\n",
    "                # so if the point is at a distance less than the turnover radius, then the velocity is the max velocity\n",
    "                vel_max_top=-vel_max\n",
    "            if np.sqrt(np.array(new_pos[0]).ravel()**2+np.array(new_pos[1]).ravel()**2+np.array(new_pos[2]).ravel()**2)>r_t:\n",
    "                # if the point is greater than the turnover radius, then it will decline linearly to zero at 2*r_t\n",
    "                vel_max_top=-(vel_max-(vel_max/r_t)*(np.sqrt(np.array(new_pos[0]).ravel()**2+np.array(new_pos[1]).ravel()**2+np.array(new_pos[2]).ravel()**2)-r_t))\n",
    "                \n",
    "            if np.sqrt(np.array(new_pos[0]).ravel()**2+np.array(new_pos[1]).ravel()**2+np.array(new_pos[2]).ravel()**2)>2*r_t:\n",
    "                # if the point is farther than 2*r_t, then it is already at zero\n",
    "                vel_max_top=0\n",
    "            #do that thing:\n",
    "            #equation: d/dw/e((x^2 + y^2)/c^2 = (z-z_0)^2)\n",
    "            #recall c=r/h\n",
    "            #<2*x,2*y,-(2*r^2*z)/h^2>\n",
    "            #plug in everything and normalize and then the z component is your v_rad\n",
    "    \n",
    "            # Time to project this velocity into a line of sight velocity\n",
    "            slope_x=np.array(new_pos[0]).ravel()#eliminated 2*\n",
    "            slope_y=np.array(new_pos[1]).ravel()# eliminated 2*\n",
    "            slope_z=np.array(new_pos[2]).ravel()#-(2*r**2*np.array(new_pos[2]).ravel())/h**2\n",
    "            \n",
    "            norm=np.sqrt(slope_x**2+slope_y**2+slope_z**2)\n",
    "            A_comp=-(slope_y/norm)\n",
    "            if verbose=='yes':\n",
    "                ax.plot3D([slope_x,0],[slope_y,0],[slope_z,0])\n",
    "            \n",
    "            \n",
    "            # multiply the intrinsic velocity by the component of A that is in the y direction\n",
    "            # y, which is the line of sight direction\n",
    "            # currently, the velocity is projected along the wall of the bicone\n",
    "            rad_proj=vel_max_top*np.array(A_comp).ravel()\n",
    "            \n",
    "            \n",
    "            #print('position', new_pos)\n",
    "            #print('total length to x,y,z = 0', norm, 'y cont', slope_y)\n",
    "            #print('velocity at this point', vel_max_top)\n",
    "            #print('component', *np.array(A_comp).ravel())\n",
    "            #print('projected vel', rad_proj)\n",
    "            \n",
    "            vel_radial_top.append(round(rad_proj[0]))\n",
    "            \n",
    "            slope_x=2*np.array(new_pos_2[0]).ravel()\n",
    "            slope_y=2*np.array(new_pos_2[1]).ravel()\n",
    "            \n",
    "            slope_z_2=-(2*r**2*np.array(new_pos_2[2]).ravel())/h**2\n",
    "            norm=np.sqrt(slope_x**2+slope_y**2+slope_z_2**2)\n",
    "            \n",
    "            if np.sqrt(np.array(new_pos_2[0]).ravel()**2+np.array(new_pos_2[1]).ravel()**2+np.array(new_pos_2[2]).ravel()**2)<r_t:\n",
    "                \n",
    "            \n",
    "#                vel_max_bottom=-(vel_max/r_t)*np.sqrt(new_pos_2[0]**2+new_pos_2[1]**2+new_pos_2[2]**2)\n",
    "                vel_max_bottom=-vel_max\n",
    "            if np.sqrt(np.array(new_pos_2[0]).ravel()**2+np.array(new_pos_2[1]).ravel()**2+np.array(new_pos_2[2]).ravel()**2)>r_t:\n",
    "                #vel_max_bottom=vel_max-(vel_max/r_t)*np.sqrt(new_pos_2[0]**2+new_pos_2[1]**2+new_pos_2[2]**2)\n",
    "                vel_max_bottom=-(vel_max-(vel_max/r_t)*(np.sqrt(np.array(new_pos[0]).ravel()**2+np.array(new_pos[1]).ravel()**2+np.array(new_pos[2]).ravel()**2)-r_t))\n",
    "                #if new_pos_2[2]>0:\n",
    "                #    vel_max_bottom=-vel_max_bottom\n",
    "                #if vel_max_bottom>0:\n",
    "                #    vel_max_bottom=0\n",
    "            if np.sqrt(np.array(new_pos_2[0]).ravel()**2+np.array(new_pos_2[1]).ravel()**2+np.array(new_pos_2[2]).ravel()**2)>2*r_t:\n",
    "                #vel_max_bottom=vel_max-(vel_max/r_t)*np.sqrt(new_pos_2[0]**2+new_pos_2[1]**2+new_pos_2[2]**2)\n",
    "                vel_max_bottom=0\n",
    "            #if abs(vel_max_bottom)>1001:\n",
    "            #    vel_max_bottom=0\n",
    "            #A dot x should give us the vector projection along x - divide by the magnitude of A to get cos (theta)\n",
    "            A_comp=-(slope_y/norm)\n",
    "            \n",
    "            \n",
    "            \n",
    "            rad_proj_2=np.array(A_comp).ravel()*vel_max_bottom\n",
    "            vel_radial_bottom.append(round(rad_proj_2[0]))\n",
    "    if verbose=='yes':\n",
    "        # planes at x=0, y=0, and z=0 to guide the eye\n",
    "        xx, zz = np.meshgrid(range(-20,20), range(-20,20))\n",
    "        im = ax.scatter3D(x, y, z, c=vel_radial_top, cmap='Blues_r')\n",
    "        im2 = ax.scatter3D(x_2,y_2,z_2,c=vel_radial_bottom, cmap='Reds')\n",
    "        # calculate corresponding z\n",
    "        yy = [0 for x in xx]\n",
    "        ax.plot_surface(xx, yy, zz, alpha=0.2)\n",
    "        #ax.set_ylim([-20,0])\n",
    "        ax.set_xlabel('X')\n",
    "        ax.set_ylabel('Y')\n",
    "        ax.set_zlabel('Z')\n",
    "        ax.view_init(azim=0)\n",
    "        plt.colorbar(im)\n",
    "        plt.colorbar(im2)\n",
    "        plt.savefig('3D_diag_'+str(name)+'.png')\n",
    "    \n",
    "    \n",
    "    # So the first half of all these merged arrays is the blueshifted side of the cone (above the plane of the sky)\n",
    "    # and x_2, etc are the redshifted, or 'bottom' side of the cone.\n",
    "    merged_x=x+x_2\n",
    "    merged_y=y+y_2\n",
    "    merged_z=z+z_2\n",
    "    \n",
    "    merged_x_plane=x_plane+x_plane_2\n",
    "    merged_y_plane=y_plane+y_plane_2\n",
    "    merged_z_plane=z_plane+z_plane_2\n",
    "    \n",
    "    \n",
    "    \n",
    "    merged_vel=vel_radial_top+vel_radial_bottom\n",
    "    \n",
    "    if verbose=='yes':\n",
    "        '''plt.clf()\n",
    "        fig = plt.figure()\n",
    "        ax = plt.axes(projection='3d')\n",
    "        im = ax.scatter3D(merged_x_plane, merged_y_plane, merged_z_plane, c=merged_vel, cmap='RdBu_r')\n",
    "        plt.colorbar(im)\n",
    "        ax.set_xlabel('X')\n",
    "        ax.set_ylabel('Y')\n",
    "        ax.set_zlabel('Z')\n",
    "        ax.plot_surface(xx, yy, zz, alpha=0.2)\n",
    "        ax.view_init(azim=10)\n",
    "\n",
    "        plt.savefig('3D_merged_plane_'+str(name)+'.png')\n",
    "\n",
    "        plt.clf()\n",
    "        fig = plt.figure()\n",
    "        ax = plt.axes(projection='3d')\n",
    "        im = ax.scatter3D(merged_x, merged_y, merged_z, c=merged_vel, cmap='RdBu_r')\n",
    "        plt.colorbar(im)\n",
    "        ax.set_xlabel('X')\n",
    "        ax.set_ylabel('Y')\n",
    "        ax.set_zlabel('Z')\n",
    "        ax.plot_surface(xx, yy, zz, alpha=0.2)\n",
    "        ax.view_init(azim=10)\n",
    "        plt.savefig('3D_merged_'+str(name)+'.png')\n",
    "        \n",
    "        sns.set_style(\"dark\")\n",
    "        plt.clf()\n",
    "        fig = plt.figure()\n",
    "        ax = fig.add_subplot(111)\n",
    "        new_merged_x = []\n",
    "        new_merged_z = []\n",
    "        for j in range(np.shape(merged_x)[0]):\n",
    "            new_merged_x.append(np.array(merged_x)[j][0][0])\n",
    "            new_merged_z.append(np.array(merged_z)[j][0][0])\n",
    "            \n",
    "        im = ax.scatter(new_merged_x, new_merged_z, c=merged_vel, cmap=get_SauronCmap(), alpha = 0.5, s=1)\n",
    "        for n in range(np.shape(xs_proj)[0]):\n",
    "            ax.scatter(xs_proj[n], ys_proj[n], color='white',edgecolor = 'black', s=1)\n",
    "        ax.set_aspect('equal')\n",
    "        plt.colorbar(im, label='Line of sight velocity')\n",
    "        ax.set_ylabel('Position in Arcsec')\n",
    "        ax.set_aspect(aspect=1)\n",
    "        plt.savefig('overplot_data_model_'+str(name)+'.png', dpi=1000)'''\n",
    "        \n",
    "        # Fuck, I need to figure out how to split\n",
    "        # the cone by the y plane, which needs to be inclined and\n",
    "        # rotated\n",
    "        \n",
    "        \n",
    "        sns.set_context(\"talk\")\n",
    "        sns.set_style(\"white\")\n",
    "        plt.clf()\n",
    "        fig = plt.figure(figsize = (20,15))\n",
    "        ax = fig.add_subplot(121)\n",
    "        new_merged_x = []\n",
    "        new_merged_z = []\n",
    "        vel_radial = []\n",
    "        for j in range(np.shape(merged_x)[0]):\n",
    "            if np.array(merged_y)[j][0][0] < 0:\n",
    "                new_merged_x.append(np.array(merged_x)[j][0][0])\n",
    "                new_merged_z.append(np.array(merged_z)[j][0][0])\n",
    "                vel_radial.append(merged_vel[j])\n",
    "         \n",
    "        \n",
    "        # Create grid values first.\n",
    "        import matplotlib.tri as tri\n",
    "        ngridx = 200\n",
    "        ngridy = 200\n",
    "        xi = np.linspace(min(new_merged_x), max(new_merged_x), ngridx)\n",
    "        yi = np.linspace(min(new_merged_z), max(new_merged_z), ngridy)\n",
    "\n",
    "        # Perform linear interpolation of the data (x,y)\n",
    "        # on a grid defined by (xi,yi)\n",
    "        triang = tri.Triangulation(new_merged_x, new_merged_z)\n",
    "        interpolator = tri.LinearTriInterpolator(triang, vel_radial)\n",
    "        Xi, Yi = np.meshgrid(xi, yi)\n",
    "        zi = interpolator(Xi, Yi)\n",
    "\n",
    "        # Note that scipy.interpolate provides means to interpolate data on a grid\n",
    "        # as well. The following would be an alternative to the four lines above:\n",
    "        #from scipy.interpolate import griddata\n",
    "        #zi = griddata((x, y), z, (xi[None,:], yi[:,None]), method='linear')\n",
    "\n",
    "\n",
    "        #ax.contour(xi, yi, zi, levels=14, linewidths=0.5, colors='k')\n",
    "        levels = np.linspace(np.min(zi), np.max(zi), 100)#[-250, -200, -150, -100,-50, -25]\n",
    "        cntr1 = ax.contourf(xi, yi, zi, levels=levels, cmap=\"Blues_r\", alpha=0.5)\n",
    "        \n",
    "        im = ax.scatter(new_merged_x, new_merged_z, \n",
    "                        c=vel_radial, cmap='Blues_r', s=2)\n",
    "        \n",
    "        for n in range(np.shape(xs_proj)[0]):\n",
    "            #ax.scatter(xs_proj[n], ys_proj[n], color='white',edgecolor = 'black', s=1)\n",
    "            \n",
    "            for t in range(len(xs_proj[n])):\n",
    "                #bound of pt 1 (1, 58, 4, 2)\n",
    "                if t==0 or t==int(len(xs_proj[n])/2) or xs_proj[n][t]==0:\n",
    "                    ax.annotate(str(round(np.sqrt(xs_proj[n][t]**2+ys_proj[n][t]**2),2))+'$^{\\prime\\prime}$', \n",
    "                        xy = (xs_proj[n][t]+0.5, ys_proj[n][t]+0.2),xycoords='data')\n",
    "                poly = list(bounds[n][t])\n",
    "                poly.append(poly[0]) #repeat the first point to create a 'closed loop'\n",
    "\n",
    "                xs, ys = zip(*poly) #create lists of x and y values\n",
    "                ax.plot(xs, ys, color='black')\n",
    "        ax.set_aspect('equal')\n",
    "        plt.colorbar(im, fraction = 0.046)#, label='Line of sight velocity')\n",
    "        ax.set_ylabel('Position in Arcsec')\n",
    "        ax.set_xlabel('Position in ARcsec')\n",
    "        ax.set_aspect(aspect=1)\n",
    "        ax.set_title('Approaching', size=30)\n",
    "        \n",
    "        \n",
    "        \n",
    "        ax2 = fig.add_subplot(122)\n",
    "        new_merged_x = []\n",
    "        new_merged_z = []\n",
    "        vel_radial = []\n",
    "        for j in range(np.shape(merged_x)[0]):\n",
    "            if np.array(merged_y)[j][0][0] > 0:\n",
    "                new_merged_x.append(np.array(merged_x)[j][0][0])\n",
    "                new_merged_z.append(np.array(merged_z)[j][0][0])\n",
    "                vel_radial.append(merged_vel[j])\n",
    "            \n",
    "        \n",
    "        # Create grid values first.\n",
    "        import matplotlib.tri as tri\n",
    "        ngridx = 200\n",
    "        ngridy = 200\n",
    "        xi = np.linspace(min(new_merged_x), max(new_merged_x), ngridx)\n",
    "        yi = np.linspace(min(new_merged_z), max(new_merged_z), ngridy)\n",
    "\n",
    "        # Perform linear interpolation of the data (x,y)\n",
    "        # on a grid defined by (xi,yi)\n",
    "        triang = tri.Triangulation(new_merged_x, new_merged_z)\n",
    "        interpolator = tri.LinearTriInterpolator(triang, vel_radial)\n",
    "        Xi, Yi = np.meshgrid(xi, yi)\n",
    "        zi = interpolator(Xi, Yi)\n",
    "\n",
    "        # Note that scipy.interpolate provides means to interpolate data on a grid\n",
    "        # as well. The following would be an alternative to the four lines above:\n",
    "        #from scipy.interpolate import griddata\n",
    "        #zi = griddata((x, y), z, (xi[None,:], yi[:,None]), method='linear')\n",
    "\n",
    "\n",
    "        levels = np.linspace(np.min(zi), np.max(zi),  100)\n",
    "        cntr2 = ax2.contourf(xi, yi, zi, levels=levels, cmap=\"Reds\", alpha=0.5)\n",
    "        \n",
    "        \n",
    "        \n",
    "        for n in range(np.shape(xs_proj)[0]):\n",
    "            #ax2.scatter(xs_proj[n], ys_proj[n], color='white',edgecolor = 'black', s=1)\n",
    "            for t in range(len(xs_proj[n])):\n",
    "                #bound of pt 1 (1, 58, 4, 2)\n",
    "                \n",
    "                poly = list(bounds[n][t])\n",
    "                poly.append(poly[0]) #repeat the first point to create a 'closed loop'\n",
    "\n",
    "                xs, ys = zip(*poly) #create lists of x and y values\n",
    "                ax2.plot(xs, ys, color='black')\n",
    "        im2 = ax2.scatter(new_merged_x, new_merged_z, c=vel_radial, cmap='Reds', s=4)\n",
    "        \n",
    "        ax2.set_aspect('equal')\n",
    "        plt.colorbar(im2, label='Line of sight velocity', fraction = 0.046)\n",
    "        ax2.set_aspect(aspect=1)\n",
    "        ax2.set_title('Receding', size=30)\n",
    "        \n",
    "        plt.savefig('overplot_data_model_two_'+str(name)+'.png', dpi=500)\n",
    "    \n",
    "    \n",
    "    return merged_x, merged_y, merged_z, merged_vel, merged_x_plane, merged_y_plane, merged_z_plane\n",
    "\n",
    "# This is the lean version for the emcee\n",
    "def bicone_construction(phi,theta,r_t, half_angle, vel_max):\n",
    "    \n",
    "    \n",
    "    half_angle_r=math.radians(half_angle)\n",
    "    phi_1=math.radians(phi)\n",
    "    theta_1=math.radians(theta)\n",
    "    psi_1=math.radians(0)\n",
    "\n",
    "    # the total heigh is twice the effective radius because\n",
    "    # the velocity decays linearly from vmax to zero\n",
    "    h=2*r_t\n",
    "    # to get the radius of the cone, you need to do some trig\n",
    "    # this is the radius across the opening\n",
    "    r=math.tan(half_angle_r)*h\n",
    "    \n",
    "    # this is your sampling around the cone, here I'm taking 50 points\n",
    "    theta_para=(np.asarray(np.linspace(0,2*np.pi,50)))\n",
    "    \n",
    "    # This is the sampling along the heigh of the cone\n",
    "    u1_orig=np.asarray(np.linspace(-h,0,30))+h#\n",
    "    u2_orig=-np.asarray(np.linspace(-h,0,30))-h\n",
    "    u=-np.asarray(np.linspace(-h,0,30))\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "    #R is the rotation matrix\n",
    "    R=np.matrix([[np.cos(theta_1)*np.cos(psi_1),np.cos(phi_1)*np.sin(psi_1)+np.sin(phi_1)*np.sin(theta_1)*np.cos(psi_1),\n",
    "                  np.sin(phi_1)*np.sin(psi_1)-np.cos(phi_1)*np.sin(theta_1)*np.cos(psi_1)],\n",
    "                     [-np.cos(theta_1)*np.sin(psi_1),\n",
    "                      np.cos(phi_1)*np.cos(psi_1)-np.sin(phi_1)*np.sin(theta_1)*np.sin(psi_1),\n",
    "                      np.sin(phi_1)*np.cos(psi_1)+np.cos(phi_1)*np.sin(theta_1)*np.sin(psi_1)],\n",
    "                     [np.sin(theta_1), -np.sin(phi_1)*np.cos(theta_1), np.cos(phi_1)*np.cos(theta_1)]])\n",
    "    #x is going to be the front facing side (blueshifted) and x_2 is the rear cone\n",
    "    x=[]\n",
    "    x_2=[]\n",
    "    y=[]\n",
    "    y_2=[]\n",
    "    z=[]\n",
    "    z_2=[]\n",
    "    \n",
    "    vel_radial_bottom=[]\n",
    "    vel_radial_top=[]\n",
    "    \n",
    "    x_totes=[]\n",
    "    y_totes=[]\n",
    "    z_totes=[]\n",
    "    x_plane=[]\n",
    "    y_plane=[]\n",
    "    z_plane=[]\n",
    "    x_plane_2=[]\n",
    "    y_plane_2=[]\n",
    "    z_plane_2=[]\n",
    "    \n",
    "    \n",
    "    \n",
    "    for i in range(len(theta_para)):\n",
    "        for j in range(len(u)):\n",
    "            if i==0:\n",
    "                i=1\n",
    "            if j==0:\n",
    "                j=1\n",
    "\n",
    "            #here's the parametric equation for a bicone\n",
    "            X=((h-u[j])*r*np.cos((theta_para[i])))/h\n",
    "            Y=((h-u[j])*r*np.sin((theta_para[i])))/h\n",
    "\n",
    "          \n",
    "\n",
    "            #blue cone above is Z_1\n",
    "            #red cone below is Z_2\n",
    "            Z_1=u2_orig[j]#was u2\n",
    "            Z_2=u1_orig[j]#was u1\n",
    "            \n",
    "            \n",
    "            \n",
    "            y_plane_into=0\n",
    "\n",
    "            pos=np.matrix([X,Y,Z_1])\n",
    "            pos_2=np.matrix([X,Y,Z_2])\n",
    "            \n",
    "            # so the 'plane' positions are all at y=0, because they are projected\n",
    "            # onto the plane of the sky\n",
    "            pos_plane=np.matrix([X,y_plane_into,Z_1])\n",
    "            pos_plane_2=np.matrix([X,y_plane_into, Z_2])\n",
    "            \n",
    "            # take the dot product of the rotation matrix and the current position\n",
    "            # in order to move to the location on the cone\n",
    "            new_pos=np.dot(R,pos.transpose())\n",
    "            new_pos_2=np.dot(R,pos_2.transpose())\n",
    "            new_pos_plane=np.dot(R,pos_plane.transpose())\n",
    "            x_plane.append(new_pos_plane[0])\n",
    "            \n",
    "            y_plane.append(new_pos_plane[1])\n",
    "            z_plane.append(new_pos_plane[2])\n",
    "            new_pos_plane_2=np.dot(R, pos_plane_2.transpose())\n",
    "            x_plane_2.append(new_pos_plane_2[0])\n",
    "            y_plane_2.append(new_pos_plane_2[1])\n",
    "            z_plane_2.append(new_pos_plane_2[2])\n",
    "            \n",
    "            \n",
    "            #Z_2=u1[j]\n",
    "            x.append(new_pos[0])\n",
    "            x_2.append(new_pos_2[0])\n",
    "            y.append(new_pos[1])\n",
    "            y_2.append(new_pos_2[1])\n",
    "            \n",
    "            z.append(new_pos[2])\n",
    "            z_2.append(new_pos_2[2])\n",
    "            \n",
    "            \n",
    "            if np.sqrt(np.array(new_pos[0]).ravel()**2+np.array(new_pos[1]).ravel()**2+np.array(new_pos[2]).ravel()**2)<r_t:\n",
    "                # so if the point is at a distance less than the turnover radius, then the velocity is the max velocity\n",
    "                vel_max_top=-vel_max\n",
    "            if np.sqrt(np.array(new_pos[0]).ravel()**2+np.array(new_pos[1]).ravel()**2+np.array(new_pos[2]).ravel()**2)>r_t:\n",
    "                # if the point is greater than the turnover radius, then it will decline linearly to zero at 2*r_t\n",
    "                vel_max_top=-(vel_max-(vel_max/r_t)*(np.sqrt(np.array(new_pos[0]).ravel()**2+np.array(new_pos[1]).ravel()**2+np.array(new_pos[2]).ravel()**2)-r_t))\n",
    "                \n",
    "            if np.sqrt(np.array(new_pos[0]).ravel()**2+np.array(new_pos[1]).ravel()**2+np.array(new_pos[2]).ravel()**2)>2*r_t:\n",
    "                # if the point is farther than 2*r_t, then it is already at zero\n",
    "                vel_max_top=0\n",
    "            #do that thing:\n",
    "            #equation: d/dw/e((x^2 + y^2)/c^2 = (z-z_0)^2)\n",
    "            #recall c=r/h\n",
    "            #<2*x,2*y,-(2*r^2*z)/h^2>\n",
    "            #plug in everything and normalize and then the z component is your v_rad\n",
    "    \n",
    "            # Time to project this velocity into a line of sight velocity\n",
    "            slope_x=np.array(new_pos[0]).ravel()#eliminated 2*\n",
    "            slope_y=np.array(new_pos[1]).ravel()# eliminated 2*\n",
    "            slope_z=np.array(new_pos[2]).ravel()#-(2*r**2*np.array(new_pos[2]).ravel())/h**2\n",
    "            \n",
    "            norm=np.sqrt(slope_x**2+slope_y**2+slope_z**2)\n",
    "            A_comp=-(slope_y/norm)\n",
    "            \n",
    "            # multiply the intrinsic velocity by the component of A that is in the y direction\n",
    "            # y, which is the line of sight direction\n",
    "            # currently, the velocity is projected along the wall of the bicone\n",
    "            rad_proj=vel_max_top*np.array(A_comp).ravel()\n",
    "            \n",
    "            \n",
    "            \n",
    "            vel_radial_top.append(round(rad_proj[0]))\n",
    "            \n",
    "            slope_x=2*np.array(new_pos_2[0]).ravel()\n",
    "            slope_y=2*np.array(new_pos_2[1]).ravel()\n",
    "            \n",
    "            slope_z_2=-(2*r**2*np.array(new_pos_2[2]).ravel())/h**2\n",
    "            norm=np.sqrt(slope_x**2+slope_y**2+slope_z_2**2)\n",
    "            \n",
    "            if np.sqrt(np.array(new_pos_2[0]).ravel()**2+np.array(new_pos_2[1]).ravel()**2+np.array(new_pos_2[2]).ravel()**2)<r_t:\n",
    "                \n",
    "            \n",
    "#                vel_max_bottom=-(vel_max/r_t)*np.sqrt(new_pos_2[0]**2+new_pos_2[1]**2+new_pos_2[2]**2)\n",
    "                vel_max_bottom=-vel_max\n",
    "            if np.sqrt(np.array(new_pos_2[0]).ravel()**2+np.array(new_pos_2[1]).ravel()**2+np.array(new_pos_2[2]).ravel()**2)>r_t:\n",
    "                #vel_max_bottom=vel_max-(vel_max/r_t)*np.sqrt(new_pos_2[0]**2+new_pos_2[1]**2+new_pos_2[2]**2)\n",
    "                vel_max_bottom=-(vel_max-(vel_max/r_t)*(np.sqrt(np.array(new_pos[0]).ravel()**2+np.array(new_pos[1]).ravel()**2+np.array(new_pos[2]).ravel()**2)-r_t))\n",
    "                #if new_pos_2[2]>0:\n",
    "                #    vel_max_bottom=-vel_max_bottom\n",
    "                #if vel_max_bottom>0:\n",
    "                #    vel_max_bottom=0\n",
    "            if np.sqrt(np.array(new_pos_2[0]).ravel()**2+np.array(new_pos_2[1]).ravel()**2+np.array(new_pos_2[2]).ravel()**2)>2*r_t:\n",
    "                #vel_max_bottom=vel_max-(vel_max/r_t)*np.sqrt(new_pos_2[0]**2+new_pos_2[1]**2+new_pos_2[2]**2)\n",
    "                vel_max_bottom=0\n",
    "            #if abs(vel_max_bottom)>1001:\n",
    "            #    vel_max_bottom=0\n",
    "            #A dot x should give us the vector projection along x - divide by the magnitude of A to get cos (theta)\n",
    "            A_comp=-(slope_y/norm)\n",
    "            \n",
    "            \n",
    "            \n",
    "            rad_proj_2=np.array(A_comp).ravel()*vel_max_bottom\n",
    "            vel_radial_bottom.append(round(rad_proj_2[0]))\n",
    "     \n",
    "    # So the first half of all these merged arrays is the blueshifted side of the cone (above the plane of the sky)\n",
    "    # and x_2, etc are the redshifted, or 'bottom' side of the cone.\n",
    "    merged_x=x+x_2\n",
    "    merged_y=y+y_2\n",
    "    merged_z=z+z_2\n",
    "    \n",
    "    merged_x_plane=x_plane+x_plane_2\n",
    "    merged_y_plane=y_plane+y_plane_2\n",
    "    merged_z_plane=z_plane+z_plane_2\n",
    "    \n",
    "    \n",
    "    \n",
    "    merged_vel=vel_radial_top+vel_radial_bottom\n",
    "    \n",
    "     \n",
    "    \n",
    "    return merged_x, merged_y, merged_z, merged_vel, merged_x_plane, merged_y_plane, merged_z_plane\n",
    "                \n",
    "    \n",
    "            \n",
    "# This creates a diagnostic plot by returning the \n",
    "def diagnostic_bicone_plot(z, xs_data_concat, xs_data_concat_ortho):\n",
    "\n",
    "\n",
    "    #bicone_construction(h,phi,theta,r_t, half_angle )\n",
    "    phi_array, theta_array, r_t,half_angle, vel_max_array=z\n",
    "\n",
    "\n",
    "    h=2*r_t\n",
    "    #h=[2*x for x in r_t]\n",
    "\n",
    "    out=bicone_construction(phi_array, theta_array, r_t, half_angle, vel_max_array)\n",
    "\n",
    "    # So this gives you a whole lot of 3D measurements that you do not actually need\n",
    "\n",
    "    merged_x=[float(y) for y in out[0]]\n",
    "    merged_y=[float(y) for y in out[1]]\n",
    "    merged_z=[float(y) for y in out[2]]\n",
    "    merged_vel=[float(y) for y in out[3]]\n",
    "    merged_x_plane=[float(y) for y in out[4]]\n",
    "    merged_y_plane=[float(y) for y in out[5]]\n",
    "    merged_z_plane=[float(y) for y in out[6]]\n",
    "\n",
    "    '''cone_red_x=[float(y) for y in out[7]]\n",
    "    cone_red_y=[float(y) for y in out[8]]\n",
    "    cone_red_z=[float(y) for y in out[9]]\n",
    "    cone_blue_x=[float(y) for y in out[10]]\n",
    "    cone_blue_y=[float(y) for y in out[11]]\n",
    "    cone_blue_z=[float(y) for y in out[12]]\n",
    "    cone_red_vel=[float(y) for y in out[13]]\n",
    "    cone_blue_vel=[float(y) for y in out[14]]'''\n",
    "    ##vel_radial_top actually refers to the stuff going away from us on the bottom -ugh\n",
    "    #it's the projection looking down in z\n",
    "    #p=ax.scatter(x_2,y_2,z_2, c=vel_radial_bottom)\n",
    "\n",
    "\n",
    "    #%```````````````````````````````````\n",
    "    #I'm going to make the phi cuts according to observe PAs\n",
    "    PA_obs_1=np.radians(PA1+90)\n",
    "    PA_obs_2=np.radians(PA2+90)\n",
    "\n",
    "    '''x_slit_blue=np.linspace(-100*h,100*h, len(cone_blue_z))\n",
    "    x_slit_red=np.linspace(-100*h,100*h,len(cone_red_z))'''\n",
    "    \n",
    "    x_slit=np.linspace(-100*h,100*h, len(merged_x))\n",
    "\n",
    "    len_pts=max(upper_lim-lower_lim,upper_lim_ortho-lower_lim_ortho)\n",
    "\n",
    "    #height is based upon the length of the overall data we have on the bicone and the slitwidth\n",
    "    height=slitwidth/pixelscale_1#(slitwidth/(pixelscale*len_pts))#*(h)#I kinda want this to be a fraction of something else#10#was 4\n",
    "\n",
    "    if PA1 < 90:\n",
    "        z_slit_1_upper=[x*np.tan(PA_obs_1)-height/np.cos(PA_obs_1) for x in merged_x]\n",
    "        z_slit_1_lower=[x*np.tan(PA_obs_1)+height/np.cos(PA_obs_1) for x in merged_x]\n",
    "        \n",
    "    else:\n",
    "        z_slit_1_upper=[x*np.tan(PA_obs_1)+height/np.cos(PA_obs_1) for x in merged_x]\n",
    "        z_slit_1_lower=[x*np.tan(PA_obs_1)-height/np.cos(PA_obs_1) for x in merged_x]\n",
    "        \n",
    "    height=slitwidth/pixelscale_2  \n",
    "    if PA2 > 90:\n",
    "        z_slit_2_upper=[x*np.tan(PA_obs_2)+height/np.cos(PA_obs_2) for x in merged_x]\n",
    "        z_slit_2_lower=[x*np.tan(PA_obs_2)-height/np.cos(PA_obs_2) for x in merged_x]\n",
    "        \n",
    "    else: \n",
    "        z_slit_2_upper=[x*np.tan(PA_obs_2)-height/np.cos(PA_obs_2) for x in merged_x]\n",
    "        z_slit_2_lower=[x*np.tan(PA_obs_2)+height/np.cos(PA_obs_2) for x in merged_x]\n",
    "        \n",
    "   \n",
    "\n",
    "    if PA1<90:\n",
    "        inds_1=np.logical_and(np.logical_and((np.asarray(merged_z) > np.asarray(z_slit_1_lower)), (np.asarray(merged_z) < np.asarray(z_slit_1_upper))), (np.asarray(merged_y) < np.asarray(merged_y_plane)))\n",
    "        inds_1_below=np.logical_and(np.logical_and((np.asarray(merged_z) > np.asarray(z_slit_1_lower)), (np.asarray(merged_z) < np.asarray(z_slit_1_upper))), (np.asarray(merged_y) > np.asarray(merged_y_plane)))\n",
    "    else:\n",
    "        inds_1=np.logical_and(np.logical_and((np.asarray(merged_z) < np.asarray(z_slit_1_lower)), (np.asarray(merged_z) > np.asarray(z_slit_1_upper))), (np.asarray(merged_y) < np.asarray(merged_y_plane)))\n",
    "        inds_1_below=np.logical_and(np.logical_and((np.asarray(merged_z) < np.asarray(z_slit_1_lower)), (np.asarray(merged_z) > np.asarray(z_slit_1_upper))), (np.asarray(merged_y) > np.asarray(merged_y_plane)))\n",
    "    if PA2>90:\n",
    "        inds_2=np.logical_and(np.logical_and((np.asarray(merged_z) < np.asarray(z_slit_2_lower)), (np.asarray(merged_z) > np.asarray(z_slit_2_upper))), (np.asarray(merged_y) < np.asarray(merged_y_plane)))\n",
    "        inds_2_below=np.logical_and(np.logical_and((np.asarray(merged_z) < np.asarray(z_slit_2_lower)), (np.asarray(merged_z) > np.asarray(z_slit_2_upper))), (np.asarray(merged_y) > np.asarray(merged_y_plane)))\n",
    "    else:\n",
    "        inds_2=np.logical_and(np.logical_and((np.asarray(merged_z) > np.asarray(z_slit_2_lower)), (np.asarray(merged_z) < np.asarray(z_slit_2_upper))), (np.asarray(merged_y) < np.asarray(merged_y_plane)))\n",
    "        inds_2_below=np.logical_and(np.logical_and((np.asarray(merged_z) > np.asarray(z_slit_2_lower)), (np.asarray(merged_z) < np.asarray(z_slit_2_upper))), (np.asarray(merged_y) > np.asarray(merged_y_plane)))\n",
    "    \n",
    "\n",
    "    '''xs_cont_1 is the blueshifted cone of PA1'''\n",
    "    xs_cont_1=np.asarray(merged_x)[np.asarray(inds_1)]\n",
    "    ys_cont_1=np.asarray(merged_y)[np.asarray(inds_1)]\n",
    "    zs_cont_1=np.asarray(merged_z)[np.asarray(inds_1)]\n",
    "    vel_cont_1=np.asarray(merged_vel)[np.asarray(inds_1)]\n",
    "\n",
    "    '''xs_cont_1_below is the redshifted cone of PA1'''\n",
    "    xs_cont_1_below=np.asarray(merged_x)[np.asarray(inds_1_below)]\n",
    "    ys_cont_1_below=np.asarray(merged_y)[np.asarray(inds_1_below)]\n",
    "    zs_cont_1_below=np.asarray(merged_z)[np.asarray(inds_1_below)]\n",
    "    vel_cont_1_below=np.asarray(merged_vel)[np.asarray(inds_1_below)]\n",
    "\n",
    "    xs_cont_2=np.asarray(merged_x)[np.asarray(inds_2)]\n",
    "    ys_cont_2=np.asarray(merged_y)[np.asarray(inds_2)]\n",
    "    zs_cont_2=np.asarray(merged_z)[np.asarray(inds_2)]\n",
    "    vel_cont_2=np.asarray(merged_vel)[np.asarray(inds_2)]\n",
    "    xs_cont_2_below=np.asarray(merged_x)[np.asarray(inds_2_below)]\n",
    "    ys_cont_2_below=np.asarray(merged_y)[np.asarray(inds_2_below)]\n",
    "    zs_cont_2_below=np.asarray(merged_z)[np.asarray(inds_2_below)]\n",
    "    vel_cont_2_below=np.asarray(merged_vel)[np.asarray(inds_2_below)]\n",
    "\n",
    "    \n",
    "   \n",
    "    \n",
    "    r_slit_1_above=[]\n",
    "    v_slit_1_above=[]\n",
    "    r_slit_2_above=[]\n",
    "    v_slit_2_above=[]\n",
    "    r_slit_1_below=[]\n",
    "    v_slit_1_below=[]\n",
    "    r_slit_2_below=[]\n",
    "    v_slit_2_below=[]\n",
    "\n",
    "    mask_slit_1_above=[]\n",
    "    mask_slit_2_above=[]\n",
    "    mask_slit_1_below=[]\n",
    "    mask_slit_2_below=[]\n",
    "\n",
    "\n",
    "    stepping=1\n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "    length=max((upper_lim-lower_lim),(upper_lim_ortho-lower_lim_ortho))\n",
    "\n",
    "    if PA1 < 90:\n",
    "        additive=np.pi/2\n",
    "    else:\n",
    "        additive=np.pi/2\n",
    "    for j in range(length):\n",
    "        #\n",
    "        width=pixelscale_1*j\n",
    "        '''z_1_perp_upper=[-x*(1/np.tan(PA_obs_1))-(width+stepping+0.5)/np.sin(math.radians(PA1-90)) for x in xs_cont_1]\n",
    "        z_1_perp_lower=[-x*(1/np.tan(PA_obs_1))-(width+0.5)/np.sin(math.radians(PA1-90)) for x in xs_cont_1]\n",
    "        z_1_perpl_upper=[-x*(1/np.tan(PA_obs_1))+(width+0.5)/np.sin(math.radians(PA1-90)) for x in xs_cont_1]\n",
    "        z_1_perpl_lower=[-x*(1/np.tan(PA_obs_1))+(width+stepping+0.5)/np.sin(math.radians(PA1-90)) for x in xs_cont_1]\n",
    "        '''\n",
    "        z_1_perp_upper=[-x*(1/np.tan(PA_obs_1))+(width+1.5*pixelscale_1)/np.cos(PA_obs_1+additive) for x in xs_cont_1]\n",
    "        z_1_perp_lower=[-x*(1/np.tan(PA_obs_1))+(width+0.5*pixelscale_1)/np.cos(PA_obs_1+additive) for x in xs_cont_1]\n",
    "        z_1_perpl_upper=[-x*(1/np.tan(PA_obs_1))-(width+0.5*pixelscale_1)/np.cos(PA_obs_1+additive) for x in xs_cont_1]\n",
    "        z_1_perpl_lower=[-x*(1/np.tan(PA_obs_1))-(width+1.5*pixelscale_1)/np.cos(PA_obs_1+additive) for x in xs_cont_1]\n",
    "\n",
    "\n",
    "        if PA1 < 90:\n",
    "            pos_1=np.logical_and((np.asarray(zs_cont_1) > np.asarray(z_1_perp_upper)), (np.asarray(zs_cont_1) < np.asarray(z_1_perp_lower)))\n",
    "            pos_1_1=np.logical_and((np.asarray(zs_cont_1) > np.asarray(z_1_perpl_upper)), (np.asarray(zs_cont_1) < np.asarray(z_1_perpl_lower)))\n",
    "            pos_1_center=np.logical_and((np.asarray(zs_cont_1) < np.asarray(z_1_perpl_upper)), (np.asarray(zs_cont_1) > np.asarray(z_1_perp_lower)))\n",
    "        else:\n",
    "            pos_1=np.logical_and((np.asarray(zs_cont_1) < np.asarray(z_1_perp_upper)), (np.asarray(zs_cont_1) > np.asarray(z_1_perp_lower)))\n",
    "            pos_1_1=np.logical_and((np.asarray(zs_cont_1) < np.asarray(z_1_perpl_upper)), (np.asarray(zs_cont_1) > np.asarray(z_1_perpl_lower)))\n",
    "            pos_1_center=np.logical_and((np.asarray(zs_cont_1) > np.asarray(z_1_perpl_upper)), (np.asarray(zs_cont_1) < np.asarray(z_1_perp_lower)))\n",
    "        \n",
    "        \n",
    "       \n",
    "\n",
    "        if j==0:\n",
    "            xs_cont_slit_middle=np.asarray(xs_cont_1)[np.asarray(pos_1_center)]\n",
    "            zs_cont_slit_middle=np.asarray(zs_cont_1)[np.asarray(pos_1_center)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit_middle)**2+np.mean(zs_cont_slit_middle)**2))==True:\n",
    "                r_slit_1_above.append(j)\n",
    "                v_slit_1_above.append(10)\n",
    "                mask_slit_1_above.append(1)\n",
    "\n",
    "            else:\n",
    "                #so this is the positions to the North so we'll make them negative\n",
    "                r_slit_1_above.append(j)\n",
    "                v_slit_1_above.append(np.mean(np.asarray(vel_cont_1)[np.asarray(pos_1_center)]))\n",
    "                mask_slit_1_above.append(0)\n",
    "        else:\n",
    "            xs_cont_slit=np.asarray(xs_cont_1)[np.asarray(pos_1)]\n",
    "            zs_cont_slit=np.asarray(zs_cont_1)[np.asarray(pos_1)]\n",
    "\n",
    "\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))==True:\n",
    "\n",
    "                r_slit_1_above.append(j)\n",
    "                v_slit_1_above.append(10)\n",
    "                mask_slit_1_above.append(1)\n",
    "            else:\n",
    "                #so this is the positions to the North so we'll make them negative\n",
    "                r_slit_1_above.append(j)\n",
    "                v_slit_1_above.append(np.mean(np.asarray(vel_cont_1)[np.asarray(pos_1)]))\n",
    "                mask_slit_1_above.append(0)\n",
    "                #r_slit_1_above.append(np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))\n",
    "                #v_slit_1_above.append(np.mean(np.asarray(vel_cont_1)[np.asarray(pos_1)]))\n",
    "\n",
    "\n",
    "            xs_cont_slit=np.asarray(xs_cont_1)[np.asarray(pos_1_1)]\n",
    "            zs_cont_slit=np.asarray(zs_cont_1)[np.asarray(pos_1_1)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))==True:\n",
    "\n",
    "                r_slit_1_above.append(-j)\n",
    "                v_slit_1_above.append(10)\n",
    "                mask_slit_1_above.append(1)\n",
    "            else:\n",
    "                r_slit_1_above.append(-j)\n",
    "                #r_slit_1_above.append(-np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))\n",
    "                #r_slit_1_above.append(-np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))\n",
    "                v_slit_1_above.append(np.mean(np.asarray(vel_cont_1)[np.asarray(pos_1_1)]))\n",
    "                mask_slit_1_above.append(0)\n",
    "\n",
    "        z_1_perp_upper=[-x*(1/np.tan(PA_obs_1))+(width+1.5*pixelscale_1)/np.cos(PA_obs_1+additive) for x in xs_cont_1_below]\n",
    "        z_1_perp_lower=[-x*(1/np.tan(PA_obs_1))+(width+0.5*pixelscale_1)/np.cos(PA_obs_1+additive) for x in xs_cont_1_below]\n",
    "        z_1_perpl_upper=[-x*(1/np.tan(PA_obs_1))-(width+0.5*pixelscale_1)/np.cos(PA_obs_1+additive) for x in xs_cont_1_below]\n",
    "        z_1_perpl_lower=[-x*(1/np.tan(PA_obs_1))-(width+1.5*pixelscale_1)/np.cos(PA_obs_1+additive) for x in xs_cont_1_below]\n",
    "        \n",
    "        if PA1 < 90:\n",
    "            pos_1_below=np.logical_and((np.asarray(zs_cont_1_below) > np.asarray(z_1_perp_upper)), (np.asarray(zs_cont_1_below) < np.asarray(z_1_perp_lower)))\n",
    "            pos_1_below_1=np.logical_and((np.asarray(zs_cont_1_below) > np.asarray(z_1_perpl_upper)), (np.asarray(zs_cont_1_below) < np.asarray(z_1_perpl_lower)))\n",
    "            pos_1_below_center=np.logical_and((np.asarray(zs_cont_1_below) < np.asarray(z_1_perpl_upper)), (np.asarray(zs_cont_1_below) > np.asarray(z_1_perp_lower)))\n",
    "        else:\n",
    "            pos_1_below=np.logical_and((np.asarray(zs_cont_1_below) < np.asarray(z_1_perp_upper)), (np.asarray(zs_cont_1_below) > np.asarray(z_1_perp_lower)))\n",
    "            pos_1_below_1=np.logical_and((np.asarray(zs_cont_1_below) < np.asarray(z_1_perpl_upper)), (np.asarray(zs_cont_1_below) > np.asarray(z_1_perpl_lower)))\n",
    "            pos_1_below_center=np.logical_and((np.asarray(zs_cont_1_below) > np.asarray(z_1_perpl_upper)), (np.asarray(zs_cont_1_below) < np.asarray(z_1_perp_lower)))\n",
    "\n",
    "        if j==0:\n",
    "            xs_cont_slit_middle=np.asarray(xs_cont_1_below)[np.asarray(pos_1_below_center)]\n",
    "            zs_cont_slit_middle=np.asarray(zs_cont_1_below)[np.asarray(pos_1_below_center)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit_middle)**2+np.mean(zs_cont_slit_middle)**2))==True:\n",
    "                r_slit_1_below.append(j)\n",
    "                v_slit_1_below.append(10)\n",
    "                mask_slit_1_below.append(1)\n",
    "\n",
    "            else:\n",
    "                #so this is the positions to the North so we'll make them negative\n",
    "                r_slit_1_below.append(j)\n",
    "                v_slit_1_below.append(np.mean(np.asarray(vel_cont_1_below)[np.asarray(pos_1_below_center)]))\n",
    "                mask_slit_1_below.append(0)\n",
    "        else:\n",
    "\n",
    "            xs_cont_slit=np.asarray(xs_cont_1_below)[np.asarray(pos_1_below)]\n",
    "            zs_cont_slit=np.asarray(zs_cont_1_below)[np.asarray(pos_1_below)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))==True:\n",
    "                r_slit_1_below.append(j)\n",
    "                v_slit_1_below.append(10)\n",
    "                mask_slit_1_below.append(1)\n",
    "\n",
    "            else:\n",
    "                r_slit_1_below.append(j)\n",
    "                v_slit_1_below.append(np.mean(np.asarray(vel_cont_1_below)[np.asarray(pos_1_below)]))\n",
    "                mask_slit_1_below.append(0)\n",
    "\n",
    "            xs_cont_slit=np.asarray(xs_cont_1_below)[np.asarray(pos_1_below_1)]\n",
    "            zs_cont_slit=np.asarray(zs_cont_1_below)[np.asarray(pos_1_below_1)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2)):\n",
    "                r_slit_1_below.append(-j)\n",
    "                v_slit_1_below.append(10)\n",
    "                mask_slit_1_below.append(1)\n",
    "\n",
    "            else:\n",
    "                r_slit_1_below.append(-j)\n",
    "                v_slit_1_below.append(np.mean(np.asarray(vel_cont_1_below)[np.asarray(pos_1_below_1)]))\n",
    "                mask_slit_1_below.append(0)\n",
    "\n",
    "        '''Now PA 2 which is greater than 90'''\n",
    "        width=pixelscale_2*j\n",
    "\n",
    "        z_2_perp_upper=[-x*(1/np.tan(PA_obs_2))+(width+1.5*pixelscale_2)/np.cos(PA_obs_2+additive) for x in xs_cont_2]\n",
    "        z_2_perp_lower=[-x*(1/np.tan(PA_obs_2))+(width+0.5*pixelscale_2)/np.cos(PA_obs_2+additive) for x in xs_cont_2]\n",
    "        z_2_perpl_upper=[-x*(1/np.tan(PA_obs_2))-(width+0.5*pixelscale_2)/np.cos(PA_obs_2+additive) for x in xs_cont_2]\n",
    "        z_2_perpl_lower=[-x*(1/np.tan(PA_obs_2))-(width+1.5*pixelscale_2)/np.cos(PA_obs_2+additive) for x in xs_cont_2]\n",
    "        \n",
    "        \n",
    "        if PA2 > 90:\n",
    "            pos_1_2=np.logical_and((np.asarray(zs_cont_2) < np.asarray(z_2_perp_upper)), (np.asarray(zs_cont_2) > np.asarray(z_2_perp_lower)))\n",
    "            pos_1_3=np.logical_and((np.asarray(zs_cont_2) < np.asarray(z_2_perpl_upper)), (np.asarray(zs_cont_2)> np.asarray(z_2_perpl_lower)))\n",
    "\n",
    "            pos_1_2_center=np.logical_and((np.asarray(zs_cont_2) > np.asarray(z_2_perpl_upper)), (np.asarray(zs_cont_2) < np.asarray(z_2_perp_lower)))\n",
    "        else:\n",
    "            pos_1_2=np.logical_and((np.asarray(zs_cont_2) > np.asarray(z_2_perp_upper)), (np.asarray(zs_cont_2) < np.asarray(z_2_perp_lower)))\n",
    "            pos_1_3=np.logical_and((np.asarray(zs_cont_2) > np.asarray(z_2_perpl_upper)), (np.asarray(zs_cont_2)< np.asarray(z_2_perpl_lower)))\n",
    "\n",
    "            pos_1_2_center=np.logical_and((np.asarray(zs_cont_2) < np.asarray(z_2_perpl_upper)), (np.asarray(zs_cont_2) > np.asarray(z_2_perp_lower)))\n",
    "        #\n",
    "        \n",
    "        #if j==0:\n",
    "            #plt.plot(xs_cont_2, z_2_perp_upper, label='z_1_perp_upper',lw=4, color='black')\n",
    "            #plt.plot(xs_cont_2, z_2_perp_lower, label='z_2_perp_lower',lw=4,ls='--', color='red')\n",
    "            #plt.plot(xs_cont_2, z_2_perpl_upper, label='z_2_perpl_upper',lw=4, color='pink')\n",
    "            #plt.show()\n",
    "        if j==0:\n",
    "            xs_cont_slit_middle=np.asarray(xs_cont_2)[np.asarray(pos_1_2_center)]\n",
    "            zs_cont_slit_middle=np.asarray(zs_cont_2)[np.asarray(pos_1_2_center)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit_middle)**2+np.mean(zs_cont_slit_middle)**2))==True:\n",
    "\n",
    "                r_slit_2_above.append(j)\n",
    "                v_slit_2_above.append(10)\n",
    "                mask_slit_2_above.append(1)\n",
    "\n",
    "            else:\n",
    "                #so this is the positions to the North so we'll make them negative\n",
    "                r_slit_2_above.append(j)\n",
    "                v_slit_2_above.append(np.mean(np.asarray(vel_cont_2)[np.asarray(pos_1_2_center)]))\n",
    "                mask_slit_2_above.append(0)\n",
    "        else:\n",
    "\n",
    "            xs_cont_slit=np.asarray(xs_cont_2)[np.asarray(pos_1_2)]\n",
    "            zs_cont_slit=np.asarray(zs_cont_2)[np.asarray(pos_1_2)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))==True:\n",
    "                r_slit_2_above.append(j)\n",
    "                v_slit_2_above.append(10)\n",
    "                mask_slit_2_above.append(1)\n",
    "\n",
    "            else:\n",
    "                r_slit_2_above.append(j)\n",
    "                v_slit_2_above.append(np.mean(np.asarray(vel_cont_2)[np.asarray(pos_1_2)]))\n",
    "                mask_slit_2_above.append(0)\n",
    "\n",
    "            xs_cont_slit=np.asarray(xs_cont_2)[np.asarray(pos_1_3)]\n",
    "            zs_cont_slit=np.asarray(zs_cont_2)[np.asarray(pos_1_3)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))==True:\n",
    "\n",
    "                r_slit_2_above.append(-j)\n",
    "                v_slit_2_above.append(10)\n",
    "                mask_slit_2_above.append(1)\n",
    "\n",
    "            else:\n",
    "                r_slit_2_above.append(-j)\n",
    "                v_slit_2_above.append(np.mean(np.asarray(vel_cont_2)[np.asarray(pos_1_3)]))\n",
    "                mask_slit_2_above.append(0)\n",
    "            #math.isnan(np.mean(np.asarray(vel_cont_2)[np.asarray(pos_1_3)])):\n",
    "\n",
    "\n",
    "\n",
    "        z_2_perp_upper=[-x*(1/np.tan(PA_obs_2))+(width+1.5*pixelscale_2)/np.cos(PA_obs_2+additive) for x in xs_cont_2_below]\n",
    "        z_2_perp_lower=[-x*(1/np.tan(PA_obs_2))+(width+0.5*pixelscale_2)/np.cos(PA_obs_2+additive) for x in xs_cont_2_below]\n",
    " \n",
    "\n",
    "# This code simply models the mean of the above and below cone at each position\n",
    "def model_bicone_three_slits_means(z, PA1, PA2, PA3, pixelscale_1, slitwidth, spatial_resolution):\n",
    "\n",
    "\n",
    "    #bicone_construction(h,phi,theta,r_t, half_angle )\n",
    "    phi_array, theta_array, r_t,half_angle, vel_max_array=z\n",
    "\n",
    "\n",
    "    h=2*r_t\n",
    "    #h=[2*x for x in r_t]\n",
    "\n",
    "    out=bicone_construction(phi_array, theta_array, r_t, half_angle, vel_max_array)\n",
    "\n",
    "    # So this gives you a whole lot of 3D measurements that you do not actually need\n",
    "\n",
    "    merged_x=[float(y) for y in out[0]]\n",
    "    merged_y=[float(y) for y in out[1]]\n",
    "    merged_z=[float(y) for y in out[2]]\n",
    "    merged_vel=[float(y) for y in out[3]]\n",
    "    merged_x_plane=[float(y) for y in out[4]]\n",
    "    merged_y_plane=[float(y) for y in out[5]]\n",
    "    merged_z_plane=[float(y) for y in out[6]]\n",
    "\n",
    "    plt.clf()\n",
    "    plt.scatter(merged_x, merged_y, merged_z, c=merged_vel)\n",
    "    plt.colorbar()\n",
    "    plt.savefig('3D_cone.png')\n",
    "\n",
    "\n",
    "\n",
    "    plt.clf()\n",
    "    plt.scatter(merged_x_plane, merged_y_plane, merged_z_plane, c=merged_vel)\n",
    "    plt.colorbar()\n",
    "    plt.savefig('3D_cone_plane.png')\n",
    "    \n",
    "    plt.clf()\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    im = ax.scatter(merged_x, merged_y, c=merged_vel, cmap='RdBu_r')\n",
    "    plt.colorbar(im)\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    #%```````````````````````````````````\n",
    "    #I'm going to make the phi cuts according to observe PAs\n",
    "    PA_obs_1=np.radians(PA1+90)\n",
    "    PA_obs_2=np.radians(PA2+90)\n",
    "    PA_obs_3=np.radians(PA3+90)\n",
    "\n",
    "    print('PA1', PA1+90)\n",
    "\n",
    "    #x_slit=np.linspace(-100*h,100*h, len(merged_x))\n",
    "\n",
    "    #len_pts=max(upper_lim-lower_lim,upper_lim_ortho-lower_lim_ortho)\n",
    "\n",
    "    #height is based upon the length of the overall data we have on the bicone and the slitwidth\n",
    "    height=slitwidth/pixelscale_1#\n",
    "    # so this part is a bit tricky because we're defining a PA of 0 to be straight up\n",
    "    # so add 90 to everything above, and then move one half a slitwidth above and below\n",
    "    # the centerline of each slit to capture light\n",
    "    # so the equation of a line would normally be mx + b = rise/run*x + b = arctan(angle)*x+b\n",
    "    # but in our case, we are adding 90 degrees, so this is equivalent to tan(angle)*x\n",
    "    # and then instead of dividing the height by np.sin(PA1), you divide by np.cos(PA1) because\n",
    "    # we have moved 90' around the unit circle!\n",
    "    \n",
    "    # if the PA1 is lt 90, then swith the order of the two slits (upper and lower)\n",
    "    if PA1 < 90:\n",
    "        z_slit_1_upper=[x*np.tan(PA_obs_1)-0.5*height/np.cos(PA_obs_1) for x in merged_x]\n",
    "        z_slit_1_lower=[x*np.tan(PA_obs_1)+0.5*height/np.cos(PA_obs_1) for x in merged_x]\n",
    "        z_slit_center = [x*np.tan(PA_obs_1) for x in merged_x]\n",
    "        \n",
    "    else:\n",
    "        z_slit_1_upper=[x*np.tan(PA_obs_1)+0.5*height/np.cos(PA_obs_1) for x in merged_x]\n",
    "        z_slit_1_lower=[x*np.tan(PA_obs_1)-0.5*height/np.cos(PA_obs_1) for x in merged_x]\n",
    "    \n",
    "    \n",
    "    \n",
    "    height=slitwidth/pixelscale_2  \n",
    "    if PA2 > 90:\n",
    "        z_slit_2_upper=[x*np.tan(PA_obs_2)+0.5*height/np.cos(PA_obs_2) for x in merged_x]\n",
    "        z_slit_2_lower=[x*np.tan(PA_obs_2)-0.5*height/np.cos(PA_obs_2) for x in merged_x]\n",
    "        \n",
    "    else: \n",
    "        z_slit_2_upper=[x*np.tan(PA_obs_2)-0.5*height/np.cos(PA_obs_2) for x in merged_x]\n",
    "        z_slit_2_lower=[x*np.tan(PA_obs_2)+0.5*height/np.cos(PA_obs_2) for x in merged_x]\n",
    "        \n",
    "    ax.plot(merged_x, z_slit_1_upper, color='k')\n",
    "    ax.plot(merged_x, z_slit_1_lower, color='k')\n",
    "    ax.plot(merged_x, z_slit_center, color='k', ls='--')\n",
    "    ax.plot(merged_x, z_slit_2_upper, color='k')\n",
    "    ax.plot(merged_x, z_slit_2_lower, color='k')\n",
    "    ax.set_aspect(aspect=1)\n",
    "    ax.set_xlim([-30,30])\n",
    "    ax.set_ylim([-30,30])\n",
    "    ax.set_xlabel('Pixels')\n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "    if PA1<90:\n",
    "        inds_1=np.logical_and(np.logical_and((np.asarray(merged_z) > np.asarray(z_slit_1_lower)), (np.asarray(merged_z) < np.asarray(z_slit_1_upper))), (np.asarray(merged_y) < np.asarray(merged_y_plane)))\n",
    "        inds_1_below=np.logical_and(np.logical_and((np.asarray(merged_z) > np.asarray(z_slit_1_lower)), (np.asarray(merged_z) < np.asarray(z_slit_1_upper))), (np.asarray(merged_y) > np.asarray(merged_y_plane)))\n",
    "    else:\n",
    "        inds_1=np.logical_and(np.logical_and((np.asarray(merged_z) < np.asarray(z_slit_1_lower)), (np.asarray(merged_z) > np.asarray(z_slit_1_upper))), (np.asarray(merged_y) < np.asarray(merged_y_plane)))\n",
    "        inds_1_below=np.logical_and(np.logical_and((np.asarray(merged_z) < np.asarray(z_slit_1_lower)), (np.asarray(merged_z) > np.asarray(z_slit_1_upper))), (np.asarray(merged_y) > np.asarray(merged_y_plane)))\n",
    "    if PA2>90:\n",
    "        inds_2=np.logical_and(np.logical_and((np.asarray(merged_z) < np.asarray(z_slit_2_lower)), (np.asarray(merged_z) > np.asarray(z_slit_2_upper))), (np.asarray(merged_y) < np.asarray(merged_y_plane)))\n",
    "        inds_2_below=np.logical_and(np.logical_and((np.asarray(merged_z) < np.asarray(z_slit_2_lower)), (np.asarray(merged_z) > np.asarray(z_slit_2_upper))), (np.asarray(merged_y) > np.asarray(merged_y_plane)))\n",
    "    else:\n",
    "        inds_2=np.logical_and(np.logical_and((np.asarray(merged_z) > np.asarray(z_slit_2_lower)), (np.asarray(merged_z) < np.asarray(z_slit_2_upper))), (np.asarray(merged_y) < np.asarray(merged_y_plane)))\n",
    "        inds_2_below=np.logical_and(np.logical_and((np.asarray(merged_z) > np.asarray(z_slit_2_lower)), (np.asarray(merged_z) < np.asarray(z_slit_2_upper))), (np.asarray(merged_y) > np.asarray(merged_y_plane)))\n",
    "    \n",
    "\n",
    "    # xs_cont_1 is the blueshifted cone of PA1\n",
    "    xs_cont_1=np.asarray(merged_x)[np.asarray(inds_1)]\n",
    "    ys_cont_1=np.asarray(merged_y)[np.asarray(inds_1)]\n",
    "    zs_cont_1=np.asarray(merged_z)[np.asarray(inds_1)]\n",
    "    vel_cont_1=np.asarray(merged_vel)[np.asarray(inds_1)]\n",
    "\n",
    "    # xs_cont_1_below is the redshifted cone of PA1\n",
    "    xs_cont_1_below=np.asarray(merged_x)[np.asarray(inds_1_below)]\n",
    "    ys_cont_1_below=np.asarray(merged_y)[np.asarray(inds_1_below)]\n",
    "    zs_cont_1_below=np.asarray(merged_z)[np.asarray(inds_1_below)]\n",
    "    vel_cont_1_below=np.asarray(merged_vel)[np.asarray(inds_1_below)]\n",
    "\n",
    "    xs_cont_2=np.asarray(merged_x)[np.asarray(inds_2)]\n",
    "    ys_cont_2=np.asarray(merged_y)[np.asarray(inds_2)]\n",
    "    zs_cont_2=np.asarray(merged_z)[np.asarray(inds_2)]\n",
    "    vel_cont_2=np.asarray(merged_vel)[np.asarray(inds_2)]\n",
    "    xs_cont_2_below=np.asarray(merged_x)[np.asarray(inds_2_below)]\n",
    "    ys_cont_2_below=np.asarray(merged_y)[np.asarray(inds_2_below)]\n",
    "    zs_cont_2_below=np.asarray(merged_z)[np.asarray(inds_2_below)]\n",
    "    vel_cont_2_below=np.asarray(merged_vel)[np.asarray(inds_2_below)]\n",
    "\n",
    "    \n",
    "    # Now you're going to need to step up each slit by\n",
    "    # units of the resolution, starting in the center at zero zero and moving outward in either direction\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    if PA1 < 90:\n",
    "        additive=np.pi/2\n",
    "    else:\n",
    "        additive=np.pi/2\n",
    "        \n",
    "    # Okay so make a list of coordinates that define each slit center\n",
    "    # and then for each one define the four corners\n",
    "    width = spatial_resolution/pixelscale_1\n",
    "    slit_center_above = [(width*j*(1/np.sin(PA_obs_1)),width*j*(1/np.cos(PA_obs_1))) for j in range(20-lower_lim)]\n",
    "    x_center_slit_1_above = [x[0] for x in slit_center_above]\n",
    "    y_center_slit_1_above = [x[1] for x in slit_center_above]\n",
    "    \n",
    "    slit_center_below = [(-width*j*(1/np.sin(PA_obs_1)),-width*j*(1/np.cos(PA_obs_1))) for j in range(upper_lim-20)]\n",
    "    x_center_slit_1_below = [x[0] for x in slit_center_below]\n",
    "    y_center_slit_1_below = [x[1] for x in slit_center_below]\n",
    "    \n",
    "\n",
    "    x_slit_1_center = x_center_slit_1_above[1:] + x_center_slit_1_below\n",
    "    y_slit_1_center = y_center_slit_1_above[1:] + y_center_slit_1_below\n",
    "    ax.scatter(x_slit_1_center, y_slit_1_center, edgecolor='black', color='pink')\n",
    "\n",
    "    \n",
    "    slit_pos_1 = [j for j in range(20-lower_lim)]\n",
    "    slit_pos_2 = [-j for j in range(upper_lim-20)]\n",
    "\n",
    "    combo_slit = np.array(slit_pos_1 + slit_pos_2)[1:]\n",
    "    # Okay can I reorder these slit positions\n",
    "\n",
    "    ind = np.unravel_index(np.argsort(combo_slit), combo_slit.shape)\n",
    "\n",
    "\n",
    "    combo_slit = combo_slit[ind]\n",
    "    x_slit_1_center = np.array(x_slit_1_center)[ind]\n",
    "    y_slit_1_center = np.array(y_slit_1_center)[ind]\n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "\n",
    "    # okay so for each of these centers, construct an array that has all four points of the edge,\n",
    "    # then find all points within that\n",
    "    profiles=[]\n",
    "    mean_vel = []\n",
    "    for p in range(len(x_slit_1_center)):\n",
    "        # okay so to form the triangle you have to rotate the points about the 'origin', which is the slit center\n",
    "        # the origin is defined by x_slit_1_center and y_slit_1_center\n",
    "        #if abs(x_slit_1_center[p]) > 1:\n",
    "        #    continue\n",
    "        #print('centers', x_slit_1_center[p], y_slit_1_center[p])\n",
    "        origin = (x_slit_1_center[p],y_slit_1_center[p])\n",
    "        corners = [(0.5*height+x_slit_1_center[p], width+y_slit_1_center[p]),(0.5*height+x_slit_1_center[p],-width+y_slit_1_center[p]),(-0.5*height+x_slit_1_center[p], width+y_slit_1_center[p]), (-0.5*height+x_slit_1_center[p],-width+y_slit_1_center[p])]\n",
    "        #print('corners before rotation', corners, np.shape(corners))\n",
    "        #plt.scatter(np.array(corners)[:,0], np.array(corners)[:,1], marker='^', color='white', edgecolor='black', s=80, zorder=100)\n",
    "        \n",
    "        #qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\n",
    "        #qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\n",
    "    \n",
    "\n",
    "        #corners_rotated_x = [origin[0] + np.cos(PA_obs_1-np.pi/2)*(x[0] - origin[0]) - np.sin(PA_obs_1-np.pi/2)*(x[1] - origin[1]) for x in corners]\n",
    "        corners_rotated = [(origin[0] + np.cos(PA_obs_1-np.pi/2)*(x[0] - origin[0]) - np.sin(PA_obs_1-np.pi/2)*(x[1] - origin[1]),origin[1] + np.sin(PA_obs_1-np.pi/2)*(x[0]-origin[0])+np.cos(PA_obs_1-np.pi/2)*(x[1] - origin[1])) for x in corners]\n",
    "        #print('corners after rotation', corners_rotated)\n",
    "        corners_rotated_y = np.array(corners_rotated)[:,1]\n",
    "        corners_rotated_x = np.array(corners_rotated)[:,0]\n",
    "#[0 + np.sin(PA_obs_1-np.pi/2)*(x[0]-0)+np.cos(PA_obs_1-np.pi/2)*(x[1]-0) for x in corners]\n",
    "        plt.scatter(corners_rotated_x,corners_rotated_y, marker='*', color='white', edgecolor='black', s=120, zorder=100)\n",
    "    \n",
    "        z_1_perp_lower=[-x*(1/np.tan(PA_obs_1))-(width)/np.cos(PA_obs_1+additive) for x in xs_cont_1]\n",
    "        z_1_perp_upper=[-x*(1/np.tan(PA_obs_1))+(width)/np.cos(PA_obs_1+additive) for x in xs_cont_1]\n",
    "        plt.plot(xs_cont_1, z_1_perp_upper, color='red')\n",
    "        plt.plot(xs_cont_1, z_1_perp_lower, color='red')\n",
    "   \n",
    "\n",
    "\n",
    "        ordered_pts = order_points(np.array(corners_rotated))\n",
    "    \n",
    "    \n",
    "        polygon = Polygon(ordered_pts)\n",
    "\n",
    "    \n",
    "        cont_vel = []\n",
    "        cont_x = []\n",
    "        cont_y = []\n",
    "        for k in range(len(merged_x)):\n",
    "            #print(polygon.contains(Point(merged_x[k],merged_y[k])))\n",
    "            if polygon.contains(Point(merged_x[k],merged_y[k])):\n",
    "                cont_x.append(merged_x[k])\n",
    "                cont_y.append(merged_y[k])\n",
    "                cont_vel.append(merged_vel[k])\n",
    "        im4 = plt.scatter(cont_x, cont_y, c=cont_vel, cmap='Greens', s=1)\n",
    "        mean_vel.append(np.mean(cont_vel))\n",
    "        profiles.append(cont_vel)\n",
    "    plt.colorbar(im4)\n",
    "    im5 = ax.scatter(x_slit_1_center, y_slit_1_center, c=mean_vel, edgecolor='black', cmap='RdBu_r', vmax = 300, vmin=-300)\n",
    "    plt.colorbar(im5)\n",
    "    plt.title('Params = '+str(z))\n",
    "    plt.savefig('2D_projection.png')\n",
    "\n",
    "\n",
    "    # What if there was a way to plot the profile of each slit position?\n",
    "    print(np.shape(profiles))\n",
    "  \n",
    "    plt.clf()\n",
    "    fig, axs = plt.subplots(10,4, figsize=(20, 15), facecolor='w', edgecolor='k')\n",
    "    fig.subplots_adjust(hspace = .5, wspace=.2)\n",
    "\n",
    "    axs = axs.ravel()\n",
    "    for p in range(len(profiles)):\n",
    "        if profiles[p]:\n",
    "            print('this is your profile', profiles[p])\n",
    "            print('sorted', profiles[p])\n",
    "            print(profiles[p].sort()[0], profiles[p].sort()[-1])\n",
    "            if np.arange(profiles[p].sort()[0],profiles[p].sort()[-1],20)-10:\n",
    "                range_xbin = np.arange(profiles[p].sort()[0],profiles[p].sort()[-1],20)-10\n",
    "                print('these are your bins', range_xbin)\n",
    "                ybins, xbins = np.histogram(profiles[p], \n",
    "                                            bins=range_xbin)\n",
    "                axs[p].hist(profiles[p], bins=range_xbin)\n",
    "                axs[p].annotate('x = '+str(p)+', '+str(round((p-20)*pixelscale,1))+'$^{\\prime\\prime}$', xy=(0.01,0.8), xycoords='axes fraction')\n",
    "                second_max = ybins.sort()[-2]\n",
    "                axs[p].ylim([0,second_max])\n",
    "            else:\n",
    "                axs[p].annotate('x = '+str(p)+', '+str(round((p-20)*pixelscale,1))+'$^{\\prime\\prime}$', xy=(0.01,0.8), xycoords='axes fraction')\n",
    "            \n",
    "        else:\n",
    "            print('does not exist', p)\n",
    "            axs[p].annotate('x = '+str(p)+', '+str(round((p-20)*pixelscale,1))+'$^{\\prime\\prime}$', xy=(0.01,0.8), xycoords='axes fraction')\n",
    "            \n",
    "    plt.savefig('slit0.png')\n",
    "\n",
    "\n",
    "    # OMG is there a way to do this in KDE space?\n",
    "    # the name for this is a ridge plot\n",
    "    plt.clf()\n",
    "    colors = ['#0000ff', '#3300cc', '#660099', '#990066', '#cc0033', '#ff0000',\n",
    "              '#0000ff', '#3300cc', '#660099', '#990066', '#cc0033', '#ff0000',\n",
    "              '#0000ff', '#3300cc', '#660099', '#990066', '#cc0033', '#ff0000',\n",
    "              '#0000ff', '#3300cc', '#660099', '#990066', '#cc0033', '#ff0000',\n",
    "              '#0000ff', '#3300cc', '#660099', '#990066', '#cc0033', '#ff0000',\n",
    "              '#0000ff', '#3300cc', '#660099', '#990066', '#cc0033', '#ff0000',\n",
    "              '#0000ff', '#3300cc', '#660099', '#990066', '#cc0033', '#ff0000']\n",
    "\n",
    "\n",
    "    gs = grid_spec.GridSpec(len(profiles),1)\n",
    "    fig = plt.figure(figsize=(16,9))\n",
    "    \n",
    "    ax_objs = []\n",
    "    i = 0\n",
    "    \n",
    "    for profile in profiles:\n",
    "        profile = profiles[i]\n",
    "        hist_y, hist_bins = np.histogram(profile)\n",
    "        x = np.array(hist_bins)\n",
    "        \n",
    "        if x[0] == 0:\n",
    "            i += 1\n",
    "            continue\n",
    "        x_d = np.linspace(-300,300, 1000)\n",
    "        kde = KernelDensity(bandwidth=10, kernel='gaussian')\n",
    "        kde.fit(x[:,None])\n",
    "\n",
    "        logprob = kde.score_samples(x_d[:, None])\n",
    "        # creating new axes object\n",
    "        ax_objs.append(fig.add_subplot(gs[i:i+1, 0:]))\n",
    "\n",
    "    \n",
    "        # plotting the distribution\n",
    "        ax_objs[-1].plot(x_d, np.exp(logprob),color=\"#f0f0f0\",lw=1)\n",
    "        ax_objs[-1].fill_between(x_d, np.exp(logprob), alpha=1,color=colors[i])\n",
    "\n",
    "        # setting uniform x and y lims\n",
    "        ax_objs[-1].set_xlim(-300,300)\n",
    "        #ax_objs[-1].set_ylim(0,2.5)\n",
    "\n",
    "        # make background transparent\n",
    "        rect = ax_objs[-1].patch\n",
    "        rect.set_alpha(0)\n",
    "\n",
    "        # remove borders, axis ticks, and labels\n",
    "        ax_objs[-1].set_yticklabels([])\n",
    "\n",
    "        if i == len(profiles)-1:\n",
    "            ax_objs[-1].set_xlabel(\"Velocity [km s$^{-1}$]\", fontsize=16,fontweight=\"bold\")\n",
    "        else:\n",
    "            ax_objs[-1].set_xticklabels([])\n",
    "\n",
    "        spines = [\"top\",\"right\",\"left\",\"bottom\"]\n",
    "        for s in spines:\n",
    "            ax_objs[-1].spines[s].set_visible(False)\n",
    "\n",
    "            \n",
    "        ax_objs[-1].text(-300,0,str(combo_slit[i]),fontweight=\"bold\",fontsize=14,ha=\"right\")\n",
    "\n",
    "\n",
    "        i += 1\n",
    "\n",
    "    gs.update(hspace=-0.7)\n",
    "\n",
    "    fig.text(0.07,0.85,\"Distribution of Aptitude Test Results from 18 – 24 year-olds\",fontsize=20)\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('ridgeplot.png')\n",
    "\n",
    "        \n",
    "        \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    STOP\n",
    "\n",
    "   \n",
    "    # this seems too slow:\n",
    "    \n",
    "\n",
    "    point = (Point(0.5, 0.5),Point(0.5, 0.5))\n",
    "    polygon = Polygon(corners_rotated)\n",
    "    #Polygon([(0, 0), (0, 1), (1, 1), (1, 0)])\n",
    "    points_plural = [merged_x, merged_y]\n",
    "    print(polygon.contains(ST_Collect(Point(0.5, 0.5),Point(0.5, 0.5))))\n",
    "    \n",
    "    STOP\n",
    "\n",
    "    plt.clf()\n",
    "    plt.scatter(xs_cont_1, ys_cont_1, c=vel_cont_1)\n",
    "    plt.colorbar()\n",
    "    plt.savefig('diag_slit1.png')\n",
    "\n",
    "\n",
    "    plt.clf()\n",
    "    plt.scatter(xs_cont_2, ys_cont_2, c=vel_cont_2)\n",
    "    plt.colorbar()\n",
    "    plt.savefig('diag_slit2.png')\n",
    "    STOP\n",
    "\n",
    "    \n",
    "    r_slit_1_above=[]\n",
    "    v_slit_1_above=[]\n",
    "    r_slit_2_above=[]\n",
    "    v_slit_2_above=[]\n",
    "    r_slit_1_below=[]\n",
    "    v_slit_1_below=[]\n",
    "    r_slit_2_below=[]\n",
    "    v_slit_2_below=[]\n",
    "\n",
    "    mask_slit_1_above=[]\n",
    "    mask_slit_2_above=[]\n",
    "    mask_slit_1_below=[]\n",
    "    mask_slit_2_below=[]\n",
    "\n",
    "\n",
    "    stepping=1\n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "    length=max((upper_lim-lower_lim),(upper_lim_ortho-lower_lim_ortho))\n",
    "\n",
    "    if PA1 < 90:\n",
    "        additive=np.pi/2\n",
    "    else:\n",
    "        additive=np.pi/2\n",
    "    for j in range(length):\n",
    "        #\n",
    "        width=pixelscale_1*j\n",
    "        \n",
    "        z_1_perp_upper=[-x*(1/np.tan(PA_obs_1))+(width+1.5*pixelscale_1)/np.cos(PA_obs_1+additive) for x in xs_cont_1]\n",
    "        z_1_perp_lower=[-x*(1/np.tan(PA_obs_1))+(width+0.5*pixelscale_1)/np.cos(PA_obs_1+additive) for x in xs_cont_1]\n",
    "        z_1_perpl_upper=[-x*(1/np.tan(PA_obs_1))-(width+0.5*pixelscale_1)/np.cos(PA_obs_1+additive) for x in xs_cont_1]\n",
    "        z_1_perpl_lower=[-x*(1/np.tan(PA_obs_1))-(width+1.5*pixelscale_1)/np.cos(PA_obs_1+additive) for x in xs_cont_1]\n",
    "\n",
    "\n",
    "        if PA1 < 90:\n",
    "            pos_1=np.logical_and((np.asarray(zs_cont_1) > np.asarray(z_1_perp_upper)), (np.asarray(zs_cont_1) < np.asarray(z_1_perp_lower)))\n",
    "            pos_1_1=np.logical_and((np.asarray(zs_cont_1) > np.asarray(z_1_perpl_upper)), (np.asarray(zs_cont_1) < np.asarray(z_1_perpl_lower)))\n",
    "            pos_1_center=np.logical_and((np.asarray(zs_cont_1) < np.asarray(z_1_perpl_upper)), (np.asarray(zs_cont_1) > np.asarray(z_1_perp_lower)))\n",
    "        else:\n",
    "            pos_1=np.logical_and((np.asarray(zs_cont_1) < np.asarray(z_1_perp_upper)), (np.asarray(zs_cont_1) > np.asarray(z_1_perp_lower)))\n",
    "            pos_1_1=np.logical_and((np.asarray(zs_cont_1) < np.asarray(z_1_perpl_upper)), (np.asarray(zs_cont_1) > np.asarray(z_1_perpl_lower)))\n",
    "            pos_1_center=np.logical_and((np.asarray(zs_cont_1) > np.asarray(z_1_perpl_upper)), (np.asarray(zs_cont_1) < np.asarray(z_1_perp_lower)))\n",
    "        \n",
    "        \n",
    "       \n",
    "\n",
    "        if j==0:\n",
    "            xs_cont_slit_middle=np.asarray(xs_cont_1)[np.asarray(pos_1_center)]\n",
    "            zs_cont_slit_middle=np.asarray(zs_cont_1)[np.asarray(pos_1_center)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit_middle)**2+np.mean(zs_cont_slit_middle)**2))==True:\n",
    "                r_slit_1_above.append(j)\n",
    "                v_slit_1_above.append(10)\n",
    "                mask_slit_1_above.append(1)\n",
    "\n",
    "            else:\n",
    "                #so this is the positions to the North so we'll make them negative\n",
    "                r_slit_1_above.append(j)\n",
    "                v_slit_1_above.append(np.mean(np.asarray(vel_cont_1)[np.asarray(pos_1_center)]))\n",
    "                mask_slit_1_above.append(0)\n",
    "        else:\n",
    "            xs_cont_slit=np.asarray(xs_cont_1)[np.asarray(pos_1)]\n",
    "            zs_cont_slit=np.asarray(zs_cont_1)[np.asarray(pos_1)]\n",
    "\n",
    "\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))==True:\n",
    "\n",
    "                r_slit_1_above.append(j)\n",
    "                v_slit_1_above.append(10)\n",
    "                mask_slit_1_above.append(1)\n",
    "            else:\n",
    "                #so this is the positions to the North so we'll make them negative\n",
    "                r_slit_1_above.append(j)\n",
    "                v_slit_1_above.append(np.mean(np.asarray(vel_cont_1)[np.asarray(pos_1)]))\n",
    "                mask_slit_1_above.append(0)\n",
    "                #r_slit_1_above.append(np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))\n",
    "                #v_slit_1_above.append(np.mean(np.asarray(vel_cont_1)[np.asarray(pos_1)]))\n",
    "\n",
    "\n",
    "            xs_cont_slit=np.asarray(xs_cont_1)[np.asarray(pos_1_1)]\n",
    "            zs_cont_slit=np.asarray(zs_cont_1)[np.asarray(pos_1_1)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))==True:\n",
    "\n",
    "                r_slit_1_above.append(-j)\n",
    "                v_slit_1_above.append(10)\n",
    "                mask_slit_1_above.append(1)\n",
    "            else:\n",
    "                r_slit_1_above.append(-j)\n",
    "                #r_slit_1_above.append(-np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))\n",
    "                #r_slit_1_above.append(-np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))\n",
    "                v_slit_1_above.append(np.mean(np.asarray(vel_cont_1)[np.asarray(pos_1_1)]))\n",
    "                mask_slit_1_above.append(0)\n",
    "\n",
    "        z_1_perp_upper=[-x*(1/np.tan(PA_obs_1))+(width+1.5*pixelscale_1)/np.cos(PA_obs_1+additive) for x in xs_cont_1_below]\n",
    "        z_1_perp_lower=[-x*(1/np.tan(PA_obs_1))+(width+0.5*pixelscale_1)/np.cos(PA_obs_1+additive) for x in xs_cont_1_below]\n",
    "        z_1_perpl_upper=[-x*(1/np.tan(PA_obs_1))-(width+0.5*pixelscale_1)/np.cos(PA_obs_1+additive) for x in xs_cont_1_below]\n",
    "        z_1_perpl_lower=[-x*(1/np.tan(PA_obs_1))-(width+1.5*pixelscale_1)/np.cos(PA_obs_1+additive) for x in xs_cont_1_below]\n",
    "        \n",
    "        if PA1 < 90:\n",
    "            pos_1_below=np.logical_and((np.asarray(zs_cont_1_below) > np.asarray(z_1_perp_upper)), (np.asarray(zs_cont_1_below) < np.asarray(z_1_perp_lower)))\n",
    "            pos_1_below_1=np.logical_and((np.asarray(zs_cont_1_below) > np.asarray(z_1_perpl_upper)), (np.asarray(zs_cont_1_below) < np.asarray(z_1_perpl_lower)))\n",
    "            pos_1_below_center=np.logical_and((np.asarray(zs_cont_1_below) < np.asarray(z_1_perpl_upper)), (np.asarray(zs_cont_1_below) > np.asarray(z_1_perp_lower)))\n",
    "        else:\n",
    "            pos_1_below=np.logical_and((np.asarray(zs_cont_1_below) < np.asarray(z_1_perp_upper)), (np.asarray(zs_cont_1_below) > np.asarray(z_1_perp_lower)))\n",
    "            pos_1_below_1=np.logical_and((np.asarray(zs_cont_1_below) < np.asarray(z_1_perpl_upper)), (np.asarray(zs_cont_1_below) > np.asarray(z_1_perpl_lower)))\n",
    "            pos_1_below_center=np.logical_and((np.asarray(zs_cont_1_below) > np.asarray(z_1_perpl_upper)), (np.asarray(zs_cont_1_below) < np.asarray(z_1_perp_lower)))\n",
    "\n",
    "        if j==0:\n",
    "            xs_cont_slit_middle=np.asarray(xs_cont_1_below)[np.asarray(pos_1_below_center)]\n",
    "            zs_cont_slit_middle=np.asarray(zs_cont_1_below)[np.asarray(pos_1_below_center)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit_middle)**2+np.mean(zs_cont_slit_middle)**2))==True:\n",
    "                r_slit_1_below.append(j)\n",
    "                v_slit_1_below.append(10)\n",
    "                mask_slit_1_below.append(1)\n",
    "\n",
    "            else:\n",
    "                #so this is the positions to the North so we'll make them negative\n",
    "                r_slit_1_below.append(j)\n",
    "                v_slit_1_below.append(np.mean(np.asarray(vel_cont_1_below)[np.asarray(pos_1_below_center)]))\n",
    "                mask_slit_1_below.append(0)\n",
    "        else:\n",
    "\n",
    "            xs_cont_slit=np.asarray(xs_cont_1_below)[np.asarray(pos_1_below)]\n",
    "            zs_cont_slit=np.asarray(zs_cont_1_below)[np.asarray(pos_1_below)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))==True:\n",
    "                r_slit_1_below.append(j)\n",
    "                v_slit_1_below.append(10)\n",
    "                mask_slit_1_below.append(1)\n",
    "\n",
    "            else:\n",
    "                r_slit_1_below.append(j)\n",
    "                v_slit_1_below.append(np.mean(np.asarray(vel_cont_1_below)[np.asarray(pos_1_below)]))\n",
    "                mask_slit_1_below.append(0)\n",
    "\n",
    "            xs_cont_slit=np.asarray(xs_cont_1_below)[np.asarray(pos_1_below_1)]\n",
    "            zs_cont_slit=np.asarray(zs_cont_1_below)[np.asarray(pos_1_below_1)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2)):\n",
    "                r_slit_1_below.append(-j)\n",
    "                v_slit_1_below.append(10)\n",
    "                mask_slit_1_below.append(1)\n",
    "\n",
    "            else:\n",
    "                r_slit_1_below.append(-j)\n",
    "                v_slit_1_below.append(np.mean(np.asarray(vel_cont_1_below)[np.asarray(pos_1_below_1)]))\n",
    "                mask_slit_1_below.append(0)\n",
    "\n",
    "        '''Now PA 2 which is greater than 90'''\n",
    "        width=pixelscale_2*j\n",
    "\n",
    "        z_2_perp_upper=[-x*(1/np.tan(PA_obs_2))+(width+1.5*pixelscale_2)/np.cos(PA_obs_2+additive) for x in xs_cont_2]\n",
    "        z_2_perp_lower=[-x*(1/np.tan(PA_obs_2))+(width+0.5*pixelscale_2)/np.cos(PA_obs_2+additive) for x in xs_cont_2]\n",
    "        z_2_perpl_upper=[-x*(1/np.tan(PA_obs_2))-(width+0.5*pixelscale_2)/np.cos(PA_obs_2+additive) for x in xs_cont_2]\n",
    "        z_2_perpl_lower=[-x*(1/np.tan(PA_obs_2))-(width+1.5*pixelscale_2)/np.cos(PA_obs_2+additive) for x in xs_cont_2]\n",
    "        \n",
    "        \n",
    "        if PA2 > 90:\n",
    "            pos_1_2=np.logical_and((np.asarray(zs_cont_2) < np.asarray(z_2_perp_upper)), (np.asarray(zs_cont_2) > np.asarray(z_2_perp_lower)))\n",
    "            pos_1_3=np.logical_and((np.asarray(zs_cont_2) < np.asarray(z_2_perpl_upper)), (np.asarray(zs_cont_2)> np.asarray(z_2_perpl_lower)))\n",
    "\n",
    "            pos_1_2_center=np.logical_and((np.asarray(zs_cont_2) > np.asarray(z_2_perpl_upper)), (np.asarray(zs_cont_2) < np.asarray(z_2_perp_lower)))\n",
    "        else:\n",
    "            pos_1_2=np.logical_and((np.asarray(zs_cont_2) > np.asarray(z_2_perp_upper)), (np.asarray(zs_cont_2) < np.asarray(z_2_perp_lower)))\n",
    "            pos_1_3=np.logical_and((np.asarray(zs_cont_2) > np.asarray(z_2_perpl_upper)), (np.asarray(zs_cont_2)< np.asarray(z_2_perpl_lower)))\n",
    "\n",
    "            pos_1_2_center=np.logical_and((np.asarray(zs_cont_2) < np.asarray(z_2_perpl_upper)), (np.asarray(zs_cont_2) > np.asarray(z_2_perp_lower)))\n",
    "        #\n",
    "        \n",
    "        #if j==0:\n",
    "            #plt.plot(xs_cont_2, z_2_perp_upper, label='z_1_perp_upper',lw=4, color='black')\n",
    "            #plt.plot(xs_cont_2, z_2_perp_lower, label='z_2_perp_lower',lw=4,ls='--', color='red')\n",
    "            #plt.plot(xs_cont_2, z_2_perpl_upper, label='z_2_perpl_upper',lw=4, color='pink')\n",
    "            #plt.show()\n",
    "        if j==0:\n",
    "            xs_cont_slit_middle=np.asarray(xs_cont_2)[np.asarray(pos_1_2_center)]\n",
    "            zs_cont_slit_middle=np.asarray(zs_cont_2)[np.asarray(pos_1_2_center)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit_middle)**2+np.mean(zs_cont_slit_middle)**2))==True:\n",
    "\n",
    "                r_slit_2_above.append(j)\n",
    "                v_slit_2_above.append(10)\n",
    "                mask_slit_2_above.append(1)\n",
    "\n",
    "            else:\n",
    "                #so this is the positions to the North so we'll make them negative\n",
    "                r_slit_2_above.append(j)\n",
    "                v_slit_2_above.append(np.mean(np.asarray(vel_cont_2)[np.asarray(pos_1_2_center)]))\n",
    "                mask_slit_2_above.append(0)\n",
    "        else:\n",
    "\n",
    "            xs_cont_slit=np.asarray(xs_cont_2)[np.asarray(pos_1_2)]\n",
    "            zs_cont_slit=np.asarray(zs_cont_2)[np.asarray(pos_1_2)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))==True:\n",
    "                r_slit_2_above.append(j)\n",
    "                v_slit_2_above.append(10)\n",
    "                mask_slit_2_above.append(1)\n",
    "\n",
    "            else:\n",
    "                r_slit_2_above.append(j)\n",
    "                v_slit_2_above.append(np.mean(np.asarray(vel_cont_2)[np.asarray(pos_1_2)]))\n",
    "                mask_slit_2_above.append(0)\n",
    "\n",
    "            xs_cont_slit=np.asarray(xs_cont_2)[np.asarray(pos_1_3)]\n",
    "            zs_cont_slit=np.asarray(zs_cont_2)[np.asarray(pos_1_3)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))==True:\n",
    "\n",
    "                r_slit_2_above.append(-j)\n",
    "                v_slit_2_above.append(10)\n",
    "                mask_slit_2_above.append(1)\n",
    "\n",
    "            else:\n",
    "                r_slit_2_above.append(-j)\n",
    "                v_slit_2_above.append(np.mean(np.asarray(vel_cont_2)[np.asarray(pos_1_3)]))\n",
    "                mask_slit_2_above.append(0)\n",
    "            #math.isnan(np.mean(np.asarray(vel_cont_2)[np.asarray(pos_1_3)])):\n",
    "\n",
    "\n",
    "\n",
    "        z_2_perp_upper=[-x*(1/np.tan(PA_obs_2))+(width+1.5*pixelscale_2)/np.cos(PA_obs_2+additive) for x in xs_cont_2_below]\n",
    "        z_2_perp_lower=[-x*(1/np.tan(PA_obs_2))+(width+0.5*pixelscale_2)/np.cos(PA_obs_2+additive) for x in xs_cont_2_below]\n",
    "        z_2_perpl_upper=[-x*(1/np.tan(PA_obs_2))-(width+0.5*pixelscale_2)/np.cos(PA_obs_2+additive) for x in xs_cont_2_below]\n",
    "        z_2_perpl_lower=[-x*(1/np.tan(PA_obs_2))-(width+1.5*pixelscale_2)/np.cos(PA_obs_2+additive) for x in xs_cont_2_below]\n",
    "\n",
    "        \n",
    "        if PA2 >  90:\n",
    "            pos_1_4=np.logical_and((np.asarray(zs_cont_2_below) < np.asarray(z_2_perp_upper)), (np.asarray(zs_cont_2_below) > np.asarray(z_2_perp_lower)))\n",
    "            pos_1_5=np.logical_and((np.asarray(zs_cont_2_below) < np.asarray(z_2_perpl_upper)), (np.asarray(zs_cont_2_below) > np.asarray(z_2_perpl_lower)))\n",
    "            pos_1_4_center=np.logical_and((np.asarray(zs_cont_2_below) > np.asarray(z_2_perpl_upper)), (np.asarray(zs_cont_2_below) < np.asarray(z_2_perp_lower)))\n",
    "        else:\n",
    "            pos_1_4=np.logical_and((np.asarray(zs_cont_2_below) > np.asarray(z_2_perp_upper)), (np.asarray(zs_cont_2_below) < np.asarray(z_2_perp_lower)))\n",
    "            pos_1_5=np.logical_and((np.asarray(zs_cont_2_below) > np.asarray(z_2_perpl_upper)), (np.asarray(zs_cont_2_below) < np.asarray(z_2_perpl_lower)))\n",
    "            pos_1_4_center=np.logical_and((np.asarray(zs_cont_2_below) < np.asarray(z_2_perpl_upper)), (np.asarray(zs_cont_2_below) > np.asarray(z_2_perp_lower)))\n",
    "\n",
    "\n",
    "        if j==0:\n",
    "            xs_cont_slit_middle=np.asarray(xs_cont_2_below)[np.asarray(pos_1_4_center)]\n",
    "            zs_cont_slit_middle=np.asarray(zs_cont_2_below)[np.asarray(pos_1_4_center)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit_middle)**2+np.mean(zs_cont_slit_middle)**2))==True:\n",
    "\n",
    "                r_slit_2_below.append(j)\n",
    "                v_slit_2_below.append(10)\n",
    "                mask_slit_2_below.append(1)\n",
    "            else:\n",
    "                #so this is the positions to the North so we'll make them negative\n",
    "                r_slit_2_below.append(j)\n",
    "                v_slit_2_below.append(np.mean(np.asarray(vel_cont_2_below)[np.asarray(pos_1_4_center)]))\n",
    "                mask_slit_2_below.append(0)\n",
    "        else:\n",
    "\n",
    "            xs_cont_slit=np.asarray(xs_cont_2_below)[np.asarray(pos_1_4)]\n",
    "            zs_cont_slit=np.asarray(zs_cont_2_below)[np.asarray(pos_1_4)]\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))==True:\n",
    "                r_slit_2_below.append(j)\n",
    "                v_slit_2_below.append(10)\n",
    "                mask_slit_2_below.append(1)\n",
    "\n",
    "            else:\n",
    "                r_slit_2_below.append(j)\n",
    "                v_slit_2_below.append(np.mean(np.asarray(vel_cont_2_below)[np.asarray(pos_1_4)]))\n",
    "                mask_slit_2_below.append(0)\n",
    "\n",
    "            xs_cont_slit=np.asarray(xs_cont_2_below)[np.asarray(pos_1_5)]\n",
    "            zs_cont_slit=np.asarray(zs_cont_2_below)[np.asarray(pos_1_5)]\n",
    "\n",
    "            if math.isnan(np.sqrt(np.mean(xs_cont_slit)**2+np.mean(zs_cont_slit)**2))==True:\n",
    "\n",
    "                r_slit_2_below.append(-j)\n",
    "                v_slit_2_below.append(10)\n",
    "                mask_slit_2_below.append(1)\n",
    "\n",
    "            else:\n",
    "                r_slit_2_below.append(-j)\n",
    "                v_slit_2_below.append(np.mean(np.asarray(vel_cont_2_below)[np.asarray(pos_1_5)]))\n",
    "                mask_slit_2_below.append(0)\n",
    "\n",
    "\n",
    "\n",
    "    inds = np.array(r_slit_1_above).argsort()\n",
    "    sortedx_1_above = np.array(r_slit_1_above)[inds]#-minus_one\n",
    "    sortedv_1_above = np.array(v_slit_1_above)[inds]\n",
    "\n",
    "    sorted_mask = np.array(mask_slit_1_above)[inds]\n",
    "\n",
    "    m_sortedx_1_above = ma.masked_array(sortedx_1_above, mask=sorted_mask)\n",
    "    m_sortedv_1_above = ma.masked_array(sortedv_1_above, mask=sorted_mask)\n",
    "\n",
    "    inds = np.array(r_slit_1_below).argsort()\n",
    "    sortedx_1_below = np.array(r_slit_1_below)[inds]\n",
    "    sortedv_1_below = np.array(v_slit_1_below)[inds]\n",
    "\n",
    "    sorted_mask = np.array(mask_slit_1_below)[inds]\n",
    "\n",
    "    m_sortedx_1_below = ma.masked_array(sortedx_1_below, mask=sorted_mask)\n",
    "    m_sortedv_1_below = ma.masked_array(sortedv_1_below, mask=sorted_mask)\n",
    "\n",
    "    inds = np.array(r_slit_2_above).argsort()\n",
    "    sortedx_2_above = np.array(r_slit_2_above)[inds]\n",
    "    sortedv_2_above = np.array(v_slit_2_above)[inds]\n",
    "\n",
    "    sorted_mask = np.array(mask_slit_2_above)[inds]\n",
    "\n",
    "    m_sortedx_2_above = ma.masked_array(sortedx_2_above, mask=sorted_mask)\n",
    "    m_sortedv_2_above = ma.masked_array(sortedv_2_above, mask=sorted_mask)\n",
    "\n",
    "    inds = np.array(r_slit_2_below).argsort()\n",
    "    sortedx_2_below = np.array(r_slit_2_below)[inds]\n",
    "    sortedv_2_below = np.array(v_slit_2_below)[inds]\n",
    "\n",
    "    sorted_mask = np.array(mask_slit_2_below)[inds]\n",
    "\n",
    "    m_sortedx_2_below = ma.masked_array(sortedx_2_below, mask=sorted_mask)\n",
    "    m_sortedv_2_below = ma.masked_array(sortedv_2_below, mask=sorted_mask)\n",
    "\n",
    "\n",
    "\n",
    "    '''Okay so we need to cut this according to the xs_data_concat array'''\n",
    "    first=xs_data[lower_lim:upper_lim][0]\n",
    "    last=xs_data[lower_lim:upper_lim][-1]\n",
    "    for z in range(len(m_sortedx_1_below)):\n",
    "        if sortedx_1_below[z]==first:\n",
    "            i_b_first=z\n",
    "        if sortedx_1_below[z]==last:\n",
    "            i_b_last=z+1\n",
    "\n",
    "    for z in range(len(m_sortedx_1_above)):\n",
    "        if sortedx_1_above[z]==first:\n",
    "            i_a_first=z\n",
    "        if sortedx_1_above[z]==last:\n",
    "            i_a_last=z+1\n",
    "\n",
    "\n",
    "    xs_fit_concat=np.ma.concatenate([m_sortedx_1_below[i_b_first:i_b_last],m_sortedx_1_above[i_a_first:i_a_last]])#xs_fit_bin+xs_fit_bin_below\n",
    "    vs_fit_concat=np.ma.concatenate([m_sortedv_1_below[i_b_first:i_b_last],m_sortedv_1_above[i_a_first:i_a_last]])#vs_fit_bin+vs_fit_bin_below\n",
    "\n",
    "    first=xs_data_ortho[lower_lim_ortho:upper_lim_ortho][0]\n",
    "    last=xs_data_ortho[lower_lim_ortho:upper_lim_ortho][-1]\n",
    "\n",
    "    '''find index where m_sortedx_1_below and same for above have the values of first and last and cut it there'''\n",
    "    for z in range(len(m_sortedx_2_below)):\n",
    "        if sortedx_2_below[z]==first:\n",
    "            i_b_first=z\n",
    "        if sortedx_2_below[z]==last:\n",
    "            i_b_last=z+1\n",
    "\n",
    "    for z in range(len(m_sortedx_2_above)):\n",
    "        if sortedx_2_above[z]==first:\n",
    "            i_a_first=z\n",
    "        if sortedx_2_above[z]==last:\n",
    "            i_a_last=z+1\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    xs_fit_concat_ortho=np.ma.concatenate([m_sortedx_2_below[i_b_first:i_b_last],m_sortedx_2_above[i_a_first:i_a_last]])#xs_fit_ortho_bin+xs_fit_ortho_bin_below\n",
    "    vs_fit_concat_ortho=np.ma.concatenate([m_sortedv_2_below[i_b_first:i_b_last],m_sortedv_2_above[i_a_first:i_a_last]])#vs_fit_ortho_bin+vs_fit_ortho_bin_below\n",
    "\n",
    "\n",
    "    xs_data_concat_arc=[x*pixelscale for x in xs_data_concat]\n",
    "    xs_data_concat_ortho_arc=[x*pixelscale for x in xs_data_concat_ortho]\n",
    "    xs_fit_concat_arc=[x*pixelscale for x in xs_fit_concat]\n",
    "    xs_fit_concat_ortho_arc=[x*pixelscale for x in xs_fit_concat_ortho]\n",
    "\n",
    " \n",
    "    \n",
    "    \n",
    "    resid_alt_1=[]\n",
    "    resid_alt_2=[]\n",
    "\n",
    "    sum_masked=[]\n",
    "    for i in range(len(vs_fit_concat)):\n",
    "        if vs_fit_concat[i] is ma.masked:\n",
    "            sum_masked.append(1)\n",
    "        else:\n",
    "            resid_alt_1.append(-0.5*(((vs_fit_concat[i]-vel_data_concat[i])**2)/(np.sqrt((np.sqrt(error_data_concat[0][i]**2+error_data_concat[1][i]**2))**2+2.5**2))**2))\n",
    "    for i in range(len(vs_fit_concat_ortho)):\n",
    "        if vs_fit_concat_ortho[i] is ma.masked:\n",
    "            sum_masked.append(1)\n",
    "        else:\n",
    "            resid_alt_2.append(-0.5*(((vs_fit_concat_ortho[i]-vel_data_concat_ortho[i])**2)/(np.sqrt((np.sqrt(error_data_concat_ortho[0][i]**2+error_data_concat_ortho[1][i]**2))**2+2.5**2))**2))\n",
    "\n",
    "    masked_elements_sum=2*np.sum(sum_masked)\n",
    "\n",
    "    resid_alt_concat=resid_alt_1+resid_alt_2\n",
    "    #resid_concat=resid_1+resid_2\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    n=2*(upper_lim-lower_lim+upper_lim_ortho-lower_lim_ortho)\n",
    "    k=5\n",
    "\n",
    "\n",
    "\n",
    "    return np.sum(resid_alt_concat)/(n-k-1-masked_elements_sum)\n",
    "\n",
    "# I need the SAURON cmap (from Eric Emsellem)\n",
    "#!/usr/bin/python - https://github.com/emsellem/pygme/blob/master/pygme/colormaps/mycolormap.py\n",
    "\"\"\"\n",
    "This module is useful to define ColourMaps in matplotlib\n",
    "Here we define the SAURON color map, which is useful\n",
    "as a rainbow colour map without too much green\n",
    "(good for velocity fields)\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "Importing the required modules\n",
    "\"\"\"\n",
    "\n",
    "################################################################################################\n",
    "# FIXED data\n",
    "################################################################################################\n",
    "## Values for the interpolated Sauron colour map\n",
    "xSauronCOL = np.array([1.0, 43.5, 86.0, 86.0+20, 128.5-10, 128.5, 128.5+10, 171.0-20, 171.0, 213.5, 256.0])\n",
    "SauronRed =   [0.0, 0.0, 0.4,  0.5, 0.3, 0.0, 0.7, 1.0, 1.0,  1.0, 0.9]\n",
    "SauronGreen = [0.0, 0.0, 0.85, 1.0, 1.0, 0.9, 1.0, 1.0, 0.85, 0.0, 0.9]\n",
    "SauronBlue =  [0.0, 1.0, 1.0,  1.0, 0.7, 0.0, 0.0, 0.0, 0.0,  0.0, 0.9]\n",
    "\n",
    "################################################################################################\n",
    "# Define the Sauron colour map\n",
    "################################################################################################\n",
    "def get_SauronCmap() :\n",
    "    \"\"\"\n",
    "    Define the Sauron color maps and return it \n",
    "    (as a cmap from matplotlib)\n",
    "    \"\"\"\n",
    "    Nseg = len(xSauronCOL)\n",
    "    Nm1 = np.max(xSauronCOL) - 1.0\n",
    "    xSauronN = (xSauronCOL - 1.0) / Nm1\n",
    "    redtup = ()\n",
    "    greentup = ()\n",
    "    bluetup = ()\n",
    "    for i in range(Nseg) :\n",
    "        redtup = redtup + ((xSauronN[i],SauronRed[i],SauronRed[i]),)\n",
    "        greentup = greentup + ((xSauronN[i],SauronGreen[i],SauronGreen[i]),)\n",
    "        bluetup = bluetup + ((xSauronN[i],SauronBlue[i],SauronBlue[i]),)\n",
    "\n",
    "    cdict =  {'red': redtup, 'green': greentup, 'blue': bluetup}\n",
    "    sauron_cmap = matplotlib.colors.LinearSegmentedColormap('Sauron_colormap',cdict,256)\n",
    "    plt.register_cmap(name=\"Sauron\", cmap=sauron_cmap)\n",
    "    return sauron_cmap\n",
    "\n",
    "print('compiled')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "compiled\n"
     ]
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "\n",
    "# This function will project the x positions in arcsec into x and y\n",
    "def project_xy(PA_cen, PA_list, xs_data_list):\n",
    "    #plt.clf()\n",
    "    new_x_list = []\n",
    "    new_y_list = []\n",
    "    for n in range(len(PA_list)):\n",
    "        xcen = PA_cen[n][0]\n",
    "        ycen = PA_cen[n][1]\n",
    "        # Okay so make a list of coordinates that define each slit center\n",
    "        # and then for each one define the four corners\n",
    "        PA_obs = PA_list[n]\n",
    "        \n",
    "        xs_here = xs_data_list[n]\n",
    "        \n",
    "        new_x = [np.cos(math.radians(PA_obs+90))*(x) + xcen for x in xs_here]\n",
    "        new_y = [np.sin(math.radians(PA_obs+90))*(x) + ycen for x in xs_here]\n",
    "        new_x_list.append(new_x)\n",
    "        new_y_list.append(new_y)\n",
    "        \n",
    "        #plt.scatter(new_x, new_y)\n",
    "    #plt.show()\n",
    "    return new_x_list, new_y_list\n",
    "\n",
    "\n",
    "# So with this function I would like to output a list of four coordinates (in the x and y plane)\n",
    "# that correspond to the edges of each spatial element, center on \n",
    "# number_pos is 20 in our case where there are 20 spatial elements on each side; it can be adjusted\n",
    "\n",
    "# This can be replaced by another function that, say, generates coordinates, such as\n",
    "# the edges of spaxels in an IFS map.\n",
    "def a_function_that_computes_bounds(xs_proj, ys_proj, PA_cen, PA_list,  slitwidth, width, color_list):\n",
    "    height=slitwidth\n",
    "    \n",
    "    plt.clf()\n",
    "    \n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    \n",
    "    ax.set_aspect(aspect=1)\n",
    "    #ax.set_xlim([-5,5])\n",
    "    #ax.set_ylim([-5,5])\n",
    "    ax.set_xlabel('Arcsec')\n",
    "    ax.set_ylabel('Arcsec')\n",
    "    \n",
    "    polygon_list = []#{key:[] for key in range(len(xs_proj))}\n",
    "    \n",
    "    for n in range(len(xs_proj)):\n",
    "        x_slit = xs_proj[n]\n",
    "        y_slit = ys_proj[n]\n",
    "        \n",
    "        PA_obs = PA_list[n]\n",
    "        \n",
    "        if PA_obs < 90:\n",
    "            PA_obs_use = (90-PA_obs) +90\n",
    "        else:\n",
    "            if PA_obs > 90 and PA_obs < 180:\n",
    "                PA_obs_use = PA_obs - 90\n",
    "        \n",
    "        \n",
    "        \n",
    "        ax.scatter(x_slit, y_slit, edgecolor='black', color='white', s=20)\n",
    "        \n",
    "        #ax.scatter(x_slit_1_center, y_slit_1_center, edgecolor='black', color='white', s=10)\n",
    "        \n",
    "\n",
    "        \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "        # okay so for each of these centers, construct an array that has all four points of the edge,\n",
    "        # then find all points within that\n",
    "        profiles=[]\n",
    "        mean_vel = []\n",
    "        polygon_pts = []\n",
    "        \n",
    "        #print('this is wat you are using to rotate', -(PA_obs_use), PA_obs)\n",
    "        \n",
    "        for p in range(len(x_slit)):\n",
    "            # okay so to form the triangle you have to rotate the points about the 'origin', which is the slit center\n",
    "            # the origin is defined by x_slit_1_center and y_slit_1_center\n",
    "            \n",
    "            origin = (x_slit[p],y_slit[p])\n",
    "            #if abs(origin[0]) > 0.5:\n",
    "            #    continue\n",
    "            corners = [(0.5*height+x_slit[p], width/2+y_slit[p]),(0.5*height+x_slit[p],-width/2+y_slit[p]),(-0.5*height+x_slit[p], width/2+y_slit[p]), (-0.5*height+x_slit[p],-width/2+y_slit[p])]\n",
    "            if -PA_obs_use < -90:\n",
    "                corners_rotated = [(origin[0] + np.cos(math.radians(-(PA_obs_use)))*(x[0] - origin[0]) - np.sin(math.radians(-(PA_obs_use)))*(x[1] - origin[1]),origin[1] + np.sin(math.radians(-(PA_obs_use)))*(x[0]-origin[0])+np.cos(math.radians(-(PA_obs_use)))*(x[1] - origin[1])) for x in corners]\n",
    "            \n",
    "            else:\n",
    "                corners_rotated = [(origin[0] + np.cos(math.radians((PA_obs_use+90)))*(x[0] - origin[0]) - np.sin(math.radians((PA_obs_use+90)))*(x[1] - origin[1]),origin[1] + np.sin(math.radians((PA_obs_use+90)))*(x[0]-origin[0])+np.cos(math.radians((PA_obs_use+90)))*(x[1] - origin[1])) for x in corners]\n",
    "            \n",
    "            corners_rotated_y = np.array(corners_rotated)[:,1]\n",
    "            corners_rotated_x = np.array(corners_rotated)[:,0]\n",
    "            #plt.scatter(np.array(corners)[:,0], np.array(corners)[:,1], marker='^', color=color_list[n], edgecolor='black', s=120, zorder=100)\n",
    "\n",
    "            plt.scatter(corners_rotated_x,corners_rotated_y, marker='*', color=color_list[n],  s=10, zorder=100)\n",
    "\n",
    "            \n",
    "\n",
    "\n",
    "            ordered_pts = order_points(np.array(corners_rotated))\n",
    "\n",
    "\n",
    "            polygon = Polygon(ordered_pts)\n",
    "            polygon_pts.append(ordered_pts)\n",
    "\n",
    "            \n",
    "        polygon_list.append(polygon_pts)\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('2D_projection.png')\n",
    "    return polygon_list\n",
    "\n",
    "def plot_data(xs_data_list, vel_data_list, error_up_list, error_down_list, \n",
    "              PA_pos, pixelscale, color_list,  name):\n",
    "    # so this should be made to be flexible to the number of slits :)\n",
    "    \n",
    "    sns.set_style(\"whitegrid\")\n",
    "    sns.set_context(\"talk\")\n",
    "    \n",
    "    pointsize = 500\n",
    "    if len(PA_pos)==1:\n",
    "        x=0\n",
    "        plt.clf()\n",
    "        fig = plt.figure(figsize=(20, 15), facecolor='w', edgecolor='k')\n",
    "        axs = fig.add_subplot(111)\n",
    "        \n",
    "        max_weight = 100\n",
    "\n",
    "        for j in range(len(xs_data_list[x][int(len(xs_data_list[x])/2):])):\n",
    "            weight =  1 - max(error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j])/max_weight\n",
    "            if weight < 0:\n",
    "                weight = 0.1\n",
    "            #print(j,  xs_data_list[x][int(len(xs_data_list[x])/2):][j],'weight', weight, max_weight, weight/max_weight)  \n",
    "            if j == 0 :\n",
    "                axs.scatter(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], label='PA '+str(PA_pos[x])+' redshifted ', color=color_list[x], marker='^', alpha = weight, s= pointsize)\n",
    "                axs.errorbar(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], yerr=np.array([[error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j]]]).T, capsize=5, \n",
    "                         color=color_list[x],ls='None', alpha=weight)\n",
    "            else:\n",
    "                axs.scatter(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], color=color_list[x], marker='^', alpha = weight, s= pointsize)\n",
    "                axs.errorbar(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], yerr=np.array([[error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j]]]).T, capsize=5, \n",
    "                         color=color_list[x],ls='None', alpha=weight)\n",
    "        for j in range(len(xs_data_list[x][:int(len(xs_data_list[x])/2)])):\n",
    "            weight =  1 - max(error_down_list[x][:int(len(xs_data_list[x])/2)][j],error_up_list[x][:int(len(xs_data_list[x])/2)][j])/max_weight\n",
    "            if weight < 0:\n",
    "                weight = 0.1\n",
    "            #print(j,  xs_data_list[x][int(len(xs_data_list[x])/2):][j],'weight', weight, max_weight, weight/max_weight)  \n",
    "            if j == 0 :\n",
    "                axs.scatter(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], label='PA '+str(PA_pos[x])+' blueshifted ', color=color_list[x], alpha = weight, s= pointsize, zorder=100)\n",
    "                axs.errorbar(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], yerr=np.array([[error_down_list[x][:int(len(xs_data_list[x])/2)][j],error_up_list[x][:int(len(xs_data_list[x])/2)][j]]]).T, capsize=5, \n",
    "                         color=color_list[x],ls='None', alpha=weight)\n",
    "            else:\n",
    "                axs.scatter(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j],  color=color_list[x], alpha = weight, s= pointsize, zorder=100)\n",
    "                axs.errorbar(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], yerr=np.array([[error_down_list[x][:int(len(xs_data_list[x])/2)][j],error_up_list[x][:int(len(xs_data_list[x])/2)][j]]]).T, capsize=5, \n",
    "                         color=color_list[x],ls='None', alpha=weight)\n",
    "        axs.legend(loc=1)\n",
    "        axs.set_ylim([np.min(vel_data_list[x])-100,np.max(vel_data_list[x])+100])\n",
    "\n",
    "        axs.axhline(y=0, color='k')\n",
    "\n",
    "    else:\n",
    "        plt.clf()\n",
    "        fig, axs = plt.subplots(len(PA_pos),1, figsize=(20, 15), facecolor='w', edgecolor='k')\n",
    "        fig.subplots_adjust(hspace = .5, wspace=.2)\n",
    "\n",
    "        axs = axs.ravel()\n",
    "        for x in range(len(xs_data_list)):\n",
    "            '''max_weight = max(max(error_down_list[x][int(len(xs_data_list[x])/2):]),max(error_up_list[x][int(len(xs_data_list[x])/2):]))\n",
    "            if max_weight > 100:'''\n",
    "            max_weight = 100\n",
    "\n",
    "            for j in range(len(xs_data_list[x][int(len(xs_data_list[x])/2):])):\n",
    "                weight =  1 - max(error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j])/max_weight\n",
    "                if weight < 0:\n",
    "                    weight = 0.1\n",
    "                #print(j,  xs_data_list[x][int(len(xs_data_list[x])/2):][j],'weight', weight, max_weight, weight/max_weight)  \n",
    "                if j == 0 :\n",
    "                    axs[x].scatter(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], label='PA '+str(PA_pos[x])+' redshifted ', color=color_list[x], marker='^', alpha = weight, s= pointsize)\n",
    "                    axs[x].errorbar(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], yerr=np.array([[error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j]]]).T, capsize=5, \n",
    "                             color=color_list[x],ls='None', alpha=weight)\n",
    "                else:\n",
    "                    axs[x].scatter(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], color=color_list[x], marker='^', alpha = weight, s= pointsize)\n",
    "                    axs[x].errorbar(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], yerr=np.array([[error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j]]]).T, capsize=5, \n",
    "                             color=color_list[x],ls='None', alpha=weight)\n",
    "            for j in range(len(xs_data_list[x][:int(len(xs_data_list[x])/2)])):\n",
    "                weight =  1 - max(error_down_list[x][:int(len(xs_data_list[x])/2)][j],error_up_list[x][:int(len(xs_data_list[x])/2)][j])/max_weight\n",
    "                if weight < 0:\n",
    "                    weight = 0.1\n",
    "                #print(j,  xs_data_list[x][int(len(xs_data_list[x])/2):][j],'weight', weight, max_weight, weight/max_weight)  \n",
    "                if j == 0 :\n",
    "                    axs[x].scatter(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], label='PA '+str(PA_pos[x])+' blueshifted ', color=color_list[x], alpha = weight, s= pointsize, zorder=100)\n",
    "                    axs[x].errorbar(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], yerr=np.array([[error_down_list[x][:int(len(xs_data_list[x])/2)][j],error_up_list[x][:int(len(xs_data_list[x])/2)][j]]]).T, capsize=5, \n",
    "                             color=color_list[x],ls='None', alpha=weight)\n",
    "                else:\n",
    "                    axs[x].scatter(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j],  color=color_list[x], alpha = weight, s= pointsize, zorder=100)\n",
    "                    axs[x].errorbar(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], yerr=np.array([[error_down_list[x][:int(len(xs_data_list[x])/2)][j],error_up_list[x][:int(len(xs_data_list[x])/2)][j]]]).T, capsize=5, \n",
    "                             color=color_list[x],ls='None', alpha=weight)\n",
    "            axs[x].legend(loc=1)\n",
    "            axs[x].set_ylim([np.min(vel_data_list[x])-100,np.max(vel_data_list[x])+100])\n",
    "\n",
    "            axs[x].axhline(y=0, color='k')\n",
    "    #plt.annotate('Still Working on the Weighting', xy=(0.2,0.5), xycoords='axes fraction', size=30)\n",
    "    plt.xlabel('Position along the Slit in $^{\\prime\\prime}$', size=15)\n",
    "    plt.savefig('data_'+str(name)+'.png')\n",
    "    \n",
    "    \n",
    "    '''plt.clf()\n",
    "    for n in range(len(xs_data_list)):\n",
    "        xs_data_concat = xs_data_list[n]\n",
    "        vel_data_concat = vel_data_list[n]\n",
    "        if PA_pos[n] < 90:\n",
    "        # Maybe also plot the slits against the 2D map:\n",
    "            xs_2D_concat_1 = [pixelscale*np.cos(math.radians(PA_pos[n]))*x+(pixelscale*np.cos(math.radians(PA_pos[n])))/2 for x in xs_data_concat[:-int(len(xs_data_concat)/2)]]\n",
    "            # pixel scale is \"/pix, so this whole plot will be in arcsec\n",
    "            ys_2D_concat_1 = [pixelscale*np.sin(math.radians(PA_pos[n]))*x-(pixelscale*np.cos(math.radians(PA_pos[n])))/2 for x in xs_data_concat[:-int(len(xs_data_concat)/2)]]\n",
    "            xs_2D_concat_2 = [pixelscale*np.cos(math.radians(PA_pos[n]))*x-(pixelscale*np.cos(math.radians(PA_pos[n])))/2 for x in xs_data_concat[-int(len(xs_data_concat)/2):]]\n",
    "            ys_2D_concat_2 = [pixelscale*np.sin(math.radians(PA_pos[n]))*x+(pixelscale*np.cos(math.radians(PA_pos[n])))/2 for x in xs_data_concat[-int(len(xs_data_concat)/2):]]\n",
    "        else:\n",
    "\n",
    "            xs_2D_concat_1 = [pixelscale*np.cos(math.radians(PA_pos[n]))*x+(pixelscale*np.sin(math.radians(PA_pos[n])))/2 for x in xs_data_concat_ortho[:-int(len(xs_data_concat)/2)]]\n",
    "            # pixel scale is \"/pix, so this whole plot will be in arcsec\n",
    "            ys_2D_concat_1 = [pixelscale*np.sin(math.radians(PA_pos[n]))*x for x in xs_data_concat[:-int(len(xs_data_concat)/2)]]\n",
    "            xs_2D_concat_2 = [pixelscale*np.cos(math.radians(PA_pos[n]))*x-(pixelscale*np.sin(math.radians(PA_pos[n])))/2 for x in xs_data_concat_ortho[-int(len(xs_data_concat)/2):]]\n",
    "            ys_2D_concat_2 = [pixelscale*np.sin(math.radians(PA_pos[n]))*x for x in xs_data_concat[-int(len(xs_data_concat)/2):]]\n",
    "\n",
    "    \n",
    "        plt.scatter(xs_2D_concat_1, ys_2D_concat_1, c=vel_data_concat[:-int(len(xs_data_concat)/2)], cmap='RdBu_r', vmax=300, vmin=-300, s=50)\n",
    "        plt.scatter(xs_2D_concat_2, ys_2D_concat_2, c=vel_data_concat[-int(len(xs_data_concat)/2):], cmap='RdBu_r', vmax=300, vmin=-300, s=50)\n",
    "    \n",
    "    plt.colorbar()\n",
    "    plt.annotate('The Angles are Wrong', xy=(0.2,0.5), xycoords='axes fraction', size=100)\n",
    "    \n",
    "    plt.savefig('physical.png')'''\n",
    "\n",
    "\n",
    "def load_data(PAs, minus, error_limit):\n",
    "    n_slits = len(PAs)\n",
    "    x_list = []\n",
    "    vel_list = []\n",
    "    vel_error_up_list = []\n",
    "    vel_error_down_list = []\n",
    "        \n",
    "    for n in range(len(PAs)):\n",
    "        PA_here = PAs[n]\n",
    "\n",
    "        with open(PA_here, 'r') as f:\n",
    "            data = f.readlines()\n",
    "            col_1_1=[]\n",
    "            col_1_2=[]\n",
    "            col_1_3=[]\n",
    "            col_2_1=[]\n",
    "            col_2_2=[]\n",
    "            col_2_3=[]\n",
    "            xs=[]\n",
    "\n",
    "            for line in data:\n",
    "                words = line.split()\n",
    "                if words[0]=='Veltwoone':\n",
    "                    col_1_1.append(words[1])\n",
    "                    col_1_2.append(words[3])\n",
    "                    col_1_3.append(words[4])\n",
    "                if words[0]=='Veltwotwo':\n",
    "                    col_2_1.append(words[1])\n",
    "                    col_2_2.append(words[3])\n",
    "                    col_2_3.append(words[4])\n",
    "                if words[0]=='Row':\n",
    "                    xs.append(float(words[1]))\n",
    "\n",
    "        \n",
    "        vel_2_1_gauss=[]\n",
    "        vel_2_1_error_up=[]\n",
    "        vel_2_1_error_down=[]\n",
    "        \n",
    "        vel_2_2_gauss=[]\n",
    "        vel_2_2_error_up=[]\n",
    "        vel_2_2_error_down=[]\n",
    "        \n",
    "        for j in range(len(col_1_1)):\n",
    "            \n",
    "            vel_2_2_gauss.append(col_2_1[j])\n",
    "            vel_2_1_gauss.append(col_1_1[j])\n",
    "            if float(col_1_2[j]) > error_limit:\n",
    "                vel_2_1_error_up.append(error_limit)\n",
    "            else:\n",
    "                vel_2_1_error_up.append(float(col_1_2[j]))\n",
    "            if float(col_1_1[j]) > error_limit:\n",
    "                vel_2_1_error_down.append(error_limit)\n",
    "            else:\n",
    "                vel_2_1_error_down.append(float(col_1_1[j]))\n",
    "            \n",
    "            if float(col_2_2[j]) > error_limit:\n",
    "                vel_2_2_error_up.append(error_limit)\n",
    "            else:\n",
    "                vel_2_2_error_up.append(float(col_2_2[j]))\n",
    "            if float(col_2_1[j]) > error_limit:\n",
    "                vel_2_2_error_down.append(10)\n",
    "            else:\n",
    "                vel_2_2_error_down.append(float(col_2_1[j]))\n",
    "            \n",
    "            '''vel_2_1_error_up.append(float(col_1_2[j])-float(col_1_1[j]))\n",
    "            vel_2_1_error_down.append(float(col_1_1[j])-float(col_1_3[j]))\n",
    "            vel_2_1_error.append([float(col_1_2[j])-float(col_1_1[j]),float(col_1_1[j])-float(col_1_3[j])])\n",
    "\n",
    "            vel_2_2_gauss.append(col_2_1[j])\n",
    "            vel_2_2_error_up.append(float(col_2_2[j])-float(col_2_1[j]))\n",
    "            vel_2_2_error_down.append(float(col_2_1[j])-float(col_2_3[j]))\n",
    "            vel_2_2_error.append([float(col_2_2[j])-float(col_2_1[j]),float(col_2_1[j])-float(col_2_3[j])])'''                                                                                                                                                                                                \n",
    "\n",
    "\n",
    "    \n",
    "    \n",
    "        vel_2_1=[float(y) for y in vel_2_1_gauss]\n",
    "        vel_2_2=[float(y) for y in vel_2_2_gauss]\n",
    "        #vel_1_error=[float(y) for y in vel_1_error]\n",
    "        \n",
    "        if np.mean(vel_2_1)< np.mean(vel_2_1):\n",
    "            #this means that the first set is the above side\n",
    "            v_1_above=vel_2_1\n",
    "            v_1_below=vel_2_2\n",
    "            vel_data_concat=vel_2_1+vel_2_2\n",
    "            vel_error_up_concat=vel_2_1_error_up+vel_2_2_error_up\n",
    "            vel_error_down_concat=vel_2_1_error_down+vel_2_2_error_down\n",
    "\n",
    "        else:\n",
    "            v_1_above=vel_2_2\n",
    "            v_1_below=vel_2_1\n",
    "            vel_data_concat=vel_2_2+vel_2_1\n",
    "            vel_error_up_concat=vel_2_2_error_up+vel_2_1_error_up\n",
    "            vel_error_down_concat=vel_2_2_error_down+vel_2_1_error_down\n",
    "        \n",
    "        x_list.append(xs+xs)\n",
    "        vel_list.append(vel_data_concat)\n",
    "        vel_error_up_list.append(vel_error_up_concat)\n",
    "        vel_error_down_list.append(vel_error_up_concat)\n",
    "        \n",
    "\n",
    "    \n",
    "    return x_list, vel_list, vel_error_up_list, vel_error_down_list\n",
    "\n",
    "\n",
    "# This code simply models the mean of the above and below cone at each position\n",
    "# that you feed in\n",
    "def model_bicone_means(z, boundaries):\n",
    "    \n",
    "    #bicone_construction(h,phi,theta,r_t, half_angle )\n",
    "    phi_array, theta_array, r_t,half_angle, vel_max_array=z\n",
    "\n",
    "\n",
    "    h=2*r_t\n",
    "    #h=[2*x for x in r_t]\n",
    "\n",
    "    out=bicone_construction(phi_array, theta_array, r_t, half_angle, vel_max_array)\n",
    "\n",
    "    # So this gives you a whole lot of 3D measurements that you do not actually need\n",
    "\n",
    "    merged_x=[float(y) for y in out[0]]\n",
    "    merged_y=[float(y) for y in out[1]]\n",
    "    merged_z=[float(y) for y in out[2]]\n",
    "    merged_vel=[float(y) for y in out[3]]\n",
    "    merged_x_plane=[float(y) for y in out[4]]\n",
    "    merged_y_plane=[float(y) for y in out[5]]\n",
    "    merged_z_plane=[float(y) for y in out[6]]\n",
    "\n",
    "    \n",
    "    \n",
    "    \n",
    "    # Okay so I'd like to use the boundaries and for each region, extract\n",
    "    # the mean velocity of both the upper and the lower cone which is given by \n",
    "    # merged_y_plane being less than and greater than 0 :/ (I think)\n",
    "    \n",
    "    inds_above = []\n",
    "    inds_below = []\n",
    "    for j in range(len(merged_y_plane)):\n",
    "        if merged_y[j] < merged_y_plane[j]:\n",
    "            inds_above.append(j)\n",
    "        else:\n",
    "            inds_below.append(j)\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    # Okay so chop up the portion of the cone above and below the cone midplane to\n",
    "    # calculate two mean velocities; one for each side of the cone (above and below)\n",
    "    \n",
    "    merged_x_blue = np.array(merged_x)[inds_above]\n",
    "    merged_z_blue = np.array(merged_z)[inds_above]\n",
    "    merged_vel_blue = np.array(merged_vel)[inds_above]\n",
    "    \n",
    "    merged_x_red = np.array(merged_x)[inds_below]\n",
    "    merged_z_red = np.array(merged_z)[inds_below]\n",
    "    merged_vel_red = np.array(merged_vel)[inds_below]\n",
    "    \n",
    "    # Do it for each slit:\n",
    "    #feature_names[i] = {key:[] for key in myr}\n",
    "    \n",
    "    #First reshape the boundaries\n",
    "    \n",
    "    vel_model_blue = {key:[] for key in range(np.shape(boundaries)[0])}\n",
    "    vel_model_red = {key:[] for key in range(np.shape(boundaries)[0])}\n",
    "    vel_model_blue_std = {key:[] for key in range(np.shape(boundaries)[0])}\n",
    "    vel_model_red_std = {key:[] for key in range(np.shape(boundaries)[0])}\n",
    "    for n in range(np.shape(boundaries)[0]):\n",
    "        for j in range(np.shape(boundaries[0])[0] ):\n",
    "            #so for each position along the slit, determine what the \n",
    "            #mean velocity is for above and below\n",
    "            try:\n",
    "                polygon = Polygon(boundaries[n][j])\n",
    "            except IndexError:\n",
    "                continue\n",
    "    \n",
    "            cont_vel = []\n",
    "            for k in range(len(merged_x_blue)):\n",
    "                #print(polygon.contains(Point(merged_x[k],merged_y[k])))\n",
    "                if polygon.contains(Point(merged_x_blue[k],merged_z_blue[k])):\n",
    "                    cont_vel.append(merged_vel_blue[k])\n",
    "            if np.isnan(np.mean(cont_vel)):\n",
    "                vel_model_blue[n].append(0)\n",
    "                vel_model_blue_std[n].append(0)\n",
    "            else:\n",
    "                vel_model_blue[n].append(np.mean(cont_vel))\n",
    "                vel_model_blue_std[n].append(np.std(cont_vel))\n",
    "            \n",
    "            cont_vel = []\n",
    "            for k in range(len(merged_x_red)):\n",
    "                #print(polygon.contains(Point(merged_x[k],merged_y[k])))\n",
    "                if polygon.contains(Point(merged_x_red[k],merged_z_red[k])):\n",
    "                    cont_vel.append(merged_vel_red[k])\n",
    "            if np.isnan(np.mean(cont_vel)):\n",
    "                vel_model_red[n].append(0)\n",
    "                vel_model_red_std[n].append(0)\n",
    "            else:    \n",
    "                vel_model_red[n].append(np.mean(cont_vel))\n",
    "                vel_model_red_std[n].append(np.std(cont_vel))\n",
    "            \n",
    "    \n",
    "    return vel_model_blue, vel_model_red\n",
    "# This function compares the model bicone to the data and gives you a log likelihood value\n",
    "# to minimize with the emcee\n",
    "def lnlike_bicone(z, *args):\n",
    "    # First produce the model\n",
    "    \n",
    "    bounds, xs_data_list, vel_data_list, v_e_up, v_e_down = args\n",
    "    \n",
    "    model_v_blue, model_v_red = model_bicone_means(z, bounds)\n",
    "    \n",
    "\n",
    "    \n",
    "    \n",
    "    # So the velocity from the input is in a shape\n",
    "\n",
    "    vel_model_cut = {key:[] for key in range(np.shape(vel_data_list)[0])}\n",
    "    for n in range(np.shape(boundaries)[0]):\n",
    "        for k in range(int(len(model_v_red[n])/2)):\n",
    "            vel_model_cut[n].append(model_v_red[n][k])\n",
    "        for j in range(int(len(model_v_blue[n])/2)):\n",
    "            #fill = j+k\n",
    "            vel_model_cut[n].append(model_v_blue[n][j])\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    resid=[]\n",
    "    \n",
    "    sum_masked=[]\n",
    "    \n",
    "    for n in range(np.shape(boundaries)[0]):\n",
    "        for i in range(len(vel_model_cut[n])):\n",
    "            if vel_model_cut[n][i]==0:\n",
    "                sum_masked.append(1)\n",
    "            else:\n",
    "                resid.append(-0.5*(((vel_model_cut[n][i]-vel_data_list[n][i])**2)/(np.sqrt(v_e_up[n][i]**2+v_e_down[n][i]**2))**2))\n",
    "    \n",
    "    masked_elements_sum=2*np.sum(sum_masked)\n",
    "\n",
    "    n=2*(len(resid))# count the number of elements in vel_data_list\n",
    "    k=5\n",
    "\n",
    "    #print('-lnlike', np.sum(resid)/(n-k-1-masked_elements_sum))\n",
    "    \n",
    "    \n",
    "    return np.sum(resid)/(n-k-1-masked_elements_sum)\n",
    "\n",
    "# This code simply models the mean of the above and below cone at each position\n",
    "# that you feed in\n",
    "def model_bicone_profile_plot(z, boundaries, verbose, xs_proj, ys_proj, name):\n",
    "    \n",
    "    #bicone_construction(h,phi,theta,r_t, half_angle )\n",
    "    phi_array, theta_array, r_t,half_angle, vel_max_array=z\n",
    "\n",
    "\n",
    "    h=2*r_t\n",
    "    #h=[2*x for x in r_t]\n",
    "\n",
    "    out=bicone_construction_plot(boundaries, phi_array, theta_array, r_t, half_angle, vel_max_array, verbose, xs_proj, ys_proj, name)\n",
    "\n",
    "    # So this gives you a whole lot of 3D measurements that you do not actually need\n",
    "\n",
    "    merged_x=[float(y) for y in out[0]]\n",
    "    merged_y=[float(y) for y in out[1]]\n",
    "    merged_z=[float(y) for y in out[2]]\n",
    "    merged_vel=[float(y) for y in out[3]]\n",
    "    \n",
    "    \n",
    "    # Do it for each slit:\n",
    "    #feature_names[i] = {key:[] for key in myr}\n",
    "    \n",
    "    #First reshape the boundaries\n",
    "    \n",
    "    vel_prof_model = {key:[] for key in range(np.shape(boundaries)[0])}\n",
    "    for n in range(np.shape(boundaries)[0]):\n",
    "        for j in range(np.shape(boundaries[0])[0] ):\n",
    "            #so for each position along the slit, determine what the \n",
    "            #mean velocity is for above and below\n",
    "            try:\n",
    "                polygon = Polygon(boundaries[n][j])\n",
    "            except IndexError:\n",
    "                continue\n",
    "    \n",
    "            cont_vel = []\n",
    "            for k in range(len(merged_x)):\n",
    "                #print(polygon.contains(Point(merged_x[k],merged_y[k])))\n",
    "                if polygon.contains(Point(merged_x[k],merged_z[k])):\n",
    "                    cont_vel.append(merged_vel[k])\n",
    "            vel_prof_model[n].append(cont_vel)\n",
    "                \n",
    "            \n",
    "            \n",
    "    \n",
    "    return vel_prof_model\n",
    "\n",
    "\n",
    "\n",
    "# This code simply models the mean of the above and below cone at each position\n",
    "# that you feed in\n",
    "def model_bicone_means_plot(z, boundaries, verbose, xs_proj, ys_proj, name):\n",
    "    \n",
    "    #bicone_construction(h,phi,theta,r_t, half_angle )\n",
    "    phi_array, theta_array, r_t,half_angle, vel_max_array=z\n",
    "\n",
    "\n",
    "    h=2*r_t\n",
    "    #h=[2*x for x in r_t]\n",
    "\n",
    "    out=bicone_construction_plot(boundaries, phi_array, theta_array, r_t, half_angle, vel_max_array, verbose, xs_proj, ys_proj, name)\n",
    "\n",
    "    # So this gives you a whole lot of 3D measurements that you do not actually need\n",
    "\n",
    "    merged_x=[float(y) for y in out[0]]\n",
    "    merged_y=[float(y) for y in out[1]]\n",
    "    merged_z=[float(y) for y in out[2]]\n",
    "    merged_vel=[float(y) for y in out[3]]\n",
    "    merged_x_plane=[float(y) for y in out[4]]\n",
    "    merged_y_plane=[float(y) for y in out[5]]\n",
    "    merged_z_plane=[float(y) for y in out[6]]\n",
    "\n",
    "    '''plt.clf()\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    im = ax.scatter(merged_x, merged_z, c=merged_vel, cmap='RdBu_r')\n",
    "    \n",
    "    plt.colorbar(im)\n",
    "    plt.xlim([-5,5])\n",
    "    plt.ylim([-5,5])\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "    #I'm confused; time to make a 3D plot:\n",
    "    # Import dependencies\n",
    "    import plotly\n",
    "    import plotly.graph_objs as go\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "    # Configure Plotly to be rendered inline in the notebook.\n",
    "    plotly.offline.init_notebook_mode()\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "    # Configure the trace.\n",
    "    trace = go.Scatter3d(\n",
    "        x=merged_x,  # <-- Put your data instead\n",
    "        y=merged_y,  # <-- Put your data instead\n",
    "        z=merged_z,  # <-- Put your data instead\n",
    "        mode='markers',\n",
    "        marker=dict(\n",
    "        size=12,\n",
    "        color=merged_vel,                # set color to an array/list of desired values\n",
    "        colorscale='RdBu_r',   # choose a colorscale\n",
    "        opacity=0.8\n",
    "    )\n",
    "    )\n",
    "\n",
    "    # Configure the layout.\n",
    "    layout = go.Layout(\n",
    "        margin={'l': 0, 'r': 0, 'b': 0, 't': 0}\n",
    "    )\n",
    "\n",
    "    data = [trace]\n",
    "\n",
    "    plot_figure = go.Figure(data=data, layout=layout)\n",
    "\n",
    "    # Render the plot.\n",
    "    plotly.offline.iplot(plot_figure)\n",
    "    \n",
    "    \n",
    "    plotly.offline.init_notebook_mode()\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "    # Configure the trace.\n",
    "    trace = go.Scatter3d(\n",
    "        x=merged_x_plane,  # <-- Put your data instead\n",
    "        y=merged_y_plane,  # <-- Put your data instead\n",
    "        z=merged_z_plane,  # <-- Put your data instead\n",
    "        mode='markers',\n",
    "        marker=dict(\n",
    "        size=12,\n",
    "        color=merged_vel,                # set color to an array/list of desired values\n",
    "        colorscale='RdBu_r',   # choose a colorscale\n",
    "        opacity=0.8\n",
    "    )\n",
    "    )\n",
    "\n",
    "    # Configure the layout.\n",
    "    layout = go.Layout(\n",
    "        margin={'l': 0, 'r': 0, 'b': 0, 't': 0}\n",
    "    )\n",
    "\n",
    "    data = [trace]\n",
    "\n",
    "    plot_figure = go.Figure(data=data, layout=layout)\n",
    "\n",
    "    # Render the plot.\n",
    "    plotly.offline.iplot(plot_figure)'''\n",
    "    \n",
    "    \n",
    "    # Okay so I'd like to use the boundaries and for each region, extract\n",
    "    # the mean velocity of both the upper and the lower cone which is given by \n",
    "    # merged_y_plane being less than and greater than 0 :/ (I think)\n",
    "    \n",
    "    inds_above = []\n",
    "    inds_below = []\n",
    "    for j in range(len(merged_y_plane)):\n",
    "        if merged_y[j] < merged_y_plane[j]:\n",
    "            inds_above.append(j)\n",
    "        else:\n",
    "            inds_below.append(j)\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    # Okay so chop up the portion of the cone above and below the cone midplane to\n",
    "    # calculate two mean velocities; one for each side of the cone (above and below)\n",
    "    \n",
    "    merged_x_blue = np.array(merged_x)[inds_above]\n",
    "    merged_z_blue = np.array(merged_z)[inds_above]\n",
    "    merged_vel_blue = np.array(merged_vel)[inds_above]\n",
    "    \n",
    "    merged_x_red = np.array(merged_x)[inds_below]\n",
    "    merged_z_red = np.array(merged_z)[inds_below]\n",
    "    merged_vel_red = np.array(merged_vel)[inds_below]\n",
    "    \n",
    "    # Do it for each slit:\n",
    "    #feature_names[i] = {key:[] for key in myr}\n",
    "    \n",
    "    #First reshape the boundaries\n",
    "    \n",
    "    vel_model_blue = {key:[] for key in range(np.shape(boundaries)[0])}\n",
    "    vel_model_red = {key:[] for key in range(np.shape(boundaries)[0])}\n",
    "    vel_model_blue_std = {key:[] for key in range(np.shape(boundaries)[0])}\n",
    "    vel_model_red_std = {key:[] for key in range(np.shape(boundaries)[0])}\n",
    "    for n in range(np.shape(boundaries)[0]):\n",
    "        for j in range(np.shape(boundaries[0])[0] ):\n",
    "            #so for each position along the slit, determine what the \n",
    "            #mean velocity is for above and below\n",
    "            try:\n",
    "                polygon = Polygon(boundaries[n][j])\n",
    "            except IndexError:\n",
    "                continue\n",
    "    \n",
    "            cont_vel = []\n",
    "            for k in range(len(merged_x_blue)):\n",
    "                #print(polygon.contains(Point(merged_x[k],merged_y[k])))\n",
    "                if polygon.contains(Point(merged_x_blue[k],merged_z_blue[k])):\n",
    "                    cont_vel.append(merged_vel_blue[k])\n",
    "            if np.isnan(np.mean(cont_vel)):\n",
    "                vel_model_blue[n].append(0)\n",
    "                vel_model_blue_std[n].append(0)\n",
    "            else:\n",
    "                vel_model_blue[n].append(np.mean(cont_vel))\n",
    "                vel_model_blue_std[n].append(np.std(cont_vel))\n",
    "            \n",
    "            cont_vel = []\n",
    "            for k in range(len(merged_x_red)):\n",
    "                #print(polygon.contains(Point(merged_x[k],merged_y[k])))\n",
    "                if polygon.contains(Point(merged_x_red[k],merged_z_red[k])):\n",
    "                    cont_vel.append(merged_vel_red[k])\n",
    "            if np.isnan(np.mean(cont_vel)):\n",
    "                vel_model_red[n].append(0)\n",
    "                vel_model_red_std[n].append(0)\n",
    "            else:    \n",
    "                vel_model_red[n].append(np.mean(cont_vel))\n",
    "                vel_model_red_std[n].append(np.std(cont_vel))\n",
    "            \n",
    "    \n",
    "    return vel_model_blue, vel_model_red, vel_model_blue_std, vel_model_red_std\n",
    "\n",
    "\n",
    "\n",
    "def lnlike_bicone_plot_profile(z, *args):\n",
    "    # First produce the model\n",
    "    \n",
    "    bounds, xs_data_list, vel_data_list, v_e_up, v_e_down, verbose, xs_proj, ys_proj, name = args\n",
    "    \n",
    "    model_v = model_bicone_profile_plot(z, bounds, verbose, xs_proj, ys_proj, name)\n",
    "    \n",
    "    \n",
    "    for j in range(np.shape(xs_data_list)[0]):#assume this is the number of slits\n",
    "        plt.clf()\n",
    "        sns.set_context(\"paper\")\n",
    "        sns.set_style('dark')\n",
    "        n_slits = int(np.shape(model_v[j])[0]/2)\n",
    "        \n",
    "        fig, axs = plt.subplots(int(np.sqrt(n_slits)+1), int(np.sqrt(n_slits)), sharex='all')#, sharey='all')\n",
    "        \n",
    "        '''# Turn off axis lines and ticks of the big subplot\n",
    "        ax = fig.add_subplot(111)\n",
    "        ax.spines['top'].set_color('none')\n",
    "        ax.spines['bottom'].set_color('none')\n",
    "        ax.spines['left'].set_color('none')\n",
    "        ax.spines['right'].set_color('none')\n",
    "        ax.tick_params(labelcolor='w', top=False, bottom=False, left=False, right=False)\n",
    "        ax.set_xlabel('Velocity [km s$^{-1}$]')\n",
    "        ax.set_ylabel('Relative Frequency')'''\n",
    "        \n",
    "        \n",
    "        axs = axs.ravel()\n",
    "        for i in range(n_slits):\n",
    "            ybins, xbins = np.histogram(model_v[j][i], range = [-400, 400], normed=True, bins = 25)\n",
    "            axs[i].set_yticks([])\n",
    "            axs[i].step(xbins[:-1], ybins, color='black')\n",
    "            axs[i].annotate(str(-round(xs_data_list[j][i], 2))+'$^{\\prime\\prime}$', \n",
    "                                xy=(0.05,1.02), xycoords='axes fraction', size=5)\n",
    "            '''if i > 24:\n",
    "                axs[i].set_xticks([-300,300])\n",
    "                axs[i].set_xticklabels([-300,300])\n",
    "                \n",
    "                axs[i].tick_params(top='off',bottom='on',left='off',right='off',\n",
    "                                  labelleft='off',labelright='off',labelbottom='on',labeltop='off')\n",
    "            else:\n",
    "                axs[i].tick_params(top='off',bottom='off',left='off',right='off',\n",
    "                                  labelleft='off',labelright='off',labelbottom='off',labeltop='off')\n",
    "            '''\n",
    "            \n",
    "            '''try:\n",
    "                print('slit', i, 'vs', model_v[j][i])\n",
    "                axs[i].hist(model_v[j][i])\n",
    "                \n",
    "            except:\n",
    "                break'''\n",
    "            ''' ybins, xbins = np.histogram(profiles[p], \n",
    "                                            bins=range_xbin)\n",
    "                axs[p].hist(profiles[p], bins=range_xbin)'''\n",
    "        #plt.tight_layout()\n",
    "        axs[n_slits].axis('off')\n",
    "        plt.subplots_adjust(wspace=None, hspace=None)\n",
    "        '''plt.xlabel('Velocity')\n",
    "        plt.ylabel('Relative Frequency')'''\n",
    "        plt.savefig('toy_profiles.png', dpi=200)\n",
    "        print('size', int(np.sqrt(n_slits)+1), int(np.sqrt(n_slits)), 'that was x y')\n",
    "    \n",
    "    STOP\n",
    "    \n",
    "    if verbose=='yes':#then plot it\n",
    "        # Make a plot of the model velocities :)\n",
    "        pointsize=15\n",
    "        \n",
    "        if len(PA_pos)==1:\n",
    "            x=0\n",
    "            \n",
    "            plt.clf()\n",
    "            fig = plt.figure( figsize=(20, 15), facecolor='w', edgecolor='k')\n",
    "            fig.subplots_adjust(hspace = .5, wspace=.2)\n",
    "\n",
    "            color_list = ['#3587A4','#FFA69E']\n",
    "\n",
    "            axs = fig.add_subplot(111)\n",
    "            axs.scatter(xs_data_list[x], ma.masked_where(model_v_blue[x]==0, model_v_blue[x]), color = '#3587A4', label = 'Model Blue', marker='^')\n",
    "            axs.errorbar(xs_data_list[x], ma.masked_where(model_v_blue[x]==0, model_v_blue[x]), yerr=model_v_blue_std[x],color = '#3587A4', linestyle='None')\n",
    "            \n",
    "\n",
    "            axs.scatter(xs_data_list[x], model_v_red[x], color = '#FFA69E', label = 'Model Red')\n",
    "            axs.errorbar(xs_data_list[x], ma.masked_where(model_v_red[x]==0, model_v_red[x]), yerr = model_v_red_std[x], color = '#FFA69E', linestyle='None')\n",
    "            max_weight = 100\n",
    "\n",
    "            for j in range(len(xs_data_list[x][int(len(xs_data_list[x])/2):])):\n",
    "                weight =  1 - max(error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j])/max_weight\n",
    "                if weight < 0:\n",
    "                    weight = 0\n",
    "                #print(j,  xs_data_list[x][int(len(xs_data_list[x])/2):][j],'weight', weight, max_weight, weight/max_weight)  \n",
    "                if j == 0 :\n",
    "                    axs.scatter(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], \n",
    "                                   label='PA '+str(PA_pos[x])+' Blue ', color=color_list[0], marker='^', alpha = weight, s= pointsize)\n",
    "                    axs.errorbar(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], \n",
    "                                    yerr=np.array([[error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j]]]).T, capsize=5, \n",
    "                             color=color_list[0],ls='None', alpha=weight)\n",
    "                else:\n",
    "                    axs.scatter(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], \n",
    "                                   color=color_list[0], marker='^', alpha = weight, s= pointsize)\n",
    "                    axs.errorbar(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], \n",
    "                                    yerr=np.array([[error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j]]]).T, capsize=5, \n",
    "                             color=color_list[0],ls='None', alpha=weight)\n",
    "            for j in range(len(xs_data_list[x][:int(len(xs_data_list[x])/2)])):\n",
    "                weight =  1 - max(error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j])/max_weight\n",
    "                if weight < 0:\n",
    "                    weight = 0\n",
    "                #print(j,  xs_data_list[x][int(len(xs_data_list[x])/2):][j],'weight', weight, max_weight, weight/max_weight)  \n",
    "                if j == 0 :\n",
    "                    axs.scatter(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], \n",
    "                                   label='PA '+str(PA_pos[x])+' Red ', color=color_list[1], alpha = weight, s= pointsize, zorder=100)\n",
    "                    axs.errorbar(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], \n",
    "                                    yerr=np.array([[error_down_list[x][:int(len(xs_data_list[x])/2)][j],error_up_list[x][:int(len(xs_data_list[x])/2)][j]]]).T, capsize=5, \n",
    "                             color=color_list[1],ls='None', alpha=weight)\n",
    "                else:\n",
    "\n",
    "                    axs.scatter(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j],  \n",
    "                                   color=color_list[1], alpha = weight, s= pointsize, zorder=100)\n",
    "                    axs.errorbar(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], \n",
    "                                    yerr=np.array([[error_down_list[x][:int(len(xs_data_list[x])/2)][j],error_up_list[x][:int(len(xs_data_list[x])/2)][j]]]).T, capsize=5, \n",
    "                             color=color_list[1],ls='None', alpha=weight)\n",
    "            axs.legend(loc=1)\n",
    "            axs.set_ylim([-600,600])#[np.min(vel_data_list[x]),np.max(vel_data_list[x])])\n",
    "            axs.set_title('PA #'+str(x+1))\n",
    "            axs.axhline(y=0, color='k')\n",
    "            \n",
    "        else:\n",
    "            plt.clf()\n",
    "            fig, axs = plt.subplots(len(PA_pos),1, figsize=(20, 15), facecolor='w', edgecolor='k')\n",
    "            fig.subplots_adjust(hspace = .5, wspace=.2)\n",
    "\n",
    "            color_list = ['#3587A4','#FFA69E']\n",
    "\n",
    "            axs = axs.ravel()\n",
    "            for x in range(len(xs_data_list)):\n",
    "\n",
    "                # So this is going over the two PA axes\n",
    "                '''print(xs_data_list[x], np.shape(xs_data_list[x]))\n",
    "                print(np.shape(model_v_blue[x]))\n",
    "                continue\n",
    "                '''\n",
    "                axs[x].scatter(xs_data_list[x], ma.masked_where(model_v_blue[x]==0, model_v_blue[x]), color = '#3587A4', label = 'Model Blue', marker='^')\n",
    "                axs[x].errorbar(xs_data_list[x], ma.masked_where(model_v_blue[x]==0, model_v_blue[x]), yerr=model_v_blue_std[x],color = '#3587A4', linestyle='None')\n",
    "                #axs[x].fill_between(xs_data_list[x], ma.masked_where(model_v_blue[x]==0, model_v_blue[x]) - model_v_blue_std[x],\n",
    "                #                   ma.masked_where(model_v_blue[x]==0, model_v_blue[x]) + model_v_blue_std[x], color = '#3587A4', alpha=0.5)\n",
    "                #plt.fill_between(x, y-error, y+error)\n",
    "\n",
    "\n",
    "                axs[x].scatter(xs_data_list[x], model_v_red[x], color = '#FFA69E', label = 'Model Red')\n",
    "                axs[x].errorbar(xs_data_list[x], ma.masked_where(model_v_red[x]==0, model_v_red[x]), yerr = model_v_red_std[x], color = '#FFA69E', linestyle='None')\n",
    "                #axs[x].fill_between(xs_data_list[x], ma.masked_where(model_v_red[x]==0, model_v_red[x]) - model_v_red_std[x],\n",
    "                #                   ma.masked_where(model_v_red[x]==0, model_v_red[x]) + model_v_red_std[x], color = '#FFA69E', alpha=0.5)\n",
    "                #plt.fill_between(x, y-error, y+error)\n",
    "                max_weight = 100\n",
    "\n",
    "                for j in range(len(xs_data_list[x][int(len(xs_data_list[x])/2):])):\n",
    "                    weight =  1 - max(error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j])/max_weight\n",
    "                    if weight < 0:\n",
    "                        weight = 0\n",
    "                    #print(j,  xs_data_list[x][int(len(xs_data_list[x])/2):][j],'weight', weight, max_weight, weight/max_weight)  \n",
    "                    if j == 0 :\n",
    "                        axs[x].scatter(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], \n",
    "                                       label='PA '+str(PA_pos[x])+' Blue ', color=color_list[0], marker='^', alpha = weight, s= pointsize)\n",
    "                        axs[x].errorbar(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], \n",
    "                                        yerr=np.array([[error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j]]]).T, capsize=5, \n",
    "                                 color=color_list[0],ls='None', alpha=weight)\n",
    "                    else:\n",
    "                        axs[x].scatter(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], \n",
    "                                       color=color_list[0], marker='^', alpha = weight, s= pointsize)\n",
    "                        axs[x].errorbar(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], \n",
    "                                        yerr=np.array([[error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j]]]).T, capsize=5, \n",
    "                                 color=color_list[0],ls='None', alpha=weight)\n",
    "                for j in range(len(xs_data_list[x][:int(len(xs_data_list[x])/2)])):\n",
    "                    weight =  1 - max(error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j])/max_weight\n",
    "                    if weight < 0:\n",
    "                        weight = 0\n",
    "                    #print(j,  xs_data_list[x][int(len(xs_data_list[x])/2):][j],'weight', weight, max_weight, weight/max_weight)  \n",
    "                    if j == 0 :\n",
    "                        axs[x].scatter(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], \n",
    "                                       label='PA '+str(PA_pos[x])+' Red ', color=color_list[1], alpha = weight, s= pointsize, zorder=100)\n",
    "                        axs[x].errorbar(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], \n",
    "                                        yerr=np.array([[error_down_list[x][:int(len(xs_data_list[x])/2)][j],error_up_list[x][:int(len(xs_data_list[x])/2)][j]]]).T, capsize=5, \n",
    "                                 color=color_list[1],ls='None', alpha=weight)\n",
    "                    else:\n",
    "\n",
    "                        axs[x].scatter(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j],  \n",
    "                                       color=color_list[1], alpha = weight, s= pointsize, zorder=100)\n",
    "                        axs[x].errorbar(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], \n",
    "                                        yerr=np.array([[error_down_list[x][:int(len(xs_data_list[x])/2)][j],error_up_list[x][:int(len(xs_data_list[x])/2)][j]]]).T, capsize=5, \n",
    "                                 color=color_list[1],ls='None', alpha=weight)\n",
    "                axs[x].legend(loc=1)\n",
    "                axs[x].set_ylim([-600,600])#[np.min(vel_data_list[x]),np.max(vel_data_list[x])])\n",
    "                axs[x].set_title('PA #'+str(x+1))\n",
    "                axs[x].axhline(y=0, color='k')\n",
    "\n",
    "        \n",
    "    \n",
    "    \n",
    "    \n",
    "    # So the velocity from the input is in a shape\n",
    "\n",
    "    vel_model_cut = {key:[] for key in range(np.shape(vel_data_list)[0])}\n",
    "    for n in range(np.shape(boundaries)[0]):\n",
    "        for k in range(int(len(model_v_red[n])/2)):\n",
    "            vel_model_cut[n].append(model_v_red[n][k])\n",
    "        for j in range(int(len(model_v_blue[n])/2)):\n",
    "            #fill = j+k\n",
    "            vel_model_cut[n].append(model_v_blue[n][j])\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    resid=[]\n",
    "    \n",
    "    sum_masked=[]\n",
    "    \n",
    "    for n in range(np.shape(boundaries)[0]):\n",
    "        for i in range(len(vel_model_cut[n])):\n",
    "            if vel_model_cut[n][i]==0:\n",
    "                sum_masked.append(1)\n",
    "            else:\n",
    "                resid.append(-0.5*(((vel_model_cut[n][i]-vel_data_list[n][i])**2)/(np.sqrt(v_e_up[n][i]**2+v_e_down[n][i]**2))**2))\n",
    "    \n",
    "    masked_elements_sum=2*np.sum(sum_masked)\n",
    "\n",
    "    n=2*(len(resid))# count the number of elements in vel_data_list\n",
    "    k=5\n",
    "\n",
    "    print('-lnlike', np.sum(resid)/(n-k-1-masked_elements_sum))\n",
    "    if verbose=='yes':\n",
    "        if len(PA_pos)==1:\n",
    "            axs.annotate('Best Fit Model lnlike = '+str(round(np.sum(resid)/(n-k-1-masked_elements_sum),2)), xy =(0.02, 1.02), xycoords='axes fraction', size=20)\n",
    "        else:\n",
    "            axs[0].annotate('Best Fit Model lnlike = '+str(round(np.sum(resid)/(n-k-1-masked_elements_sum),2)), xy =(0.02, 1.02), xycoords='axes fraction', size=20)\n",
    "        plt.savefig('data_model_'+str(name)+'.png')\n",
    "    \n",
    "    return np.sum(resid)/(n-k-1-masked_elements_sum)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# This function compares the model bicone to the data and gives you a log likelihood value\n",
    "# to minimize with the emcee\n",
    "def lnlike_bicone_plot(z, *args):\n",
    "    # First produce the model\n",
    "    \n",
    "    bounds, xs_data_list, vel_data_list, v_e_up, v_e_down, verbose, xs_proj, ys_proj, name = args\n",
    "    \n",
    "    model_v_blue, model_v_red, model_v_blue_std, model_v_red_std = model_bicone_means_plot(z, bounds, verbose, xs_proj, ys_proj, name)\n",
    "    \n",
    "\n",
    "    \n",
    "    if verbose=='yes':#then plot it\n",
    "        # Make a plot of the model velocities :)\n",
    "        pointsize=15\n",
    "        \n",
    "        if len(PA_pos)==1:\n",
    "            x=0\n",
    "            \n",
    "            plt.clf()\n",
    "            fig = plt.figure( figsize=(20, 15), facecolor='w', edgecolor='k')\n",
    "            fig.subplots_adjust(hspace = .5, wspace=.2)\n",
    "\n",
    "            color_list = ['#3587A4','#FFA69E']\n",
    "\n",
    "            axs = fig.add_subplot(111)\n",
    "            axs.scatter(xs_data_list[x], ma.masked_where(model_v_blue[x]==0, model_v_blue[x]), color = '#3587A4', label = 'Model Blue', marker='^')\n",
    "            axs.errorbar(xs_data_list[x], ma.masked_where(model_v_blue[x]==0, model_v_blue[x]), yerr=model_v_blue_std[x],color = '#3587A4', linestyle='None')\n",
    "            \n",
    "\n",
    "            axs.scatter(xs_data_list[x], model_v_red[x], color = '#FFA69E', label = 'Model Red')\n",
    "            axs.errorbar(xs_data_list[x], ma.masked_where(model_v_red[x]==0, model_v_red[x]), yerr = model_v_red_std[x], color = '#FFA69E', linestyle='None')\n",
    "            max_weight = 100\n",
    "\n",
    "            for j in range(len(xs_data_list[x][int(len(xs_data_list[x])/2):])):\n",
    "                weight =  1 - max(error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j])/max_weight\n",
    "                if weight < 0:\n",
    "                    weight = 0\n",
    "                #print(j,  xs_data_list[x][int(len(xs_data_list[x])/2):][j],'weight', weight, max_weight, weight/max_weight)  \n",
    "                if j == 0 :\n",
    "                    axs.scatter(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], \n",
    "                                   label='PA '+str(PA_pos[x])+' Blue ', color=color_list[0], marker='^', alpha = weight, s= pointsize)\n",
    "                    axs.errorbar(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], \n",
    "                                    yerr=np.array([[error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j]]]).T, capsize=5, \n",
    "                             color=color_list[0],ls='None', alpha=weight)\n",
    "                else:\n",
    "                    axs.scatter(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], \n",
    "                                   color=color_list[0], marker='^', alpha = weight, s= pointsize)\n",
    "                    axs.errorbar(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], \n",
    "                                    yerr=np.array([[error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j]]]).T, capsize=5, \n",
    "                             color=color_list[0],ls='None', alpha=weight)\n",
    "            for j in range(len(xs_data_list[x][:int(len(xs_data_list[x])/2)])):\n",
    "                weight =  1 - max(error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j])/max_weight\n",
    "                if weight < 0:\n",
    "                    weight = 0\n",
    "                #print(j,  xs_data_list[x][int(len(xs_data_list[x])/2):][j],'weight', weight, max_weight, weight/max_weight)  \n",
    "                if j == 0 :\n",
    "                    axs.scatter(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], \n",
    "                                   label='PA '+str(PA_pos[x])+' Red ', color=color_list[1], alpha = weight, s= pointsize, zorder=100)\n",
    "                    axs.errorbar(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], \n",
    "                                    yerr=np.array([[error_down_list[x][:int(len(xs_data_list[x])/2)][j],error_up_list[x][:int(len(xs_data_list[x])/2)][j]]]).T, capsize=5, \n",
    "                             color=color_list[1],ls='None', alpha=weight)\n",
    "                else:\n",
    "\n",
    "                    axs.scatter(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j],  \n",
    "                                   color=color_list[1], alpha = weight, s= pointsize, zorder=100)\n",
    "                    axs.errorbar(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], \n",
    "                                    yerr=np.array([[error_down_list[x][:int(len(xs_data_list[x])/2)][j],error_up_list[x][:int(len(xs_data_list[x])/2)][j]]]).T, capsize=5, \n",
    "                             color=color_list[1],ls='None', alpha=weight)\n",
    "            axs.legend(loc=1)\n",
    "            axs.set_ylim([-600,600])#[np.min(vel_data_list[x]),np.max(vel_data_list[x])])\n",
    "            axs.set_title('PA #'+str(x+1))\n",
    "            axs.axhline(y=0, color='k')\n",
    "            \n",
    "        else:\n",
    "            plt.clf()\n",
    "            fig, axs = plt.subplots(len(PA_pos),1, figsize=(20, 15), facecolor='w', edgecolor='k')\n",
    "            fig.subplots_adjust(hspace = .5, wspace=.2)\n",
    "\n",
    "            color_list = ['#3587A4','#FFA69E']\n",
    "\n",
    "            axs = axs.ravel()\n",
    "            for x in range(len(xs_data_list)):\n",
    "\n",
    "                # So this is going over the two PA axes\n",
    "                '''print(xs_data_list[x], np.shape(xs_data_list[x]))\n",
    "                print(np.shape(model_v_blue[x]))\n",
    "                continue\n",
    "                '''\n",
    "                axs[x].scatter(xs_data_list[x], ma.masked_where(model_v_blue[x]==0, model_v_blue[x]), color = '#3587A4', label = 'Model Blue', marker='^')\n",
    "                axs[x].errorbar(xs_data_list[x], ma.masked_where(model_v_blue[x]==0, model_v_blue[x]), yerr=model_v_blue_std[x],color = '#3587A4', linestyle='None')\n",
    "                #axs[x].fill_between(xs_data_list[x], ma.masked_where(model_v_blue[x]==0, model_v_blue[x]) - model_v_blue_std[x],\n",
    "                #                   ma.masked_where(model_v_blue[x]==0, model_v_blue[x]) + model_v_blue_std[x], color = '#3587A4', alpha=0.5)\n",
    "                #plt.fill_between(x, y-error, y+error)\n",
    "\n",
    "\n",
    "                axs[x].scatter(xs_data_list[x], model_v_red[x], color = '#FFA69E', label = 'Model Red')\n",
    "                axs[x].errorbar(xs_data_list[x], ma.masked_where(model_v_red[x]==0, model_v_red[x]), yerr = model_v_red_std[x], color = '#FFA69E', linestyle='None')\n",
    "                #axs[x].fill_between(xs_data_list[x], ma.masked_where(model_v_red[x]==0, model_v_red[x]) - model_v_red_std[x],\n",
    "                #                   ma.masked_where(model_v_red[x]==0, model_v_red[x]) + model_v_red_std[x], color = '#FFA69E', alpha=0.5)\n",
    "                #plt.fill_between(x, y-error, y+error)\n",
    "                max_weight = 100\n",
    "\n",
    "                for j in range(len(xs_data_list[x][int(len(xs_data_list[x])/2):])):\n",
    "                    weight =  1 - max(error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j])/max_weight\n",
    "                    if weight < 0:\n",
    "                        weight = 0\n",
    "                    #print(j,  xs_data_list[x][int(len(xs_data_list[x])/2):][j],'weight', weight, max_weight, weight/max_weight)  \n",
    "                    if j == 0 :\n",
    "                        axs[x].scatter(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], \n",
    "                                       label='PA '+str(PA_pos[x])+' Blue ', color=color_list[0], marker='^', alpha = weight, s= pointsize)\n",
    "                        axs[x].errorbar(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], \n",
    "                                        yerr=np.array([[error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j]]]).T, capsize=5, \n",
    "                                 color=color_list[0],ls='None', alpha=weight)\n",
    "                    else:\n",
    "                        axs[x].scatter(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], \n",
    "                                       color=color_list[0], marker='^', alpha = weight, s= pointsize)\n",
    "                        axs[x].errorbar(np.array(xs_data_list[x][int(len(xs_data_list[x])/2):])[j], vel_data_list[x][int(len(xs_data_list[x])/2):][j], \n",
    "                                        yerr=np.array([[error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j]]]).T, capsize=5, \n",
    "                                 color=color_list[0],ls='None', alpha=weight)\n",
    "                for j in range(len(xs_data_list[x][:int(len(xs_data_list[x])/2)])):\n",
    "                    weight =  1 - max(error_down_list[x][int(len(xs_data_list[x])/2):][j],error_up_list[x][int(len(xs_data_list[x])/2):][j])/max_weight\n",
    "                    if weight < 0:\n",
    "                        weight = 0\n",
    "                    #print(j,  xs_data_list[x][int(len(xs_data_list[x])/2):][j],'weight', weight, max_weight, weight/max_weight)  \n",
    "                    if j == 0 :\n",
    "                        axs[x].scatter(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], \n",
    "                                       label='PA '+str(PA_pos[x])+' Red ', color=color_list[1], alpha = weight, s= pointsize, zorder=100)\n",
    "                        axs[x].errorbar(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], \n",
    "                                        yerr=np.array([[error_down_list[x][:int(len(xs_data_list[x])/2)][j],error_up_list[x][:int(len(xs_data_list[x])/2)][j]]]).T, capsize=5, \n",
    "                                 color=color_list[1],ls='None', alpha=weight)\n",
    "                    else:\n",
    "\n",
    "                        axs[x].scatter(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j],  \n",
    "                                       color=color_list[1], alpha = weight, s= pointsize, zorder=100)\n",
    "                        axs[x].errorbar(np.array(xs_data_list[x][:int(len(xs_data_list[x])/2)])[j], vel_data_list[x][:int(len(xs_data_list[x])/2)][j], \n",
    "                                        yerr=np.array([[error_down_list[x][:int(len(xs_data_list[x])/2)][j],error_up_list[x][:int(len(xs_data_list[x])/2)][j]]]).T, capsize=5, \n",
    "                                 color=color_list[1],ls='None', alpha=weight)\n",
    "                axs[x].legend(loc=1)\n",
    "                axs[x].set_ylim([-600,600])#[np.min(vel_data_list[x]),np.max(vel_data_list[x])])\n",
    "                axs[x].set_title('PA #'+str(x+1))\n",
    "                axs[x].axhline(y=0, color='k')\n",
    "\n",
    "        \n",
    "    \n",
    "    \n",
    "    \n",
    "    # So the velocity from the input is in a shape\n",
    "\n",
    "    vel_model_cut = {key:[] for key in range(np.shape(vel_data_list)[0])}\n",
    "    for n in range(np.shape(boundaries)[0]):\n",
    "        for k in range(int(len(model_v_red[n])/2)):\n",
    "            vel_model_cut[n].append(model_v_red[n][k])\n",
    "        for j in range(int(len(model_v_blue[n])/2)):\n",
    "            #fill = j+k\n",
    "            vel_model_cut[n].append(model_v_blue[n][j])\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    resid=[]\n",
    "    \n",
    "    sum_masked=[]\n",
    "    \n",
    "    for n in range(np.shape(boundaries)[0]):\n",
    "        for i in range(len(vel_model_cut[n])):\n",
    "            if vel_model_cut[n][i]==0:\n",
    "                sum_masked.append(1)\n",
    "            else:\n",
    "                resid.append(-0.5*(((vel_model_cut[n][i]-vel_data_list[n][i])**2)/(np.sqrt(v_e_up[n][i]**2+v_e_down[n][i]**2))**2))\n",
    "    \n",
    "    masked_elements_sum=2*np.sum(sum_masked)\n",
    "\n",
    "    n=2*(len(resid))# count the number of elements in vel_data_list\n",
    "    k=5\n",
    "\n",
    "    print('-lnlike', np.sum(resid)/(n-k-1-masked_elements_sum))\n",
    "    if verbose=='yes':\n",
    "        if len(PA_pos)==1:\n",
    "            axs.annotate('Best Fit Model lnlike = '+str(round(np.sum(resid)/(n-k-1-masked_elements_sum),2)), xy =(0.02, 1.02), xycoords='axes fraction', size=20)\n",
    "        else:\n",
    "            axs[0].annotate('Best Fit Model lnlike = '+str(round(np.sum(resid)/(n-k-1-masked_elements_sum),2)), xy =(0.02, 1.02), xycoords='axes fraction', size=20)\n",
    "        plt.savefig('data_model_'+str(name)+'.png')\n",
    "    \n",
    "    return np.sum(resid)/(n-k-1-masked_elements_sum)\n",
    "\n",
    "\n",
    "\n",
    "print('compiled')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Akira_45\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/beckynevin/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:754: VisibleDeprecationWarning: Passing `normed=True` on non-uniform bins has always been broken, and computes neither the probability density function nor the probability mass function. The result is only correct if the bins are uniform, when density=True will produce the same result anyway. The argument will be removed in a future version of numpy.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "size 6 5 that was x y\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'STOP' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-6773c3a9f2d9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m    103\u001b[0m     \u001b[0mmean_0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmean_1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmean_2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmean_3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmean_4\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m15\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m33\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m40\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m332\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    104\u001b[0m     \u001b[0margs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mboundaries\u001b[0m\u001b[0;34m,\u001b[0m  \u001b[0mxs_data_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvel_data_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0merror_up_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0merror_down_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'yes'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxs_proj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mys_proj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 105\u001b[0;31m     \u001b[0mlnlike_bicone_plot_profile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmean_0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmean_1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmean_2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmean_3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmean_4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    106\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    107\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-3-7fd03ef2124d>\u001b[0m in \u001b[0;36mlnlike_bicone_plot_profile\u001b[0;34m(z, *args)\u001b[0m\n\u001b[1;32m    785\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'size'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_slits\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_slits\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'that was x y'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    786\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 787\u001b[0;31m     \u001b[0mSTOP\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    788\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    789\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;34m'yes'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;31m#then plot it\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'STOP' is not defined"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1440x1080 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1440x1080 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 30 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "from scipy import stats\n",
    "# Now, this part calls whatever galaxy you are running\n",
    "names=['Akira_45']\n",
    "for z in range(len(names)):\n",
    "    name=names[z]\n",
    "    \n",
    "    print(name)\n",
    "    \n",
    "    minus_one=0\n",
    "    if name =='Akira_90':\n",
    "        PA_1 = 'akira_slit1_input_bin90_edited.txt'\n",
    "        PA1 = 40\n",
    "        pixelscale_1 = 0.15\n",
    "        slitwidth = 0.75\n",
    "        minus_pa_1 = 0\n",
    "        spatial_resolution=0.4626\n",
    "        PA_s = [PA_1]\n",
    "        PA_pos = [PA1]\n",
    "        minus_list = [minus_pa_1]\n",
    "        cen_0 = [0,0]\n",
    "        cen_list = [cen_0]\n",
    "    \n",
    "    \n",
    "    if name =='Akira_45':\n",
    "        PA_1 = 'akira_slit1_input_bin45_edited.txt'\n",
    "        PA1 = 40\n",
    "        pixelscale_1 = 0.15\n",
    "        slitwidth = 0.75\n",
    "        minus_pa_1 = 0\n",
    "        spatial_resolution=0.4626\n",
    "        PA_s = [PA_1]\n",
    "        PA_pos = [PA1]\n",
    "        minus_list = [minus_pa_1]\n",
    "        cen_0 = [0,0]\n",
    "        cen_list = [cen_0]\n",
    "    if name=='Akira':\n",
    "        PA_1 = 'akira_slit1_input.txt'\n",
    "        PA_2 = 'akira_slit2_input.txt'\n",
    "        PA_3 = 'akira_slit3_input.txt'\n",
    "        PA1 = 40\n",
    "        PA2 = 110\n",
    "        PA3 = PA1\n",
    "        pixelscale = 0.15 # This is arcsec per pixel\n",
    "        pixelscale_1 = pixelscale\n",
    "        pixelscale_2 = pixelscale\n",
    "        slitwidth = 0.75 # This is arcsec\n",
    "        \n",
    "        minus_pa_1 = 2\n",
    "        minus_pa_2 = 0\n",
    "        minus_pa_3 = 0\n",
    "        \n",
    "        spatial_resolution = 0.4626 # This is the res in arcsec\n",
    "        PA_s = [PA_1, PA_2, PA_3]\n",
    "        PA_pos = [PA1, PA2, PA3]\n",
    "        minus_list = [minus_pa_1, minus_pa_2, minus_pa_3]\n",
    "        \n",
    "        # the first two slits are centered at - RA = 136.0895, Dec = 41.4817\n",
    "        # the third slit is centered at - RA = 136.0911, Dec = 41.4807,\n",
    "        RA_1 = 136.0895\n",
    "        dec_1 = 41.4817\n",
    "        RA_2 = 136.0911\n",
    "        dec_2 = 41.4807\n",
    "        \n",
    "        ddec = (dec_2 - dec_1)*3600\n",
    "        print(ddec)\n",
    "        print('difference in dec', (dec_2 + dec_1)/2)\n",
    "        dRA = (RA_1 - RA_2) *3600 * np.cos(math.radians((dec_2 + dec_1)/2))\n",
    "        print(dRA)\n",
    "        \n",
    "        cen_0 = [0,0]\n",
    "        cen_1 = [0,0]\n",
    "        cen_2 = [dRA, ddec] # This is relative positioning\n",
    "        print('cen_2', cen_2)\n",
    "        cen_list = [cen_0,cen_1, cen_2]\n",
    "    \n",
    "    xs_data_list, vel_data_list, error_up_list, error_down_list = load_data(PA_s, minus_list, 1000)\n",
    "    \n",
    "    \n",
    "    \n",
    "    color_list = ['#E40066','#03CEA4','#EAC435','#4C4C9D','#48639C']\n",
    "    \n",
    "    # This makes some diagnostic plots of the input data:\n",
    "    plot_data(xs_data_list, vel_data_list, error_up_list, error_down_list, \n",
    "              PA_pos, spatial_resolution, color_list, name)\n",
    "    \n",
    "    # This function will use the PAs to project into x and y coordinates in arcesec\n",
    "    # in order to make the new boundaries\n",
    "    xs_proj, ys_proj = project_xy(cen_list, PA_pos, xs_data_list)\n",
    "    \n",
    "\n",
    "    start=datetime.datetime.now()\n",
    "    z_prelim=10,40,4,40,500\n",
    "\n",
    "    \n",
    "    # So this returns an array of the corners of all the spatial bins that you\n",
    "    # have in your data; it can then be used as an input to lnlike to compare with the model :)\n",
    "    \n",
    "    boundaries = a_function_that_computes_bounds(xs_proj, ys_proj, cen_list, PA_pos,  \n",
    "                                                 slitwidth, spatial_resolution,\n",
    "                                                color_list)\n",
    "    \n",
    "    mean_0, mean_1, mean_2, mean_3, mean_4 = [15, 33, 6, 40, 332]\n",
    "    args = [boundaries,  xs_data_list, vel_data_list, error_up_list, error_down_list, 'yes', xs_proj, ys_proj, name]\n",
    "    lnlike_bicone_plot_profile([mean_0, mean_1, mean_2, mean_3, mean_4], *args)\n",
    "    \n",
    "    \n",
    "    STOP\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    end=datetime.datetime.now()\n",
    "    print(end-start)\n",
    "    print('youve done one run')\n",
    "    \n",
    "    \n",
    "    #`~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`\n",
    "    \n",
    "\n",
    "    def lnprior(z):\n",
    "        phi_array, theta_array, r_t, half_angle, vel_max_array=z\n",
    "        if -90 < phi_array < 90 and 0.0 < theta_array < 359.9 and 0 < r_t < 100 and 0 < half_angle < 90 and 10 < vel_max_array < 1000:\n",
    "            return 0.0\n",
    "        return -np.inf\n",
    "    #you also need the log likelihood function:                                                                                                                                                             \n",
    "    #we already have a log likelihood function                                                                                                                                                              \n",
    "    def lnprob(z, *args):\n",
    "        lp=lnprior(z)\n",
    "        if not np.isfinite(lp):\n",
    "            return -np.inf\n",
    "        return lp + lnlike_bicone(z, *args)\n",
    "    ndim, nwalkers=5,20#was 100\n",
    "    result=5,18.6,5,33.36,420\n",
    "    mult=10,5,1,5,10\n",
    "\n",
    "    #pos is the starting position for the walkers                                                                                                                                                           \n",
    "    pos=[result+mult*np.random.randn(ndim) for i in range(nwalkers)]\n",
    "    #print('pos', pos)                                                                                                                                                                                      \n",
    "\n",
    "    import emcee\n",
    "    start=datetime.datetime.now()\n",
    "    #count=0   \n",
    "    \n",
    "    #a=2, threads=48,\n",
    "    sampler=emcee.EnsembleSampler(nwalkers, ndim, lnprob, args=[boundaries,  xs_data_list, vel_data_list, error_up_list, error_down_list])\n",
    "    #sampler=emcee.EnsembleSampler(nwalkers, ndim, lnprob,a=1.75, threads=48)\n",
    "    print('You finished the prep for burn in')\n",
    "    \n",
    "    len_chain = 100\n",
    "    pos, prob, state = sampler.run_mcmc(pos,\n",
    "                                        len_chain, progress=True)\n",
    "    #was 200\n",
    "    end=datetime.datetime.now()\n",
    "    samples_pre=sampler.chain[:,:,:]\n",
    "    f_acc_pre=sampler.acceptance_fraction\n",
    "    #autocorr_pre=sampler.acor\n",
    "    print('f_acc burn in', f_acc_pre)\n",
    "    #print('autocorr for burn in', autocorr_pre)\n",
    "    print('pos after burn in', pos)\n",
    "    g=open(str(name)+\"/bicone/emcee_burn_0_c.txt\",\"w\")\n",
    "    h=open(str(name)+\"/bicone/emcee_burn_1_c.txt\",\"w\")\n",
    "    k=open(str(name)+\"/bicone/emcee_burn_2_c.txt\",\"w\")\n",
    "    l=open(str(name)+\"/bicone/emcee_burn_3_c.txt\",\"w\")\n",
    "    m=open(str(name)+\"/bicone/emcee_burn_4_c.txt\",\"w\")\n",
    "    n=open(str(name)+\"/bicone/emcee_burn_f_acc_c.txt\",\"w\")\n",
    "    for i in range(nwalkers):\n",
    "        for j in range(len_chain):\n",
    "            g.write(str(samples_pre[i][j][0])+'\\n')\n",
    "            h.write(str(samples_pre[i][j][1])+'\\n')\n",
    "            k.write(str(samples_pre[i][j][2])+'\\n')\n",
    "            l.write(str(samples_pre[i][j][3])+'\\n')\n",
    "            m.write(str(samples_pre[i][j][4])+'\\n')\n",
    "\n",
    "    #       #n.write(str(f_acc_pre[i][j])+'\\n')                                                                                                                                                             \n",
    "    g.close()\n",
    "    h.close()\n",
    "    k.close()\n",
    "    l.close()\n",
    "    m.close()\n",
    "    \n",
    "    \n",
    "    plt.clf()\n",
    "    fig, axes = plt.subplots(5, figsize=(15, 7), sharex=True)\n",
    "    samples = sampler.get_chain()\n",
    "    labels = [\"inc\", \"PA\", \"r\",\"theta\", \"v\"]\n",
    "    for i in range(ndim):\n",
    "        ax = axes[i]\n",
    "        ax.plot(samples[:, :, i], \"k\", alpha=0.3)\n",
    "        ax.set_xlim(0, len(samples))\n",
    "        ax.set_ylabel(labels[i])\n",
    "        ax.yaxis.set_label_coords(-0.1, 0.5)\n",
    "\n",
    "    axes[-1].set_xlabel(\"step number\")\n",
    "    plt.savefig('walkers_bicone.png')\n",
    "\n",
    "\n",
    "    print(np.shape(samples_pre))\n",
    "    mean_0 = np.mean(samples_pre[:][len_chain-1][0])\n",
    "    mean_1 = np.mean(samples_pre[:][len_chain-1][1])\n",
    "    mean_2 = np.mean(samples_pre[:][len_chain-1][2])\n",
    "    mean_3 = np.mean(samples_pre[:][len_chain-1][3])\n",
    "    mean_4 = np.mean(samples_pre[:][len_chain-1][4])\n",
    "    print('mean variables', mean_0, mean_1, mean_2, mean_3, mean_4)\n",
    "    \n",
    "    # Now make a plot of the bicone from these\n",
    "    \n",
    "    args = [boundaries,  xs_data_list, vel_data_list, error_up_list, error_down_list, 'yes', xs_proj, ys_proj]\n",
    "    lnlike_bicone([mean_0, mean_1, mean_2, mean_3, mean_4], *args)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fabled corner plot:\n",
    "import corner\n",
    "\n",
    "fig = corner.corner(\n",
    "    samples_flat, labels=labels\n",
    ")\n",
    "plt.savefig('corner_plot_new.png')\n",
    "\n",
    "from IPython.display import display, Math\n",
    "\n",
    "for i in range(len_chain):\n",
    "    mcmc = np.percentile(samples_flat[:, i], [16, 50, 84])\n",
    "    q = np.diff(mcmc)\n",
    "    txt = \"\\mathrm{{{3}}} = {0:.3f}_{{-{1:.3f}}}^{{{2:.3f}}}\"\n",
    "    txt = txt.format(mcmc[1], q[0], q[1], labels[i])\n",
    "    display(Math(txt))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.shape(samples_pre))\n",
    "print(samples_pre[:,99,0])\n",
    "final = 99\n",
    "samples_flat = sampler.get_chain(flat=True)\n",
    "\n",
    "params = ['inc', 'PA', 'r', 'opening', 'vmax']\n",
    "for i in range(len(params)):\n",
    "    plt.clf()\n",
    "    fig = plt.figure(figsize=(12,2))\n",
    "    ax0 = fig.add_subplot(121)\n",
    "    ax0.hist(samples_flat[:, i], 20, color=\"k\", histtype=\"step\")\n",
    "    ax0.set_xlabel(params[i])\n",
    "    ax0.set_ylabel(r\"$p(\"+params[i]+\")$\")\n",
    "    \n",
    "    ax1 = fig.add_subplot(122)\n",
    "    for j in range(20):# there are 20 walkers, they walk for 50 steps\n",
    "        ax1.plot(samples_pre[j,:,i])\n",
    "    ax1.set_ylabel(params[i])\n",
    "    ax1.set_xlabel('Steps')\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "print(\"Mean acceptance fraction: {0:.3f}\".format(np.mean(sampler.acceptance_fraction)))\n",
    "\n",
    "'''print(\n",
    "    \"Mean autocorrelation time: {0:.3f} steps\".format(\n",
    "        np.mean(sampler.get_autocorr_time())\n",
    "    )\n",
    ")'''\n",
    "\n",
    "# Now get the mean dists\n",
    "for i in range(len(params)):\n",
    "    print('Parameter ', params[i])\n",
    "    print('Starting mean is ', np.mean(samples_pre[:,0,i]))\n",
    "    print('Starting std is ',np.std(samples_pre[:,0,i]))\n",
    "    \n",
    "    print('Ending mean is ', np.mean(samples_pre[:,final,i]))\n",
    "    print('Ending std is ',np.std(samples_pre[:,final,i]))\n",
    "    \n",
    "    plt.clf()\n",
    "    plt.hist(samples_pre[:,0,i], 20, color=\"k\", histtype=\"step\", label='Starting')\n",
    "    plt.hist(samples_pre[:,final,i], 20, color=\"r\", histtype=\"step\", label='Ending')\n",
    "    plt.xlabel(params[i])\n",
    "    plt.legend()\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-lnlike 7100.621884435163\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "7100.621884435163"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1080 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Now make a plot of the bicone from these\n",
    "mean_0, mean_1, mean_2, mean_3, mean_4 = [-5, 13,6, 32, 432]\n",
    "args = [boundaries,  xs_data_list, vel_data_list, error_up_list, error_down_list, 'yes', xs_proj, ys_proj]\n",
    "lnlike_bicone_plot([mean_0, mean_1, mean_2, mean_3, mean_4], *args)\n"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}