Você está na página 1de 76

UNIVERSIDADE FEDERAL DE MINAS GERAIS

ESCOLA DE ENGENHARIA

GABRIEL COUTO FONSECA

DESENVOLVIMENTO DE API PARA ANÁLISE


ESTRUTURAL COM FEMAP UTILIZANDO VB.NET

BELO HORIZONTE
2018
GABRIEL COUTO FONSECA

DESENVOLVIMENTO DE API PARA ANÁLISE


ESTRUTURAL COM FEMAP UTILIZANDO VB.NET

Trabalho de Conclusão de Curso


apresentado ao curso de Engenharia
Aeroespacial da Escola de Engenharia
da Universidade Federal de Minas
Gerais, como requisito parcial para
obtenção do grau de Engenheiro
Aeroespacial.

Orientador: Prof. Guilherme de Souza


Papini.

BELO HORIZONTE
2018
AGRADECIMENTOS

Agradeço inicialmente meu tutor de estágio Eduardo Albino, por me orientar em


análise de estruturas dentro da Embraer e por me permitir trabalhar com assuntos de
inovação, para mim, o mais apaixonante da engenharia. Obrigado por sua confiança.

Gostaria em seguida de agradecer a todos os meus professores da


Universidade Federal de Minas Gerais, assim como a própria instituição, que me
ajudaram a construir bases sólidas que me permitiram alcançar objetivos grandiosos
enquanto aluno de engenharia aeroespacial. Em especial, agradeço ao professor
orientador Guilherme de Souza Papini por sua atenção, orientação e disponibilidade
na realização deste trabalho assim como ao professor cordenador Eduardo Bauzer
Medeiros, por ter me auxiliado e me permitido abraçar as oportunidades ao longo do
curso, entre as quais a oportunidade de estágio que permitiu este trabalho.

Finalmente, agradeço a meu pai Odilon Aparecido da Fonseca e minha mãe


Silvana Morais Couto Fonseca por ter me dado meios e força para trilhar esse longo,
difícil e gratificante caminho de busca de conhecimento.

Obrigado a todas as pessoas não mencionadas neste texto, mas que de alguma
forma, tiveram grande importância ao longo da minha trajetória.
RESUMO

Este trabalho consiste no desenvolvimento de dois softwares responsáveis por auxiliar


análises estruturais com o software Femap. Os códigos, desenvolvidos no Visual
Basic Studio com a linguagem de programação Vb.net, utilizam funções contidas na
biblioteca do Femap para executar operações dentro de sua interface. Ambas
ferramentas possuem interfaces também desenvolvidas no Visual Basic Studio que
facilitam sua iteração com o usuário. As duas ferramentas foram testadas e tiveram
resultados satisfatórios comparados com as soluções atuais para o respectivo
problema. Os códigos reduzem o tempo para modelagem assim como probabilidade
de erro do usuário. Ambos os softwares foram implementados no processo de análise
de não conformidades da equipe de apoio a produção da aviação executiva da
Embraer.

Palavras-chave: API, VB.net, Femap, Visual Basic Studio.


ABSTRACT

This work consists in the development of two softwares responsible for supporting
structural analysis with the Femap software. The codes, developed in Visual Basic
Studio software with the Vb.net programming language, use functions contained in the
Femap library to perform operations within the interface of this software. Both tools
have interfaces also developed in Visual Basic Studio that facilitates iteration with the
user. The two tools were tested and had satisfactory results compared to the current
solutions to the problem. The codes reduce the time for modeling as well as probability
of user error. Both software were implemented in the non-conformance analysis
process of Embraer's executive aviation production support team.

Keywords: API, VB.net, Femap, Visual Basic Studio.


LISTA DE FIGURAS

Figura 1 - Procedimento na criação de API ............................................................................ 15


Figura 2 - Modelo de uma viga I no software Femap............................................................. 16
Figura 3 - Exemplo de cartão de um modelo para análise no Nastran ................................... 18
Figura 4 - Resultado da deformada em uma análise de flambagem ....................................... 19
Figura 5 - Translações e rotações em cada eixo totalizando os 6 DOF que definem o
movimento de um nó no espaço ............................................................................................. 21
Figura 6 - Exemplo da condição de contorno de uma barra submetida à uma força de
compressão ............................................................................................................................. 22
Figura 7 - Exemplo da condição de contorno de uma barra submetida à SPCD de compressão
................................................................................................................................................ 23
Figura 8 - Exemplo de casos de estudos criados para organizar outputs................................ 24
Figura 9 - Exemplo de contorno para o vetor Tensão de Von Mises ..................................... 25
Figura 10 - Exemplo de contorno de valores do vetor Tensão de VonMises para caso de carga
“Case1” ................................................................................................................................... 26
Figura 11 - Exemplo de contorno de valores do vetor Tensão de VonMises para caso de carga
“Case2” ................................................................................................................................... 26
Figura 12 - Envelope do vetor “Tensão de VonMises” dos casos de carga “Case1” e “Case2”
................................................................................................................................................ 26
Figura 13 - Interface gráfica do MapLoads.vb ....................................................................... 30
Figura 14 - Fluxograma simplificado do procedimento global do MapLoads.vb. ................. 31
Figura 15 - Seleção dos nós na interface do Femap por ordem do MapLoads.vb .................. 32
Figura 16 - Seleção dos Load Set na interface do Femap por ordem do MapLoads.vb ......... 33
Figura 17 - Leitura dos inputs da interface gráfica ................................................................. 34
Figura 18 - Função do MapLoads.vb para ler valores de output do Femap ........................... 35
Figura 19 - Função ReadVectors do MapLoads.vb para obter vetores de output do Femap .. 35
Figura 20 - Função do MapLoads.vb para criar carregamento no Femap .............................. 36
Figura 21 - Rotina para verificar existência de output desejado ............................................ 37
Figura 22 - Loop responsável por gerar o vetor contendo as cargas à serem aplicadas ......... 39
Figura 23 - Exemplo de StopWatch........................................................................................ 40
Figura 24 - Tempo gasto no procedimento da Figura 23 (0s devido a simplicidade do
procedimento do exemplo). .................................................................................................... 40
Figura 25 - Resultado de análise de desempenho. Legendas respondem as seguintes
perguntas: Foi utilizado cálculo em paralelo neste procedimento? / A atualização automática
de tela para cada carregamento criado foi habilitada? ............................................................ 42
Figura 26 - Atividade dos quatros núcleos do processador durante a execução com cálculo
em paralelo.............................................................................................................................. 43
Figura 27 - Funcionalidades da interface gráfica do MapLoads.vb ....................................... 44
Figura 28 - Modelo Semi asa .................................................................................................. 45
Figura 29 - Contorno do resultado de deslocamento total em análise estática ....................... 46
Figura 30 - Nervura do modelo global para análise em modelo local destacada em amarelo 46
Figura 31 - Modelo local da nervura ...................................................................................... 47
Figura 32 - Procedimento para obter condição de contorno de flambagem com uso do
MapLoads.vb .......................................................................................................................... 47
Figura 33 - Mapeamento de deslocamentos (T1,T2 e T3) e rotações (R1,R2 e R3) .............. 48
Figura 34 - Condição de contorno com SPCD e SPC nos 6 DOF .......................................... 49
Figura 35 - Mapeamento de deslocamentos (T1, T2 e T3) com restrições ............................ 50
Figura 36 - Condição de contorno após mapeamento de SPCD(1,2 e 3) e SPC(1,2 e3) ........ 50
Figura 37 - Mapeamento de momentos aplicados (R1, R2 e R3) ........................................... 51
Figura 38 - Condição de contorno após mapeamento de momento aplicado (4, 5 e 6).......... 51
Figura 39 - Condição de contorno para análise de flambagem aplicado aos nós de interface 51
Figura 40 - Contorno de deslocamento total da análise de flambagem. Casos de carga que
apresentou o menor autovalor (10.66) .................................................................................... 52
Figura 41 - Interface gráfica do EnvelopeGroups.vb ............................................................. 57
Figura 42 - Caixa de inputs: Compare Envelopes .................................................................. 58
Figura 43 - Caixa de inputs para seleção dos Output Vectors ................................................ 59
Figura 44 - Caixa de inputs para seleção das opções de envelope ......................................... 60
Figura 45 - Funcionalidade da interface para seleção dos vetores e opções de envelope ...... 60
Figura 46 - Script responsável em verificar quais vetores foram selecionados e lançar o script:
CompareEnvelope................................................................................................................... 62
Figura 47 - Função CompareEnvelope responsável por criar os envelopes no Femap .......... 62
Figura 48 - Script responsável por inserir os IDs de acordo com o Femap dos vetores
selecionados ao objeto Vectors ............................................................................................... 63
Figura 49 - Script responsável por abrir caixas de seleção do Femap e receber os valores
selecionados para a opção Other Vectors. Fonte: próprio autor, 2018 ................................... 64
Figura 50 - Fluxograma utilizado pelo EnvelopeGroups.vb para gerar os envelopes ............ 64
Figura 51 - Script responsável por criar os envelopes no Femap como novos OutputSets .... 65
Figura 52 - Script responsável por criar a comparação entre envelopes dentro do Femap como
novo OutputSet ....................................................................................................................... 65
Figura 53 - Modelo de pá de hélice ........................................................................................ 66
Figura 54 - Modelo pá de hélice original e modificado.......................................................... 67
Figura 55 - Inserir inputs na caixa Compare Envelopes ......................................................... 68
Figura 56 - Selecionar Ouput Sets para o grupo 1 e Output Vectors para envelope .............. 69
Figura 57 - Selecionar Output Sets para grupo 2 .................................................................... 69
Figura 58 - Estudo de caso criado com os resultados do programa EnvelopeGroups.vb no
Femap ..................................................................................................................................... 70
Figura 59 - Contorno de cores do Envelope de Tensão de Von Mises resultante das análises
do modelo original .................................................................................................................. 70
Figura 60 - Contorno de cores do Envelope de Tensão de Von Mises resultante das análises
do modelo modificado ............................................................................................................ 71
Figura 61 - Comparação entre o Envelope do modelo modificado e original. Acusa regiões
onde houve acréscimo de tensão (vermelho) alívio de tensão (rosa) e variação desprezível
(azul). Fonte: próprio autor, 2018 ........................................................................................... 71
LISTA DE TABELAS

Tabela 1 - Identificador e título de alguns vetores de saída do solver Nastran ...................... 24


Tabela 2 – Inputs da caixa: Load Settings Input..................................................................... 31
Tabela 3 - Inputs da caixa: Constraint Settings Input. ............................................................ 31
Tabela 4 - Inputs da caixa: Performance Settings Input. ........................................................ 32
Tabela 5 - Mensagem de erros e avisos .................................................................................. 36
Tabela 6 - Comparação do desempenho entre MapLoads.vb e solução atual ........................ 38
Tabela 7 - Análise do tempo gasto pelo loop candidato à melhoria ....................................... 41
Tabela 8 - Comparação entre solução atual e o MapLoads.vb modificado ............................ 42
Tabela 9 - Comparação entre uso do MapLoads e solução atual no estudo de caso de
flambagem .............................................................................................................................. 52
Tabela 10 - Inputs na caixa Compare envelopes .................................................................... 61
Tabela 11 - Inputs na caixa Envelope Vectors ....................................................................... 61
Tabela 12 - Inputs nas opções dos vetores.............................................................................. 61
Tabela 13 - Mensagens de erros do programa EnvelopeGroups.vb ....................................... 66
LISTA DE ABREVIATURAS E SIGLAS

ANAC Agencia nacinonal de aviação civil


UFMG Universidade Federal de Minas Gerais
MEF Modelo de Elementos Finitos
RE Relatório Estrutural
API Application Programming Interface
VBS Visual Basic Studio
EDP Equação Diferencial Parcial
DOF Degrees Of Freedom
SUMÁRIO

1 INTRODUÇÃO ................................................................................................................ 12
2 OBJETIVO E METODOLOGIA.....................ERROR! BOOKMARK NOT DEFINED.
2.1 Objetivo ....................................................................... Error! Bookmark not defined.
2.2 Metodologia ................................................................................................................. 14
3 REVISÃO BIBLIOGRÁFICA ........................................................................................ 16
3.1 Modelagem estrutural para cálculo com elementos finitos ......................................... 16
3.2 API para o Femap com programação em VB.net ........................................................ 20
3.3 Nomenclatura utilizando Femap.................................................................................. 21
4 CÓDIGO MAPLOADS.VB ............................................................................................ 27
4.1 Contexto ...................................................................................................................... 27
4.2 Solução atual ............................................................................................................... 29
4.3 Proposta de melhoria ................................................................................................... 29
4.4 O algoritmo .................................................................................................................. 30
4.4.1 Inputs MapLoads.vb ...................................................................................... 31
4.4.2 Tratamento dos inputs para o Femap ........................................................ 33
4.4.3 Interface com o FEMAP ............................................................................... 35
4.4.4 Mensagens de erros e avisos ...................................................................... 36
4.4.5 Análise de desempenho ............................................................................... 37
4.4.6 Código final ..................................................................................................... 43
4.5 Estudo de Caso: Reproduzir uma análise de flambagem com uso do MapLoads.vb .. 45
4.5.1 Análise estática do modelo global .............................................................. 45
4.5.2 Condição de contorno do modelo local para análise de flambagem .... 47
4.5.3 Mapeamento dos SPCD a partir dos vetores de deslocamento ............ 48
4.5.4 Mapeamento dos SPCD e momentos de restrição para análise de
flambagem. ............................................................................................................... 49
4.5.5 Conclusão do estudo de caso ..................................................................... 53
5 ENVELOPEGROUPS .................................................................................................... 54
5.1 Contexto ...................................................................................................................... 54
5.2 Solução atual ............................................................................................................... 55
5.3 Proposta de melhoria ................................................................................................... 56
5.4 O algoritmo EnvelopeGroups.vb ................................................................................. 57
5.4.1 A interface ......................................................................................................... 57
5.4.2 O código ............................................................................................................ 62
5.4.3 Mensagens de erros ........................................................................................... 65
5.5 Estudo de Caso: Comparar envelopes de Tensão de Von Mises de uma pá de hélice
após remoção de material .................................................................................................. 66
5.5.1 Introdução do estudo de caso ............................................................................ 66
5.5.2 Definindo entradas do EnvelopeGroups.vb....................................................... 68
5.5.3 Saídas do EnvelopeGroups.vb ........................................................................... 70
5.5.4 Análise dos resultados ....................................................................................... 72
5.5.5 Conclusão do estudo de caso ............................................................................. 72
6 CONCLUSÃO GERAL .................................................................................................. 73
7 TRABALHOS FUTUROS .............................................................................................. 74
8 REFERÊNCIAS BIBLIOGRÁFICAS ........................................................................... 75
12

1 INTRODUÇÃO

A certificação de aeronaves envolve, entre várias outras análises, a validação


de todos os componentes estruturais. Atualmente, a validação de estruturas
aeronáuticas é feita utilizando análise numérica com softwares de elementos finitos e
análise experimental. Os dois tipos de análise em conjunto validam a estrutura
garantindo sua capacidade em suportar os carregamentos de projeto para os critérios
de falha aplicáveis. Todas as análises feitas devem ser detalhadas no relatório
estrutural de cada estrutura da aeronave que deve ser enviado ao órgão
regulamentador, no Brasil a ANAC, para a certificação.
A certificação de um programa de aeronave ocorre uma única vez em sua fase
de projeto, porém, nenhum processo produtivo é isento de erros e não é possível
garantir a repetibilidade perfeita da estrutura certificada para as futuras aeronaves.
Uma estrutura cuja as dimensões e especificações não estejam dentro das tolerâncias
contidas no relatório estrutural é chamada de estrutura não conforme sendo o
defeito a não conformidade. Por não estarem cobertas pelo relatório estrutural, ou
seja, por não serem certificadas, as estruturas não conformes devem ser analisadas,
retrabalhadas ou até mesmo descartadas se necessário. Devido a frequência em que
ocorre não conformidades na linha de produção e devido o alto valor agregado nas
estruturas aeronáutica, descartar todas estruturas não conformes não é uma opção
considerável para o fabricante por ameaçar a competitividade da empresa. Logo, é
necessária uma equipe de apoio à produção composta de engenheiros especialistas
em análise de estruturas responsáveis em avaliar a gravidade de cada não
conformidade e suas especificidades.
Ao receber uma nota CD1 a equipe de apoio à produção da inicio ao
procedimento que define o futuro da estrutura não conforme. O procedimento inicia-
se pela pesquisa e obtenção do modelo de elementos finitos (MEF) daquela estrutura
juntamente com seu relatório estrutural (RE). Afim de garantir que o engenheiro está
se referenciando ao MEF correto da estrutura certificada, algumas análises
importantes contidas no RE são reproduzidas. Uma vez em posse do MEF validado,
a não conformidade ocorrida é reproduzida no MEF e a estrutura é reanalisada. A

1
Nota emitida pela linha de produção afim de reportar uma não conformidade
contendo todos os detalhes da estrutura não conforme e do defeito
13

reanálise da estrutura pode ser dispensada somente se a região da não conformidade


apresentar uma alta margem de segurança (HMS – High Margin of Safity, MS>200%)
para todos os critérios de falha aplicáveis.
O processo de leitura do RE, análise do MEF, reprodução da não conformidade
e reanálise do MEF junto com a devida documentação demanda um tempo importante
da equipe sendo uma grande oportunidade de melhoria. Afim de tornar o cotidiano da
equipe mais produtivo, é proposto neste trabalho uma forma de automatizar processos
repetitivos que ocorrem em toda análise de estruturas não conformes com a criação
de API (Application Programming Interface).
API são programas desenvolvidos em uma linguagem de programação
compatível com o software em questão. Entre outras linguagens, o Femap apresenta
compatibilidade com a linguagem de programação VB.net, utilizada pelo Visual Basic
Studio (VBS), linguagem esta utilizada neste trabalho. Com uso do VBS é possível
criar API com interfaces amigáveis ao usuário, não requerendo conhecimento prévio
de programação ou conhecimento de VB.net para executar o programa desenvolvido.
Com o uso do VBS, é possível gerar um arquivo executável (.exe) do API
desenvolvido. Este arquivo passa a ser independente ao VBS, não necessitando que
o mesmo esteja instalado na máquina para ser executado. O programa desenvolvido
também pode ser inserido no diretório do Femap, sendo incorporado pela sua
interface sempre que o Femap for iniciado.
API são capazes de interagir com o Femap utilizando sua biblioteca de funções.
Desta forma, todas as funcionalidades do Femap disponíveis ao usuário para a
manipulação de um MEF também podem ser executadas por um API. Existem vários
objetos disponíveis na programação de um API, alguns exemplos de objetos comuns
são objetos de:

 Geometria  Pontos, linhas, superfícies e sólidos


 Modelo  Nós, elementos, cargas, restrições, etc.
 Outputs (saídas)  Vetores de saída, contorno, casos de estudo

Todos esses objetos podem ser manipulados no Femap por ordem do API.
14

O objetivo deste trabalho é reduzir o tempo de trabalho da equipe de apoio a


produção da aviação executiva da Embraer em análises de estruturas não conformes
com a criação de dois API afim de automatizar processos repetitivos no Femap.
O primeiro API apresentado neste trabalho é responsável por auxiliar análises
que utilizam como entradas as saídas de uma outra análise prévia. Essa relação entre
duas análises é comum principalmente quando deseja-se analisar apenas uma parte
de um grande MEF. Neste caso, resultados de tensões ou deslocamentos dos nós
encontrados após análise de modelo global servem como condições de contorno do
modelo local. Neste caso, vetores de saída2 como: deslocamento de nós, forças e
momentos de restrição do modelo global são transformados em deslocamentos
forçados e forças e momentos aplicados do modelo local. O primeiro API auxilia nesta
conversão entre saídas e entradas de análise.
O segundo API auxilia na tarefa de analisar o impacto de uma não
conformidade em vetores de saída importantes de acordo com o RE da estrutura
como: tensão de Von Mises, Tensão principal mínima, Tensão principal máxima, ou
outro vetor de saída de interesse.
O desenvolvimento de API’s será abordado neste trabalho da seguinte forma:
 O capítulo 2 contém a revisão bibliográfica afim de permitir a compreensão da
teoria e nomenclatura utilizada ao longo do trabalho
 O capítulo 3 contém o desenvolvimento do API MapLoads.vb
 O capítulo 4 contém o desenvolvimento do API EnvelopeGroups.vb
 O capítulo 5 contém a conclusão geral do desenvolvimento dos dois API’s
 O capítulo 6 aborda as sugestões para trabalhos futuros

1.1 Metodologia

Este trabalho apresenta 2 API que foram desenvolvidos dentro da equipe de


apoio a produção da aviação executiva da EMBRAER. O desenvolvimento de ambos
API foram resultados do seguinte procedimento:

2
Objetos contendo o resultado do cálculo do Solver em cada elemento onde o
resultado foi requerido. Cada vetor possui um ID único estabelecido pelo Nastran
também utilizados pelo API.
15

Identificar
Interface
oportunidade Esboço do API Código Testar API
gráfica
de melhoria

Figura 1 - Procedimento na criação de API


Fonte: próprio autor, 2018

 Identificar oportunidade de melhoria: Consiste em identificar tarefas repetitivas


feitas manualmente pelo usuário na análise de um MEF. Antes de decidir
desenvolver um API, é necessário verificar se não existe outros meios já
disponíveis para executar a operação desejada. É necessário ter uma visão
geral de aplicação do API para que não seja uma ferramenta aplicável somente
em casos específicos de análise
 Esboço do API: Nesta etapa é definido as entradas e saídas principais do
programa, bem como a estratégia de programação. A biblioteca do Femap
fornece mais de um único meio para executar determinada função, cabendo ao
programador definir qual será a mais eficiente para suas necessidades. Além
das opções do Femap, a linguagem de programação em si permite várias meios
de obter o mesmo resultado de forma mais ou menos eficiente e/ou conveniente
 Construir a interface gráfica: Para que a execução do programa seja uma tarefa
simples e dispense conhecimento de programação do usuário, é criado uma
interface para receber os inputs necessários e enviar ao código. A interface
também tem a função de indicar o status de execução do programa e também
de requisitar ações ao usuário ao longo da execução (ex.: pedir que usuário
faça alguma operação na interface do Femap). Algumas funcionalidades
também podem ser atribuídas à interface gráfica como: ativar ou desativar
opções de uma segunda entrada caso uma primeira tenha sido selecionada e
iniciar valores de entradas como default
 Código: O código é criado com linguagem de programação vb.net contido no
arquivo NomedoPrograma.vb. O código será o coração do programa
responsável por ler e processar as entradas do usuário e gerar as saídas
 Testar API: O teste do API é feito ao comparar seus resultados com os
resultados da solução atual. Um teste de falhas de usuário propositais também
é realizado para garantir que o programa não irá parar ou gerar resultados
indesejados em caso de erros como: nenhum input selecionado, Femap
16

encontra-se fechado, input errado. Em tais casos, o API é responsável por gerar
mensagens de erros e avisos para que o usuário faça a devida correção

2 REVISÃO BIBLIOGRÁFICA

2.1 Modelagem estrutural para cálculo com elementos finitos

O método de elementos finitos é um método numérico para a resolução de


equações diferenciais parciais (EDP) dentro de um domínio definido. Resolver EDP’s
permite ao método resolver problemas em várias áreas de estudo como: Estruturas,
Mecânica dos fluidos e transferência de calor. É mostrado na Figura 2 uma
representação de uma viga com seção I modelada no software Femap (Software para
análise estrutural utilizando o método de elementos finitos).

Figura 2 - Modelo de uma viga I no software Femap


Fonte: próprio autor, 2018

Na figura, observa-se a subdivisão do domínio da estrutura em elementos,


podendo esses ser uni, bi ou tri-dimensionais. Cada elemento quadrangular possui
em seus vértices os nós. Elementos e nós são os objetos fundamentais para qualquer
17

MEF. Com esses objetos, é possível definir a geometria de uma estrutura que,
juntamente com a condição de contorno, definem o problema físico. As condições
de contorno definem a influência externa na estrutura, podendo ser: forças,
momentos, deslocamentos, temperaturas aplicadas à estrutura e restrições de
movimento em parte da estrutura. Cada elemento estrutural deve conter o material e
propriedade que definem a rigidez da estrutura. As propriedades contêm informações
espaciais dos elementos estruturais como: espessura, dimensões da seção de uma
barra, rigidez, entre outras informações, e fazem referencia a um material definito. Ao
MEF deve ser informado as propriedades necessárias do material afim de realizar o
calculo desejado (por exemplo, caso não haja variação de temperatura, o coeficiente
de dilatação térmica é dispensado).
A modelagem de um problema estrutural com elementos finitos pode ser
resumida em três etapas:

i. Pré-processamento
ii. Cálculo
iii. Pós-Processamento

Pré-processamento
O pré-processamento é a etapa de criação do modelo afim de representar um
problema físico. Nesta etapa é gerado a malha (elementos e nós) do modelo como
mostrado na Figura 2. Também é definido as condições de contorno, propriedades e
materiais da estrutura que compõe cada parte do modelo. Após definido todas as
informações da estrutura necessárias para o cálculo, é definido o tipo de análise a ser
feito, podendo ser uma análise estática, dinâmica, modal, de flambagem, não linear,
de otimização, entre outros tipos aceitos pelo Solver. Define-se também parâmetros a
serem considerados durante o cálculo, bem como o que se deseja como resultado
(tensão elementar, deslocamentos de nós, deformação, etc.). Finalmente é exportado
o cartão do modelo, sendo este um arquivo texto contendo todas as informações do
modelo e da análise. É mostrado na Figura 3 um cartão de um MEF simples a ser
enviado para o Solver. Cada linha contida no cartão deve serguir o padrão do Natran
que pode ser encontrado em (SIEMENS, 2014) NX NASTRAN USER’S GUIDES.
18

Figura 3 - Exemplo de cartão de um modelo para análise no Nastran


Fonte: próprio autor, 2018

Cálculo
O cálculo das EDP em cada nó e elemento é realizado pelo Solver. Atualmente
o Nastran é o solver mais utilizado em análise de elementos finitos. Este software
desenvolvido pela NASA tem como função receber o cartão enviado pelo pré-
processador e realizar o cálculo dos deslocamentos dos nós utilizando o método de
elementos finitos. Em função dos deslocamentos dos nós calculados, o solver
consegue calcular as demais saídas solicitadas no cartão e exportar os resultados
para o pós-processador.

Pós-processamento
O pós-processamento é a etapa onde os resultados podem ser coletados e
mostrados ao usuário em uma forma que facilite a leitura dos valores.
Nesta etapa deve ser verificado se o resultado condiz com o que era esperado,
podendo indicar algum erro durante a fase de pré-processamento. Também é feito
nesta etapa a análise dos critérios de falha afim de julgar se a estrutura suporta ou
não o carregamento aplicado. É mostrado na Figura 4 a deformada de uma chapa
19

simplesmente apoiada submetida à compressão, obtida na fase de pós-


processamento de uma análise de flambagem.

Figura 4 - Resultado da deformada em uma análise de flambagem


Fonte: próprio autor, 2018

Até aqui foi mencionado elementos básicos para a modelagem com elementos
finitos, porém a modelagem estrutural pode ser tão complexa quanto necessário afim
de atender ao nível de detalhamento desejado. Existem vários outros tipos de
elementos, como: Cbeam (elementos de vigas), Cbar (elementos de barra), Rod
(elementos de tubos), Gap (espassadores), CINTC (elementos distribuidores de
carga), entre outros, que auxiliam na simulação aproximada do evento físico real.
Grande parte da dificuldade da modelagem reside na aplicação correta da condição
de contorno afim de simular as condições físicas ao qual a estrutura está sujeita. A
simulação sempre será uma aproximação da realidade.
20

2.2 API para o Femap com programação em VB.net

O Femap é um software de análise estrutural utilisando o método de elementos


finitos. Ele cumpre a função de pré e pós processador na análise (ver item 2.1). Uma
das qualidades do software é permitir que suas funcionalidades sejam acessíveis à
códigos externos, o que permite a automatização de qualquer processo que pode ser
realizado dentro de sua interface por um usuário. Esse processo é realizado através
de API (Application Program Interface). API são programas desenvolvidos em
ambiente externo ao Femap que podem acessar suas funcionalidades através de um
código de programação sem ter acesso ao código fonte do Femap. O API deve
importar a biblioteca de funções do Femap para que a troca de informações seja
possível. Todas as funções que podem ser executadas manualmente no Femap
também podem ser executadas por um API utilizando as funções contidas na
biblioteca do Femap. Todas essas funções podem ser encontradas em (SIEMENS,
2014) FEMAP API REFERENCE.
Uma linguagem de programação aceita pelo Femap para a criação do API é o
Vb.net (ou simplesmente .net), podendo ser desenvolvida no software Visual Basic
Studio. Tal software além de possuir uma interface amigável para a criação do código,
possibilita a criação da interface do programa. Com a interface o usuário pode inserir
os inputs necessários ao código de forma intuitiva, sem que este precise ter
conhecimento prévio de programação. As funções disponíveis pela linguagem do
vb.net e funcionalidades do VBS podem ser encontradas em (Microsoft Guia do .NET,
2018) e (Microsoft Guia do Visual Basic, 2018) respectivamente.
Após concluído o API com o VBS, o mesmo pode ser exportado como um
arquivo executável (.exe) e pode ser inserido nas pastas de instalação do Femap.
Com isso o programa passa a ser um toolbox do Femap assim como qualquer outra
função. Com os API é possível “equipar” o Femap com uma infinidade de
funcionalidades desejadas.
21

2.3 Nomenclatura utilizando Femap

O Femap possui várias ferramentas, objetos e funcionalidades disponíveis e


cobrir todas essas funcionalidades não é o escopo do trabalho. Porém alguns termos
utilizados frequentemente ou pelo Femap ou na linguagem do cotidiano de uma
equipe de estruturas serão listados a seguir:

i. Degree of Freedom - DOF


“O menor número de parâmetros (movimento, coordenadas, temperatura, etc.)
requerido para definir a posição e o estado de qualquer entidade no espaço são
conhecidos como graus de liberdade (DOF – Degree of Freedom).” (Altair
Engineering, 2015).
Neste trabalho, os únicos DOF necessários utilizados são os parâmetros de
movimento, uma vez que apenas o eixo de coordenadas global é utilizado e todos os
demais parâmetros são constantes. Se considerarmos um nó no espaço, seu
movimento é completamente definido por 6 DOF, entre eles: 3 DOF para rotações e 3
DOF para translação nos 3 eixos de coordenadas. Os 6 DOF de um nó são
representados Figura 5. Na figura, as translações e rotações nos eixos X, Y e Z são
representadas como T1, T2, T3 e R1, R2 e R3 respectivamente, sendo essa
nomenclatura utilizada ao longo deste trabalho.

Figura 5 - Translações e rotações em cada eixo totalizando os 6 DOF que definem o movimento de um nó no
espaço
Fonte: próprio autor, 2018
22

ii. Load Set


Os casos de carga (Load Cases) são combinações de carregamento aplicados
aos elementos e nós afim de reproduzir diferentes condições da estrutura. Vários tipos
de carga podem ser aplicadas no MEF como: Força nodal, força elementar, momento,
variação de temperatura, deslocamento forçado ao nó, entre outros. Em uma análise
de uma estrutura de aeronave, cada caso de carga reproduz diferentes condições que
a aeronave pode estar sujeita e manobras que a aeronave deve efetuar. Condições
de temperatura, manobras para pouso e decolagem, carregamento devido à falha de
atuadores, são eventos simulados através de combinações de carga. Tais
combinações estão contidos no caso de carga referente àquela manobra ou condição
da aeronave. O Femap e o API se referenciam aos casos de carga como Load Set,
neste trabalho serão utilizados ambos os termos: Caso de carga e Load Set, sendo
escolhido o mais adequado para o contexto. Após a análise, cada caso de carga gera
um Ouput Set, elemento do Femap que contém o conjunto de vetores de saídas
solicitados para cada Load Set.

iii. Single Point Constraint - SPC


SPC são utilizados para restringir 1 ou mais DOF de um nó afim de reproduzir
a condição de contorno da estrutura. A Figura 6 mostra um exemplo de condições de
contorno aplicado aos nós de extremidade de um elemento unidirecional. Neste
exemplo, a barra esta fixa na extremidade esquerda e simplesmente apoiada na
extremidade direita. Os DOF restringidos por cada SPC é indicado por números abaixo
do símbolo triangular (símbolo do SPC). Nota-se que a restrição do DOF 1 ao nó
simplesmente apoiado é dispensado por ser a direção de aplicação da carga. Caso
tal DOF fosse restringido, a força seria completamente resistida pelo SPC e o
elemento de barra não responderia a aplicação da força.

Figura 6 - Exemplo da condição de contorno de uma barra submetida à uma força de compressão
Fonte: próprio autor, 2018
23

iv. Single Point Constraint Displacement - SPCD


SPCD é um deslocamento forçado imposto ao nó. Por mais que tenha restrição
(Constraint) em seu nome, o SPCD é mais entendido como uma carga de aplicada,
uma vez que seu efeito é o mesmo à de uma força aplicada ao nó que resulte no
mesmo valor de deslocamento. A vantagem de uso do SPCD é que você pode, e deve,
restringir o DOF da direção de aplicação da carga. Dessa forma, o nó terá o respectivo
DOF restringido após o deslocamento forçado, comportamento extremamente útil
para análises como as de flambagem. Similarmente ao exemplo da Figura 6, a Figura
7 mostra um exemplo de uma barra com a mesma condição de contorno submetida a
compressão (nota-se que dessa vez o DOF 1 é restringido). Caso não haja restrição
do DOF no sentido de aplicação do SPCD, o Solver irá desconsiderar o SPCD e
emitirá uma mensagem de aviso ao usuário.

Figura 7 - Exemplo da condição de contorno de uma barra submetida à SPCD de compressão


Fonte: próprio autor, 2018

v. Vetores de saída
Vetores de saída são vetores cujo cada valor corresponde ao resultado do
cálculo do solver para um determinado elemento ou nó do MEF. Antes de enviar o
cartão do MEF ao solver, o usuário deve definir no cartão qual ou quais serão os
vetores de saída que solver deverá calcular (Figura 3). Cada vetor de saída é
identificado por um ID fixo determinado pelo Nastran, o qual também é utilizado pelo
código de API. A Tabela 1 lista alguns dos possíveis vetores de saída obtidos após o
cálculo do Solver.
24
Tabela 1 - Identificador e título de alguns vetores de saída do solver Nastran
ID Título ID Título
1 Total Translation 52 T1 Constraint Force
2 T1 Translation 53 T2 Constraint Force
3 T2 Translation 54 T3 Constraint Force
4 T3 Translation 55 Total Constraint Moment
5 Total Rotation 56 R1 Constraint Moment
6 R1 Rotation 57 R2 Constraint Moment
7 R2 Rotation 58 R3 Constraint Moment
8 R3 Rotation 60010 Solid X Normal Stress
41 Total Applied Force 60011 Solid Y Normal Stress
42 T1 Applied Force 60012 Solid Z Normal Stress
43 T2 Applied Force 60013 Solid XY Shear Stress
44 T3 Applied Force 60014 Solid YZ Shear Stress
45 Total Applied Moment 60015 Solid ZX Shear Stress
46 R1 Applied Moment 60016 Solid Max Prin Stress
47 R2 Applied Moment 60017 Solid Min Prin Stress
48 R3 Applied Moment 60018 Solid Int Prin Stress
51 Total Constraint Force 60028 Solid Max Shear Stress

vi. Caso de estudo


Caso de estudo é uma funcionalidade do Femap que permite agrupar os Output
Sets em categorias diferentes. Por exemplo, ao estudar uma não conformidade, é
interessante separar os resultados da análise da estrutura intacta e da estrutura
modificada para os mesmos casos de carga afim de evitar erros na manipulação dos
resultados. A Figura 8 mostra um exemplo em que os resultados são agrupados em 3
casos de estudos diferentes contidos na arvore de projeto do Femap.

Figura 8 - Exemplo de casos de estudos criados para organizar outputs


Fonte: próprio autor, 2018
25

vii. Contorno
Contorno é uma ferramenta visual do pós-processador que consiste em atribuir
cores aos elementos em função do valor do vetor de saída selecionado contido no
Output Set ativo. A Figura 9 mostra um contorno para o vetor tensão de Von Mises.

Figura 9 - Exemplo de contorno para o vetor Tensão de Von Mises


Fonte: próprio autor, 2018

viii. Envelopes
Envelopes são vetores que agrupam o valor máximo de um ou mais vetores de
saída em cada elemento considerando dois ou mais casos de carga. Logo, o envelope
permite uma análise mais eficaz do carregamento da estrutura que possui vários
casos de carga. As Figura 10 e Figura 11 mostram um MEF de asa com contorno do
vetor Tensão de VonMises do caso de carga 1 e caso de carga 2 respectivamente. É
feito um envelope dos valores máximos de tensão de VonMises e o resultado
mostrado na Figura 12. Observa-se na Figura 12 que o valor em cada elemento é o
maior entre os valores do mesmo elemento na Figura 10 e Figura 11.
26

Figura 10 - Exemplo de contorno de valores do vetor Tensão de VonMises para caso de carga “Case1”
Fonte: próprio autor, 2018

Figura 11 - Exemplo de contorno de valores do vetor Tensão de VonMises para caso de carga “Case2”
Fonte: próprio autor, 2018

Figura 12 - Envelope do vetor “Tensão de VonMises” dos casos de carga “Case1” e “Case2”
Fonte: próprio autor, 2018
27

3 CÓDIGO MAPLOADS.VB

3.1 Contexto

A análise de estruturas de alta complexidade é inviável se todos seus detalhes


são considerados em um único MEF. É fundamental ao analista saber equilibrar o
detalhamento do modelo com o custo computacional. Um avião é uma montagem que
envolve estruturas de diferentes escalas, desde grandes painéis que compõem a
fuselagem à pequenas emendas que une as longarinas da asa. Um modelo que
considera todos esses detalhes em uma única análise certamente apresenta um custo
computacional altíssimo, sua elaboração consequentemente geraria uma perda da
competitividade da empresa.
Uma solução conhecida para este problema é dividir o processo de análise de
grandes montagens em dois tipos de modelo: o modelo global e modelo local.
O modelo global contém a montagem completa a ser analisada. Tal modelo
contém elementos grosseiros (cujas dimensões tem a mesma ordem de grandeza das
dimensões principais da estrutura). Seu objetivo é prever fenômenos globais da
estrutura que são verificados com ensaios experimentais.

O que é calculado com o modelo global:


 Fluxo de cisalhamento que passa da fuselagem para a asa
 Flambagem de Euler da asa

O que não é calculado com o modelo global:


 Flambagem local de placas
 Cargas aplicadas aos rebites

Para realizar análises mais detalhadas não cobertas pelo modelo global, o
modelo local deve ser isolado (exportado para um novo modelo) utilizando como
condição de contorno os resultados de análises do modelo global. O processo de
obtenção de carregamento e casos de carga a partir de resultados de análises é
chamado de mapeamento. Desta forma, cada componente da grande montagem do
modelo global pode ser analisado separadamente e isoladamente após mapear as
condições de contorno do modelo local.
28

Dessa forma é possível cobrir todos dos níveis de detalhamento da estrutura


global desejados além de desenvolver diferentes tipos de análises (como flambagem
locais, cravações, análises não lineares) sem elevar excessivamente o tempo de
cálculo. A estratégia de uso do modelo local eleva o número de análises, comparado
com uma única análise do modelo global, porém tal divisão traz benefícios como:
arquivos menores de MEF e de resultados e melhor organização de resultados das
análises.
Existem duas formas de aplicar a condição de contorno ao modelo local
baseadas em resultados de cálculo do modelo global:

i. Deslocamentos e rotações obtidos do cálculo do modelo global. Tais


deslocamentos e rotações são aplicados na forma de SPCD aos nós de
interface.
ii. Força e momento de restrição obtidos do cálculo do modelo global. Tais
parâmetros são transformados em forças e momentos aplicados aos nós de
interface do modelo local.

Para gerar o modelo local, é necessário:

i. Isolar e exportar a região do modelo local para um novo arquivo.


ii. Obter as condições de contorno (Forças e momentos ou SPCDs aplicados
aos nós de interface) do modelo local apartir do resultado de análise do
modelo global.

O Femap atende satisfatoriamente a etapa i deste processo, porém a eficiência


da etapa ii é limitada ao número de casos de carga à serem considerados. A
ferramenta encontrada em Model > Loads > From Output na interface do programa é
utilizada para realizar essa conversão, porém é necessário executá-la manualmente
a cada caso de carga. Devido à grande variedade de manobras e condição que uma
aeronave está sujeita, frequentemente seu MEF contém centenas3 de casos de carga.

3
A quantidade real de casos de carga é superior à quantidade de casos considerados pela equipe
de estruturas. Uma redução é feita retirando casos que são sempre menos críticos (do ponto de
vista de estrutura) que outro.
29

Neste caso, a opção Load From Output do Femap torna-se inviável e o uso de um
processo automatizado é indispensável.

3.2 Solução atual

Uma forma de automatizar uma tarefa no Femap é a programação dentro da


sua interface, na opção Program Files. Atualmente o problema de gerar modelos
locais a partir de modelos globais contendo vários casos de carga é solucionado por
um script executado no Program Files. Um programa executado em nesta área do
Femap executa exatamente o mesmo procedimento que o usuário faria,
repetitivamente. Enquanto o código é executado, podemos observar na tela os
mesmos passos da ferramenta Load From Output sendo executado várias vezes.
Logo, como o mesmo processo feito pelo usuário é feito pela máquina, o tempo de
operação diminui consideravelmente. Mesmo sendo mais eficaz que a operação
manual, foi identificado pontos negativos e oportunidades de melhorias na solução
atual:

i. Não é possível executar outra operação enquanto o código está sendo


executado, sendo qualquer interferência no momento do cálculo introduzida
no procedimento do código
ii. O script deve ser copiado e colado na área Program Files a cada vez que o
Femap é aberto antes da execução
iii. Não há uma interface amigável para o usuário, que deve ter um
conhecimento mínimo de programação para inserir os inputs necessários.
iv. Mesmo sendo mais eficaz que o mapeamento manual, o código consome
tempo considerável da equipe para cobrir centenas de casos de carga
v. Diferentes opções de mapeamento (SPCDs e forças/momentos) requerem
códigos diferentes

3.3 Proposta de melhoria

Frente aos pontos supracitados, é proposto a criação de uma ferramenta


utilizando o VBS como forma alternativa de automação para o Femap. Este programa
nos permite automatizar as tarefas no Femap e gerar um programa executável (.exe)
30

que pode ser executado de forma independente ao VBS. Ele também nos permite criar
uma interface amigável ao usuário, logo seu uso não depende de nenhum
conhecimento prévio na linguagem de programação utilizada. Ao adicionar o
programa criado à biblioteca do Femap, o mesmo será carregado assim que o Femap
for iniciado, não sendo necessário carregá-lo a cada análise. Tais pontos positivos da
programação através do VBS motivou o desenvolvimento de um programa que
resolva o problema de mapeamento da condição de contorno e que o faça de forma
mais prática e mais eficiente que a solução atual. As duas opções de condição de
contorno (cargas e SPCD) são comumente utilizadas, dependendo do tipo de análise
a ser feita com o modelo local, logo é importante que o código permita mapear ambas
condições de carregamento a ser decidido pelo usuário.
Por praticidade, o código desenvolvido nesta parte do trabalho será
referenciado por seu nome: MapLoads.vb.

3.4 O algoritmo

É mostrado na figura a interface gráfica do MapLoads.vb por onde alguns inputs


são definidos.

Figura 13 - Interface gráfica do MapLoads.vb


Fonte: próprio autor, 2018
31

A Figura 14 ilustra o fluxograma simplificado do processo global do


MapLoads.vb.

Figura 14 - Fluxograma simplificado do procedimento global do MapLoads.vb.


Fonte: próprio autor, 2018

3.4.1 Inputs MapLoads.vb

Cada input da interface gráfica do MapLoads.vb está representado na Tabela


2 à Tabela 4.
Tabela 2 – Inputs da caixa: Load Settings Input.
NOME Opções DESCRIÇÃO
1. Displacements to SPCD
Define o tipo de carregamento que a ser
Map Option 2. Constraint Loads to applied
mapeado
loads
Define os DOF considerados para o
T1,...,T6 Check/Uncheck
mapeamento
First Load
Número inteiro Define o primeiro ID do Load Case criado4
Case

Tabela 3 - Inputs da caixa: Constraint Settings Input.


NOME Opções DESCRIÇÃO
Define se o código criará ou não SPC aos
Create SPC Yes/No
nós em que o carregamento for aplicado
Define os DOF em que os SPC serão
DOF1,...,DOF6 Check/Uncheck
criados.

4
Caso o valor atribuído ao First Load Case seja menor ou igual ao primeiro ID de Load Case
já existente no Femap, uma combinação ou sobreposição de Load Set irá ocorrer no
mapeamento, a ser definido pelo usuário em uma caixa de diálogo emitida pelo Femap durante
o Mapeamento.
32

Tabela 4 - Inputs da caixa: Performance Settings Input5.


NOME Opções DESCRIÇÃO
Enable Screen Define se a tela do Femap será
Check/Uncheck
atualizada após cada Load Set for criado.
Updating
Use Parallel Define so cálculo será divido entre todos
Check/Uncheck
os núcleos do processador.
Calculation

Além dos inputs previamente definidos na interface gráfica, existem aqueles


que são definidos na interface do Femap após o MapLoads.vb for executado, como:

i. Seleção dos nós do modelo onde o carregamento será mapeado (Figura 15)
ii. Seleção dos Output sets de onde o carregamento será extraído (Figura 16)

Figura 15 - Seleção dos nós na interface do Femap por ordem do MapLoads.vb


Fonte: próprio autor, 2018

5
Os inputs de desempenho do código serão apresentados no item 3.4.5.
33

Figura 16 - Seleção dos Load Set na interface do Femap por ordem do MapLoads.vb
Fonte: próprio autor, 2018

3.4.2 Tratamento dos inputs para o Femap

Nesta etapa, o MapLoads.vb cria os inputs à serem enviados para as funções


do Femap à partir das opções definidas na interface gráfica (cotidos no código na
Figura 17). São utilizadas funções contidas na biblioteca do Femap (importada pelo
MapLoads.vb) que executam a operação desejada, como a de abrir uma caixa de
seleção de nós. Tais funções do Femap requerem inputs específicos que são gerados
no tratamento dos inputs da interface gráfica. Por exemplo, se o usuário solicitar o
mapeamento de SPCD, o código atribuirá o valor 3 e 4 às variáveis load_type1 e
load_type2, respectivamente. O valor da variável load_type comunica ao Femap qual
tipo de carregamento está sendo criado, sendo o valor 1 e 2 para o tipo
força/momentos aplicados, 3 e 4 para o tipo translação e rotação forçada (SPCD).
Outra atribuição que é feita é o identificador (ID) dos vetores de saída a serem lidos
pelo MapLoads.vb. Caso seja solicitado o mapeamento de SPCD, os IDs: 2, 3 e 4
(translação em X, Y e Z) e 5, 6 e 7 (rotação em X, Y e Z) serão atribuídos na função
de mapeamento. Caso seja solicitado o mapeamento de força e momento, os ID: 52,
53 e 54 (forças de restrição em X, Y e Z) e 55, 56 e 57(momentos de restrição em X,
Y e Z) serão atribuídos.
34

A Figura 17 mostra o trecho do código onde é feito a leitura da entrada Map


Option, Create constraint e First Load Case ID.

Figura 17 - Leitura dos inputs da interface gráfica


Fonte: próprio autor, 2018

Uma vez definidos os inputs para o Femap, o MapLoads.vb obtém do Femap


os valores de output de interesse (deslocamentos ou forças de restrição) e armazena-
os em vetores definidos no código. Este processo é mostrado na Figura 18. A estrutura
If identifica qual opção de mapeamento foi selecionado pelo usuário. O valor desta
opção definirá os valores dos ID dos outputs (2...8 para deslocamento e rotação e
52...58 para forças e momentos). Dentro da estrutura, as variáveis Value1...6
assumem o valor da função ReadVectors. Esta função, mostrada na Figura 19, retorna
o vetor com os valores do vetor de saída do Femap que possui o ID selecionado. Para
isso, utiliza-se a função GetOutputListAtID disponibilizado no diretório do Femap.
35

Figura 18 - Função do MapLoads.vb para ler valores de output do Femap


Fonte: próprio autor, 2018

Figura 19 - Função ReadVectors do MapLoads.vb para obter vetores de output do Femap


Fonte: próprio autor, 2018

3.4.3 Interface com o FEMAP

Uma vez com todos os inputs necessários, o MapLoads.vb usa da função


AddArray para adicionar carregamento em múltiplos nós. O trecho do código
responsável por esta função é mostrado na Figura 20.
36

Figura 20 - Função do MapLoads.vb para criar carregamento no Femap


Fonte: próprio autor, 2018

O procedimento descrito anteriormente é processado à cada caso de carga de


resultados, transformando-os em casos de carga aplicados.

3.4.4 Mensagens de erros e avisos

Para impedir que o programa retorne resultados errados, vazios ou que não
execute a tarefa desejada, é necessário inserir no MapLoads.vb caixas de mensagens
de erro que serão mostrados ao usuário. Além de erros fatais, existem casos em que
o MapLoads.vb executa a tarefa porém o resultado não é o que o usuário deseja
devido a erros de inputs. Para este último caso é necessário inserir mensagens de
aviso. As caixas de mensagem dão ao usuário a opção de realizar a correção, finalizar
o programa ou continuar o procedimento (apenas para mensagens de aviso). As
mensagens de erros e avisos são listadas na Tabela 5.
Tabela 5 - Mensagem de erros e avisos
Fonte: próprio autor, 2018
Nota: coluna Mensagem contém capturas de tela do Femap e Visual Basic Studio
ID Motivo Mensagem

Nenhum nó foi
Erro 01
selecionado

Nenhum Output Set


Erro 02
foi selecionado
37

Output set
selecionado não
Erro 03
contém o vetor de
output desejado

ID de carregamento
Aviso 01 que deseja-se criar já
existe.

As mensagens são inseridas no programa dentro de estruturas condicionais “If”


(Figura 21), que avalia se as entradas definidas pelo usuário satisfazem a condição
de anormalidade.

Figura 21 - Rotina para verificar existência de output desejado


Fonte: próprio autor, 2018

3.4.5 Análise de desempenho

Para análise de desempenho, foi utilizado um modelo teste de uma estrutura


responsável pela ligação asa/fuselagem do programa Legacy500 da Embraer. A
estrutura contém 3253 nós de interface e seu resultado de análise estática contém
248 Outputs Set a serem convertidos em Load Set. É mostrado na tabela o
desempenho da solução atual (ver seção 3.2) e a primeira versão do MapLoads.vb.
38
Tabela 6 - Comparação do desempenho entre MapLoads.vb e solução atual
Fonte: próprio autor, 2018
Solução Desempenho
Código atual 440s (7min 20s)
MapLoads.vb 443s (7min 22s)

Concluiu-se então que mesmo o MapLoads.vb contendo qualidades como:


praticidade e permitir que outras tarefas sejam feitas enquanto o código está sendo
executado, ele se mostrou menos eficaz que a solução atual. Frente ao problema de
desempenho, um estudo de melhoria foi realizado no código afim de identificar trechos
do código onde o MapLoads.vb gasta mais tempo para executar afim de implementar
ação de melhoria.
Uma análise prévia do código indica o loop responsável por montar os vetores
das cargas à serem inseridas no Femap (Figura 22) como um forte candidato à ser
responsável por grande parte do tempo de cálculo.
Esta operação é necessária para adicionar os Load Set ao modelo, uma vez
que para adicionar carregamento à múltiplos nós é necessário que a informação esteja
contida em apenas um único vetor. Porém a leitura de outputs em múltiplos nós é feita
em vetores diferentes, um para cada grau de liberdade. Logo, o loop é responsável
por inserir múltiplos vetores em um único vetor.
39

Figura 22 - Loop responsável por gerar o vetor contendo as cargas à serem aplicadas
Fonte: próprio autor, 2018

Nesse trecho, os vetores Value1, Value2, ... , Value 6 são os vetores coletados
do output. Tais vetores são inseridos em 2 novos vetores maiores Vals1 e Vals2,
sendo que cada um contém valores de carga em 3 DOF. O vetor Vals1 coleta os dados
de Value1, Value2 e Value3 sendo esses os valores de carregamento relacionado aos
DOF 1, 2 e 3, respectivamente. O vetor Vals2 coleta os dados de Value4, Value5 e
Value6 sendo esses os valores de carregamento relacionado aos DOF 4, 5 e 6,
respectivamente.
Este trecho é então submetido à avaliação devido a quantidade de operações
executadas, calculada utilizando a Eq. i

𝑇𝑜𝑡𝑎𝑙 𝑑𝑒 𝑜𝑝𝑒𝑟𝑎çõ𝑒𝑠 = 𝑄𝑡𝑒. 𝑂𝑢𝑡𝑝𝑢𝑡 𝑠𝑒𝑡 ′ 𝑠 ∗ (𝑄𝑡𝑒. 𝑛ó𝑠 ∗ 𝑄𝑡𝑒. 𝑜𝑝𝑒𝑟𝑎çõ𝑒𝑠 𝑑𝑒𝑛𝑡𝑟𝑜 𝑑𝑜 𝑙𝑜𝑜𝑝)
Eq. i
Logo:
𝑇𝑜𝑡𝑎𝑙 𝑑𝑒 𝑜𝑝𝑒𝑟𝑎çõ𝑒𝑠 = 248 ∗ (3253 ∗ 12) = 9 680 928 𝑂𝑝𝑒𝑟𝑎çõ𝑒𝑠
40

É utilizado então a ferramenta StopWatch para validar a hipótese e indicar a


oportunidade de melhoria neste trecho.
O StopWatch do VBS é uma ferramenta responsável por calcular o tempo gasto
pelo código em executar determinado trecho de interesse. Primeiramente define-se
uma variável como StopWatch.new. Uma vez definida, a variável permite o
procedimento “.start()” e “.stop()”. Como ilustrado na figura.

Figura 23 - Exemplo de StopWatch.


Fonte: próprio autor, 2018

Ao passar pelo comando .start(), o código começa a contagem do tempo até o


código executar o comando .stop(), quando o cronômetro é encerrado. O tempo gasto
entre os dois comandos é registrado no objeto definido como stopwatch (Objeto
exemplo na Figura 23) e pode ser acessado pela propriedade “.ElapsedMilliseconds”
(Figura 24).

Figura 24 - Tempo gasto no procedimento da Figura 23 (0s devido a simplicidade do procedimento do exemplo).
Fonte: próprio autor, 2018
Nota: Captura de tela do Software Visual Basic Studio

Com uso do stopwatch, foi analisado a participação do trecho da Figura 22


citado no item anterior no tempo total gasto pelo MapLoads.vb. Para tal estudo, foi
41

escolhido apenas um Output Set, sendo o interesse o conhecimento da porcentagem


do consumo do tempo total dedicada ao trecho em questão.
Obteve-se então os resultados mostrados na Tabela 7.

Tabela 7 - Análise do tempo gasto pelo loop candidato à melhoria


Fonte: próprio autor, 2018
Procedimento Tempo gasto (s)
Código total 17.2
Loop (Figura 12) 15.5

Confirma-se então que o trecho da Figura 22 é onde o código dedica a maior


parte do tempo de processamento, sendo este responsável por 90% do tempo total
do código.
Uma vez identificado que uma estrutura “For” consome 90% do tempo total do
código, sugeriu-se utilizar o cálculo em paralelo como solução ao problema de
desempenho. Paralelizar a estrutura “For” significa dividir as tarefas executadas (9
680 928 linhas) para todos núcleos de processadores disponíveis da máquina.
Atualmente é comum encontrar computadores com processadores que possuem dois
ou mais núcleos, porém quando um código é executado, apenas um núcleo é
dedicado a executá-lo a menos que o cálculo em paralelo seja solicitado. Como cada
núcleo executará uma parte do loop simultaneamente, é necessário que as operações
contidas no loop sejam independentes entre si, ou seja, podem ser executadas em
ordem aleatória sem alterar o resultado do procedimento. A estrutura “For” em questão
(Figura 22) é perfeitamente adequada aos requisitos de uso do paralelo uma vez que
não importa a ordem de leitura dos nós ou a ordem das linhas dentro do for.
Outra solução proposta é de impedir que o MapLoads.vb atualize a visualização
do Femap a cada Load Set criado. É mostrado na Figura 25 as combinações entre o
uso, ou não, das duas soluções sugeridas. Foi considerado apenas 20 dos 248 Output
Sets para o teste.
42

Cálculo em paralelo/Atualização automática


de tela
40 Não/Sim, 37

35
Não/Não, 31
30
Tempo gasto (s)

25

20

15

10
Sim/Sim, 6.7
5
Sim/Não, 0.8
0

Figura 25 - Resultado de análise de desempenho. Legendas respondem as seguintes perguntas: Foi utilizado
cálculo em paralelo neste procedimento? / A atualização automática de tela para cada carregamento criado foi
habilitada?
Fonte: próprio autor, 2018

Ao utilizar a configuração mais rápida (uso do cálculo em paralelo sem atualizar


a tela do Femap a cada Load Set inserido) foi observado uma redução de 98% do
tempo gasto total. Posteriormente o teste foi refeito considerando os 248 Outputs Set
para comparar o MapLoads.vb com a solução atual. A tabela mostra o desempenho
considerando tal condição e relembrando o desempenho da solução atual.

Tabela 8 - Comparação entre solução atual e o MapLoads.vb modificado


Fonte: próprio autor, 2018
Solução Desempenho
Código atual 440s (7min 20s)
MapLoads.vb 20s

Como a opção do paralelo usa todos os núcleos do processador, não é


recomendável que a mesma seja utilizada caso a máquina esteja executando algum
outro programa de peso. Logo, o uso do paralelo foi inserido como opção a ser
decidido pelo usuário, decisão essa comunicada através da CheckBox da interface
gráfica do MapLoads.vb (Figura 13). Ao ativar a opção de uso do paralelo, um aviso é
mostrado ao usuário indicando que não é recomendado utilizá-lo junto com outros
43

programas. No entanto, foi analisado a atividade dos núcleos do processador


enquanto o MapLoads.vb é executado com uso do paralelo. A análise não mostrou
sobrecarga da CPU sendo o uso máximo indicado de 32% de sua capacidade total
(gráfico à esquerda na Figura 26). O intervalo de tempo em que o programa foi
executado é evidenciado pelos picos de atividade dos núcleos do processador.

Figura 26 - Atividade dos quatros núcleos do processador durante a execução com cálculo em paralelo
Fonte: próprio autor, 2018

Também foi analisado a influência no desempenho de outros programas


comuns com o MapLoads.vb sendo executado (Word, Excel, PowerPoint), nenhuma
interferência no desempenho dos outros programas nem no resultado final do
MapLoads.vb foi identificado. Porém, por não ter um valor exato de quantos e quais
programas podem ser executados junto com o MapLoads.vb além de não saber quais
as especificações de máquina que garanta que não exista problema de execução
simultanea, é inserido na interface do MapLoads.vb um aviso para que não seja
executado nenhum outro programa durante sua execução com cálculo em paralelo.

3.4.6 Código final

Chega-se então na solução ao problema de mapeamento de carregamento a


partir de resultados de análise. A interface final é mostrada na Figura 13.
A interface gráfica contém algumas funcionalidades úteis, como:

1. Ao selecionar uma das caixas T1 a T6, o respectivo DOF1 ao DOF6 será


selecionado automaticamente. O motivo para esta funcionalidade é o fato que
SPCD aplicado à um nó deve sempre ser acompanhado de uma restrição ao
44

nó do respectivo DOF. Caso contrário, a carga será desconsiderada pelo


solver. É permitido ao usuário retirar a seleção de DOF caso, por algum motivo,
seja de seu interesse (por exemplo, caso já existam as restrições necessárias).
2. Ao selecionar a opção de não criar SPC, as caixas de opção DOF1 ao DOF6
tornam-se não selecionáveis com coloração cinza (Figura 27 (a)).
3. Ao selecionar a opção “Use Parallel Calculation” é mostrado uma mensagem
de alerta (Figura 27 (b)).

(a) (b)

Figura 27 - Funcionalidades da interface gráfica do MapLoads.vb


(a) Caixas de seleção de DOF tornam-se cinzas caso selecionado para não criar restrições (SPCs)
(b) Mensagem de alerta quando cálculo em paralelo for selecionado
Fonte: próprio autor, 2018
45

3.5 Estudo de Caso: Reproduzir uma análise de flambagem com uso do


MapLoads.vb

Figura 28 - Modelo Semi asa


Fonte: próprio autor, 2018

É realizado um estudo de flambagem no Femap de uma nervura contida em


um MEF de uma semi asa (Figura 28) afim de validar o uso do MapLoads.vb. O modelo
utilizado da semi asa pode ser encontrado na pasta Exemples no diretório do Femap.
Os nós de contorno da raiz da semi asa são restringidos nos 6 DOF e o carregamento
é aplicado aos nós da ponta da semi asa. Foram criados 250 casos de carga com
forças nodais cujos componentes foram gerados aleatóriamente.

3.5.1 Análise estática do modelo global

Após gerado os 250 casos de carga, a análise estática do modelo global é


executada. O contorno de cores para o vetor de deslocamento total é mostrado na
Figura 29. A Figura 30 destaca em amarelo a nervura a ser estudada.
46

Figura 29 - Contorno do resultado de deslocamento total em análise estática


Fonte: próprio autor, 2018

Figura 30 - Nervura do modelo global para análise em modelo local destacada em amarelo
Fonte: próprio autor, 2018

Uma vez calculado o modelo global, a nervura deve ser isolada do restante da
semi asa em um modelo separado (Figura 31). Os resultados da análise do modelo
global são então importados ao modelo local da nervura.
47

Figura 31 - Modelo local da nervura


Fonte: próprio autor, 2018

3.5.2 Condição de contorno do modelo local para análise de flambagem

A condição de contorno aplicado aos nós para estudo de flambagem deve ser
tal que permita rotação porém não a translação dos nós da borda da nervura. Para tal
deve-se restringir apenas os DOF 1, 2 e 3 (translações). Uma sugestão intuitiva seria
aplicar o carregamento apenas como forças e momentos aos nós de interface, porém
como deve ser criado restrições de translação afim de reproduzir a condição de apoio
simples, quaisquer forças aplicadas em tais DOF não serão transmitidas aos
elementos, sendo resistida apenas pelos SPC. Tal fato justifica o uso dos
deslocamentos forçados nos DOF de translações ao invés de forças nodais. Desta
forma, o nó será deslocado de acordo com o valor do SPCD e posteriormente
restringido nos DOF 1, 2 e 3, não sofrendo nenhum deslocamento posterior devido às
cargas internas. Logo, a condição de contorno a ser reproduzida deve ser: Restrições
nos DOF 1, 2 e 3. SPCD nos DOF 1, 2 e 3. Momentos aplicados nos DOF 4,5 e 6.
A Figura 32 ilustra o procedimento a ser seguido para reproduzir a condição de
contorno necessária utilizando o MapLoads.vb.

Maploads.vb
MapLoads.vb
Mapear SPCD nos MapLoads.vb
Lançar cálculo do Mapear
nós de contorno
modelo local com momentos Mapear SPCD nos
com SPC em
SPCD mapeados aplicados a partir nós de contorno
todos DOF a
e nós de de momentos para T1, T2 e T3
partir dos vetores
contorno fixados resistidos pelos aplicando SPC em
de deslocamento
SPC do cálculo DOF 1, 2 e 3
total do modelo
anterior
global

Figura 32 - Procedimento para obter condição de contorno de flambagem com uso do MapLoads.vb
Fonte: próprio autor, 2018
48

3.5.3 Mapeamento dos SPCD a partir dos vetores de deslocamento

Com o modelo local da nervura e com os resultados da análise do modelo


global, executa-se o MapLoads.vb afim de mapear os deslocamentos forçados
(SPCD) aplicados aos nós de interface. Todos os DOF são selecionados na interface
do MapLoads.vb, tanto para no Load Settings quanto no Constraint Settings, como
mostrado na Figura 33.

Figura 33 - Mapeamento de deslocamentos (T1,T2 e T3) e rotações (R1,R2 e R3)


Fonte: próprio autor, 2018

Após o término da execução do MapLoads.vb, o modelo local já contém as


condições de contorno apresentados na Figura 34 (SPCD e SPC em todos DOF) e é
submetido à análise estática.
49

Figura 34 - Condição de contorno com SPCD e SPC nos 6 DOF


Fonte: próprio autor, 2018

Deve ser solicitado ao solver o resultado de Constraint Force. O objetivo desta


análise é obter os valores de momento nos DOF 4, 5 e 6 sentido pelos SPC nos nós
de interface, que serão utilizados na análise de flambagem. Deve ser acrescentado
ao cartão do modelo o pedido de calculo de força de restrição no formato:
SPCFORCE(PLOT) = ALL.

3.5.4 Mapeamento dos SPCD e momentos de restrição para análise de


flambagem.

Com o resultado da análise estática contendo vetores de momento de restrição


e deslocamento dos nós de interface, mapeia-se os SPCD somente de translação (T1,
T2 e T3) acompanhado com as respectivas restrições. Os parâmetros de entrada do
MapLoads.vb são mostrados na Figura 35. A visualização do MEF no Femap após o
mapeamento é mostrado na Figura 36.
50

Figura 35 - Mapeamento de deslocamentos (T1, T2 e T3) com restrições


Fonte: próprio autor, 2018

Figura 36 - Condição de contorno após mapeamento de SPCD(1,2 e 3) e SPC(1,2 e3)


Fonte: próprio autor, 2018

Uma vez os SPCD de translação aplicados, utiliza-se o MapLoads.vb


novamente para mapear os momentos de restrições (R1, R2 e R3) sem a criação de
restrições. É necessário que o valor do campo First Load Case seja igual ao
mapeamento anterior afim de adicionar os momentos nodais aos SPCD de translação
já criados (Figura 36). Os parâmetros de entrada do MapLoads.vb são mostrados na
Figura 37. A visualização do MEF no Femap após o mapeamento é mostrado na
Figura 38.
51

Figura 37 - Mapeamento de momentos aplicados (R1, R2 e R3)


Fonte: próprio autor, 2018

Figura 38 - Condição de contorno após mapeamento de momento aplicado (4, 5 e 6)


Fonte: próprio autor, 2018

Após o mapeamento dos momentos, juntamente com os SPCD criados


anteriormente, o modelo contém as condições de contorno correta para a análise de
flambagem (Figura 39).

Figura 39 - Condição de contorno para análise de flambagem aplicado aos nós de interface
Fonte: próprio autor, 2018
52

O modelo é então enviado para o solver. É requisitado apenas o cálculo do


primeiro autovalor da análise de cada caso de carregamento.
A figura mostra o resultado de deslocamento total da análise de flambagem do
caso de carga que apresentou o menor autovalor, evidenciando a flambagem no
centro da nervura.

Figura 40 - Contorno de deslocamento total da análise de flambagem. Casos de carga que apresentou o menor
autovalor (10.66)
Fonte: próprio autor, 2018

Foi registrado o tempo gasto para desenvolver a análise de flambagem da


nervura e estimado o tempo que seria gasto pela solução atual baseada nas
proporções de tempo apresentadas na Tabela 8.

Tabela 9 - Comparação entre uso do MapLoads e solução atual no estudo de caso de flambagem
Fonte: próprio autor, 2018

Tempo gasto em execução MapLoads.vb 17 s

Tempo que estimado Solução atual 6 min 13 s

Tempo gasto com manipulação do modelo 6 min 33 s

Tempo total de cada solução

Tempo total com MapLoads.vb 6 min 50 s

Tempo total estimadeo com solução atual 12 min 46 s


53

3.5.5 Conclusão do estudo de caso

Foi mostrado neste estudo de caso diferentes utilidades do MapLoads.vb em


uma única análise de flambagem. O estudo explorou todas funcionalidades contidas
na interface do programa. Foi realizado mapeamento de SPCD e Momentos de
restrição em diferentes opções de graus de liberdade. Finalmente o programa
mostrou-se eficiente comparado com a solução atual durante o estudo de caso,
tornando o precesso total de análise de flambagem aproximadamente 2 vezes mais
rápido que o processo atual.
54

4 ENVELOPEGROUPS

4.1 Contexto

Ferramentas de alta precisão e procedimentos bem planejados garantem


atualmente um alto nível de qualidade no processo produtivo de aeronaves. Porém,
ainda não é possível ter um processo isento de falhas sem que haja um investimento
longe do alcance das empresas aeronáuticas. A fabricação de materiais compósitos
e metálicos esta sujeita a erros como:

 Furos com valores de diâmetros diferentes dos valores de projeto


 Inclusão de material estranho entre as fibras de um compósito durante sua cura
 Espessura de uma estrutura metálica diferente da de projeto após erro de
usinagem
 Uso de prendedores (e.g. parafusos, rebites) de material diferente ao de projeto

Tais erros geram não conformidades nas estruturas que se distanciam das
estruturas apresentadas pelo relatório estrutural (RE). Porém, descartar uma estrutura
de alto custo causa grande impacto na competitividade do fabricante no mercado.
Como solução ao problema, cabe a equipe de apoio à produção reanalisar tais
estruturas para validar sua capacidade de suportar os carregamentos de projeto e
evitar o descarte.
A reanálise das não conformidades consiste em reproduzir o RE da estrutura
que foi validado pelo órgão regulamentador.
Ao receber uma nota de não conformidade, a equipe de apoio à produção busca
reproduzir o erro de fabricação no MEF para mensurar seu impacto nas análises dos
critérios de ruptura. O MEF é modificado e o calculo é refeito pelo Solver. Após o
cálculo, é verificado os vetores de saída como: tensão de Von Mises para resistência
de metal, tensão mínima de compressão para análises de estabilidade e de fadiga em
compósitos e Failure Index para resistência do compósito. Essa análise bem como
uma comparação com os resultados da estrutura intacta permite à equipe de apoio a
produção decidir se a estrutura será descartada, retrabalhada ou até mesmo mantida
sem retrabalho.
55

4.2 Solução atual

A modificação do MEF com a não conformidade é feito no software Femap. A


modificação mais comum realizada é alteração na espessura da estrutura, devido a
erros de usinagem ou no lixamento da superfície para retirada de inclusão no
compósito ou remoção de camadas defeituosas após a cura. Outras modificações
como mudança de material e modificação na posição de furos também são
recorrentes. É inviável analisar cada caso de carga separadamente, sendo que a
maioria dos modelos de estruturas aeronáuticas contém centenas de casos de cargas
diferentes. Logo, são criados envelopes dos vetores de saída de interesse.
Na análise de não conformidades, é criado o envelope dos vetores de saída de
interesse para o MEF intacto e não conforme. Posteriormente é feito uma subtração
entre o envelope do MEF não conforme e o envelope intacto que permite avaliar a
variação dos valores máximos do vetor de saída de interesse em cada elemento com
o efeito da não conformidade. Logo, A combinação de envelopes em cada elemento
é feita da seguinte forma:

Valor no elemento i = (Valor do envelope 1 − Valor do envelope 2)no elemento i

O procedimento necessário para criar os envelopes no Femap para aplicação


de análise de não conformidades é descrito a seguir:
1. Acesse a ferramenta Process Output Data
2. Selecione a opção de um ou mais vetores de output
3. Selecione a opção para envelopar valores máximos, mínimos ou máximos
absolutos, dependendo do vetor de saída de interesse
4. Selecione a opção envelopar todos os vetores selecionados
5. Selecione os casos de cargas do modelo intacto a serem envelopados
6. Selecione os vetores de saída a serem envelopados
7. Repita o processo de 1 a 6 para os demais Load Set do MEF não conforme
8. Renomeie os envelopes para facilitar a identificação (qual envelope é antes ou
depois da modificação do modelo)
9. Acesse a ferramenta Process Output Data -> Linear Combination
10. Execute uma combinação de subtração entre os envelopes
56

11. Renomeie o vetor resultante da subtração para facilitar a identificação


12. Repita o processo 1 a 11 para análise de outros vetores de saída (Deformação,
translação, Índice de falha, etc.)

A solução atual necessita de um número considerável de etapas a serem


seguidas e são fontes de consumo de tempo de trabalho e de erros do usuário.

4.3 Proposta de melhoria

Afim de eliminar a quantidade de etapas na análise de não conformidades e


consequentemente reduzir o tempo e erros do usuário no processo, propõe-se a
automação com uso de API. O API será capaz de:
i. Criar envelopes de dois casos de carga diferentes e sua combinação em uma
única etapa, solicitando apenas uma vez quais casos de carga deseja-se
envelopar
ii. Criar envelopes de vários vetores de saída em apenas uma operação
iii. Organizar e renomear os envelopes automaticamente afim de facilitar sua
identificação
57

4.4 O algoritmo EnvelopeGroups.vb

4.4.1 A interface

Figura 41 - Interface gráfica do EnvelopeGroups.vb


Fonte: próprio autor, 2018

A Figura 41 mostra a interface gráfica do programa EnvelopeGroups.vb. A


interface conta com 3 caixas de input:

1. Compare Envelopes
2. Envelope Vectors
3. Seleção das opções dos vetores: Failure Index, Von Mises, Strain Level ou
Other Vectors IDs.
58

Cada caixa de input será detalhada a seguir.

1. Compare Envelopes

Figura 42 - Caixa de inputs: Compare Envelopes


Fonte: próprio autor, 2018

Nesta caixa, são definidos os nomes que serão atribuídos aos envelopes de
cada grupo de Output Set (Output set do modelo original e Output sets do modelo não
conforme). Por padrão, os nomes do grupo 1 e 2 são “Original” e “Modified”
respectivamente, fazendo alusão ao fato do primeiro modelo ser, normalmente, o
modelo original validado da estrutura e o segundo modelo ser o modelo alterado após
a não conformidade. Nesta caixa de input também é informado que a combinação feita
automaticamente pelo programa será:

𝐸𝑛𝑣𝑒𝑙𝑜𝑝𝑒 = 𝐺𝑟𝑜𝑢𝑝 2 (𝑉𝑒𝑐𝑡𝑜𝑟𝑠) − 𝐺𝑟𝑜𝑢𝑝 1 (𝑉𝑒𝑐𝑡𝑜𝑟𝑠)

O usuário poderá inverter a ordem da subtração caso a opção de envelopar


valores mínimos for escolhida selecionado a CheckBox: “Invert combination if Min
Option for enveloping is set”. Por exemplo, se a não conformidade estiver em uma
região onde a flambagem é o critério limitante, é indispensável verificar o aumento (do
valor absoluto) da mínima tensão principal. Como os valores de mínima tensão
principal são frequentemente negativos, pode ser interessante inverter a ordem de
Group 1 e Group 2 na operação de subtração afim de obter resultados positivos. Os
valores da comparação sendo positivos eliminam o trabalho do operador de inverter a
legenda de palheta de cores do contorno entre a análise dos envelopes do grupo 1 e
do grupo 2 separadamente e a análise da combinação entre os dois envelopes (a cor
para valores críticos continuará sendo a mesma na análise de todos envelopes).
59

2. Envelope Vectors

Figura 43 - Caixa de inputs para seleção dos Output Vectors


Fonte: próprio autor, 2018

Neste grupo são selecionados os vetores de saída de interesse a serem


envelopados. Esta opção elimina o tempo de seleção dos vetores na criação dos
envelopes uma vez que alguns são frequentemente utilizados como:

 Failure Index: Indica a margem de segurança em cada elemento de uma


estrutura compósito, de acordo com o critério selecionado na análise
 Strain Level: Indica o valor de deformação em cada elemento. Seu valor mínimo
é utilizado frequentemente em análise de fadiga em material compósito
 Von Mises: Indica a tensão crítica de Von Mises utilizada em análise de
materiais isotrópicos

Caso seja de interesse analisar outro vetor, a ChekBox “Other” deve ser
selecionada.
60

3. Caixa de Input das opções dos vetores de saida: Failure Index, Von Mises,
Strain Level ou Other Vectors IDs.

Figura 44 - Caixa de inputs para seleção das opções de envelope


Fonte: próprio autor, 2018

Figura 45 - Funcionalidade da interface para seleção dos vetores e opções de envelope


Fonte: próprio autor, 2018
61

Ao selecionar a caixa de verificação na caixa de input Envelope Vectors, a caixa


de input de opção do respectivo vetor é habilitado, como ilustrado na figura Figura 45.
Em cada caixa está indicado o ID do vetor que será envelopado (e.g. 7171 Plate
Mid MinorPrn Strain). O usuário tem a opção de criar envelopes com os valores
máximos, mínimos ou máximos absolutos. O título escolhido para o envelope,
juntamente com os títulos do grupo 1 e grupo 2 definidos na caixa Compare
Envelopes, irão nomear os envelopes criados. Na Tabela 10 a Tabela 12 são
resumidos os inputs necessários para executar o programa EnvelopeGroups.

Tabela 10 - Inputs na caixa Compare envelopes


Fonte: próprio autor, 2018
NOME Opções DESCRIÇÃO
Group 1 Name Texto Define o nome do grupo 1 de output

Group 2 Name Texto Define o nome do grupo 2 de output


Inverte a ordem da combinação entre o
CheckBox
Check/Uncheck envelope do grupo 1 e o envelope do
Invert Combination
grupo 2

Tabela 11 - Inputs na caixa Envelope Vectors


Fonte: próprio autor, 2018
NOME Opções DESCRIÇÃO
Check/Uncheck:
CheckBox Define quais vetores de saída serão
Tensão de Von Mises,
Vetores de saída envelopados
Strain, Failure Index, Outro.

Tabela 12 - Inputs nas opções dos vetores


Fonte: próprio autor, 2018
NOME Opções DESCRIÇÃO
Envelope Title Text Título do envelope a ser criado

CheckBox Define se será envelopado os valores


Max, Min e Check/Uncheck mínimos, máximos ou máximos absolutos

max abs do(s) vetor(es) selecionado(s)


62

4.4.2 O código

Inicialmente o código faz leitura das caixa Envelope Vectors para identificar os
vetores de saída que foram escolhidas pelo usuário. Essa leitura é feita através da
estrutura if que verifica se as caixas CheckBox de cada vetor foi selecionada, lançando
o código principal CompareEnvelope caso seja verdadeiro. Caso nenhum vetor for
selecionado, a função CompareEnvelope retornará valor de err3 = 1 causando
reinicialização do código e emissão de mensagem de aviso.

Figura 46 - Script responsável em verificar quais vetores foram selecionados e lançar o script:
CompareEnvelope
Fonte: próprio autor, 2018

A função CompareEnvelope, chamada pela estrutura If contido no script


mostrado na Figura 46, requer os inputs contidos na Sub da Figura 47:

Figura 47 - Função CompareEnvelope responsável por criar os envelopes no Femap


Fonte: próprio autor, 2018

Sendo:
1. EnvelopeTitle: Texto que foi inserido nas caixas de opção dos vetores de saida
(Tabela 12)
2. MaxOrMin: Vetor contendo as opções de envelopar valores máximos, mínimos
ou máximos absolutos escolhidos pelo usuário.
3. VectorType: Valor inteiro de 1 a 4 utilizado para identificar qual vetor foi
selecionado.
63

Figura 48 - Script responsável por inserir os IDs de acordo com o Femap dos vetores selecionados ao objeto
Vectors
Fonte: próprio autor, 2018

O código gera o objeto de vetor no Femap e insere os ID correspondentes


utilizado a variável VectorType. Dependendo do valor do VectorType o código entrará
no if correspondente ao vetor desejado afim de inserir o ID deste vetor utilizado pelo
Nastran, como:

 6060: Failure Index


 7033: Plate Top VonMises Stress
 7433: Plate Bot VonMises Stress
 7272: Plate Mid MinorPrn Strain

Caso a opção Other na caixa Envelope Vectors for selecionada, o código


acionará o Femap para que o usuário selecione o vetor de saída desejado. É mostrado
na Figura 49 o script responsável de abrir a seleção dentro do Femap para o usuário
para a seleção de outro vetor de saída além dos vetores com acesso rápido pela
interface.
64

Figura 49 - Script responsável por abrir caixas de seleção do Femap e receber os valores selecionados para a
opção Other Vectors. Fonte: próprio autor, 2018

O EnvelopeGroups.vb utiliza o fluxograma apresentado na Figura 50 para gerar


e organizar os envelopes.

Gerar envelope
utilizando os
Identificar Renomear
inputs
próximo ID Criar um Envelope
anteriormente
disponível de OutputSet utilizando as
definidos no
OutputSet no vazio no Femap opções do
Output Vazio
Femap usuário
criado
anteriormente

Figura 50 - Fluxograma utilizado pelo EnvelopeGroups.vb para gerar os envelopes


Fonte: próprio autor, 2018

Esse procedimento é seguido pelo script mostrado na Figura 51, onde os


envelopes do grupo 1 e do grupo 2 são gerados no Femap.
65

Figura 51 - Script responsável por criar os envelopes no Femap como novos OutputSets
Fonte: próprio autor, 2018

Da mesma forma, a combinação dos envelopes é gerada afim de comparação


utilizando o procedimento seguido pelo script apresentado pela Figura 52.

Figura 52 - Script responsável por criar a comparação entre envelopes dentro do Femap como novo OutputSet
Fonte: próprio autor, 2018

4.4.3 Mensagens de erros

O programa EnvelopGroups.vb possui duas mensagens de erro do tipo Fatal


Error, contidos na Tabela 13. A interface do programa permanece aberta após o erro
para que seja feita a correção.
66

Tabela 13 - Mensagens de erros do programa EnvelopeGroups.vb


Fonte: próprio autor, 2018
ID Motivo Mensagem

Erro 01 Nenhum vetor de Output foi selecionado

Algum erro fatal diferente do Erro01


ocorreu. Provavelmente o programa foi
Erro 02
executado sem que o Femap esteja
funcionando

4.5 Estudo de Caso: Comparar envelopes de Tensão de Von Mises de uma pá de


hélice após remoção de material

4.5.1 Introdução do estudo de caso

Figura 53 - Modelo de pá de hélice


Fonte: próprio autor, 2018
67

Nesta seção é estudada uma aplicação do programa EnvelopeGroups.vb em


uma análise de perda de material de uma pá de hélice.
O modelo de pá conta com elementos sólidos de tipo tetragonal. O
carregamento de pressão é aplicado na superfície do extradorso e intradorso da pá
enquanto os nós em volta do eixo são restringidos nos seis DOF. Três casos de carga
estão presentes no modelo, diferenciando-se em sentido e magnitude das
componentes da pressão aplicada. Afim de reproduzir um exemplo de não
conformidade, é retirado elementos tetragonais localizados na raiz da pá e isentos de
pressão aplicada. Tal análise pode ser entendida também como uma perda de
material por impacto, corrosão ou trinca do material. É mostrado na Figura 54 o
modelo intacto e o modelo modificado da pá.

Figura 54 - Modelo pá de hélice original e modificado


Fonte: próprio autor, 2018

Após a análise dos dois MEF (intacto e modificado), 6 Output Set são gerados:
três para os três Load Set do modelo intacto e outras três para o modelo modificado.
Uma análise separada de cada um dos seis Output Set é uma solução
ineficiente devido à quantidade de informações em diferentes Outputs. Logo, o
programa EnvelopeGroups.vb é utilizado para gerar os envelopes dos vetors de saída
de interesse do modelo original, do modelo modificado e uma comparação entre os
dois envelopes.
68

4.5.2 Definindo entradas do EnvelopeGroups.vb

Ao abrir o arquivo EnvelopeGroups.exe, a interface (Figura 55) aparece para o


usuário. Como deseja-se analisar elementos sólidos, a opção Tensão de VonMises
(ID 6060) de acesso rápido do programa não pode ser utilizada, uma vez que é
atribuída apenas para elementos de placa. É selecionado então a opção Others para
que o vetor de saída seja posteriormente selecionado pelo usuário na interface do
Femap. Os inputs do programa são mostrados na Figura 55.

Figura 55 - Inserir inputs na caixa Compare Envelopes


Fonte: próprio autor, 2018

Ao lançar o programa, clicando no botão “Compare”, o status da execução,


mostrado na parte inferior da interface, é atualizado para: “Status: Waiting for selection
in Femap...” e uma caixa de seleção é aberto no Femap, contida na Figura 56.
A caixa de seleção possui como título: “Select the Output Set and vectors for: ”
seguido do nome do grupo que deve ser selecionado definido em “Group 1 Name” e
“Group 2 Name” na caixa Compare Envelopes da interface. À esquerda, encontra-se
os Output Sets disponíveis enquanto à direita encontra-se os Output Vectors
69

disponíveis. São selecionados então os Output Sets da análise do modelo original


(sem a remoção de material) e o Output Vector “60031.. Solid Von Mises Stress”.

Figura 56 - Selecionar Ouput Sets para o grupo 1 e Output Vectors para envelope
Fonte: próprio autor, 2018

Ao confirmar a seleção, o programa EnvelopeGroups.vb abrirá uma segunda


caixa de seleção, dessa vez para que o grupo 2 de Output Set seja selecionado. São
selecionados então os Outputs Sets da análise do modelo modificado, como mostrado
na Figura 57.

Figura 57 - Selecionar Output Sets para grupo 2


Fonte: próprio autor, 2018
70

4.5.3 Saídas do EnvelopeGroups.vb

Ao confirmar a seleção da Figura 57, o programa EnvelopeGroups.vb finaliza o


processo criando os envelopes de cada grupo de Output Set assim como a
comparação entre o envelope do grupo 2 e o envelope do grupo 1. Os resultados
criados no Femap são organizados pelo EnvelopeGroups.vb como estudo de caso.
Os resultados do EnvelopeGroups.vb são visíveis no Femap como mostrado na Figura
58.

Figura 58 - Estudo de caso criado com os resultados do programa EnvelopeGroups.vb no Femap


Fonte: próprio autor, 2018

Cada OuputSet criado (Figura 58) pode ser visualizado pelo contorno do vetor
de saída, como mostrado na Figura 59 a Figura 61.

Figura 59 - Contorno de cores do Envelope de Tensão de Von Mises resultante das análises do modelo original
Fonte: próprio autor, 2018
71

Figura 60 - Contorno de cores do Envelope de Tensão de Von Mises resultante das análises do modelo modificado
Fonte: próprio autor, 2018

Figura 61 - Comparação entre o Envelope do modelo modificado e original. Acusa regiões onde houve
acréscimo de tensão (vermelho) alívio de tensão (rosa) e variação desprezível (azul). Fonte: próprio autor, 2018
72

4.5.4 Análise dos resultados

É mostrado na Figura 61 um tipo de leitura de resultado comum na equipe de


apoio à produção para comparação de envelopes. Apenas três cores são utilizadas
para mostrar regiões onde teve aumento, diminuição ou variação desprezível do valor
máximo do vetor de saída. Neste trabalho, observa-se que a região que contém o
bordo de ataque e bordo de fuga da raiz da pá da hélice foi o caminho de carga
alternativo em resposta à remoção de material a 50% da corda da pá. A redução da
carga resistida na região de remoção de material deve-se pela perda de rigidez do
local. Tal aumento e diminuição de carga pode ser observado pelas cores vermelho e
rosa respectivamente na Figura 61. A região em azul representa uma região onde não
houve variação significativa de tensão. Tal análise guia as atenções para as regiões
onde houve o aumento de carga. Com auxílio do relatório estrutural é possível saber
se a região onde houve aumento de tensão é uma região crítica de um ou mais
critérios de falha como ruptura, fadiga e flambagem. Caso a margem de segurança da
região seja alta (acima de 100%), um retrabalho pode ser o suficiente para restauração
da estrutura. Porém, caso a margem de segurança seja de moderada a baixa (abaixo
de 100%), a estrutura deve ser reanalisada para o respectivo critério de falha.

4.5.5 Conclusão do estudo de caso

O programa EnvelopeGroups.vb se mostrou uma ferramenta bastante útil na


análise de não conformidades. Gerar envelopes e comparações entre eles é uma
tarefa que ocorre com frequência (quantas vezes forem necessárias dependendo da
quantidade de vetores de saída a analisar e da quantidade de reanálises devido a
erros do usuário). O auxílio do API tem como maior qualidade a praticidade na criação
e organização de envelopes, qualidade essa que supera sua maior velocidade
comparado com a solução atual.
73

5 CONCLUSÃO GERAL

Dois API foram gerados ao longo do trabalho afim de atingir o objetivo de


reduzir o tempo de trabalho da equipe de apoio a produção da aviação executiva da
Embraer em análises de estruturas não conformes.
O primeiro API apresentado: MapLoads.vb, cumpre seu objetivo de mapear
Load Set a partir de Output Set. O MapLoads.vb teve como principal benefício ser 20
vezes mais rapido do que a solução atual quando a opção de cálculo em paralelo é
selecionada.
O segundo API apresentado: EnvelopeGroups.vb, cumpre com o objetivo de
gerar e comparar envelopes de vetores de saída de forma rápida e prática. O
EnvelopeGroups.vb teve como principal benefício sua praticidade ao diminuir o
número de etapas na criação de envelopes além de evitar seleções excessivas
durante o processo de análise de não conformidade.
Ambos os programas foram validados e implementados no cotidiano da equipe
de apoio à produção.
74

6 TRABALHOS FUTUROS

Ambos API desenvolvidos neste trabalho podem ser aperfeiçoados e


adaptados dependendo de sua aplicação. Algumas funcionalidades extras sugeridas
para cada um dos dois API desenvolvidos são listadas a seguir:

MapLoads.vb:
1. Acrescentar opções de mapeamento como: pressão distribuída e
resultante de esforços
2. Criar relatório ao término da execução contendo informações sobre o
carregamento mapeado
EnvelopeGroups.vb
1. Permitir que o usuário acrescente caixas de acesso rápido para vetores
de saída
2. Permitir a criação de dois ou mais envelopes quando a CheckBox
“Outros” for selecionada
3. Emitir um relatório padrão sobre a análise de não conformidade
MapLoads.vb e EnvelopeGoups.vb
1. Criar guia para o usuário
2. Inserir API na interface do Femap
75

7 REFERÊNCIAS BIBLIOGRÁFICAS

FEMAP API REFERENCE, SIEMENS, 2014

Microsoft, GUIA DO VB.NET. Disponível em: https://docs.microsoft.com/pt-


br/dotnet/standard/#api-reference Acesso em 07 Ago. 2018.

Microsoft, GUIA DO VISUAL BASIC. Disponível em: <https://docs.microsoft.com/pt-


br/dotnet/visual-basic/index> Acesso em 07 Ago. 2018.

SIEMENS, NX NASTRAN USER’S GUIDES, 2014.

Troy, PRATICAL ASPECTS OF FINITE ELEMENT SIMULATION, Altair Engineering,


2015.