Física Computacional - FSC-5705

só um divisor

Prova de Física Computacional,

I semestre de 2013 - REC

Antes de iniciar a prova é necessário que o estudante crie uma pasta denominada prova_I_matricula_do_aluno dentro desta pasta serão feitos cada um dos programas correspondente aos problemas da prova. O nome dos programas serão problema1.py, problema2.py, etc. Ao concluir a prova o estudante tem de criar um arquivo comprimido com tudo, isto é criar um arquivo do tipo .tar.gz. Este arquivo devera ser enviado por email para o endereço evy.fisica@gmail.com e o assunto do email deve ser prova 1 - matricula do aluno. Depois disso deverá chamar ao professor a fim de copiar para um pendrive o mesmo arquivo.

Exercício 01 (1.5 pts)

A série arbitraria tem a os primeiros elementos na sua sequência: \[ 0,\,1,\,1,\,2,\,3,\,5,\,8,\,13,\,21,\,\ldots \nonumber \] crie um programa que pergunte ao usuário quantos termos da série deseja e imprima estes no terminal (deve podem ir além dos 9 termos apresentados como exemplo)

Solução

A série dada acima é a série de Fibonacci. Chamemos de $F$ o vetor onde serão armazenadas as variáveis. Note que os 2 primeiros termos da série são fixos, de forma que: \[ F[0] = 0,\,\,\,\,\,\,F[1] = 1 \nonumber \] Qualquer outro termo pode ser obtido utilizando \[ F[i] = F[i-2] + F[i-1] \nonumber \] dai que seja necessário ter prefixado os 2 primeiros termos. Preste atenção nos if que cuidam os casos onde o número de elementos solicitados pelo usuário for menor que 2.

      #/usr/bin/env python
      #-*- coding: utf-8 -*-

      import numpy as np

      while True:
        n = input('Quantos termos da serie você quer: ')
        if (n > 0):
          break
        print 'o número de termos deve ser maior do que zero'

      F = np.zeros(n, dtype=np.int32)

      F[0] = 0
      if (n >= 1):
        F[1] = 1
      if (n >= 2):
        for i in xrange(2, n):
          F[i] = F[i-1] + F[i-2]
          
      print F
      

Exercício 02 (1.5 pts)

Crie um programa que calcule a quantidade associada a cada cela de um quadro de xadrez seguindo a regra ilustrada no desenho abaixo:

Em construcao

O programa deve criar um arquivo chamado "graos_por_cela.dat". Nesse arquivo você vai imprimir a coordenada da cela e do lado a quantidade associada a essa coordenada, por exemplo:
[0,0] 1
[0,1] 2
[0,3] 4
[0,4] 8
O programa deverá também imprimir a soma total das quantidades associadas a cada cela.

Solução

Este problema é inspirado num conto, não sei se hindu ou árabe: Um rei que era aficionado por jogos ficou sabendo que um sábio tinha criado o xadrez. O rei ficou encantado com o jogo e ofereceu-lhe ao sábio riquezas como recompensa. O sábio rejeitou a oferta mas dize para o rei que aceitaria a quantia de arroz que se obtinha ao se colocar 1 grão na primeira casa, 2 grão na segunda, 4 na terceira, 8 na quarta, etc. O rei aceito aceito e mando trazer um saco de arroz, o sábio respondeu que a quantidade era um pouco maior do que aquela contida no saco o que motivo ao rei chamar o matemático da corte. Ao tempo o matemático voltou nervoso dizendo que não tinha arroz em todo o reino para suprir o pagamento

Os números desenhados no tabuleiro formam uma progressão geométrica, o objetivo do problema é obter á "serie" com $8*8=64$ elementos: \[ S = \sum_{i=0}^{63} r^i \nonumber \] Da matemática sabemos que essa serie infinita converge para o caso em $|r|<1$, isto porque a progressão cresce exponencialmente.

O maior problema do exercício era notar que a numeração dada às celas (casa) do tabuleiro se podia obter com \[ cela = coluna + 8 * linha \nonumber \] fazendo variar $coluna$ e $linha$ desde $0$ até $7$:

      #/usr/bin/env python
      #-*- coding: utf-8 -*-

      import numpy as np

      n = 8
      A = np.zeros((n,n), dtype=np.float)

      arq = open('graos_por_cela.dat', 'w')

      cela = 0
      for linha in xrange(n):
        for coluna in xrange(n):
          cela = linha * n + coluna
          A[linha][coluna] = 2**cela
          print >>arq, '[', linha, ', ', coluna, '] ', A[linha][coluna]
          
      print 'Total = ', np.sum(np.sum(A, axis=0))

      arq.close()
      

O resultado é assustador, como o rei do conto ficou sabendo, o total de grão seria: $1,84467440737\times 10^{19}$ grãos. Se um grão pesa algo como $30\, mg$, então essa quantidade de arroz é $5,53\times 10^{17}$ kg. Em 2009 foram produzidos $6.150680\times 10^{11}$ Kg de arroz, por tanto serão necessários $8.997416\times 10^{5}$ anos ou quase 900 mil anos!!! Note que a teoria da eva mitocondrial nos dize que o homem moderno está a uns 200 mil anos sobre a terra!!!

Exercício 03 (3.0 pts)

Um diodo é um elemento não linear que deixa fluir a corrente elétrica se é aplicada uma diferencia de potencial positiva entre seu terminais porém não permite o passo de corrente (ou permite pobremente) se a diferencia de potencial é negativa. É por isso que os diodos são utilizados como retificador, ou seja, converte a corrente alternada em corrente direta. Quando a resistência própria do diodo é desconsiderado, o comportamento do diodo pode ser modelado por \[ i = i_s \exp\left( \dfrac{qV_j}{nk_BT} \right) \nonumber \] onde $i_s$ é a corrente de saturação que para o silício está dada por $i_s\approx 1.0\times10^{-8}A$,
$q=1.6\times10^{-19}C$ é a carga do elétron,
$V_j$ é a diferencia de potencial aplicada ao diodo,
$n=2$ para o silício,
$k_B=1.38\times10^{-23}J/K$,
$T=300\,K$
Escreva um programa que calcule $i$ para o diodo de silício quando $V_j$ varia desde $-0.20$ volts até $0.55$ volts com passo de $0.05$ volts. Calcule para $T=300\,K$ e $T=350\,K$ e coloque em um gráfico, salve em png.

Solução

Aqui se deve prestar atenção na forma como se definem os números com notação científica:

      #/usr/bin/env python
      #-*- coding: utf-8 -*-

      import numpy as np
      import matplotlib.pyplot as plt

      Is = 1.0e-8
      q  = 1.6e-19
      n  = 2.0
      kb = 1.38e-23

      V = np.arange(-0.20, 0.55, 0.05)
      T = 300.0
      i1 = Is * np.exp( q*V/(n*kb*T))

      T = 350
      i2 = Is * np.exp( q*V/(n*kb*T))


      plt.plot(V, i1, linestyle='-', color='black',\
          marker="*", label='T=300')
      plt.plot(V, i2, linestyle='-', color='red',\
          marker="o", label='T=350')
        
      plt.legend(loc='upper left')
        
      plt.xlabel(r'$V_j$', fontsize=30)
      plt.ylabel(r'$i_s$', fontsize=30)
      plt.title(u"Exercício 03", fontsize=30)
      plt.tight_layout()
      plt.savefig('exercicio03.png')
      plt.show()
      
campo da carga

Exercício 04 (4.0 pts)

Suponha que um objeto se move com aceleração constante de $a_p = 1.0\times 10^5\,m/s^2$ e enquanto se move emite outros objetos nas direções mostradas pelas zetas da figura abaixo ($45^\circ$ entre cada zeta).

campo da carga

Se os objetos são emitidos com velocidade de $v_f = 3.0\times 10^8\,m/s$. Calcule o trajeto da partícula na direção $2$, vista desde o objeto emissor. Crie um gráfico mostrando este trajeto. Suponha que o corpo emissor parte do repouso e se desloca $10\,m$. O gráfico deve apresentar 50 pontos.

Solução

A solução deste problema era utilizar as transformações de Galileo para calcular a aceleração "fictícia" na componente $x$ da partícula emitida. O problema é que a aceleração dada no problema era muito pequena para ver este efeito:

      #/usr/bin/env python
      #-*- coding: utf-8 -*-

      import numpy as np
      import matplotlib.pyplot as plt

      vf    = 3.0e8
      ap    = 1.0e5
      theta = 45.0
      xf    = 10.0

      print 'Este problema será resolvido utilizando\
      a relatividade de Galileo:'


      vfxo = vf * np.cos(np.deg2rad(theta))
      vfyo = vf * np.sin(np.deg2rad(theta))


      print '\ncomponentes da partícula emitida segundo um\
      observado em repouso em relação a ela:'
      print 'vx = %e'%vfxo
      print 'vy = %e'%vfyo


      tv = np.sqrt(2.0*xf / ap)
      print '\nO tempo necessário para percorrer 10 m é: %e'% tv

      #gera os 50 pontos de tempo
      t = np.linspace(0, tv, 50)

      afx = -ap
      print'\nA aceleração em x da partícula emitida = %e'%afx


      #a componente x da partícula emitida muda segundo
      xf = vfxo * t + 0.5 * afx * t**2

      #a componente em y muda linearmente
      yf = vfyo * t

      a = 'a =%.2e'%ap

      plt.plot(xf, yf, linestyle='-', color='black',\
          label=a)
        
      plt.legend(loc='upper left')
        
      plt.xlabel(r'$x_f$', fontsize=30)
      plt.ylabel(r'$y_f$', fontsize=30)
      plt.title(u"Exercício 04", fontsize=30)
      plt.tight_layout()
      plt.savefig('exercicio04.png')
      plt.show()
      
campo da carga

Se mudamos a aceleração para $a=5.0\times 10^{15}$ veremos um efeito interessante na trajetória (a figura à esquerda é um zoom da linha verda à direita que é justamente a linha de $45^\circ$

campo da carga

Contudo a aplicação da relatividade de Galileo é inapropriada devido a que a velocidade da partícula emitida é $c$ (vel. da luz), ou seja, é um fóton (luz). O programa que fez todas as linhas é o seguinte

      #/usr/bin/env python
      #-*- coding: utf-8 -*-

      import numpy as np
      import matplotlib.pyplot as plt

      vf     = 3.0e8
      ap     = 5.0e15
      thetaM = np.arange(0, 360, 45)
      xf     = 10.0

      if (ap != 0):
        tv = np.sqrt(2.0*xf / ap)
      else:
        print 'erro'
        stop
      t = np.linspace(0, tv, 50)
      afx = -ap

      for theta in thetaM:
        thetaR = np.deg2rad(theta)
        vfxo   = vf * np.cos(thetaR)
        vfyo   = vf * np.sin(thetaR)

        xf = vfxo * t + 0.5 * afx * t**2
        yf = vfyo * t
        plt.plot(xf, yf, linestyle='-')

      plt.xlabel(r'$x_f$', fontsize=30)
      plt.ylabel(r'$y_f$', fontsize=30)
      plt.title(u"Exercício 04", fontsize=30)
      plt.tight_layout()
      plt.savefig('exercicio04_3.png')
      plt.show()