bohrpy 0.1.0__tar.gz

bohrpy-0.1.0/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/PKG-INFO

@@ -0,0 +1,79 @@
+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
+Provides-Extra: test
+License-File: LICENSE
+
+# 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/README.md

@@ -0,0 +1,67 @@
+# 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/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools==68.1.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "bohrpy"
+version = "0.1.0"
+description = "Librería para cálculos y visualización del modelo atómico de Bohr"
+readme = "README.md"
+authors = [
+    { name = "Isabel Nieto" },
+    { name = "Kevin Osorio" },
+]
+license = { text = "MIT" }
+requires-python = ">=3.9"
+dependencies = [
+    "numpy==1.26.4",
+    "matplotlib==3.6.3",
+]
+
+[project.optional-dependencies]
+test = ["pytest==9.2.0"]
+
+[project.urls]
+Homepage = "https://github.com/isabelnieto900/bohrpy"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

bohrpy-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

bohrpy-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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/src/bohrpy.egg-info/PKG-INFO

@@ -0,0 +1,79 @@
+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
+Provides-Extra: test
+License-File: LICENSE
+
+# 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/src/bohrpy.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/bohrpy/__init__.py
+src/bohrpy/bohr.py
+src/bohrpy/constants.py
+src/bohrpy/plots.py
+src/bohrpy.egg-info/PKG-INFO
+src/bohrpy.egg-info/SOURCES.txt
+src/bohrpy.egg-info/dependency_links.txt
+src/bohrpy.egg-info/requires.txt
+src/bohrpy.egg-info/top_level.txt
+tests/test_bohr.py

bohrpy-0.1.0/src/bohrpy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bohrpy-0.1.0/src/bohrpy.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy==1.26.4
+matplotlib==3.6.3
+
+[test]
+pytest==9.2.0

bohrpy-0.1.0/src/bohrpy.egg-info/top_level.txt

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

bohrpy-0.1.0/tests/test_bohr.py

@@ -0,0 +1,104 @@
+"""Pruebas del modelo de Bohr: energías, radios, transiciones y gráficas."""
+
+import matplotlib
+
+matplotlib.use("Agg")
+
+import matplotlib.pyplot as plt
+import pytest
+
+from bohrpy import A_0, BohrAtom
+from bohrpy.constants import C_LIGHT, E_CHARGE, H_PLANCK
+
+
+def test_energia_del_estado_fundamental_del_hidrogeno():
+    atomo = BohrAtom(Z=1)
+    assert atomo.energy_level(1) == pytest.approx(-13.605693)
+
+
+def test_la_energia_crece_con_el_cuadrado_de_z():
+    hidrogeno = BohrAtom(Z=1)
+    helio = BohrAtom(Z=2)
+    assert helio.energy_level(1) == pytest.approx(4 * hidrogeno.energy_level(1))
+
+
+def test_la_energia_cae_con_el_cuadrado_de_n():
+    atomo = BohrAtom()
+    assert atomo.energy_level(2) == pytest.approx(atomo.energy_level(1) / 4)
+    assert atomo.energy_level(3) == pytest.approx(atomo.energy_level(1) / 9)
+
+
+def test_rechaza_nivel_y_numero_atomico_invalidos():
+    with pytest.raises(ValueError):
+        BohrAtom().energy_level(0)
+    with pytest.raises(ValueError):
+        BohrAtom(Z=0)
+    with pytest.raises(ValueError):
+        BohrAtom(Z=1.5)
+
+
+def test_radio_de_bohr_y_su_dependencia_con_n_y_z():
+    hidrogeno = BohrAtom(Z=1)
+    assert hidrogeno.orbit_radius(1) == pytest.approx(A_0)
+    assert hidrogeno.orbit_radius(2) == pytest.approx(4 * A_0)
+
+    helio = BohrAtom(Z=2)
+    assert helio.orbit_radius(1) == pytest.approx(A_0 / 2)
+
+
+def test_transicion_lyman_alfa_es_emision():
+    atomo = BohrAtom()
+    resultado = atomo.transition(2, 1)
+
+    delta_e = abs(atomo.energy_level(2) - atomo.energy_level(1))
+    frecuencia = delta_e * E_CHARGE / H_PLANCK
+
+    assert resultado["type"] == "emisión"
+    assert resultado["delta_E_eV"] == pytest.approx(delta_e)
+    assert resultado["frequency_Hz"] == pytest.approx(frecuencia)
+    assert resultado["wavelength_m"] == pytest.approx(C_LIGHT / frecuencia)
+    # La línea Lyman-alfa del hidrógeno está cerca de 121.6 nm.
+    assert resultado["wavelength_m"] * 1e9 == pytest.approx(121.6, abs=1.0)
+
+
+def test_transicion_de_absorcion_y_niveles_iguales():
+    resultado = BohrAtom().transition(1, 3)
+    assert resultado["type"] == "absorción"
+    assert resultado["delta_E_eV"] > 0
+
+    with pytest.raises(ValueError):
+        BohrAtom().transition(2, 2)
+
+
+def test_grafica_de_niveles_marca_energias_y_longitudes_de_onda():
+    fig, ax = BohrAtom().plot_energy_levels(max_n=4, show=False)
+    textos = [texto.get_text() for texto in ax.texts]
+
+    assert any(texto.startswith("n = 1") for texto in textos)
+    assert any("nm" in texto for texto in textos)
+    assert ax.get_ylabel() == "Energía (eV)"
+    plt.close(fig)
+
+
+def test_grafica_de_orbitas_conserva_la_escala():
+    fig, ax = BohrAtom(Z=1).plot_orbits(max_n=3, show=False)
+
+    assert ax.get_aspect() in ("equal", 1.0)
+    assert len(ax.lines) == 3
+    plt.close(fig)
+
+
+def test_las_graficas_rechazan_un_nivel_maximo_invalido():
+    with pytest.raises(ValueError):
+        BohrAtom().plot_energy_levels(max_n=0, show=False)
+    with pytest.raises(ValueError):
+        BohrAtom().plot_orbits(max_n=False, show=False)
+
+
+def test_se_puede_guardar_la_figura(tmp_path):
+    destino = tmp_path / "niveles.png"
+    fig, _ = BohrAtom().plot_energy_levels(max_n=3, show=False, save_path=destino)
+
+    assert destino.is_file()
+    assert destino.stat().st_size > 0
+    plt.close(fig)