From ed134dda3e081e6d67aabaef4f337869aaf680ba Mon Sep 17 00:00:00 2001
From: Juan David Hernandez Ramirez <hernandezj@jupyterMiLAB>
Date: Thu, 18 Feb 2021 20:40:18 -0500
Subject: [PATCH] =?UTF-8?q?se=20a=C3=B1ade=20analisis=20con=20barras=20de?=
 =?UTF-8?q?=20error?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ENTREGA.ipynb | 185 ++++++++++++++++++++++++++++++++++++++++++++------
 ENTREGA.md    | 123 ++++++++++++++++++++++++++-------
 2 files changed, 265 insertions(+), 43 deletions(-)

diff --git a/ENTREGA.ipynb b/ENTREGA.ipynb
index 8163916..ee1acfc 100644
--- a/ENTREGA.ipynb
+++ b/ENTREGA.ipynb
@@ -78,7 +78,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7f79a0cfae80>"
+       "<matplotlib.image.AxesImage at 0x7fd5fe36ccf8>"
       ]
      },
      "execution_count": 4,
@@ -137,7 +137,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7f79a0c365f8>"
+       "<matplotlib.image.AxesImage at 0x7fd5fe2aa400>"
       ]
      },
      "execution_count": 6,
@@ -170,7 +170,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7f79a0bac1d0>"
+       "<matplotlib.image.AxesImage at 0x7fd5fe291f60>"
       ]
      },
      "execution_count": 7,
@@ -203,7 +203,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7f79a0b907b8>"
+       "<matplotlib.image.AxesImage at 0x7fd5fe203630>"
       ]
      },
      "execution_count": 8,
@@ -243,7 +243,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7f79a0afbb00>"
+       "<matplotlib.image.AxesImage at 0x7fd5fe16f978>"
       ]
      },
      "execution_count": 9,
@@ -318,7 +318,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7f79a0a684e0>"
+       "<matplotlib.image.AxesImage at 0x7fd5fe0dc390>"
       ]
      },
      "execution_count": 11,
@@ -393,7 +393,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7f79a0a4f898>"
+       "<matplotlib.image.AxesImage at 0x7fd5fe0c3780>"
       ]
      },
      "execution_count": 13,
@@ -449,7 +449,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7f799ceade10>"
+       "<matplotlib.image.AxesImage at 0x7fd5fa524a20>"
       ]
      },
      "execution_count": 15,
@@ -525,7 +525,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7f799cccbda0>"
+       "<matplotlib.image.AxesImage at 0x7fd5fa33fc18>"
       ]
      },
      "execution_count": 18,
@@ -617,6 +617,40 @@
     "               ,np.reshape(star5,144),np.reshape(star6,144),np.reshape(star7,144),np.reshape(star8,144)]"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 84,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<ErrorbarContainer object of 3 artists>"
+      ]
+     },
+     "execution_count": 84,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "z=np.sqrt(estrellasshape[0])\n",
+    "equis=np.arange(0,144,1)\n",
+    "plt.errorbar(equis,estrellasshape[0], z,capsize=7, fmt='o')"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -718,7 +752,7 @@
     {
      "data": {
       "text/plain": [
-       "<mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x7f79a0a15c18>"
+       "<mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x7fd5fa4e7b38>"
       ]
      },
      "execution_count": 27,
@@ -760,7 +794,7 @@
     {
      "data": {
       "text/plain": [
-       "<mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x7f799cbe12e8>"
+       "<mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x7fd5fa2551d0>"
       ]
      },
      "execution_count": 28,
@@ -811,7 +845,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.colorbar.Colorbar at 0x7f799cac6748>"
+       "<matplotlib.colorbar.Colorbar at 0x7fd6056109e8>"
       ]
      },
      "execution_count": 30,
@@ -844,7 +878,7 @@
     {
      "data": {
       "text/plain": [
-       "<mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x7f799caa4048>"
+       "<mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x7fd5fa112ef0>"
       ]
      },
      "execution_count": 31,
@@ -1384,6 +1418,116 @@
     "FWHMB.mean()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### FWHM incluyendo la incertidumbre de la medida"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "En medidas que se llevan a cabo a partir del conteo de fotones, el proceso sigue un estadística de Poisson y si el flujo es grande, toma forma gaussiana. Para este caso, la incertidumbre viene dada por la raíz cuadrada del flujo."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Para determinar el ancho de las barras de error, basta con tomar la raíz cuadrada de los arreglos 1D que contienen la información de la imagen de las estrellas. (np.sqrt())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 85,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "error=[np.sqrt(np.reshape(star1,144)),np.sqrt(np.reshape(star2,144)),np.sqrt(np.reshape(star3,144)),np.sqrt(np.reshape(star4,144))\n",
+    "       ,np.sqrt(np.reshape(star5,144)),np.sqrt(np.reshape(star6,144)),np.sqrt(np.reshape(star7,144)),np.sqrt(np.reshape(star8,144))]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "El ancho de las barra de error nos permite \"amortiguar\" valores que se encuentren lejanos a los medidos experimentalmente. Para esto es necesario dividir la diferencia entre la función y los datos entre el ancho de la barra de error."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 86,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def errorbar(tpl,x,y,z,sigma):\n",
+    "    return ((gauss2D(tpl,x,y)-z)/sigma).ravel()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ahora procedemos a calcular los coeficientes de la función gaussiana utilizando esta nueva función."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 87,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bestBar=[]\n",
+    "m=0\n",
+    "while m < len(estrellas):\n",
+    "    bestBar.append(leastsq(errorbar, p[m], args=(xx,yy,estrellasshape[m],error[m])))\n",
+    "    m+=1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finalmente calculamos el sigma de cada gaussiana y el FWHM promedio."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 90,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sigmasBar=[]\n",
+    "o=0\n",
+    "while o < len(estrellasB):\n",
+    "    sigmasBar.append(math.sqrt(abs(bestBar[o][0][4])))\n",
+    "    o+=1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.3441085375998454"
+      ]
+     },
+     "execution_count": 91,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sigmasnpBar=np.array(sigmasBar)\n",
+    "FWHMBar=2*math.sqrt(2*math.log(2))*sigmasnpBar\n",
+    "FWHMBar.mean()"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -1393,18 +1537,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 59,
+   "execution_count": 92,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "+--------------------+---------+---------+---------+\n",
-      "|   Escala de Grises |       R |       G |       B |\n",
-      "|--------------------+---------+---------+---------|\n",
-      "|            2.09742 | 2.31156 | 2.32033 | 2.38171 |\n",
-      "+--------------------+---------+---------+---------+\n"
+      "+--------------------+---------+---------+---------+-----------------------+\n",
+      "|   Escala de Grises |       R |       G |       B |   Con Barras de Error |\n",
+      "|--------------------+---------+---------+---------+-----------------------|\n",
+      "|            2.09742 | 2.31156 | 2.32033 | 2.38171 |               2.34411 |\n",
+      "+--------------------+---------+---------+---------+-----------------------+\n"
      ]
     }
    ],
@@ -1412,7 +1556,8 @@
     "df = pd.DataFrame({'Escala de Grises' : [FWHM.mean()],\n",
     "                   'R' : [FWHMR.mean()],\n",
     "                  'G' : [FWHMG.mean()],\n",
-    "                 'B' : [FWHMB.mean()]})\n",
+    "                 'B' : [FWHMB.mean()],\n",
+    "                  'Con Barras de Error' : [FWHMBar.mean()]})\n",
     "print(tabulate(df, headers='keys', tablefmt='psql',showindex=\"never\"))"
    ]
   },
diff --git a/ENTREGA.md b/ENTREGA.md
index 80ecc8f..7206516 100644
--- a/ENTREGA.md
+++ b/ENTREGA.md
@@ -39,7 +39,7 @@ plt.imshow(estrella)
 
 
 
-    <matplotlib.image.AxesImage at 0x7f79a0cfae80>
+    <matplotlib.image.AxesImage at 0x7fd5fe36ccf8>
 
 
 
@@ -72,7 +72,7 @@ plt.imshow(R,cmap='gray')
 
 
 
-    <matplotlib.image.AxesImage at 0x7f79a0c365f8>
+    <matplotlib.image.AxesImage at 0x7fd5fe2aa400>
 
 
 
@@ -91,7 +91,7 @@ plt.imshow(G,cmap='gray')
 
 
 
-    <matplotlib.image.AxesImage at 0x7f79a0bac1d0>
+    <matplotlib.image.AxesImage at 0x7fd5fe291f60>
 
 
 
@@ -110,7 +110,7 @@ plt.imshow(B,cmap='gray')
 
 
 
-    <matplotlib.image.AxesImage at 0x7f79a0b907b8>
+    <matplotlib.image.AxesImage at 0x7fd5fe203630>
 
 
 
@@ -131,7 +131,7 @@ plt.imshow(grisprom,cmap='gray')
 
 
 
-    <matplotlib.image.AxesImage at 0x7f79a0afbb00>
+    <matplotlib.image.AxesImage at 0x7fd5fe16f978>
 
 
 
@@ -169,7 +169,7 @@ plt.imshow(grisprom,cmap='gray')
 
 
 
-    <matplotlib.image.AxesImage at 0x7f79a0a684e0>
+    <matplotlib.image.AxesImage at 0x7fd5fe0dc390>
 
 
 
@@ -206,7 +206,7 @@ plt.imshow(gray1,cmap='gray')
 
 
 
-    <matplotlib.image.AxesImage at 0x7f79a0a4f898>
+    <matplotlib.image.AxesImage at 0x7fd5fe0c3780>
 
 
 
@@ -237,7 +237,7 @@ axarr[1].imshow(seccion2,cmap='gray')
 
 
 
-    <matplotlib.image.AxesImage at 0x7f799ceade10>
+    <matplotlib.image.AxesImage at 0x7fd5fa524a20>
 
 
 
@@ -284,7 +284,7 @@ axarr[1,3].imshow(star8,cmap='gray')
 
 
 
-    <matplotlib.image.AxesImage at 0x7f799cccbda0>
+    <matplotlib.image.AxesImage at 0x7fd5fa33fc18>
 
 
 
@@ -322,6 +322,26 @@ estrellasshape=[np.reshape(star1,144),np.reshape(star2,144),np.reshape(star3,144
                ,np.reshape(star5,144),np.reshape(star6,144),np.reshape(star7,144),np.reshape(star8,144)]
 ```
 
+
+```python
+z=np.sqrt(estrellasshape[0])
+equis=np.arange(0,144,1)
+plt.errorbar(equis,estrellasshape[0], z,capsize=7, fmt='o')
+```
+
+
+
+
+    <ErrorbarContainer object of 3 artists>
+
+
+
+
+    
+![png](output_42_1.png)
+    
+
+
 Creamos dos arreglos que tengan de longitud el eje x y y de las imágenes de las estrellas.
 
 
@@ -381,13 +401,13 @@ ax.plot_surface(xx,yy, zz2, rstride=3, cstride=3, linewidth=1, antialiased=True,
 
 
 
-    <mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x7f79a0a15c18>
+    <mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x7fd5fa4e7b38>
 
 
 
 
     
-![png](output_52_1.png)
+![png](output_53_1.png)
     
 
 
@@ -403,13 +423,13 @@ ax.plot_surface(xx,yy, estrellas[0], rstride=3, cstride=3, linewidth=1, antialia
 
 
 
-    <mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x7f799cbe12e8>
+    <mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x7fd5fa2551d0>
 
 
 
 
     
-![png](output_54_1.png)
+![png](output_55_1.png)
     
 
 
@@ -430,13 +450,13 @@ plt.colorbar()
 
 
 
-    <matplotlib.colorbar.Colorbar at 0x7f799cac6748>
+    <matplotlib.colorbar.Colorbar at 0x7fd6056109e8>
 
 
 
 
     
-![png](output_57_1.png)
+![png](output_58_1.png)
     
 
 
@@ -450,13 +470,13 @@ ax.plot_surface(xx,yy, error2(best[0][0],xx,yy,estrellas[0]), rstride=3, cstride
 
 
 
-    <mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x7f799caa4048>
+    <mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x7fd5fa112ef0>
 
 
 
 
     
-![png](output_58_1.png)
+![png](output_59_1.png)
     
 
 
@@ -752,6 +772,62 @@ FWHMB.mean()
 
 
 
+### FWHM incluyendo la incertidumbre de la medida
+
+En medidas que se llevan a cabo a partir del conteo de fotones, el proceso sigue un estadística de Poisson y si el flujo es grande, toma forma gaussiana. Para este caso, la incertidumbre viene dada por la raíz cuadrada del flujo.
+
+Para determinar el ancho de las barras de error, basta con tomar la raíz cuadrada de los arreglos 1D que contienen la información de la imagen de las estrellas. (np.sqrt())
+
+
+```python
+error=[np.sqrt(np.reshape(star1,144)),np.sqrt(np.reshape(star2,144)),np.sqrt(np.reshape(star3,144)),np.sqrt(np.reshape(star4,144))
+       ,np.sqrt(np.reshape(star5,144)),np.sqrt(np.reshape(star6,144)),np.sqrt(np.reshape(star7,144)),np.sqrt(np.reshape(star8,144))]
+```
+
+El ancho de las barra de error nos permite "amortiguar" valores que se encuentren lejanos a los medidos experimentalmente. Para esto es necesario dividir la diferencia entre la función y los datos entre el ancho de la barra de error.
+
+
+```python
+def errorbar(tpl,x,y,z,sigma):
+    return ((gauss2D(tpl,x,y)-z)/sigma).ravel()
+```
+
+Ahora procedemos a calcular los coeficientes de la función gaussiana utilizando esta nueva función.
+
+
+```python
+bestBar=[]
+m=0
+while m < len(estrellas):
+    bestBar.append(leastsq(errorbar, p[m], args=(xx,yy,estrellasshape[m],error[m])))
+    m+=1
+```
+
+Finalmente calculamos el sigma de cada gaussiana y el FWHM promedio.
+
+
+```python
+sigmasBar=[]
+o=0
+while o < len(estrellasB):
+    sigmasBar.append(math.sqrt(abs(bestBar[o][0][4])))
+    o+=1
+```
+
+
+```python
+sigmasnpBar=np.array(sigmasBar)
+FWHMBar=2*math.sqrt(2*math.log(2))*sigmasnpBar
+FWHMBar.mean()
+```
+
+
+
+
+    2.3441085375998454
+
+
+
 ### Resumiendo los valores de FWHM en las 4 matrices, obtenemos.
 
 
@@ -759,15 +835,16 @@ FWHMB.mean()
 df = pd.DataFrame({'Escala de Grises' : [FWHM.mean()],
                    'R' : [FWHMR.mean()],
                   'G' : [FWHMG.mean()],
-                 'B' : [FWHMB.mean()]})
+                 'B' : [FWHMB.mean()],
+                  'Con Barras de Error' : [FWHMBar.mean()]})
 print(tabulate(df, headers='keys', tablefmt='psql',showindex="never"))
 ```
 
-    +--------------------+---------+---------+---------+
-    |   Escala de Grises |       R |       G |       B |
-    |--------------------+---------+---------+---------|
-    |            2.09742 | 2.31156 | 2.32033 | 2.38171 |
-    +--------------------+---------+---------+---------+
+    +--------------------+---------+---------+---------+-----------------------+
+    |   Escala de Grises |       R |       G |       B |   Con Barras de Error |
+    |--------------------+---------+---------+---------+-----------------------|
+    |            2.09742 | 2.31156 | 2.32033 | 2.38171 |               2.34411 |
+    +--------------------+---------+---------+---------+-----------------------+
 
 
 Se encuentra que el FWHM para el caso de la imagen en escala de grises es menor que al tomar cada una de las matrices de forma independiente.
-- 
GitLab