Demonstrando que o tamanho da etapa de tempo é pequeno o suficiente em um código com seleção automática de tamanho da etapa

8

Recentemente, herdei um grande corpo de código legado que resolve um problema muito rígido e transitório. Eu gostaria de demonstrar que os tamanhos de etapas espaciais e temporais são pequenos o suficiente para que a natureza qualitativa da solução computada não seja alterada se forem diminuídas. Em outras palavras, eu gostaria de mostrar que a solução é "convergida" em um sentido qualitativo. Como eu posso definir explicitamente o tamanho da malha espacial, essa parte é simples. No entanto, como o código usa o controle automático do tamanho do intervalo de tempo, não posso definir o tamanho do intervalo de tempo diretamente.

O algoritmo altera o intervalo de tempo entre dois limites, com base no número de iterações jacobianas necessárias para atingir uma tolerância a erros durante os últimos passos. O fato de usar iteração jacobiana me deixa bastante certo de que é algum tipo de esquema implícito, mas não posso estar absolutamente certo. Ele não leva em consideração o erro que está vendo na etapa de tempo atual, o que a leva a atingir o limite de iteração de vez em quando (talvez uma dúzia de vezes ao longo de vários milhares de etapas de tempo, quase sempre durante as partes mais dinâmicas do simulação). As corridas atuais que estou concluindo, estou definindo os limites do intervalo de tempo em duas ordens e meia de magnitude ( a ). n101351011

Nas corridas, eu tenho controle sobre os limites do intervalo de tempo, o número de intervalos de tempo passados ​​em que ele olha para escolher o intervalo de tempo atual, a alteração máxima no intervalo de tempo (proporções), o número alvo de iterações jacobianas, o número máximo de iterações e o erro associado. Eu gostaria que alguém pudesse me colocar no caminho certo para analisar a independência no tempo, ou pelo menos descobrir qual algoritmo é usado.

Godric Seer
fonte
Você está dizendo que acha que será mais fácil fazer engenharia reversa do algoritmo de escalonamento do tempo do que apenas ler o código?
David Ketcheson 04/04/12
o código é de aproximadamente 50 mil linhas de fortran escritas nos últimos 20 anos, portanto, procurar os detalhes do loop principal não é trivial. Eu acredito que é um método implícito, que é informação suficiente para meus propósitos. Estou mais interessado no que preciso alterar em execuções separadas para estabelecer que meu intervalo de tempo seja suficientemente pequeno.
Godric Seer
Eu tentei esclarecer o que está sendo solicitado; corrija-o se eu tiver interpretado mal. Observe que a solução não pode ser literalmente "independente da etapa do tempo", pois os erros locais sempre dependerão da etapa do tempo. Você só pode esperar que os erros sejam pequenos o suficiente para seus propósitos.
David Ketcheson

Respostas:

5

O objetivo da estimativa automática de erros e do controle do tamanho da etapa é libertá-lo do problema de determinar manualmente qual é a dimensão da etapa suficientemente pequena. Portanto, sua pergunta é como perguntar "alguém me deu esse carro de transmissão automática; como posso saber em que equipamento estou?" O ponto é que você não precisa saber. Obviamente, se a transmissão estiver com defeito, talvez seja necessário desmontá-la e corrigi-la, mas esse é um problema muito maior.

No seu caso, normalmente a abordagem correta é determinar que tipo de erro é aceitável e impor isso através do controle automático do tamanho da etapa. É imperfeito, porque o controle de erros, nesse sentido, geralmente é apenas o controle de erros local ; portanto, você não controla diretamente o erro global, o que provavelmente lhe interessa.

Uma coisa que você poderia facilmente fazer em caso de dúvida é executar a simulação com uma sequência de tolerâncias de erro cada vez mais rígidas (ou seja, pequenas). Quando a solução parecer insensível (independentemente da sua métrica) para diminuir a tolerância, você poderá parar.

Adendo : Quanto ao problema do limite máximo de iteração sendo atingido (o que leva a um erro local que excede a tolerância especificada), sugiro o seguinte.

Aparentemente, o código pensa que, se exceder o número máximo de iterações, a coisa certa a fazer é aceitar a etapa. Eu diria que é a coisa errada. Uma abordagem melhor é rejeitar a etapa e iniciá-la novamente com um tamanho reduzido. Obviamente, existe o risco de a etapa ser reduzida abaixo do tamanho mínimo da etapa. Nesse caso, a coisa certa é abortar a simulação. Mas se você acredita que uma solução errada é melhor do que nenhuma solução, você pode simplesmente aceitar a etapa e continuar se ambas as condições forem atendidas: o tamanho mínimo da etapa é atingido e o número máximo de iterações é excedido.

Em um código bem projetado, fazer esses tipos de alterações é trivial, mas em um código arbitrário pode ser arbitrariamente difícil.

David Ketcheson
fonte
O último parágrafo é o importante do ponto de vista prático. O regime assintótico é atingido quando o gráfico de características relevantes da solução em relação às tolerâncias de erro especificadas parecer regular o suficiente.
Arnold Neumaier
É uma boa notícia, porém ainda não tenho certeza de como lidar com essas poucas ocasiões em que atinge o limite máximo de iteração. Vi, felizmente, a etapa do tempo máximo, atingindo erro local em meia dúzia de iterações; depois, a próxima etapa executa 100 iterações e atinge apenas um erro local de . O intervalo de tempo após isso reduz o tamanho do passo e atinge o limite do erro, mas ainda tenho esse erro grande propagando-se pela solução. 107102
Godric Seer
Acabei de notar o adendo. Sua descrição do que o código realmente faz concorda com o que vejo dos arquivos de log. Espero que a mudança que você sugere seja possível sem muitas dores de cabeça.
21875 Godric Seer