# Decaimiento radiactivo

Existen muchos modelos de decaimiento radiactivo, sin embargo, uno de los más sencillos es el considerar que la cantidad de material radioactivo decae de forma proporcional a la cantidad que tenga en un tiempo $t$. esto puede ser escrito de forma sencilla en el siguiente modelo:
$$\frac{\Delta N(t)}{\Delta t}\rightarrow\frac{dN}{dt}=\lambda N$$
Esta ecuación resulta de un promedio sobre un conjunto de atomos (Ensamble), esto se tiene para el caso en el que el numero de partículas $N\to\infty$ y el intervalo de observación $\Delta t \to 0$. La ecuación del modelo puede ser integrada y esta da como resultado algo llamado la ley expoenecial de decaimiento de los núcleos.

El siguiente programa efectua una simulación de del decaimiento de un nucleo.

Tomado de del libro A Survey of Computational Physics Introductory Computational Science de Landau, Paez, Bordeianu (Python Multimodal eTextBook Beta4.0)


```python
import numpy as np
import matplotlib.pylab as plt 
import random
```


```python
Lambda = 0.001 # Decay c o n s t a n t
maximum = 200. ; timemax = 500 # Pa rams
number = nloop = maximum # I n i t i a l v a l u e
lambda1 = 0.001
maximum = 200. ; timemax = 500
number = nloop = maximum
for time in range(0 , timemax + 1 ) : # Time l o o p
    for atom in range(1 , int(number) + 1 ) : # Decay l o o p
        decay = random.random( )
        if(decay < Lambda):
            nloop +=  -1
        number = nloop
```

El programa anterior simula el numero de atomos en un nucleo en función del tiempo a partir de la generación de números aleatorios con distribución uniforme.
# Ejercicio 1
Modifique el codigo anterior para guardar los valores que se obtienen de tiempo y numero de atomos en el nucleo, prepare una gráfica en donde muestre cual es el comportamiento que tiene el número de atomos en función del tiempo.


```python
Lambda = 0.001 # Decay c o n s t a n t
maximum = 200. ; timemax = 500 # Pa rams
number = nloop = maximum # I n i t i a l v a l u e
lambda1 = 0.001
maximum = 200. ; timemax = 500
number = nloop = maximum
Atomos=[]
tiempo=[]
for time in range(0 , timemax + 1 ) : # Time l o o p
    for atom in range(1 , int(number) + 1 ) : # Decay l o o p
        decay = random.random( )
        if(decay < Lambda):
            nloop +=  -1
        number = nloop
    Atomos.append(number)
    tiempo.append(time)
plt.plot(tiempo,Atomos)
plt.show()
```

# Ejercicio 2
Modifique el codigo efectuado en el ejercicio 1 con el fin de que no sólo se efectue el comportamiento de 1 nucleo si no que se efectue un ensamble de 1000 posibles comportamientos del número de atomos en el nucleo.
Efectue un promedio de todos los valores obtenidos para cada trayectoria y prepare una gráfica con el comportamiento del promedio.


```python
num_experimentos=100
Avg=np.zeros(timemax+1)
for experimento in range(num_experimentos):
    Lambda = 0.001 # Decay c o n s t a n t
    maximum = 200. ; timemax = 500 # Pa rams
    number = nloop = maximum # I n i t i a l v a l u e
    for time in range(0 , timemax + 1 ) : # Time l o o p
        for atom in range(1 , int(number) + 1 ) : # Decay l o o p
            decay = random.random( )
            if(decay < Lambda):
                nloop +=  -1
            number = nloop
        Avg[time] += number/num_experimentos
plt.plot(range(0 , timemax + 1 ),Avg)
plt.show()
```

# Ejercicio 3
Tome una trayectoria de su preferencia y tome el logaritmo  del numero de atomos en el nucleo y grafique estos resultados, intente recrear la figura 5.5 del libro guia.


```python
plt.plot(tiempo,np.log(Atomos))
plt.show()
```

# Ejercicio 4

Genere una gráfica en donde muestre que para distintos valores de $N(0)$ en el tiempo inicial, el comportamiento de $\ln(N(t)$ vs $t$ es invariante ante la escogencia de $N(0)$ 


```python
for i in (100,200,300,500,1000):
    Lambda = 0.001 # Decay c o n s t a n t
    maximum = float(i)
    timemax= 500 # Pa rams
    number = nloop = maximum # I n i t i a l v a l u e
    Atomos=[]
    tiempo=[]
    for time in range(0 , timemax + 1 ) : # Time l o o p
        for atom in range(1 , int(number) + 1 ) : # Decay l o o p
            decay = random.random( )
            if(decay < Lambda):
                nloop +=  -1
            number = nloop
        Atomos.append(number)
        tiempo.append(time)
    plt.plot(tiempo,np.log(Atomos))
plt.show()
```

# Ejercicio 5

La función de autocorrelación se define como la correlación cruzada de la señal consigo misma. 
Esta función resulta de gran utilidad para encontrar patrones repetitivos dentro de una señal, como la periodicidad de una señal enmascarada bajo el ruido o para identificar la frecuencia fundamental de una señal que no contiene dicha componente, pero aparecen numerosas frecuencias armónicas de esta.

Esta función está dada por:


\begin{equation}
\varphi(i)=\frac{1}{N}\sum_{j=1}^{N} \left(x_j - \langle X\rangle\right)\left(x_{i+j}-\langle X\rangle\right) \tag{D2}
\end{equation}

Y tiene la propiedad de que si se cumple:
\begin{equation}
\varphi(i=0)=\frac{1}{N}\sum_{j=1}^{N} \left(x_j - \langle X\rangle\right)^2=\langle x_j - \langle X\rangle\rangle^2=\sigma^2\tag{D3}
\end{equation}

\begin{equation}
\varphi(i\ne 0)= \langle x_j - \langle X\rangle\rangle\langle x_{i\ne j} - \langle X\rangle\rangle=0\hspace{5mm}
(\rightarrow{\rm White\ noise})\hspace{-12mm}
\tag{D4}
\end{equation}

se denomina que el proceso estocastico es un ruido blanco o que no tiene correlación alguna más que en el momento en el que este fue generado.

Haciendo uso de la función de ``numpy`` "correlate" calcule la función de correlación para una secuencia de puntos generados a partir de una distribución uniforme.


```python
x=np.random.uniform(0,3,1000)
corr=np.correlate(x-np.mean(x),x-np.mean(x),mode="full")
corr=corr/len(x)
```


```python
plt.plot(range(0,len(corr)//2 +1),corr[len(corr)//2:])
```

 Como se observa el valor del pico es de


```python
np.max(corr)
```




    0.7710989675733794



El cual coincide con la varianza de los numeros aleatorios


```python
np.var(x)
```




    0.7710989675733794



Y su promedio es:


```python
np.mean(corr)
```




    -2.7769460345801814e-19



Con lo cual sepuede ver que lo que se tiene acá es un ruido blanco generado a partir de una distribución uniforme


```python

```


```python

```


```python

```


```python

```

a93c56792e3d12ff4fe46d0d2c99949fb9b89441
ipynb
Jupyter Notebook
Seccion_1/Ejercicio_3 (1).ipynb
ComputoCienciasUniandes/FISI2029-201910
88909a78e562f8d5c61f3fd9178ed5f59f973945
MIT
Seccion_1/Ejercicio_3 (1).ipynb
ComputoCienciasUniandes/FISI2029-201910
88909a78e562f8d5c61f3fd9178ed5f59f973945
MIT
Seccion_1/Ejercicio_3 (1).ipynb
ComputoCienciasUniandes/FISI2029-201910
88909a78e562f8d5c61f3fd9178ed5f59f973945
MIT
2019-04-03T19:28:00.000Z
2019-06-28T15:18:56.000Z
Qwen/Qwen-72B
1. YES
2. YES