LCOV - code coverage report
Current view: top level - algs/meshkit - EdgeMesher.hpp (source / functions) Hit Total Coverage
Test: coverage_sk.info Lines: 10 14 71.4 %
Date: 2020-07-01 15:24:36 Functions: 4 6 66.7 %
Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : //-----------------------------------C++-------------------------------------//
       2                 :            : // File: src/algs/EdgeMesher.hpp
       3                 :            : // Wednesday February 11 10:50 2011
       4                 :            : // Brief: EdgeMesher class definition: four schemes are provided: equal meshing,
       5                 :            : //        Bias Meshing, Dual Bias Meshing, Curvature-based meshing 
       6                 :            : //---------------------------------------------------------------------------//
       7                 :            : 
       8                 :            : #ifndef MESHKIT_EDGE_MESHER_HPP
       9                 :            : #define MESHKIT_EDGE_MESHER_HPP
      10                 :            : 
      11                 :            : #include <stdlib.h>
      12                 :            : #include <stdio.h>
      13                 :            : #include <assert.h>
      14                 :            : #include <string>
      15                 :            : #include <iostream>
      16                 :            : #include <fstream>
      17                 :            : #include <string.h>
      18                 :            : #include <limits.h>
      19                 :            : 
      20                 :            : #include "meshkit/iGeom.hpp"
      21                 :            : #include <set>
      22                 :            : #include <vector>
      23                 :            : 
      24                 :            : #include "meshkit/MeshScheme.hpp"
      25                 :            : 
      26                 :            : namespace MeshKit
      27                 :            : {
      28                 :            : //===========================================================================//
      29                 :            :   /*!
      30                 :            :    * \class EdgeMesher
      31                 :            :    * \brief Generate the mesh for edges
      32                 :            :    * 
      33                 :            :    * EdgeMesher generates a mesh for edges, creating the nodes and line segments
      34                 :            :    * on edges. There are four schemes for edge mesher: equal meshing, Bias Meshing
      35                 :            :    * Dual Bias Meshing, Curvature-Based Meshing
      36                 :            :    */
      37                 :            : //===========================================================================//
      38                 :            : 
      39                 :            : using namespace std;
      40                 :            : 
      41                 :            : class EdgeMesher : public MeshScheme
      42                 :            : {
      43                 :            : public:
      44                 :            :         //six schemes for edge meshing
      45                 :            :         enum EdgeSchemeType {EQUAL=0, BIAS, DUAL, CURVATURE, VARIABLE, EQUIGNOMONIC};
      46                 :            : 
      47                 :            :         
      48                 :            : public:
      49                 :            :         //construction function for edge mesher
      50                 :            :         EdgeMesher(MKCore *mk_core, const MEntVector &me_vec);
      51                 :            : 
      52                 :            :         //set up the parameters for edge meshing, e.g. compute the number of intervals
      53                 :            :         virtual void setup_this();
      54                 :            : 
      55                 :            :         //Generate the edge mesh
      56                 :            :         virtual void execute_this();
      57                 :            : 
      58                 :            :        /**\brief Get class name */
      59                 :       1180 :        static const char* name() 
      60                 :       1180 :          { return "EdgeMesher"; }
      61                 :            : 
      62                 :            :        /**\brief Function returning whether this scheme can mesh entities of t
      63                 :            :         *        the specified dimension.
      64                 :            :         *\param dim entity dimension
      65                 :            :         */
      66                 :        160 :        static bool can_mesh(iBase_EntityType dim)
      67                 :        160 :           { return iBase_EDGE == dim; }
      68                 :            : 
      69                 :            :        /** \brief Function returning whether this scheme can mesh the specified entity
      70                 :            :         * 
      71                 :            :         * Used by MeshOpFactory to find scheme for an entity.
      72                 :            :         * \param me ModelEnt being queried
      73                 :            :         * \return If true, this scheme can mesh the specified ModelEnt
      74                 :            :         */
      75                 :          0 :        static bool can_mesh(ModelEnt *me)
      76                 :          0 :           { return canmesh_edge(me); }
      77                 :            : 
      78                 :            : 
      79                 :            :        /**\brief Get list of mesh entity types that can be generated.
      80                 :            :         *\return array terminated with \c moab::MBMAXTYPE
      81                 :            :         */
      82                 :            :        static const moab::EntityType* output_types();
      83                 :            : 
      84                 :            :        /** \brief Return the mesh entity types operated on by this scheme
      85                 :            :         * \return array terminated with \c moab::MBMAXTYPE
      86                 :            :         */
      87                 :          0 :        virtual const moab::EntityType* mesh_types_arr() const
      88                 :          0 :          { return output_types(); }
      89                 :            : 
      90                 :            :   // set/get some options
      91                 :            :   EdgeSchemeType get_edge_scheme() const;
      92                 :            :   void set_edge_scheme(EdgeSchemeType scheme);
      93                 :            : 
      94                 :            :   // used in bias and dual meshing schemes
      95                 :            :   void set_ratio(double q);
      96                 :            :   double get_ratio();
      97                 :            :         ~EdgeMesher();
      98                 :            :         
      99                 :            : private:
     100                 :            : 
     101                 :            :         struct Point3D
     102                 :            :         {
     103                 :            :                 double px;
     104                 :            :                 double py;
     105                 :            :                 double pz;      
     106                 :            :         };
     107                 :            : 
     108                 :            :         EdgeSchemeType schemeType;
     109                 :            :         double ratio;
     110                 :            : 
     111                 :            :         //return x, y, z coordinates based on the parametric coordinate u on the edge
     112                 :            :         Point3D getXYZCoords(ModelEnt *ent, double u) const;
     113                 :            :         
     114                 :            :         //return the parametrical coordinate based the starting parametric coordinate ustart and distance in physical space
     115                 :            :         double getUCoord(ModelEnt *ent, double ustart, double dist, double uguess, double umin, double umax) const;
     116                 :            : 
     117                 :            :         //Create more nodes if there is a high curvature on the edge
     118                 :            :         void DivideIntoMore(ModelEnt *ent, Point3D p0, Point3D pMid, Point3D p1, double u0, double u1, double uMid, int &index, vector<double> &nodes, vector<double> &URecord);
     119                 :            : 
     120                 :            :         //calculate the error between the line segments and the edge in the physical space
     121                 :            :         bool ErrorCalculate(ModelEnt *ent, Point3D p0, Point3D p1, Point3D pMid);
     122                 :            : 
     123                 :            :         //Sort the nodes on the edge
     124                 :            :         void RapidSorting(vector<double> &nodes, vector<double> &URecord, int left, int right);
     125                 :            :         void QuickSorting(vector<double> &nodes, vector<double> &URecord, int count);
     126                 :            : 
     127                 :            :         //four schemes for edge meshing
     128                 :            :         //create the mesh for edges with equal distances
     129                 :            :         void EqualMeshing(ModelEnt *ent, int num_edges, std::vector<double> &coords);
     130                 :            : 
     131                 :            :         //create the mesh for edges with bias distances
     132                 :            :         void BiasMeshing(ModelEnt *ent, int num_edges, std::vector<double> &coords);
     133                 :            : 
     134                 :            :         //create the mesh for edges with dual bias distances
     135                 :            :         void DualBiasMeshing(ModelEnt *ent, int &num_edges, std::vector<double> &coords);
     136                 :            : 
     137                 :            :         //create the mesh for edges based on curvatures 
     138                 :            :         void CurvatureMeshing(ModelEnt *ent, int &num_edges, std::vector<double> &coords);
     139                 :            : 
     140                 :            :         //create the mesh for edges based on variable size from SizingFunction (var)
     141                 :            :         void VariableMeshing(ModelEnt *ent, int &num_edges, std::vector<double> &coords);
     142                 :            : 
     143                 :            :         //create the edge mesh on the edge on a cube, such that the
     144                 :            :         // dihedral angles from the center of the cube are equal (for gnomonic equi angle mesh on the sphere)
     145                 :            :         void EquiAngleGnomonic(ModelEnt *ent, int num_edges, std::vector<double> &coords);
     146                 :            :         //compute the distance between the parametric coordinate ustart and parametric coordinate uend.
     147                 :            :         //double measure(iGeom::EntityHandle ent, double ustart, double uend) const;
     148                 :            : 
     149                 :            : };
     150                 :            : 
     151                 :            : //set up the scheme type for edge meshing
     152                 :          2 : inline void EdgeMesher::set_edge_scheme(EdgeMesher::EdgeSchemeType scheme)
     153                 :            : {
     154                 :          2 :         schemeType = scheme;
     155                 :          2 : }
     156                 :            : 
     157                 :            : //return the scheme type for edge meshing
     158                 :            : inline EdgeMesher::EdgeSchemeType EdgeMesher::get_edge_scheme() const
     159                 :            : {
     160                 :            :         return schemeType;
     161                 :            : }
     162                 :            : 
     163                 :            : // set the ratio for bias or dual meshing
     164                 :          1 : inline void EdgeMesher::set_ratio(double q)
     165                 :            : {
     166                 :          1 :   ratio = q;
     167                 :          1 : }
     168                 :            : 
     169                 :            : // get the ratio for bias or dual meshing
     170                 :            : inline double EdgeMesher::get_ratio()
     171                 :            : {
     172                 :            :   return ratio;
     173                 :            : }
     174                 :            : }
     175                 :            : 
     176                 :            : #endif

Generated by: LCOV version 1.11