src/HEXABLOCK/HexQuad.cxx

   1
   2 // C++ : Gestion des Quadrangles
   3
   4 // Copyright (C) 2009-2013  CEA/DEN, EDF R&D
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 #include "HexQuad.hxx"
  23
  24 #include "HexDocument.hxx"
  25 #include "HexHexa.hxx"
  26 #include "HexElements.hxx"
  27 #include "HexGlobale.hxx"
  28
  29 #include "HexXmlWriter.hxx"
  30 #include "HexNewShape.hxx"
  31 #include "HexFaceShape.hxx"
  32
  33 BEGIN_NAMESPACE_HEXA
  34
  35 bool db = false;
  36
  37 // ======================================================== Constructeur
  38 Quad::Quad (Vertex* va, Vertex* vb, Vertex* vc, Vertex* vd)
  39     : EltBase (va->dad(), EL_QUAD)
  40 {
  41    q_vertex [E_A] = va;
  42    q_vertex [E_B] = vb;
  43    q_vertex [E_C] = vc;
  44    q_vertex [E_D] = vd;
  45    q_clone        = NULL;
  46    q_orientation  = Q_UNDEFINED;
  47
  48    for (int nro=0 ; nro<QUAD4 ; nro++)
  49        {
  50        q_edge [nro] = new Edge (q_vertex[nro],
  51                                 q_vertex[(nro+1) MODULO QUAD4]);
  52
  53        if (BadElement (q_vertex [nro]) || BadElement (q_edge [nro]))
  54           setError ();
  55        else
  56           for (int nv=nro+1 ; nv<QUAD4 ; nv++)
  57               if (q_vertex[nv] == q_vertex[nro])
  58                  setError ();
  59        }
  60
  61    if (el_root != NULL && el_status==HOK)
  62        el_root->addQuad (this);
  63    majReferences ();
  64 }
  65 // ======================================================== Constructeur bis
  66 Quad::Quad (Edge* ea, Edge* eb, Edge* ec, Edge* ed)
  67     : EltBase (ea->dad(), EL_QUAD)
  68 {
  69    q_edge [E_A] = ea;
  70    q_edge [E_B] = eb;
  71    q_edge [E_C] = ec;
  72    q_edge [E_D] = ed;
  73    q_clone       = NULL;
  74    q_orientation = Q_UNDEFINED;
  75
  76    for (int nro=0 ; nro<QUAD4 ; nro++)
  77        {
  78        if (BadElement (q_edge[nro]))
  79           setError (886);
  80        else
  81           {
  82           for (int nv=nro+1 ; nv<QUAD4 ; nv++)
  83               if (q_edge[nv] == q_edge[nro])
  84                   setError (887);
  85           }
  86        }
  87
  88    if (isValid())
  89       {
  90                 // Cond necessaire : ea disjoint de ec (opposes)
  91       int nc = ea->inter (ec);
  92       if (nc>=0)
  93          {
  94          nc = ea->inter (eb);
  95          if (nc<0)
  96             {
  97             q_edge [E_C] = eb;
  98             q_edge [E_B] = ec;
  99             }
 100          else
 101             {
 102             nc = ea->inter (ed);
 103             if (nc<0)
 104                {
 105                q_edge [E_C] = ed;
 106                q_edge [E_D] = ec;
 107                }
 108             else
 109                setError (880);
 110             }
 111          }
 112       }
 113
 114    for (int nro=0 ; nro<QUAD4 ; nro++)
 115        {
 116        int prec = (nro+1) MODULO QUAD4;
 117        Vertex* node = NULL;
 118        int nc  = q_edge[nro] -> inter (q_edge[prec]);
 119        if (nc>=0)
 120           node = q_edge[nro]->getVertex (nc);
 121        else
 122           setError (888);
 123        q_vertex [prec] = node;
 124        }
 125
 126    if (isBad())
 127       {
 128       printf (" +++++++++++++++++++++++++++++++++++++++++++ \n");
 129       printf (" +++ Quadrangle impossible \n");
 130       printf (" +++++++++++++++++++++++++++++++++++++++++++ \n");
 131       dump ();
 132       printf (" +++++++++++++++++++++++++++++++++++++++++++ \n");
 133       // el_root->dump ();
 134       for (int ned=0; ned<QUAD4; ned++)
 135           {
 136           q_edge[ned]->dumpPlus ();
 137           }
 138       HexDump (q_vertex[0]);
 139       HexDump (q_vertex[1]);
 140       HexDump (q_vertex[2]);
 141       HexDump (q_vertex[3]);
 142
 143       printf (" +++++++++++++++++++++++++++++++++++++++++++ \n");
 144       fatal_error ("Quadrangle impossible");
 145       }
 146
 147    if (el_root != NULL && el_status==HOK)
 148        el_root->addQuad (this);
 149    majReferences ();
 150 }
 151 // ======================================================== Constructeur ter
 152 Quad::Quad (Quad* other)
 153     : EltBase (other->dad(), EL_QUAD)
 154 {
 155    for (int nro=0 ; nro<QUAD4 ; nro++)
 156        {
 157        q_edge   [nro] = NULL;
 158        q_vertex [nro] = NULL;
 159        }
 160    q_orientation = Q_UNDEFINED;
 161    q_clone       = NULL;
 162
 163    if (el_root != NULL && el_status==HOK)
 164        el_root->addQuad (this);
 165 }
 166 // ============================================================  getEdge
 167 Edge* Quad::getEdge (int nro)
 168 {
 169    Edge* elt = NULL;
 170    if (nro >=0 && nro < QUAD4 && el_status == HOK && q_edge [nro]->isValid())
 171       elt = q_edge [nro];
 172
 173    DumpStart  ("getEdge", nro);
 174    DumpReturn (elt);
 175    return elt;
 176 }
 177 // ============================================================  getVertex
 178 Vertex* Quad::getVertex (int nro)
 179 {
 180    Vertex* elt = NULL;
 181    if (nro >=0 && nro < QUAD4 && el_status == HOK && q_vertex [nro]->isValid())
 182       elt = q_vertex [nro];
 183
 184    DumpStart  ("getVertex", nro);
 185    DumpReturn (elt);
 186    return elt;
 187 }
 188 // ========================================================= majReferences
 189 void Quad::majReferences ()
 190 {
 191    for (int nro=0 ; nro<QUAD4 ; nro++)
 192        q_edge [nro] -> addParent (this);
 193 }
 194 // ========================================================= getParent
 195 Hexa* Quad::getParent  (int nro)
 196 {
 197    return static_cast <Hexa*> (getFather (nro));
 198 }
 199 // ======================================================== anaMerge
 200 int Quad::anaMerge (Vertex* v1, Vertex* v2, Vertex* tv1[], Edge* te1[])
 201 {
 202    int orig = NOTHING;
 203    for (int nro=0 ; orig == NOTHING && nro < QUAD4 ; nro++)
 204        if (q_vertex [nro] == v1)
 205            orig = nro;
 206
 207    if (orig==NOTHING)
 208       return HERR;
 209
 210    int nsp1 = (orig+1)       MODULO QUAD4;
 211    int nsm1 = (orig+QUAD4-1) MODULO QUAD4;
 212
 213    if (q_vertex [nsp1] == v2)
 214       {
 215       for (int nro=0 ; nro < QUAD4 ; nro++)
 216           {
 217           tv1 [nro] = q_vertex [(orig+nro) MODULO QUAD4];
 218           te1 [nro] = q_edge   [(orig+nro) MODULO QUAD4];
 219           }
 220       }
 221    else if (q_vertex [nsm1] == v2)
 222       {
 223       for (int nro=0 ; nro < QUAD4 ; nro++)
 224           {
 225           tv1 [nro] = q_vertex [(orig+QUAD4-nro) MODULO QUAD4];
 226           te1 [nro] = q_edge   [(orig+QUAD4-nro) MODULO QUAD4];
 227           }
 228       }
 229    else
 230       return 588;
 231
 232    return HOK;
 233 }
 234 // ======================================================== ordoVertex
 235 int Quad::ordoVertex (Vertex* v1, Vertex* v2, Vertex* tver[])
 236 {
 237    int orig = NOTHING;
 238    for (int nro=0 ; orig == NOTHING && nro < QUAD4 ; nro++)
 239        if (q_vertex [nro] == v1)
 240            orig = nro;
 241
 242    if (orig==NOTHING)
 243       return HERR;
 244
 245    int nsp1 = (orig+1)       MODULO QUAD4;
 246    int nsm1 = (orig+QUAD4-1) MODULO QUAD4;
 247
 248    if (q_vertex [nsp1] == v2)
 249       {
 250       for (int nro=0 ; nro < QUAD4 ; nro++)
 251           tver [nro] = q_vertex [(orig+nro) MODULO QUAD4];
 252       }
 253    else if (q_vertex [nsm1] == v2)
 254       {
 255       for (int nro=0 ; nro < QUAD4 ; nro++)
 256           tver [nro] = q_vertex [(orig+QUAD4-nro) MODULO QUAD4];
 257       }
 258    else
 259       return 588;
 260
 261    return HOK;
 262 }
 263 // ======================================================== ordonner
 264 int Quad::ordonner (Vertex* v1, Vertex* v2, Vertex* tver[], Edge* ted[])
 265 {
 266    tver [0] = tver [1] = tver [2] = tver [3] = NULL;
 267    ted  [0] = ted  [1] = ted  [2] = ted  [3] = NULL;
 268
 269    int ier = ordoVertex (v1, v2, tver);
 270    if (ier != HOK)
 271        return ier;
 272
 273    for (int nro=0 ; nro < QUAD4 ; nro++)
 274        ted [nro] = findEdge (tver[nro], tver [(nro+1) MODULO QUAD4]);
 275
 276    return HOK;
 277 }
 278 // ======================================================== getBrother
 279 Quad* Quad::getBrother (StrOrient* orient)
 280 {
 281 /* *****************************
 282    printf (" getBrother ");
 283    dump ();
 284    printf (" .. Base  : ");
 285    orient->v21->printName();
 286    orient->v22->printName();
 287    printf ("dir=%d, arete=", orient->dir);
 288   ***************************** */
 289
 290    int n21 = indexVertex (orient->v21);
 291    int n22 = indexVertex (orient->v22);
 292
 293    int sens  = n22 - n21;
 294    if (sens >  1) sens -= QUAD4;
 295    if (sens < -1) sens += QUAD4;
 296    if (sens*sens !=1) return NULL;
 297
 298    switch (orient->dir)
 299       {
 300       case OR_LEFT  : n22 = n21 - sens;
 301            break;
 302       case OR_RIGHT : n21 = n22 + sens;
 303            break;
 304       case OR_FRONT : n21 += 2;
 305                       n22 += 2;
 306            break;
 307       default : ;
 308       }
 309
 310    n21 = (n21 + QUAD4) MODULO QUAD4;
 311    n22 = (n22 + QUAD4) MODULO QUAD4;
 312
 313    orient->v21 = q_vertex [n21];
 314    orient->v22 = q_vertex [n22];
 315
 316    Edge* arete  = findEdge (orient->v21, orient->v22);
 317    // arete->printName("\n");
 318
 319    int nbfreres = arete->getNbrParents ();
 320
 321    for (int nq = 0 ; nq < nbfreres ; nq++)
 322        {
 323        Quad* next = arete->getParent (nq);
 324        if (next!=NULL && next != this )
 325           {
 326           int   nbp   = next->getNbrParents();
 327           Hexa* dad   = next->getParent(0);
 328           int   mark  = next->getMark();
 329           int   mark2 = dad ? dad->getMark() : IS_NONE;
 330
 331           if (nbp  <= 1  && mark2 != IS_MARRIED && mark == IS_NONE)
 332              return next;
 333           // if (nbp  <= 1  && mark == IS_NONE)
 334              // return next;
 335           }
 336        }
 337    return NULL;
 338 }
 339 // ======================================================== coupler
 340 int Quad::coupler (Quad* other, StrOrient* orient, Elements* table)
 341 {
 342    if (other==NULL)
 343       return HERR;
 344
 345    Hexa* hexa = other->getParent(0);
 346
 347    setMark (IS_MARRIED);
 348    other->setMark (IS_MARRIED);
 349    if (hexa != NULL)
 350        hexa->setMark (IS_MARRIED);
 351
 352    for (int ned = 0 ; ned < QUAD4 ; ned++)
 353        {
 354        Edge* arete  = q_edge[ned];
 355        int nbfreres = arete ->getNbrParents ();
 356        for (int nq = 0 ; nq < nbfreres ; nq++)
 357            {
 358            Quad* next = arete->getParent (nq);
 359            if (next!=NULL && next != this && next->getMark() > 0)
 360               {
 361               StrOrient new_ori (orient);
 362               new_ori.dir = OR_FRONT;
 363               Vertex* va  = arete->getVertex (V_AMONT);
 364               Vertex* vb  = arete->getVertex (V_AVAL);
 365
 366 //    On voit si un point de repere est conserve
 367               if (va == orient->v11)
 368                  {
 369                  new_ori.v12 = vb;
 370                  new_ori.dir += OR_LEFT;
 371                  }
 372               else if (vb == orient->v11)
 373                  {
 374                  new_ori.v12 = va;
 375                  new_ori.dir += OR_LEFT;
 376                  }
 377
 378               if (va == orient->v12)
 379                  {
 380                  new_ori.v11 = vb;
 381                  new_ori.dir += OR_RIGHT;
 382                  }
 383               else if (vb == orient->v12)
 384                  {
 385                  new_ori.v11 = va;
 386                  new_ori.dir += OR_RIGHT;
 387                  }
 388
 389               if (new_ori.dir == OR_FRONT)
 390                  {
 391                  if (definedBy (va, orient->v11))
 392                     {
 393                     new_ori.v11 = va;
 394                     new_ori.v12 = vb;
 395                     }
 396                  else
 397                     {
 398                     new_ori.v11 = vb;
 399                     new_ori.v12 = va;
 400                     }
 401                  }
 402
 403               int nro = next->getMark ();
 404               Quad* beauf = other->getBrother (&new_ori);
 405               int ier = table->coupler (nro, beauf, &new_ori);
 406               if (ier != HOK)
 407                  return ier;
 408               ier = next->coupler (beauf, &new_ori, table);
 409               if (ier != HOK)
 410                  return ier;
 411               }
 412            }
 413        }
 414    return HOK;
 415 }
 416 // ======================================================== getOpposVertex
 417 Vertex* Quad::getOpposVertex (Vertex* start)
 418 {
 419    int  na = indexVertex (start);
 420    if (na==NOTHING)
 421       return NULL;
 422    return  q_vertex [(na+2) MODULO QUAD4];
 423 }
 424 // ======================================================== getOpposEdge
 425 Edge* Quad::getOpposEdge (Edge* start, int& sens)
 426 {
 427    sens = 1;
 428    int  na = indexVertex (start->getVertex (V_AMONT));
 429    int  nb = indexVertex (start->getVertex (V_AVAL));
 430
 431    Vertex* vaprim = q_vertex [(nb+2) MODULO QUAD4];
 432    Vertex* vbprim = q_vertex [(na+2) MODULO QUAD4];
 433
 434    for (int ned = 0 ; ned < QUAD4 ; ned++)
 435        {
 436        if (   q_edge[ned]->getVertex(V_AMONT) == vaprim
 437            && q_edge[ned]->getVertex(V_AVAL ) == vbprim)
 438            {
 439            sens = 1;
 440            return q_edge[ned];
 441            }
 442        else if (   q_edge[ned]->getVertex(V_AMONT) == vbprim
 443                 && q_edge[ned]->getVertex(V_AVAL ) == vaprim)
 444            {
 445            sens = -1;
 446            return q_edge[ned];
 447            }
 448        }
 449    //             TODO : traiter l'erreur
 450    cout << " ... Probleme dans Quad::getOpposedEdge :" << endl;
 451    HexDisplay (el_name);
 452    PutName (start);
 453    PutName (vaprim);
 454    PutName (vbprim);
 455    HexDisplay (na);
 456    HexDisplay (nb);
 457    dumpPlus ();
 458
 459    for (int ned = 0 ; ned < QUAD4 ; ned++)
 460        q_edge[ned]->dump();
 461
 462    return NULL;
 463 }
 464 // ========================================================= saveXml
 465 void Quad::saveXml (XmlWriter* xml)
 466 {
 467    char buffer[12];
 468    string edges;
 469
 470    for (int nro=0 ; nro<QUAD4 ; nro++)
 471        {
 472        if (nro>0) edges += " ";
 473        edges += q_edge[nro]->getName(buffer);
 474        }
 475
 476    xml->openMark     ("Quad");
 477    xml->addAttribute ("id",    getName (buffer));
 478    xml->addAttribute ("edges", edges);
 479    if (el_name!=buffer)
 480        xml->addAttribute ("name", el_name);
 481    xml->closeMark ();
 482
 483    int nbass = tab_assoc.size();
 484    for (int nro=0 ; nro<nbass ; nro++)
 485        if (tab_assoc[nro] != NULL)
 486            tab_assoc[nro]->saveXml (xml);
 487 }
 488 // ======================================================== replaceEdge
 489 void Quad::replaceEdge (Edge* old, Edge* par)
 490 {
 491    for (int nro=0 ; nro<QUAD4 ; nro++)
 492        {
 493        if (q_edge[nro]==old)
 494            {
 495            q_edge[nro] = par;
 496            if (debug())
 497               {
 498               printf (" Dans ");
 499               printName ();
 500               printf (" [%d], ", nro);
 501               old->printName (" est remplace par ");
 502               par->printName ("\n");
 503               }
 504            }
 505        }
 506 }
 507 // ======================================================== replaceVertex
 508 void Quad::replaceVertex (Vertex* old, Vertex* par)
 509 {
 510    for (int nro=0 ; nro<QUAD4 ; nro++)
 511        {
 512        if (q_vertex [nro]==old)
 513           {
 514           q_vertex [nro] = par;
 515            if (debug())
 516               {
 517               printf (" Dans ");
 518               printName ();
 519               printf (" [%d], ", nro);
 520               old->printName (" est remplace par ");
 521               par->printName ("\n");
 522               }
 523           }
 524        }
 525 }
 526 // ======================================================== dump
 527 void Quad::dump ()
 528 {
 529    printName(" = (");
 530    if (NOT isHere ())
 531       {
 532       printf ("*** deleted ***)\n");
 533       return;
 534       }
 535
 536    for (int nro=0 ; nro<QUAD4 ; nro++)
 537         PrintName (q_edge[nro]);
 538    printf (")\n");
 539
 540    printf ("        (");
 541    for (int nro=0 ; nro<QUAD4 ; nro++)
 542         PrintName (q_vertex[nro]);
 543    printf (")");
 544
 545    dumpRef ();
 546 }
 547 // ======================================================== dumpPlus
 548 void Quad::dumpPlus ()
 549 {
 550    dump ();
 551    if (NOT isHere ())
 552       return;
 553
 554    for (int nro=0 ; nro < QUAD4 ; nro++)
 555        {
 556        Vertex* pv = q_vertex[nro];
 557        printf ( "    ");
 558        if (pv!=NULL)
 559           {
 560           pv->printName ("");
 561           printf ( " (%g, %g, %g)\n", pv->getX(),  pv->getY(),  pv->getZ());
 562           }
 563        else
 564           {
 565           printf ( "NULL\n");
 566           }
 567        }
 568 }
 569 // ======================================================== getOpposEdge (2)
 570 Edge* Quad::getOpposEdge (Edge* start)
 571 {
 572    int  na = indexEdge (start);
 573    if (na<0)
 574       return NULL;
 575    return q_edge [(na+2) MODULO QUAD4];
 576 }
 577 // ======================================================== getPerpendicular
 578 Edge* Quad::getPerpendicular (Edge* arete, Vertex* node)
 579 {
 580    int na = indexEdge (arete);
 581    if (na<0)
 582       return NULL;
 583
 584    int nv = arete->index (node);
 585    if (nv<0)
 586       return NULL;
 587    Edge* perp = q_edge [(na+1) MODULO QUAD4];
 588
 589    nv = perp->index (node);
 590    if (nv>=0)
 591       return perp;
 592
 593    perp = q_edge [(na+3) MODULO QUAD4];
 594    nv   = perp->index (node);
 595    if (nv>=0)
 596       return perp;
 597    else
 598       return NULL;
 599 }
 600 static cpchar t_ori[] = {"Q_INSIDE", "Q_DIRECT", "Q_INVERSE", "Q_UNDEF"};
 601 // ======================================================== setOrientation
 602 void Quad::setOrientation (int ori)
 603 {
 604     q_orientation = ori;
 605     if (db && (ori==Q_DIRECT || ori==Q_INVERSE))
 606        printf (" %s = %s\n", el_name.c_str(), t_ori [ q_orientation ]);
 607 }
 608 // ======================================================== setOrientation
 609 int Quad::setOrientation ()
 610 {
 611     q_orientation = Q_INSIDE;
 612     if (getNbrParents() != 1)
 613        return q_orientation;
 614
 615     Real3 cg, orig, pi, pj, vi, vj, vk;
 616
 617     Hexa* hexa = getParent(0);
 618     hexa->getCenter (cg);
 619
 620 /********************************************************************
 621     printName (" = ");
 622
 623     for (int np=0 ; np < QUAD4 ; np++)
 624         {
 625         q_vertex [np        ] -> getPoint (orig);
 626         q_vertex [(np+1) % 4] -> getPoint (pi);
 627         q_vertex [(np+3) % 4] -> getPoint (pj);
 628
 629         calc_vecteur (orig, pi, vi);
 630         calc_vecteur (orig, pj, vj);
 631         calc_vecteur (orig, cg, vk);
 632         double pmixte = prod_mixte (vi, vj, vk);
 633         q_orientation = pmixte > ZEROR ? Q_DIRECT : Q_INVERSE;
 634         if (pmixte>0) printf (">");
 635            else       printf ("<");
 636         }
 637
 638     printf ("\n");
 639     return;
 640   ******************************************************************* */
 641     q_vertex [0] -> getPoint (orig);
 642     q_vertex [1] -> getPoint (pi);
 643     q_vertex [3] -> getPoint (pj);
 644
 645     calc_vecteur (orig, pi, vi);
 646     calc_vecteur (orig, pj, vj);
 647     calc_vecteur (cg, orig, vk);
 648
 649     double pmixte = prod_mixte (vi, vj, vk);
 650     q_orientation = pmixte > ZEROR ? Q_DIRECT : Q_INVERSE;
 651     if (db)
 652        printf (" %s := %s\n", el_name.c_str(), t_ori [ q_orientation ]);
 653     return q_orientation;
 654 }
 655 // ========================================================== clearAssociation
 656 void Quad::clearAssociation ()
 657 {
 658    tab_assoc.clear ();
 659    is_associated = false;
 660 }
 661 // ========================================================== addAssociation
 662 int Quad::addAssociation (NewShape* geom, int subid)
 663 {
 664    if (geom == NULL)
 665       return HERR;
 666
 667    FaceShape* face = geom->findFace (subid);
 668    int ier = addAssociation (face);
 669
 670    return ier;
 671 }
 672 // ========================================================== addAssociation
 673 int Quad::addAssociation (FaceShape* face)
 674 {
 675    if (face == NULL)
 676       return HERR;
 677
 678    face->addAssociation (this);
 679    tab_assoc.push_back (face);
 680    is_associated = true;
 681    return HOK;
 682 }
 683 // ========================================================== getAssociation
 684 FaceShape* Quad::getAssociation (int nro)
 685 {
 686    if (nro < 0 || nro >= (int)tab_assoc.size())
 687       return NULL;
 688
 689    return tab_assoc [nro];
 690 }
 691 // ======================================================== commonEdge
 692 Edge* Quad::commonEdge (Quad* other)
 693 {
 694    for (int ne1=0 ; ne1<QUAD4 ; ne1++)
 695        for (int ne2=0 ; ne2<QUAD4 ; ne2++)
 696            if (q_edge [ne1] == other->q_edge [ne2])
 697               return q_edge [ne1];
 698
 699    return NULL;
 700 }
 701 // ======================================================== Inter
 702 int Quad::inter (Quad* other, int& nother)
 703 {
 704    for (int ne1=0 ; ne1<QUAD4 ; ne1++)
 705        for (int ne2=0 ; ne2<QUAD4 ; ne2++)
 706            if (q_edge [ne1] == other->q_edge [ne2])
 707               {
 708               nother = ne2;
 709               return  ne1;
 710               }
 711
 712    nother = NOTHING;
 713    return NOTHING;
 714 }
 715 // ======================================================== Inter (2)
 716 Edge* Quad::inter (Quad* other)
 717 {
 718    for (int ne1=0 ; ne1<QUAD4 ; ne1++)
 719        for (int ne2=0 ; ne2<QUAD4 ; ne2++)
 720            if (q_edge [ne1] == other->q_edge [ne2])
 721               return  q_edge [ne1];
 722    return NULL;
 723 }
 724 // ============================================================ definedBy (v)
 725 bool Quad::definedBy  (Vertex* v1, Vertex* v2)
 726 {
 727    for (int n1=0 ; n1< QUAD4 ; n1++)
 728        if (v1 == q_vertex[n1] && v2 == q_vertex[(n1+2) MODULO QUAD4])
 729           return true;
 730
 731    return false;
 732 }
 733 // ============================================================ definedBy (e)
 734 bool Quad::definedBy  (Edge* e1, Edge* e2)
 735 {
 736    if (e1==e2 || BadElement (e1) || BadElement (e2))
 737       return false;
 738
 739    bool f1=false, f2=false;
 740    for (int ned=0 ; ned< QUAD4 ; ned++)
 741        if      (e1 == q_edge[ned]) f1 = true;
 742        else if (e2 == q_edge[ned]) f2 = true;
 743     // if (e1 == q_edge[ned] && e2 == q_edge[(ned+2) MODULO QUAD4]) return true;
 744
 745    return f1 && f2;
 746 }
 747 // =============================================================== findEdge
 748 Edge* Quad::findEdge (Vertex* v1, Vertex* v2)
 749 {
 750    for (int nro=0 ; nro< QUAD4 ; nro++)
 751        {
 752        Vertex* va = q_edge[nro]->getVertex(V_AMONT) ;
 753        Vertex* vb = q_edge[nro]->getVertex(V_AVAL) ;
 754        if ((v1==va && v2==vb) || (v1==vb && v2==va))
 755            return q_edge [nro];
 756        }
 757
 758    return NULL;
 759 }
 760 // =============================================================== indexVertex
 761 int Quad::indexVertex  (Vertex* elt)
 762 {
 763    for (int n1=0 ; n1< QUAD4 ; n1++)
 764        if (elt == q_vertex[n1])
 765           return n1;
 766
 767    return NOTHING;
 768 }
 769 // =============================================================== indexEdge
 770 int Quad::indexEdge  (Edge* elt)
 771 {
 772    for (int n1=0 ; n1< QUAD4 ; n1++)
 773        if (elt == q_edge[n1])
 774           return n1;
 775
 776    return NOTHING;
 777 }
 778 // =============================================================== setColor
 779 void Quad::setColor  (double val)
 780 {
 781    for (int n1=0 ; n1< QUAD4 ; n1++)
 782        q_vertex[n1] -> setColor (val);
 783 }
 784 // =============================================================== duplicate
 785 void Quad::duplicate  ()
 786 {
 787    q_orientation  = Q_UNDEFINED;
 788    q_clone = new Quad (GetClone (q_edge [E_A]),
 789                        GetClone (q_edge [E_B]),
 790                        GetClone (q_edge [E_C]),
 791                        GetClone (q_edge [E_D]));
 792    q_clone->tab_assoc  = tab_assoc;
 793 }
 794 // ============================================================ nearestVertex
 795 Vertex* Quad::nearestVertex (Vertex* other)
 796 {
 797    if (BadElement (other))
 798       return NULL;
 799
 800    Vertex* vsol = NULL;
 801    double  dmin = 1e+77;
 802    int nbre = countVertex ();
 803    for (int nro=0 ; nro<nbre ; nro++)
 804        {
 805        Vertex* vert = getVertex (nro);
 806        double  dist = other->dist2 (vert);
 807        if (dist < dmin)
 808           {
 809           dmin = dist;
 810           vsol = vert;
 811           }
 812        }
 813    return vsol;
 814 }
 815 // =============================================================== reorienter
 816 void Quad::reorienter  ()
 817 {
 818    if (q_orientation != Q_INVERSE)
 819          return;
 820
 821    Edge* edge   = q_edge [E_B];
 822    q_edge [E_B] = q_edge [E_D];
 823    q_edge [E_B] = edge;
 824
 825    q_vertex [E_A] = q_edge [E_D]->commonVertex(q_edge [E_A]);
 826    q_vertex [E_B] = q_edge [E_A]->commonVertex(q_edge [E_B]);
 827    q_vertex [E_C] = q_edge [E_B]->commonVertex(q_edge [E_C]);
 828    q_vertex [E_D] = q_edge [E_C]->commonVertex(q_edge [E_D]);
 829
 830    if (db)
 831        printf (" %s est reoriente\n", el_name.c_str());
 832    q_orientation = Q_DIRECT;
 833 }
 834 // =============================================================== getCenter
 835 double* Quad::getCenter (double* center)
 836 {
 837    center[dir_x] = center[dir_y] = center[dir_z] =  0;
 838    if (BadElement (this))
 839       return NULL;
 840
 841    for (int nv=0 ; nv<QUAD4 ; nv++)
 842        {
 843        if (BadElement (q_vertex [nv]))
 844            return NULL;
 845        center [dir_x] += q_vertex[nv]->getX();
 846        center [dir_y] += q_vertex[nv]->getY();
 847        center [dir_z] += q_vertex[nv]->getZ();
 848        }
 849     return center;
 850 }
 851 // =============================================================== getCenter
 852 double Quad::dist2 (double* point)
 853 {
 854    Real3 center;
 855    getCenter (center);
 856    double d2 = carre (point[dir_x] - center[dir_x])
 857              + carre (point[dir_y] - center[dir_y])
 858              + carre (point[dir_z] - center[dir_z]) ;
 859    return d2;
 860 }
 861 // =============================================================== getCenter
 862 Hexa* Quad::opposedHexa (Hexa* hexa)
 863 {
 864    int nbre = getNbrParents ();
 865    for (int nro=0 ; nro <nbre ; ++nro)
 866        {
 867        Hexa* dad = getParent (nro);
 868        if (dad!= NULL && dad->isValid() && dad != hexa)
 869            return dad;
 870        }
 871    return NULL;
 872 }
 873 END_NAMESPACE_HEXA