21 |
#include <Variable.hpp> |
#include <Variable.hpp> |
22 |
|
|
23 |
#include <Mesh.hpp> |
#include <Mesh.hpp> |
24 |
|
|
25 |
|
#include <MeshOfHexahedra.hpp> |
26 |
|
#include <MeshOfTetrahedra.hpp> |
27 |
#include <Structured3DMesh.hpp> |
#include <Structured3DMesh.hpp> |
28 |
|
|
29 |
#include <SurfaceMeshOfTriangles.hpp> |
#include <SurfaceMeshOfTriangles.hpp> |
30 |
|
|
31 |
#include <MeshTetrahedrizor.hpp> |
#include <MeshTetrahedrizor.hpp> |
311 |
} |
} |
312 |
|
|
313 |
|
|
|
ReferenceCounting<MeshExpression> |
|
|
MeshExpressionTetrahedrize::mesh() |
|
|
{ |
|
|
fferr(0) << __FILE__ << ':' << __LINE__ << ": Not implemented\n"; |
|
|
std::exit(1); |
|
|
} |
|
|
|
|
314 |
void |
void |
315 |
MeshExpressionTetrahedrize::execute() |
MeshExpressionTetrahedrize::execute() |
316 |
{ |
{ |
347 |
; |
; |
348 |
} |
} |
349 |
|
|
350 |
|
template <typename ElementsGeometry, typename TypeOfMesh> |
351 |
|
ElementsGeometry MeshExpressionTransform:: |
352 |
|
__getElement(const TypeOfMesh& M, |
353 |
|
VerticesSet& V, |
354 |
|
size_t numberOfCell) |
355 |
|
{ |
356 |
|
fferr(0) << __FILE__ << ':' << __LINE__ << ": Not implemented\n"; |
357 |
|
std::exit(1); |
358 |
|
} |
359 |
|
|
360 |
|
template <> |
361 |
|
Hexahedron MeshExpressionTransform:: |
362 |
|
__getElement<Hexahedron>(const Structured3DMesh& m, |
363 |
|
VerticesSet& V, |
364 |
|
size_t i) |
365 |
|
{ |
366 |
|
const CartesianHexahedron& H = m.cell(i); |
367 |
|
const size_t i0 = m.vertexNumber(H(0)); |
368 |
|
const size_t i1 = m.vertexNumber(H(1)); |
369 |
|
const size_t i2 = m.vertexNumber(H(2)); |
370 |
|
const size_t i3 = m.vertexNumber(H(3)); |
371 |
|
const size_t i4 = m.vertexNumber(H(4)); |
372 |
|
const size_t i5 = m.vertexNumber(H(5)); |
373 |
|
const size_t i6 = m.vertexNumber(H(6)); |
374 |
|
const size_t i7 = m.vertexNumber(H(7)); |
375 |
|
|
376 |
|
return Hexahedron(V[i0],V[i1],V[i2],V[i3], |
377 |
|
V[i4],V[i5],V[i6],V[i7]); |
378 |
|
} |
379 |
|
|
380 |
|
template <> |
381 |
|
Tetrahedron MeshExpressionTransform:: |
382 |
|
__getElement<Tetrahedron>(const MeshOfTetrahedra& m, |
383 |
|
VerticesSet& V, |
384 |
|
size_t i) |
385 |
|
{ |
386 |
|
const Tetrahedron& T = m.cell(i); |
387 |
|
const size_t i0 = m.vertexNumber(T(0)); |
388 |
|
const size_t i1 = m.vertexNumber(T(1)); |
389 |
|
const size_t i2 = m.vertexNumber(T(2)); |
390 |
|
const size_t i3 = m.vertexNumber(T(3)); |
391 |
|
|
392 |
|
return Tetrahedron(V[i0],V[i1],V[i2],V[i3]); |
393 |
|
} |
394 |
|
|
395 |
|
|
396 |
|
template <typename TypeOfMesh> |
397 |
|
void MeshExpressionTransform::__transform(const Mesh& M) |
398 |
|
{ |
399 |
|
const TypeOfMesh& m = static_cast<const TypeOfMesh&>(M); |
400 |
|
|
401 |
|
typedef typename TypeOfMesh::Transformed NewMeshType; |
402 |
|
typedef typename NewMeshType::ElementsGeometry ElementsGeometry; |
403 |
|
|
404 |
|
ReferenceCounting<VerticesSet> v = new VerticesSet(m.numberOfVertices()); |
405 |
|
|
406 |
|
VerticesSet& vertices = *v; |
407 |
|
FunctionExpression& f1 = (*__transformationField).f1(); |
408 |
|
FunctionExpression& f2 = (*__transformationField).f2(); |
409 |
|
FunctionExpression& f3 = (*__transformationField).f3(); |
410 |
|
|
411 |
|
for (size_t i=0; i<m.numberOfVertices(); ++i) { |
412 |
|
const Vertex& X = m.vertex(i); |
413 |
|
vertices[i][0] = f1.value(X[0],X[1],X[2]); |
414 |
|
vertices[i][1] = f2.value(X[0],X[1],X[2]); |
415 |
|
vertices[i][2] = f3.value(X[0],X[1],X[2]); |
416 |
|
vertices[i].Ref() = X.Ref(); |
417 |
|
} |
418 |
|
|
419 |
|
ReferenceCounting<Vector<ElementsGeometry> > elements |
420 |
|
= new Vector<ElementsGeometry>(m.numberOfCells()); |
421 |
|
|
422 |
|
|
423 |
|
for (size_t i=0; i<m.numberOfCells(); ++i) { |
424 |
|
(*elements)[i] = __getElement<ElementsGeometry>(m, vertices, i); |
425 |
|
} |
426 |
|
|
427 |
|
__mesh = new NewMeshType(v, elements); |
428 |
|
} |
429 |
|
|
430 |
|
|
431 |
|
void |
432 |
|
MeshExpressionTransform::execute() |
433 |
|
{ |
434 |
|
(*__inputMesh).execute(); |
435 |
|
(*__transformationField).execute(); |
436 |
|
|
437 |
|
const Mesh& M = (*(*__inputMesh).mesh()); |
438 |
|
switch (M.type()) { |
439 |
|
case Mesh::cartesianHexahedraMesh: { |
440 |
|
this->__transform<Structured3DMesh>(M); |
441 |
|
break; |
442 |
|
} |
443 |
|
case Mesh::tetrahedraMesh: { |
444 |
|
this->__transform<MeshOfTetrahedra>(M); |
445 |
|
break; |
446 |
|
} |
447 |
|
default: { |
448 |
|
fferr(0) << __FILE__ << ':' << __LINE__ << ": Not implemented\n"; |
449 |
|
std::exit(1); |
450 |
|
} |
451 |
|
} |
452 |
|
} |
453 |
|
|
454 |
|
MeshExpressionTransform:: |
455 |
|
MeshExpressionTransform(ReferenceCounting<MeshExpression> m, |
456 |
|
ReferenceCounting<FieldExpression> f) |
457 |
|
: MeshExpression(0,MeshExpression::transform), |
458 |
|
__inputMesh(m), |
459 |
|
__transformationField(f) |
460 |
|
{ |
461 |
|
; |
462 |
|
} |
463 |
|
|
464 |
|
MeshExpressionTransform:: |
465 |
|
MeshExpressionTransform(const MeshExpressionTransform& m) |
466 |
|
: MeshExpression(m), |
467 |
|
__inputMesh(m.__inputMesh), |
468 |
|
__transformationField(m.__transformationField) |
469 |
|
{ |
470 |
|
; |
471 |
|
} |
472 |
|
|
473 |
|
MeshExpressionTransform:: |
474 |
|
~MeshExpressionTransform() |
475 |
|
{ |
476 |
|
; |
477 |
|
} |
478 |
|
|
479 |
|
|
480 |
MeshExpressionUndefined::MeshExpressionUndefined() |
MeshExpressionUndefined::MeshExpressionUndefined() |
481 |
: MeshExpression(0, MeshExpression::undefined) |
: MeshExpression(0, MeshExpression::undefined) |
482 |
{ |
{ |