Skip to content
Snippets Groups Projects
Commit 425809f3 authored by Arturo Sanchez's avatar Arturo Sanchez
Browse files

modificaciones

parent de8ded90
No related branches found
No related tags found
No related merge requests found
%% Cell type:markdown id: tags:
# Deposición Aleatoria
%% Cell type:markdown id: tags:
Inluimos las librerías 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 que van a depositarse en el espacio de longitud $L$.
%% 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()); //Rugosidad
datos<<t<<","<<Hm<<","<<W; //Guardando datos
datos<<endl;
}
datos.close();
```
......
%% Cell type:markdown id: tags:
# Deposición vecino más cercano
%% Cell type:markdown id: tags:
Inluimos las librerías 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 que van a depositarse en el espacio de longitud $L$.
%% 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()); //Rugosidad
datos<<t<<","<<Hm<<","<<W; //Guardando datos
datos<<endl;
}
datos.close();
```
......
%% Cell type:markdown id: tags:
# Deposición vecino siguiente más cercano
%% Cell type:markdown id: tags:
Inluimos las librerías 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 que van a depositarse en el espacio de longitud $L$.
%% 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()); //Rugosidad
datos<<t<<","<<Hm<<","<<W; //Guardando datos
datos<<endl;
}
datos.close();
```
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment