src/HEXABLOCK/HexDocument_tools.cxx

   1
   2 // C++ : Classe Document : Methodes internes 2011
   3
   4 // Copyright (C) 2009-2023  CEA, EDF
   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, or (at your option) any later version.
  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
  23 #include "HexDocument.hxx"
  24 #include "HexVertex.hxx"
  25 #include "HexEdge.hxx"
  26 #include "HexQuad.hxx"
  27 #include "HexHexa.hxx"
  28 #include "HexGlobale.hxx"
  29 #include "HexGroup.hxx"
  30
  31 BEGIN_NAMESPACE_HEXA
  32
  33 // ======================================================== countHexa
  34 int Document::countHexa ()
  35 {
  36    DumpStart0 ("countHexa");
  37    if (holes_elements)
  38        renumeroter ();
  39
  40    int nombre =  doc_hexas.size();
  41    DumpReturn (nombre);
  42    return nombre;
  43 }
  44 // ======================================================== countQuad
  45 int Document::countQuad ()
  46 {
  47    DumpStart0 ("countQuad");
  48    if (holes_elements)
  49        renumeroter ();
  50
  51    int nombre =  doc_quads.size();
  52    DumpReturn (nombre);
  53    return nombre;
  54 }
  55 // ======================================================== countEdge
  56 int Document::countEdge ()
  57 {
  58    DumpStart0 ("countEdge");
  59    if (holes_elements)
  60        renumeroter ();
  61
  62    int nombre =  doc_edges.size();
  63    DumpReturn (nombre);
  64    return nombre;
  65 }
  66 // ======================================================== countVertex
  67 int Document::countVertex ()
  68 {
  69    DumpStart0 ("countVertex");
  70    if (holes_elements)
  71        renumeroter ();
  72
  73    int nombre =  doc_vertex.size();
  74    DumpReturn (nombre);
  75    return nombre;
  76 }
  77
  78 // ======================================================== getHexa
  79 Hexa* Document::getHexa (int nro)
  80 {
  81    if (holes_elements)
  82        renumeroter ();
  83
  84    if (nro<0 || nro >= (int) doc_hexas.size())
  85       return NULL;
  86
  87    return doc_hexas [nro];
  88 }
  89 // ======================================================== getQuad
  90 Quad* Document::getQuad (int nro)
  91 {
  92    if (holes_elements)
  93        renumeroter ();
  94
  95    if (nro<0 || nro >= (int) doc_quads.size())
  96       return NULL;
  97
  98    return doc_quads [nro];
  99 }
 100 // ======================================================== getEdge
 101 Edge* Document::getEdge (int nro)
 102 {
 103    if (holes_elements)
 104        renumeroter ();
 105
 106    if (nro<0 || nro >= (int) doc_edges.size())
 107       return NULL;
 108
 109    return doc_edges [nro];
 110 }
 111 // ======================================================== getVertex
 112 Vertex* Document::getVertex (int nro)
 113 {
 114    if (holes_elements)
 115        renumeroter ();
 116
 117    if (nro<0 || nro >= (int) doc_vertex.size())
 118       return NULL;
 119
 120    return doc_vertex [nro];
 121 }
 122 // ======================================================== renumeroter
 123 void Document::renumeroter ()
 124 {
 125    int nbelts = doc_vertex.size();
 126    int decal  = 0;
 127    for (int nro=0 ; nro<nbelts ; nro++)
 128        {
 129        Vertex* elt = doc_vertex [nro];
 130        if (elt->isDeleted())
 131           decal ++;
 132        else if (decal != 0)
 133           doc_vertex [nro-decal] = elt;
 134        }
 135
 136    if (decal != 0)
 137        doc_vertex.resize (nbelts-decal);
 138                                         // ----------------- Edges
 139    nbelts = doc_edges.size();
 140    decal  = 0;
 141    for (int nro=0 ; nro<nbelts ; nro++)
 142        {
 143        Edge* elt = doc_edges [nro];
 144        if (elt->isDeleted())
 145           decal ++;
 146        else if (decal != 0)
 147           doc_edges [nro-decal] = elt;
 148        }
 149
 150    if (decal != 0)
 151        doc_edges.resize (nbelts-decal);
 152                                         // ----------------- Quads
 153    nbelts = doc_quads.size();
 154    decal  = 0;
 155    for (int nro=0 ; nro<nbelts ; nro++)
 156        {
 157        Quad* elt = doc_quads [nro];
 158        if (elt->isDeleted())
 159           decal ++;
 160        else if (decal != 0)
 161           doc_quads [nro-decal] = elt;
 162        }
 163
 164    if (decal != 0)
 165        doc_quads.resize (nbelts-decal);
 166                                         // ----------------- Hexas
 167    nbelts = doc_hexas.size();
 168    decal  = 0;
 169    for (int nro=0 ; nro<nbelts ; nro++)
 170        {
 171        Hexa* elt = doc_hexas [nro];
 172        if (elt->isDeleted())
 173           decal ++;
 174        else if (decal != 0)
 175           doc_hexas [nro-decal] = elt;
 176        }
 177
 178    if (decal != 0)
 179        doc_hexas.resize (nbelts-decal);
 180 }
 181 // ----------------------------------------------------------------------------
 182 // ======================================================== countUsedHexa
 183 int Document::countUsedHexa ()
 184 {
 185    if (count_modified)
 186        recountUsed ();
 187
 188    return nbr_used_hexas;
 189 }
 190 // ======================================================== countUsedQuad
 191 int Document::countUsedQuad ()
 192 {
 193    if (count_modified)
 194        recountUsed ();
 195
 196    return nbr_used_quads;
 197 }
 198 // ======================================================== countUsedEdge
 199 int Document::countUsedEdge ()
 200 {
 201    if (count_modified)
 202        recountUsed ();
 203
 204    return nbr_used_edges;
 205 }
 206 // ======================================================== countUsedVertex
 207 int Document::countUsedVertex ()
 208 {
 209    if (count_modified)
 210        recountUsed ();
 211
 212    return nbr_used_vertex;
 213 }
 214
 215 // ======================================================== getUsedHexa
 216 Hexa* Document::getUsedHexa (int nro)
 217 {
 218    if (count_modified)
 219        recountUsed ();
 220
 221    if (nro<0 || nro >= nbr_used_hexas)
 222       return NULL;
 223
 224    return doc_used_hexas [nro];
 225 }
 226 // ======================================================== getUsedQuad
 227 Quad* Document::getUsedQuad (int nro)
 228 {
 229    if (count_modified)
 230        recountUsed ();
 231
 232    if (nro<0 || nro >= nbr_used_quads)
 233       return NULL;
 234
 235    return doc_used_quads [nro];
 236 }
 237 // ======================================================== getUsedEdge
 238 Edge* Document::getUsedEdge (int nro)
 239 {
 240    if (count_modified)
 241        recountUsed ();
 242
 243    if (nro<0 || nro >= nbr_used_edges)
 244       return NULL;
 245
 246    return doc_used_edges [nro];
 247 }
 248 // ======================================================== getUsedVertex
 249 Vertex* Document::getUsedVertex (int nro)
 250 {
 251    if (count_modified)
 252        recountUsed ();
 253
 254    if (nro<0 || nro >= nbr_used_vertex)
 255       return NULL;
 256
 257    return doc_used_vertex [nro];
 258 }
 259 // ======================================================== recountUsed
 260 void Document::recountUsed ()
 261 {
 262    count_modified = false;
 263                                        // -- 1) Raz numerotation precedente
 264    markAll (NO_COUNTED);
 265
 266    doc_used_hexas .clear ();
 267    doc_used_quads .clear ();
 268    doc_used_edges .clear ();
 269    doc_used_vertex.clear ();
 270
 271    for (EltBase* elt = doc_first_elt[EL_HEXA]->next (); elt!=NULL;
 272                  elt = elt->next())
 273        {
 274        if (elt!=NULL && elt->isHere())
 275           {
 276           Hexa* cell = static_cast <Hexa*> (elt);
 277           doc_used_hexas.push_back (cell);
 278           for (int nb=0 ; nb<HQ_MAXI ; nb++)
 279               cell->getQuad (nb)->setMark (IS_USED);
 280
 281           for (int nb=0 ; nb<HE_MAXI ; nb++)
 282               cell->getEdge (nb)->setMark (IS_USED);
 283
 284           for (int nb=0 ; nb<HV_MAXI ; nb++)
 285               cell->getVertex (nb)->setMark (IS_USED);
 286           }
 287        }
 288
 289    for (EltBase* elt = doc_first_elt[EL_QUAD]->next (); elt!=NULL;
 290                  elt = elt->next())
 291        {
 292        if (elt!=NULL && elt->isHere() && elt->getMark()==IS_USED)
 293           {
 294           Quad* cell = static_cast <Quad*> (elt);
 295           doc_used_quads.push_back (cell);
 296           }
 297        }
 298
 299    for (EltBase* elt = doc_first_elt[EL_EDGE]->next (); elt!=NULL;
 300                  elt = elt->next())
 301        {
 302        if (elt!=NULL && elt->isHere() && elt->getMark()==IS_USED)
 303           {
 304           Edge* cell = static_cast <Edge*> (elt);
 305           doc_used_edges.push_back (cell);
 306           }
 307        }
 308
 309    for (EltBase* elt = doc_first_elt[EL_VERTEX]->next (); elt!=NULL;
 310                  elt = elt->next())
 311        {
 312        if (elt!=NULL && elt->isHere() && elt->getMark()==IS_USED)
 313           {
 314           Vertex* cell = static_cast <Vertex*> (elt);
 315           doc_used_vertex.push_back (cell);
 316           }
 317        }
 318
 319    nbr_used_hexas  = doc_used_hexas .size ();
 320    nbr_used_quads  = doc_used_quads .size ();
 321    nbr_used_edges  = doc_used_edges .size ();
 322    nbr_used_vertex = doc_used_vertex .size ();
 323 }
 324 // ========================================================= saveVtk (avec nro)
 325 int Document::saveVtk  (cpchar radical, int &nro)
 326 {
 327    char num[8];
 328    sprintf (num, "%d", nro);
 329    nro ++;
 330
 331    std::string filename = radical;
 332    filename += num;
 333    filename += ".vtk";
 334    int ier = saveVtk (filename.c_str());
 335    return ier;
 336 }
 337 // ========================================================= setDeprecated
 338 void Document::setDeprecated (int level)
 339 {
 340    switch (level)
 341           {
 342                          // En cas de destruction  : parents invalides
 343           case 2 : maj_connection  = true;
 344                    purge_elements  = true;
 345                    holes_elements  = true;
 346                          // creation + destruction : propagations a revoir
 347           case 1 : maj_propagation = true;
 348                          // Par defaut :
 349           default: doc_modified    = true;
 350                    count_modified  = true;
 351           }
 352 }
 353
 354 // ========================================================= addHexaGroup
 355 Group* Document::addHexaGroup (cpchar name)
 356 {
 357    DumpStart ("addHexaGroup", name);
 358    Group* groupe = addGroup (name, HexaCell);
 359
 360    DumpReturn (groupe);
 361    return groupe;
 362 }
 363 // ========================================================= addHexaNodeGroup
 364 Group* Document::addHexaNodeGroup (cpchar name)
 365 {
 366    DumpStart ("addHexaNodeGroup", name);
 367    Group* groupe = addGroup (name, HexaNode);
 368
 369    DumpReturn (groupe);
 370    return groupe;
 371 }
 372 // ========================================================= addQuadGroup
 373 Group* Document::addQuadGroup (cpchar name)
 374 {
 375    DumpStart ("addQuadGroup", name);
 376    Group* groupe = addGroup (name, QuadCell);
 377
 378    DumpReturn (groupe);
 379    return groupe;
 380 }
 381 // ========================================================= addQuadNodeGroup
 382 Group* Document::addQuadNodeGroup (cpchar name)
 383 {
 384    DumpStart ("addQuadNodeGroup", name);
 385    Group* groupe = addGroup (name, QuadNode);
 386
 387    DumpReturn (groupe);
 388    return groupe;
 389 }
 390 // ========================================================= addEdgeGroup
 391 Group* Document::addEdgeGroup (cpchar name)
 392 {
 393    DumpStart ("addEdgeGroup", name);
 394    Group* groupe = addGroup (name, EdgeCell);
 395
 396    DumpReturn (groupe);
 397    return groupe;
 398 }
 399 // ========================================================= addEdgeNodeGroup
 400 Group* Document::addEdgeNodeGroup (cpchar name)
 401 {
 402    DumpStart ("addEdgeNodeGroup", name);
 403    Group* groupe = addGroup (name, EdgeNode);
 404
 405    DumpReturn (groupe);
 406    return groupe;
 407 }
 408 // ========================================================= addVertexNodeGroup
 409 Group* Document::addVertexNodeGroup (cpchar name)
 410 {
 411    DumpStart ("addVertexNodeGroup", name);
 412    Group* groupe = addGroup (name, VertexNode);
 413
 414    DumpReturn (groupe);
 415    return groupe;
 416 }
 417 // ======================================================== addGroup
 418 Group* Document::addGroup (cpchar name, EnumGroup kind)
 419 {
 420    Group* grp = new Group (this, name, kind);
 421    doc_group.push_back (grp);
 422    return grp;
 423 }
 424 // ======================================================== findGroup
 425 Group* Document::findGroup (cpchar name)
 426 {
 427    DumpStart ("findGroup", name);
 428
 429    int    nbre   = doc_group.size();
 430    Group* groupe = NULL;
 431
 432    for (int ng=0 ; groupe==NULL && ng<nbre ; ng++)
 433        if (Cestegal (doc_group [ng]->getName(), name))
 434            groupe = doc_group [ng];
 435
 436    DumpReturn (groupe);
 437    return groupe;
 438 }
 439 // ======================================================== removeGroup
 440 int Document::removeGroup (Group* grp)
 441 {
 442    DumpStart ("removeGroup", grp );
 443
 444    int  nbre = doc_group.size();
 445    bool more = true;
 446    int  ier  = HERR;
 447
 448    for (int ng=0 ; more && ng<nbre ; ng++)
 449        {
 450        if (grp == doc_group [ng])
 451           {
 452           doc_group.erase (doc_group.begin() + ng);
 453           more = false;
 454           ier  = HOK;
 455           }
 456        }
 457                       // Si pas trouve dans la liste. On detruit quand meme
 458
 459    if (NOT (BadElement (grp)))
 460       grp->suppress ();
 461
 462    DumpReturn (ier);
 463    return ier;
 464 }
 465 // ----------------------------------------------------------------------------
 466 END_NAMESPACE_HEXA