TetMeshFacetedSurface that defines disk with torus around edge. More...

#include <tetmesh_faceted_surfaces.h>

Inheritance diagram for oomph::DiskWithTorusAroundEdgeTetMeshFacetedSurface:

Public Member Functions
	DiskWithTorusAroundEdgeTetMeshFacetedSurface (DiskLikeGeomObjectWithBoundaries *disk_parametrised_by_nonsingular_coordinates_pt, const unsigned &half_nsegment, const double &r_torus, const unsigned &nvertex_torus, const unsigned &first_one_based_boundary_id_for_disk, const unsigned &one_based_torus_region_id, unsigned &last_one_based_boundary_id_for_disk, unsigned &first_one_based_boundary_id_for_torus, unsigned &last_one_based_boundary_id_for_torus, Vector< unsigned > &one_based_boundary_id_for_disk_within_torus, Vector< unsigned > &one_based_boundary_id_for_disk_outside_torus)

Public Member Functions inherited from oomph::DiskTetMeshFacetedSurface
	DiskTetMeshFacetedSurface (DiskLikeGeomObjectWithBoundaries *disk_parametrised_by_nonsingular_coordinates_pt, const unsigned &half_nsegment, const unsigned &first_one_based_boundary_id_for_disk, unsigned &last_one_based_boundary_id_for_disk)

	~DiskTetMeshFacetedSurface ()
	Destructor. More...

void	boundary_zeta01 (const unsigned &facet_id, const double &zeta_boundary, Vector< double > &zeta)

Public Member Functions inherited from oomph::TetMeshFacetedSurface
	TetMeshFacetedSurface ()
	Constructor: More...

virtual	~TetMeshFacetedSurface ()
	Empty destructor. More...

unsigned	nvertex () const
	Number of vertices. More...

unsigned	nfacet () const
	Number of facets. More...

unsigned	one_based_facet_boundary_id (const unsigned &j) const
	One-based boundary id of j-th facet. More...

unsigned	one_based_vertex_boundary_id (const unsigned &j) const
	First (of possibly multiple) one-based boundary id of j-th vertex. More...

double	vertex_coordinate (const unsigned &j, const unsigned &i) const
	i-th coordinate of j-th vertex More...

unsigned	nvertex_on_facet (const unsigned &j) const
	Number of vertices defining the j-th facet. More...

bool	boundaries_can_be_split_in_tetgen ()
	Test whether boundary can be split in tetgen. More...

void	enable_boundaries_can_be_split_in_tetgen ()
	Test whether boundaries can be split in tetgen. More...

void	disable_boundaries_can_be_split_in_tetgen ()
	Test whether boundaries can be split in tetgen. More...

TetMeshFacet *	facet_pt (const unsigned &j) const
	Pointer to j-th facet. More...

TetMeshVertex *	vertex_pt (const unsigned &j) const
	Pointer to j-th vertex. More...

DiskLikeGeomObjectWithBoundaries *	geom_object_with_boundaries_pt ()

void	output (std::ostream &outfile) const
	Output. More...

void	output (const std::string &filename) const
	Output. More...

virtual void	boundary_zeta12 (const unsigned &facet_id, const double &zeta_boundary, Vector< double > &zeta)

virtual void	boundary_zeta20 (const unsigned &facet_id, const double &zeta_boundary, Vector< double > &zeta)

Vector< unsigned >	vertex_index_in_tetgen (const unsigned &f)

Public Member Functions inherited from oomph::TetMeshFacetedClosedSurface
	TetMeshFacetedClosedSurface ()
	Constructor: More...

virtual	~TetMeshFacetedClosedSurface ()
	Empty destructor. More...

void	enable_faceted_volume_represents_hole_for_gmsh ()
	Declare closed surface to represent hole for gmsh. More...

void	disable_faceted_volume_represents_hole_for_gmsh ()
	Declare closed surface NOT to represent hole for gmsh. More...

bool	faceted_volume_represents_hole_for_gmsh () const
	Does closed surface represent hole for gmsh? More...

const double &	internal_point_for_tetgen (const unsigned &j, const unsigned &i) const
	i=th coordinate of the j-th internal point for tetgen More...

void	set_hole_for_tetgen (const Vector< double > &hole_point)
	Specify coordinate of hole for tetgen. More...

void	set_region_for_tetgen (const unsigned &region_id, const Vector< double > &region_point)

unsigned	ninternal_point_for_tetgen ()

const int &	region_id_for_tetgen (const unsigned &j) const

bool	internal_point_identifies_hole_for_tetgen (const unsigned &j)
	Is j-th internal point for tetgen associated with a hole? More...

bool	internal_point_identifies_region_for_tetgen (const unsigned &j)
	Is j-th internal point for tetgen associated with a region? More...

Additional Inherited Members
Protected Attributes inherited from oomph::DiskTetMeshFacetedSurface
unsigned	Nfacet
	Number of facets. More...

std::vector< bool >	Facet_is_on_boundary
	Is facet on boundary? More...

Vector< double >	Left_boundary_coordinate
	Left boundary coordinate of i-th facet. More...

Vector< double >	Right_boundary_coordinate
	Right boundary coordinate of i-th facet. More...

Vector< unsigned >	Boundary_id
	ID of boundary the i-th facet is located on. More...

unsigned	Nelement_on_disk_boundary
	Number of elements on disk boundary. More...

TriangleMesh< TPoissonElement< 2, 2 > > *	Tri_mesh_pt
	Mesh used to facet-ise (discretise) disk. More...

std::map< Node , TetMeshVertex >	Equivalent_vertex_pt
	Mapping between nodes and vertices. More...

Protected Attributes inherited from oomph::TetMeshFacetedSurface
Vector< TetMeshVertex * >	Vertex_pt
	Vector pointers to vertices. More...

Vector< TetMeshFacet * >	Facet_pt
	Vector of pointers to facets. More...

bool	Boundaries_can_be_split_in_tetgen

Vector< Vector< unsigned > >	Facet_vertex_index_in_tetgen

DiskLikeGeomObjectWithBoundaries *	Geom_object_with_boundaries_pt
	GeomObject with boundaries associated with this surface. More...

Detailed Description

TetMeshFacetedSurface that defines disk with torus around edge.

//////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////

Constructor & Destructor Documentation

◆ DiskWithTorusAroundEdgeTetMeshFacetedSurface()

oomph::DiskWithTorusAroundEdgeTetMeshFacetedSurface::DiskWithTorusAroundEdgeTetMeshFacetedSurface	(	DiskLikeGeomObjectWithBoundaries *	disk_parametrised_by_nonsingular_coordinates_pt,
		const unsigned &	half_nsegment,
		const double &	r_torus,
		const unsigned &	nvertex_torus,
		const unsigned &	first_one_based_boundary_id_for_disk,
		const unsigned &	one_based_torus_region_id,
		unsigned &	last_one_based_boundary_id_for_disk,
		unsigned &	first_one_based_boundary_id_for_torus,
		unsigned &	last_one_based_boundary_id_for_torus,
		Vector< unsigned > &	one_based_boundary_id_for_disk_within_torus,
		Vector< unsigned > &	one_based_boundary_id_for_disk_outside_torus
	)

inline

Constructor: Pass pointer to GeomObject (with boundaries, and parametrised by coordinates without coordinate singularities, i.e. not polars, say) that defines the shape of the disk. Other args specify:

half the number of segments on perimeter of disk
radius of torus
number of vertices around the perimeter of the torus
first one-based boundary ID to be used to enumerate the boundaries on the disk
one based region ID for volume contained inside torus.

Computes:

last one-based boundary id used to enumerate boundaries on disk
first one-based boundary id used to enumerate boundaries on torus
last one-based boundary id used to enumerate boundaries on torus
vector containing one-based boundary ids of boundaries on disk enclosed within the torus
vector containing one-based boundary ids of boundaries on disk not enclosed within the torus

                                                                   :
  DiskTetMeshFacetedSurface(
   disk_parametrised_by_nonsingular_coordinates_pt,
   half_nsegment,
   first_one_based_boundary_id_for_disk,
   last_one_based_boundary_id_for_disk)
   {
    // Wipe
    one_based_boundary_id_for_disk_within_torus.clear();
    one_based_boundary_id_for_disk_outside_torus.clear();
  
  
    // Is element in torus region or not?
    std::map<FiniteElement*,bool> is_in_torus_region;
    {
     unsigned r=1;
     /* ofstream some_file; */
     /* some_file.open("tri_mesh_in_region1.dat");  */
     unsigned nel=Tri_mesh_pt->nregion_element(r);
     for(unsigned e=0;e<nel;e++)
      {
       FiniteElement* el_pt=Tri_mesh_pt->region_element_pt(r,e);
       is_in_torus_region[el_pt]=true;
       //unsigned npts=3;
       //el_pt->output(some_file,npts);
      }
     //some_file.close();
    }
     
    
    // Now loop over all elements   
    unsigned nel=Tri_mesh_pt->nelement();
    for (unsigned e=0;e<nel;e++)  
     {
      FiniteElement* el_pt=Tri_mesh_pt->finite_element_pt(e); 
      unsigned one_based_boundary_id=Facet_pt[e]->one_based_boundary_id();
      if (is_in_torus_region[el_pt])
       {
        Facet_pt[e]->set_one_based_region_that_facet_is_embedded_in
         (one_based_torus_region_id);
        one_based_boundary_id_for_disk_within_torus.push_back
         (one_based_boundary_id);
       }
      else
       {
        one_based_boundary_id_for_disk_outside_torus.push_back
         (one_based_boundary_id);
       }
     }
  
  
    // Now add torus:
    //---------------
    unsigned one_based_boundary_id=last_one_based_boundary_id_for_disk+1;
    first_one_based_boundary_id_for_torus=one_based_boundary_id;
  
    // Find sorted sequence of vertices going around the
    // inner boundary (innermost part of torus)
    Vector<TetMeshVertex*> sorted_vertex_pt;
    Vector<std::pair<TetMeshVertex*,double> > vertex_pt_and_boundary_coord;
    std::map<Node*,bool> done;
    Vector<double> boundary_zeta(1);
    for (unsigned b=2;b<=3;b++)
     {
      unsigned nnod=Tri_mesh_pt->nboundary_node(b);
      for (unsigned j=0;j<nnod;j++)
       {
        Node* nod_pt=Tri_mesh_pt->boundary_node_pt(b,j);
        if (!done[nod_pt])
         {
          nod_pt->get_coordinates_on_boundary(b,boundary_zeta);
          vertex_pt_and_boundary_coord.push_back(
           std::make_pair(Equivalent_vertex_pt[nod_pt],
                          boundary_zeta[0]));
          done[nod_pt]=true;
         }
       }
     }
  
    
  
    oomph_info << "Number of vertices on inner ring: "
               <<  vertex_pt_and_boundary_coord.size() << " "
               << " sum: "
               << Tri_mesh_pt->nboundary_node(2)+Tri_mesh_pt->nboundary_node(3)
               << std::endl;
    
    // Identify point in torus (for tetgen)
    Vector<double> point_in_torus(3);
    unsigned b=0;
    unsigned j=0;
    Node* nod_pt=Tri_mesh_pt->boundary_node_pt(b,j);
    point_in_torus[0]=Equivalent_vertex_pt[nod_pt]->x(0);
    point_in_torus[1]=Equivalent_vertex_pt[nod_pt]->x(1);
    point_in_torus[2]=Equivalent_vertex_pt[nod_pt]->x(2)+0.5*r_torus;
  
    oomph_info << "point in torus: " 
               << point_in_torus[0] << " " 
               << point_in_torus[1] << " " 
               << point_in_torus[2] << " " 
               << std::endl;
  
   // Sort based on boundary coordinate
   std::sort (vertex_pt_and_boundary_coord.begin(),
              vertex_pt_and_boundary_coord.end(),
              HelperForSortingVectorOfPairsOfVertexPtAndDouble::
              less_than_based_on_double);
  
   // Loop over annular rings
   unsigned n_vertices_on_annular_ring=nvertex_torus;
   unsigned n_new_vertices_on_annular_ring=
    n_vertices_on_annular_ring-2;
  
  
   // Storage for vertices and facets
   unsigned nv=Vertex_pt.size();
   unsigned jv=nv;
   nv+=n_new_vertices_on_annular_ring*
    vertex_pt_and_boundary_coord.size();
   Vertex_pt.resize(nv);
  
   unsigned jf=Nfacet;
   Nfacet+=(n_new_vertices_on_annular_ring+1)*
    (vertex_pt_and_boundary_coord.size());
   Facet_pt.resize(Nfacet);
  
  
   unsigned new_vertex_count=0;
   unsigned new_facet_count=0;
   unsigned n=vertex_pt_and_boundary_coord.size();
   Vector<Vector<TetMeshVertex*> > annulus_vertex_pt(n);
   for (unsigned j=0;j<n;j++)
    {
  
     // Wrap around for simplicity
     annulus_vertex_pt[j].resize(n_vertices_on_annular_ring);
     annulus_vertex_pt[j][0]=vertex_pt_and_boundary_coord[j].first;
     annulus_vertex_pt[j][n_vertices_on_annular_ring-1]=
      vertex_pt_and_boundary_coord[j].first;
  
     // Position of vertex
     Vector<double> vertex_position(3);
     vertex_position[0]=vertex_pt_and_boundary_coord[j].first->x(0);
     vertex_position[1]=vertex_pt_and_boundary_coord[j].first->x(1);
     vertex_position[2]=vertex_pt_and_boundary_coord[j].first->x(2);
  
     // Polar angle
     double theta=vertex_pt_and_boundary_coord[j].second;
  
     // Which boundary is this point located on?
     unsigned b=0;
     if (theta>Geom_object_with_boundaries_pt->zeta_boundary_end(0))
      {
       b=1;
      }
     double zeta_bound=theta;
  
     // Get coordinate on edge and normal and tangent vectors
     Vector<double> x(3);
     Vector<double> r_edge(3);
     Vector<double> normal(3);
     Vector<double> tangent(3);
     Vector<double> normal_normal(3);
     Geom_object_with_boundaries_pt->boundary_triad(b,
                                                    zeta_bound,
                                                    r_edge,
                                                    tangent,
                                                    normal,
                                                    normal_normal);
     
     // What rho do we need to create a circle, centred at the edge
     // going through current vertex?
     Vector<double> distance_to_edge(3);
     distance_to_edge[0]=r_edge[0]-vertex_position[0];
     distance_to_edge[1]=r_edge[1]-vertex_position[1];
     distance_to_edge[2]=r_edge[2]-vertex_position[2];
     double rho=sqrt(distance_to_edge[0]*distance_to_edge[0]+
                     distance_to_edge[1]*distance_to_edge[1]+
                     distance_to_edge[2]*distance_to_edge[2]);
  
     // What is the starting angle?
     double cos_phi0=(distance_to_edge[0]*normal[0]+
                      distance_to_edge[1]*normal[1]+
                      distance_to_edge[2]*normal[2])/rho;
     if (cos_phi0>1.0) cos_phi0=1.0;
     if (cos_phi0<-1.0) cos_phi0=-1.0;
  
     double phi_0=acos(cos_phi0);
     
     for (unsigned i=1;i<n_vertices_on_annular_ring-1;i++)
      {
       double phi=phi_0+double(i)/double(n_vertices_on_annular_ring-1)*
        2.0*MathematicalConstants::Pi-MathematicalConstants::Pi;
       x[0]=r_edge[0]+rho*cos(phi)*normal[0]+rho*sin(phi)*normal_normal[0];
       x[1]=r_edge[1]+rho*cos(phi)*normal[1]+rho*sin(phi)*normal_normal[1];
       x[2]=r_edge[2]+rho*cos(phi)*normal[2]+rho*sin(phi)*normal_normal[2];
       
       TetMeshVertex* new_vertex_pt=new TetMeshVertex(x);
       annulus_vertex_pt[j][i]=new_vertex_pt;
       Vertex_pt[jv]=new_vertex_pt;
       jv++;
       new_vertex_count++;
      }
    }
  
   for (unsigned i=0;i<n-1;i++)
    {
     unsigned m=annulus_vertex_pt[i].size();
     for (unsigned j=0;j<m-1;j++)
      {
       unsigned n_vertex_on_facet=4;
       TetMeshFacet* new_facet_pt=new TetMeshFacet(n_vertex_on_facet);
       new_facet_count++;
       new_facet_pt->set_vertex_pt(0,annulus_vertex_pt[i][j]);
       new_facet_pt->set_vertex_pt(1,annulus_vertex_pt[i][j+1]);
       new_facet_pt->set_vertex_pt(2,annulus_vertex_pt[i+1][j+1]);
       new_facet_pt->set_vertex_pt(3,annulus_vertex_pt[i+1][j]);
       Facet_pt[jf]=new_facet_pt;
       unsigned region_id=one_based_torus_region_id;
       Facet_pt[jf]->set_one_based_adjacent_region_id(region_id);
       Facet_pt[jf]->set_one_based_boundary_id(one_based_boundary_id);
       one_based_boundary_id++;
       jf++;
      }
    }
   
   unsigned m=annulus_vertex_pt[n-1].size();
   for (unsigned j=0;j<m-1;j++)
    {
     unsigned n_vertex_on_facet=4;
     TetMeshFacet* new_facet_pt=new TetMeshFacet(n_vertex_on_facet);
     new_facet_count++;
     new_facet_pt->set_vertex_pt(0,annulus_vertex_pt[n-1][j]);
     new_facet_pt->set_vertex_pt(1,annulus_vertex_pt[n-1][j+1]);
     new_facet_pt->set_vertex_pt(2,annulus_vertex_pt[0][j+1]);
     new_facet_pt->set_vertex_pt(3,annulus_vertex_pt[0][j]);
     Facet_pt[jf]=new_facet_pt;
     unsigned region_id=one_based_torus_region_id;
     Facet_pt[jf]->set_one_based_adjacent_region_id(region_id);
     Facet_pt[jf]->set_one_based_boundary_id(one_based_boundary_id);
     last_one_based_boundary_id_for_torus=one_based_boundary_id;
     one_based_boundary_id++;
     jf++;
    }
  
   oomph_info << "First/last one-based disk boundary ID: "
              << first_one_based_boundary_id_for_disk << " "
              << last_one_based_boundary_id_for_disk << std::endl;
  
  
   oomph_info << "First/last one-based torus boundary ID: "
              << first_one_based_boundary_id_for_torus << " "
              << last_one_based_boundary_id_for_torus << std::endl;
  
  
    // Is it a genuine region?
    if (one_based_torus_region_id>0)
     {
      set_region_for_tetgen(one_based_torus_region_id-1,point_in_torus);
     }
    else
     {
      std::ostringstream error_message;
      error_message << "one_based_torus_region_id must be strictly positive";
      throw OomphLibError(error_message.str(),
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
     }
  
  
  
   }

References acos(), b, oomph::DiskLikeGeomObjectWithBoundaries::boundary_triad(), cos(), e(), oomph::DiskTetMeshFacetedSurface::Equivalent_vertex_pt, oomph::TetMeshFacetedSurface::Facet_pt, oomph::TetMeshFacetedSurface::Geom_object_with_boundaries_pt, oomph::Node::get_coordinates_on_boundary(), i, j, oomph::HelperForSortingVectorOfPairsOfVertexPtAndDouble::less_than_based_on_double(), m, n, oomph::DiskTetMeshFacetedSurface::Nfacet, WallFunction::normal(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, oomph::MathematicalConstants::Pi, UniformPSDSelfTest::r, oomph::TetMeshFacetedClosedSurface::set_region_for_tetgen(), oomph::TetMeshFacet::set_vertex_pt(), sin(), sqrt(), BiharmonicTestFunctions2::theta, oomph::DiskTetMeshFacetedSurface::Tri_mesh_pt, oomph::TetMeshFacetedSurface::Vertex_pt, plotDoE::x, and oomph::DiskLikeGeomObjectWithBoundaries::zeta_boundary_end().

The documentation for this class was generated from the following file:

tetmesh_faceted_surfaces.h

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DiskWithTorusAroundEdgeTetMeshFacetedSurface()