Simple Children

Concept

Chaque successeur de la classe Block peut avoir des blocs enfants. Chaque classe avec items (actuellement Matrix et Layer) peut avoir des enfants pour chaque item.

Chaque enfant est un fichier gmsh_scripts au format JSON ou YAML.

Les enfants sont spécifiés dans le champ data.children. On pourrait définir transforms pour les enfants dans le champ data.children_transforms.

Les éléments enfants sont spécifiés dans data.items_children Il faut définir data.items_children_transforms et data.items_children_transforms_map pour leur appliquer des transformations.

Children

Créons deux enfants et un parent. Les enfants sont des instances de la classe Layer, c’est-à-dire qu’ils sont des cylindres avec des rayons différents. Le parent est une instance de la classe Block et a 3 items disposés le long de l’axe X.

Nous les créons structurés et quadrillés pour plus de commodité.

  • Enfant 1

 1metadata:
 2  run:
 3    factory: geo
 4    strategy:
 5      class: strategy.NoBoolean
 6data:
 7  class: block.Layer
 8  layer: [ [ 0.05;;4, 0.15;;4 ],
 9           [ 0.1;;2, 0.3;;2 ] ]
10  layer_curves: [ [ line, circle_arc ],
11                  [ line, line ] ]
12  items_zone: [ CHILD_1 ]
13  items_do_structure_map: 1
14  items_do_quadrate_map: 1

python -m gmsh_scripts child_1.yaml
_images/tutorial_simple_children_child_1.png

Enfant 1

  • Enfant 2

 1metadata:
 2  run:
 3    factory: geo
 4    strategy:
 5      class: strategy.NoBoolean
 6data:
 7  class: block.Layer
 8  layer: [ [ 0.1;;4, 0.3;;4 ],
 9           [ 0.1;;2, 0.3;;2 ] ]
10  layer_curves: [ [ line, circle_arc ],
11                  [ line, line ] ]
12  items_zone: [ CHILD_2 ]
13  items_do_structure_map: 1
14  items_do_quadrate_map: 1

python -m gmsh_scripts child_2.yaml
_images/tutorial_simple_children_child_2.png

Enfant 2

  • Parent

 1metadata:
 2  run:
 3    factory: geo
 4    strategy:
 5      class: strategy.NoBoolean
 6data:
 7  class: block.Matrix
 8  matrix: [ [ 0;;2, 1;;2, 2;;2, 3;;2 ],
 9            [ 0;;2, 1;;2 ],
10            [ 0;;2, 1;;2 ] ]
11  items_zone: [ PARENT ]
12  items_do_structure_map: 1
13  items_do_quadrate_map: 1

python -m gmsh_scripts parent.yaml
_images/tutorial_simple_children_parent.png

Parent

On peut ajouter des enfants au parent en spécifiant data.children avec la liste des noms de fichiers des enfants commençant par le caractère /.

 1metadata:
 2  run:
 3    factory: geo
 4    strategy:
 5      class: strategy.NoBoolean
 6data:
 7  class: block.Matrix
 8  matrix: [ [ 0;;2, 1;;2, 2;;2, 3;;2 ],
 9            [ 0;;2, 1;;2 ],
10            [ 0;;2, 1;;2 ] ]
11  items_zone: [ PARENT ]
12  children: [
13    /child_1.yaml,
14    /child_2.yaml
15  ]
16  items_do_structure_map: 1
17  items_do_quadrate_map: 1
_images/tutorial_simple_children_parent_2.png

Parent avec children sans children_transforms

Comme on peut le voir, les enfants sont placés dans leur origine (0, 0, 0). Pour les déplacer vers un autre emplacement, utilisez le champ data.children_transforms qui contient transforms pour chaque enfant en fonction de sa position dans le champ data.children.

Dans cet exemple, nous déplaçons le premier enfant de -1 et le deuxième enfant de 2 le long de l’axe Y.

 1metadata:
 2  run:
 3    factory: geo
 4    strategy:
 5      class: strategy.NoBoolean
 6data:
 7  class: block.Matrix
 8  matrix: [ [ 0;;2, 1;;2, 2;;2, 3;;2 ],
 9            [ 0;;2, 1;;2 ],
10            [ 0;;2, 1;;2 ] ]
11  items_zone: [ PARENT ]
12  children: [
13    /child_1.yaml,
14    /child_2.yaml
15  ]
16  children_transforms: [
17    [ [ 0, -1, 0] ],
18    [ [ 0, 2, 0] ]
19  ]
20  items_do_structure_map: 1
21  items_do_quadrate_map: 1
_images/tutorial_simple_children_parent_3.png

Parent avec children avec children_transforms

Items Children

L’ajout d’éléments enfants est un peu plus délicat: nous devons d’abord spécifier des enfants pour chaque élément, puis appliquer des transformations à chaque enfant de chaque élément.

Travailler avec items consiste en 2 étapes: créer un main field avec des options, puis créer un addressing field, qui se termine par le suffixe _map à l’exception des champs avec do_ préfixe, ils n’ont pas besoin de main field. Chaque valeur dans le addressing field est un index dans le main field et la position de la valeur indique à quel item de Matrix ou Layer doit se voir attribuer l’option de main_field.

Dans cet exemple, le parent a 3 éléments, donc les champs d’adressage auront une longueur de 3. Nous devons d’abord définir le champ principal pour les enfants items_children puis le champ d’adressage items_children_map.

items_children se compose de 3 options, la première et la deuxième assignent un enfant à un élément et la troisième - deux:

  1. /child_1.yaml,

  2. /child_2.yaml,

  3. /child_1.yaml et /child_2.yaml.

items_children_map affecte la première option de items_children au premier élément, la deuxième option de items_children au deuxième élément, et la troisième à la troisième: [0, 1, 2].

De même, les champs items_children_transforms et items_children_transforms_map sont définis.

items_children_transforms se compose de 2 options, d’abord n’attribuer aucune transformation à un enfant et la troisième une transformation à deux enfants:

  1. [ [ ] ],

  2. [ [ [ 0, 0, 0.1 ] ], [ [ 0, 0, -0.3 ] ] ].

items_children_transforms_map attribue la première option de items_children aux premier et deuxième éléments et la deuxième option au troisième: [0, 0, 1].

Il est pratique de créer uniquement une géométrie au lieu d’un maillage lorsque vous travaillez avec des enfants et leurs transformations.

 1metadata:
 2  run:
 3    factory: geo
 4data:
 5  class: block.Matrix
 6  matrix: [ [ 0;;2, 1;;2, 2;;2, 3;;2 ],
 7            [ 0;;2, 1;;2 ],
 8            [ 0;;2, 1;;2 ] ]
 9  items_zone: [ PARENT ]
10  items_children: [
11    [ /child_1.yaml ],
12    [ /child_2.yaml ],
13    [ /child_1.yaml, /child_2.yaml ],
14  ]
15  items_children_map: [
16    0, 1, 2
17  ]
18  items_children_transforms: [
19    [ [ ] ],
20    [ [ [ 0, 0, 0.1 ] ], [ [ 0, 0, -0.3 ] ] ],
21  ]
22  items_children_transforms_map: [
23    0, 0, 1
24  ]
25  items_do_structure_map: 1
26  items_do_quadrate_map: 1

python -m gmsh_scripts parent_items.yaml
_images/tutorial_simple_children_parent_items.png

Parent avec items_children au format de sortie geo_unrolled

Après cela, nous pourrions ajouter une stratégie pour créer le maillage.

 1metadata:
 2  run:
 3    factory: geo
 4    strategy:
 5      class: strategy.NoBoolean
 6data:
 7  class: block.Matrix
 8  matrix: [ [ 0;;2, 1;;2, 2;;2, 3;;2 ],
 9            [ 0;;2, 1;;2 ],
10            [ 0;;2, 1;;2 ] ]
11  items_zone: [ PARENT ]
12  items_children: [
13    [ /child_1.yaml ],
14    [ /child_2.yaml ],
15    [ /child_1.yaml, /child_2.yaml ],
16  ]
17  items_children_map: [
18    0, 1, 2
19  ]
20  items_children_transforms: [
21    [ [ ] ],
22    [ [ [ 0, 0, 0.1 ] ], [ [ 0, 0, -0.3 ] ] ],
23  ]
24  items_children_transforms_map: [
25    0, 0, 1
26  ]
27  items_do_structure_map: 1
28  items_do_quadrate_map: 1
_images/tutorial_simple_children_parent_items_2.png

Parent avec items_children

Nous pourrions supprimer la génération d’éléments (pas leurs enfants) en définissant items_do_register_map sur 0.

 1metadata:
 2  run:
 3    factory: geo
 4    strategy:
 5      class: strategy.NoBoolean
 6data:
 7  class: block.Matrix
 8  matrix: [ [ 0;;2, 1;;2, 2;;2, 3;;2 ],
 9            [ 0;;2, 1;;2 ],
10            [ 0;;2, 1;;2 ] ]
11  items_zone: [ PARENT ]
12  items_children: [
13    [ /child_1.yaml ],
14    [ /child_2.yaml ],
15    [ /child_1.yaml, /child_2.yaml ],
16  ]
17  items_children_map: [
18    0, 1, 2
19  ]
20  items_children_transforms: [
21    [ [ ] ],
22    [ [ [ 0, 0, 0.1 ] ], [ [ 0, 0, -0.3 ] ] ],
23  ]
24  items_children_transforms_map: [
25    0, 0, 1
26  ]
27  items_do_structure_map: 1
28  items_do_quadrate_map: 1
29  items_do_register_map: 0
_images/tutorial_simple_children_parent_items_3.png

Parent avec items_children sans items

Nous pourrions également créer de nombreuses copies d’enfants à l’intérieur d’un élément en ajoutant un paramètre supplémentaire après la coordonnée avec le séparateur :, par exemple. 5:4 divise le dernier élément en 3 parties (avec 4 nœuds) et crée des enfants à l’intérieur de chaque partie.

 1metadata:
 2  run:
 3    factory: geo
 4    strategy:
 5      class: strategy.NoBoolean
 6data:
 7  class: block.Matrix
 8  matrix: [ [ 0;;2, 1;;2, 2;;2, 5:4;;2 ],
 9            [ 0;;2, 1;;2 ],
10            [ 0;;2, 1;;2 ] ]
11  items_zone: [ PARENT ]
12  items_children: [
13    [ /child_1.yaml ],
14    [ /child_2.yaml ],
15    [ /child_1.yaml, /child_2.yaml ],
16  ]
17  items_children_map: [
18    0, 1, 2
19  ]
20  items_children_transforms: [
21    [ [ ] ],
22    [ [ [ 0, 0, 0.1 ] ], [ [ 0, 0, -0.3 ] ] ],
23  ]
24  items_children_transforms_map: [
25    0, 0, 1
26  ]
27  items_do_structure_map: 1
28  items_do_quadrate_map: 1
29  items_do_register_map: 0
_images/tutorial_simple_children_parent_items_4.png

Parent avec items_children avec troisième élément étendu

Tous ensemble

On pourrait combiner children et items_children, par ex. d’ajouter arbitrairement et régulièrement des enfants localisés.

 1metadata:
 2  run:
 3    factory: occ
 4    strategy:
 5      class: strategy.NoBoolean
 6data:
 7  class: block.Matrix
 8  matrix: [ [ 0;;2, 1;;2, 2;;2, 5:4;;2 ],
 9            [ 0;;2, 1;;2 ],
10            [ 0;;2, 1;;2 ] ]
11  items_zone: [ PARENT ]
12  children: [
13    /child_1.yaml,
14    /child_2.yaml
15  ]
16  children_transforms: [
17    [ [ 0, -1, 0 ] ],
18    [ [ 0, 2, 0 ] ]
19  ]
20  items_children: [
21    [ /child_1.yaml ],
22    [ /child_2.yaml ],
23    [ /child_1.yaml, /child_2.yaml ],
24  ]
25  items_children_map: [
26    0, 1, 2
27  ]
28  items_children_transforms: [
29    [ [ ] ],
30    [ [ [ 0, 0, 0.1 ] ], [ [ 0, 0, -0.3 ] ] ],
31  ]
32  items_children_transforms_map: [
33    0, 0, 1
34  ]
35  items_do_structure_map: 1
36  items_do_quadrate_map: 1
37  items_do_register_map: 0

python -m gmsh_scripts parent_all.yaml
_images/tutorial_simple_children_parent_all.png

Parent avec children et items_children

Maillage

Pour créer un maillage, nous avons besoin d’opérations booléennes disponibles dans l’usine occ.

Avertissement

Il est recommandé de désactiver les champs items_do_structure_map et items_do_quadrate_map, c’est-à-dire de créer un maillage tétraédrique non structuré tout en utilisant des opérations booléennes pour obtenir une meilleure stabilité de génération du maillage.

1data:
2  class: block.Layer
3  layer: [ [ 0.05;;4, 0.15;;4 ],
4           [ 0.1;;2, 0.3;;2 ] ]
5  layer_curves: [ [ line, circle_arc ],
6                  [ line, line ] ]
7  items_zone: [ CHILD_1 ]
8  items_do_structure_map: 0
9  items_do_quadrate_map: 0

1data:
2  class: block.Layer
3  layer: [ [ 0.1;;4, 0.3;;4 ],
4           [ 0.1;;2, 0.3;;2 ] ]
5  layer_curves: [ [ line, circle_arc ],
6                  [ line, line ] ]
7  items_zone: [ CHILD_2 ]
8  items_do_structure_map: 0
9  items_do_quadrate_map: 0

 1metadata:
 2  run:
 3    factory: occ
 4data:
 5  class: block.Matrix
 6  matrix: [ [ 0;;2, 1;;2, 2;;2, 5:4;;2 ],
 7            [ 0;;2, 1;;2 ],
 8            [ 0;;2, 1;;2 ] ]
 9  items_zone: [ PARENT ]
10  children: [
11    /child_1.yaml,
12    /child_2.yaml
13  ]
14  children_transforms: [
15    [ [ 0, -1, 0 ] ],
16    [ [ 0, 2, 0 ] ]
17  ]
18  items_children: [
19    [ /child_1.yaml ],
20    [ /child_2.yaml ],
21    [ /child_1.yaml, /child_2.yaml ],
22  ]
23  items_children_map: [
24    0, 1, 2
25  ]
26  items_children_transforms: [
27    [ [ ] ],
28    [ [ [ 0, 0, 0.1 ] ], [ [ 0, 0, -0.3 ] ] ],
29  ]
30  items_children_transforms_map: [
31    0, 0, 1
32  ]
33  items_do_structure_map: 0
34  items_do_quadrate_map: 0
35  items_do_register_map: 1

python -m gmsh_scripts parent_all.yaml
_images/tutorial_simple_children_parent_all_2.png

Maillage généré avec occ factory

On pourrait personnaliser la qualité du maillage en utilisant les champs run.options, par exemple:

  1. Mesh.MeshSizeFactor - facteur appliqué à toutes les tailles d’éléments de maillage,

  2. Mesh.MeshSizeMin - taille minimale de l’élément de maillage,

  3. Mesh.MeshSizeMax - taille maximale de l’élément de maillage,

  4. Mesh.MeshSizeExtendFromBoundary - étend le calcul de la taille des éléments de maillage des frontières vers l’intérieur (0: jamais; 1: pour les surfaces et les volumes; 2: pour les surfaces et les volumes, mais utiliser la plus petite longueur d’arête d’élément de surface au lieu de la plus grande longueur en 3D Delaunay; -2 : uniquement pour les surfaces; -3: uniquement pour les volumes)

  5. Mesh.MeshSizeFromCurvature - calcule automatiquement la taille des éléments de maillage à partir de la courbure, en utilisant la valeur comme nombre cible d’éléments par 2 * Pi radians.

Note

Voir la documentation de gmsh pour plus d’informations sur les options et leur description.

 1metadata:
 2  run:
 3    factory: occ
 4    options:
 5      Mesh.MeshSizeFactor: 1.0
 6      Mesh.MeshSizeMin: 0.1
 7      Mesh.MeshSizeMax: 0.3
 8      Mesh.MeshSizeExtendFromBoundary: 2
 9      Mesh.MeshSizeFromCurvature: 12
10data:
11  class: block.Matrix
12  matrix: [ [ 0;;2, 1;;2, 2;;2, 5:4;;2 ],
13            [ 0;;2, 1;;2 ],
14            [ 0;;2, 1;;2 ] ]
15  items_zone: [ PARENT ]
16  children: [
17    /child_1.yaml,
18    /child_2.yaml
19  ]
20  children_transforms: [
21    [ [ 0, -1, 0 ] ],
22    [ [ 0, 2, 0 ] ]
23  ]
24  items_children: [
25    [ /child_1.yaml ],
26    [ /child_2.yaml ],
27    [ /child_1.yaml, /child_2.yaml ],
28  ]
29  items_children_map: [
30    0, 1, 2
31  ]
32  items_children_transforms: [
33    [ [ ] ],
34    [ [ [ 0, 0, 0.1 ] ], [ [ 0, 0, -0.3 ] ] ],
35  ]
36  items_children_transforms_map: [
37    0, 0, 1
38  ]
39  items_do_structure_map: 0
40  items_do_quadrate_map: 0
41  items_do_register_map: 1
_images/tutorial_simple_children_parent_all_3.png

Maillage configuré avec metadata.run.options