Geração de malha de cilindros em tandem utilizando o SnappyHexMesh
Geração de malha de cilindros em tandem utilizando o SnappyHexMesh
Observações:
- Este tutorial tem função meramente didática, visando auxiliar usuários iniciantes, e não representa garantias de qualidade de resultados da simulação. A verificação e validação dos resultados, assim como estudos de refino de malha e demais análises, são de responsabilidade do usuário final.
- This offering is not approved or endorsed by OpenCFD Limited, producer and distributor of the OpenFOAM software via www.openfoam.com, and owner of the OPENFOAM® and OpenCFD® trade marks.
- Este tutorial foi criado dentro do contexto de um projeto de extensão da UFSC e não é homologado pelos desenvolvedores do código OpenFOAM®.
- Foi utilizada a versão 1912 do OpenFOAM.
- Este tutorial foi elaborado pelo aluno de graduação Julio Victor Vieira, sob supervisão de Filipe Dutra da Silva.
- Ao utilizar este material, solicita-se que sejam dadas as devidas referências à esta página. Dúvidas e sugestões podem ser enviadas aos endereços de contato da página.
Neste tutorial será apresentado a geração de uma malha de cilindros em tandem utilizando a ferramenta SnappyHexMesh do OpenFOAM, cuja malha resultante é formada por elementos hexaédricos.
Vamos utilizar um caso do OpenFOAM como base. Abra a pasta onde o OpenFOAM foi instalado e vá até o seguinte diretório: tutorials/mesh/snappyHexMesh e copie a pasta “flange” e cole no local onde você deseja salvar o tutorial com o nome “cylinders_snappyHex”.
Dentro dessa pasta, vá até “system” e exclua o arquivo “meshQualityDict”, pois definiremos essas configurações no próprio arquivo do SnappyHexMesh. O arquivo “surfaceFeatureExtractDict” também pode ser excluído.
Agora abra o arquivo blockMeshDict. Aqui vamos definir as dimensões do domínio que será usado como base para criar a geometria. Primeiramente, configuramos os valores dos vértices, conforme mostrado abaixo.
vertices
(
(-0.75 -0.75 0)
( 2 -0.75 0)
( 2 0.75 0)
(-0.75 0.75 0)
(-0.75 -0.75 0.9044)
( 2 -0.75 0.9044)
( 2 0.75 0.9044)
(-0.75 0.75 0.9044)
);
Em seguida, devemos alterar o número de elementos em “blocks”, como mostrado abaixo:
blocks
(
hex (0 1 2 3 4 5 6 7) (80 60 10) simpleGrading (1 1 1)
);
Por fim, configuramos as faces onde serão aplicadas as condições de contorno:
boundary
(
free
{
type patch;
faces
(
(3 7 6 2)
(1 5 4 0)
);
}
inlet
{
type patch;
faces
(
(0 4 7 3)
);
}
outlet
{
type patch;
faces
(
(2 6 5 1)
);
}
frontAndBack
{
type patch;
faces
(
(0 3 2 1)
(4 5 6 7)
);
}
);
Feito isso, salve e feche o arquivo “blockMeshDict”.
Agora abra o arquivo “snappyHexMeshDict”. Aqui vamos definir as configurações para a geração da malha. Primeiramente deixe as funções “castellatedMesh”, “snap” e “addLayer” ativas com a seguinte configuração:
castellatedMesh true;
snap true;
addLayers true;
Em “geometry” definimos cada cilindro por meio de dois pontos (ajustam a posição e a altura) e do raio. Além dos cilindros, vamos criar uma “caixa” que será útil para aplicar um maior refino nas regiões próximas aos cilindros e também à jusante. Essas mudanças são feitas alterando o conteúdo que está em “geometry” para o seguinte:
geometry
{
cyl-1
{
type searchableCylinder;
point1 (0.0 0.0 0.0);
point2 (0.0 0.0 0.9144);
radius 0.028575;
}
cyl-2
{
type searchableCylinder;
point1 (0.211455 0.0 0.0);
point2 (0.211455 0.0 0.9144);
radius 0.028575;
}
refinementBox
{
type searchableBox;
min ( -0.1 -0.1 0);
max ( 0.9 0.1 0.9144);
}
}
“Castellated Mesh Control”
Em “castellatedMeshControl” vamos definir as configurações da divisão dos elementos. Primeiro modifique o valor referente à transição entre os diferentes níveis de refino alterando o valor de “nCellsBetweenLevels” para 6.
Em seguida apague o conteúdo que está em “features”, pois os cilindros foram criados dentro do próprio “SnappyHexMesh.dict” e essa função é usada para geometrias importadas.
O refino na superfície dos cilindros é controlado pela função “refinementSurfaces”. Mude o nome “flange” para “cyl-1” e altere os níveis para “level (4 4)”. O primeiro parâmetro controla o nível de refino na superfície e o segundo controla o nível de refino nas curvaturas da superfície. Adicione, ainda, uma superfície para o segundo cilindro, com o nome “cyl-2” e utilize os mesmos níveis do primeiro.
Outro parâmetro importante para o controle do refino da curvatura é o “resolveFeatureAngle”. Quanto menor o seu valor maior será o refino. Vamos deixá-lo com o valor de 60.
A fim de estabelecer um maior refino nas regiões próximas aos cilindros e também na região da esteira, utilizamos a função “refinementRegions”. Substitua o nome “refineHole” por “refinementBox” e mude os valores de “levels” para ((1e15 2)). O primeiro valor se refere à distância da superfície (usamos um valor alto para cobrir toda a superfície) e o segundo ao nível de refino. Vamos ainda acrescentar um refino maior em volta dos cilindros. Adicione uma região com o nome “cyl-1” e outra com o nome “cyl-2”. Altere em ambos o modo de “inside” para “distance” e defina “levels” como ((0.025 4)).
Ao fim, devemos escolher um ponto dentro do domínio, mas fora da região interna dos cilindros, de modo que essa região seja removida, ficando apenas a base do domínio (gerada no “blockMeshDict”) e as superfícies dos cilindros. Assim, altere o valor de “locationInMesh” para (1 0 0.01).
Em resumo, as configurações de “castellatedMeshControl” devem ser as seguintes:
castellatedMeshControls
{
maxLocalCells 100000;
maxGlobalCells 2000000;
minRefinementCells 0;
nCellsBetweenLevels 6;
features
(
);
refinementSurfaces
{
cyl-1
{
level (4 4);
}
cyl-2
{
level (4 4);
}
}
resolveFeatureAngle 60;
refinementRegions
{
refinementBox
{
mode inside;
levels ((1e15 2));
}
cyl-1
{
mode distance;
levels ((0.025 4));
}
cyl-2
{
mode distance;
levels ((0.025 4));
}
}
locationInMesh (1 0 0.01);
allowFreeStandingZoneFaces true;
}
Em “snapControls” não vamos modificar nada, deixando as configurações padrão.
“Add Layers Controls”
Com o objetivo de discretizar os gradientes da camada limite, criaremos camadas de prismas nessa região com a função “addLayersControls”.
Primeiramente altere “relativeSizes” para false, pois vamos usar valores absolutos para as dimensões das camadas.
Em “layers” altere o nome “flange_.*” para “cyl-1” (sem aspas). Altere, também, o número de camadas em “nSurfaceLayers” para 9. Acrescente a mesma configuração para o segundo cilindro com o nome “cyl-2”.
Em “expansionRatio” definimos a taxa de crescimento das camadas como sendo de 1.175.
Defina a espessura da última camada em “finalLayerThickness” para 0.00075. Já para a espessura mínima modifique o valor para 0.00025 em “minThickness”.
Em “featureAngle” aumente o valor para 130. Se esse valor for pequeno, poderá haver erros no momento de criar as camadas.
Resumindo, os valores em “addLayersControls” devem ser os seguintes:
addLayersControls
{
relativeSizes false;
layers
{
cyl-1
{
nSurfaceLayers 9;
}
cyl-2
{
nSurfaceLayers 9;
}
}
expansionRatio 1.3;
finalLayerThickness 0.00075;
minThickness 0.00025;
nGrow 0;
featureAngle 130;
nRelaxIter 5;
nSmoothSurfaceNormals 1;
nSmoothNormals 3;
nSmoothThickness 10;
maxFaceThicknessRatio 0.5;
maxThicknessToMedialRatio 0.3;
minMedialAxisAngle 90;
nBufferCellsNoExtrude 0;
nLayerIter 50;
nRelaxedIter 20;
}
Em “meshQualityControls” apague todo o conteúdo que está dentro e substitua pelos seguintes valores:
meshQualityControls
{
maxNonOrtho 75;
maxBoundarySkewness 20;
maxInternalSkewness 4;
maxConcave 80;
minVol 1.00E-13;
minTetQuality -1e30;
minArea -1;
minTwist 0.02;
minDeterminant 0.001;
minFaceWeight 0.05;
minVolRatio 0.01;
minTriangleTwist -1;
minFlatness 0.5;
nSmoothScale 4;
errorReduction 0.75;
}
As demais configurações permanecem inalteradas. Salve o arquivo “snappyHexMeshDict” e feche-o.
Geração da malha
Para gerar a malha, abra o terminal e vá até a pasta do caso (“cylinders_snappyHex”). Então, digite “blockMesh” para gerar a base da malha.
Depois, digite “snappyHexMesh -overwrite” para criar a malha. Esse processo pode levar alguns minutos.
Digite, agora, “checkMesh”. Se tudo estiver certo, será exibida a mensagem “Mesh Ok” no final.
Vamos abrir o Paraview para visualizar a malha. Antes é necessário criar um arquivo .foam. Digite nano cylinders.foam no terminal e aperte “enter”. Depois aperte “ctrl + o”, “enter” e por fim “ctrl + x”.
Agora abra o Paraview digitando “paraview cylinders.foam”
No Paraview, clique em “Apply” e depois selecione “Surface With Edges”, como indicado abaixo, para visualizar a malha. A malha resultante com seus diferentes níveis de refino e sua camada de prismas nas paredes pode ser visualizada nas imagens abaixo.
