Astronomia

Problemas com a computação das posições X, Y, Z dos planetas em um determinado momento no Unity3D (C #)

Problemas com a computação das posições X, Y, Z dos planetas em um determinado momento no Unity3D (C #)


We are searching data for your request:

Forums and discussions:
Manuals and reference books:
Data from registers:
Wait the end of the search in all databases.
Upon completion, a link will appear to access the found materials.

Estou tentando criar um pequeno programa em Unity3D que posiciona os planetas no espaço 3D em um determinado momento. Eu segui este documento: http://stjarnhimlen.se/comp/ppcomp.html.

Usando os dados da seção 4 e o código das seções 6 e 7, devo ter o algoritmo correto, certo? Eu pulei as mudanças nos atributos orbitais (por exemplo, + 4.70935E-5 * d) porque eu só preciso que eles se movam em uma órbita definida. Eu realmente não preciso que eles mudem com o tempo. Por enquanto, estou apenas aumentando a anomalia média ao longo do tempo, sem levar o período em consideração.

O problema é que os planetas não parecem obter o deslocamento correto para a eclíptica, e seu movimento é realmente estranho: eles aceleram, depois diminuem a velocidade e invertem seus caminhos. Aqui está um vídeo de seu movimento: https://www.youtube.com/watch?v=zHOBChFpan0

Parece que a excentricidade está correta em suas elipses e as distâncias ao sol também estão corretas, mas o resto está errado. Não sou muito bom em matemática ou astronomia para entender completamente o que está acontecendo neste algoritmo, mas espero que alguém aqui possa detectar o erro.

using UnityEngine; using System; public class Orbit: MonoBehaviour {public float longitudeOfTheAscendingNode; inclinação do flutuador público; public float argumentOfPerihelion; public float semimajorAxis; excentricidade de flutuação pública; public float meanAnomalySpeed ​​= 0.1f; float M = 0; // significa anomalia void Update () {SetPosition (); } void SetPosition () {float N = longitudeOfTheAscendingNode; float i = inclinação; float w = argumentOfPerihelion; float a = semimajorAxis; float e = excentricidade; flutuante E = M + e * (180 / Mathf.PI) * Mathf.Sin (M) * (1 + e * Mathf.Cos (M)); float xv = a * (Mathf.Cos (E) - e); float yv = a * (Mathf.Sqrt (1 - e * e) * Mathf.Sin (E)); float v = Mathf.Atan2 (yv, xv); float r = Mathf.Sqrt (xv * xv + yv * yv); float xx = r * (Mathf.Cos (N) * Mathf.Cos (v + w) - Mathf.Sin (N) * Mathf.Sin (v + w) * Mathf.Cos (i)); float yy = r * (Mathf.Sin (N) * Mathf.Cos (v + w) + Mathf.Cos (N) * Mathf.Sin (v + w) * Mathf.Cos (i)); float zz = r * (Mathf.Sin (v + w) * Mathf.Sin (i)); transform.position = new Vector3 (xx, yy, zz); M + = meanAnomalySpeed ​​* Time.deltaTime; se (M> 360) M - = 360; }

}


Acho que E e M estão em graus no seu código, mas as funções trigonométricas nomatemáticabiblioteca em C # espera um argumento em radianos.

Uma maneira de lidar com isso é definir constantesradianos = Pi / 180egraus = 180 / pientão sempre façaMathf.Sin (M * radianos). Você também precisará fazer isso para as linhasfloat xx =.

Alternativamente, você pode trabalhar inteiramente em radianos. Converta todos os ângulos em radianos no início e use apenas radianos no código. Você precisaria convertern, i, weMpara radianos e lembre-se dissoeevtambém estará em radianos.


Não tenho certeza do que você quer dizer com isso, mas em algum momento você precisará de coordenadas esféricas. Pelo seu código, parece que você tem um bom entendimento de trigonometria, então isso não deve ser um problema.

Uma possível causa de confusão são os quadros de referência. Você definiu um? Se sim, qual? Se não, você precisa de ajuda com isso? Você já ouviu falar de quadros geocêntrico-eclíptica, geocêntrico-equatorial e heliocêntrico-eclíptica?

A questão é que a latitude e a longitude dependem da rotação da Terra, portanto não é inercial. Compreenda totalmente que você deseja evitar isso.

Obrigado pela resposta rápida :)

- Sou um novato em Mecânica Orbital e coisas assim, mas posso aprender rapidamente se um assunto me interessar: D

Eu esperava que um Quaternion fosse suficiente para a rotação do primário, para calcular posições e graus a partir. (mesmo que eu apenas saiba que um Quaternion é uma rotação no espaço 3D)

Eu nem tenho certeza do que é um referencial. Em algumas wikipages eu vi um plano de referência, que era um círculo ao redor do equador. - Eu não defini um: /

Não ouvi falar de nenhum destes: quadros geocêntrico-eclíptica, geocêntrico-equatorial e heliocêntrico-eclíptica - mas talvez o equatorial seja o plano do equador que vi na página wiki? : D

Ok, é muito mais simples do que parece, mas extremamente importante se você quiser trabalhar com x, y, z e definir ângulos.

Na esfera celestial, os astrônomos definem o equador celeste (uma projeção do equador da Terra) e a eclíptica, que é o movimento aparente do Sol através da esfera durante o ano. Claro, a eclíptica é basicamente uma projeção da órbita da Terra na esfera aparente, então quando dizemos & quotthe plano da eclíptica & quot, queremos dizer o plano de nossa órbita.

O ponto onde a eclíptica e o equador celestial se cruzam é ​​o equinócio vernal (estações do hemisfério norte). Em 21 de março, esta é a posição aparente do Sol no céu. A linha entre este ponto e o centro da Terra também é a interseção entre o plano equatorial e o plano eclíptico.

O referencial geocêntrico-equatorial tem origem no centro da Terra, o eixo Z através do pólo Norte, o eixo X apontando para o equinócio vernal e o eixo Y segue a regra da mão direita. Tanto X quanto Y estarão no plano do equador. Acontece que X também está no plano da eclíptica, mas não Y.

O referencial heliocêntrico-eclíptico tem origem no centro do Sol, o eixo X apontando para o equinócio vernal, o eixo Y 90º à frente na direção da órbita da Terra e o eixo Z apontando para o norte perpendicular ao plano equatorial (não é coincidente com o pólo norte do Sol).

O sistema de coordenadas perifocal torna o plano XY coincidente com a órbita do satélite. O eixo X aponta para o periapsia, o eixo Y está 90º à frente na direção de seu movimento e o eixo Z completa a regra da mão direita.

Fonte para os 3 acima: Fundamentos da Astrodinâmica por Bate, Mueller e White ISBN 0-486-60061-0.

Não encontrei uma estrutura geocêntrico-eclíptica na bibliografia, mas usei-a e tenho certeza de que existe. Basicamente, está centrado na Terra, o eixo X ao equinócio vernal, o eixo Z apontando para o norte perpendicular ao plano da eclíptica e o eixo Y completa a regra da mão direita.

Se você usar geocêntrico-eclíptica e heliocêntrico-eclíptica, há uma boa simplificação, pois o plano XY é coincidente, então você só precisa adicionar ângulos para converter de um para o outro. O quadro perifocal não tem essa propriedade, então você precisa de uma rotação para converter, mas é bom porque você só precisa de um ângulo para descrever a posição do seu satélite.

Você está familiarizado com os sistemas de coordenadas esféricas? Suponho que sim porque você usou trigonometria em seu código, se não, você será capaz de entendê-la.

Portanto, quando você usa vetores 3d e variáveis ​​x, y, z, você deve saber a que referencial eles se referem. Acho que é tudo que você precisa para fazer as conversões, embora possa precisar de uma caneta e um papel para desenhar algumas setas e ângulos antes de entender tudo.


1. Introdução

O texto abaixo descreve como calcular as posições do Sol, da Lua e dos planetas principais no céu até Netuno. O algoritmo para Plutão é obtido a partir de um ajuste de Fourier para a posição de Plutão, calculada por integração numérica no JPL. As posições de outros corpos celestes também (ou seja, cometas e asteróides) também podem ser calculadas, se seus elementos orbitais estiverem disponíveis.

Essas fórmulas podem parecer complicadas, mas acredito que este seja o método mais simples para calcular as posições planetárias com a precisão bastante boa de cerca de um minuto de arco (= 1/60 graus). Quaisquer outras simplificações resultarão em menor precisão, mas é claro que isso pode ser bom, dependendo da aplicação.


Por que eclipses acontecem?

Um eclipse solar total ocorre quando a Lua fica na frente do Sol do ponto de vista de um local específico na Terra. E acontece que, neste ponto da história da Terra, a Lua pode simplesmente bloquear o Sol porque tem quase exatamente o mesmo diâmetro angular no céu que o Sol (cerca de 0,5 ° ou 30 minutos de arco).

Então, quando a Lua fica entre o Sol e a Terra? Bem, basicamente toda vez que há uma lua nova (ou seja, uma vez a cada mês lunar). Mas sabemos que não há um eclipse a cada mês. Então, por quê?

Bem, na verdade, na situação análoga de Ganimedes e Júpiter, há um eclipse cada vez que Ganimedes gira em torno de Júpiter (o que acontece a cerca de uma vez por semana). Como a Terra, a órbita de Júpiter em torno do Sol encontra-se em um plano particular (o "Plano da Eclíptica"). E acontece que a órbita de Ganimedes em torno de Júpiter também está essencialmente no mesmo plano. Portanto, toda vez que Ganimedes atinge a posição de "lua nova" (ou, no jargão oficial da astronomia, quando está alinhado "em sizígia" - pronunciado sizz-ee-gee), está no lugar certo para lançar sua sombra sobre Júpiter e eclipsar o Sol onde quer que a sombra caia. (De Júpiter, Ganimedes aparece cerca de 3 vezes o tamanho do Sol).

Mas nossa lua é diferente. Sua órbita não está no plano da eclíptica. Em vez disso, é inclinado em cerca de 5 °. (Como ficou assim é desconhecido, mas provavelmente está relacionado a como a Lua foi formada.) Mas esse 5 ° é o que torna os eclipses tão relativamente raros: eles só podem acontecer quando há uma "configuração de lua nova" (sizígia) bem em um momento em que a órbita da Lua passa pelo Plano da Eclíptica.

Para mostrar o que está acontecendo, vamos desenhar uma versão exagerada de tudo. Aqui está a Lua girando em torno da Terra, colorida de vermelho sempre que está perto do Plano da Eclíptica:

Agora vamos ver o que acontece ao longo de cerca de um ano. Estamos mostrando um ponto para onde a Lua está a cada dia. E o ponto é mais vermelho se a Lua estiver mais perto do Plano da Eclíptica naquele dia. (Observe que se isso fosse desenhado em escala, você mal seria capaz de ver a órbita da Lua, e ela nunca pareceria retroceder como está aqui.)

Agora podemos começar a ver como funcionam os eclipses. O ponto básico é que há um eclipse solar sempre que a Lua está posicionada entre a Terra e o Sol, e está no Plano da Eclíptica. Na foto, essas duas condições correspondem à Lua estar o mais longe possível em direção ao centro e o mais vermelha possível. Até agora, estamos mostrando a posição da Lua (exagerada) apenas uma vez por dia. Mas, para tornar as coisas mais claras, vamos mostrar quatro vezes por dia - e agora eliminar os casos em que a Lua não está pelo menos aproximadamente alinhada com o Sol:

E agora podemos ver que, pelo menos neste caso particular, há dois pontos (indicados por setas) onde a Lua está alinhada e no plano da eclíptica (mostrada em vermelho) - e esses pontos então corresponderão a eclipses solares .

Em anos diferentes, a imagem parecerá um pouco diferente, essencialmente porque a Lua está começando em um lugar diferente em sua órbita no início do ano. Aqui estão as fotos esquemáticas de alguns anos sucessivos:

Não é tão fácil ver exatamente quando os eclipses ocorrem aqui - e também não é possível dizer quais são os eclipses totais onde a Lua está exatamente alinhada e quais são apenas eclipses parciais. Mas há pelo menos uma indicação, por exemplo, de que há "estações de eclipses" em diferentes partes do ano em que acontecem os eclipses.

OK, então como são os dados reais? Aqui está um gráfico para 20 anos no passado e 20 anos no futuro, mostrando os dias reais em cada ano quando ocorrem eclipses solares totais e parciais (os pequenos pontos em todos os lugares indicam novas luas):

A razão para a “deriva” entre anos sucessivos é apenas que o mês lunar (29,53 dias) não se alinha com o ano, então a Lua não passa por um número inteiro de órbitas no decorrer de um ano, com o resultado é que no início de um novo ano, a Lua está em uma fase diferente. Mas, como a imagem deixa claro, há bastante regularidade nos tempos gerais em que ocorrem os eclipses - e por exemplo, geralmente há 2 eclipses em um determinado ano - embora possa haver mais (e em 0,2 por cento dos anos pode haver até 5, como havia pela última vez em 1935).

Para ver mais detalhes sobre os eclipses, vamos representar graficamente as diferenças de tempo (em anos fracionários) entre todos os eclipses solares sucessivos de 100 anos no passado e 100 anos no futuro:

E agora vamos traçar as mesmas diferenças de tempo, mas apenas para eclipses solares totais:

Obviamente, há uma boa quantidade de regularidade geral aqui, mas também há muitas pequenas estruturas e irregularidades. E ser capaz de prever corretamente todos esses detalhes basicamente levou a ciência a boa parte de alguns milhares de anos.


Ângulo entre dois vetores 3D - exemplo

Suponha que queremos encontrar o ângulo entre dois vetores:

e b definido como

o vetor entre o ponto A = (1, 1, 2) e B = (-4, -8, 6).

Primeiro, calcular vetor b, dados os pontos iniciais e terminais:

b = [-4 - 1, -8 - 1, 6 - 2] = [-5, -9, 4]

Então, encontre o produto escalar de vetores uma e b:

uma & # xB7 b = (3 * -5) + (6 * -9) + (1 * 4) = -15 - 54 + 4 = -65

Próximo, determine a magnitude de vetores:

Finalmente, use a equação do produto escalar transformado:

& # x3B1 = arccos [(a & # xB7 b) / (|uma| * |b|)] = arccos [-65 / (6,782 * 11,045)] = arccos (-0,86767) = 150,189 & # x2248 150,2 & # xB0

E pronto! Você acabou de calcular o ângulo entre dois vetores 3D. Parabéns!


Construindo um simulador de sistema solar

Hiya
Hiya. Estou tentando construir um simulador de sistema solar para fins de pesquisa e isso não parece ser tão fácil. Tipo, meus primeiros testes mostram a lua saindo do sistema solar. Gostaria de saber se vocês poderiam oferecer alguma orientação.

Então, como é para pesquisa, a precisão é o aspecto mais importante. As velocidades dos objetos no sistema solar são especialmente importantes para mim, e gostaria de poder chegar o mais perto possível dos valores verdadeiros em alguns intervalos de tempo. Idealmente, gostaria de ser capaz de alcançar uma precisão dos movimentos das massas dentro de cerca de 0,1 m / s do valor real durante um período de simulação de um ano. Imagino que essa precisão otimista esteja muito longe do que posso realmente gerenciar, mas é a figura que gostaria de manter em mente ao construir o simulador.
Por causa das coisas que gostaria de testar, basicamente preciso usar a aceleração gravitacional, não posso usar o movimento planetário do Kepler ou hacks semelhantes.


Então, problema um. Usar timesteps obviamente introduz pequenos erros que se acumulam. Qual a melhor forma de prevenir essas imprecisões? Devo apenas usar o método de Euler com pequenos passos de tempo, ou há algum método melhor que eu poderia usar (em termos de precisão / tempo de execução)?

Problema dois. De quais massas eu realmente preciso para meu nível de precisão desejado? Eu precisaria dos satélites de outros planetas? Que tal o cinturão de Kuiper? (e como eu modelaria isso?) Planetas anões? Que tal estrelas em "proximidade" do sol ou da própria galáxia? Por motivos de desempenho e para facilitar o desenvolvimento, obviamente gostaria de ter o mínimo de massas necessário. Estaria certo apenas adicionar as massas das luas de outros planetas às suas massas?

Problema três. Vou precisar de uma boa verdade grond para posições e velocidades para o tempo inicial e final da minha simulação para as massas que decidir usar. Tanto para começar tudo de forma realista quanto para verificar se sou preciso. Idealmente, a verdade terrestre é algo que posso acessar programaticamente para que possa alterar facilmente meu período de simulação. As posições / velocidades também terão que estar em coordenadas x, y, z ou precisam ser convertidas nelas. Não me importo necessariamente se a 'verdade fundamental' realmente corresponde perfeitamente aos verdadeiros dados históricos. Contanto que a 'verdade final' seja um resultado correto (dentro da minha precisão desejada) da 'verdade inicial' dado o que sabemos, então funciona para mim.
A melhor biblioteca que encontrei até agora é esta https://github.com/mgvez/planet-positions que é usada na simulação do sistema solar jsOrrery, e estou usando agora, mas não tenho certeza se é utilizável / confiável o suficiente. Para começar, ele só tem dados para o Sol, planetas e lua, então eu não poderia adicionar luas maiores como Titã se fosse com isso. Alguém conhece uma maneira melhor de obter dados de verdade do solo?

Problema quatro. A aceleração gravitacional newtoniana é realmente suficiente para a precisão desejada? Há algum efeito de GR que eu preciso considerar para minha precisão desejada? E a pressão de radiação? Adição de velocidade SR? Mais alguma coisa que eu possa ter perdido?


Movimento da câmera

Há apenas um problema com o movimento do fuzileiro espacial: ele escorregará da tela. Você quer que a câmera siga o herói pela arena, para que ele não fuja de você.

Com um pouco de script, você pode manter o fuzileiro naval em foco.

Primeiro, certifique-se de que você não está no modo de reprodução - para interromper o modo de reprodução, selecione o Reproduzir botão novamente.

Na Hierarquia, clique no botão Criar e selecione Criar Vazio. Diga CameraMount.

A ideia básica é que você queira que o CameraMount represente a posição em que a câmera deve focar e que a câmera esteja em relação a essa posição.

Inicialmente, você deseja que a câmera foque onde está o fuzileiro espacial, então vamos configurar o CameraMount para estar exatamente na mesma posição que o fuzileiro espacial.

Para fazer isso, selecione o marinha espacial, clique no botão de engrenagem no canto superior direito do componente Transformar e selecione Copiar Componente

Em seguida, selecione o CameraMount, clique no botão de engrenagem no canto superior direito do componente Transformar e selecione Colar Valores de Componente:

Em seguida, arraste o Câmera Principal GameObject no CameraMount GameObject.

Excelente! Agora, conforme você move o player, você pode mover o CameraMount para mover com o player, e a câmera irá rastreá-lo. Você só precisa escrever um script para fazer isso.

Com o CameraMount selecionado, clique no Adicionar Componente botão no Inspetor e selecione Novo Script. Chame-o CameraMovement e então clique Criar e adicionar.

Arrastar seu novo arquivo do nível superior da pasta de ativos para o Scripts pasta.

Duplo click a CameraMovement script para abri-lo em seu editor de código. Abaixo da definição de classe, adicione as seguintes variáveis:

followTarget é o que você deseja que a câmera siga e moveSpeed ​​é a velocidade na qual ela deve se mover. Ao criá-las como variáveis ​​públicas, o Unity permitirá que você as defina dentro do próprio editor do Unity, para que você possa definir o followTarget para o fuzileiro naval espacial e mexer com o moveSpeed ​​como quiser, como você verá em breve.

Agora adicione o seguinte a Update ():

Este código verifica se há um alvo disponível. Do contrário, a câmera não segue.

Em seguida, Vector3.Lerp () é chamado para calcular a posição necessária do CameraMount.

Lerp () usa três parâmetros: uma posição inicial no espaço 3D, uma posição final no espaço 3D e um valor entre 0 e 1 que representa um ponto entre as posições inicial e final. Lerp () retorna um ponto no espaço 3D entre as posições inicial e final que é determinado pelo último valor.

Por exemplo, se o último valor for definido como 0, Lerp () retornará a posição inicial. Se o último valor for 1, ele retorna a posição final. Se o último valor for 0,5, ele retorna um ponto a meio caminho entre as posições inicial e final.

Neste caso, você fornecerá a posição de montagem da câmera como o início e a posição do jogador como o final. Finalmente, você multiplica o tempo desde a última taxa de quadros por um multiplicador de velocidade para obter um valor adequado para o último parâmetro. Efetivamente, isso faz com que a posição de montagem da câmera se mova suavemente para onde o jogador está ao longo do tempo.

Salve seu código e retorne ao Unity. Selecione CameraMount na Hierarquia e procure no Inspetor. Você verá dois novos campos chamados Seguir Alvo e Velocidade de movimento. Conforme mencionado anteriormente, eles foram derivados automaticamente pelo Unity das variáveis ​​públicas que você acabou de adicionar ao script. Essas variáveis ​​precisam de alguns valores.

Com o CameraMount ainda selecionado na hierarquia, arraste SpaceMarine para o Seguir Alvo campo e definir o Velocidade de movimento para 20.

Jogue para ver o que mudou.

O fuzileiro naval é um verdadeiro superstar agora, completo com uma equipe de câmera pessoal. É verdade que ele não consegue se virar e passa direto por objetos como Kitty Pryde, mas esses são problemas facilmente solucionáveis ​​que você não precisa enfrentar agora.


Nós nos esforçamos para criar um local de trabalho inclusivo, onde diferentes pontos de vista são incentivados e a melhor ideia - não importa a fonte - vence. A SpaceX facilita grupos liderados por funcionários que constroem comunidade em torno de identidades sociais e interesses comuns, promovendo conexões em toda a empresa. Eles fornecem oportunidades para os funcionários desenvolverem habilidades, aprenderem sobre tópicos de interesse dos palestrantes, se reunirem socialmente e apoiarem uns aos outros.


Atualizar

Eu atualizei o método ConvertToCartesian, de forma que ele tenha a True Anomaly (nu) calculada a partir da função ConvertToKeplerElements como uma entrada. Em seguida, ele calcula a anomalia excêntrica (E) e, a partir daí, calcula a anomalia média (Mt). Quando ConvertToCartesian é chamado em loops subsequentes, Mt é atualizado com o intervalo de tempo relevante. Em seguida, calculo E novamente a partir do Mt atualizado e, em seguida, calculo nu a partir do E. atualizado. Isso resolve a maioria dos casos. O problema é que às vezes nu é calculado 180 graus fora de onde deveria estar, tornando o ponto inicial da órbita exibida 180 graus fora.

Na minha função ConvertToKeplerElements, de acordo com a matemática, nu = 2pi - nu se r.v & lt 0. Isso acontece, por exemplo, quando eu defino os vetores r, v iniciais de modo que o navio não comece no periapsia ou apoapsis, mas em algum lugar entre eles. Eu sei que isso é correto, mas quando eu calculo nu- & gtE- & gtnu, aquele giro de 180 graus é perdido no cálculo.

Aqui estão as partes relevantes do método atualizado ConvertToCartesian.

Aqui está o resultado ruim que estou obtendo:


Então, o que aconteceu aqui?

Há muito o que aprender ao revisitar conceitos que nos foram “ensinados”. A matemática é linda, mas a elegância geralmente está escondida sob provas mecânicas e uma parede de equações. Não precisamos de mais provas, precisamos de resultados interessantes e intuitivos.

Por exemplo, o Teorema de Pitágoras:

  • Trabalha para qualquer forma, não apenas triângulos (como círculos)
  • Trabalha para qualquer equação com quadrados (como 1/2 m v 2)
  • Generaliza para qualquer número de dimensões (a 2 + b 2 + c 2 + ...)
  • Medidas qualquer tipo de distância (ou seja, entre cores ou preferências de filme)

Nada mal para um resultado de 2.000 anos, certo? Isso é bastante complicado, então vou terminar aqui por hoje (o artigo anterior tem mais utilidades). Feliz matemática.


Assista o vídeo: Teoria da Computação: Introdução à Complexidade de Problemas (Dezembro 2022).