Discussion :

[etiennep17]

Bonjour à tous,

J'ai récupéré les coordonnées des nœuds du maillage suivant sur Abaqus (surface avec maillage affinée)



Après les avoir stockés dans une liste, j'aimerais pouvoir les trier afin de les manipuler aisément. Attention: petite subtilité, il faudrait que ça soit trié selon 2 critères d'importance équivalente (ici, x et y) afin d'obtenir un tri qui a du sens par rapport à l'image ci-dessus.

Voici un exemple basique de ce j'obtiens:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 coord = [ [1,0,2],[5,9,4],[4,1,5],
           [6,3,9],[10,4,12],[8,2,9], 
           [0,9,1],[3,1,3],[7,10,8] ]

Voici ce que j'aimerais obtenir:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 coord = [ [8,2,9],[10,4,12],[7,10,8],
           [4,1,5],[9,3,9],[5,9,4], 
           [1,0,2],[3,1,3],[0,9,1] ]

Représenté comme des matrices pour visualiser plus facilement.
Méthode de tri souhaité: Y croissant de gauche vers droite / X croissant de bas en haut (afin d'être cohérent par rapport aux référentiel de l'image)
Là où c'est compliqué pour moi, c'est quand il y a des croisements, ex dans la matrice souhaitée: A(1,1)=[8,2,9] et B(3,2)=[3,1,3] -> on remarque que By < Ay. Pourtant le tri est correct car fidèle aux coordonnées de la surface (voir image)
Autre ex: A(1,1)=[8,2,9] et C(2,2)=[9,3,9] -> on remarque que Cx > Ax. Pourtant le tri est correct car fidèle aux coordonnées de la surface (voir image)

Voilà, j'espère avoir été claire, n'hésitez à me demander des détails.
J'attends vos réponses avec impatience

P.S: j'ai déjà longuement réfléchi au pb. Pour ceux qui estimerait ne pas avoir à faire le travail à ma place, sachez que j'ai déjà codé quelques lignes. C'est de le fouilli, ça fonctionne... mais pas tout le temps (selon comment on affine le maillage) ! D'où mon appel à l'aide

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
n1=mdb.models['Verzahnung'].rootAssembly.sets['SET-SURFACE'] 
xyz_koor = []    
for i in range(0,len(n1.nodes)): 
        xyz_koor.append([n1.nodes[i].coordinates[0],n1.nodes[i].coordinates[1],n1.nodes[i].coordinates[2],0])  
xyz_koor=sorted({tuple(x): x for x in xyz_koor}.values(),key=lambda a_entry: a_entry[1],reverse=True)      
diff=0    
for i in range(1,len(xyz_koor)-1):       
    if abs(xyz_koor[i][1]-xyz_koor[i-1][1])>diff:  
        diff=abs(xyz_koor[i][1]-xyz_koor[i-1][1])  
breite=abs(xyz_koor[0][1]-xyz_koor[-1][1])   
x_punkte=[]         
y_punkte=[]          
z_punkte=[]         
hohe=0 
for i in range(0,len(xyz_koor)):   
    if abs(xyz_koor[i][1]-xyz_koor[0][1])<0.2*diff:    
        hohe+=1    
lange=len(xyz_koor)/hohe    
n=0    
for i in range(0,lange):    
    for j in range(lange*hohe,lange*hohe+hohe):    
        xyz_koor[n][3] = i+1      
        n+=1      
for i in range(0,len(xyz_koor)):   
    for k in range(0,hohe):   
        if abs(xyz_koor[i][1]-xyz_koor[-1][1]-k*(1.0/(hohe-1))*breite)<=0.48*diff:   
            x_punkte.append(xyz_koor[i][0])   
            y_punkte.append(xyz_koor[i][1])   
            z_punkte.append(xyz_koor[i][2])   
for i in range(1,int((len(x_punkte)-1))):   #Sortierung nach X-koor 
    for j in range(i,-1,-1):    
        if abs(y_punkte[j]-y_punkte[j-1])<diff and x_punkte[j]>x_punkte[j-1]:    
            x_punkte[j],x_punkte[j-1]=x_punkte[j-1],x_punkte[j]       
            y_punkte[j],y_punkte[j-1]=y_punkte[j-1],y_punkte[j]       
            z_punkte[j],z_punkte[j-1]=z_punkte[j-1],z_punkte[j]       
for i in range(0,len(y_punkte)):       #Korrektur schlechter Punkte 
    if y_punkte[i]<min(y_punkte)+0.45*breite and y_punkte[i]>min(y_punkte)+0.01*breite and y_punkte[i]<y_punkte[i+1] and x_punkte[i]>x_punkte[i+1]:      
        y_punkte[i]=y_punkte[i]+0.8*diff      
    if y_punkte[i]>min(y_punkte)+0.55*breite and y_punkte[i]<min(y_punkte)+0.99*breite and y_punkte[i]>y_punkte[i+1] and x_punkte[i]>x_punkte[i+1]:      
        y_punkte[i]=y_punkte[i]-0.8*diff      
    n2 = a.instances['ZR1_instance'].nodes      
    koor_load = x_punkte[i],y_punkte[i],z_punkte[i]    
    nodes1 = n2.getClosest(coordinates=(koor_load ,))      
    x_punkte[i]=n2[nodes1[0].label-1].coordinates[0]     
    y_punkte[i]=n2[nodes1[0].label-1].coordinates[1]     
    z_punkte[i]=n2[nodes1[0].label-1].coordinates[2]

Bonne soirée

[lg_53]

Corrigez moi si je me trompe, mais en entrée vous avez une liste de positions (x,y,z), et en sortie, ce n'est pas une liste triée de positions que vous voulez, mais une matrice de positions non ?

Mais si vous avez en entrée une liste de 13 positions, votre matrice a quelle taille à la fin ? ...

D'autant plus que trier une liste, ca veut dire définir un ordre. Et un ordre se doit d'ordonner, de manière stricte, les points. Vous ne pouvez pas avoir 2 points égaux. Donc si dans votre définition, 2 points peuvent être égaux (dans leur rang) alors vous devez préciser votre règle pour les départager et dire qui sera devant l'autre.

[Sve@r]

Bonjour

Voici ce que j'aimerais obtenir:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 coord = [ [8,2,9],[10,4,12],[7,10,8],
           [4,1,5],[9,3,9],[5,9,4], 
           [1,0,2],[3,1,3],[0,9,1] ]

Méthode de tri souhaité: Y croissant de gauche vers droite / X croissant de bas en haut (afin d'être cohérent par rapport aux référentiel de l'image)

Le souci, c'est que la notion "bas en haut" n'existe pas. Ok tel que tu montres ta matrice on voit que le "X" de chaque groupe placé verticalement est trié "visuellement" mais si on écrit ton tableau ainsi (tel qu'il est réellement en RAM)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 coord = [ [8,2,9], [10,4,12], [7,10,8], [4,1,5], [9,3,9], [5,9,4], [1,0,2], [3,1,3], [0,9,1] ]

la notion de "bas en haut" disparait totalement et il faut trouver une règle un peu plus "mathématique" de tri si tu veux pouvoir ensuite la programmer.

[wiztricks]

Salut,

Quand une solution n'est pas facile à trouver, il serait quand même bon d'expliquer le problème à résoudre (et revalider à quoi ressemblerait une solution quitte à aller demander de l'aide dans les forums algo.).

Pour le reste, je suis d'accord avec lg_53, pour calculer la distance entre 2 points, il faut savoir calculer cette distance... et sur une surface un peu tordue, çà passe par des géométries genre riemannienne où on va avoir des points de courbure locaux et des géodésiques à calculer.

- W

[etiennep17]

Bonsoir,

Merci pour vos réponses rapides !

Corrigez moi si je me trompe, mais en entrée vous avez une liste de positions (x,y,z), et en sortie, ce n'est pas une liste triée de positions que vous voulez, mais une matrice de positions non ?

Oui c'est tout à fait ça.

Mais si vous avez en entrée une liste de 13 positions, votre matrice a quelle taille à la fin ? ...

13 ce n'est pas possible car c'est un nombre premier. Je m'explique: Dans mon cas, j'ai 8 noeuds en hauteur et 34 en largeur, soit 8 lignes et 34 colonnes -> je récupère donc 8*34=272 points.
La liste obtenue contient 272 coordonnées différentes et non ordonnées. La matrice souhaitée sera de dimension 8*34 et contiendra les coordonnées des 272 points de façon à ce qu'on puisse la "superposer" mentalement à la surface étudiée dans l'image de mon premier post. C'est du moins le tri que je cherche à obtenir.

D'autant plus que trier une liste, ca veut dire définir un ordre. Et un ordre se doit d'ordonner, de manière stricte, les points. Vous ne pouvez pas avoir 2 points égaux. Donc si dans votre définition, 2 points peuvent être égaux (dans leur rang) alors vous devez préciser votre règle pour les départager et dire qui sera devant l'autre.

Vous venez de mettre le doigt sur le problème

la notion de "bas en haut" disparait totalement et il faut trouver une règle un peu plus "mathématique" de tri si tu veux pouvoir ensuite la programmer.

Vous avez tout à fait raison. Je n'ai malheureusement pas trouvé d'astuce mathématiques pour y parvenir. J'espérais fortement qu'il existait une fonction toute faite pour gérer ça, mais j'imagine que vous m'en auriez parlé...

Quand une solution n'est pas facile à trouver, il serait quand même bon d'expliquer le problème à résoudre

L'un des intérêts de ce travail est de calculer les déformations de la surface (c'est la surface d'une dent d'engrenage droit). Afin d'obtenir des résultats qui soient compréhensibles visuellement, il faut qu'ils soient triés comme tel afin d'obtenir une comparaison avec la surface sans chargement. De plus, seuls quelques points seront retenues pour le calcul. Ex: si on a 10 col et 4 lignes, seuls les points des colonnes 1, 4, 7, 10 seront conservés. Or pour déterminer à quelle colonne appartient un point, il faut qu'il soit trié.
Par ailleurs, les résultats seront interpolés afin d'obtenir une matrice résultat plus précise. Et on ne peut pas faire d'interpolation si les résultats "voisins" dans la matrice apparaissent comme un non sens physique. Je précise que cette interpolation sera gérée par Matlab (qui lui gère très bien les matrices).
Bon c'est pas évident à expliquer, j'espère avoir été claire.

et revalider à quoi ressemblerait une solution quitte à aller demander de l'aide dans les forums algo

A quels forums faîtes vous allusion ?


Bonne soirée.

[wiztricks]

Salut,

Bon c'est pas évident à expliquer, j'espère avoir été claire.

et revalider à quoi ressemblerait une solution quitte à aller demander de l'aide dans les forums algo

A quels forums faîtes vous allusion ?

Ceux qui sont listés dans la rubrique Algorithmique.

D'autant que votre questionnement semble appartenir aux calculs d'éléments finis qu'on retrouve sur les maillages qu'on fait en CAO/FAO.
Le fameux CATIA de Dassault devrait savoir faire çà.
Vous avez des variants open source (farfouillez du côté d'Open Cascade Technology) qui devraient savoir faire çà.

Ca a demandé des années hommes de recherche et d’ingénierie pour arriver à mettre en forme les problèmes et à en écrire des solutions.

- W

[lg_53]

13 ce n'est pas possible car c'est un nombre premier. Je m'explique: Dans mon cas, j'ai 8 noeuds en hauteur et 34 en largeur, soit 8 lignes et 34 colonnes -> je récupère donc 8*34=272 points.
La liste obtenue contient 272 coordonnées différentes et non ordonnées. La matrice souhaitée sera de dimension 8*34 et contiendra les coordonnées des 272 points

Ok je vois. Donc ca veut dire que déjà en input, vous avez pas juste la liste à triée. Vous avez la liste, et la dimension de la matrice finale souhaitée (dont le produit des dimensions correspond à la longueur de la liste).

L'un des intérêts de ce travail est de calculer les déformations de la surface (c'est la surface d'une dent d'engrenage droit). Afin d'obtenir des résultats qui soient compréhensibles visuellement, il faut qu'ils soient triés comme tel afin d'obtenir une comparaison avec la surface sans chargement. De plus, seuls quelques points seront retenues pour le calcul. Ex: si on a 10 col et 4 lignes, seuls les points des colonnes 1, 4, 7, 10 seront conservés. Or pour déterminer à quelle colonne appartient un point, il faut qu'il soit trié.

Euh là, ca colle pas ce que vous dites. Déjà, si vous souhaitez définir un tri pour ordonner les points de la grille, et bien vous pouvez très bien en définir un tout simple (je trie par rapport à x, puis si les x sont égaux, y départage, et enfin si x et y sont encore égaux, z départage, qui est le tri naturelle sur les tuples/liste en python), car finalement vous vous moquez de la nature du tri, il faut juste que vous soyez capable de trier la surface non déformée, et celle déformée dans le même ordre. Donc là comment le tri est fait, bah on s'en moque.
Mais il y a pire comme incohérence dans votre raisonnement. Si vous avez une déformation un peu cisaillante, ou une torsion. Bah vous pouvez très bien avoir des points qui "passe" devant un autre ! Exemple : A=(0,0), B=(1,1) et à l'arrivée après déformation, A se trouve en (0.7,0.5) et B en (0.6,0.9). Donc là si vous appliquer juste un tri, et bien vous allez commettre une erreur, car le premier point de ma liste de point triée sera A au départ, mais ne sera plus A après déformation !

Après quand on fait des éléments finis, normalement avec notre géométrie on n'a pas que la liste des points. On a aussi justement l'index de ces noeuds et la table de connectivité. Tout ceci normalement doit vous donner le mapping sur le maillage cartésien de référence.

Je précise que cette interpolation sera gérée par Matlab (qui lui gère très bien les matrices).

Numpy aussi gère très bien les matrices, et sa syntaxe est très proche de scilab...

[etiennep17]

Bonjour,

Ceux qui sont listés dans la rubrique Algorithmique.

Je vais aller y faire un tour merci.

D'autant que votre questionnement semble appartenir aux calculs d'éléments finis qu'on retrouve sur les maillages qu'on fait en CAO/FAO.
Le fameux CATIA de Dassault devrait savoir faire çà.
Vous avez des variants open source (farfouillez du côté d'Open Cascade Technology) qui devraient savoir faire çà.

Certes, mais la gestion du tri doit se faire en python donc je pensais pouvoir trouver mon bonheur ici.
En ce qui concerne le logiciel, on m'a imposé l'utilisation d'Abaqus

Ok je vois. Donc ca veut dire que déjà en input, vous avez pas juste la liste à triée. Vous avez la liste, et la dimension de la matrice finale souhaitée (dont le produit des dimensions correspond à la longueur de la liste).

Effectivement, je ne connais pas les dimensions de la matrice à obtenir (puisque le maillage peut être plus ou moins affiné donc avec plus ou moins de lignes et de colonnes)

Euh là, ca colle pas ce que vous dites. Déjà, si vous souhaitez définir un tri pour ordonner les points de la grille, et bien vous pouvez très bien en définir un tout simple (je trie par rapport à x, puis si les x sont égaux, y départage, et enfin si x et y sont encore égaux, z départage, qui est le tri naturelle sur les tuples/liste en python), car finalement vous vous moquez de la nature du tri, il faut juste que vous soyez capable de trier la surface non déformée, et celle déformée dans le même ordre. Donc là comment le tri est fait, bah on s'en moque.

Vous faîtes erreur malheureusement. Je vais tenter d'être un peu plus claire dans mon explication.



Sur cette image, soit une surface dont les points étudiés sont A,B,C,D,E,F. Le schéma est mauvais mais faisons preuve d'imagination: pour y croissant de droite vers gauche, Dy>Ey>Ay>Fy>By>Cy. Il y a donc quelque croisements dans les rangs.

La matrice M2 est la matrice (ou liste) obtenue en brut (non triée)
La matrice M3 est obtenue après avoir trié la matrice M2 selon la méthode que vous préconisez (critère principal: y)
La matrice M1 est la matrice obtenue selon le tri souhaité. Elle se superpose fidèlement à la surface étudiée.

Si l'on applique un effort F au nœud B, celui-ci ainsi que les nœuds aux alentours (donc ici, A et C car les autres nœuds sont assez éloignés) subiront une déformation.
Simplifions: B, A, C subissent déformation, D, E, F ne subissent aucune déformation.

En observant les résultats sur M3 (méthode que vous proposez), on constaterez des déformations principalement "en bas à droite" de la matrice, soit en bas à droite de la surface -> Non conforme à la réalité.
En observant les résultats sur M1 (méthode souhaitée), on constaterez des déformations principalement "en haut" de la matrice, soit en haut de la surface -> Conforme à la réalité.

Mais il y a pire comme incohérence dans votre raisonnement. Si vous avez une déformation un peu cisaillante, ou une torsion. Bah vous pouvez très bien avoir des points qui "passe" devant un autre ! Exemple : A=(0,0), B=(1,1) et à l'arrivée après déformation, A se trouve en (0.7,0.5) et B en (0.6,0.9). Donc là si vous appliquer juste un tri, et bien vous allez commettre une erreur, car le premier point de ma liste de point triée sera A au départ, mais ne sera plus A après déformation !

C'est très bien vu, mais le logiciel associe chaque valeur de déformation calculée aux coordonnées des nœuds initiaux. Ainsi il suffit d'analyser les valeurs de déformations pour estimer à quel point un nœud s'est "déplacé".

Après quand on fait des éléments finis, normalement avec notre géométrie on n'a pas que la liste des points. On a aussi justement l'index de ces noeuds et la table de connectivité. Tout ceci normalement doit vous donner le mapping sur le maillage cartésien de référence.

J'ai pensé également à utiliser les index. Mais en fait la matrice obtenue en input est déjà triée selon les index malheureusement.


Bon je vous remercie encore pour vos réponses rapides et pour votre aide

[lg_53]

Alors je reprends l'exemple des 9 coordonnées de votre premier post. En brut de force je teste toutes les possibilités de mettre ces 9 points dans les 9 cases de la matrice (fictive, car c'est en fait une liste) et je traduis vos conditions sur les ordre en x et y, pour voir quelles sont les possibilités.

Voici le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
import itertools
 
coord = [ [1,0,2],[5,9,4],[4,1,5],
          [6,3,9],[10,4,12],[8,2,9], 
          [0,9,1],[3,1,3],[7,10,8] ]
 
for x in itertools.permutations(coord):
    if all( x[i][1]<=x[i+1][1]<=x[i+2][1] for i in (0,3,6)) : ### croissant selon y, de gauche à droite
        if all(x[j+6][0]<=x[j+3][0]<=x[j][0] for j in (0,1,2)):  ### croissant selon x, de bas en haut
            print(x[:3])
            print(x[3:6])
            print(x[6:])
            print()

Voici le résultat :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
([4, 1, 5], [10, 4, 12], [7, 10, 8])
([3, 1, 3], [8, 2, 9], [5, 9, 4])
([1, 0, 2], [6, 3, 9], [0, 9, 1])
 
([4, 1, 5], [10, 4, 12], [7, 10, 8])
([3, 1, 3], [8, 2, 9], [6, 3, 9])
([1, 0, 2], [5, 9, 4], [0, 9, 1])
 
([4, 1, 5], [10, 4, 12], [7, 10, 8])
([3, 1, 3], [8, 2, 9], [6, 3, 9])
([1, 0, 2], [0, 9, 1], [5, 9, 4])
 
([4, 1, 5], [8, 2, 9], [10, 4, 12])
([3, 1, 3], [6, 3, 9], [7, 10, 8])
([1, 0, 2], [5, 9, 4], [0, 9, 1])
 
([4, 1, 5], [8, 2, 9], [10, 4, 12])
([3, 1, 3], [6, 3, 9], [7, 10, 8])
([1, 0, 2], [0, 9, 1], [5, 9, 4])
 
([6, 3, 9], [10, 4, 12], [7, 10, 8])
([4, 1, 5], [8, 2, 9], [5, 9, 4])
([1, 0, 2], [3, 1, 3], [0, 9, 1])
 
([6, 3, 9], [10, 4, 12], [7, 10, 8])
([3, 1, 3], [8, 2, 9], [5, 9, 4])
([1, 0, 2], [4, 1, 5], [0, 9, 1])
 
([8, 2, 9], [6, 3, 9], [10, 4, 12])
([4, 1, 5], [5, 9, 4], [7, 10, 8])
([1, 0, 2], [3, 1, 3], [0, 9, 1])
 
([8, 2, 9], [6, 3, 9], [10, 4, 12])
([4, 1, 5], [3, 1, 3], [7, 10, 8])
([1, 0, 2], [0, 9, 1], [5, 9, 4])
 
([8, 2, 9], [6, 3, 9], [10, 4, 12])
([3, 1, 3], [5, 9, 4], [7, 10, 8])
([1, 0, 2], [4, 1, 5], [0, 9, 1])
 
([8, 2, 9], [6, 3, 9], [10, 4, 12])
([3, 1, 3], [4, 1, 5], [7, 10, 8])
([1, 0, 2], [0, 9, 1], [5, 9, 4])
 
([8, 2, 9], [10, 4, 12], [7, 10, 8])
([4, 1, 5], [6, 3, 9], [5, 9, 4])
([1, 0, 2], [3, 1, 3], [0, 9, 1])
 
([8, 2, 9], [10, 4, 12], [7, 10, 8])
([4, 1, 5], [3, 1, 3], [6, 3, 9])
([1, 0, 2], [0, 9, 1], [5, 9, 4])
 
([8, 2, 9], [10, 4, 12], [7, 10, 8])
([3, 1, 3], [4, 1, 5], [6, 3, 9])
([1, 0, 2], [0, 9, 1], [5, 9, 4])
 
([8, 2, 9], [10, 4, 12], [7, 10, 8])
([3, 1, 3], [6, 3, 9], [5, 9, 4])
([1, 0, 2], [4, 1, 5], [0, 9, 1])

Soit 15 possibilités.
Donc :
1) Inutile de vous dire que si vous avez plus que 9 points, et bien vous allez avoir encore plus de possibilités.
2) Il va falloir préciser comment vous voulez obtenir un ordre de manière univoque, c'est à dire nous donner un critère qui nous conduise à une seule et unique matrice de sortie possible.
3) Tant que 2) n'est pas fait, on ne peut guère vous aider plus.

[wiztricks]

2) Il va falloir préciser comment vous voulez obtenir un ordre de manière univoque, c'est à dire nous donner un critère qui nous conduise à une seule et unique matrice de sortie possible.

Le critère est "on voit bien sur l'image"...

La difficulté est d'arriver à traduire cette perception humaine en algorithme.

Impossible de n'avoir que les indices des points du quadrillage, il faut pouvoir les associer à leur position dans l'espace.

Ce qui est sûr c'est qu'il faut un algo. à chercher sans doute du côté des méthodes aux éléments finis (et si on trouve un truc pour simplifier pourquoi pas mais çà reste un algo. à trouver).

- W

[lg_53]

Le critère est "on voit bien sur l'image"...

Sur l'image il n'y a pas que des points. Il y a des lignes entre ces points. Et ces lignes, vous devez aussi les avoir dans vos données, ca doit correspondre à la table de connectivité des noeuds. Donc moyennant le respect de cette table de connectivité, il est possible qu'on puisse écarter toute les possibilités présentées dans mon précédent posts sauf une, qui sera celle cherchée.