← Back to branch summary

~ubuntu-branches/debian/squeeze/gmsh/squeeze

« back to all changes in this revision

Viewing changes to Geo/MZoneBoundary.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Christophe Prud'homme
  • Date: 2009-02-17 10:12:27 UTC
  • mfrom: (1.2.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20090217101227-mdrolkldak2pgd2i
Tags: 2.3.0.dfsg-1
* New upstream release
  + major graphics and GUI code refactoring; 
  + new full-quad/hexa subdivision algorithm (removed 
    Mesh.RecombineAlgo);
  + improved automatic transfinite corner selection (now also 
    for volumes); 
  + improved visibility browser; new automatic adaptive visualization
    for high-order simplices;
  + modified arrow size, clipping planes and transform options; many
    improvements and
  + bug fixes all over the place.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Geo/MZoneBoundary.cpp
1
 
// Gmsh - Copyright (C) 1997-2008 C. Geuzaine, J.-F. Remacle
 
1
// Gmsh - Copyright (C) 1997-2009 C. Geuzaine, J.-F. Remacle
2
2
//
3
3
// See the LICENSE.txt file for license information. Please report all
4
4
// bugs and problems to <gmsh@geuz.org>.
5
5
//
6
6
// MZoneBoundary.cpp - Copyright (C) 2008 S. Guzik, C. Geuzaine, J.-F. Remacle
7
7
 
 
8
#include "GmshConfig.h"
 
9
 
8
10
#if defined(HAVE_LIBCGNS)
9
11
 
10
12
#include <iostream> // DBG
152
154
 *   zoneBoVec          - (O) updated with domain boundary information for the
153
155
 *                            vertex
154
156
 *   patch              - (O) record BC patch index for an entity
155
 
 *   warnNormFromElem   - (I) wether a warning about obtaining normals from
 
157
 *   warnNormFromElem   - (I) whether a warning about obtaining normals from
156
158
 *                            elements has already been given. 
157
159
 *                        (O) set to true if warning given in this call
158
160
 *
202
204
 *                            and from which the normal will be determined
203
205
 *   faces              - (I) All faces on the boundary connected to 'vertex'
204
206
 *   boNormal           - (O) The normal to the boundary face (edge in 2D)
 
207
 *   onlyFace           - (I) If >= 0, only use this face to determine the
 
208
 *                            interior vertex and normal to the mesh plane.
205
209
 *   returns            - (O) 0 - success
206
 
 *                            1 - parFromPoint() failed
 
210
 *                            1 - no parameter found on edge for vertex
207
211
 *
208
212
 *============================================================================*/
209
213
 
210
214
int edge_normal
211
215
(const MVertex *const vertex, const int zoneIndex, const GEdge *const gEdge,
212
216
 const CCon::FaceVector<MZoneBoundary<2>::GlobalVertexData<MEdge>::FaceDataB>
213
 
 &faces, SVector3 &boNormal)
 
217
 &faces, SVector3 &boNormal, const int onlyFace = -1)
214
218
{
215
219
 
216
 
  const double par = gEdge->parFromPoint(vertex->point());
217
 
  if(par == std::numeric_limits<double>::max()) return 1;
 
220
  double par;
 
221
  // Note: const_cast used to match MVertex.cpp interface
 
222
  if(!reparamMeshVertexOnEdge(vertex, gEdge, par)) return 1;
218
223
 
219
224
  const SVector3 tangent(gEdge->firstDer(par));
220
225
                                        // Tangent to the boundary face
225
230
  // The interior point and mesh plane normal are computed from all elements in
226
231
  // the zone.
227
232
  int cFace = 0;
228
 
  const int nFace = faces.size();
229
 
  for(int iFace = 0; iFace != nFace; ++iFace) {
 
233
  int iFace = 0;
 
234
  int nFace = faces.size();
 
235
  if ( onlyFace >= 0 ) {
 
236
    iFace = onlyFace;
 
237
    nFace = onlyFace + 1;
 
238
  }
 
239
  for(; iFace != nFace; ++iFace) {
230
240
    if(faces[iFace].zoneIndex == zoneIndex) {
231
241
      ++cFace;
232
242
      interior += faces[iFace].parentElement->barycenter();
288
298
        // Get the edge entities that are connected to the vertex
289
299
        std::list<GEdge*> gEdgeList = ent->edges();
290
300
        // Find edge entities that are connected to elements in the zone
291
 
        std::vector<GEdge*> useGEdge;
 
301
        std::vector<std::pair<GEdge*, int> > useGEdge;
292
302
        const int nFace = faces.size();
293
303
        for(int iFace = 0; iFace != nFace; ++iFace) {
294
304
          if(zoneIndex == faces[iFace].zoneIndex) {
302
312
            // edge entities that will be used to determine the normal
303
313
            GEntity *const ent2 = vertex2->onWhat();
304
314
            if(ent2->dim() == 1) {
305
 
              useGEdge.push_back(static_cast<GEdge*>(ent2));
 
315
              useGEdge.push_back(std::pair<GEdge*, int>
 
316
                                 (static_cast<GEdge*>(ent2), iFace));
306
317
            }
307
318
          }
308
319
        }
321
332
        case 1:
322
333
          {
323
334
            const GEdge *const gEdge =
324
 
              static_cast<const GEdge*>(useGEdge[0]);
 
335
              static_cast<const GEdge*>(useGEdge[0].first);
325
336
            SVector3 boNormal;
326
337
            if(edge_normal(vertex, zoneIndex, gEdge, faces, boNormal))
327
338
               goto getNormalFromElements;
337
348
          {
338
349
            // Get the first normal
339
350
            const GEdge *const gEdge1 =
340
 
              static_cast<const GEdge*>(useGEdge[0]);
 
351
              static_cast<const GEdge*>(useGEdge[0].first);
341
352
            SVector3 boNormal1;
342
 
            if(edge_normal(vertex, zoneIndex, gEdge1, faces, boNormal1))
 
353
            if(edge_normal(vertex, zoneIndex, gEdge1, faces, boNormal1,
 
354
                           useGEdge[0].second))
343
355
              goto getNormalFromElements;
344
356
 
345
357
            // Get the second normal
346
358
            const GEdge *const gEdge2 =
347
 
              static_cast<const GEdge*>(useGEdge[1]);
 
359
              static_cast<const GEdge*>(useGEdge[1].first);
348
360
            SVector3 boNormal2;
349
 
            if(edge_normal(vertex, zoneIndex, gEdge2, faces, boNormal2))
 
361
            if(edge_normal(vertex, zoneIndex, gEdge2, faces, boNormal2,
 
362
                           useGEdge[1].second))
350
363
              goto getNormalFromElements;
351
364
 
352
365
            if(dot(boNormal1, boNormal2) < 0.98) {
629
642
 
630
643
        for(std::list<const GFace*>::const_iterator gFIt = useGFace.begin();
631
644
            gFIt != useGFace.end(); ++gFIt) {
632
 
          const SPoint2 par = (*gFIt)->parFromPoint(vertex->point());
633
 
          if(par.x() == std::numeric_limits<double>::max())  //**?
 
645
 
 
646
          SPoint2 par;
 
647
          if(!reparamMeshVertexOnFace(vertex, *gFIt, par))
634
648
            goto getNormalFromElements;  // :P  After all that!
635
649
 
636
650
          SVector3 boNormal = (*gFIt)->normal(par);
663
677
 
664
678
      {
665
679
        const GFace *const gFace = static_cast<const GFace*>(ent);
666
 
        const SPoint2 par = gFace->parFromPoint(vertex->point());
667
 
        if(par.x() == std::numeric_limits<double>::max())
 
680
        SPoint2 par;
 
681
        if(!reparamMeshVertexOnFace(vertex, gFace, par))
668
682
          goto getNormalFromElements;
669
683
 
670
684
        SVector3 boNormal = static_cast<const GFace*>(ent)->normal(par);