src/INTERPOLATION/MEDMEM_WrapperCells.hxx

   1 #ifndef WRAPPERS_CELLS_HXX
   2 #define WRAPPERS_CELLS_HXX
   3
   4 #include "stdio.h"
   5 #include "stdlib.h"
   6
   7 #include <typeinfo>
   8
   9 #include <vector>
  10 #include <map>
  11
  12 #ifndef FAUX
  13 #define FAUX 0
  14 #endif
  15
  16 #ifndef VRAI
  17 #define VRAI 1
  18 #endif
  19
  20 #ifndef UNDEFINED
  21 #define UNDEFINED -1
  22 #endif
  23
  24 #include "MEDMEM_define.hxx"
  25
  26 #define MAXNBR 10
  27
  28 //////////////////////////////////////////////////////////////////
  29 ///                                                            ///
  30 ///                        DECLARATIONS                        ///
  31 ///                                                            ///
  32 //////////////////////////////////////////////////////////////////
  33
  34 /*********************************************************/
  35 /*                                                       */
  36 /*      Equivalence num modele local => MED              */
  37 /*                                                       */
  38 /*********************************************************/
  39
  40 #define NBR_MODELES_MAILLES_DEFINIS 15
  41 static int Equivalence_Local_MED[NBR_MODELES_MAILLES_DEFINIS] = { MED_EN::MED_POINT1 ,
  42                                                            MED_EN::MED_SEG2   , MED_EN::MED_SEG3,
  43                                                            MED_EN::MED_TRIA3  , MED_EN::MED_TRIA6   , MED_EN::MED_QUAD4 , MED_EN::MED_QUAD8  ,
  44                                                            MED_EN::MED_TETRA4 , MED_EN::MED_TETRA10 , MED_EN::MED_HEXA8 , MED_EN::MED_HEXA20 , MED_EN::MED_PYRA5 , MED_EN::MED_PYRA13 , MED_EN::MED_PENTA6 , MED_EN::MED_PENTA15 };
  45
  46 /*********************************************************/
  47 /*                                                       */
  48 /*           Classe Connectivite_Canonique_Base          */
  49 /*                                                       */
  50 /*********************************************************/
  51
  52 // classe mere des connectivités cannoniques
  53 // N'a aucune méthode virtuelle pour éviter les pertes de temps
  54 // Ce sont les constructeurs des classes dérivées qui renseignent les attributs spécifiques
  55 // un simplexe de base est constitué par un sommet de la maille qui n'est pas contenu dans la face démandée et par trois points de cette face
  56 // Ce simplexe est utilisé dans le calcul des fonctions barycentriques
  57 // LES MAILLES SONT DONC ET PAR CONSEQUENT DES MAILLES A FACES PLANES
  58 // Une face est une face P1, c'est a dire contenant uniquement les sommets, par les noeuds milieux
  59 // Ces faces sont utilisées pour le calcul de connexité
  60
  61
  62 class Connectivite_Canonique_Base
  63 {
  64 protected :
  65         int                   type          ;
  66         int                   nbr_noeuds    ;
  67         int                   nbr_faces     ;
  68         vector<int>           premier_noeud ;
  69         vector< vector<int> > simplexe_base ;
  70         vector< vector<int> > face          ;
  71 public :
  72         inline int                 DONNE_NBR_NOEUDS()                        const { return nbr_noeuds;              }
  73         inline int                 DONNE_NBR_FACES()                         const { return nbr_faces;               }
  74         inline const vector<int> & DONNE_SIMPLEXE_BASE(int num_face)         const { return simplexe_base[num_face]; }
  75         inline const vector<int> & DONNE_FACE(int num_face)                  const { return face[num_face];          }
  76         inline int                 DONNE_PREMIER_NOEUD_DE_FACE(int num_face) const { return premier_noeud[num_face]; }
  77         friend class Wrapper_Maille;
  78 };
  79
  80 /*********************************************************/
  81 /*                                                       */
  82 /*           Classe Connectivite_Canonique_*             */
  83 /*                                                       */
  84 /*********************************************************/
  85
  86 // définies dans la partie CODE
  87 // les constructeurs construisent tous les tableaux de connectivités nécessaires en fonction du MODELE MED
  88
  89 //class Connectivite_Canonique_Point1  : public Connectivite_Canonique_Base;
  90 //class Connectivite_Canonique_Seg2    : public Connectivite_Canonique_Base;
  91 //class Connectivite_Canonique_Seg3    : public Connectivite_Canonique_Base;
  92 //class Connectivite_Canonique_Tria3   : public Connectivite_Canonique_Base;
  93 //class Connectivite_Canonique_Tria6   : public Connectivite_Canonique_Base;
  94 //class Connectivite_Canonique_Quad4   : public Connectivite_Canonique_Base;
  95 //class Connectivite_Canonique_Quad8   : public Connectivite_Canonique_Base;
  96 //class Connectivite_Canonique_Tetra4  : public Connectivite_Canonique_Base;
  97 //class Connectivite_Canonique_Tetra10 : public Connectivite_Canonique_Base;
  98 //class Connectivite_Canonique_Hexa8   : public Connectivite_Canonique_Base;
  99 //class Connectivite_Canonique_Hexa20  : public Connectivite_Canonique_Base;
 100 //class Connectivite_Canonique_Pyra5   : public Connectivite_Canonique_Base;
 101 //class Connectivite_Canonique_Pyra13  : public Connectivite_Canonique_Base;
 102 //class Connectivite_Canonique_Penta6  : public Connectivite_Canonique_Base;
 103 //class Connectivite_Canonique_Penta15 : public Connectivite_Canonique_Base;
 104
 105 /*********************************************************/
 106 /*                                                       */
 107 /*               Classe Connectivite_Generale            */
 108 /*                                                       */
 109 /*********************************************************/
 110
 111 // Cette classe contient toutes les connectivités canoniques, elle est utilisée dans Wrapper_Nuage_Maille
 112
 113 class Connectivite_Generale
 114 {
 115 protected :
 116         vector<Connectivite_Canonique_Base *> AllConn;
 117 public :
 118         Connectivite_Generale();
 119         ~Connectivite_Generale();
 120         // Renvoie la connectivite locale de la maille de numero local de modele i, dont l'equivalent MED est Equivalence_Local_MED[i]
 121         Connectivite_Canonique_Base * operator[](int i) const {return AllConn[i];}
 122 };
 123
 124 /*********************************************************/
 125 /*                                                       */
 126 /*                  Structure type_retour                */
 127 /*                                                       */
 128 /*********************************************************/
 129
 130 // c'est une structure de type petit tableau statique, pour accelerer les acces et eviter les allocations dynamiques
 131
 132 struct type_retour
 133         {
 134         int quoi[MAXNBR];
 135         int combien;
 136         };
 137
 138 /*********************************************************/
 139 /*                                                       */
 140 /*           Fonction Comparaison_Informe(...)           */
 141 /*                                                       */
 142 /*********************************************************/
 143
 144 // renvoie vrai si v1 et v2 contiennent la meme chose et sont de meme tailles, faux sinon
 145
 146 inline int Comparaison_Informe(const type_retour &v1,const type_retour &v2);
 147
 148 /*********************************************************/
 149 /*                                                       */
 150 /*               Classe Wrapper_Maille                   */
 151 /*                                                       */
 152 /*********************************************************/
 153
 154 // c'est le wrapper maille sur int[]
 155 // cette classe n'est pas dérivée, tous les types de mailles sont stockées sous cette forme
 156 // la variable qui définit les type est la Connectivité_Canonique_Base, qui est toujours polymorphée en un type spécifique
 157
 158
 159 class Wrapper_Maille
 160 {
 161 protected :
 162
 163         // la référence du premier sommet
 164         int * sommets;
 165         // la connectivité canonique, toujours polymorphée
 166         Connectivite_Canonique_Base * modele;
 167
 168 public :
 169         Wrapper_Maille():sommets(NULL) {}
 170         ~Wrapper_Maille() {}
 171
 172         // sorte de transtypeur, cette méthode prend une référence vers un premier sommet et un modele canonique et renvoie *this en tant que wrapper sur ces données
 173         inline const Wrapper_Maille & positionne(int * pos, Connectivite_Canonique_Base * mod){sommets=pos;modele=mod;return *this;}
 174         // méthodes de la politique (les numéros renvoyés sont des numéros GLOBAUX, calculés à partir de l'indirection fournie par la connectivité canonique
 175         // par contre les numéros de face fournis sont des numéros locaux
 176         // renvoie le numéro global du sommet de numéro local i
 177         inline int operator[](int i) const {return sommets[i];}
 178         inline int  DONNE_NBR_NOEUDS()                               const;
 179         inline int  DONNE_NBR_FACES()                                const;
 180         inline void DONNE_SIMPLEXE_BASE(int num_face,type_retour & simplexe) const;
 181         inline void DONNE_FACE(int num_face,type_retour & face)              const;
 182         inline int  DONNE_PREMIER_NOEUD_DE_FACE(int num_face)        const;
 183         // pour une face, donne, s'il existe, le numéro local de face équivalente, -1 sinon
 184         inline int  DONNE_NUM_LOC_FACE_EGALE_A_FORMANT(const type_retour & sommets_face) const;
 185         // donne le numéro local de modele
 186         inline int  DONNE_TYPE_MAILLE()     const;
 187         // donne le numéro MED de modele
 188         inline int  DONNE_TYPE_MED_MAILLE() const;
 189 };
 190
 191
 192 /*********************************************************/
 193 /*                                                       */
 194 /*            Classe Wrapper_Nuage_Maille                */
 195 /*                                                       */
 196 /*********************************************************/
 197
 198 // Classe de Wrapping sur un nuage de maille donné sous forme SKYLINE
 199 // voir la classe Wrapper_Med_Connectivity dans MEDMEM_Wrapper_Connectivity.hxx pour la politique de classe
 200
 201 template <class FORME_SKYLINE> class Wrapper_Nuage_Maille
 202 {
 203 protected :
 204         // pointeur sur une forme skyline
 205         FORME_SKYLINE * mailles;
 206         // toutes les connectivités canoniques
 207         Connectivite_Generale ConnGen;
 208         int nbr_mailles;
 209         // ATTENTION, c'est le type en numero local de modele, pour éviter une map, le numéro de modele MED correponsdant est donné par Equivalence_Local_MED
 210         vector<int> types;
 211         // pointeur dans mailles du premier sommet de chaque maille (évite les calculs du au nombres éventuellement différents de sommets par maille)
 212         vector< int * > premier_pointeur;
 213         // maille_courante, est un Wrapper_Maille déja instancié utilisé par l'opérateur [] pour accelerer les acces
 214         Wrapper_Maille maille_courante;
 215 public :
 216         Wrapper_Nuage_Maille():mailles(NULL) {}
 217         // le constructeur renseigne types et premier_pointeur, instantie ConnGenn et positionne maille_courante sur la premiere maille
 218         Wrapper_Nuage_Maille(FORME_SKYLINE * fs);
 219         ~Wrapper_Nuage_Maille() {}
 220         // Méthodes de la politique
 221         // positionne maille_courante sur la maille de numéro global i et renvoie maille_courante
 222         inline const Wrapper_Maille & operator[](int i);
 223         inline int         SIZE() {return nbr_mailles;}
 224         void affiche();
 225 };
 226
 227 //////////////////////////////////////////////////////////////////
 228 ///                                                            ///
 229 ///                            CODE                            ///
 230 ///                                                            ///
 231 //////////////////////////////////////////////////////////////////
 232
 233 /*********************************************************/
 234 /*                                                       */
 235 /*           Fonction Comparaison_Informe(...)           */
 236 /*                                                       */
 237 /*********************************************************/
 238
 239 // effectue le test (v1 et v2 ont meme taille)&&(chaque élément de v1 est dans v2)
 240 // c'est une égalité forte si on est sur que v1 et v2 n'ont pas de doublets,
 241 // ce qui est le cas pour les mailles et les simplexes
 242
 243 int Comparaison_Informe(const type_retour &v1,const type_retour &v2)
 244         {
 245         int t1=v1.combien;
 246         int t2=v2.combien;
 247         if (t1!=t2) return FAUX;
 248         int i1,i2;
 249         int test;
 250         for (i1=0;i1<t1;i1++)
 251                 {
 252                 test=1;
 253                 for (i2=0;(i2<t2)&&(test);i2++)
 254                         {
 255                         if (v1.quoi[i1]==v2.quoi[i2]) test=0;
 256                         }
 257                 if (test) return FAUX;
 258                 }
 259         return VRAI;
 260         }
 261
 262 /*********************************************************/
 263 /*                                                       */
 264 /*               Classe Wrapper_Maille                   */
 265 /*                                                       */
 266 /*********************************************************/
 267
 268 inline int  Wrapper_Maille::DONNE_NBR_NOEUDS()                                       const
 269         {
 270         return modele->DONNE_NBR_NOEUDS();
 271         }
 272 inline int  Wrapper_Maille::DONNE_NBR_FACES()                                        const
 273         {
 274         return modele->DONNE_NBR_FACES();
 275         }
 276 inline void Wrapper_Maille::DONNE_SIMPLEXE_BASE(int num_face,type_retour & simplexe) const
 277         {
 278         const vector<int> & simplexelocal=modele->DONNE_SIMPLEXE_BASE(num_face);
 279         simplexe.combien=simplexelocal.size();
 280         for (int i=0;i<simplexe.combien;i++) simplexe.quoi[i]=sommets[simplexelocal[i]];
 281         }
 282 inline void Wrapper_Maille::DONNE_FACE(int num_face,type_retour & face)               const
 283         {
 284         const vector<int> & facelocal=modele->DONNE_FACE(num_face);
 285         face.combien=facelocal.size();
 286         for (int i=0;i<face.combien;i++) face.quoi[i]=sommets[facelocal[i]];
 287         }
 288 inline int  Wrapper_Maille::DONNE_PREMIER_NOEUD_DE_FACE(int num_face)                const
 289         {
 290         return sommets[modele->DONNE_PREMIER_NOEUD_DE_FACE(num_face)];
 291         }
 292 inline int  Wrapper_Maille::DONNE_NUM_LOC_FACE_EGALE_A_FORMANT(const type_retour & sommets_face) const
 293         {
 294         type_retour face_loc;
 295         int num_face;
 296         for (num_face=0;num_face<DONNE_NBR_FACES();num_face++)
 297                 {
 298                 DONNE_FACE(num_face,face_loc);
 299                 if (Comparaison_Informe(face_loc,sommets_face)) return num_face;
 300                 }
 301         return UNDEFINED;
 302         }
 303 inline int  Wrapper_Maille::DONNE_TYPE_MAILLE()     const
 304         {
 305         return modele->type;
 306         }
 307 inline int  Wrapper_Maille::DONNE_TYPE_MED_MAILLE() const
 308         {
 309         return Equivalence_Local_MED[modele->type];
 310         }
 311
 312
 313 /*********************************************************/
 314 /*                                                       */
 315 /*            Classe Wrapper_Nuage_Maille                */
 316 /*                                                       */
 317 /*********************************************************/
 318
 319 template <class FORME_SKYLINE>  Wrapper_Nuage_Maille<FORME_SKYLINE>::Wrapper_Nuage_Maille(FORME_SKYLINE * fs):mailles(fs)
 320                 {
 321                 int i;
 322                 map<int,int> Equivalence_MED_Local;
 323                 // calcule la map de convertion des types med en numéro local, pour accelerer l'acces
 324                 for (i=0;i<NBR_MODELES_MAILLES_DEFINIS;i++) Equivalence_MED_Local[Equivalence_Local_MED[i]]=i;
 325                 nbr_mailles=mailles->SIZE();
 326                 types.resize(nbr_mailles);
 327                 premier_pointeur.resize(nbr_mailles);
 328                 for (i=0;i<nbr_mailles;i++)
 329                         {
 330                         types[i]=Equivalence_MED_Local[mailles->DONNE_TYPE_MAILLE(i)];
 331                         premier_pointeur[i]=mailles->DONNE_PREMIER_POINTEUR(i);
 332                         }
 333                 maille_courante.positionne(premier_pointeur[0],ConnGen[types[0]]);
 334                 }
 335 template <class FORME_SKYLINE> const Wrapper_Maille & Wrapper_Nuage_Maille<FORME_SKYLINE>::operator[](int i)
 336                 {
 337                 return maille_courante.positionne(premier_pointeur[i],ConnGen[types[i]]);
 338                 }
 339 template <class FORME_SKYLINE> void Wrapper_Nuage_Maille<FORME_SKYLINE>::affiche()
 340                 {
 341                 int i,j;
 342                 for (i=0;i<nbr_mailles;i++)
 343                         {
 344                         cout<<"Maille "<<i<<" MED "<<Equivalence_Local_MED[types[i]]<<" : "<<flush;
 345                         for (j=0;j<(*this)[i].DONNE_NBR_NOEUDS();j++) cout<<(*this)[i][j]<<" "<<flush;
 346                         cout<<endl;
 347                         }
 348                 }
 349
 350 /*********************************************************/
 351 /*                                                       */
 352 /*           Classe Connectivite_Canonique_Point1        */
 353 /*                                                       */
 354 /*********************************************************/
 355
 356 class Connectivite_Canonique_Point1  : public Connectivite_Canonique_Base
 357 {
 358 public :
 359         Connectivite_Canonique_Point1()
 360                 {
 361
 362                 type=0;
 363
 364                 nbr_noeuds = 1;
 365                 nbr_faces = 0;
 366
 367                 premier_noeud = vector<int>(0);
 368
 369                 simplexe_base = vector< vector<int> >(nbr_faces);
 370                 face          = vector< vector<int> >(nbr_faces);
 371
 372                 }
 373         ~Connectivite_Canonique_Point1() {}
 374 };
 375
 376 /*********************************************************/
 377 /*                                                       */
 378 /*           Classe Connectivite_Canonique_Seg2          */
 379 /*                                                       */
 380 /*********************************************************/
 381
 382 class Connectivite_Canonique_Seg2    : public Connectivite_Canonique_Base
 383 {
 384 public :
 385         Connectivite_Canonique_Seg2()
 386                 {
 387
 388                 type=1;
 389
 390                 int pn[2] = {0,1};
 391                 int sb[4] = {1,0,0,1};
 392                 int fa[2] = {0,1};
 393                 int po[3] = {0,1,2};
 394
 395                 nbr_noeuds = 2;
 396                 nbr_faces = 2;
 397
 398
 399                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 400
 401                 simplexe_base = vector< vector<int> >(nbr_faces);
 402                 face          = vector< vector<int> >(nbr_faces);
 403
 404                 int i;
 405
 406                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[2*i],&sb[2*(i+1)]);
 407                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 408
 409                 }
 410         ~Connectivite_Canonique_Seg2() {}
 411 };
 412 /*********************************************************/
 413 /*                                                       */
 414 /*           Classe Connectivite_Canonique_Seg3          */
 415 /*                                                       */
 416 /*********************************************************/
 417
 418 class Connectivite_Canonique_Seg3    : public Connectivite_Canonique_Base
 419 {
 420 public :
 421         Connectivite_Canonique_Seg3()
 422                 {
 423
 424                 type=2;
 425
 426                 int pn[2] = {0,1};
 427                 int sb[4] = {1,0,0,1};
 428                 int fa[2] = {0,1};
 429                 int po[3] = {0,1,2};
 430
 431                 nbr_noeuds = 3;
 432                 nbr_faces = 2;
 433
 434
 435                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 436
 437                 simplexe_base = vector< vector<int> >(nbr_faces);
 438                 face          = vector< vector<int> >(nbr_faces);
 439
 440                 int i;
 441
 442                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[2*i],&sb[2*(i+1)]);
 443                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 444
 445                 }
 446         ~Connectivite_Canonique_Seg3() {}
 447 };
 448
 449
 450 /*********************************************************/
 451 /*                                                       */
 452 /*           Classe Connectivite_Canonique_Tria3         */
 453 /*                                                       */
 454 /*********************************************************/
 455
 456 class Connectivite_Canonique_Tria3 : public Connectivite_Canonique_Base
 457 {
 458 public :
 459         Connectivite_Canonique_Tria3()
 460                 {
 461
 462                 type=3;
 463
 464                 int pn[3] = {0,1,2};
 465                 int sb[9] = {2,0,1,0,1,2,1,2,0};
 466                 int fa[6] = {0,1,1,2,2,0};
 467                 int po[4] = {0,2,4,6};
 468                 nbr_noeuds = 3;
 469                 nbr_faces = 3;
 470
 471
 472                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 473
 474                 simplexe_base = vector< vector<int> >(nbr_faces);
 475                 face          = vector< vector<int> >(nbr_faces);
 476
 477                 int i;
 478
 479                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[3*i],&sb[3*(i+1)]);
 480                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 481
 482                 }
 483         ~Connectivite_Canonique_Tria3() {}
 484 };
 485
 486 /*********************************************************/
 487 /*                                                       */
 488 /*           Classe Connectivite_Canonique_Tria6         */
 489 /*                                                       */
 490 /*********************************************************/
 491
 492 class Connectivite_Canonique_Tria6 : public Connectivite_Canonique_Base
 493 {
 494 public :
 495         Connectivite_Canonique_Tria6()
 496                 {
 497
 498                 type=4;
 499
 500                 int pn[3] = {0,1,2};
 501                 int sb[9] = {2,0,1,0,1,2,1,2,0};
 502                 int fa[6] = {0,1,1,2,2,0};
 503                 int po[4] = {0,2,4,6};
 504                 nbr_noeuds = 6;
 505                 nbr_faces = 3;
 506
 507
 508                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 509
 510                 simplexe_base = vector< vector<int> >(nbr_faces);
 511                 face          = vector< vector<int> >(nbr_faces);
 512
 513                 int i;
 514
 515                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[3*i],&sb[3*(i+1)]);
 516                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 517
 518                 }
 519         ~Connectivite_Canonique_Tria6() {}
 520 };
 521
 522 /*********************************************************/
 523 /*                                                       */
 524 /*           Classe Connectivite_Canonique_Quad4         */
 525 /*                                                       */
 526 /*********************************************************/
 527
 528 class Connectivite_Canonique_Quad4 : public Connectivite_Canonique_Base
 529 {
 530 public :
 531         Connectivite_Canonique_Quad4()
 532                 {
 533
 534                 type=5;
 535
 536                 int pn[4] = {0,1,2,3};
 537                 int sb[12] = {2,0,1,3,1,2,0,2,3,1,0,2};
 538                 int fa[8] = {0,1,1,2,2,3,3,0};
 539                 int po[5] = {0,2,4,6,8};
 540                 nbr_noeuds = 4;
 541                 nbr_faces = 4;
 542
 543
 544                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 545
 546                 simplexe_base = vector< vector<int> >(nbr_faces);
 547                 face          = vector< vector<int> >(nbr_faces);
 548
 549                 int i;
 550
 551                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[3*i],&sb[3*(i+1)]);
 552                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 553
 554                 }
 555         ~Connectivite_Canonique_Quad4() {}
 556 };
 557
 558
 559 /*********************************************************/
 560 /*                                                       */
 561 /*           Classe Connectivite_Canonique_Quad8         */
 562 /*                                                       */
 563 /*********************************************************/
 564
 565 class Connectivite_Canonique_Quad8 : public Connectivite_Canonique_Base
 566 {
 567 public :
 568         Connectivite_Canonique_Quad8()
 569                 {
 570
 571                 type=6;
 572
 573                 int pn[4] = {0,1,2,3};
 574                 int sb[12] = {2,0,1,3,1,2,0,2,3,1,0,2};
 575                 int fa[8] = {0,1,1,2,2,3,3,0};
 576                 int po[5] = {0,2,4,6,8};
 577                 nbr_noeuds = 8;
 578                 nbr_faces = 4;
 579
 580
 581                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 582
 583                 simplexe_base = vector< vector<int> >(nbr_faces);
 584                 face          = vector< vector<int> >(nbr_faces);
 585
 586                 int i;
 587
 588                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[3*i],&sb[3*(i+1)]);
 589                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 590
 591                 }
 592         ~Connectivite_Canonique_Quad8() {}
 593 };
 594
 595 /*********************************************************/
 596 /*                                                       */
 597 /*           Classe Connectivite_Canonique_Tetra4        */
 598 /*                                                       */
 599 /*********************************************************/
 600
 601 class Connectivite_Canonique_Tetra4 : public Connectivite_Canonique_Base
 602 {
 603 public :
 604         Connectivite_Canonique_Tetra4()
 605                 {
 606
 607                 type=7;
 608
 609                 int pn[4] = {0,0,1,2};
 610                 int sb[16] = {3,0,1,2,2,0,3,1,0,1,3,2,1,2,3,0};
 611                 int fa[12] = {0,1,2,0,3,1,1,3,2,2,3,0};
 612                 int po[5] = {0,3,6,9,12};
 613                 nbr_noeuds = 4;
 614                 nbr_faces = 4;
 615
 616
 617                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 618
 619                 simplexe_base = vector< vector<int> >(nbr_faces);
 620                 face          = vector< vector<int> >(nbr_faces);
 621
 622                 int i;
 623
 624                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
 625                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 626
 627                 }
 628         ~Connectivite_Canonique_Tetra4() {}
 629 };
 630
 631 /*********************************************************/
 632 /*                                                       */
 633 /*          Classe Connectivite_Canonique_Tetra10        */
 634 /*                                                       */
 635 /*********************************************************/
 636
 637 class Connectivite_Canonique_Tetra10 : public Connectivite_Canonique_Base
 638 {
 639 public :
 640         Connectivite_Canonique_Tetra10()
 641                 {
 642
 643                 type=8;
 644
 645                 int pn[4] = {0,0,1,2};
 646                 int sb[16] = {3,0,1,2,2,0,3,1,0,1,3,2,1,2,3,0};
 647                 int fa[12] = {  0,1,2,  0,3,1,  1,3,2,  2,3,0};
 648                 int po[5] = {0,3,6,9,12};
 649
 650                 nbr_noeuds = 10;
 651                 nbr_faces = 4;
 652
 653
 654                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 655
 656                 simplexe_base = vector< vector<int> >(nbr_faces);
 657                 face          = vector< vector<int> >(nbr_faces);
 658
 659                 int i;
 660
 661                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
 662                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 663
 664                 }
 665         ~Connectivite_Canonique_Tetra10() {}
 666 };
 667
 668 /*********************************************************/
 669 /*                                                       */
 670 /*           Classe Connectivite_Canonique_Hexa8         */
 671 /*                                                       */
 672 /*********************************************************/
 673
 674 class Connectivite_Canonique_Hexa8 : public Connectivite_Canonique_Base
 675 {
 676 public :
 677         Connectivite_Canonique_Hexa8()
 678                 {
 679
 680                 type=9;
 681
 682                 int pn[6] = {0,4,0,1,2,3};
 683                 int sb[24] = {5,0,1,2,0,7,6,5,3,0,4,5,4,1,5,6,1,2,6,3,2,3,7,0};
 684                 int fa[24] = {0,1,2,3,4,5,6,7,0,4,5,1,1,5,6,2,2,6,7,3,3,7,4,0};
 685                 int po[7] = {0,4,8,12,16,20,24};
 686                 nbr_noeuds = 8;
 687                 nbr_faces = 6;
 688
 689
 690                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 691
 692                 simplexe_base = vector< vector<int> >(nbr_faces);
 693                 face          = vector< vector<int> >(nbr_faces);
 694
 695                 int i;
 696
 697                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
 698                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 699
 700                 }
 701         ~Connectivite_Canonique_Hexa8() {}
 702 };
 703
 704 /*********************************************************/
 705 /*                                                       */
 706 /*           Classe Connectivite_Canonique_Hexa20        */
 707 /*                                                       */
 708 /*********************************************************/
 709
 710 class Connectivite_Canonique_Hexa20 : public Connectivite_Canonique_Base
 711 {
 712 public :
 713         Connectivite_Canonique_Hexa20()
 714                 {
 715
 716                 type=10;
 717
 718                 int pn[6] = {0,4,0,1,2,3};
 719                 int sb[24] = {5,0,1,2,0,7,6,5,3,0,4,5,4,1,5,6,1,2,6,3,2,3,7,0};
 720                 int fa[24] = {0,1,2,3,4,5,6,7,0,4,5,1,1,5,6,2,2,6,7,3,3,7,4,0};
 721                 int po[7] = {0,4,8,12,16,20,24};
 722                 nbr_noeuds = 20;
 723                 nbr_faces = 6;
 724
 725
 726                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 727
 728                 simplexe_base = vector< vector<int> >(nbr_faces);
 729                 face          = vector< vector<int> >(nbr_faces);
 730
 731                 int i;
 732
 733                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
 734                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 735
 736                 }
 737         ~Connectivite_Canonique_Hexa20() {}
 738 };
 739
 740 /*********************************************************/
 741 /*                                                       */
 742 /*           Classe Connectivite_Canonique_Pyra5         */
 743 /*                                                       */
 744 /*********************************************************/
 745
 746 class Connectivite_Canonique_Pyra5 : public Connectivite_Canonique_Base
 747 {
 748 public :
 749         Connectivite_Canonique_Pyra5()
 750                 {
 751
 752                 type=11;
 753
 754                 int pn[5] = {0,0,1,2,3};
 755                 int sb[20] = {4,0,1,2,3,0,4,1,0,1,4,2,1,2,4,3,2,0,3,4};
 756                 int fa[16] = {0,1,2,3,0,4,1,1,4,2,2,4,3,3,4,0};
 757                 int po[6] = {0,4,7,10,13,16};
 758                 nbr_noeuds = 5;
 759                 nbr_faces = 5;
 760
 761
 762                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 763
 764                 simplexe_base = vector< vector<int> >(nbr_faces);
 765                 face          = vector< vector<int> >(nbr_faces);
 766
 767                 int i;
 768
 769                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
 770                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 771
 772                 }
 773         ~Connectivite_Canonique_Pyra5() {}
 774 };
 775
 776 /*********************************************************/
 777 /*                                                       */
 778 /*           Classe Connectivite_Canonique_Pyra13        */
 779 /*                                                       */
 780 /*********************************************************/
 781
 782 class Connectivite_Canonique_Pyra13 : public Connectivite_Canonique_Base
 783 {
 784 public :
 785         Connectivite_Canonique_Pyra13()
 786                 {
 787
 788                 type=12;
 789
 790                 int pn[5] = {0,0,1,2,3};
 791                 int sb[20] = {4,0,1,2,3,0,4,1,0,1,4,2,1,2,4,3,2,0,3,4};
 792                 int fa[16] = {0,1,2,3,0,4,1,1,4,2,2,4,3,3,4,0};
 793                 int po[6] = {0,4,7,10,13,16};
 794                 nbr_noeuds = 13;
 795                 nbr_faces = 5;
 796
 797
 798                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 799
 800                 simplexe_base = vector< vector<int> >(nbr_faces);
 801                 face          = vector< vector<int> >(nbr_faces);
 802
 803                 int i;
 804
 805                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
 806                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 807
 808                 }
 809         ~Connectivite_Canonique_Pyra13() {}
 810 };
 811
 812 /*********************************************************/
 813 /*                                                       */
 814 /*           Classe Connectivite_Canonique_Penta6        */
 815 /*                                                       */
 816 /*********************************************************/
 817
 818 class Connectivite_Canonique_Penta6 : public Connectivite_Canonique_Base
 819 {
 820 public :
 821         Connectivite_Canonique_Penta6()
 822                 {
 823
 824                 type=13;
 825
 826                 int pn[5] = {0,3,0,1,2};
 827                 int sb[20] = {3,0,1,2,2,3,4,5,5,0,3,1,0,1,4,2,1,2,5,0};
 828                 int fa[18] = {0,1,2,3,4,5,0,3,4,1,1,4,5,2,2,5,3,1};
 829                 int po[6] = {0,3,6,10,14,18};
 830                 nbr_noeuds = 6;
 831                 nbr_faces = 5;
 832
 833
 834                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 835
 836                 simplexe_base = vector< vector<int> >(nbr_faces);
 837                 face          = vector< vector<int> >(nbr_faces);
 838
 839                 int i;
 840
 841                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
 842                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 843
 844                 }
 845         ~Connectivite_Canonique_Penta6() {}
 846 };
 847
 848 /*********************************************************/
 849 /*                                                       */
 850 /*           Classe Connectivite_Canonique_Penta15       */
 851 /*                                                       */
 852 /*********************************************************/
 853
 854 class Connectivite_Canonique_Penta15 : public Connectivite_Canonique_Base
 855 {
 856 public :
 857         Connectivite_Canonique_Penta15()
 858                 {
 859
 860                 type=14;
 861
 862                 int pn[5] = {0,3,0,1,2};
 863                 int sb[20] = {3,0,1,2,2,3,4,5,5,0,3,1,0,1,4,2,1,2,5,0};
 864                 int fa[18] = {0,1,2,3,4,5,0,3,4,1,1,4,5,2,2,5,3,1};
 865                 int po[6] = {0,3,6,10,14,18};
 866                 nbr_noeuds = 15;
 867                 nbr_faces = 5;
 868
 869
 870                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 871
 872                 simplexe_base = vector< vector<int> >(nbr_faces);
 873                 face          = vector< vector<int> >(nbr_faces);
 874
 875                 int i;
 876
 877                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
 878                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 879
 880                 }
 881         ~Connectivite_Canonique_Penta15() {}
 882 };
 883
 884 /*********************************************************/
 885 /*                                                       */
 886 /*               Classe Connectivite_Generale            */
 887 /*                                                       */
 888 /*********************************************************/
 889
 890 inline Connectivite_Generale::Connectivite_Generale():AllConn(NBR_MODELES_MAILLES_DEFINIS)
 891         {
 892         // l'ordre est important, il dépend de la relation entre numéro local et modele et numéro MED
 893         AllConn[ 0]=new Connectivite_Canonique_Point1  ();
 894         AllConn[ 1]=new Connectivite_Canonique_Seg2    ();
 895         AllConn[ 2]=new Connectivite_Canonique_Seg3    ();
 896         AllConn[ 3]=new Connectivite_Canonique_Tria3   ();
 897         AllConn[ 4]=new Connectivite_Canonique_Tria6   ();
 898         AllConn[ 5]=new Connectivite_Canonique_Quad4   ();
 899         AllConn[ 6]=new Connectivite_Canonique_Quad8   ();
 900         AllConn[ 7]=new Connectivite_Canonique_Tetra4  ();
 901         AllConn[ 8]=new Connectivite_Canonique_Tetra10 ();
 902         AllConn[ 9]=new Connectivite_Canonique_Hexa8   ();
 903         AllConn[10]=new Connectivite_Canonique_Hexa20  ();
 904         AllConn[11]=new Connectivite_Canonique_Pyra5   ();
 905         AllConn[12]=new Connectivite_Canonique_Pyra13  ();
 906         AllConn[13]=new Connectivite_Canonique_Penta6  ();
 907         AllConn[14]=new Connectivite_Canonique_Penta15 ();
 908         }
 909 inline Connectivite_Generale::~Connectivite_Generale()
 910         {
 911         for (int i=0;i<AllConn.size();i++) delete AllConn[i];
 912         }
 913
 914
 915 #endif