Simulação do Experimento de Fenda Dupla de Young

Uma simulação física interativa e visualmente precisa do Experimento da Fenda Dupla de Thomas Young, desenvolvida em Python.

O projeto utiliza processamento vetorial com NumPy para renderizar padrões de difração e interferência da luz em tempo real, , permitindo que estudantes e entusiastas explorem os princípios da óptica ondulatória.

---

📸 O Projeto em Ação

---

✨ Funcionalidades

• Simulação Física: Combina Difração de Fraunhofer (Fenda Única) com Interferência de Young (Fenda Dupla).
• Renderização em Tempo Real: Visualização instantânea do gráfico de intensidade com marcadores visuais que indicam as posições.
• Controles Interativos: Ajuste dinâmico de todos os parâmetros físicos via Sliders e Inputs:
  • Comprimento de Onda ($\lambda$): 380nm a 780nm (com conversão para cores RGB).
  • Distância entre Fendas ($d$): Ajuste em micrômetros ($\mu m$).
  • Largura da Fenda ($a$): Controle do envelope de difração.
  • Distância do Anteparo ($L$): Afaste ou aproxime a tela de projeção.
• Zoom Dinâmico: Ajuste da área total observada na tela em centímetros, permitindo análises macro ou micro do fenômeno.

🚀 Instalação e Execução

Pré-requisitos

• Python 3.10 ou superior.

Passo a Passo

1. Clone o repositório:

   git clone https://github.com/LucasJSM/young-experiment.git

2. Crie e ative um ambiente virtual (Recomendado):

   • Windows:

     python -m venv .venv
     .venv\Scripts\activate

   • Linux/Mac:

     python3 -m venv .venv
     source .venv/bin/activate

3. Instale as dependências:

   pip install -r requirements.txt

4. Execute a simulação:

   python main.py

🛠️ Tecnologias Utilizadas

• Python 3: Linguagem base.
• Pygame CE: Motor gráfico para renderização da janela e primitivas visuais.
• Pygame GUI: Gerenciamento de interface (sliders e inputs).
• NumPy: Cálculos vetoriais de alta performance para processar a intensidade de luz em milhares de pixels simultaneamente.

📂 Estrutura do Projeto

O projeto segue o padrão arquitetural MVC (Model-View-Controller) para separar a lógica física da interface gráfica.

young-experiment/
├── assets/
│   └── fonts/              # Tipografia customizada (ex: Roboto)
├── src/
│   ├── core/
│   │   └── app.py          # Gerenciador do Game Loop (Controller)
│   ├── model/
│   │   ├── experiment_state.py  # Estado global e parâmetros físicos
│   │   └── young_engine.py      # Motor matemático
│   ├── view/
│   │   ├── renderer.py     # Desenho do gráfico, anteparo e HUD
│   │   ├── ui_manager.py   # Gerenciador de Sliders e Inputs (Pygame GUI)
│   │   └── colors.py       # Conversor Espectral (Lambda -> RGB)
│   └── utils/
│       └── math_conversions.py  # Conversores de escalas e unidades
├── theme.json              # Configuração visual da interface
└── main.py

🧠 Física do Projeto

A intensidade $I$ da luz em um ponto $x$ do anteparo é calculada pela combinação de dois fenômenos ondulatórios.

A distância teórica entre dois máximos principais consecutivos é dada por:

$$\Delta y = \frac{\lambda L}{d}$$

Interferência (Fenda Dupla):

$$I_{interf} = \cos^2\left(\frac{\pi d x}{\lambda L}\right)$$

Difração (Fenda Única - Envelope):

$$I_{difr} = \text{sinc}^2\left(\frac{\pi a x}{\lambda L}\right)$$

Onde:

• $\lambda$: Comprimento de onda.
• $L$: Distância das fendas ao anteparo.
• $d$: Distância entre os centros das fendas.
• $a$: Largura de cada fenda.

👥 Autores

• Luca Zoio
• Lucas Moura

📄 Licença

Este projeto está licenciado sob a licença MIT - veja o arquivo LICENSE para mais detalhes.