Referencia de la clase dirac_solver.initial_state.GaussianPacket

Métodos públicos
	__init__ (self, constant_spinor, center=[0, 0, 0], spatial_width=1)
	evaluate (self, grid_position)
	evaluate_on_grid (self, grid)

Atributos públicos
	constant_spinor
	center
	spatial_width

Documentación de constructores y destructores

__init__()

dirac_solver.initial_state.GaussianPacket.__init__	(		self,
			constant_spinor,
			center = [0,0,0],
			spatial_width = 1
	)

@brief el spinor constante entra como parametro

    def __init__(self, constant_spinor, center = [0,0,0], spatial_width = 1):
        """
        @brief el spinor constante entra como parametro
        """
        self.constant_spinor = constant_spinor
        self.center = np.array(center)
        self.spatial_width = spatial_width
 

Documentación de funciones miembro

evaluate()

dirac_solver.initial_state.GaussianPacket.evaluate	(		self,
			grid_position
	)

@brief calcula el estado base en un punto exacto

    def evaluate(self, grid_position):
        """
        @brief calcula el estado base en un punto exacto
        """
        x = np.array(grid_position)
        p0 = self.constant_spinor.momentum
        x0 = self.center
 
        # Pad the position vector 'x' to match the dimension of momentum and center vectors
        if len(x) < len(p0):
            padded_x = np.zeros(len(p0), dtype=float)
            padded_x[:len(x)] = x.flatten()
            x = padded_x
 
        sigma0 = self.spatial_width
        u_p0 = self.constant_spinor.constant_spinor
 
        p0_dot_x = np.dot(p0, x)
        exponent_norm = np.linalg.norm(x - x0)**2
 
        spatial_part = np.exp(1j * p0_dot_x) * np.exp(-exponent_norm / (4 + sigma0**2))
 
        dirac_spinor = u_p0 * spatial_part
 
        """
        @brief Devuelve el spinor calculado en el punto
        """
        return dirac_spinor
 

evaluate_on_grid()

dirac_solver.initial_state.GaussianPacket.evaluate_on_grid	(		self,
			grid
	)

@brief Calcula el estado inicial en toda la malla.
@param grid: Objeto Grid sobre el que se evaluará el paquete.
@return: Un array de NumPy con la forma (n_points, 4)

    def evaluate_on_grid(self, grid):
        """
        @brief Calcula el estado inicial en toda la malla.
        @param grid: Objeto Grid sobre el que se evaluará el paquete.
        @return: Un array de NumPy con la forma (n_points, 4)
        """
        n_points = grid.shape[0] # Assuming 1D for now
        psi_0 = np.zeros((n_points, 4), dtype=np.complex128)
 
        for i in range(n_points):
            position = grid.coords[i]
            spinor_at_point = self.evaluate(position)
            psi_0[i, :] = spinor_at_point.flatten()
 
        return psi_0
 
# """
# @class GaussianWavePacket
# @brief Clase para inicializar el paquete de ondas gaussiano.
# """
# 
# 
# class GaussianWavePacket:
#     """
#     @brief En esta clase se construye un paquete de ondas gaussiano.
#     """
#     def __init__(self, momentum=[0,0,0], mass=1.0, packet_width=1.0, spin_orientation='up_z'):
#         """
#         @brief Inicializa los parametros fisicos del paquete de ondas
#         @param momemtum:  Momentum del paquete de ondas (array), por defecto: [0,0,0]
#         @param mass: Masa en reposo de la particula (float), por defecto: 1.0
#         @param packet_width: Ancho inicial del paquete (float), por defecto: 1.0
#         @param spin_orientation: Orientación del spin. (char), por defecto: 'up_z'
#         """
# 
#         self.p_vec = np.array(momentum)
#         self.mass = mass
#         self.x0 = packet_width 
#         self.spin = spin_orientation
# 
#         consts = Constants()
#         self.c = consts.get("c")
#         self.HBAR = consts.get("HBAR")
# 
# 
# 
# 
#         self._precompute_spinor()
# 
#     def _precompute_spinor(self):
#         """
#         @brief En este metodo se calcula la parte espinorial constante del paquete de ondas
#         @note Se ejecuta al crearse el objeto, es de uso interno.
#         """
#         """
#         @brief Aqui calculamos la energia relativista del paquete de ondas:
#         """
# 
#         p_mag = np.linalg.norm(self.p_vec)
# 
#         if p_mag == 0:
#             """
#             @todo Este condicional se podria eliminar si el sqrt eliminara la potencia cuadrada al ser p_mag = 0
#             """
#             self.energy = self.mass * (self.c**2)
#         else:
#             self.energy = np.sqrt((p_mag * self.c)**2 + (self.mass * self.c**2)**2)
# 
#         """
#         @brief Se calcula la constante de normalización N:
#         """
#         N = ( (2 * np.pi )**(3/2) * (self.x0)**3 )**(-1/2)
# 
#         """
#         @brief Se calcula el factor de normalización:
#         """
#         norm_factor = np.sqrt((self.energy + self.mass*(self.c**2)) / (2 * self.energy))
# 
#         """
#         @brief Se construye el spinor base:
#         """
# 
#         px, py, pz = self.p_vec
#         spinor = np.zeros(4, dtype=np.complex128)
# 
#         if self.spin == 'up_z':
#             spinor[0] = 1.0 
#             spinor[1] = 0.0
#             spinor[2] = ((pz * self.c)/(self.energy + (self.mass * (self.c**2)))) 
#             spinor[3] = ( ((px - (1j * py))*self.c ) / (self.energy + (self.mass*(self.c**2))) )
#         else:
#             raise NotImplementedError(f"Spin orientation '{self.spin}' is not supported.")
#         """
#             @warning Es necesario implementar las otras componentes
#             """
# 
#         """
#         @brief Se aplica la normalizacion a nuestro vertor 4x1
#         @note Es necesario construir el termino faltante con al geometria.
#         """
# 
#         self.spinor_vector = N * norm_factor * spinor
#         print("Objeto creado (falta aplicarle la geometria)")
 

Documentación de datos miembro

center

dirac_solver.initial_state.GaussianPacket.center

constant_spinor

dirac_solver.initial_state.GaussianPacket.constant_spinor

spatial_width

dirac_solver.initial_state.GaussianPacket.spatial_width

---

La documentación de esta clase está generada del siguiente archivo:

• dirac_solver/initial_state.py