Section transversale 2

Let’s consider a cross section (See examples/matrix/cross_section_2)

_images/cross_section_2_draft.png

Section transversale

Nous pouvons utiliser la classe Matrix pour créer ce type de géométrie. Nous devons d’abord décomposer la géométrie en blocs, puis modifier chacun d’eux en fonction des dimensions.

Décomposition

La géométrie peut être décomposée en 4 blocs: BOTTOM, TOP1, TOP2 et « TOP3, où la partie TOP3 est requise pour une petite surface avec \(F\), \(u_v\) condition aux limites à la fin de la partie supérieure de la géométrie. Sans la condition aux limites, 3 blocs suffiraient. Chacun de ces blocs sera décrit par la classe Matrix.

_images/cross_section_2_decomposition.png

Décomposition de la géométrie

Géométrie

Définissons que l’axe X est dirigé vers la droite, Y - dans la profondeur et Z - vers le haut, c’est-à-dire que la section transversale est symétrique le long de l’axe Y.

Nous devons d’abord créer un fichier séparé pour chacun des blocs:

  • top_1.yaml

1 data:
2   class: block.Matrix
3   matrix: [ [ 0, 0.250 ], [ 0, 1 ], [ 0, 0.250 ] ]

  • top_2.yaml

1  data:
2    class: block.Matrix
3    matrix: [ [ 0, 0.220 ], [ 0, 1 ], [ 0, 0.250 ] ]

  • top_3.yaml

1 data:
2   class: block.Matrix
3   matrix: [ [ 0, 0.030 ], [ 0, 1 ], [ 0, 0.250 ] ]

  • bottom.yaml

1 data:
2   class: block.Matrix
3   matrix: [ [ 0, 0.250 ], [ 0, 1 ], [ 0, 0.250 ] ]

Chacun des fichiers est constitué d’un champ de haut niveau data dont 2 champs: 1. class - nom de la classe du bloc 2. matrix - listes de coordonnées de points par axes

Par exemple Matrix a 2 points par axe X avec les coordonnées 0 et 0.250.

La matrice a également 2 points par axe Y avec les coordonnées 0 et 1 et 2 points par axe Z avec 0 et 0.250. Ainsi Matrix est une boîte de dimensions : 0.250, 1 et 0.250 par les axes X, Y et Z respectivement et l’origine au point (0, 0, 0).

Nous pourrions générer la géométrie de bottom.yaml dans le fichier bottom.geo_unrolled:

python -m gmsh_scripts bottom.yaml
_images/cross_section_2_geometry_bottom.png

Géométrie du bloc BOTTOM

Nous devons maintenant créer le fichier principal main.yaml avec tous les blocs:

 1 data:
 2   class: block.Block
 3   do_register: 0
 4   children: [
 5     /bottom.yaml,
 6     /top_1.yaml,
 7     /top_2.yaml,
 8     /top_3.yaml
 9   ]
10   children_transforms: [
11     [ ],
12     [ [ 0, 0, 0.250 ] ],
13     [ [ 0.250, 0, 0.250 ] ],
14     [ [ 0.470, 0, 0.250 ] ]
15   ]

Le fichier a également un champ de haut niveau data avec 4 sous-champs:

  1. class - nom de la classe du bloc

  2. do_register - créer ce bloc? (mettez 0 car nous n’en avons pas besoinbloquer lui-même, c’est-à-dire que ce n’est qu’un conteneur pour d’autres blocs)

  3. children - références à d’autres fichiers de blocs (doit commencer par le

  4. children_transforms - transformations d’autres blocs

Le champ children_transforms est une liste de Transform pour chaque enfants. Dans ce tutoriel, nous n’avons besoin que de Translate qui sont donnés par 3 nombres - décalés le long des axes X, Y et Z respectivement.

Par example:

  1. L’enfant bottom.yaml n’a pas de transformations

  2. L’enfant top_1.yaml en a un Translate [ 0, 0, 0.250 ] avec un décalage de 0.250 par l’axe Z et aucun décalage par X et Y (nous avons juste besoin de pour élever au bottom.yaml)

  3. L’enfant top_2.yaml en a un Translate [ 0.250, 0, 0.250 ]

  4. L’enfant top_3.yaml en a un Translate [ 0.470, 0, 0.250 ]

Let’s generate geometry with all blocks into main.geo_unrolled:

python -m gmsh_scripts main.yaml
_images/cross_section_2_geometry_main.png

Géométrie avec tous les blocs

Maille

Pour générer un maillage, nous devons ajouter le champ metadata au fichier main.yaml:

 1 metadata:
 2   run:
 3     factory: geo
 4     strategy:
 5       class: strategy.NoBoolean
 6 data:
 7   class: block.Block
 8   do_register: 0
 9   children: [
10     /bottom.yaml,
11     /top_1.yaml,
12     /top_2.yaml,
13     /top_3.yaml
14   ]
15   children_transforms: [
16     [ ],
17     [ [ 0, 0, 0.250 ] ],
18     [ [ 0.250, 0, 0.250 ] ],
19     [ [ 0.470, 0, 0.250 ] ]
20   ]

Le fichier metadata a un sous-champ run avec des champs:

  1. factory - Quel noyau de gmsh utiliser pour la génération de maillage? Actuellement, gmsh a deux geo et occ. Nous utilisons geo parce que c’est plus rapide

  2. strategy - Strategy de génération de maillage

  3. strategy.class - Classe de la stratégie. Nous utilisons NoBoolean car nous n’avons pas besoin d’opérations booléennes

Avertissement

Si nous avons besoin d’opérations booléennes, nous DEVONS utiliser la fabrique occ avec la stratégie par défaut (ne la définissez pas dans les metadata)

Maintenant, le générateur de maillage renverra le maillage dans le fichier main.msh2 (il renvoie également main.geo_unrolled comme auparavant). Le générateur crée un maillage tétraédrique non structuré par défaut.

python -m gmsh_scripts main.yaml
_images/cross_section_2_mesh_main_default.png

Maillage par défaut

Tétraédrique non structuré

Nous pouvons personnaliser le maillage non structuré avec des paramètres dans les fichiers d’entrée.

Le premier type de paramètres alias point parameters est défini dans le champ matrix (par exemple, bottom.yaml):

1data:
2  class: block.Matrix
3  matrix: [ [ 0;0.01, 0.250;0.1 ], [ 0;0.01, 1;0.1 ], [ 0;0.01, 0.250;0.1 ] ]

Comme on peut le voir, pour chaque point un nouveau paramètre a été ajouté avec le séparateur ;, par ex. 0;0.01 pour le premier point par l’axe X ou 0.250;0.1 pour le deuxième point par l’axe Z. Les paramètres 0.01 ou 0.1 sont des tailles approximatives du maillage près des points correspondants.

Dans cet exemple, le maillage est plus fin près du point (0, 0, 0) avec une taille 0.01 et plus grossier près du point (0.250, 1, 0.250) avec une taille 0.1.

Ajoutons le champ metadata à bottom.yaml et générons le maillage:

python -m gmsh_scripts bottom.yaml

1metadata:
2  run:
3    factory: geo
4    strategy:
5      class: strategy.NoBoolean
6data:
7  class: block.Matrix
8  matrix: [ [ 0;0.01, 0.250;0.1 ], [ 0;0.01, 1;0.1 ], [ 0;0.01, 0.250;0.1 ] ]
_images/cross_section_2_mesh_unstructured_tetrahedral_bottom_1.png

Maillage tétraédrique non structuré du bloc BOTTOM

On pourrait fixer la taille du maillage le long d’un des axes (par exemple Y avec 0.01):

1metadata:
2  run:
3    factory: geo
4    strategy:
5      class: strategy.NoBoolean
6data:
7  class: block.Matrix
8  matrix: [ [ 0;0.01, 0.250;0.1 ], [ 0;0.01, 1;0.01 ], [ 0;0.01, 0.250;0.1 ] ]
_images/cross_section_2_mesh_unstructured_tetrahedral_bottom_2.png

Maillage tétraédrique non structuré de taille fixe le long de l’axe Y du bloc BOTTOM »

Pour générer tous les blocs, il faut spécifier des paramètres de point à tous les blocs et exécuter le générateur:

python -m gmsh_scripts main.yaml
_images/cross_section_2_mesh_unstructured_tetrahedral_main.png

Maillage tétraédrique non structuré avec une taille fixe le long de l’axe Y au bloc BOTTOM

Le deuxième type de paramètres alias global parameters est défini dans le champ metadata.run.options (par exemple, bottom.yaml):

 1metadata:
 2  run:
 3    factory: geo
 4    strategy:
 5      class: strategy.NoBoolean
 6    options:
 7      Mesh.MeshSizeFactor: 0.5
 8      Mesh.MeshSizeMin: 0
 9      Mesh.MeshSizeMax: 1.0e+22
10      Mesh.MeshSizeFromPoints: 1
11data:
12  class: block.Matrix
13  matrix: [ [ 0;0.01, 0.250;0.1 ], [ 0;0.01, 1;0.01 ], [ 0;0.01, 0.250;0.1 ] ]

Voici 4 options (de nombreuses autres options disponibles, voir documentation gmsh): 1. Mesh.MeshSizeFactor - facteur appliqué à toutes les tailles d’éléments de maillage 2. Mesh.MeshSizeMin - taille minimale des éléments de maillage 3. Mesh.MeshSizeMax - taille maximale des éléments de maillage 4. Mesh.MeshSizeFromPoints - calcule les tailles des éléments de maillage à partir de valeurs données aux points géométriques (par exemple dans le champ matrix)

Dans cet exemple, Mesh.MeshSizeFactor est défini sur 0.5, ce qui génère un maillage deux fois plus fin.

_images/cross_section_2_mesh_unstructured_tetrahedral_bottom_global_1.png

Maillage tétraédrique non structuré avec Mesh.MeshSizeFactor = 0.5

On pourrait désactiver Mesh.MeshSizeFromPoints (réglé sur 0) pour créer un maillage uniforme dont la taille n’est contrôlée que par global parameters.

 1metadata:
 2  run:
 3    factory: geo
 4    strategy:
 5      class: strategy.NoBoolean
 6    options:
 7      Mesh.MeshSizeFactor: 1
 8      Mesh.MeshSizeMin: 0
 9      Mesh.MeshSizeMax: 1.0e+22
10      Mesh.MeshSizeFromPoints: 0
11data:
12  class: block.Matrix
13  matrix: [ [ 0;0.01, 0.250;0.1 ], [ 0;0.01, 1;0.01 ], [ 0;0.01, 0.250;0.1 ] ]
_images/cross_section_2_mesh_unstructured_tetrahedral_bottom_global_2.png

Maillage tétraédrique non structuré avec Mesh.MeshSizeFromPoints = 0

Ensuite, nous pourrions utiliser pour contrôler la taille du maillage, par exemple avec Mesh.MeshSizeMax = 0.1:

 1metadata:
 2  run:
 3    factory: geo
 4    strategy:
 5      class: strategy.NoBoolean
 6    options:
 7      Mesh.MeshSizeFactor: 1
 8      Mesh.MeshSizeMin: 0
 9      Mesh.MeshSizeMax: 0.1
10      Mesh.MeshSizeFromPoints: 0
11data:
12  class: block.Matrix
13  matrix: [ [ 0, 0.250 ], [ 0, 1 ], [ 0, 0.250 ] ]
_images/cross_section_2_mesh_unstructured_tetrahedral_bottom_global_3.png

Maillage non structuré avec Mesh.MeshSizeMax = 0.1

Pour générer tous les blocs, il faut spécifier des global parameters dans main.yaml :

 1 metadata:
 2   run:
 3     factory: geo
 4     strategy:
 5       class: strategy.NoBoolean
 6     options:
 7       Mesh.MeshSizeFactor: 1
 8       Mesh.MeshSizeMin: 0
 9       Mesh.MeshSizeMax: 0.1
10       Mesh.MeshSizeFromPoints: 0
11 data:
12   class: block.Block
13   do_register: 0
14   children: [
15     /bottom.yaml,
16     /top_1.yaml,
17     /top_2.yaml,
18     /top_3.yaml
19   ]
20   children_transforms: [
21     [ ],
22     [ [ 0, 0, 0.250 ] ],
23     [ [ 0.250, 0, 0.250 ] ],
24     [ [ 0.470, 0, 0.250 ] ]
25   ]

python -m gmsh_scripts main.yaml
_images/cross_section_2_mesh_unstructured_tetrahedral_main_global.png

Maillage tétraédrique non structuré contrôlé par global parameters

Hexaèdre non structuré

Avertissement

La génération de maillage hexaédrique non structuré est expérimentale donc ne crée pas toujours un maillage de qualité, cela dépend de la complexité de la géométrie.

Les paramètres hexaédriques non structurés sont définis dans le champ metadata.run.options et ont Recombine dans leurs noms (voir options gmsh)

Pour générer un maillage hexaédrique non structuré, le paramètre `Mesh.SubdivisionAlgorithm doit être supérieur à 1 (voir tutoriel 11 de gmsh pour plus d’informations)

 1metadata:
 2  run:
 3    factory: geo
 4    strategy:
 5      class: strategy.NoBoolean
 6    options:
 7      Mesh.MeshSizeFactor: 1
 8      Mesh.MeshSizeMin: 0
 9      Mesh.MeshSizeMax: 0.1
10      Mesh.MeshSizeFromPoints: 0
11      Mesh.SubdivisionAlgorithm: 2
12data:
13  class: block.Matrix
14  matrix: [ [ 0, 0.250 ], [ 0, 1 ], [ 0, 0.250 ] ]

python -m gmsh_scripts bottom.yaml
_images/cross_section_2_mesh_unstructured_hexahedral_bottom_1.png

Unstructured hexahedral mesh of bottom.yaml

Pour générer un maillage hexaédrique non structuré de tous les blocs, ajoutez des paramètres aux metadata de main.yaml:

 1 metadata:
 2   run:
 3     factory: geo
 4     strategy:
 5       class: strategy.NoBoolean
 6     options:
 7       Mesh.MeshSizeFactor: 1
 8       Mesh.MeshSizeMin: 0
 9       Mesh.MeshSizeMax: 0.1
10       Mesh.MeshSizeFromPoints: 0
11       Mesh.SubdivisionAlgorithm: 2
12 data:
13   class: block.Block
14   do_register: 0
15   children: [
16     /bottom.yaml,
17     /top_1.yaml,
18     /top_2.yaml,
19     /top_3.yaml
20   ]
21   children_transforms: [
22     [ ],
23     [ [ 0, 0, 0.250 ] ],
24     [ [ 0.250, 0, 0.250 ] ],
25     [ [ 0.470, 0, 0.250 ] ]
26   ]

python -m gmsh_scripts main.yaml
_images/cross_section_2_mesh_unstructured_hexahedral_main.png

Maillage hexaédrique non structuré

Tétraédrique Structuré

Pour créer un maillage tétraédrique structuré, il faut ajouter un troisième paramètre aux points du champ matrix avec le séparateur ;, par ex. dans bottom.yaml:

1metadata:
2   run:
3     factory: geo
4     strategy:
5       class: strategy.NoBoolean
6
7data:
8  class: block.Matrix
9  matrix: [ [ 0;0.01, 0.250;0.1;4 ], [ 0;0.01, 1;0.1;8 ], [ 0;0.01, 0.250;0.1;16 ] ]

Le troisième argument doit être défini uniquement pour le deuxième point et spécifie le nombre de nœuds dans la direction correspondante. Par exemple, 4 nœuds par l’axe X, 8 nœuds par Y et 16 par Z.

python -m gmsh_scripts bottom.yaml
_images/cross_section_2_mesh_structured_tetrahedral_bottom_1.png

Maillage tétraédrique structuré du bloc BOTTOM

On pourrait désactiver la génération de maillage structuré en mettant items_do_structure_map à 0 (1 par défaut) dans le champ data:

 1metadata:
 2   run:
 3     factory: geo
 4     strategy:
 5       class: strategy.NoBoolean
 6
 7data:
 8  class: block.Matrix
 9  matrix: [ [ 0;0.01, 0.250;0.1;4 ], [ 0;0.01, 1;0.1;8 ], [ 0;0.01, 0.250;0.1;16 ] ]
10  items_do_structure_map: 0
_images/cross_section_2_mesh_structured_tetrahedral_bottom_2.png

Maillage tétraédrique non structuré du bloc BOTTOM avec items_do_structure_map = 0

Pour créer un maillage tétraédrique structuré avec tous les blocs, il faut définir le troisième paramètre dans chacun des blocs et exécuter main.yaml

Avertissement

Le nombre de nœuds DOIT être cohérent entre les blocs adjacents, par exemple, tous les blocs TOP doivent avoir le même nombre de nœuds par axe Y et Z

  • top_1.yaml

1 data:
2   class: block.Matrix
3   matrix: [ [ 0, 0.250;0.1;8 ], [ 0, 1;0.1;8 ], [ 0, 0.250;0.1;8 ] ]

  • top_2.yaml

1  data:
2    class: block.Matrix
3    matrix: [ [ 0, 0.220;0.1;8 ], [ 0, 1;0.1;8 ], [ 0, 0.250;0.1;8 ] ]

  • top_3.yaml

1 data:
2   class: block.Matrix
3   matrix: [ [ 0, 0.030;0.1;8 ], [ 0, 1;0.1;8 ], [ 0, 0.250;0.1;8 ] ]

  • bottom.yaml

1 data:
2   class: block.Matrix
3   matrix: [ [ 0, 0.250;0.1;8 ], [ 0, 1;0.1;8 ], [ 0, 0.250;0.1;8 ] ]

python -m gmsh_scripts main.yaml
_images/cross_section_2_mesh_structured_tetrahedral_main_1.png

Maillage tétraédrique structuré

Pour désactiver la génération de maillage structuré pour tous les blocs à la fois, il faut définir children_items_do_structure_map = [0, ..., nombre d'enfants] au niveau du bloc parent, par exemple pour main.yaml:

 1 metadata:
 2   run:
 3     factory: geo
 4     strategy:
 5       class: strategy.NoBoolean
 6 data:
 7   class: block.Block
 8   do_register: 0
 9   children: [
10     /bottom.yaml,
11     /top_1.yaml,
12     /top_2.yaml,
13     /top_3.yaml
14   ]
15   children_transforms: [
16     [ ],
17     [ [ 0, 0, 0.250 ] ],
18     [ [ 0.250, 0, 0.250 ] ],
19     [ [ 0.470, 0, 0.250 ] ]
20   ]
21   children_items_do_structure_map: [0, 0, 0, 0]
_images/cross_section_2_mesh_structured_tetrahedral_main_2.png

Maillage tétraédrique structuré avec children_items_do_structure_map désactivé

Hexaèdre structuré

Pour créer un maillage hexaédrique structuré, on peut suivre les mêmes étapes que pour Tétraédrique Structuré mais avec items_do_quadrate_map = 1 (0 par défaut) dans le champ data:

 1metadata:
 2   run:
 3     factory: geo
 4     strategy:
 5       class: strategy.NoBoolean
 6
 7data:
 8  class: block.Matrix
 9  matrix: [ [ 0;0.01, 0.250;0.1;4 ], [ 0;0.01, 1;0.1;8 ], [ 0;0.01, 0.250;0.1;16 ] ]
10  items_do_quadrate_map: 1

python -m gmsh_scripts bottom.yaml
_images/cross_section_2_mesh_structured_hexahedral_bottom_1.png

Maillage hexaédrique structuré du bloc BOTTOM

On pourrait changer les positions des nœuds le long des axes en utilisant l’une des deux méthodes:

  1. progression - augmenter/diminuer l’espace entre les nœuds du point de départ au point final

  2. bump - augmenter/diminuer l’espace entre les nœuds du centre aux points

Pour utiliser progression, nous devons spécifier 2 sous-paramètres supplémentaires au troisième paramètre séparés par ::

  1. Le premier est 0 (qui choisit le type progression)

  2. Le second est un coefficient de la progression - si le coefficient > 1 l’espace augmentera du premier point au second, sinon il diminuera

Par exemple, les sous-paramètres progression 0:1.5 pour l’axe Y:

 1metadata:
 2   run:
 3     factory: geo
 4     strategy:
 5       class: strategy.NoBoolean
 6
 7data:
 8  class: block.Matrix
 9  matrix: [ [ 0;0.01, 0.250;0.1;4 ], [ 0;0.01, 1;0.1;8:0:1.5 ], [ 0;0.01, 0.250;0.1;16 ] ]
10  items_do_quadrate_map: 1
_images/cross_section_2_mesh_structured_hexahedral_bottom_progression_1.png

Maillage hexaédrique structuré avec progression = 1.5

Par exemple, les sous-paramètres progression 0:0.75 pour l’axe Y:

 1metadata:
 2   run:
 3     factory: geo
 4     strategy:
 5       class: strategy.NoBoolean
 6
 7data:
 8  class: block.Matrix
 9  matrix: [ [ 0;0.01, 0.250;0.1;4 ], [ 0;0.01, 1;0.1;8:0:0.75 ], [ 0;0.01, 0.250;0.1;16 ] ]
10  items_do_quadrate_map: 1
_images/cross_section_2_mesh_structured_hexahedral_bottom_progression_2.png

Maillage hexaédrique structuré avec progression = 0.75

Pour utiliser bump, nous devons spécifier 2 sous-paramètres supplémentaires au troisième paramètre séparés par ::

  1. Le premier est 1 (qui choisit le type bump)

  2. Le second est un coefficient de la bump - si le coefficient > 1, l’espace augmentera à partir du centre, sinon il diminuera

Par exemple, les sous-paramètres bump 1:2.0 pour l’axe Y:

 1metadata:
 2   run:
 3     factory: geo
 4     strategy:
 5       class: strategy.NoBoolean
 6
 7data:
 8  class: block.Matrix
 9  matrix: [ [ 0;0.01, 0.250;0.1;4 ], [ 0;0.01, 1;0.1;8:1:2.0 ], [ 0;0.01, 0.250;0.1;16 ] ]
10  items_do_quadrate_map: 1
_images/cross_section_2_mesh_structured_hexahedral_bottom_bump_1.png

Maillage hexaédrique structuré avec bump = 2.0

Par exemple, les sous-paramètres bump 1:0.5 pour l’axe Y:

 1metadata:
 2   run:
 3     factory: geo
 4     strategy:
 5       class: strategy.NoBoolean
 6
 7data:
 8  class: block.Matrix
 9  matrix: [ [ 0;0.01, 0.250;0.1;4 ], [ 0;0.01, 1;0.1;8:1:0.5 ], [ 0;0.01, 0.250;0.1;16 ] ]
10  items_do_quadrate_map: 1
_images/cross_section_2_mesh_structured_hexahedral_bottom_bump_2.png

Maillage hexaédrique structuré avec bump = 0.5

Pour générer un maillage hexaédrique structuré de tous les blocs, on peut définir items_do_quadrate_map = 0 à chacun des blocs ou définir children_items_do_quadrate_map = [0, ..., nombre d'enfants] au bloc parent, par ex. pour main.yaml:

 1 metadata:
 2   run:
 3     factory: geo
 4     strategy:
 5       class: strategy.NoBoolean
 6 data:
 7   class: block.Block
 8   do_register: 0
 9   children: [
10     /bottom.yaml,
11     /top_1.yaml,
12     /top_2.yaml,
13     /top_3.yaml
14   ]
15   children_transforms: [
16     [ ],
17     [ [ 0, 0, 0.250 ] ],
18     [ [ 0.250, 0, 0.250 ] ],
19     [ [ 0.470, 0, 0.250 ] ]
20   ]
21   children_items_do_quadrate_map: [1, 1, 1, 1]

python -m gmsh_scripts main.yaml
_images/cross_section_2_mesh_structured_hexahedral_main.png

Maillage hexaédrique structuré

Zones

Si nous voulons ajouter des noms aux entités du maillage (par exemple, des volumes de surfaces), nous devons définir un champ supplémentaire items_zones dans le champ data

Par exemple, nous pouvons ajouter [ [ Volume, [ NX, X, NY, Y, NZ, Z ] ] ] dans le bottom.yaml, où:

  1. Volume - nom du volume

  2. [ NX, X, NY, Y, NZ, Z ] - noms des surfaces:

    • NX - surface pointant dans la direction opposée à l’axe X

    • X - surface pointant dans la direction de l’axe X

    • NY - surface pointant dans la direction opposée à l’axe Y

    • Y - surface pointant dans la direction de l’axe Y

    • NZ - surface pointant dans la direction opposée à l’axe Z

    • Z - surface pointant dans la direction de l’axe Z

 1metadata:
 2   run:
 3     factory: geo
 4     strategy:
 5       class: strategy.NoBoolean
 6
 7data:
 8  class: block.Matrix
 9  matrix: [ [ 0;0.01, 0.250;0.1;4 ], [ 0;0.01, 1;0.1;8 ], [ 0;0.01, 0.250;0.1;16 ] ]
10  items_zone: [ [ Volume, [ NX, X, NY, Y, NZ, Z ] ] ]
11  items_do_quadrate_map: 1
_images/cross_section_2_mesh_structured_hexahedral_bottom_zones.png

Hexaèdre structuré avec zones

Résultat

Note

Nous devrions définir différents noms de zone des surfaces inférieures de TOP2 et TOP3, par ex. Top2NZ et Top3NZ respectivement

  • top_1.yaml

1data:
2  class: block.Matrix
3  matrix: [ [ 0;0.1, 0.250;0.1;8 ], [ 0;0.1, 1;0.1;8 ], [ 0;0.1, 0.250;0.1;8 ] ]
4  items_zone: [ [ Volume, [ NX, X, NY, Y, NZ, Z ] ] ]

  • top_2.yaml

1data:
2  class: block.Matrix
3  matrix: [ [ 0;0.1, 0.220;0.1;8 ], [ 0;0.1, 1;0.1;8 ], [ 0;.1, 0.250;0.1;8 ] ]
4  items_zone: [ [ Volume, [ NX, X, NY, Y, Top2NZ, Z ] ] ]

  • top_3.yaml

1data:
2  class: block.Matrix
3  matrix: [ [ 0;0.1, 0.030;0.1;8 ], [ 0;0.1, 1;0.1;8 ], [ 0;.1, 0.250;0.1;8 ] ]
4  items_zone: [ [ Volume, [ NX, X, NY, Y, Top3NZ, Z ] ] ]

  • bottom.yaml

1data:
2  class: block.Matrix
3  matrix: [ [ 0;.1, 0.250;.1;8 ], [ 0;.1, 1;.1;8 ], [ 0;.1, 0.250;.1;8 ] ]
4  items_zone: [ [ Volume, [ NX, X, NY, Y, NZ, Z ] ] ]

  • main.yaml

 1metadata:
 2  run:
 3    factory: geo
 4    strategy:
 5      class: strategy.NoBoolean
 6data:
 7  class: block.Block
 8  do_register: 0
 9  children: [
10    /bottom.yaml,
11    /top_1.yaml,
12    /top_2.yaml,
13    /top_3.yaml
14  ]
15  children_transforms: [
16    [ ],
17    [ [ 0, 0, 0.250 ] ],
18    [ [ 0.250, 0, 0.250 ] ],
19    [ [ 0.470, 0, 0.250 ] ]
20  ]
21  children_items_do_quadrate_map: [ 1, 1, 1, 1 ]
22  children_items_do_structure_map: [ 1, 1, 1, 1 ]

python -m gmsh_scripts main.yaml
_images/cross_section_2.png

Maille