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         int taille_face_exam;
 297         int test=FAUX;
 298         for (num_face=0;num_face<DONNE_NBR_FACES();num_face++)
 299                 {
 300                 DONNE_FACE(num_face,face_loc);
 301                 if (Comparaison_Informe(face_loc,sommets_face)) return num_face;
 302                 }
 303         return UNDEFINED;
 304         }
 305 inline int  Wrapper_Maille::DONNE_TYPE_MAILLE()     const
 306         {
 307         return modele->type;
 308         }
 309 inline int  Wrapper_Maille::DONNE_TYPE_MED_MAILLE() const
 310         {
 311         return Equivalence_Local_MED[modele->type];
 312         }
 313
 314
 315 /*********************************************************/
 316 /*                                                       */
 317 /*            Classe Wrapper_Nuage_Maille                */
 318 /*                                                       */
 319 /*********************************************************/
 320
 321 template <class FORME_SKYLINE>  Wrapper_Nuage_Maille<FORME_SKYLINE>::Wrapper_Nuage_Maille(FORME_SKYLINE * fs):mailles(fs)
 322                 {
 323                 int i;
 324                 map<int,int> Equivalence_MED_Local;
 325                 // calcule la map de convertion des types med en numéro local, pour accelerer l'acces
 326                 for (i=0;i<NBR_MODELES_MAILLES_DEFINIS;i++) Equivalence_MED_Local[Equivalence_Local_MED[i]]=i;
 327                 nbr_mailles=mailles->SIZE();
 328                 types.resize(nbr_mailles);
 329                 premier_pointeur.resize(nbr_mailles);
 330                 for (i=0;i<nbr_mailles;i++)
 331                         {
 332                         types[i]=Equivalence_MED_Local[mailles->DONNE_TYPE_MAILLE(i)];
 333                         premier_pointeur[i]=mailles->DONNE_PREMIER_POINTEUR(i);
 334                         }
 335                 maille_courante.positionne(premier_pointeur[0],ConnGen[types[0]]);
 336                 }
 337 template <class FORME_SKYLINE> const Wrapper_Maille & Wrapper_Nuage_Maille<FORME_SKYLINE>::operator[](int i)
 338                 {
 339                 return maille_courante.positionne(premier_pointeur[i],ConnGen[types[i]]);
 340                 }
 341 template <class FORME_SKYLINE> void Wrapper_Nuage_Maille<FORME_SKYLINE>::affiche()
 342                 {
 343                 int i,j;
 344                 for (i=0;i<nbr_mailles;i++)
 345                         {
 346                         cout<<"Maille "<<i<<" MED "<<Equivalence_Local_MED[types[i]]<<" : "<<flush;
 347                         for (j=0;j<(*this)[i].DONNE_NBR_NOEUDS();j++) cout<<(*this)[i][j]<<" "<<flush;
 348                         cout<<endl;
 349                         }
 350                 }
 351
 352 /*********************************************************/
 353 /*                                                       */
 354 /*           Classe Connectivite_Canonique_Point1        */
 355 /*                                                       */
 356 /*********************************************************/
 357
 358 class Connectivite_Canonique_Point1  : public Connectivite_Canonique_Base
 359 {
 360 public :
 361         Connectivite_Canonique_Point1()
 362                 {
 363
 364                 type=0;
 365
 366                 nbr_noeuds = 1;
 367                 nbr_faces = 0;
 368
 369                 premier_noeud = vector<int>(0);
 370
 371                 simplexe_base = vector< vector<int> >(nbr_faces);
 372                 face          = vector< vector<int> >(nbr_faces);
 373
 374                 }
 375         ~Connectivite_Canonique_Point1() {}
 376 };
 377
 378 /*********************************************************/
 379 /*                                                       */
 380 /*           Classe Connectivite_Canonique_Seg2          */
 381 /*                                                       */
 382 /*********************************************************/
 383
 384 class Connectivite_Canonique_Seg2    : public Connectivite_Canonique_Base
 385 {
 386 public :
 387         Connectivite_Canonique_Seg2()
 388                 {
 389
 390                 type=1;
 391
 392                 int pn[2] = {0,1};
 393                 int sb[4] = {1,0,0,1};
 394                 int fa[2] = {0,1};
 395                 int po[3] = {0,1,2};
 396
 397                 nbr_noeuds = 2;
 398                 nbr_faces = 2;
 399
 400
 401                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 402
 403                 simplexe_base = vector< vector<int> >(nbr_faces);
 404                 face          = vector< vector<int> >(nbr_faces);
 405
 406                 int i;
 407
 408                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[2*i],&sb[2*(i+1)]);
 409                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 410
 411                 }
 412         ~Connectivite_Canonique_Seg2() {}
 413 };
 414 /*********************************************************/
 415 /*                                                       */
 416 /*           Classe Connectivite_Canonique_Seg3          */
 417 /*                                                       */
 418 /*********************************************************/
 419
 420 class Connectivite_Canonique_Seg3    : public Connectivite_Canonique_Base
 421 {
 422 public :
 423         Connectivite_Canonique_Seg3()
 424                 {
 425
 426                 type=2;
 427
 428                 int pn[2] = {0,1};
 429                 int sb[4] = {1,0,0,1};
 430                 int fa[2] = {0,1};
 431                 int po[3] = {0,1,2};
 432
 433                 nbr_noeuds = 3;
 434                 nbr_faces = 2;
 435
 436
 437                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 438
 439                 simplexe_base = vector< vector<int> >(nbr_faces);
 440                 face          = vector< vector<int> >(nbr_faces);
 441
 442                 int i;
 443
 444                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[2*i],&sb[2*(i+1)]);
 445                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 446
 447                 }
 448         ~Connectivite_Canonique_Seg3() {}
 449 };
 450
 451
 452 /*********************************************************/
 453 /*                                                       */
 454 /*           Classe Connectivite_Canonique_Tria3         */
 455 /*                                                       */
 456 /*********************************************************/
 457
 458 class Connectivite_Canonique_Tria3 : public Connectivite_Canonique_Base
 459 {
 460 public :
 461         Connectivite_Canonique_Tria3()
 462                 {
 463
 464                 type=3;
 465
 466                 int pn[3] = {0,1,2};
 467                 int sb[9] = {2,0,1,0,1,2,1,2,0};
 468                 int fa[6] = {0,1,1,2,2,0};
 469                 int po[4] = {0,2,4,6};
 470                 nbr_noeuds = 3;
 471                 nbr_faces = 3;
 472
 473
 474                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 475
 476                 simplexe_base = vector< vector<int> >(nbr_faces);
 477                 face          = vector< vector<int> >(nbr_faces);
 478
 479                 int i;
 480
 481                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[3*i],&sb[3*(i+1)]);
 482                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 483
 484                 }
 485         ~Connectivite_Canonique_Tria3() {}
 486 };
 487
 488 /*********************************************************/
 489 /*                                                       */
 490 /*           Classe Connectivite_Canonique_Tria6         */
 491 /*                                                       */
 492 /*********************************************************/
 493
 494 class Connectivite_Canonique_Tria6 : public Connectivite_Canonique_Base
 495 {
 496 public :
 497         Connectivite_Canonique_Tria6()
 498                 {
 499
 500                 type=4;
 501
 502                 int pn[3] = {0,1,2};
 503                 int sb[9] = {2,0,1,0,1,2,1,2,0};
 504                 int fa[6] = {0,1,1,2,2,0};
 505                 int po[4] = {0,2,4,6};
 506                 nbr_noeuds = 6;
 507                 nbr_faces = 3;
 508
 509
 510                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 511
 512                 simplexe_base = vector< vector<int> >(nbr_faces);
 513                 face          = vector< vector<int> >(nbr_faces);
 514
 515                 int i;
 516
 517                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[3*i],&sb[3*(i+1)]);
 518                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 519
 520                 }
 521         ~Connectivite_Canonique_Tria6() {}
 522 };
 523
 524 /*********************************************************/
 525 /*                                                       */
 526 /*           Classe Connectivite_Canonique_Quad4         */
 527 /*                                                       */
 528 /*********************************************************/
 529
 530 class Connectivite_Canonique_Quad4 : public Connectivite_Canonique_Base
 531 {
 532 public :
 533         Connectivite_Canonique_Quad4()
 534                 {
 535
 536                 type=5;
 537
 538                 int pn[4] = {0,1,2,3};
 539                 int sb[12] = {2,0,1,3,1,2,0,2,3,1,0,2};
 540                 int fa[8] = {0,1,1,2,2,3,3,0};
 541                 int po[5] = {0,2,4,6,8};
 542                 nbr_noeuds = 4;
 543                 nbr_faces = 4;
 544
 545
 546                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 547
 548                 simplexe_base = vector< vector<int> >(nbr_faces);
 549                 face          = vector< vector<int> >(nbr_faces);
 550
 551                 int i;
 552
 553                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[3*i],&sb[3*(i+1)]);
 554                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 555
 556                 }
 557         ~Connectivite_Canonique_Quad4() {}
 558 };
 559
 560
 561 /*********************************************************/
 562 /*                                                       */
 563 /*           Classe Connectivite_Canonique_Quad8         */
 564 /*                                                       */
 565 /*********************************************************/
 566
 567 class Connectivite_Canonique_Quad8 : public Connectivite_Canonique_Base
 568 {
 569 public :
 570         Connectivite_Canonique_Quad8()
 571                 {
 572
 573                 type=6;
 574
 575                 int pn[4] = {0,1,2,3};
 576                 int sb[12] = {2,0,1,3,1,2,0,2,3,1,0,2};
 577                 int fa[8] = {0,1,1,2,2,3,3,0};
 578                 int po[5] = {0,2,4,6,8};
 579                 nbr_noeuds = 8;
 580                 nbr_faces = 4;
 581
 582
 583                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 584
 585                 simplexe_base = vector< vector<int> >(nbr_faces);
 586                 face          = vector< vector<int> >(nbr_faces);
 587
 588                 int i;
 589
 590                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[3*i],&sb[3*(i+1)]);
 591                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 592
 593                 }
 594         ~Connectivite_Canonique_Quad8() {}
 595 };
 596
 597 /*********************************************************/
 598 /*                                                       */
 599 /*           Classe Connectivite_Canonique_Tetra4        */
 600 /*                                                       */
 601 /*********************************************************/
 602
 603 class Connectivite_Canonique_Tetra4 : public Connectivite_Canonique_Base
 604 {
 605 public :
 606         Connectivite_Canonique_Tetra4()
 607                 {
 608
 609                 type=7;
 610
 611                 int pn[4] = {0,0,1,2};
 612                 int sb[16] = {3,0,1,2,2,0,3,1,0,1,3,2,1,2,3,0};
 613                 int fa[12] = {0,1,2,0,3,1,1,3,2,2,3,0};
 614                 int po[5] = {0,3,6,9,12};
 615                 nbr_noeuds = 4;
 616                 nbr_faces = 4;
 617
 618
 619                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 620
 621                 simplexe_base = vector< vector<int> >(nbr_faces);
 622                 face          = vector< vector<int> >(nbr_faces);
 623
 624                 int i;
 625
 626                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
 627                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 628
 629                 }
 630         ~Connectivite_Canonique_Tetra4() {}
 631 };
 632
 633 /*********************************************************/
 634 /*                                                       */
 635 /*          Classe Connectivite_Canonique_Tetra10        */
 636 /*                                                       */
 637 /*********************************************************/
 638
 639 class Connectivite_Canonique_Tetra10 : public Connectivite_Canonique_Base
 640 {
 641 public :
 642         Connectivite_Canonique_Tetra10()
 643                 {
 644
 645                 type=8;
 646
 647                 int pn[4] = {0,0,1,2};
 648                 int sb[16] = {3,0,1,2,2,0,3,1,0,1,3,2,1,2,3,0};
 649                 int fa[12] = {  0,1,2,  0,3,1,  1,3,2,  2,3,0};
 650                 int po[5] = {0,3,6,9,12};
 651
 652                 nbr_noeuds = 10;
 653                 nbr_faces = 4;
 654
 655
 656                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 657
 658                 simplexe_base = vector< vector<int> >(nbr_faces);
 659                 face          = vector< vector<int> >(nbr_faces);
 660
 661                 int i;
 662
 663                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
 664                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 665
 666                 }
 667         ~Connectivite_Canonique_Tetra10() {}
 668 };
 669
 670 /*********************************************************/
 671 /*                                                       */
 672 /*           Classe Connectivite_Canonique_Hexa8         */
 673 /*                                                       */
 674 /*********************************************************/
 675
 676 class Connectivite_Canonique_Hexa8 : public Connectivite_Canonique_Base
 677 {
 678 public :
 679         Connectivite_Canonique_Hexa8()
 680                 {
 681
 682                 type=9;
 683
 684                 int pn[6] = {0,4,0,1,2,3};
 685                 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};
 686                 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};
 687                 int po[7] = {0,4,8,12,16,20,24};
 688                 nbr_noeuds = 8;
 689                 nbr_faces = 6;
 690
 691
 692                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 693
 694                 simplexe_base = vector< vector<int> >(nbr_faces);
 695                 face          = vector< vector<int> >(nbr_faces);
 696
 697                 int i;
 698
 699                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
 700                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 701
 702                 }
 703         ~Connectivite_Canonique_Hexa8() {}
 704 };
 705
 706 /*********************************************************/
 707 /*                                                       */
 708 /*           Classe Connectivite_Canonique_Hexa20        */
 709 /*                                                       */
 710 /*********************************************************/
 711
 712 class Connectivite_Canonique_Hexa20 : public Connectivite_Canonique_Base
 713 {
 714 public :
 715         Connectivite_Canonique_Hexa20()
 716                 {
 717
 718                 type=10;
 719
 720                 int pn[6] = {0,4,0,1,2,3};
 721                 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};
 722                 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};
 723                 int po[7] = {0,4,8,12,16,20,24};
 724                 nbr_noeuds = 20;
 725                 nbr_faces = 6;
 726
 727
 728                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 729
 730                 simplexe_base = vector< vector<int> >(nbr_faces);
 731                 face          = vector< vector<int> >(nbr_faces);
 732
 733                 int i;
 734
 735                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
 736                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 737
 738                 }
 739         ~Connectivite_Canonique_Hexa20() {}
 740 };
 741
 742 /*********************************************************/
 743 /*                                                       */
 744 /*           Classe Connectivite_Canonique_Pyra5         */
 745 /*                                                       */
 746 /*********************************************************/
 747
 748 class Connectivite_Canonique_Pyra5 : public Connectivite_Canonique_Base
 749 {
 750 public :
 751         Connectivite_Canonique_Pyra5()
 752                 {
 753
 754                 type=11;
 755
 756                 int pn[5] = {0,0,1,2,3};
 757                 int sb[20] = {4,0,1,2,3,0,4,1,0,1,4,2,1,2,4,3,2,0,3,4};
 758                 int fa[16] = {0,1,2,3,0,4,1,1,4,2,2,4,3,3,4,0};
 759                 int po[6] = {0,4,7,10,13,16};
 760                 nbr_noeuds = 5;
 761                 nbr_faces = 5;
 762
 763
 764                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 765
 766                 simplexe_base = vector< vector<int> >(nbr_faces);
 767                 face          = vector< vector<int> >(nbr_faces);
 768
 769                 int i;
 770
 771                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
 772                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 773
 774                 }
 775         ~Connectivite_Canonique_Pyra5() {}
 776 };
 777
 778 /*********************************************************/
 779 /*                                                       */
 780 /*           Classe Connectivite_Canonique_Pyra13        */
 781 /*                                                       */
 782 /*********************************************************/
 783
 784 class Connectivite_Canonique_Pyra13 : public Connectivite_Canonique_Base
 785 {
 786 public :
 787         Connectivite_Canonique_Pyra13()
 788                 {
 789
 790                 type=12;
 791
 792                 int pn[5] = {0,0,1,2,3};
 793                 int sb[20] = {4,0,1,2,3,0,4,1,0,1,4,2,1,2,4,3,2,0,3,4};
 794                 int fa[16] = {0,1,2,3,0,4,1,1,4,2,2,4,3,3,4,0};
 795                 int po[6] = {0,4,7,10,13,16};
 796                 nbr_noeuds = 13;
 797                 nbr_faces = 5;
 798
 799
 800                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 801
 802                 simplexe_base = vector< vector<int> >(nbr_faces);
 803                 face          = vector< vector<int> >(nbr_faces);
 804
 805                 int i;
 806
 807                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
 808                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 809
 810                 }
 811         ~Connectivite_Canonique_Pyra13() {}
 812 };
 813
 814 /*********************************************************/
 815 /*                                                       */
 816 /*           Classe Connectivite_Canonique_Penta6        */
 817 /*                                                       */
 818 /*********************************************************/
 819
 820 class Connectivite_Canonique_Penta6 : public Connectivite_Canonique_Base
 821 {
 822 public :
 823         Connectivite_Canonique_Penta6()
 824                 {
 825
 826                 type=13;
 827
 828                 int pn[5] = {0,3,0,1,2};
 829                 int sb[20] = {3,0,1,2,2,3,4,5,5,0,3,1,0,1,4,2,1,2,5,0};
 830                 int fa[18] = {0,1,2,3,4,5,0,3,4,1,1,4,5,2,2,5,3,1};
 831                 int po[6] = {0,3,6,10,14,18};
 832                 nbr_noeuds = 6;
 833                 nbr_faces = 5;
 834
 835
 836                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 837
 838                 simplexe_base = vector< vector<int> >(nbr_faces);
 839                 face          = vector< vector<int> >(nbr_faces);
 840
 841                 int i;
 842
 843                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
 844                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 845
 846                 }
 847         ~Connectivite_Canonique_Penta6() {}
 848 };
 849
 850 /*********************************************************/
 851 /*                                                       */
 852 /*           Classe Connectivite_Canonique_Penta15       */
 853 /*                                                       */
 854 /*********************************************************/
 855
 856 class Connectivite_Canonique_Penta15 : public Connectivite_Canonique_Base
 857 {
 858 public :
 859         Connectivite_Canonique_Penta15()
 860                 {
 861
 862                 type=14;
 863
 864                 int pn[5] = {0,3,0,1,2};
 865                 int sb[20] = {3,0,1,2,2,3,4,5,5,0,3,1,0,1,4,2,1,2,5,0};
 866                 int fa[18] = {0,1,2,3,4,5,0,3,4,1,1,4,5,2,2,5,3,1};
 867                 int po[6] = {0,3,6,10,14,18};
 868                 nbr_noeuds = 15;
 869                 nbr_faces = 5;
 870
 871
 872                 premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
 873
 874                 simplexe_base = vector< vector<int> >(nbr_faces);
 875                 face          = vector< vector<int> >(nbr_faces);
 876
 877                 int i;
 878
 879                 for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
 880                 for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
 881
 882                 }
 883         ~Connectivite_Canonique_Penta15() {}
 884 };
 885
 886 /*********************************************************/
 887 /*                                                       */
 888 /*               Classe Connectivite_Generale            */
 889 /*                                                       */
 890 /*********************************************************/
 891
 892 inline Connectivite_Generale::Connectivite_Generale():AllConn(NBR_MODELES_MAILLES_DEFINIS)
 893         {
 894         // l'ordre est important, il dépend de la relation entre numéro local et modele et numéro MED
 895         AllConn[ 0]=new Connectivite_Canonique_Point1  ();
 896         AllConn[ 1]=new Connectivite_Canonique_Seg2    ();
 897         AllConn[ 2]=new Connectivite_Canonique_Seg3    ();
 898         AllConn[ 3]=new Connectivite_Canonique_Tria3   ();
 899         AllConn[ 4]=new Connectivite_Canonique_Tria6   ();
 900         AllConn[ 5]=new Connectivite_Canonique_Quad4   ();
 901         AllConn[ 6]=new Connectivite_Canonique_Quad8   ();
 902         AllConn[ 7]=new Connectivite_Canonique_Tetra4  ();
 903         AllConn[ 8]=new Connectivite_Canonique_Tetra10 ();
 904         AllConn[ 9]=new Connectivite_Canonique_Hexa8   ();
 905         AllConn[10]=new Connectivite_Canonique_Hexa20  ();
 906         AllConn[11]=new Connectivite_Canonique_Pyra5   ();
 907         AllConn[12]=new Connectivite_Canonique_Pyra13  ();
 908         AllConn[13]=new Connectivite_Canonique_Penta6  ();
 909         AllConn[14]=new Connectivite_Canonique_Penta15 ();
 910         }
 911 inline Connectivite_Generale::~Connectivite_Generale()
 912         {
 913         for (int i=0;i<AllConn.size();i++) delete AllConn[i];
 914         }
 915
 916
 917 #endif