Implementación concreta de TimeIntegrator mediante el esquema FDTD de salto de rana (Leapfrog). Más...

#include <TimeIntegrator.h>

Diagrama de herencia de FDTDLeapfrogIntegrator

Diagrama de colaboración de FDTDLeapfrogIntegrator:

Métodos públicos
	FDTDLeapfrogIntegrator (py::array_t< std::complex< double >, py::array::c_style\|py::array::forcecast > initial_psi, const Grid &grid, std::shared_ptr< Potential > potential, std::shared_ptr< BoundaryCondition > boundary_condition, double dt, double mass)
	Constructor principal del integrador Leapfrog.

void	step () override
	Avanza un paso de tiempo completo según el esquema FDTD Leapfrog.

std::string	get_name () const override
	Devuelve el nombre del integrador.

py::array_t< std::complex< double > >	get_psi () const
	Devuelve la función de onda actual en formato NumPy.

Métodos públicos heredados de TimeIntegrator
virtual	~TimeIntegrator ()=default

Descripción detallada

Implementación concreta de TimeIntegrator mediante el esquema FDTD de salto de rana (Leapfrog).

Este integrador emplea el método Finite-Difference Time-Domain (FDTD) con un esquema temporal tipo "leapfrog", ampliamente usado para ecuaciones de onda relativistas como la ecuación de Dirac.

El algoritmo alterna entre los estados ψ(t - Δt), ψ(t) y ψ(t + Δt) para avanzar la solución sin necesidad de almacenar todas las configuraciones temporales.

Características principales

Soporta dominios 1D, 2D y 3D.
Compatible con potenciales arbitrarios Potential.
Integra condiciones de frontera mediante la clase BoundaryCondition.
Expone la función de onda al entorno Python vía pybind11.

Referencias

Taflove, A., & Hagness, S. C. (2005). Computational Electrodynamics: The Finite-Difference Time-Domain Method.
Thaller, B. (1992). The Dirac Equation.

Documentación de constructores y destructores

◆ FDTDLeapfrogIntegrator()

FDTDLeapfrogIntegrator::FDTDLeapfrogIntegrator	(	py::array_t< std::complex< double >, py::array::c_style\|py::array::forcecast >	initial_psi,
		const Grid &	grid,
		std::shared_ptr< Potential >	potential,
		std::shared_ptr< BoundaryCondition >	boundary_condition,
		double	dt,
		double	mass
	)

inline

Constructor principal del integrador Leapfrog.

Inicializa la función de onda y los buffers de tiempo (ψ_prev, ψ_curr, ψ_next), validando dimensiones y preparando los parámetros del algoritmo.

Parámetros

initial_psi	Estado inicial del campo espinorial, como array NumPy de forma (N, 4).
grid	Objeto de tipo Grid que define la geometría de la simulación.
potential	Potencial escalar aplicado a la partícula.
boundary_condition	Condición de frontera a aplicar (e.g. periódica, absorbente).
dt	Paso temporal.
mass	Masa de la partícula.

Excepciones

std::runtime_error Si la forma del array de entrada no es (N, 4) o si el número de puntos no coincide con la malla.

        : grid_(grid), potential_(potential), boundary_condition_(boundary_condition), dt_(dt), mass_(mass)
    {
        // Validación de dimensiones de entrada
        py::buffer_info psi_info = initial_psi.request();
        if (psi_info.ndim != 2 || psi_info.shape[1] != 4) {
            throw std::runtime_error("El psi inicial debe ser un array de NumPy de forma (N, 4)");
        }
        if (static_cast<size_t>(psi_info.shape[0]) != grid_.get_total_points()) {
            throw std::runtime_error("El número de puntos en psi debe coincidir con el total de puntos de la malla.");
        }
 
        // Asignación de memoria
        size_t n_points = grid_.get_total_points();
        psi_curr_.resize(n_points);
        psi_prev_.resize(n_points);
        psi_next_.resize(n_points);
 
        // Copiar datos desde el array de NumPy a psi_curr_
        auto ptr = static_cast<Dirac::complex*>(psi_info.ptr);
        for (size_t i = 0; i < n_points; ++i)
            for (size_t j = 0; j < 4; ++j)
                psi_curr_[i].components[j] = ptr[i * 4 + j];
 
        // Inicialización básica del buffer previo
        psi_prev_ = psi_curr_;
    }

Documentación de funciones miembro

◆ get_name()

std::string FDTDLeapfrogIntegrator::get_name ( ) const

inlineoverridevirtual

Devuelve el nombre del integrador.

Devuelve: La cadena "FDTDLeapfrogIntegrator".

Implementa TimeIntegrator.

                                        {
        return "FDTDLeapfrogIntegrator";
    }

◆ get_psi()

py::array_t< std::complex< double > > FDTDLeapfrogIntegrator::get_psi ( ) const

inline

Devuelve la función de onda actual en formato NumPy.

Convierte internamente el vector de spinors psi_curr_ a un array bidimensional compatible con Python, de forma (N, 4).

Devuelve: Un objeto py::array_t<std::complex<double>> con la función de onda actual.

                                                  {
        py::array_t<std::complex<double>> result({grid_.get_total_points(), 4ul});
        auto buf = result.request();
        auto* ptr = static_cast<std::complex<double>*>(buf.ptr);
 
        for (size_t i = 0; i < grid_.get_total_points(); ++i)
            for (size_t j = 0; j < 4; ++j)
                ptr[i * 4 + j] = psi_curr_[i].components[j];
 
        return result;
    }

◆ step()

void FDTDLeapfrogIntegrator::step ( )

inlineoverridevirtual

Avanza un paso de tiempo completo según el esquema FDTD Leapfrog.

Calcula el operador espacial y el término local del Hamiltoniano para cada punto de la malla, aplicando las matrices de Dirac correspondientes a cada dimensión. Luego, actualiza ψ(t+Δt) a partir de ψ(t) y ψ(t-Δt).

También aplica la condición de frontera definida por boundary_condition_.

Nota: Actualmente implementa derivadas centrales de segundo orden y admite condiciones periódicas o absorbentes.