bohrpy 0.1.0__py3-none-any.whl

bohrpy/__init__.py

@@ -0,0 +1,29 @@
+"""
+bohrpy: Una librería en Python para el modelo del átomo de Bohr.
+Desarrollada para calcular niveles de energía, radios, transiciones electrónicas 
+y representaciones gráficas de átomos hidrogenoides.
+"""
+
+# Importamos la clase principal para facilitar su acceso
+from .bohr import BohrAtom
+
+# Importamos las constantes físicas
+from .constants import H_PLANCK, C_LIGHT, E_CHARGE, M_ELECTRON, A_0
+
+# Importamos las gráficas para usarlas sin entrar al módulo plots
+from .plots import plot_energy_levels, plot_orbits
+
+# Definición de la versión de la librería (ideal para publicar en PyPI)
+__version__ = "0.1.0"
+
+# Limitamos qué se importa cuando alguien usa 'from bohrpy import *'
+__all__ = [
+    "BohrAtom",
+    "H_PLANCK",
+    "C_LIGHT",
+    "E_CHARGE",
+    "M_ELECTRON",
+    "A_0",
+    "plot_energy_levels",
+    "plot_orbits",
+]

bohrpy/bohr.py

@@ -0,0 +1,84 @@
+from .constants import H_PLANCK, C_LIGHT, E_CHARGE, A_0
+
+class BohrAtom:
+    """
+    Clase que representa un átomo hidrogenoide según el modelo de Bohr.
+    Encapsula los parámetros físicos y métodos para cálculos y gráficos.
+    """
+    
+    def __init__(self, Z=1):
+        """
+        Inicializa el átomo con un número atómico Z.
+        Por defecto, Z=1 (Hidrógeno).
+        """
+        if not isinstance(Z, int) or Z < 1:
+            raise ValueError("El número atómico Z debe ser un entero positivo.")
+        self.Z = Z
+        # Energía del estado fundamental del Hidrógeno en eV (aprox -13.6 eV)
+        self.E1_H = -13.605693
+
+    def energy_level(self, n):
+        """
+        Calcula la energía del electrón en el nivel n en electrón-voltios (eV).
+        """
+        if n < 1:
+            raise ValueError("El número cuántico principal n debe ser >= 1.")
+        return self.E1_H * (self.Z**2) / (n**2)
+
+    def orbit_radius(self, n):
+        """
+        Calcula el radio de la órbita para el nivel n en metros (m).
+        """
+        if n < 1:
+            raise ValueError("El número cuántico principal n debe ser >= 1.")
+        return A_0 * (n**2) / self.Z
+
+    def transition(self, n_initial, n_final):
+        """
+        Calcula la transición electrónica entre dos niveles.
+        Retorna la diferencia de energía (eV), la frecuencia (Hz) y la longitud de onda (m) del fotón emitido o absorbido.
+        """
+        if n_initial == n_final:
+            raise ValueError("Los niveles inicial y final deben ser diferentes.")
+
+        e_i = self.energy_level(n_initial)
+        e_f = self.energy_level(n_final)
+        
+        # Diferencia de energía en eV y conversión a Julios
+        delta_E_eV = abs(e_f - e_i)
+        delta_E_J = delta_E_eV * E_CHARGE
+        
+        # Frecuencia: f = E / h
+        frequency = delta_E_J / H_PLANCK
+        
+        # Longitud de onda: lambda = c / f
+        wavelength = C_LIGHT / frequency
+        
+        return {
+            "delta_E_eV": delta_E_eV,
+            "frequency_Hz": frequency,
+            "wavelength_m": wavelength,
+            "type": "emisión" if n_initial > n_final else "absorción"
+        }
+
+    def plot_energy_levels(self, max_n=5, show=True, save_path=None):
+        """
+        Representa los niveles de energía y las transiciones hasta max_n.
+
+        El dibujo vive en plots.py. Este método solo expone esa gráfica
+        desde el átomo.
+        """
+        from .plots import plot_energy_levels
+
+        return plot_energy_levels(self, max_n=max_n, show=show, save_path=save_path)
+
+    def plot_orbits(self, max_n=4, show=True, save_path=None):
+        """
+        Dibuja las órbitas electrónicas en el plano hasta el nivel max_n.
+
+        El dibujo vive en plots.py. Este método solo expone esa gráfica
+        desde el átomo.
+        """
+        from .plots import plot_orbits
+
+        return plot_orbits(self, max_n=max_n, show=show, save_path=save_path)

bohrpy/constants.py

@@ -0,0 +1,14 @@
+"""
+Constantes físicas fundamentales para el modelo del átomo de Bohr.
+Valores basados en el Sistema Internacional (SI) y factores de conversión.
+"""
+
+H_PLANCK = 6.62607015e-34      # Constante de Planck (J·s)
+C_LIGHT = 299792458            # Velocidad de la luz en el vacío (m/s)
+E_CHARGE = 1.602176634e-19     # Carga elemental o del electrón (C)
+M_ELECTRON = 9.1093837015e-31  # Masa del electrón (kg)
+EPSILON_0 = 8.8541878128e-12   # Permitividad del vacío (F/m)
+
+# Constantes derivadas útiles
+K_COULOMB = 1 / (4 * 3.141592653589793 * EPSILON_0)  # Constante de Coulomb (N·m²/C²)
+A_0 = 5.29177210903e-11        # Radio de Bohr (m)

bohrpy/plots.py

@@ -0,0 +1,193 @@
+"""Gráficas del modelo de Bohr: niveles de energía y órbitas."""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Nombre y color de cada serie, según el nivel inferior de la transición.
+SERIES = {
+    1: ("Lyman", "#1f77b4"),
+    2: ("Balmer", "#d62728"),
+    3: ("Paschen", "#2ca02c"),
+    4: ("Brackett", "#9467bd"),
+    5: ("Pfund", "#8c564b"),
+}
+
+
+def _validar_max_n(max_n):
+    """Comprueba que el nivel máximo sea un entero mayor o igual que 1."""
+    if not isinstance(max_n, int) or isinstance(max_n, bool) or max_n < 1:
+        raise ValueError("max_n debe ser un entero mayor o igual que 1.")
+    return max_n
+
+
+def _estilo_serie(n_final):
+    """Devuelve el nombre y el color de la serie que termina en n_final."""
+    if n_final in SERIES:
+        return SERIES[n_final]
+    return (f"hacia n={n_final}", "#7f7f7f")
+
+
+def _guardar_o_mostrar(fig, show, save_path):
+    """Guarda la figura si hay ruta y la muestra si show es verdadero."""
+    if save_path is not None:
+        fig.savefig(save_path, dpi=150, bbox_inches="tight")
+    if show:
+        plt.show()
+
+
+def plot_energy_levels(atom, max_n=5, show=True, save_path=None):
+    """Dibuja los niveles de energía y las transiciones de emisión.
+
+    Cada línea horizontal es un nivel n. Las flechas bajan del nivel
+    inicial al final y se agrupan por serie (Lyman, Balmer, Paschen...).
+    Junto a cada flecha va la longitud de onda del fotón, en nanómetros.
+
+    Parameters
+    ----------
+    atom : BohrAtom
+        Átomo hidrogenoide cuyos niveles se van a dibujar.
+    max_n : int
+        Nivel más alto que entra en la figura.
+    show : bool
+        Si es verdadero, abre la ventana de la gráfica.
+    save_path : str o Path, opcional
+        Ruta donde se guarda la imagen. Si es None, no se guarda.
+
+    Returns
+    -------
+    tuple
+        La figura y los ejes de Matplotlib.
+    """
+    _validar_max_n(max_n)
+
+    fig, ax = plt.subplots(figsize=(8, 8))
+    energia_minima = atom.energy_level(1)
+
+    for n in range(1, max_n + 1):
+        energia = atom.energy_level(n)
+        ax.hlines(energia, 0, 1, colors="#1f4e79", linewidth=2)
+        ax.text(
+            1.04,
+            energia,
+            f"n = {n}    {energia:.2f} eV",
+            va="center",
+            fontsize=9,
+        )
+
+    # Cada transición ocupa su propia x. Las más largas van a la izquierda,
+    # donde hay más espacio vertical para la etiqueta.
+    transiciones = [
+        (n_inicial, n_final)
+        for n_final in range(1, max_n)
+        for n_inicial in range(n_final + 1, max_n + 1)
+    ]
+    transiciones.sort(
+        key=lambda niveles: atom.energy_level(niveles[0]) - atom.energy_level(niveles[1])
+    )
+    caja = {"boxstyle": "round,pad=0.12", "fc": "white", "ec": "none", "alpha": 0.9}
+
+    for indice, (n_inicial, n_final) in enumerate(transiciones):
+        _, color = _estilo_serie(n_final)
+        x = 0.06 + 0.88 * (indice + 0.5) / len(transiciones)
+        energia_inicial = atom.energy_level(n_inicial)
+        energia_final = atom.energy_level(n_final)
+        ax.annotate(
+            "",
+            xy=(x, energia_final),
+            xytext=(x, energia_inicial),
+            arrowprops={"arrowstyle": "-|>", "color": color, "lw": 1.4},
+        )
+        transicion = atom.transition(n_inicial, n_final)
+        longitud_nm = transicion["wavelength_m"] * 1e9
+        salto = abs(energia_inicial - energia_final)
+        if salto < 0.08 * abs(energia_minima):
+            y_texto = energia_inicial + 0.045 * abs(energia_minima)
+            va = "bottom"
+        else:
+            y_texto = (energia_inicial + energia_final) / 2
+            va = "center"
+        ax.text(
+            x,
+            y_texto,
+            f"{longitud_nm:.0f} nm",
+            color=color,
+            fontsize=7,
+            ha="center",
+            va=va,
+            bbox=caja,
+        )
+
+    for n_final in range(1, max_n):
+        nombre, color = _estilo_serie(n_final)
+        ax.plot([], [], color=color, label=nombre)
+
+    ax.set_xlim(-0.05, 1.62)
+    ax.set_ylim(energia_minima * 1.12, abs(energia_minima) * 0.08)
+    ax.set_xticks([])
+    ax.set_ylabel("Energía (eV)")
+    ax.set_title(f"Niveles de energía y transiciones (Z = {atom.Z})")
+    ax.grid(axis="y", linestyle="--", alpha=0.35)
+    ax.legend(title="Serie", loc="lower right", frameon=True)
+    fig.tight_layout()
+    _guardar_o_mostrar(fig, show, save_path)
+    return fig, ax
+
+
+def plot_orbits(atom, max_n=4, show=True, save_path=None):
+    """Dibuja las órbitas circulares del modelo de Bohr en el plano.
+
+    El núcleo queda en el origen. El radio se muestra en ångströms
+    para que la escala sea legible, y un punto marca al electrón
+    sobre el eje x de cada órbita.
+
+    Parameters
+    ----------
+    atom : BohrAtom
+        Átomo hidrogenoide cuyas órbitas se van a dibujar.
+    max_n : int
+        Nivel más alto que entra en la figura.
+    show : bool
+        Si es verdadero, abre la ventana de la gráfica.
+    save_path : str o Path, opcional
+        Ruta donde se guarda la imagen. Si es None, no se guarda.
+
+    Returns
+    -------
+    tuple
+        La figura y los ejes de Matplotlib.
+    """
+    _validar_max_n(max_n)
+
+    fig, ax = plt.subplots(figsize=(7.2, 7))
+    angulo = np.linspace(0, 2 * np.pi, 400)
+    colores = plt.cm.viridis(np.linspace(0.15, 0.9, max_n))
+
+    ax.scatter(
+        [0],
+        [0],
+        s=130,
+        c="#c0392b",
+        zorder=5,
+        label=f"Núcleo (Z = {atom.Z})",
+    )
+
+    for n, color in zip(range(1, max_n + 1), colores):
+        radio_angstrom = atom.orbit_radius(n) * 1e10
+        ax.plot(
+            radio_angstrom * np.cos(angulo),
+            radio_angstrom * np.sin(angulo),
+            color=color,
+            linewidth=1.8,
+            label=f"n = {n}    r = {radio_angstrom:.3f} Å",
+        )
+        ax.scatter([radio_angstrom], [0], s=30, color=color, zorder=4)
+
+    ax.set_aspect("equal")
+    ax.set_xlabel("x (Å)")
+    ax.set_ylabel("y (Å)")
+    ax.set_title(f"Órbitas del modelo de Bohr (Z = {atom.Z})")
+    ax.grid(True, linestyle="--", alpha=0.4)
+    ax.legend(loc="upper left", bbox_to_anchor=(1.02, 1), frameon=False)
+    fig.tight_layout()
+    _guardar_o_mostrar(fig, show, save_path)
+    return fig, ax

bohrpy-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Isabel Nieto y Kevin Osorio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bohrpy-0.1.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.1
+Name: bohrpy
+Version: 0.1.0
+Summary: Librería para cálculos y visualización del modelo atómico de Bohr
+Author: Isabel Nieto, Kevin Osorio
+License: MIT
+Project-URL: Homepage, https://github.com/isabelnieto900/bohrpy
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy==1.26.4
+Requires-Dist: matplotlib==3.6.3
+Provides-Extra: test
+Requires-Dist: pytest==9.2.0; extra == "test"
+
+# bohrpy
+
+Librería en Python del modelo atómico de Bohr para el hidrógeno y átomos hidrogenoides. Calcula niveles de energía, radios de órbita y transiciones electrónicas, y dibuja esos resultados.
+
+## Instalación
+
+Desde la raíz del repositorio:
+
+```bash
+python -m venv venv
+source venv/bin/activate
+pip install -e ".[test]"
+```
+
+El paquete pide estas versiones, que son las usadas en el proyecto:
+
+- `numpy==1.26.4`
+- `matplotlib==3.6.3`
+- `pytest==9.2.0` para las pruebas
+
+## Uso básico
+
+```python
+from bohrpy import BohrAtom
+
+hidrogeno = BohrAtom(Z=1)
+
+print(hidrogeno.energy_level(1))    # energía del nivel n, en eV
+print(hidrogeno.orbit_radius(1))    # radio de la órbita, en metros
+
+transicion = hidrogeno.transition(3, 2)
+print(transicion["delta_E_eV"])
+print(transicion["frequency_Hz"])
+print(transicion["wavelength_m"])
+print(transicion["type"])           # "emisión" o "absorción"
+
+hidrogeno.plot_energy_levels(max_n=5)
+hidrogeno.plot_orbits(max_n=4)
+```
+
+`Z` es el número atómico. Con `Z=1` se obtiene el hidrógeno y con `Z=2` el He+.
+
+Para guardar una figura sin abrir una ventana:
+
+```python
+hidrogeno.plot_energy_levels(max_n=5, show=False, save_path="niveles.png")
+hidrogeno.plot_orbits(max_n=4, show=False, save_path="orbitas.png")
+```
+
+## Ejemplo
+
+```bash
+python examples/ejemplo_uso.py
+```
+
+Imprime los niveles del hidrógeno, la línea de Balmer n = 3 → n = 2 y una absorción n = 1 → n = 2. También guarda las figuras en `examples/figuras/`.
+
+## Pruebas
+
+```bash
+pytest
+```
+
+## Autores
+
+- Isabel Nieto
+- Kevin Osorio

bohrpy-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+bohrpy/__init__.py,sha256=cdYvsFXqdvl0dlpVNyk7slFL0FLwW4aGccfX5S06Ga8,844
+bohrpy/bohr.py,sha256=Q7qqjWmaFH_XjYoQQKtC1r1kECe4IBRdkh_baP_musA,2988
+bohrpy/constants.py,sha256=dvZfLK6zalws7OqP-pKc60lmbtyW8GIiSIDyeOrq0b4,647
+bohrpy/plots.py,sha256=0wkLk3SacltHG1O-YnufS-7tLPmrPV9tg0fwuZV6i-w,6256
+bohrpy-0.1.0.dist-info/LICENSE,sha256=0dyNrY5V934bq3ZZg_qWXYUjtUsSD0GZvqbFcbcezsA,1084
+bohrpy-0.1.0.dist-info/METADATA,sha256=BgVHywMeAcufNucbfuGBCSRRZOXBpLFMkeBtSgE7SXk,2016
+bohrpy-0.1.0.dist-info/WHEEL,sha256=EWGgdj_eH-g9dwsWZOTG0kmGucEuKPxGzOKD-jAVUHs,92
+bohrpy-0.1.0.dist-info/top_level.txt,sha256=51jhWjESZlWunATjNLA2XcOZoyou2QZKu7Qc6VeR8sI,7
+bohrpy-0.1.0.dist-info/RECORD,,

bohrpy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.48.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bohrpy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bohrpy