Discussion :

[dianbobo]

bonjour

voilà , ici je vous présente , le problème que je dois résoudre ,
en gros j'ai un maillage à faire , il y a deux fichiers , le premier contient des points(noeuds) et chaque point a deux coordonnés . le second donne un tableau de triangle(chaque triangle est appelé élément) , dont chacun des point représente"un point du premier tableau"
chaque élément passe donc par 3 noeuds
chaque noeud a 2 coordonnées
comment créer une table de connectivité entre chaque élément(triangle) et les noeuds qui le forment
puis un tableau de connectivité entre chaque noeud et ses coordonnées ?
si quelqu'un a une premiere idée ,

merci d avance

[Steph_ng8]

Bonsoir,
Si j'ai bien compris, tu veux, à partir d'un élément, retrouver les nœuds qui le composent, et à partir d'un nœud, retrouver les éléments dans lesquels il intervient.

Déjà, chaque élément devrait connaître tous les nœuds qui le composent, donc dans ce cas là je ne vois pas vraiment le problème.
Enfin, tout dépend de ta représentation, mais conceptuellement, je ne vois pas de raison pour qu'il en soit autrement.

Pour l'autre sens, je créerais un tableau associatif (dont les clés sont les nœuds et les valeurs sont les éléments) que je remplirais au fur et à mesure que les éléments sont construits.

Une autre méthode serait de mettre un attribut membre dans la classe des nœuds qui aurait pour rôle de garder une référence vers les éléments impliqués.
L'avantage de cette méthode est que, si elle est bien implémentée, le tableau se remplit tout seul en fonction des créations et destructions d'éléments.

Mais encore une fois, tout dépend de ton implémentation, et ce que tu veux faire exactement avec ces « tables d'association ».
Pourrais-tu mettre un peu de code et donner quelques précisions, s'il-te-plaît ?

Cordialement.

[dianbobo]

voilà je vous présente un exemple
j'ai un premier fichier
qui se présente comme ci-dessous(les noeuds)
"fichier2"

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
30  2  0  1
   1    1  0    1
   2    0.80901699999999999  0.587785    1
   3    0.30901699999999999  0.95105700000000004    1
   4    -0.30901699999999999  0.95105700000000004    1
   5    -0.80901699999999999  0.587785    1
   6    -1  3.5897899999999999e-09    1
   7    -0.80901699999999999  -0.587785    1
   8    -0.30901699999999999  -0.95105700000000004    1
   9    0.30901699999999999  -0.95105700000000004    1
  10    0.80901699999999999  -0.587785    1
  11    3  0    2
  12    2.4270499999999999  1.76336    2
  13    0.92705099999999996  2.85317    2
  14    -0.92705099999999996  2.85317    2
  15    -2.4270499999999999  1.76336    2
  16    -3  1.07694e-08    2
  17    -2.4270499999999999  -1.76336    2
  18    -0.92705099999999996  -2.85317    2
  19    0.92705099999999996  -2.85317    2
  20    2.4270499999999999  -1.76336    2
  21    -1.8470647354641934  -0.60014770447655841    0
  22    -1.1415502165304945  -1.5712075628654207    0
  23    -1.1415502165304945  1.5712075628654207    0
  24    0  1.9421197131879349    0
  25    -1.8470647239512119  0.60014770806634843    0
  26    1.1415502165304945  -1.5712075628654207    0
  27    1.8470647297077027  -0.60014770627145331    0
  28    0  -1.9421197131879349    0
  29    1.1415502165304945  1.5712075628654207    0
  30    1.8470647297077027  0.60014770627145331    0

et celui là (les éléments):
"fichier1"

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
40  3  0
   1       6    25    21
   2       6    21     7
   3      21    22     7
   4      19    26    28
   5      24    23     4
   6       7    22     8
   7      12    13    29
   8      13    14    24
   9      23    25     5
  10      21    25    16
  11      23    15    25
  12      23     5     4
  13      22    21    17
  14       4     3    24
  15       6     5    25
  16      15    16    25
  17      28    22    18
  18      24    29    13
  19      14    15    23
  20       9    26    10
  21      27     1    10
  22      22    28     8
  23      27    11    30
  24      26    20    27
  25       8    28     9
  26      17    18    22
  27      30    29     2
  28      16    17    21
  29       2    29     3
  30       2     1    30
  31      26    27    10
  32      19    20    26
  33      27    30     1
  34      14    23    24
  35      20    11    27
  36      29    24     3
  37      18    19    28
  38      28    26     9
  39      11    12    30
  40      29    30    12

le principe est le suivant :

pour le "fichier1":
la premiere ligne contient le nombre d’éléments de ton maillage, la geometrie (3=triangle) et le milieu
l'idée est de faire une boucle sur le nombre d'éléments de lire le fichier (avec fscanf) pour créer la table de connectivité c'est grosso modo un tableau qui associe au numero d'un élement les numeros des noeuds associés.

Pour le "fichier2" :
meme chose que pour le fichier1 sauf que la premier ligne contien le nombre de noeuds, la dimension (ici 2) une condition 1 et une condition 2.
il faut faire une boucle sur le nombre de noeuds pour créer un tableau qui associe au n° du noeuds ses coordonnées et la conditions.

comment faire ça ? je veux des idées , pour que pas une méthode pour que je puisse commencer mon code(je ne sais pas bien comment commencer le code ) c'est ma première fois de faire du c++

merci bien

[koala01]

Salut,

Comme chaque noeud est identifiable de manière unique au travers de la première valeur que l'on récupère dans le fichier, je te proposerais volontiers de travailler en deux classes pour les noeuds:

Une classe "Coordonnee" qui contient simplement les coordonnées du noeud, qui a sémantique de valeur, sous la forme de

Code :

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

1
2
3
4
5
6
7
8
9
10
class Coordonnee
{
    public:
        Coordonnee(double x, double y):x_(x),y(y){}
        double x() const{return x_;}
        double y() const{return y_;}
    private:
        double x_;
        double y_; 
};

et une classe "Noeud", dont la responsabilité sera de créer la relation entre l'identifiant unique et la coordonnée correspondante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class Noeud
{
    public:
        Noeud(int ind, double x, double y):index_(ind),coord_(x,y){}
        int index() const {return index_;}
        double x() const{return coord_.x();}
        double y() const{return coord_.y();}
    private:
        int index_;
        Coordonnee coord_;
};

Cette deuxième classe sera avantageusement complétée par les opérateurs < et == en fonction libre, car ce sont les deux fonctions qui nous permettront de trier et de retrouver le noeud au départ de son index.

Elles prendront la forme de

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
inline bool operator <(Noeud const & first, Noeud const & second)
{
    return first.index() < second.index();
}
inline bool operator ==(Noeud const & first, Noeud const & second)
{
    return first.index() == second.index();
}
inline bool operator <(Noeud const & first, int index)
{
    return first.index() < index;
}
inline bool operator ==(Noeud const & first, int index )
{
    return first.index() == index;
}

De cette manière, tu peux gérer l'ensemble des noeuds avec un "simple" set (ou un vector), sous la forme de std::vector<Noeud> tab; ou de [CODEINLINE]std::set<Noeud> list[CODEINLINE] en fonction de l'évolution éventuelle de la liste des noeud (le set sera préférable si les noeuds ne changent pas, le vector si il est question, à terme, de modifier certains noeuds sous certaines circonstances )

Pour la gestion des triangles, nous partirions sur le même principe:
Une classe Triangle dont la responsabilité est de gérer les index des noeuds qui les composent

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
class Triangle
{
    public:
        Triangle(int first, int second, int third):first_(first),second_(second),third_(third){}
        int firstIndex() const{return first_;}
        int secondIndex() const{return second_;}
        int thirdInedex() const{return third_;}
        bool useNode(int ind) const
        {
            return first_ == ind || second_ == ind || third_ == ind;
        }
    private:
        int first_;
        int second_;
        int third_;
};

et une classe Element dont la responsabilité est de faire correspondre un index avec un triangle:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
class Element
{
    public:
        Element(int index, int first, int second, int third):index_(index),elem_(first,second, third){}
        int index() const{return index_;}
        int firstAngle() const{return elem_.firstIndex();}
        int secondAngle() const{return elem_.secondIndex();}
        int thirdAngle() const{return elem_.thirdIndex();}
        bool useNode(int ind) const{return elem_.useNode(ind);}
    private:
        int index_;
        Triangle elem_;
};

Cette classe sera également avantageusement complétée par les opérateur < et == permettant de déterminer si nous avons bien affaire à un noeud donné sur base de son index :

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
inline bool operator <(Elementconst & first, Elementconst & second)
{
    return first.index() < second.index();
}
inline bool operator ==(Elementconst & first, Noeud Element& second)
{
    return first.index() == second.index();
}
inline bool operator <(Elementconst & first, int index)
{
    return first.index() < index;
}
inline bool operator ==(Elementconst & first, int index)
{
    return first.index() == index;
}

De cette manière, tu pourras gérer les éléments de manière similaire à celle que j'ai expliquée pour les Noeuds

S'il te faut la possibilité de gérer l'ensemble des éléments dans lesquels apparait un noeud donné, il est toujours possible de gérer une map dont la clé est l'index du noeud en question et dont la valeur est un tableau des indexes des éléments dans lesquels il apparait, sous la forme de std::map<int, std::vector<int> > lalist;Le remplissage de cette map pourrait s'effectuer sous une forme proche de

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
void addNodeRelation(std::map<int, std::vector<int> & list, Element const & elem)
{
    int count = 0;
    for(std::map<int, std::vector<int> >::iterator it=list.begin();
        it!=list.end();++it)
    {
        count = 0;
        if(elem == it->first)
        {
            it->second.push_back(elem.index()) ;
            ++ count;
        }
    }
    /* normalement, count doit etre égal à 3 car on doit avoir ajouté l'index 
     * à chacun des noeuds correspondant
     *
     * Si ce n'est pas le cas, il faut trouver le(s) noeud(s) qui n'apparaissent
     * pas encore dans la map
     */
    if(count == 3)
        return;
    if(list.find(elem.firstAngle() == list.end())
    {
        std::vector<int> tab;
        tab.push_back(elem.index());
        list.insert(std::make_pair(elem.firstAngle(),elem.index());
    }
 
    if(list.find(elem.firstAngle() == list.end())
    {
        std::vector<int> tab;
        tab.push_back(elem.index());
        list.insert(std::make_pair(elem.firstAngle(),elem.index());
    }
    if(list.find(elem.secondAngle() == list.end())
    {
        std::vector<int> tab;
        tab.push_back(elem.index());
        list.insert(std::make_pair(elem.secondAngle(),elem.index());
    }
    if(list.find(elem.thirdAngle() == list.end())
    {
        std::vector<int> tab;
        tab.push_back(elem.index());
        list.insert(std::make_pair(elem.thirdAngle(),elem.index());
    }
}

(il faudrait même, idéalement, factoriser l'ajout des éléments dans la map, mais ainsi, on voit exactement ce qui se fait )

Avec tout cela, tu devrais être capable de faire toutes les relations entre tes éléments et tes noeuds

[Steph_ng8]

+1

Personnellement, j'aurais fait disparaître les index.
Enfin sauf s'il y a un réel intérêt de les garder.

[koala01]

+1

Personnellement, j'aurais fait disparaître les index.
Enfin sauf s'il y a un réel intérêt de les garder.

Ben, je me dis que c'est surement le critère discriminant le plus intéressant à utiliser, du moins si l'on est sur que, au pire, la modification des coordonnées d'un noeud ne provoque pas de changement au niveau de l'index

Cela permet d'ailleurs de pouvoir avoir une idée particulièrement précise de l'ensemble des modifications qui peuvent être apportées aux différents éléments et aux triangles si l'on décide, par exemple, de modifier les coordonnées correspondant au noeud 15