Define behavior of get_cell_t! for GridSurface2D; fix bug in tangent calc

Author: EdoAlvarezR

src/GeometricTools_grid.jl

@@ -214,10 +214,15 @@ function get_cell_t!(out, self::Grid, coor_in, lin, ndivscells)
       c2::Int = length(coor_in) >= 2 ? coor_in[2]==0 && ndivscells[2]==0 ? 1 : coor_in[2] : -1
       c3::Int = length(coor_in) >= 3 ? coor_in[3]==0 && ndivscells[3]==0 ? 1 : coor_in[3] : -1
 
+      # Catch case of 2D quasi dimensional space
+      if c3==-1 && length(coor_in)<3 && length(ndivscells)<3
+          c3 -= c3 - 1
+      end
+
       # ERROR CASE: Coordinates out of bounds
       if (c1 > ndivscells[1] && !(c1==1 && ndivscells[1]==0)) ||
          (c2 > ndivscells[2] && !(c2==1 && ndivscells[2]==0)) ||
-         (c3 > ndivscells[3] && !(c3==1 && ndivscells[3]==0)) ||
+         (length(coor_in)>=3 && c3 > ndivscells[3] && !(c3==1 && ndivscells[3]==0)) ||
          c1<=0 || c2<=0 || c3<=0
             error("Requested cell $(coor_in) but max cell is $(ndivscells). $((c1, c2, c3))")
       end
@@ -308,7 +313,7 @@ function get_cell_t!(out, self::Grid, coor_in, lin, ndivscells)
         return out
 
       else
-        error("Definition of $(self.ndims)-dimensional cells not implemented yet!")
+        error("Definition of $(self.dims)-dimensional cells not implemented yet!")
       end
 
   # end

src/GeometricTools_gridspecials2D.jl

@@ -4,7 +4,7 @@
 # AUTHORSHIP
   * Author    : Eduardo J Alvarez
   * Email     : [email protected]
-  * Created   : Jan 2024
+  * Created   : Jan 2025
   * License   : MIT License
 =###############################################################################
 
@@ -61,27 +61,36 @@ end
 
 get_node(self::GridSurface2D, args...; optargs...) = get_node(self.orggrid, args...; optargs...)
 get_cell(self::GridSurface2D, args...; optargs...) = get_cell(self.orggrid, args...; optargs...)
-get_cell_t!(self::GridSurface2D, args...; optargs...) = get_cell_t!(self.orggrid, args...; optargs...)
-generate_getcellt_args!(self::GridSurface2D, args...; optargs...) = get_cell(self.orggrid, args...; optargs...)
+get_cell_t!(out, self::GridSurface2D, args...; optargs...) = get_cell_t!(out, self.orggrid, args...; optargs...)
 lintransform!(self::GridSurface2D, args...; optargs...) = lintransform!(self.orggrid, args...; optargs...)
 
+function generate_getcellt_args!(self::GridSurface2D)
+
+        # Pre-allocate memory for panel calculation
+        lin = LinearIndices(self._ndivsnodes)
+        ndivscells = vcat(self._ndivscells...)
+        cin = CartesianIndices(Tuple(collect( 1:(d != 0 ? d : 1) for d in self._ndivscells)))
+        coor = zeros(Int, 2)
+        out = zeros(Int, 2)
+
+        return out, coor, lin, ndivscells, cin
+end
+
+
 get_area(self::GridSurface2D, i) = get_area2D(self._nodes, get_cell(self, i))
 function _get_area2D(nodes, panel)
     p1, p2 = panel
     return sqrt( (nodes[1, p2] - nodes[1, p1])^2 + (nodes[2, p2] - nodes[2, p1])^2 )
 end
 
 ##### INTERNAL FUNCTIONS  ######################################################
-_calc_t1_2D(args...) = _calc_t1(args...) / _calc_tnorm_2D(args...)
-_calc_t2_2D(args...) = _calc_t2(args...) / _calc_tnorm_2D(args...)
-_calc_tnorm_2D(nodes::AbstractMatrix, panel) = sqrt(
-                                                        (nodes[1, panel[2]] - nodes[1, panel[1]])^2
-                                                        + (nodes[2, panel[2]] - nodes[2, panel[1]])^2
-                                                    )
+_calc_t1_2D(nodes::AbstractMatrix, panel) = (nodes[1, panel[2]] - nodes[1, panel[1]]) / _calc_tnorm_2D(nodes, panel)
+_calc_t2_2D(nodes::AbstractMatrix, panel) = (nodes[2, panel[2]] - nodes[2, panel[1]]) / _calc_tnorm_2D(nodes, panel)
+_calc_tnorm_2D(nodes::AbstractMatrix, panel) = sqrt( (nodes[1, panel[2]] - nodes[1, panel[1]])^2 + (nodes[2, panel[2]] - nodes[2, panel[1]])^2 )
 
 _calc_n1aux_2D(nodes::AbstractMatrix, panel) = -(nodes[2, panel[2]] - nodes[2, panel[1]])
 _calc_n2aux_2D(nodes::AbstractMatrix, panel) = nodes[1, panel[2]] - nodes[1, panel[1]]
-_calc_nnorm_2D(args...) = sqrt(_calc_n1aux_2D(args...)^2 + _calc_n2aux_2D(args...)^2)
+_calc_nnorm_2D(args...) = sqrt( _calc_n1aux_2D(args...)^2 + _calc_n2aux_2D(args...)^2 )
 _calc_n1_2D(args...) = _calc_n1aux_2D(args...) / _calc_nnorm_2D(args...)
 _calc_n2_2D(args...) = _calc_n2aux_2D(args...) / _calc_nnorm_2D(args...)