7a série

Propaganda

Série 7 de TFCOM – Simulação de partı́culas clássicas, MEFT, 2009/10
Objectivos
Pretende-se simular partı́culas, em particular para fazer o filme do movimento dinâmico de um conjunto de
partı́culas clássicas. Este é o último trabalho de TFCOM, sendo o pretexto para que os alunos apliquem
toda a matéria de C++ estudada.
A simulação de partı́culas tem imensas aplicações, seja para estudar directamente as próprias partı́culas em
gases ou plasmas ou até mesmo para simular o movimento de clusters de galáxias no universo, seja para
simular fluidos ou plasmas ou sólidos deformáveis evitando resolver EDP para volumes e superfı́cies. Em
termos de meios contı́nuos permite usarmos técnicas sem rede ou “meshfree”,
http://en.wikipedia.org/wiki/Meshfree methods sendo que para fluidos há duas técnicas para usar partı́culas,
a SPH http://en.wikipedia.org/wiki/Smoothed particle hydrodynamics
e a PIC http://en.wikipedia.org/wiki/Particle-in-cell.
A primeira alı́nea questiona alguns aspectos básicos de templates e da linguagem Python, mas a sua utilização ao longo da série é opcional, sendo necessário apenas optar por dar um exemplo de templates ou da
utilização de Python.
Considerações iniciais
Note que deve incluir no relatório todos os códigos que for construindo, designando-os por g1s7a1.cpp
representando, respectivametente, o grupo 1, série 7 e alı́nea 1. NOTA: Sempre que é pedido para
melhorar ou corrigir um código, este deve ser gravado com um nome novo adequado à alı́nea!
Pode usar as extensões “cpp”, “cxx” ou “cc” (iremos usar “cpp” apenas por conveniência). Utilize uma
nomenclatura semelhante para os ficheiros de output criados.
Aconselha-se que o relatório (obrigatoriamente em formato pdf) seja escrito em LATEX, mas não haverá
penalização se for escrito noutro programa (MS/Open Office).
Os códigos serão avaliados de acordo com a ponderação definida na página da cadeira. Todas as alı́neas
terão a mesma ponderação (ou seja 5/20 da série).
Questões
1. (a) Explique a funcionalidade da keyword template, explicando em que tipos de situações é que é
conveniente utilizarmos templates.
(b) Explique brevemente quais as semelhanças e diferenças que encontra relevantes entre a utilização
de C++, C++ através da STL (Standard Template Library), ROOT compilado e interpretado
e Python. Se lhes fosse fornecido um código simples (funções e ciclos), com qual destas soluções
é que o código seria mais rápido? Já agora, com qual destas soluções é que lhe parece mais fácil
desenvolver código?
(c) Escolha uma das opções apresentadas. O valor desta alı́nea será incluı́do na alı́nea 1, valendo
apenas 30% desta.
i. Implemente uma função “Print” que irá mostrar no ecrã propriedas comuns a Partı́culas e
Campos, podendo usar como argumento qualquer objecto destas classes, ou suas derivadas.
Deverá usar obrigatoriamente uma classe ou tipo template.
1
ii. Implemente uma das alı́neas de toda a série (excluindo a alı́nea 1, obviamente) em Python,
em vez de C++.1 .
2. Comece por escrever uma classe geral denominada Particula2 . As partı́culas deverão ter massa,
carga, três coordenadas de posição (x, y, z), três coordenadas de velocidade (vx, vy, vz), tempo,
energia3 , e ainda propriedades para os gráficos como cor, um raio caso sejam representadas por um
disco, etc. Note que iremos trabalhar com electrões e protões, que irão constituir duas classes derivadas
diferentes, cada uma com massa, carga e cor constantes. Defina também uma classe Campo para
trabalhar com o campo de forças, sendo que o campo terá uma constante, e três componentes em
cada ponto do espaço-tempo. Teremos doze objectos dessa classe, um campo gravı́tico e um campo
electrostático por partı́cula.
(a) Teste esse código com uma “main” simples, com inputs e outputs só de teste, por exemplo para
6 partı́culas diferentes e 12 campos.
(b) Agora restringimo-nos a uma partı́cula, pois iremos implementar a sua dinâmica num campo de
forças. Defina um campo arbitrário constante, e use a lei de Newton:
F (t)
,
m
v(t + δt) = v(t) + a(t)δt,
1
r(t + δt) = r(t) + v(t)δt + a(t)(δt)2 ,
2
com diferenças finitas como na Série 3, para resolver estas equações vectoriais.
a(t) =
(1)
(2)
(3)
3. Agora considere várias partı́culas, por exemplo três electrões e três protões (com cargas ±1 opostas mas
com massas escolhidas por si, se o desejar). Calcule os dois campos de forças, gravı́tico e electrostático
(com constantes “à vontade do freguês”), criados pelas partı́culas. Resolva o problema dinâmico do
sistema de partı́culas e campos.
4. Passe para gráfico frames de sucessivos tempos t do sistema, para fazer um filme, que deverá ser
colocado no http://www.youtube.com.
Identifique-o com o nome do trabalho, por exemplo ParticleFCOM09S7T1G13. Pode mostrar o gráfico
no plano xy, mas representando as partı́culas com discos cujo raio depende de z, para visualizarmos as
três dimensões em perspectiva. Pode guardar os frames por exemplo em jpeg, bmp ou png e depois
passar para um formato de vı́deo como mpeg ou wmv, por exemplo com o Windows Movie Maker, ou
com outro software conveniente.
Nas condições iniciais, deve definir os ri e os vi , mas considere sempre o referencial do centro de massa
P
P
ri = 0 e vi = 0, senão as partı́culas “fogem” da área visı́vel do gráfico.
Dicas para a criação dos gráficos (NOTA: apenas se pretende que seja criado um filme. A nota não
irá depender do método escolhido para fazer o filme):
1
Sugestão: se não estiver muito à vontade com Python mas quiser utilizar esta opção, é aconselhável resolver primeiro a
série toda em C++ e depois passar o código para Python na alı́nea que lhe agradar.
2
Obviamente, não utilize caracteres acentuados ou proibidos dentro do seu código.
3
Sugestão: Pode utilizar uma classe que permita guardar quatro coordenadas: três coordenadas de posição e uma de
tempo, ou três de velocidade e uma quarta coordenada de energia. Existe uma implementação parecida na classe de ROOT
“TLorentzVector”, embora aqui se pretenda algo muito mais simples que funcione como “container”.
2
• Em C++, poderá utilizar bibliotecas gráficas já conhecidas por si para gravar cada uma das
frames. Pode utilizar o gnuplot ou o Allegro, se já estiver familiarizado com este último.
• Pode utilizar o root para desenhar os gráficos, utilizando para isso um gráfico ou outro tipo
de objectos (ex: TGraph2D, TEllipse, etc.). Poderá gravar o canvas com o método “SaveAs” e
poderá actualizar o canvas com o método “Update()”.
• Apenas para esta última alı́nea, também poderá realizá-la em python. Para desenhar gráficos,
poderá utilizar uma biblioteca gráfica como o Tkinter (exemplos em
http://www.pasteur.fr/recherche/unites/sis/formation/python/ch14.html)
• Para criar o filme a partir de frames separadas (cabe-lhe a si determinar quantas frames é que
são necessárias para ter uma visualização confortável, poderá usar o Windows Movie Maker ou
outras soluções (por exemplo o Mencoder, http://pymolwiki.org/index.php/Making Movies, ou
o ImageMagick)
Pode procurar já no youtube os vı́deos criados pelos seus colegas do ano passado e ver que tipo de
soluções é que foram implementadas por eles.
P. Bicudo & P. Martins, IST, 2 de Dezembro de 2009.
3