Utilizando o gmsh para gerar malhas a partir do GNUOctave - Unesp

Utilizando o gmsh para gerar malhas a partir 

do GNUOctave 

Prof. Vicente Luiz Scalon 

Disciplina: Elem. Finitos Aplicados a Fluido-Térmica 

Curso: Engenharia Mecânica 

Faculdade de Engenharia/UNESP – Campus de Bauru 

Conteúdo 

Desenhando a geometria.......................................................................................................................3 

Utilizando o gmsh a partir do Gnu-Octave...........................................................................................4 

APÊNDICE – Código do Octave.........................................................................................................6 

Programa Principal...............................................................................................................................6 

Funções utilizadas no código principal................................................................................................9 

Arquivo de geometria para o gmsh (exemplo.geo)............................................................................11 

Bauru/2012

Utilizando o gmsh no GNU-Octave pg. 2 

Desenhando a geometria 

A geometria pode ser desenhada diretamente no gmsh ou montada através de um arquivo 

texto. Serão apresentados nesta referência apenas os comandos básicos. Outros comandos existem 

e, caso seja necessário, podem ser consultados em bibliografia complementar. Lembre-se que a 

geometria deve ser montada na seguinte ordem: 

• pontos: 

• linhas: 

• usando comando: 

Point (num_ponto) = {coordenada_x, coordenada_y, coordenada_z, 0.1}; 

• usando o comando para criar linhas entre dois pontos: 

Line(num_linha) = {ponto_1, ponto_2}; 

• usando o comando para criar spline em multipos pontos: 

Catmullrom(num_linha) = {ponto_1, ponto_2,...,ponto_n}; 

• criar um arco de círculo com centro definido no ponto 2 e final alinhado ao ponto 3: 

Circle(num_linha) = {ponto_1, ponto_2, ponto_3}; 

• superfícies (se geometria 2D/3D) 

• a partir dos pontos, linhas e arcos definidos anteriormente é possível determinar as 

superfícies que formaram os volumes ou que serão simuladas. Para isto pode se 

utilizar o comando: 

Plane Surface(num_sup) = {linha_1, linha_2, …., linha_n} 

• o agrupamento de linhas também podem ser feitos anteriormente. Passando à 

superfície já a sequência de linhas: 

Line Loop(num_ll) = {linha_1, linha_2, …., linha_n} 

e depois: 

Plane Surface(num_sup) = {num_ll} 

• em ambos os casos, o valor negativo, indica que na composição da superfície a linha 

deve ser considerada no sentido inverso ao definido na linha; 

• volumes (se geometria3D) 

• o comando permite a criação de de um volume diretamente de superfície ou a partir 

de um Surface Loop(utilizado de forma análoga ao Line Loop) ou diretamente pela 

sequencia de superfície 

Volume(num_vol) = {sup_1, sup_2, …., sup_n} ou {sup_ll} 

• o volume também pode ser obtido através da extrusão de uma determinada superfície 

na direção de um vetor vx, vy e vz através do comando: 

Extrude(num_vol) = {vx, vy, vz} {sup_ll} 

Além disto, as condições de contorno podem ser comuns a um determinado número de 

linhas e superfícies. Este conjunto pode ser agrupado pelos comandos Physical e denominados por 

um novo número o um nome. A utilização do nome permite, até mesmo, a exportação dos dados 

para outros programas típicos de solução como Open Foam, Calculix, etc. Dependendo do 

agrupamento a ser feito o comando utilizado é diferente: 

• Physical Line (num_linha_física ou “nome”)={linha_1, linha_2, …., linha_n} 

• Physical Surface (num_sup_física ou “nome”)={sup_1, sup_2, …., sup_n}


Com esta sequência de comandos é possível implementar uma grande quantidade de 

geometrias. Desenhada a geometria, a construção de malhas, ajustes devidos e a integração entre 

diferentes malhas podem ser realizadas e exportadas pela interface gráfica. Para maiores detalhes, a 

página de desenvolvimento do software http://geuz.org/gmsh/ deve ser consultada. 

Utilizando o gmsh a partir do Gnu-Octave 

Existem pacotes que realizam a integração da geometria, gmsh e importam automaticamente 

para o GNU-Octave a malha gerada. Normalmente, eles executam o gmsh e automaticamente e 

importam o arquivo resultante com os pontos nodais, conectividade entre os elementos e 

composição das superfícies para imposição das condições de contorno. 

O pacote é capaz de importar apenas as malhas não estruturadas geradas pelo gmsh. O 

próprio pacote tem um gerados de malhas estruturadas de elementos triangulares. Será apresentado 

a seguir uma breve descrição dos principais comando do pacote msh. 

O comando utilizado para executar o gmesh com um determinado arquivo.geo , já definindo 

a escala de importação(scale) e o tamanho dos elementos(clscale) é dado por e armazenar os 

resultados numa variável estruturada imesh : 

[imesh] = msh2m_gmsh ("arquivo","scale",1,"clscale",0.25); 

A variável estruturada imesh possui três componentes: 

• .p => pontos nodais com as coordenadas x na 1ª linha e y na 2ª linha; 

• .t => tabela de conectividade em linha com o número dos três nós que compõem o elemento 

nas três primeiras linhas e com o número da superfície associada a esta malha na 4ª; 

• .e => representa as superfícies dos contornos estabelecidos e representado por um vetor de 7 

linhas. As 2 primeiras representam nó inicial e nó final, a 5ª linha representa o número da 

linha na qual os pontos estão posicionados e a 6ª linha representa o tipo de elemento no qual 

o contorno está estabelecido. 

Desta maneira a variável estabelecida possui todas as informações necessárias para a 

solução do problema em elementos finitos. Existe um outro pacote que permite a visualização da 

malha gerada, mas o pacote fpl, permite a visualização da malha com o comando pdemesh. Para 

usar o comando com a malha gerada anteriormente pelo gmsh, pode-se utilizar o seguinte comando: 

pdemesh(imesh.p, imesh.e, imesh.t) 

A malha é apresentada numa figura. Ela é apresentada na forma tridimensional. Caso desejese 

uma vista de topo, pode-se utilizar o comando: view(2). A malha resultante seria mostrada na 

forma apresentada na figura 1. 

A partir da malha foram inseridas as condições de contorno nas superfícies. Para isto, foram 

extraídas da variável .e, os pontos, o número da superfície e o tipo de elemento. Com estes dados e 

sabendo que as superfícies 1, 2, 3 e 4 são as representadas no gmesh, foram incluídas as condições 

generalizadas da superfície. Para tanto foi utilizada a condição generalizada que pressupõe: 

∂T 

∂⃗n =α c⋅T +β c


Figura 1: Malha gerada e transferida ao GNU-Octave. 

Lembrando que as condições de contorno do problema são: 

• Face esquerda e superior (1 e 2) – Condição de temperatura de superfície: 

usa-se o esquema de convecção reduzindo ao máximo a resistência térmica: 

α c =−10 6 β c =10 6 ×T ∞ =500×10 6 

• Face direita (3) – Condição de simetria (condição natural) 

É a condição natural, automaticamente implementada. 

α c 

=0 β c 

=0 

• Face inferior (4) - Condição de convecção 

α t =− h k =−100 

β t= h⋅T ∞ 

=100×300 

k 

Com os valores dos parâmetros nas fronteiras conhecidas, os mesmos são são 

implementados e montadas as matrizes de condição e de carga. Posteriormente, associadas à matriz 

global elementar utilizada para cálculo das temperaturas 

Aplicadas as condições de contorno são calculadas as matrizes elementar e global e matriz 

de condições de contorno relacionadas aos dados da malha. A partir delas, obtém-se a solução do 

sistema de equações e o mesmo e o perfil de temperaturasé armazenado em um vetor Temp. O 

resultado do perfil de temperaturas plotado pelo comando: 

hh=pdesurf(mesh.p, mesh.t, Temp); 

e o gráfico resultante está mostrado na figura 2.


Figura 2: Distribuição de temperaturas no problema considerado 

APÊNDICE – Código do Octave 

Programa Principal 

% Exemplo resolvido utilizando geração de malha via gmsh 

% Met. Elem. Finitos Aplicados a FluidoTérmica 

% Atualizado em 07/11/2012 

pkg load fpl msh % pkg load all > carrega todos os pacotes disponiveis 

% importanto a malha gerada pelo gmsh do arquivo problema.geo 

[mesh] = msh2m_gmsh ("problema","scale",1,"clscale",0.25); 

% Mostrando a malha 

pdemesh (mesh.p, mesh.e, mesh.t); 

view (2); 

% Estraindo os valores do structure para matriz 

% apenas por comodidade 

% Valores nodais 

nodal = mesh.p([1 2],:).'; 

%Conectividade 

conec = mesh.t'; 

% Determinando superficies 

lsuper=unique(mesh.e(5,:)); % lista de supefícies presentes


ns=length(lsuper); %numero de superficies 

% cc > n_superf cord_i coord_f 

cc=zeros(length(mesh.e(5,:)),5); 

cc(:,1:4) = mesh.e([5 1 2 6],:)'; 

for i=1:length(cc) 

cc(i,5)=distpoint(nodal(cc(i,2:3),:)); 

end 

% Montagem da matriz elementar 

MM = matglobal(nodal, conec); 

% Condições de contorno 

ncon=length(lsuper); 

alfac=zeros(1,lsuper); 

betac=alfac; 

% Condição de contorno de temperatura definda 

% Superfícies 1 e 2 

alfac(lsuper(1:2))=1e6; 

betac(lsuper(1:2))=500e6; 

% Superficie 3 

% Condição natural 

% Não precisa implementar nada 

% Superficie 4 

alfac(lsuper(4))=100;cc 

betac(lsuper(4))=100*300; 

% Matriz de condições de contorno 

[MC Bt] = matcond(cc, alfac, betac, nodal); 

% Calculo das temperaturas no nos 

Temp=(MMMC) \ Bt; 

% Calculo dos fluxos de calor nos pontos de superfície 

qs=MC*Temp+Bt;


% Caracterizando a superficie e separando os nós que a compoe 

for i=1:ns 

% Determinando posições no CC associadas a superf. i 

noscc_i=find(cc(:,1)==lsuper(i)); 

% capturando o numero dos nós de cada superfície 

surf(i).ps=unique(cc(noscc_i,2:3)); 

qt(i)=sum(qs(surf(i).ps)); 

printf("Fluxo de calor na superfície %i: qt = %5.1f\n",lsuper(i), 

qt(i)); 

surf(i).lo(1,:)=[cc(surf(i).ps(1),2) 0]; 

xp=0; 

for j=1:length(surf(i).ps) 

end 

xp+=cc(surf(i).ps(j),5); 

surf(i).lo(j+1,:)=[cc(surf(i).ps(j),3) xp]; 

end 

% Lista de nos na superfície 

surf(i).nos=unique(cc(surf(i).ps,2:3)); 

% Coordenadas dos nós na ordem anterior 

surf(i).solu=nodal(surf(i).nos,:); 

% Plotando troca de calor pelas superfícies: 

qs1=sort([nodal(surf(1).ps,2), qs(surf(1).ps)]); %variando em y 

qs2=sort([nodal(surf(2).ps,1), qs(surf(2).ps)]) %variando em x 

qs4=sort([nodal(surf(4).ps,1), qs(surf(4).ps)]); %variando em x 

plot(qs1(:,1), qs1(:,2), qs2(:,1), qs2(:,2), qs4(:,1), qs4(:,2)); 

legend("Face esquerda", "Face superior", "Face inferior"); 

xlabel("Coordenada") 

ylabel("Energia Transferida[W]") 

%Plotando temperaturas na superfície 

figure(2); 

temps=plot(surf(3).lo(:,2), Temp(surf(3).lo(:,1)), "k", surf(4).lo(:,2), 

Temp(surf(4).lo(:,1)), "r"); 

legend("Superficie Isolada","Superficie com Conveccao"); 

xlabel("Coordenada") 

ylabel("Temperatura[°C]") 

%Superfície representando comportamento das temperaturas 

figure(3)


hh=pdesurf(mesh.p, mesh.t, Temp); 

view (3); 

view(45,30); 

axis([0 0.5 0 1 200 500]); 

% Exportanto resultados no paraview 

% Maiores detalhes sobre uso do paraview consulte 

fpl_vtk_write_field("saida", mesh, {Temp, "temperature"}, {},1) 

Funções utilizadas no código principal 

Montagem da matriz global 




%Funcao para montagem da matriz global de condução 

% de elementos triangulares 

function A=matglobal(nos, elem) 

Bxi=[1 0 1; 0 1 1]; 

nelem=length(elem); 

A=zeros(length(nos)); 

for i=1:nelem 

vetl=elem(i,1:3); % nos que compoe elemento 

Jac=Bxi*nos(vetl,:); % Jacobiano 

Bxy=inv(Jac)*Bxi; % Matriz B 

mel=Bxy'*Bxy*det(Jac)/2; % Matriz elementar integrada (x3/6) 

A(vetl,vetl) += mel; % Posicionando matriz elementar na global 

end 

end 

Implementação das condições de contorno (matcond.m) 




%Funcao para montagem da matriz de condições de contorno 

% sobre as linhas de superfície 

% Parametros de Entrada e saida 

% A : matriz principal (que multiplica Tempsraturas) 

% B : matriz Independente (Termo independente)


% conds: matriz de condição de contorna da forma 

% num_da_superficie no_inicial no_final tipo_elem dist_nos 

% a : vetor dos valores de alfa_c para todas as superficies (por numero) 

% b : vetor dos valores de beta_c para todas as superficies (por numero) 

% nos : coordenadas nodais 

function [A B]=matcond(conds, a, b, nos) 

A=zeros(length(nos)); 

B=zeros(length(nos),1); 

ncc=length(conds); 

for i=1:ncc 

j=conds(i,1); 

vetc=conds(i,2:3); 

%numero dos nos que compoe a linha 

[ma mb]=calcint(nos(vetc,:)); % int num: ma=∫ T dx, mb=∫ dx 

A(vetc,vetc) += ma*a(j); % montagem das matrizes globais de 

B(vetc) += mb*b(j); % contorno: A e B 

end 

end 

Função que resolve a integral sobre uma linha (calcint.m) 




%Funcao integraçao numerica das condições de contorno 

% usando uma aproximação 1D (linha) 

function [ml mb]=calcint(xy); 

% Calculando 3 pontos para a quadratura 

% Considerando a função da linha [xi (1xi)] 

Bxi=[1 1]; 

% Convertendo para linear Calculando reta 

ll=distpoint(xy); 

jac=Bxi*[0 ll]'; 

Bx=inv(jac)*Bxi; 

% Integral da função 

ff=inline("[x (1x)]"); 

% Usando o método de simpson para integração 

ml=1/6*(ff(0)'*ff(0)+4*ff(0.5)'*ff(0.5)+ff(1)'*ff(1))*det(jac); 

mb=1/6*(ff(0)+4*ff(0.5)+ff(1))'*det(jac); 

end


Função que calcula a distância entre dois pontos cartesianos (distpoint.m) 




%Funcao para calculo do comprimento da linha 

% (distancia entre dois pontos cartesianos) 

function dd=distpoint(mt) 

x=1; %posicao da coordenada x no vetor 

y=2; % posicao da coordenada y no vetor 

dd=sqrt((mt(1,x)mt(2,x))^2+(mt(1,y)mt(2,y))^2); 

end 

Arquivo de geometria para o gmsh (exemplo.geo) 

Point (1) = {0, 0, 0, 0.1}; 

Point (2) = {0, 1, 0, 0.1}; 

Point (3) = {0.5, 1, 0, 0.1}; 

Point (4) = {0.5, 0, 0, 0.1}; 

Line (1) = {1, 2}; 

Line (2) = {2, 3}; 

Line (3) = {3,4}; 

Line (4) = {1,4}; 

Line Loop(5) = {1, 2, 3, 4}; 

Plane Surface(1) = {5}; 

Referências 

• Manual do Gmsh 2.6, disponível em http://geuz.org/gmsh/doc/texinfo/gmsh.html, 

consultado em 17/10/2012. 

• Octave-Forge - Extra packages for GNU Octave, principalmente a documentação dos 

pacotes fpl e msh, disponível em http://octave.sourceforge.net/, consultado em 17/10/2012. 

• Scalon, V.L., Apostila de Método dos Elementos Finitos Aplicados à Fluido-Térmica, 

disponível em http://wwwp.feb.unesp.br/scalon/numerica.html, consultado em 01/10/2012.

Utilizando o gmsh para gerar malhas a partir do GNUOctave - Unesp

Create successful ePaper yourself

Delete template?

Save as template?