LCOV - code coverage report
Current view: top level - extern/CAMAL - CAMALSizeEval.hpp (source / functions) Hit Total Coverage
Test: coverage_sk.info Lines: 2 5 40.0 %
Date: 2020-07-01 15:24:36 Functions: 1 2 50.0 %
Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : #ifndef MESHKIT_CAMAL_SIZE_EVAL_HPP
       2                 :            : #define MESHKIT_CAMAL_SIZE_EVAL_HPP
       3                 :            : 
       4                 :            : #include "CMLSizeEval.hpp"
       5                 :            : #include "meshkit/SizingFunction.hpp"
       6                 :            : namespace MeshKit 
       7                 :            : {
       8                 :            : 
       9                 :            : /** \class CAMALSizeEval CAMALSizeEval.hpp "CAMALSizeEval.hpp"
      10                 :            :  * \brief The MeshKit-based size evaluator for CAMAL meshing algorithms
      11                 :            :  */
      12                 :            : class CAMALSizeEval : public ::CMLSizeEval
      13                 :            : {
      14                 :            : public:
      15                 :            :     /** \brief Constructor
      16                 :            :      * \param size Size setting for this evaluator
      17                 :            :      */
      18                 :            :   CAMALSizeEval(double size, SizingFunction * szf = NULL);
      19                 :            :   
      20                 :            :     /** \brief Destructor
      21                 :            :      */
      22                 :            :   virtual ~CAMALSizeEval();
      23                 :            :   
      24                 :            :     /** \brief Get the desired mesh size at a point in space
      25                 :            :      *
      26                 :            :      * \param x The x coordinate of the point
      27                 :            :      * \param y The y coordinate of the point
      28                 :            :      * \param z The z coordinate of the point
      29                 :            :      * \param size The desired mesh size at the point.
      30                 :            :      * \param level The number of elements between the boundary and
      31                 :            :      * this point.
      32                 :            :      *
      33                 :            :      * \return \a true if a valid size is returned, \a false otherwise.
      34                 :            :      */
      35                 :            :   virtual bool size_at_point(double x, double y, double z, double& size, 
      36                 :            :                              int level = -1);
      37                 :            : 
      38                 :            :     /** \brief Get the desired anisotropic mesh size at a point in space in 
      39                 :            :      * the given direction
      40                 :            :      *
      41                 :            :      * \param loc_x The x coordinate of the location
      42                 :            :      * \param loc_y The y coordinate of the location
      43                 :            :      * \param loc_z The z coordinate of the location
      44                 :            :      * \param vec_x The x component of the vector to be stretched, 
      45                 :            :      * returned modified
      46                 :            :      * \param vec_y The y component of the vector to be stretched, 
      47                 :            :      * returned modified
      48                 :            :      * \param vec_z The z component of the vector to be stretched, 
      49                 :            :      * returned modified
      50                 :            :      *
      51                 :            :      * \return \a true if a valid size is returned, \a false otherwise.
      52                 :            :      */
      53                 :            :   virtual bool stretch_vector(double loc_x, double loc_y, double loc_z,
      54                 :            :                               double& vec_x, double& vec_y, double& vec_z);
      55                 :            : 
      56                 :            :     /** \brief Get the size tensor at a point in space
      57                 :            :      *
      58                 :            :      * \param x The x coordinate of the point
      59                 :            :      * \param y The y coordinate of the point
      60                 :            :      * \param z The z coordinate of the point
      61                 :            :      * \param size The size tensor at the point, xx, yy, zz, xy, yz, xz. 
      62                 :            :      * Pointer only changed if a NULL is passed in.
      63                 :            :      *
      64                 :            :      * \return \a true if a valid size is returned, \a false otherwise.
      65                 :            :      */
      66                 :            :   virtual bool tensor_at_point(double x, double y, double z, 
      67                 :            :                                double*& size);
      68                 :            : 
      69                 :            :     /** \brief Get the desired mesh size at a point on the surface
      70                 :            :      *
      71                 :            :      * \param u The u parametric coordinate of the point
      72                 :            :      * \param v The v parametric coordinate of the point
      73                 :            :      * \param size The desired mesh size at the point.
      74                 :            :      * \param level The number of elements between the boundary and
      75                 :            :      * this point.
      76                 :            :      *
      77                 :            :      * \return \a true if a valid size is returned, \a false otherwise.
      78                 :            :      */
      79                 :            :   virtual bool size_at_point(double u, double v, double& size, 
      80                 :            :                              int level = -1);
      81                 :            : 
      82                 :            :     /** \brief Get the desired anisotropic mesh size at a point in space in 
      83                 :            :      * the given direction
      84                 :            :      *
      85                 :            :      * \param loc_u The u parametric coordinate of the point in the 
      86                 :            :      * sizing field
      87                 :            :      * \param loc_v The v parametric coordinate of the point in the 
      88                 :            :      * sizing field
      89                 :            :      * \param vec_u The u component of the direction to be stretched, 
      90                 :            :      * returned modified
      91                 :            :      * \param vec_v The v component of the direction to be stretched, 
      92                 :            :      * returned modified
      93                 :            :      *
      94                 :            :      * \return \a true if a valid size is returned, \a false otherwise.
      95                 :            :      */
      96                 :            :   virtual bool stretch_vector(double loc_u, double loc_v,
      97                 :            :                               double& vec_u, double& vec_v);
      98                 :            : 
      99                 :            :     /** \brief Get the size tensor at a point in space
     100                 :            :      *
     101                 :            :      * \param u The u parametric coordinate of the point
     102                 :            :      * \param v The v parametric coordinate of the point
     103                 :            :      * \param size The size tensor at the point.  Pointer only changed
     104                 :            :      * if a NULL is passed in.
     105                 :            :      *
     106                 :            :      * \return \a true if a valid size is returned, \a false otherwise.
     107                 :            :      */
     108                 :            :   virtual bool tensor_at_point(double u, double v, 
     109                 :            :                                double*& size);
     110                 :            : 
     111                 :            :   /** \brief Get the desired mesh size at a point on a curve
     112                 :            :      *
     113                 :            :      * \param u The u parametric coordinate of the point
     114                 :            :      * \param size The desired mesh size at the point.
     115                 :            :      * \param level The number of elements between the boundary and
     116                 :            :      * this point.
     117                 :            :      *
     118                 :            :      * \return \a true if a valid size is returned, \a false otherwise.
     119                 :            :      */
     120                 :            :   virtual bool size_at_point(double u, double& size, 
     121                 :            :                              int level = -1);
     122                 :            : 
     123                 :            :     /** \brief Get whether the sizing function is anisotropic or not.
     124                 :            :      * \return \a true if sizing function is anisotropic
     125                 :            :      */
     126                 :            :   virtual bool is_anisotropic();
     127                 :            : 
     128                 :            :     /** \brief Get the mesh size set on this sizeeval
     129                 :            :      * \return Mesh size
     130                 :            :      */
     131                 :            :   double get_size();
     132                 :            :   
     133                 :            :     /** \brief Set the mesh size set on this sizeeval
     134                 :            :      * \param mesh_size Mesh size being set
     135                 :            :      */
     136                 :            :   void set_size(double mesh_size);
     137                 :            :   
     138                 :            : private:
     139                 :            :   double meshSize;
     140                 :            :   SizingFunction * sizingFunc;
     141                 :            : };
     142                 :            : 
     143                 :            : 
     144                 :         42 : inline double CAMALSizeEval::get_size() 
     145                 :            : {
     146                 :         42 :   return meshSize;
     147                 :            : }
     148                 :            : 
     149                 :          0 : inline void CAMALSizeEval::set_size(double mesh_size)
     150                 :            : {
     151                 :          0 :   meshSize = mesh_size;
     152                 :          0 : }
     153                 :            :   
     154                 :            : } // namespace MeshKit
     155                 :            : 
     156                 :            : #endif

Generated by: LCOV version 1.11