modificaciones

f1c512f6 · Arturo Sanchez · 588c7aa8 · f1c512f6 · f1c512f6 · f1c512f6
Commit f1c512f6 authored 4 years ago by Arturo Sanchez
--- a/codigo/aleatoria.ipynb
+++ b/codigo/aleatoria.ipynb
@@ -11,7 +11,7 @@
   "cell_type": "markdown",
   "metadata": {},
   "source": [
-    "Inluimos las librerias necesarias"
+    "Inluimos las librerias necesarias."
   ]
  },
  {
@@ -134,7 +134,7 @@
    "        for(int i = 0; i < H.size(); i++){\n",
    "            ss=ss+(H[i]-Hm)*(H[i]-Hm);\n",
    "        }\n",
-    "        W = sqrt(ss/H.size()); //Altura media        \n",
+    "        W = sqrt(ss/H.size()); //Rugosidad       \n",
    "        datos<<t<<\",\"<<Hm<<\",\"<<W; //Guardando datos\n",
    "        datos<<endl;  \n",
    "  \n",

 %% Cell type:markdown id: tags:
 # Deposición Aleatoria
 %% Cell type:markdown id: tags:
-Inluimos las librerias necesarias
+Inluimos las librerias necesarias.
 %% Cell type:code id: tags:
 ``` c++
 #include<iostream>
 #include<vector>
 #include<stdlib.h>
 #include<time.h>
 #include<fstream>
 #include <math.h>
 using namespace std;
 ```
 %% Cell type:markdown id: tags:
 Definimos la longitud del espacio en donde caerán las partículas y el número de partículas.
 %% Cell type:code id: tags:
 ``` c++
 int L,P;
 L = 100; //Longitud del espacio
 P = 1000000; //Número de partículas
 ```
 %% Cell type:markdown id: tags:
 Creamos un vector que va a contener las alturas de las partículas.
 %% Cell type:code id: tags:
 ``` c++
 vector<int> H(L,0);
 ```
 %% Cell type:markdown id: tags:
 Definimos las variables Tiempo, Altura media y Rugosidad.
 %% Cell type:code id: tags:
 ``` c++
 int t=0; //Tiempo
 double Hm; //Altura media
 double W; //Rugosidad
 ```
 %% Cell type:markdown id: tags:
 Creamos un archivo para guardar los datos.
 %% Cell type:code id: tags:
 ``` c++
 //Archivo que va a guardar los datos
 ofstream datos("aleatoria.csv");
 ```
 %% Cell type:markdown id: tags:
 Procedemos a llenar el vector de alturas definido anteriormente, generando un número aleatorio $(l)$ entre $0$ y $L-1$ para que represente la posición en donde va a caer la partícula, luego hacemos $H[l] = H[l] + 1$, así hacemos para cada partícula hasta llenar el vector de altura. En el procedimiento se va calculando la altura media y rugosidad y el tiempo, y estos valores se guardan en el archivo aleatoria.csv.
 %% Cell type:code id: tags:
 ``` c++
 //Para cada particula}
    srand(time(NULL));
    for(int i=1;i<=P;i++){
        int l=rand()%(L);
        H[l] = H[l] + 1;
        double s = 0;
        for (int i = 0; i < H.size(); i++){
            s = s + H[i];
        }
        Hm = s/H.size(); //Altura media
        t=t+1; //Tiempo
        double sm = Hm;
        double ss = 0;
        for(int i = 0; i < H.size(); i++){
            ss=ss+(H[i]-Hm)*(H[i]-Hm);
        }
-        W = sqrt(ss/H.size()); //Altura media
+        W = sqrt(ss/H.size()); //Rugosidad
        datos<<t<<","<<Hm<<","<<W; //Guardando datos
        datos<<endl;
    }
    datos.close();
 ```

--- a/codigo/graficas.ipynb
+++ b/codigo/graficas.ipynb
@@ -281,7 +281,7 @@
   "cell_type": "markdown",
   "metadata": {},
   "source": [
-    "#### Deposicion aleatoria"
+    "#### Deposición aleatoria"
   ]
  },
  {
@@ -322,7 +322,7 @@
   "cell_type": "markdown",
   "metadata": {},
   "source": [
-    "#### Deposicion vecino mas cercano"
+    "#### Deposición vecino mas cercano"
   ]
  },
  {
@@ -363,7 +363,7 @@
   "cell_type": "markdown",
   "metadata": {},
   "source": [
-    "#### Deposicion vecino siguiente mas cercano"
+    "#### Deposición vecino siguiente mas cercano"
   ]
  },
  {

 %% Cell type:markdown id: tags:
 # Gráficas
 %% Cell type:markdown id: tags:
 Importamos las librerias necesarias.
 %% Cell type:code id: tags:
 ``` python
 import matplotlib.pyplot as plt
 %matplotlib inline
 import pandas as pd
 ```
 %% Cell type:code id: tags:
 ``` python
 import sys
 sys.path.append('../data-used/aleatoria.csv')
 sys.path.append('../data-used/vecino_mas_cercano.csv')
 sys.path.append('../data-used/vecino_siguiente_mas_cercano.csv')
 ```
 %% Cell type:markdown id: tags:
 Leemos los datos de cada deposición.
 %% Cell type:code id: tags:
 ``` python
 #deposicion aleatoria
 data1 = pd.read_csv('../data-used/aleatoria.csv')
 #deposicion vecino mas cercano
 data2 = pd.read_csv('../data-used/vecino_mas_cercano.csv')
 #deposicion vecino siguiente mas cercano
 data3 = pd.read_csv('../data-used/vecino_siguiente_mas_cercano.csv')
 ```
 %% Cell type:markdown id: tags:
 Guardamos los datos de altura media, rugosidad y tiempo para cada una de las deposiciones.
 %% Cell type:code id: tags:
 ``` python
 #deposicion aleatoria
 hm1= data1.iloc[:, 1]
 w1= data1.iloc[:, 2]
 t1 = data1.iloc[:,0]
 #deposicion vecino mas cercano
 hm2 = data2.iloc[:, 1]
 w2= data2.iloc[:, 2]
 t2 = data2.iloc[:,0]
 #deposicion vecino siguiente mas cercano
 hm3 = data3.iloc[:, 1]
 w3= data3.iloc[:, 2]
 t3 = data3.iloc[:,0]
 ```
 %% Cell type:markdown id: tags:
 ### Altura media vs Tiempo
 %% Cell type:markdown id: tags:
 Con los datos anteriores, graficamos la altura media vs tiempo para cada una de las deposiciones.
 %% Cell type:markdown id: tags:
 #### Deposición aleatoria
 %% Cell type:code id: tags:
 ``` python
 fig = plt.figure(figsize = (10,7))
 plt.subplot(111)
 #Título y ejes
 plt.xlabel('Tiempo', color = 'black', family = 'serif', size = '15')
 plt.ylabel('Altura media', color = 'black', family = 'serif', size = '15')
 plt.title('Deposicion aleatoria \n Altura media vs tiempo', color = 'darkred', family = 'serif', size = '20')
 #Gráfica para todos los datos
 plt.scatter(t1, hm1, c = 'black', marker='.')
 plt.show()
 ```
 %% Output
 %% Cell type:markdown id: tags:
 #### Deposición vecino mas cercano
 %% Cell type:code id: tags:
 ``` python
 fig = plt.figure(figsize = (10,7))
 plt.subplot(111)
 #plt.yscale('symlog') #Escala logaritmica en el eje de luminosidades para visualizar mejor
 #Título y ejes
 plt.xlabel('Tiempo', color = 'black', family = 'serif', size = '15')
 plt.ylabel('Altura media', color = 'black', family = 'serif', size = '15')
 plt.title('Deposicion vecino mas cercano \n Altura media vs tiempo', color = 'darkred', family = 'serif', size = '20')
 #Gráfica para todos los datos
 plt.scatter(t2, hm2,  c = 'blue', marker='.')
 plt.show()
 ```
 %% Output
 %% Cell type:markdown id: tags:
 #### Deposición vecino siguiente mas cercano
 %% Cell type:code id: tags:
 ``` python
 fig = plt.figure(figsize = (10,7))
 plt.subplot(111)
 #plt.yscale('symlog') #Escala logaritmica en el eje de luminosidades para visualizar mejor
 #Título y ejes
 plt.xlabel('Tiempo', color = 'black', family = 'serif', size = '15')
 plt.ylabel('Altura media', color = 'black', family = 'serif', size = '15')
 plt.title('Deposicion vecino siguiente mas cercano \n Altura media vs tiempo', color = 'darkred', family = 'serif', size = '20')
 #Gráfica para todos los datos
 plt.scatter( t3, hm3, c = 'red', marker='.')
 plt.show()
 ```
 %% Output
 %% Cell type:markdown id: tags:
 #### Todas las deposiciones
 %% Cell type:code id: tags:
 ``` python
 fig = plt.figure(figsize = (10,7))
 plt.subplot(111)
 #plt.yscale('symlog') #Escala logaritmica en el eje de luminosidades para visualizar mejor
 #Título y ejes
 plt.xlabel('Tiempo', color = 'black', family = 'serif', size = '15')
 plt.ylabel('Altura media', color = 'black', family = 'serif', size = '15')
 plt.title('Deposiciones \n Altura media vs tiempo', color = 'darkred', family = 'serif', size = '20')
 #Gráfica para todos los datos
 plt.scatter(t1, hm1, c = 'black', marker='.')
 plt.scatter(t2, hm2, c = 'blue', marker='.')
 plt.scatter(t3, hm3, c = 'red', marker='.')
 plt.show()
 ```
 %% Output
 %% Cell type:markdown id: tags:
 ### Rugosidad vs Tiempo
 %% Cell type:markdown id: tags:
 Con los datos anteriores, graficamos la rugosidad vs tiempo para cada una de las deposiciones.
 %% Cell type:markdown id: tags:
-#### Deposicion aleatoria
+#### Deposición aleatoria
 %% Cell type:code id: tags:
 ``` python
 fig = plt.figure(figsize = (10,7))
 plt.subplot(111)
 plt.yscale('symlog') #Escala logaritmica en el eje para visualizar mejor
 plt.xscale('symlog') #Escala logaritmica en el eje para visualizar mejor
 #Título y ejes
 plt.xlabel('Tiempo', color = 'black', family = 'serif', size = '15')
 plt.ylabel('Rugosidad', color = 'black', family = 'serif', size = '15')
 plt.title('Deposicion aleatoria \n Rugosidad vs tiempo', color = 'darkred', family = 'serif', size = '20')
 #Gráfica para todos los datos
 plt.scatter(t1, w1, c = 'black', marker='.')
 plt.show()
 ```
 %% Output
 %% Cell type:markdown id: tags:
-#### Deposicion vecino mas cercano
+#### Deposición vecino mas cercano
 %% Cell type:code id: tags:
 ``` python
 fig = plt.figure(figsize = (10,7))
 plt.subplot(111)
 plt.yscale('symlog') #Escala logaritmica para visualizar mejor
 plt.xscale('symlog') #Escala logaritmica para visualizar mejor
 #Título y ejes
 plt.xlabel('Tiempo', color = 'black', family = 'serif', size = '15')
 plt.ylabel('Rugosidad', color = 'black', family = 'serif', size = '15')
 plt.title('Deposicion vecino mas cercano \n Rugosidad vs tiempo', color = 'darkred', family = 'serif', size = '20')
 #Gráfica para todos los datos
 plt.scatter(t2, w2, c = 'blue', marker='.')
 plt.show()
 ```
 %% Output
 %% Cell type:markdown id: tags:
-#### Deposicion vecino siguiente mas cercano
+#### Deposición vecino siguiente mas cercano
 %% Cell type:code id: tags:
 ``` python
 fig = plt.figure(figsize = (10,7))
 plt.subplot(111)
 plt.yscale('symlog') #Escala logaritmica para visualizar mejor
 plt.xscale('symlog') #Escala logaritmica para visualizar mejor
 #Título y ejes
 plt.xlabel('Tiempo', color = 'black', family = 'serif', size = '15')
 plt.ylabel('Rugosidad', color = 'black', family = 'serif', size = '15')
 plt.title('Deposicion vecino siguiente mas cercano \n Rugosidad vs tiempo', color = 'darkred', family = 'serif', size = '20')
 #Gráfica para todos los datos
 plt.scatter(t3, w3, c = 'red', marker='.')
 plt.show()
 ```
 %% Output
 %% Cell type:markdown id: tags:
 #### Todas las deposiciones
 %% Cell type:code id: tags:
 ``` python
 fig = plt.figure(figsize = (10,7))
 plt.subplot(111)
 plt.yscale('symlog') #Escala logaritmica para visualizar mejor
 plt.xscale('symlog') #Escala logaritmica para visualizar mejor
 #Título y ejes
 plt.xlabel('Tiempo', color = 'black', family = 'serif', size = '15')
 plt.ylabel('Altura media', color = 'black', family = 'serif', size = '15')
 plt.title('Deposiciones \n Rugosidad vs tiempo', color = 'darkred', family = 'serif', size = '20')
 #Gráfica para todos los datos
 plt.scatter(t1, w1, c = 'black', marker='.')
 plt.scatter(t2, w2, c = 'blue', marker='.')
 plt.scatter(t3, w3, c = 'red', marker='.')
 plt.show()
 ```
 %% Output

--- a/codigo/vecino_mas_cercano.ipynb
+++ b/codigo/vecino_mas_cercano.ipynb
@@ -167,7 +167,7 @@
    "        for(int i = 0; i < H.size(); i++){\n",
    "            ss=ss+(H[i]-Hm)*(H[i]-Hm);\n",
    "        }\n",
-    "        W = sqrt(ss/H.size()); //Altura media        \n",
+    "        W = sqrt(ss/H.size()); //Rugosidad        \n",
    "        datos<<t<<\",\"<<Hm<<\",\"<<W; //Guardando datos\n",
    "        datos<<endl;  \n",
    "  \n",

 %% Cell type:markdown id: tags:
 # Deposición vecino más cercano
 %% Cell type:markdown id: tags:
 Inluimos las librerias necesarias.
 %% Cell type:code id: tags:
 ``` c++
 #include<iostream>
 #include<vector>
 #include<stdlib.h>
 #include<time.h>
 #include<fstream>
 #include <math.h>
 using namespace std;
 ```
 %% Cell type:markdown id: tags:
 Definimos la longitud del espacio en donde caerán las partículas y el número de partículas.
 %% Cell type:code id: tags:
 ``` c++
 int L,P;
 ```
 %% Cell type:code id: tags:
 ``` c++
 L = 100; //Longitud del espacio
 P = 1000000; //Número de partículas
 ```
 %% Cell type:markdown id: tags:
 Creamos un vector que va a contener las alturas de las partículas.
 %% Cell type:code id: tags:
 ``` c++
 vector<int> H(L,0);
 ```
 %% Cell type:markdown id: tags:
 Definimos las variables Tiempo, Altura media y Rugosidad.
 %% Cell type:code id: tags:
 ``` c++
 int t=0; //Tiempo
 double Hm; //Altura media
 double W; //Rugosidad
 ```
 %% Cell type:markdown id: tags:
 Creamos un archivo para guardar los datos.
 %% Cell type:code id: tags:
 ``` c++
 //Archivo que va a guardar los datos
 ofstream datos("vecino_mas_cercano.csv");
 ```
 %% Cell type:markdown id: tags:
 Procedemos a llenar el vector de alturas definido anteriormente, generando un número aleatorio  (𝑙)  entre  0  y  𝐿−1  para que represente la posición en donde va a caer la partícula, luego hacemos llenamos el vector de alturas tomando en cuenta como es la deposición vecino más cercano, así hacemos para cada partícula hasta llenar el vector de alturas. En el procedimiento se va calculando la altura media y rugosidad y el tiempo, y estos valores se guardan en el archivo vecino_mas_cercano.csv.
 %% Cell type:code id: tags:
 ``` c++
 //Para cada particula}
    srand(time(NULL));
    for(int i=1;i<=P;i++){
        int l=rand()%(L);
        if(l==0){
            int m;
            if(H[l]>H[l+1]) m = H[l];
            else m = H[l+1];
            if(m==H[l]) H[l]=H[l]+1;
            else H[l]=m;
        }
        else if(l==L-1){
            int m;
            if (H[l]>H[l-1]) m = H[l];
            else m = H[l-1];
            if(m==H[l]) H[l]=H[l]+1;
            else H[l]=m;
        }
        else {
            int m;
            if(H[l]>H[l-1] && H[l]>H[l+1]) m = H[l];
            else if(H[l-1]>H[l] && H[l-1]>H[l+1]) m = H[l-1];
            else if(H[l+1]>H[l] && H[l+1]>H[l-1]) m = H[l+1];
            else if(H[l]==H[l-1] && H[l+1]<H[l]) m = H[l];
            else if(H[l]==H[l+1] && H[l-1]<H[l]) m = H[l];
            else m = H[l];
            if(m==H[l]) H[l]=H[l]+1;
            else H[l]=m;
        }
        double s = 0;
        for (int i = 0; i < H.size(); i++){
            s = s + H[i];
        }
        Hm = s/H.size(); //Altura media
        t=t+1; //Tiempo
        double sm = Hm;
        double ss = 0;
        for(int i = 0; i < H.size(); i++){
            ss=ss+(H[i]-Hm)*(H[i]-Hm);
        }
-        W = sqrt(ss/H.size()); //Altura media
+        W = sqrt(ss/H.size()); //Rugosidad
        datos<<t<<","<<Hm<<","<<W; //Guardando datos
        datos<<endl;
    }
    datos.close();
 ```

--- a/codigo/vecino_siguiente_mas_cercano.ipynb
+++ b/codigo/vecino_siguiente_mas_cercano.ipynb
@@ -159,7 +159,7 @@
    "        for(int i = 0; i < H.size(); i++){\n",
    "            ss=ss+(H[i]-Hm)*(H[i]-Hm);\n",
    "        }\n",
-    "        W = sqrt(ss/H.size()); //Altura media        \n",
+    "        W = sqrt(ss/H.size()); //Rugosidad      \n",
    "        datos<<t<<\",\"<<Hm<<\",\"<<W; //Guardando datos\n",
    "        datos<<endl;  \n",
    "  \n",

 %% Cell type:markdown id: tags:
 # Deposición vecino siguiente más cercano
 %% Cell type:markdown id: tags:
 Inluimos las librerias necesarias.
 %% Cell type:code id: tags:
 ``` c++
 #include<iostream>
 #include<vector>
 #include<stdlib.h>
 #include<time.h>
 #include<fstream>
 #include <math.h>
 using namespace std;
 ```
 %% Cell type:markdown id: tags:
 Definimos la longitud del espacio en donde caerán las partículas y el número de partículas.
 %% Cell type:code id: tags:
 ``` c++
 int L,P;
 L = 100; //Longitud del espacio
 P = 1000000; //Numero de particulas
 ```
 %% Cell type:markdown id: tags:
 Creamos un vector que va a contener las alturas de las partículas.
 %% Cell type:code id: tags:
 ``` c++
 vector<int> H(L,0);
 ```
 %% Cell type:markdown id: tags:
 Definimos las variables Tiempo, Altura media y Rugosidad.
 %% Cell type:code id: tags:
 ``` c++
 int t=0; //Tiempo
 double Hm; //Altura media
 double W; //Rugosidad
 ```
 %% Cell type:markdown id: tags:
 Creamos un archivo para guardar los datos.
 %% Cell type:code id: tags:
 ``` c++
 //Archivo que va a guardar los datos
    ofstream datos("vecino_siguiente_mas_cercano.csv");
 ```
 %% Cell type:markdown id: tags:
 Procedemos a llenar el vector de alturas definido anteriormente, generando un número aleatorio (𝑙) entre 0 y 𝐿−1 para que represente la posición en donde va a caer la partícula, luego hacemos llenamos el vector de alturas tomando en cuenta como es la deposición vecino siguiente más cercano, así hacemos para cada partícula hasta llenar el vector de alturas. En el procedimiento se va calculando la altura media y rugosidad y el tiempo, y estos valores se guardan en el archivo vecino_siguiente_mas_cercano.csv.
 %% Cell type:code id: tags:
 ``` c++
 //Para cada particula}
    srand(time(NULL));
    for(int i=1;i<=P;i++){
        int l=rand()%(L);
        if(l==0){
            int m;
            if(H[l]>H[l+1]) m = H[l];
            else m = H[l+1];
            if(m==H[l]) H[l]=H[l]+1;
            else H[l]=m + 1;
        }
        else if(l==L-1){
            int m;
            if (H[l]>H[l-1]) m = H[l];
            else m = H[l-1];
            if(m==H[l]) H[l]=H[l]+1;
            else H[l]=m + 1;
        }
        else {
            int m;
            if(H[l]>H[l-1] && H[l]>H[l+1]) m = H[l];
            else if(H[l-1]>H[l] && H[l-1]>H[l+1]) m = H[l-1];
            else if(H[l+1]>H[l] && H[l+1]>H[l-1]) m = H[l+1];
            else if(H[l]==H[l-1] && H[l+1]<H[l]) m = H[l];
            else if(H[l]==H[l+1] && H[l-1]<H[l]) m = H[l];
            else m = H[l];
            if(m==H[l]) H[l]=H[l]+1;
            else H[l]=m + 1;
        }
        double s = 0;
        for (int i = 0; i < H.size(); i++){
            s = s + H[i];
        }
        Hm = s/H.size(); //Altura media
        t=t+1; //Tiempo
        double sm = Hm;
        double ss = 0;
        for(int i = 0; i < H.size(); i++){
            ss=ss+(H[i]-Hm)*(H[i]-Hm);
        }
-        W = sqrt(ss/H.size()); //Altura media
+        W = sqrt(ss/H.size()); //Rugosidad
        datos<<t<<","<<Hm<<","<<W; //Guardando datos
        datos<<endl;
    }
    datos.close();
 ```