~njansson/dolfin/hpc

« back to all changes in this revision

Viewing changes to dolfin/mesh/ALE.cpp

  • Committer: Anders Logg
  • Date: 2008-05-28 09:03:15 UTC
  • mto: (2668.1.38 trunk)
  • mto: This revision was merged to the branch mainline in revision 2670.
  • Revision ID: logg@simula.no-20080528090315-9q4pm9mokn156ve5
ALE mesh smoothing updates

Show diffs side-by-side

added added

removed removed

Lines of Context:
2
2
// Licensed under the GNU LGPL Version 2.1.
3
3
//
4
4
// First added:  2008-05-02
5
 
// Last changed: 2008-05-27
 
5
// Last changed: 2008-05-28
6
6
 
7
7
#include <string.h>
8
8
#include <dolfin/common/Array.h>
9
9
#include <dolfin/common/constants.h>
10
10
#include <dolfin/mesh/Mesh.h>
 
11
#include <dolfin/mesh/MeshData.h>
11
12
#include <dolfin/mesh/Vertex.h>
12
13
#include <dolfin/mesh/Cell.h>
13
14
#include "ALE.h"
15
16
using namespace dolfin;
16
17
 
17
18
//-----------------------------------------------------------------------------
18
 
void ALE::move(Mesh& mesh, Mesh& new_boundary,
19
 
               const MeshFunction<uint>& vertex_map,
20
 
               const MeshFunction<uint>& cell_map,
21
 
               ALEMethod method)
 
19
void ALE::move(Mesh& mesh, Mesh& new_boundary, ALEType method)
22
20
{
23
21
  // Only implemented in 2D and 3D so far
24
22
  if (mesh.topology().dim() < 2 || mesh.topology().dim() > 3 )
25
23
    error("Mesh interpolation only implemented in 2D and 3D so far.");
26
24
 
 
25
  // Get vertex and cell maps
 
26
  const MeshFunction<uint>* vertex_map = new_boundary.data().meshFunction("vertex map");
 
27
  const MeshFunction<uint>* cell_map   = new_boundary.data().meshFunction("cell map");
 
28
  dolfin_assert(vertex_map);
 
29
  dolfin_assert(cell_map);
 
30
 
27
31
  // Extract old coordinates
28
32
  const uint dim = mesh.geometry().dim();
29
33
  const uint size = mesh.numVertices()*dim;
34
38
  if (method == hermite)
35
39
  {
36
40
    hermiteFunction(ghat, dim, new_boundary,
37
 
                    mesh, vertex_map, cell_map);
 
41
                    mesh, *vertex_map, *cell_map);
38
42
  }
39
43
 
40
44
  // Iterate over coordinates in mesh
41
45
  for (VertexIterator v(mesh); !v.end(); ++v)
42
 
    meanValue(new_x + v->index()*dim, dim, new_boundary, mesh, vertex_map, *v, ghat, method);
 
46
    meanValue(new_x + v->index()*dim, dim, new_boundary, mesh, *vertex_map, *v, ghat, method);
43
47
 
44
48
  // Update mesh coordinates
45
49
  for (VertexIterator v(mesh); !v.end(); ++v)
54
58
//-----------------------------------------------------------------------------
55
59
void ALE::meanValue(real* new_x, uint dim, Mesh& new_boundary,
56
60
                    Mesh& mesh, const MeshFunction<uint>& vertex_map,
57
 
                    Vertex& vertex, real** ghat, ALEMethod method)
 
61
                    Vertex& vertex, real** ghat, ALEType method)
58
62
{
59
63
  // Check if the point is on the boundary (no need to compute new coordinate)
60
64
  for (VertexIterator v(new_boundary); !v.end(); ++v)
140
144
  }
141
145
  // Scale by totalW
142
146
  if (method == lagrange) 
 
147
  {
143
148
    for (uint i = 0; i < dim; i++)
144
149
      new_x[i] /= totalW;
 
150
  }
145
151
  else
 
152
  {
146
153
    for (uint i = 0; i < dim; i++)
147
154
      new_x[i] = new_x[i]/totalW + herm[i]/(totalW*totalW);
 
155
  }
148
156
 
149
 
  cout<<"  New x: " << new_x[0] << " " << new_x[1] << " " << new_x[2] << endl;
 
157
  //cout << "  New x: " << new_x[0] << " " << new_x[1] << " " << new_x[2] << endl;
150
158
 
151
159
  // Free memory for d
152
160
  delete [] d;
222
230
                          Mesh& mesh, const MeshFunction<uint>& vertex_map, 
223
231
                          const MeshFunction<uint>& cell_map)
224
232
{
225
 
  cout<< "hermite " << new_boundary.numVertices() << endl;
226
233
  real ** dfdn = new real * [new_boundary.numVertices()];
227
234
  normals(dfdn, dim, new_boundary,
228
235
          mesh, vertex_map, cell_map);