Clave 45 T9 Ep 314 CARL JUNG.Su Vision Esoterica

Gran trabajo amigos! una consulta, como se llama la banda musical de covers que utilizan de separadores? muchas gracias! saludos desde Argentina!!!

Sumamente interesante , complejo , laborioso y para ser un tema tan angosto,  muy ameno y entretenido . Gran trabajo 👏

Me resulta muy interesante las cosas que cuenta Gerald. Estaría bien que David no lo interrumpiera cada vez que habla, ya que dejarle hacer el podcast solo es mucho pedir...

Queridos Gerald y David:

Qué buen programa. En la discusión alrededor de las 2 h y poco de programa, a pesar de ser fan de Gerald y, sobre todo, de Caravaca (a quien se nombra implícitamente), estoy con David: si tenemos una explicación científica de algo, otras explicaciones son superfluas, con todo el respeto. David, yo también quiero creer 😊

Saludos,

Antonio

yo como aporte diria que si existe comunicación con este otro "sitio" invisible mediante la comunicación intrumental, sea por psicofonía, imagen, video y otros metodos desarrollados por los parapsicólogos. gracias por el programa, muy interesante traernos facil a Jung 🫂💙

Saludos , traigo ciencia. Podéis participar y opinar sobre mecánica cuántica.
https://www.facebook.com/share/p/iN2wjMDgdNjc8Wrd/
Una simulación matemática de como nuestra biología contactá con el soporte vital.
import os
import csv
import numpy as np
import pyopencl as cl
import psutil
from tqdm import tqdm
from datetime import datetime

# Verificar la memoria disponible
def verificar_memoria():
    memoria = psutil.virtual_memory()
    if memoria.available < 1e9:  # 1 GB de memoria disponible como umbral
        print("Advertencia: Memoria baja.")
        return False
    return True

# Crear carpeta para guardar los resultados
fecha_actual = datetime.now().strftime('%Y%m%d%H%M%S')
carpeta_resultados = f'resultados_simulacion_{fecha_actual}'
os.makedirs(carpeta_resultados, exist_ok=True)

# Dimensiones espaciales y temporales (ahora 3D)
Lx, Ly, Lz = 200, 200, 200  # Tamaño de la cuadrícula en 3D
dx = 1.0                    # Resolución espacial
dt = 0.00005                # Paso temporal
steps = 500                # Número de pasos de la simulación

# Parámetros físicos
hbar = np.float64(1.0545718e-34)  # Constante de Planck reducida (J·s)
m = np.float64(9.10938356e-31)    # Masa de un electrón (kg)
g = np.float64(1e-7)              # Reducido para evitar inestabilidades numéricas

# Parámetros de fotones
amplitud_foton = np.float64(3.0)    # Amplitud fotónica
frecuencia_foton = np.float64(5.0)  # Frecuencia fotónica

# Inicializar función de onda psi con valores aleatorios complejos y normalizar
psi = (np.random.rand(Lx, Ly, Lz) + 1j * np.random.rand(Lx, Ly, Lz)) * 1e-6
psi /= np.linalg.norm(psi)  # Normalizar psi

# Inicializar potencial V con perturbaciones aleatorias
V = (np.random.rand(Lx, Ly, Lz) * 0.1).astype(np.float64)

# Definir tiempos de creación y duración para los fotones
num_fotones = 12
posiciones_fotones = np.random.randint(0, Lx, size=(num_fotones, 3))

# Parámetros temporales: tiempo de creación y duración de los fotones
tiempo_creacion_fotones = np.random.randint(0, steps // 4, size=num_fotones)  # Creación aleatoria en los primeros pasos
duracion_fotones = np.random.randint(steps // 2, steps, size=num_fotones)     # Cada fotón dura entre la mitad y el final de la simulación

# El kernel OpenCL como cadena de texto (modificado para precisión simple)
kernel_code = """
#define M_PI 3.14159265358979323846f  // Definir PI en precisión simple

__kernel void evolucionar_espacio(
    __global float2 *psi, __global float *V,
    const float g, const float dt, const float dx, 
    const float hbar, const float m, 
    const unsigned int Lx, const unsigned int Ly, const unsigned int Lz,
    const unsigned int num_fotones, __global int3 *posiciones_fotones, 
    const float amplitud_foton, const float frecuencia_foton, const float t,
    __global int *fotones_activos)
{
    int i = get_global_id(0);
    int j = get_global_id(1);
    int k = get_global_id(2);

    // Calcular los índices vecinos
    int up_x = (i + 1) % Lx;
    int down_x = (i - 1 + Lx) % Lx;
    int up_y = (j + 1) % Ly;
    int down_y = (j - 1 + Ly) % Ly;
    int up_z = (k + 1) % Lz;
    int down_z = (k - 1 + Lz) % Lz;

    // Convertir de float2 a complejo
    float2 psi_current = psi[i * Ly * Lz + j * Lz + k];
    float2 psi_up_x = psi[up_x * Ly * Lz + j * Lz + k];
    float2 psi_down_x = psi[down_x * Ly * Lz + j * Lz + k];
    float2 psi_up_y = psi[i * Ly * Lz + up_y * Lz + k];
    float2 psi_down_y = psi[i * Ly * Lz + down_y * Lz + k];
    float2 psi_up_z = psi[i * Ly * Lz + j * Lz + up_z];
    float2 psi_down_z = psi[i * Ly * Lz + j * Lz + down_z];

    // Calcular el laplaciano
    float2 laplaciano_psi;
    laplaciano_psi.x = (psi_up_x.x + psi_down_x.x + psi_up_y.x + psi_down_y.x + psi_up_z.x + psi_down_z.x - 6.0f * psi_current.x) / (dx * dx);
    laplaciano_psi.y = (psi_up_x.y + psi_down_x.y + psi_up_y.y + psi_down_y.y + psi_up_z.y + psi_down_z.y - 6.0f * psi_current.y) / (dx * dx);

    // Interacción no lineal
    float psi_abs2 = psi_current.x * psi_current.x + psi_current.y * psi_current.y;
    float2 interaccion;
    interaccion.x = g * psi_abs2 * psi_current.x;
    interaccion.y = g * psi_abs2 * psi_current.y;

    // Inicializar el potencial fotónico y la corrección gravitacional
    float potencial_foton = 0.0f;
    float correccion_gravitacional = 0.0f;

    // Añadir la influencia de los fotones neuronales solo si están activos
    for (int l = 0; l < num_fotones; l++) {
        if (fotones_activos[l] == 1) {  // Solo aplicar si el fotón está activo
            int3 pos_foton = posiciones_fotones[l];
            float dx_foton = (float)(i - pos_foton.x);
            float dy_foton = (float)(j - pos_foton.y);
            float dz_foton = (float)(k - pos_foton.z);
            float distancia = sqrt(dx_foton * dx_foton + dy_foton * dy_foton + dz_foton * dz_foton);

            // Usar circunferencia, área y volumen de los vórtices en la simulación
            float radio = distancia;
            float circunferencia = 2.0f * M_PI * radio;
            float area = M_PI * radio * radio;
            float volumen = (4.0f / 3.0f) * M_PI * radio * radio * radio;

            // Potencial fotónico dependiente de la distancia
            potencial_foton += amplitud_foton * cos(frecuencia_foton * t) / (distancia + 1.0f);
            correccion_gravitacional += psi_abs2 / (distancia + 1.0f);

            // Introducir una fuerza proporcional al área del vórtice
            float fuerza_area = 0.1f * area;
        }
    }

    // Calcular la derivada temporal de psi usando la ecuación de Schrödinger no lineal
    float2 dpsi_dt;
    dpsi_dt.x = (-hbar / m) * laplaciano_psi.x - (V[i * Ly * Lz + j * Lz + k] + potencial_foton + correccion_gravitacional) * psi_current.x + interaccion.x;
    dpsi_dt.y = (-hbar / m) * laplaciano_psi.y - (V[i * Ly * Lz + j * Lz + k] + potencial_foton + correccion_gravitacional) * psi_current.y + interaccion.y;

    // Limitar los valores de psi para evitar desbordamiento
    float max_psi_value = 1e5f;  // Límite superior de psi
    psi[i * Ly * Lz + j * Lz + k].x = clamp(psi_current.x + dt * dpsi_dt.x, -max_psi_value, max_psi_value);
    psi[i * Ly * Lz + j * Lz + k].y = clamp(psi_current.y + dt * dpsi_dt.y, -max_psi_value, max_psi_value);
}
"""

# Función para evolucionar la función de onda usando OpenCL en 3D
def evolucionar_espacio_opencl(ctx, queue, kernel, psi, V, g, dt, dx, posiciones_fotones, amplitud_foton, frecuencia_foton, t, tiempo_creacion_fotones, duracion_fotones):
    Lx, Ly, Lz = psi.shape
    mf = cl.mem_flags
    
    # Crear buffers para psi y V en la GPU
    psi_buffer = cl.Buffer(ctx, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=psi)
    V_buffer = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=V)
    posiciones_fotones_buffer = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=posiciones_fotones)

    # Crear una máscara para identificar fotones activos (en su tiempo de vida)
    fotones_activos = np.array([1 if tiempo_creacion_fotones[i]  0:
                print(f"Seleccionando plataforma: {platform.name}")
                ctx = cl.Context(devices)
                queue = cl.CommandQueue(ctx)
                print("Contexto creado exitosamente en GPU")
                return ctx, queue
        except cl.LogicError as e:
            print(f"No se pudo crear un contexto en GPU: {e}")

    raise RuntimeError("No se pudo crear un contexto en ningún dispositivo. Verifica tu instalación de OpenCL.")

# Función para calcular las propiedades geométricas del sistema
def calcular_geometria(vorticidad_total, momento_lineal, dx):
    # Calcular el radio efectivo a partir de la vorticidad total
    radio = np.sqrt(vorticidad_total)  # Una estimación basada en la vorticidad total
    circunferencia = 2.0 * np.pi * radio
    area = np.pi * radio**2
    volumen = (4.0 / 3.0) * np.pi * radio**3

    # Calcular el momento angular total como una función del momento lineal y el radio
    momento_angular_total = momento_lineal * radio * dx  # Ajuste con dx para obtener el valor correcto

    return area, volumen, circunferencia, momento_angular_total

# Función principal de simulación sin multiprocessing
def simulacion_completa(steps, psi, V, g, dt, dx, posiciones_fotones, amplitud_foton, frecuencia_foton, archivo_csv, carpeta_resultados, tiempo_creacion_fotones, duracion_fotones):
    resultados = []

    # Crear el contexto OpenCL una vez para todo el proceso
    ctx, queue = configurar_opencl()
    program = cl.Program(ctx, kernel_code).build()
    kernel = program.evolucionar_espacio

    for t in tqdm(range(steps), desc="Simulando espacio cuántico"):
        # Ejecutar la simulación en OpenCL
        psi = evolucionar_espacio_opencl(ctx, queue, kernel, psi, V, g, dt, dx, posiciones_fotones, amplitud_foton, frecuencia_foton, t, tiempo_creacion_fotones, duracion_fotones)

        # Calcular magnitudes físicas en cada paso (las mismas que antes, más el control temporal)
        densidad_probabilidad = np.mean(np.abs(psi)**2)
        energia_cinetica_total = np.sum(np.abs(psi)**2) * dx**3
        energia_potencial_total = np.sum(V * np.abs(psi)**2) * dx**3
        energia_no_lineal_total = g * np.sum(np.abs(psi)**4) * dx**3
        coherencia_cuantica = np.sum(np.abs(np.mean(psi))**2) / np.sum(np.abs(psi)**2)
        num_particulas = np.sum(np.abs(psi)**2) * dx**3
        fase_promedio = np.mean(np.angle(psi))

        # Calcular el momento lineal (gradiente de la fase)
        grad_fase_x, grad_fase_y, grad_fase_z = np.gradient(np.angle(psi))
        momento_lineal = np.sum(np.imag(np.conj(psi) * (grad_fase_x + grad_fase_y + grad_fase_z))) * dx**3
        vorticidad_total = np.sum(np.sqrt(grad_fase_x**2 + grad_fase_y**2 + grad_fase_z**2)) * dx**3

        # Calcular propiedades geométricas (como antes)
        area, volumen, circunferencia, momento_angular_total = calcular_geometria(vorticidad_total, momento_lineal, dx)
        densidad_energia_total = energia_cinetica_total / volumen if volumen > 0 else 0

        # Curvatura total del espacio
        laplaciano_psi = (np.roll(psi, 1, axis=0) + np.roll(psi, -1, axis=0) +
                          np.roll(psi, 1, axis=1) + np.roll(psi, -1, axis=1) +
                          np.roll(psi, 1, axis=2) + np.roll(psi, -1, axis=2) - 6 * psi) / (dx**2)
        curvatura_total = np.sum(np.real(laplaciano_psi * np.conj(psi)))

        # Longitud del borde de vórtices
        longitud_borde_vortices = circunferencia

        # Número de espirales y vórtices
        umbral_vorticidad = 0.05
        num_espirales = np.sum(densidad_probabilidad > 0.5)
        num_vortices = np.sum(vorticidad_total > umbral_vorticidad)

        # Fotones activos en este paso de la simulación
        fotones_activos = [1 if tiempo_creacion_fotones[i] 

Gracias por el programa. Junto con la primera parte de Jung una auténtica Máster Class. Me ha flipado lo implicado que estaba con la alquimia y todo lo oculto.
Gracias y un saludo.

La verdad David, qué manera de destrozar un programa maravilloso, qué manera de destrozar el gran conocimiento que Gerald tiene de Jung, y qué manera tan superficial y tan llena de prejuicios respeto hacia alguien, Jung, que es todo lo contrario a ti, una mente abierta. Sigue con tu Wikipedia como fuente. Es triste. Enhorabuena Gerald , estás sin duda a otro nivel mucho más interesante

Hola, después de un magnífico trabajo con éste monográfico, sólo puedo felicitaros. 

Podría haber sido uno de los mejores monográficos de Clave45, pero las interrupciones de comentrios tan fuera de contexto, hacen que quede en un programa más. 
Disculpen los inconvenientes de mi comentario.

Creo que el pajarraco "King Fisher" en castellano se llama "Martín pescador" o "Alcedo".
Puede cazar bajo el agua...

Muchisimas gracias por el programa, super interesante la verdad creo que el señor Jung veia un poco lo que queria ver en su alrededor, me explico, no sabemos si los pajaros azules que se encontro muerto eran comunes donde el vivia, o la raza de escarabajos dorados pròpia de donde viva cuanto comunes eran, el echo es como cuando té dejo la novia y de repente té da la impressión que todo el mundo que pasea por la calle va en pareja y tu eres el unico pringado, O cuando estàs tratando de tener un hijo no no haces mas que ver mujeres con carritos de bebè, uno se ve muy influido por aquello que le ocupa la mente, al menos es lo que creo yo, mil gracias por el programa y un fuerte abrazo desde Barcelona.

Martín Pescador un ave muy bella.

Jung no tiene la culpa de lo que otros hagan con su conocimiento... David, no tengas mala baba XDDDD
Marie Curie no tiene la culpa de la bomba atómica, por ejemplo.

El juego de palabras entre "Ser" y "Estar" no pasa en inglés... o más bien, los "Dad Jokes" son una derivación de eso.

Un ejemplo diferente, y similar, son los verbos "Creer" y "Crear". La oración del Credo empieza con "Creo EN...". Un mago entendería que es, mas bien, "Creo A..."

Es un poco mágico que, en español, la primera persona del presente de ambos verbos sea "CREO". Así se puede manipular la mente de un humano.

De hecho, el Credo católico es una forma clara de programación. Cada frase de esa oración es un meme con la intención de "educar".

Me pregunto si, por ejemplo, para el caso de Angel Martín, este se lo tuvo que "Creer/crear" para dominar sus voces...

El protagonista del Lobo Estepario es un insoportable de tomo y lomo, nunca he entendido qué ve la gente de positivo en ese libro 😂