Complete updating delaunay optimality test to handle corner cases

Cleanup some template methods

Start a Geometry library for generic computational geometry methods

CMakeLists.txt

@@ -13,6 +13,7 @@ include_directories(./lib/GoogleTest/googletest/include/gtest/)
 add_subdirectory(./lib/)
 
 include_directories(./src/)
+include_directories(./src/Geometry/include/)
 include_directories(./src/Sketch/include/)
 include_directories(./src/Mesh/include/)
 include_directories(./src/Quadrature/include/)

src/CMakeLists.txt

+include_directories(./Geometry/)
 include_directories(./Sketch/)
 include_directories(./Mesh/)
 include_directories(./Quadrature/)
@@ -7,6 +8,7 @@ include_directories(./Materials/)
 include_directories(./Physics/)
 include_directories(./Model\ Templates/)
 
+add_subdirectory(./Geometry/)
 add_subdirectory(./Sketch/)
 add_subdirectory(./Mesh/)
 add_subdirectory(./Quadrature/)

src/Geometry/CMakeLists.txt

+PROJECT(Oersted_Geometry)
+
+set(SOURCE_FILES
+        ./include/Geometry.hpp
+
+        ./src/Ray.cpp ./src/Ray.h
+        ./src/Circle.cpp ./src/Circle.h)
+
+add_library(geometry SHARED ${SOURCE_FILES})
+
+target_link_libraries(geometry)
\ No newline at end of file

src/Geometry/include/Geometry.hpp

+#ifndef OERSTED_GEOMETRY_H
+#define OERSTED_GEOMETRY_H
+
+#include "../src/Ray.h"
+#include "../src/Circle.h"
+
+#endif //OERSTED_GEOMETRY_H

src/Geometry/src/Circle.cpp

+#include "Circle.h"
+#include "Ray.h"
+
+Circle Circle::calculate(double_t x0, double_t y0, double_t x1, double_t y1, Ray const &&ray) {
+    x0 -= ray.x;
+    x1 -= ray.x;
+    y0 -= ray.y;
+    y1 -= ray.y;
+
+    double_t dx = x1 - x0;
+    double_t dy = y1 - y0;
+
+    double_t t0 = atan2(dy, dx);
+    double_t t1 = t0 + M_PI_2;
+
+    double_t x2 = 0.5 * (x0 + x1);
+    double_t y2 = 0.5 * (y0 + y1);
+
+    double_t a0 = -sin(ray.a);
+    double_t b0 = +cos(ray.a);
+
+    double_t a1 = -sin(t1);
+    double_t b1 = +cos(t1);
+
+    double_t c = a1 * x2 + b1 * y2;
+    double_t d = a0 * b1 - a1 * b0;
+
+    double_t xc = -b0 * c / d;
+    double_t yc = +a0 * c / d;
+
+    double_t r = hypot(xc - x1, yc - y1);
+
+    xc += ray.x;
+    yc += ray.y;
+
+    return Circle{xc,yc,r};
+}
\ No newline at end of file

src/Geometry/src/Circle.h

+#ifndef OERSTED_CIRCLE_H
+#define OERSTED_CIRCLE_H
+
+#include <cmath>
+
+class Ray;
+
+class Circle {
+public:
+    double_t x;
+    double_t y;
+    double_t r;
+
+    static Circle calculate(double_t x0, double_t y0, double_t x1, double_t y1, Ray const &&ray);
+};
+
+#endif //OERSTED_CIRCLE_H
\ No newline at end of file

src/Geometry/src/Ray.cpp

+#include "Ray.h"
\ No newline at end of file

src/Geometry/src/Ray.h

+#ifndef OERSTED_RAY_H
+#define OERSTED_RAY_H
+
+#include <cmath>
+
+class Ray {
+public:
+    double_t x;
+    double_t y;
+    double_t a;
+};
+
+#endif //OERSTED_RAY_H

src/Mesh/src/Mesh.cpp

@@ -8,7 +8,6 @@ Mesh::Mesh(Sketch &sketch) {
             BoundaryConstraints.push_back(std::make_shared<BoundaryConstraint>(c));
         }
     }
-    sort_constraints();
 
     for (size_t i = 0; i != sketch.size_contours(); ++i) {
         Contours.push_back(sketch.contour(i));
@@ -262,7 +261,7 @@ bool Mesh::refine() {
         get_triangles();
     }
 
-    return edges_are_valid(); // TODO: Instrument in tests
+    return edges_are_valid();
 }
 
 bool Mesh::refine_once() {
@@ -280,7 +279,7 @@ bool Mesh::refine_once() {
     refine_once(index, radii, quality);
     get_triangles();
 
-    return edges_are_valid(); // TODO: Instrument in tests
+    return edges_are_valid();
 }
 
 bool Mesh::in_triangle(Point const p, size_t ei) const {
@@ -374,15 +373,22 @@ bool Mesh::is_locally_optimal(size_t ei) const {
         double_t d2 = std::sqrt(v2x * v2x + v2y * v2y);
         double_t d3 = std::sqrt(v3x * v3x + v3y * v3y);
         double_t d4 = std::sqrt(v4x * v4x + v4y * v4y);
-        //double_t tol = -std::sqrt(d1 * d2 * d3 * d4) * FLT_EPSILON * 0;
+        double_t tol = std::sqrt(d1 * d2 * d3 * d4) * DBL_EPSILON;
 
         double_t sina = v1x * v2y - v1y * v2x;
         double_t sinb = v3x * v4y - v3y * v4x;
         double_t cosa = v1x * v2x + v1y * v2y;
         double_t cosb = v3x * v4x + v3y * v4y;
-        double_t cct = sina * cosb + cosa * sinb;
 
-        return cct >= 0.0; // TODO: Optional tol for testing purposes
+        if (cosa < 0 && cosb < 0) {
+            return false;
+        } else if (cosa > 0 && cosb > 0) {
+            return true;
+        } else if ((cosa * sinb + sina * cosb) < -tol) {
+            return false;
+        }  else {
+            return true;
+        }
     }
 }
 
@@ -883,8 +889,6 @@ void Mesh::insert_internal_boundaries() {
         np_new = Points.size();
     }
 
-    sort_constraints();
-
     return;
 }
 
@@ -1019,15 +1023,13 @@ void Mesh::smooth() {
     Eigen::SparseLU<Eigen::SparseMatrix<double_t>> LU;
 
     LU.compute(A);
-    if(LU.info()!=Eigen::Success) {
-        std::cerr << "Factorization of mesh smoothing matrix was not successful";
-        return;
+    if(LU.info() != Eigen::Success) {
+        std::runtime_error("Factorization of mesh smoothing matrix was not successful");
     }
 
     q = LU.solve(b);
-    if(LU.info()!=Eigen::Success) {
-        std::cerr << "Mesh smoothing equation could not be solved";
-        return;
+    if(LU.info() != Eigen::Success) {
+        std::runtime_error("Mesh smoothing equation could not be solved");
     }
 
     for (size_t i = 0; i != num_points; ++i) {
@@ -1040,22 +1042,10 @@ void Mesh::smooth() {
     add_encroached_edges_to_queue_and_insert();
 
     if(!edges_are_optimal()) {
-        std::cerr << "Edges are not optimal" << std::endl;
-        throw;
+        std::cerr << "Warning: Edges are not optimal" << std::endl;
     }
 };
 
-void Mesh::sort_constraints() {
-    /*
-     * Sorts BoundaryConstraints by pointer address for fast lookup
-     */
-
-    std::cerr << "DO NOT SORT BY POINTER ADDRESS. THIS MAKES THINGS NONDETERMINISTIC" << std::endl;
-    auto comp = [](std::shared_ptr<BoundaryConstraint> const &x, std::shared_ptr<BoundaryConstraint> const &y) {return (size_t) (x->curve().get()) < (size_t) (y->curve().get());};
-
-    std::sort(BoundaryConstraints.begin(), BoundaryConstraints.end(), comp);
-}
-
 void Mesh::sort_constraints_by_length() {
     /*
      * Sorts BoundaryConstraints by length for internal boundary insertion
@@ -1281,9 +1271,6 @@ LocateTriangleResult Mesh::locate_triangle(Point const p, size_t &ei) const {
     double_t dx20 = p2.X - p0.X;
     double_t dy20 = p2.Y - p0.Y;
 
-    double_t tol_a = FLT_EPSILON * (dx20 * dy01 - dy20 * dx01);
-    double_t tol_l = FLT_EPSILON * sqrt(dx20 * dy01 - dy20 * dx01);
-
     double_t dist0 = sqrt(dx0p * dx0p + dy0p * dy0p);
     double_t dist1 = sqrt(dx1p * dx1p + dy1p * dy1p);
     double_t dist2 = sqrt(dx2p * dx2p + dy2p * dy2p);
@@ -1292,8 +1279,8 @@ LocateTriangleResult Mesh::locate_triangle(Point const p, size_t &ei) const {
     double_t area12 = dx1p * dy2p - dx2p * dy1p;
     double_t area20 = dx2p * dy0p - dx0p * dy2p;
 
-    tol_a = FLT_EPSILON * (dx20 * dy01 - dy20 * dx01);
-    tol_l = FLT_EPSILON * sqrt(dx20 * dy01 - dy20 * dx01);
+    //double_t tol_a = FLT_EPSILON * (dx20 * dy01 - dy20 * dx01);
+    double_t tol_l = FLT_EPSILON * sqrt(dx20 * dy01 - dy20 * dx01);
 
     if (dist0 < tol_l) {
         return LocateTriangleResult::Point;
@@ -1354,85 +1341,9 @@ LocateTriangleResult Mesh::locate_triangle(Point const p, size_t &ei) const {
         ei = prev(ei);
         return LocateTriangleResult::Exterior;
     } else {
-        std::cout << area01 << "," << area12 << "," << area20 << "," << tol_a << std::endl;
-        std::cout << xp << "," << yp << std::endl;
-        std::cout << p0.X << "," << p0.Y << std::endl;
-        std::cout << p1.X << "," << p1.Y << std::endl;
-        std::cout << p2.X << "," << p2.Y << std::endl;
-
-        std::cout << dist2 << "," << tol_l << std::endl;
-
         throw std::runtime_error(std::string("Could not locate triangle containing point"));
     }
 
-    /*
-    if (dist0 < tol_l) {
-        return LocateTriangleResult::Point;
-    } else if (dist1 < tol_l) {
-        ei = next(ei);
-        return LocateTriangleResult::Point;
-    } else if (dist2 < tol_l) {
-        ei = prev(ei);
-        return LocateTriangleResult::Point;
-    } else if (area01 > tol_a && area12 > tol_a && area20 > tol_a) {
-        return LocateTriangleResult::Interior;
-    } else if (area01 < -tol_a && ei != twin(ei)) {
-        ei = twin(ei);
-        p2 = p1;
-        p1 = p0;
-        p0 = p2;
-
-        dx2p = dx1p;
-        dx1p = dx0p;
-        dx0p = dx2p;
-
-        dy2p = dy1p;
-        dy1p = dy0p;
-        dy0p = dy2p;
-
-        dx01 = -dx01;
-        dy01 = -dy01;
-    } else if (area12 < -tol_a && next(ei) != twin(next(ei))) {
-        ei = twin(next(ei));
-        p0 = p2;
-
-        dx0p = dx2p;
-        dy0p = dy2p;
-
-        dx01 = -dx12;
-        dy01 = -dy12;
-    } else if (area20 < -tol_a && prev(ei) != twin(prev(ei))) {
-        ei = twin(prev(ei));
-        p1 = p2;
-
-        dx1p = dx2p;
-        dy1p = dy2p;
-
-        dx01 = -dx20;
-        dy01 = -dy20;
-    } else if (area01 > -tol_a && area12 > tol_a && area20 > tol_a) {
-        ei = twin(ei);
-        return LocateTriangleResult::Interior;
-    } else if (area01 > tol_a && area12 > -tol_a && area20 > tol_a) {
-        ei = twin(next(ei));
-        return LocateTriangleResult::Interior;
-    } else if (area01 > tol_a && area12 > tol_a && area20 > -tol_a) {
-        ei = twin(prev(ei));
-        return LocateTriangleResult::Interior;
-    } else if (area01 < -tol_a) {
-        return LocateTriangleResult::Exterior;
-    } else if (area12 < -tol_a) {
-        ei = next(ei);
-        return LocateTriangleResult::Exterior;
-    } else if (area20 < -tol_a) {
-        ei = prev(ei);
-        return LocateTriangleResult::Exterior;
-    } else {
-        std::cerr << "Could not locate triangle containing point" << std::endl;
-        throw std::runtime_error(std::string("1"));
-    }
-    */
-
     while (true) { // After first iteration, area01 > 0
         p2 = base(prev(ei));
 
@@ -1445,7 +1356,7 @@ LocateTriangleResult Mesh::locate_triangle(Point const p, size_t &ei) const {
         dx20 = p2.X - p0.X;
         dy20 = p2.Y - p0.Y;
 
-        tol_a = FLT_EPSILON * (dx20 * dy01 - dy20 * dx01);
+        //tol_a = FLT_EPSILON * (dx20 * dy01 - dy20 * dx01);
         tol_l = FLT_EPSILON * sqrt(dx20 * dy01 - dy20 * dx01);
 
         dist2 = sqrt(dx2p * dx2p + dy2p * dy2p);
@@ -1457,7 +1368,6 @@ LocateTriangleResult Mesh::locate_triangle(Point const p, size_t &ei) const {
             ei = prev(ei);
             return LocateTriangleResult::Point;
         } else if (area12 >= 0.0 && area20 >= 0.0) {
-            //std::cout << area01 << "," << area12 << "," << area20 << std::endl;
             return LocateTriangleResult::Interior;
         } else if (area12 < 0.0 && next(ei) != twin(next(ei))) {
                 ei = twin(next(ei));
@@ -1492,67 +1402,8 @@ LocateTriangleResult Mesh::locate_triangle(Point const p, size_t &ei) const {
             ei = prev(ei);
             return LocateTriangleResult::Exterior;
         } else {
-            std::cout << area01 << "," << area12 << "," << area20 << "," << tol_a << std::endl;
-            std::cout << xp << "," << yp << std::endl;
-            std::cout << p0.X << "," << p0.Y << std::endl;
-            std::cout << p1.X << "," << p1.Y << std::endl;
-            std::cout << p2.X << "," << p2.Y << std::endl;
-
-            std::cout << dist2 << "," << tol_l << std::endl;
-
             throw std::runtime_error(std::string("Could not locate triangle containing point"));
         }
-
-        /*
-        if (dist2 < tol_l) {
-            ei = prev(ei);
-            return LocateTriangleResult::Point;
-        } else if (area12 > tol_a && area20 > tol_a) {
-            return LocateTriangleResult::Interior;
-        } else if (area12 < -tol_a && next(ei) != twin(next(ei))) {
-            ei = twin(next(ei));
-            p0 = p2;
-
-            dx0p = dx2p;
-            dy0p = dy2p;
-
-            dx01 = -dx12;
-            dy01 = -dy12;
-            continue;
-        } else if (area20 < -tol_a && prev(ei) != twin(prev(ei))) {
-            ei = twin(prev(ei));
-            p1 = p2;
-
-            dx1p = dx2p;
-            dy1p = dy2p;
-
-            dx01 = -dx20;
-            dy01 = -dy20;
-            continue;
-        } else if (area12 > -tol_a && area20 > tol_a) {
-            ei = twin(next(ei));
-            return LocateTriangleResult::Interior;
-        } else if (area12 > tol_a && area20 > -tol_a) {
-            ei = twin(prev(ei));
-            return LocateTriangleResult::Interior;
-        } else if (area12 < -tol_a) {
-            ei = next(ei);
-            return LocateTriangleResult::Exterior;
-        } else if (area20 < -tol_a) {
-            ei = prev(ei);
-            return LocateTriangleResult::Exterior;
-        } else {
-            std::cout << area01 << "," << area12 << "," << area20 << "," << tol_a << std::endl;
-            std::cout << xp << "," << yp << std::endl;
-            std::cout << p0.X << "," << p0.Y << std::endl;
-            std::cout << p1.X << "," << p1.Y << std::endl;
-            std::cout << p2.X << "," << p2.Y << std::endl;
-
-            std::cout << dist2 << "," << tol_l << std::endl;
-
-            throw std::runtime_error(std::string("Could not locate triangle containing point"));
-        }
-         */
     }
 }
 
@@ -1775,8 +1626,7 @@ AddToQueueResult Mesh::add_point_to_queue(Point vc, size_t ei) {
         if (is_constrained(ei)) { // Move attempted insertion point to the midpoint of the located edge to force encroachement
             vc = midpoint(ei);
         } else {
-            std::cerr << "//TODO: No triangle found containing circumcenter, boundary edge was encroached by circumcenter, and the located edge was not a constrained edge" << std::endl;
-            throw std::runtime_error(std::string("3"));
+            throw std::runtime_error("TODO: No triangle found containing circumcenter, boundary edge was encroached by circumcenter, and the located edge was not a constrained edge");
         }
     }
 
@@ -1795,8 +1645,7 @@ AddToQueueResult Mesh::add_point_to_queue(Point vc, size_t ei) {
         return AddToQueueResult::Circumcenter;
 
     } else {
-        std::cerr << "No triangle could be found containing circumcenter and no boundary edge was encroached by circumcenter" << std::endl;
-        throw std::runtime_error(std::string("4"));
+        throw std::runtime_error("No triangle could be found containing circumcenter and no boundary edge was encroached by circumcenter");
     }
 }
 
@@ -1927,9 +1776,8 @@ Point Mesh::circumcenter(size_t ei) const {
 }
 
 std::shared_ptr<BoundaryConstraint> Mesh::boundary_constraint(std::shared_ptr<Curve const> const &c) const {
-    auto comp = [](std::shared_ptr<BoundaryConstraint> const &x, size_t const y) { return (size_t) (x->curve().get()) < y; };
-
-    std::shared_ptr<BoundaryConstraint> result = *std::lower_bound(BoundaryConstraints.begin(), BoundaryConstraints.end(), (size_t) c.get(), comp);
+    auto comp = [&c](std::shared_ptr<BoundaryConstraint> const&x) {return (size_t)(x->curve().get()) == (size_t)(c.get()); };
+    std::shared_ptr<BoundaryConstraint> result = *std::find_if(BoundaryConstraints.begin(), BoundaryConstraints.end(), comp);
 
     if ((size_t) (result->curve().get()) == (size_t) (c.get())) {
         return result;
@@ -1956,9 +1804,8 @@ std::shared_ptr<Contour const> Mesh::select_contour(Point const p) {
         iter = std::lower_bound(Triangles.begin(), Triangles.end(), e, [](DartTriangle const &t0, size_t te) { return t0.edge() < te; });
     }
 
-    if ((*iter).edge() != e) { // Fail
-        std::cerr << "Failed to locate contour containing point" << std::endl;
-        throw std::runtime_error(std::string("4"));
+    if ((*iter).edge() != e) {
+        std::runtime_error("Failed to locate contour containing point");
     }
 
     return Contours[iter->contour()];

src/Mesh/src/Mesh.h

@@ -158,7 +158,7 @@ public:
 
     std::shared_ptr<BoundaryConstraint> boundary_constraint(std::shared_ptr<Curve const> const &c) const;
 
-    std::shared_ptr<BoundaryConstraint> boundary_constraint(size_t i) const {return BoundaryConstraints[i]; };
+    std::shared_ptr<BoundaryConstraint> boundary_constraint(size_t i) const { return BoundaryConstraints[i]; };
 
     std::shared_ptr<MappedBoundaryPair> add_mapped_boundary_pair(ContinuousBoundaryPair const &cbp) {
         /*
@@ -400,8 +400,6 @@ private:
 
     void refine_once(std::vector<size_t> index, std::vector<double> circumradius, std::vector<double> quality);
 
-    void sort_constraints();
-
     void sort_constraints_by_length();
 
     void sort_permutation_ascending(std::vector<double> &value, std::vector<size_t> &index) const;

src/Model Templates/src/DistributedWindingStator.cpp

@@ -78,8 +78,6 @@ void DistributedWindingStator::add_to_sketch(Sketch &s, std::shared_ptr<Vertex>
 
     std::shared_ptr<MirrorCopy> mc = s.new_element<MirrorCopy>(copy_curves,L[1],true);
 
-    tol = s.solve();
-
     // Rotational Copy
     copy_curves.insert(copy_curves.end(),mc->curves().begin(),mc->curves().end());
 

src/Model Templates/src/SynchronousReluctanceRotor.cpp

 #include "SynchronousReluctanceRotor.h"
+#include "Geometry.hpp"
 
 void SynchronousReluctanceRotor::add_to_sketch(Sketch &s, std::shared_ptr<Vertex> origin) {
-    std::cout << "TODO: Clean up circular gutter center point calculation" << std::endl; // Put in a geometric utility library
-
     // Dimensions are approximate, sketch.solve() + constraints will impose real values
     double_t ri = InnerRadius;
     double_t ro = OuterRadius;
@@ -71,76 +70,22 @@ void SynchronousReluctanceRotor::add_to_sketch(Sketch &s, std::shared_ptr<Vertex
         C.push_back(c0);
 
         {
-            double_t x0 = xr[j];
-            double_t y0 = yr[j];
-
-            double_t x1 = xa[j];
-            double_t y1 = ya[j];
-
-            double_t dx = x1 - x0;
-            double_t dy = y1 - y0;
-
-            double_t t0 = atan2(dy, dx);
-            double_t t1 = t0 + M_PI_2;
-
-            double_t x2 = 0.5 * (x0 + x1);
-            double_t y2 = 0.5 * (y0 + y1);
-
-            double_t a0 = -sin(M_PI / Np);
-            double_t b0 = +cos(M_PI / Np);
-
-            double_t a1 = -sin(t1);
-            double_t b1 = +cos(t1);
-
-            double_t c = a1 * x2 + b1 * y2;
-            double_t d = a0 * b1 - a1 * b0;
-
-            double_t x3 = -b0 * c / d;
-            double_t y3 = +a0 * c / d;
-
-            double_t r3 = hypot(x3 - x1, y3 - y1);
+            Circle c = Circle::calculate(xr[j],yr[j],xa[j],ya[j],Ray{0.0,0.0,M_PI/Np});
 
-            auto vc1 = s.new_element<Vertex>(x3, y3);
+            auto vc1 = s.new_element<Vertex>(c.x, c.y);
             s.new_element<Coincident<LineSegment>>(vc1, L[1]);
 
-            auto c1 = s.new_element<CircularArc>(v1, v3, vc1, r3);
+            auto c1 = s.new_element<CircularArc>(v1, v3, vc1, c.r);
             C.push_back(c1);
         }
 
         {
-            double_t x0 = xr[j+1];
-            double_t y0 = yr[j+1];
-
-            double_t x1 = xa[j+1];
-            double_t y1 = ya[j+1];
-
-            double_t dx = x1 - x0;
-            double_t dy = y1 - y0;
-
-            double_t t0 = atan2(dy, dx);
-            double_t t1 = t0 + M_PI_2;
-
-            double_t x2 = 0.5 * (x0 + x1);
-            double_t y2 = 0.5 * (y0 + y1);
-
-            double_t a0 = -sin(M_PI / Np);
-            double_t b0 = +cos(M_PI / Np);
-
-            double_t a1 = -sin(t1);
-            double_t b1 = +cos(t1);
-
-            double_t c = a1 * x2 + b1 * y2;
-            double_t d = a0 * b1 - a1 * b0;
-
-            double_t x3 = -b0 * c / d;
-            double_t y3 = +a0 * c / d;
-
-            double_t r3 = hypot(x3 - x1, y3 - y1);
+            Circle c = Circle::calculate(xr[j+1],yr[j+1],xa[j+1],ya[j+1],Ray{0.0,0.0,M_PI/Np});
 
-            auto vc1 = s.new_element<Vertex>(x3, y3);
+            auto vc1 = s.new_element<Vertex>(c.x,c.y);
             s.new_element<Coincident<LineSegment>>(vc1, L[1]);
 
-            auto c1 = s.new_element<CircularArc>(v0, v2, vc1, r3);
+            auto c1 = s.new_element<CircularArc>(v0, v2, vc1, c.r);
             C.push_back(c1);
         }
         //auto vc2 = s.new_element<Vertex>(1.1 * ro * cos(a180p), 1.1 * ro * sin(a180p));
@@ -168,7 +113,7 @@ void SynchronousReluctanceRotor::add_to_sketch(Sketch &s, std::shared_ptr<Vertex
 
     std::shared_ptr<MirrorCopy> mc = s.new_element<MirrorCopy>(copy_curves,L[1],true);
 
-    tol = s.solve();
+    //tol = s.solve();
 
     if (Convexify) {
         convexify(s,origin,V[0],360.0/Poles);

src/Sketch/src/Sketch.cpp

@@ -28,8 +28,8 @@ double_t Sketch::solve() {
     Eigen::VectorXd lfs = Eigen::VectorXd::Zero(NumEquations);
 
     // Tolerances and iteration limits
-    double_t dbl_tol{std::sqrt(NumEquations + 1.0) * DBL_EPSILON};
-    double_t flt_tol{std::sqrt(NumEquations + 1.0) * FLT_EPSILON};
+    double_t dbl_tol{std::sqrt(NumEquations + 1.0) * DBL_EPSILON * 10.0};
+    double_t flt_tol{std::sqrt(NumEquations + 1.0) * FLT_EPSILON * 10.0};
 
     size_t double_bits = (size_t)std::log2(1/DBL_EPSILON);
 
@@ -48,11 +48,13 @@ double_t Sketch::solve() {
             std::cerr << "Linearized sketch equation could not be solved with an average error per equation less than FLT_EPSILON. Some elements may be over-constrained." << std::endl;
         }
 
+        /*
         long iter_rank = QR.rank();
         if (iter_rank < prev_rank) {
-            // perturb(delta, characteristic_length()); // perturb update in case of stagnation at inflection point
+            perturb(delta, characteristic_length()); // perturb update in case of stagnation at inflection point
         }
         prev_rank = iter_rank;
+        */
 
         update_variables(delta);
         update_linearization(J, r);
@@ -140,7 +142,7 @@ double_t Sketch::characteristic_length() const {
             ymin = std::max(ymin, Verticies[i]->y());
         }