/[ff3d]/ff3d/language/MeshExpression.cpp
ViewVC logotype

Diff of /ff3d/language/MeshExpression.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1.1.1 by delpinux, Mon Feb 17 16:32:52 2003 UTC revision 1.2 by delpinux, Tue Feb 25 20:38:42 2003 UTC
# Line 21  Line 21 
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>
# Line 307  MeshExpressionRead::~MeshExpressionRead( Line 311  MeshExpressionRead::~MeshExpressionRead(
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  {  {
# Line 350  MeshExpressionTetrahedrize:: Line 347  MeshExpressionTetrahedrize::
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  {  {

Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.2

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26