src/INTERPOLATION/MEDMEM_WrapperCells.hxx

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