← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Mesh/BackgroundMesh.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Christophe Prud'homme, Christophe Prud'homme
  • Date: 2009-07-13 15:49:21 UTC
  • mfrom: (7.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20090713154921-zer07j8wixwa07ig
Tags: 2.3.1.dfsg-4
http://bugs.debian.org/529972
[Christophe Prud'homme]
* Bug fix: "gmsh with cgns write support", thanks to Oliver Borm
  (Closes: #529972).
* debian/rules: make sure that Gmsh is built with occ support on all
  platforms thanks to Denis Barbier (#536435).

Show diffs side-by-side

added added

removed removed

Lines of Context:
Mesh/BackgroundMesh.cpp
13
13
#include "GModel.h"
14
14
#include "Field.h"
15
15
 
16
 
extern Context_T CTX;
17
 
 
18
16
// computes the characteristic length of the mesh at a vertex in order
19
17
// to have the geometry captured with accuracy. A parameter called
20
 
// CTX.mesh.min_circ_points tells the minimum number of points per
 
18
// CTX::instance()->mesh.minCircPoints tells the minimum number of points per
21
19
// radius of curvature
22
20
 
23
21
static double max_edge_curvature(const GVertex *gv)
77
75
  double Crv = 0;
78
76
  switch(ge->dim()){
79
77
  case 0:        
80
 
    // Crv = max_edge_curvature((const GVertex *)ge);
81
 
    // Crv = std::max(max_surf_curvature((const GVertex *)ge), Crv);
82
 
    Crv = max_surf_curvature((const GVertex *)ge);
 
78
    Crv = max_edge_curvature((const GVertex *)ge);
 
79
    Crv = std::max(max_surf_curvature((const GVertex *)ge), Crv);
 
80
    //Crv = max_surf_curvature((const GVertex *)ge);
83
81
    break;
84
82
  case 1:
85
83
    {
86
84
      GEdge *ged = (GEdge *)ge;
87
 
      //Crv = ged->curvature(U);
88
 
      //Crv = std::max(Crv, max_surf_curvature(ged, U));
89
 
      Crv = max_surf_curvature(ged, U);      
 
85
      Crv = ged->curvature(U);
 
86
      Crv = std::max(Crv, max_surf_curvature(ged, U));
 
87
      //Crv = max_surf_curvature(ged, U);      
90
88
    }
91
89
    break;
92
90
  case 2:
97
95
    break;
98
96
  }
99
97
 
100
 
  double lc = Crv > 0 ? 2 * M_PI / Crv / CTX.mesh.min_circ_points : MAX_LC;
 
98
  double lc = Crv > 0 ? 2 * M_PI / Crv / CTX::instance()->mesh.minCircPoints : MAX_LC;
101
99
  return lc;
102
100
}
103
101
 
111
109
      GVertex *gv = (GVertex *)ge;
112
110
      double lc = gv->prescribedMeshSizeAtVertex();
113
111
      // FIXME we might want to remove this to make all lc treatment consistent
114
 
      if(lc >= MAX_LC) return CTX.lc / 10.;
 
112
      if(lc >= MAX_LC) return CTX::instance()->lc / 10.;
115
113
      return lc;
116
114
    }
117
115
  case 1:
125
123
        double lc = (1 - a) * v1->prescribedMeshSizeAtVertex() +
126
124
          (a) * v2->prescribedMeshSizeAtVertex() ;
127
125
        // FIXME we might want to remove this to make all lc treatment consistent
128
 
        if(lc >= MAX_LC) return CTX.lc / 10.;
 
126
        if(lc >= MAX_LC) return CTX::instance()->lc / 10.;
129
127
        return lc;
130
128
      }
131
129
      else 
140
138
double BGM_MeshSize(GEntity *ge, double U, double V, double X, double Y, double Z)
141
139
{
142
140
  // default lc (mesh size == size of the model)
143
 
  double l1 = CTX.lc;
 
141
  double l1 = CTX::instance()->lc;
144
142
 
145
143
  // lc from points
146
144
  double l2 = MAX_LC;
147
 
  if(CTX.mesh.lc_from_points && ge->dim() < 2) 
 
145
  if(CTX::instance()->mesh.lcFromPoints && ge->dim() < 2) 
148
146
    l2 = LC_MVertex_PNTS(ge, U, V);
149
147
 
150
148
  // lc from curvature
151
149
  double l3 = MAX_LC;
152
 
  if(CTX.mesh.lc_from_curvature && ge->dim() < 3)
 
150
  if(CTX::instance()->mesh.lcFromCurvature && ge->dim() < 3)
153
151
    l3 = LC_MVertex_CURV(ge, U, V);
154
152
 
155
153
  // lc from fields
160
158
    if(f) l4 = (*f)(X, Y, Z, ge);
161
159
  }
162
160
 
163
 
  // take the minimum, then contrain by lc_min and lc_max
 
161
  // take the minimum, then contrain by lcMin and lcMax
164
162
  double lc = std::min(std::min(std::min(l1, l2), l3), l4);
165
 
  lc = std::max(lc, CTX.mesh.lc_min);
166
 
  lc = std::min(lc, CTX.mesh.lc_max);
 
163
  lc = std::max(lc, CTX::instance()->mesh.lcMin);
 
164
  lc = std::min(lc, CTX::instance()->mesh.lcMax);
167
165
 
168
166
  if(lc <= 0.){
169
167
    Msg::Error("Wrong characteristic length lc = %g (lcmin = %g, lcmax = %g)",
170
 
               lc, CTX.mesh.lc_min, CTX.mesh.lc_max);
 
168
               lc, CTX::instance()->mesh.lcMin, CTX::instance()->mesh.lcMax);
171
169
    lc = l1;
172
170
  }
173
171
 
174
 
  return lc * CTX.mesh.lc_factor;
 
172
  return lc * CTX::instance()->mesh.lcFactor;
175
173
}
176
174
 
177
175
bool Extend1dMeshIn2dSurfaces()
178
176
{
179
 
  return CTX.mesh.lc_extend_from_boundary ? true : false;
 
177
  return CTX::instance()->mesh.lcExtendFromBoundary ? true : false;
180
178
}
181
179
 
182
180
bool Extend2dMeshIn3dVolumes()
183
181
{
184
 
  return CTX.mesh.lc_extend_from_boundary ? true : false;
 
182
  return CTX::instance()->mesh.lcExtendFromBoundary ? true : false;
185
183
}