bspy 4.0__py3-none-any.whl → 4.2__py3-none-any.whl

bspy/_spline_fitting.py

@@ -11,6 +11,16 @@ def circular_arc(radius, angle, tolerance = None):
     samples = int(max(np.ceil(((1.1536e-5 * radius / tolerance)**(1/8)) * angle / 90), 2.0)) + 1
     return bspy.Spline.section([(radius * np.cos(u * angle * np.pi / 180), radius * np.sin(u * angle * np.pi / 180), 90 + u * angle, 1.0 / radius) for u in np.linspace(0.0, 1.0, samples)])
 
+def composition(splines, tolerance):
+    # Define the callback function
+    def composition_of_splines(u):
+        for f in splines[::-1]:
+            u = f(u)
+        return u
+    
+    # Approximate this composition
+    return bspy.Spline.fit(splines[-1].domain(), composition_of_splines, tolerance = tolerance)
+
 def cone(radius1, radius2, height, tolerance = None):
     if tolerance is None:
         tolerance = 1.0e-12
@@ -23,7 +33,7 @@ def cone(radius1, radius2, height, tolerance = None):
     return bspy.Spline.ruled_surface(bottom, top)
 
 # Courtesy of Michael Epton - Translated from his F77 code lgnzro
-def _legendre_polynomial_zeros(degree):
+def _legendre_polynomial_zeros(degree, mapToZeroOne = True):
     def legendre(degree, x):
         p = [1.0, x]
         pd = [0.0, 1.0]
@@ -35,6 +45,7 @@ def _legendre_polynomial_zeros(degree):
         return p, pd
     zval = 1.0
     z = []
+    zNegative = []
     for iRoot in range(degree // 2):
         done = False
         while True:
@@ -49,21 +60,28 @@ def _legendre_polynomial_zeros(degree):
             if dz < 1.0e-10:
                 done = True
         z.append(zval)
+        zNegative.append(-zval)
         zval -= 0.001
     if degree % 2 == 1:
-        z.append(0.0)
+        zNegative.append(0.0)
     z.reverse()
+    z = np.array(zNegative + z)
     w = []
     for zval in z:
         p, pd = legendre(degree, zval)
         w.append(2.0 / ((1.0 - zval ** 2) * pd[-1] ** 2))
+    w = np.array(w)
+    if mapToZeroOne:
+        z = 0.5 * (1.0 + z)
+        w = 0.5 * w
     return z, w
 
 def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
     # Set up parameters for initial guess of x(t) and validate arguments.
     order = 4
     degree = order - 1
-    rhos, gaussWeights = _legendre_polynomial_zeros(degree - 1)
+    gaussNodes, gaussWeights = _legendre_polynomial_zeros(degree - 1)
+
     if not(len(knownXValues) >= 2): raise ValueError("There must be at least 2 known x values.")
     m = len(knownXValues) - 1
     nCoef = m * (degree - 1) + 2
@@ -80,60 +98,67 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
         FValues = F(knownXValue)
         if not(len(FValues) == nDep - 1 and np.linalg.norm(FValues) < evaluationEpsilon):
             raise ValueError(f"F(known x) must be a zero vector of length {nDep - 1}.")
-    coefsMin = knownXValues.min(axis=0)
-    coefsMaxMinusMin = knownXValues.max(axis=0) - coefsMin
-    coefsMaxMinusMin = np.where(coefsMaxMinusMin < 1.0, 1.0, coefsMaxMinusMin)
+
+    # Record domain of F and scaling of coefficients.
+    if isinstance(F, (bspy.Spline, bspy.SplineBlock)):
+        FDomain = F.domain().T
+        coefsMin = FDomain[0]
+        coefsMaxMinusMin = FDomain[1] - FDomain[0]
+    else:
+        FDomain = np.array(nDep * [[-np.inf, np.inf]]).T
+        coefsMin = knownXValues.min(axis=0)
+        coefsMaxMinusMin = knownXValues.max(axis=0) - coefsMin
+        coefsMaxMinusMin = np.where(coefsMaxMinusMin < 1.0, 1.0, coefsMaxMinusMin)
+
+    # Rescale known values.
     coefsMaxMinMinReciprocal = np.reciprocal(coefsMaxMinusMin)
     knownXValues = (knownXValues - coefsMin) * coefsMaxMinMinReciprocal # Rescale to [0 , 1]
 
-    # Establish the first derivatives of F.
+    # Establish the Jacobian of F.
     if dF is None:
-        dF = []
-        if isinstance(F, bspy.Spline):
-            for i in range(nDep):
-                def splineDerivative(x, i=i):
-                    wrt = [0] * nDep
-                    wrt[i] = 1
-                    return F.derivative(wrt, x)
-                dF.append(splineDerivative)
+        if isinstance(F, (bspy.Spline, bspy.SplineBlock)):
+            dF = F.jacobian
         else:
-            for i in range(nDep):
-                def fDerivative(x, i=i):
+            def fJacobian(x):
+                value = np.empty((nDep - 1, nDep), float)
+                for i in range(nDep):
                     h = epsilon * (1.0 + abs(x[i]))
                     xShift = np.array(x, copy=True)
                     xShift[i] -= h
                     fLeft = np.array(F(xShift))
                     h2 = h * 2.0
                     xShift[i] += h2
-                    return (np.array(F(xShift)) - fLeft) / h2
-                dF.append(fDerivative)
-    else:
+                    value[:, i] = (np.array(F(xShift)) - fLeft) / h2
+                return value
+            dF = fJacobian
+    elif not callable(dF):
         if not(len(dF) == nDep): raise ValueError(f"Must provide {nDep} first derivatives.")
+        def fJacobian(x):
+            value = np.empty((nDep - 1, nDep), float)
+            for i in range(nDep):
+                value[:, i] = dF[i]
+            return value
+        dF = fJacobian
 
     # Construct knots, t values, and GSamples.
     tValues = np.empty(nUnknownCoefs, contourDtype)
     GSamples = np.empty((nUnknownCoefs, nDep), contourDtype)
-    t = 0.0 # We start with t measuring contour length.
+    t = 0.0 # t ranges from 0 to 1
+    dt = 1.0 / m
     knots = [t] * order
     i = 0
     previousPoint = knownXValues[0]
     for point in knownXValues[1:]:
-        dt = np.linalg.norm(point - previousPoint)
-        if not(dt > epsilon): raise ValueError("Points must be separated by at least epsilon.")
-        for rho in reversed(rhos):
-            tValues[i] = t + 0.5 * dt * (1.0 - rho)
-            GSamples[i] = 0.5 * (previousPoint + point - rho * (point - previousPoint))
-            i += 1
-        for rho in rhos[0 if degree % 2 == 1 else 1:]:
-            tValues[i] = t + 0.5 * dt * (1.0 + rho)
-            GSamples[i] = 0.5 * (previousPoint + point + rho * (point - previousPoint))
+        for gaussNode in gaussNodes:
+            tValues[i] = t + gaussNode * dt
+            GSamples[i] = (1.0 - gaussNode) * previousPoint + gaussNode * point
             i += 1
         t += dt
         knots += [t] * (order - 2)
         previousPoint = point
     knots += [t] * 2 # Clamp last knot
-    knots = np.array(knots, contourDtype) / t # Rescale knots
-    tValues /= t # Rescale t values
+    knots = np.array(knots, contourDtype)
+    knots[nCoef:] = 1.0 # Ensure last knot is exactly 1.0
     assert i == nUnknownCoefs
     
     # Start subdivision loop.
@@ -161,8 +186,6 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
         # Array to hold the Jacobian of the FSamples with respect to the coefficients.
         # The Jacobian is banded due to B-spline local support, so initialize it to zero.
         dFCoefs = np.zeros((nUnknownCoefs, nDep, nCoef, nDep), contourDtype)
-        # Working array to hold the transpose of the Jacobian of F for a particular x(t).
-        dFX = np.empty((nDep, nDep - 1), contourDtype)
 
         # Start Newton's method loop.
         previousFSamplesNorm = 0.0
@@ -184,6 +207,7 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
 
                 # Do the same for F(x(t)).
                 x = coefsMin + (compactCoefs.T @ bValues) * coefsMaxMinusMin
+                x = np.maximum(FDomain[0], np.minimum(FDomain[1], x))
                 FValues = F(x)
                 FSamplesNorm = max(FSamplesNorm, np.linalg.norm(FValues, np.inf))
                 if previousFSamplesNorm > 0.0 and FSamplesNorm > previousFSamplesNorm * (1.0 - evaluationEpsilon):
@@ -194,9 +218,7 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
                 FSamples[i, -1] = dotValues
 
                 # Compute the Jacobian of FSamples with respect to the coefficients of x(t).
-                for j in range(nDep):
-                    dFX[j] = dF[j](x) * coefsMaxMinusMin[j]
-                FValues = np.outer(dFX.T, bValues).reshape(nDep - 1, nDep, order).swapaxes(1, 2)
+                FValues = np.outer(dF(x) * coefsMaxMinusMin, bValues).reshape(nDep - 1, nDep, order).swapaxes(1, 2)
                 dotValues = (np.outer(d2Values, compactCoefs.T @ dValues) + np.outer(dValues, compactCoefs.T @ d2Values)).reshape(order, nDep)
                 dFCoefs[i, :-1, ix - order:ix, :] = FValues
                 dFCoefs[i, -1, ix - order:ix, :] = dotValues
@@ -253,33 +275,21 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
             newKnot = 0.5 * (previousKnot + knot)
 
             # Place tValues at Gauss points for the intervals [previousKnot, newKnot] and [newKnot, knot].
-            for rho in reversed(rhos):
-                tValues[i] = t = 0.5 * (previousKnot + newKnot - rho * (newKnot - previousKnot))
-                GSamples[i] = x = compactCoefs.T @ bspy.Spline.bspline_values(ix, knots, order, t)[1]
-                FSamplesNorm = max(FSamplesNorm, np.linalg.norm(F(coefsMin + x * coefsMaxMinusMin), np.inf))
-                i += 1
-            for rho in rhos[0 if degree % 2 == 1 else 1:]:
-                tValues[i] = t = 0.5 * (previousKnot + newKnot + rho * (newKnot - previousKnot))
-                GSamples[i] = x = compactCoefs.T @ bspy.Spline.bspline_values(ix, knots, order, t)[1]
-                FSamplesNorm = max(FSamplesNorm, np.linalg.norm(F(coefsMin + x * coefsMaxMinusMin), np.inf))
-                i += 1
-            for rho in reversed(rhos):
-                tValues[i] = t = 0.5 * (newKnot + knot - rho * (knot - newKnot))
-                GSamples[i] = x = compactCoefs.T @ bspy.Spline.bspline_values(ix, knots, order, t)[1]
-                FSamplesNorm = max(FSamplesNorm, np.linalg.norm(F(coefsMin + x * coefsMaxMinusMin), np.inf))
-                i += 1
-            for rho in rhos[0 if degree % 2 == 1 else 1:]:
-                tValues[i] = t = 0.5 * (newKnot + knot + rho * (knot - newKnot))
-                GSamples[i] = x = compactCoefs.T @ bspy.Spline.bspline_values(ix, knots, order, t)[1]
-                FSamplesNorm = max(FSamplesNorm, np.linalg.norm(F(coefsMin + x * coefsMaxMinusMin), np.inf))
-                i += 1
+            for knotInterval in [[previousKnot, newKnot], [newKnot, knot]]:
+                for gaussNode in gaussNodes:
+                    tValues[i] = t = (1.0 - gaussNode) * knotInterval[0] + gaussNode * knotInterval[1]
+                    x = compactCoefs.T @ bspy.Spline.bspline_values(ix, knots, order, t)[1]
+                    x = np.array([max(0.0, min(1.0, xi)) for xi in x])
+                    GSamples[i] = x
+                    FSamplesNorm = max(FSamplesNorm, np.linalg.norm(F(coefsMin + x * coefsMaxMinusMin), np.inf))
+                    i += 1
             
             newKnots += [newKnot] * (order - 2) # C1 continuity
             newKnots += [knot] * (order - 2) # C1 continuity
             previousKnot = knot
         
         # Test if F(GSamples) is close enough to zero.
-        if FSamplesNorm / np.linalg.norm(dHCoefs, np.inf) < epsilon:
+        if FSamplesNorm < evaluationEpsilon:
             break # We're done! Exit subdivision loop and return x(t).
 
         # Otherwise, update nCoef and knots array, and then re-run Newton's method.
@@ -292,7 +302,7 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
     # Rescale x(t) back to original data points.
     coefs = (coefsMin + coefs * coefsMaxMinusMin).T
     spline = bspy.Spline(1, nDep, (order,), (nCoef,), (knots,), coefs, metadata)
-    if isinstance(F, bspy.Spline):
+    if isinstance(F, (bspy.Spline, bspy.SplineBlock)):
         spline = spline.confine(F.domain())
     return spline
 
@@ -303,6 +313,122 @@ def cylinder(radius, height, tolerance = None):
     top = bottom + [0.0, 0.0, height]
     return bspy.Spline.ruled_surface(bottom, top)
 
+def fit(domain, f, order = None, knots = None, tolerance = 1.0e-4):
+    # Determine number of independent variables
+    domain = np.array(domain)
+    nInd = len(domain)
+    midPoint = f(0.5 * (domain.T[0] + domain.T[1]))
+    if not type(midPoint) is bspy.Spline:
+        nDep = len(midPoint)
+
+    # Make sure order and knots conform to this
+    if order is None:
+        order = nInd * [4]
+    if len(order) != nInd:
+        raise ValueError("Inconsistent number of independent variables")
+
+    # Establish the initial knot sequence
+    if knots is None:
+        knots = np.array([order[iInd] * [domain[iInd, 0]] + order[iInd] * [domain[iInd, 1]] for iInd in range(nInd)])
+    
+    # Determine initial nCoef
+    nCoef = [len(knotVector) - iOrder for iOrder, knotVector in zip(order, knots)]
+
+    # Define function to insert midpoints
+    def addMidPoints(u):
+        newArray = np.empty([2, len(u)])
+        newArray[0] = u
+        newArray[1, :-1] = 0.5 * (u[1:] + u[:-1])
+        return newArray.T.flatten()[:-1]
+    
+    # Track the current spline space we're fitting in
+    currentSpace = bspy.Spline(nInd, 0, order, nCoef, knots, [])
+
+    # Generate the Greville points for these knots
+    uvw = [currentSpace.greville(iInd) for iInd in range(nInd)]
+
+    # Enrich the sample points
+    for iInd in range(nInd):
+        uvw[iInd][0] = knots[iInd][order[iInd] - 1]
+        uvw[iInd][-1] = knots[iInd][nCoef[iInd]]
+        for iLevel in range(1):
+            uvw[iInd] = addMidPoints(uvw[iInd])
+
+    # Initialize the dictionary of function values
+
+    fDictionary = {}
+
+    # Keep looping until done
+    while True:
+
+        # Evaluate the function on this data set
+        fValues = []
+        indices = nInd * [0]
+        iLast = nInd
+        while iLast >= 0:
+            uValue = tuple([uvw[i][indices[i]] for i in range(nInd)])
+            if not uValue in fDictionary:
+                fDictionary[uValue] = f(uValue)
+            fValues.append(fDictionary[uValue])
+            iLast = nInd - 1
+            while iLast >= 0:
+                indices[iLast] += 1
+                if indices[iLast] < len(uvw[iLast]):
+                    break
+                indices[iLast] = 0
+                iLast -= 1
+
+        # Adjust the ordering
+        pointShape = [len(uvw[i]) for i in range(nInd)]
+        if type(midPoint) is bspy.Spline:
+            fValues = np.array(fValues).reshape(pointShape)
+        else:
+            fValues = np.array(fValues).reshape(pointShape + [nDep]).transpose([nInd] + list(range(nInd)))
+
+        # Call the least squares fitter on this data
+        bestSoFar = bspy.Spline.least_squares(uvw, fValues, order, currentSpace.knots, fixEnds = True)
+
+        # Determine the maximum error
+        maxError = 0.0
+        for key in fDictionary:
+            if type(midPoint) is bspy.Spline:
+                sampled = bestSoFar.contract(midPoint.nInd * [None] + list(key)).coefs
+                trueCoefs = fDictionary[key].coefs
+                thisError = np.max(np.linalg.norm(sampled - trueCoefs, axis = 0))
+            else:
+                thisError = np.linalg.norm(fDictionary[key] - bestSoFar(key))
+            if thisError > maxError:
+                maxError = thisError
+                maxKey = key
+        if maxError <= tolerance:
+            break
+
+        # Split the interval and try again
+        maxGap = 0.0
+        for iInd in range(nInd):
+            insert = bspy.Spline.bspline_values(None, currentSpace.knots[iInd], order[iInd], maxKey[iInd])[0]
+            leftKnot = currentSpace.knots[iInd][insert - 1]
+            rightKnot = currentSpace.knots[iInd][insert]
+            if rightKnot - leftKnot > maxGap:
+                maxGap = rightKnot - leftKnot
+                iFirst = np.searchsorted(uvw[iInd], leftKnot, side = 'right')
+                iLast = np.searchsorted(uvw[iInd], rightKnot, side = 'right')
+                maxLeft = leftKnot
+                maxRight = rightKnot
+                maxInd = iInd
+        splitAt = 0.5 * (maxLeft + maxRight)
+        newKnots = [[] for iInd in range(nInd)]
+        newKnots[maxInd] = [splitAt]
+        currentSpace = currentSpace.insert_knots(newKnots)
+
+        # Add samples for the new knot
+        uvw[maxInd] = np.array(list(uvw[maxInd][:iFirst - 1]) +
+                               list(addMidPoints(uvw[maxInd][iFirst - 1:iLast])) +
+                               list(uvw[maxInd][iLast:]))
+
+    # Return the best spline found so far
+    return bestSoFar
+
 def four_sided_patch(bottom, right, top, left, surfParam = 0.5):
     if bottom.nInd != 1 or right.nInd != 1 or top.nInd != 1 or left.nInd != 1:
         raise ValueError("Input curves must have one independent variable")
@@ -408,68 +534,72 @@ def geodesic(self, uvStart, uvEnd, tolerance = 1.0e-6):
     # Define the callback function for the ODE solver
     def geodesicCallback(t, u, surface, uvDomain):
         # Evaluate the surface information needed for the Christoffel symbols
-        u[0, 0] = max(uvDomain[0, 0], min(uvDomain[0, 1], u[0, 0]))
-        u[1, 0] = max(uvDomain[1, 0], min(uvDomain[1, 1], u[1, 0]))
+        u[:, 0] = np.maximum(uvDomain[:, 0], np.minimum(uvDomain[:, 1], u[:, 0]))
         su = surface.derivative([1, 0], u[:, 0])
         sv = surface.derivative([0, 1], u[:, 0])
         suu = surface.derivative([2, 0], u[:, 0])
         suv = surface.derivative([1, 1], u[:, 0])
         svv = surface.derivative([0, 2], u[:, 0])
+        suuu = surface.derivative([3, 0], u[:, 0])
+        suuv = surface.derivative([2, 1], u[:, 0])
+        suvv = surface.derivative([1, 2], u[:, 0])
+        svvv = surface.derivative([0, 3], u[:, 0])
 
-        # Calculate the first fundamental form
-        E = su @ su
-        F = su @ sv
-        G = sv @ sv
+        # Calculate inner products
+        su_su = su @ su
+        su_sv = su @ sv
+        sv_sv = sv @ sv
+        suu_su = suu @ su
+        suu_sv = suu @ sv
+        suv_su = suv @ su
+        suv_sv = suv @ sv
+        svv_su = svv @ su
+        svv_sv = svv @ sv
+        suu_suu = suu @ suu
+        suu_suv = suu @ suv
+        suu_svv = suu @ svv
+        suv_suv = suv @ suv
+        suv_svv = suv @ svv
+        svv_svv = svv @ svv
+        suuu_su = suuu @ su
+        suuu_sv = suuu @ sv
+        suuv_su = suuv @ su
+        suuv_sv = suuv @ sv
+        suvv_su = suvv @ su
+        suvv_sv = suvv @ sv
+        svvv_su = svvv @ su
+        svvv_sv = svvv @ sv
+
+        # Calculate the first fundamental form and derivatives
+        E = su_su
+        E_u = 2.0 * suu_su
+        E_v = 2.0 * suv_su
+        F = su_sv
+        F_u = suu_sv + suv_su
+        F_v = suv_sv + svv_su
+        G = sv_sv
+        G_u = 2.0 * suv_sv
+        G_v = 2.0 * svv_sv
         A = np.array([[E, F], [F, G]])
+        A_u = np.array([[E_u, F_u], [F_u, G_u]])
+        A_v = np.array([[E_v, F_v], [F_v, G_v]])
 
         # Compute right hand side entries
-        R_uuu = suu @ su
-        R_uuv = suu @ sv
-        R_uvu = suv @ su
-        R_uvv = suv @ sv
-        R_vvu = svv @ su
-        R_vvv = svv @ sv
-        R = np.array([[R_uuu, R_uvu, R_vvu], [R_uuv, R_uvv, R_vvv]])
+        R = np.array([[suu_su, suv_su, svv_su], [suu_sv, suv_sv, svv_sv]])
+        R_u = np.array([[suuu_su + suu_suu, suuv_su + suu_suv, suvv_su + suu_svv],
+                        [suuu_sv + suu_suv, suuv_sv + suv_suv, suvv_sv + suv_svv]])
+        R_v = np.array([[suuv_su + suu_suv, suvv_su + suv_suv, svvv_su + suv_svv],
+                        [suuv_sv + suu_svv, suvv_sv + suv_svv, svvv_sv + svv_svv]])
 
         # Solve for the Christoffel symbols
         luAndPivot = sp.linalg.lu_factor(A)
         Gamma = sp.linalg.lu_solve(luAndPivot, R)
+        Gamma_u = sp.linalg.lu_solve(luAndPivot, R_u - A_u @ Gamma)
+        Gamma_v = sp.linalg.lu_solve(luAndPivot, R_v - A_v @ Gamma)
 
         # Compute the right hand side for the ODE
         rhs = -np.array([Gamma[0, 0] * u[0, 1] ** 2 + 2.0 * Gamma[0, 1] * u[0, 1] * u[1, 1] + Gamma[0, 2] * u[1, 1] ** 2,
                          Gamma[1, 0] * u[0, 1] ** 2 + 2.0 * Gamma[1, 1] * u[0, 1] * u[1, 1] + Gamma[1, 2] * u[1, 1] ** 2])
-        
-        # Now we need the derivatives of the Christoffel symbols with respect to u
-        suuu = surface.derivative([3, 0], u[:, 0])
-        suuv = surface.derivative([2, 1], u[:, 0])
-        suvv = surface.derivative([1, 2], u[:, 0])
-        svvv = surface.derivative([0, 3], u[:, 0])
-        E_u = 2.0 * R_uuu
-        F_u = R_uuv + R_uvu
-        G_u = 2.0 * R_uvv
-        A_u = np.array([[E_u, F_u], [F_u, G_u]])
-        R_uuu_u = suuu @ su + suu @ suu
-        R_uuv_u = suuu @ sv + suu @ suv
-        R_uvu_u = suuv @ su + suv @ suu
-        R_uvv_u = suuv @ sv + suv @ suv
-        R_vvu_u = suvv @ su + svv @ suu
-        R_vvv_u = suvv @ sv + svv @ suv
-        R_u = np.array([[R_uuu_u, R_uvu_u, R_vvu_u], [R_uuv_u, R_uvv_u, R_vvv_u]])
-        Gamma_u = sp.linalg.lu_solve(luAndPivot, R_u - A_u @ Gamma)
-
-        # . . . And the derivatives of the Christoffel symbols with respect to v
-        E_v = 2.0 * R_uvu
-        F_v = R_uvv + R_vvu
-        G_v = 2.0 * R_vvv
-        A_v = np.array([[E_v, F_v], [F_v, G_v]])
-        R_uuu_v = suuv @ su + suu @ suv
-        R_uuv_v = suuv @ sv + suu @ svv
-        R_uvu_v = suvv @ su + suv @ suv
-        R_uvv_v = suvv @ sv + suv @ svv
-        R_vvu_v = svvv @ su + svv @ suv
-        R_vvv_v = svvv @ sv + svv @ svv
-        R_v = np.array([[R_uuu_v, R_uvu_v, R_vvu_v], [R_uuv_v, R_uvv_v, R_vvv_v]])
-        Gamma_v = sp.linalg.lu_solve(luAndPivot, R_v - A_v @ Gamma)
 
         # Compute the Jacobian matrix of the right hand side of the ODE
         jacobian = -np.array([[[Gamma_u[0, 0] * u[0, 1] ** 2 + 2.0 * Gamma_u[0, 1] * u[0, 1] * u[1, 1] + Gamma_u[0, 2] * u[1, 1] ** 2,
@@ -707,7 +837,10 @@ def section(xytk):
         onePlusCosTheta = 1.0 + math.cos(theta)
         r0 = 4.0 * startKappa * tangentDistances[0] ** 2 / (3.0 * tangentDistances[1] * crossTangents)
         r1 = 4.0 * endKappa * tangentDistances[1] ** 2 / (3.0 * tangentDistances[0] * crossTangents)
-        rhoCrit = (math.sqrt(1.0 + 4.0 * (r0 + r1)) - 1.0) / (2.0 * (r0 + r1))
+        if r0 != 0.0 or r1 != 0.0:
+            rhoCrit = (math.sqrt(1.0 + 4.0 * (r0 + r1)) - 1.0) / (2.0 * (r0 + r1))
+        else:
+            rhoCrit = 1.0
         rhoCritOfTheta = 3.0 * (math.sqrt(1.0 + 32.0 / (3.0 * onePlusCosTheta)) - 1.0) * onePlusCosTheta / 16.0
 
         # Determine quadratic polynomial
@@ -797,11 +930,7 @@ def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = ()):
         for knot0, knot1 in zip(currentGuess.knots[0][:-1], currentGuess.knots[0][1:]):
             if knot0 < knot1:
                 for gaussNode in gaussNodes:
-                    alpha = 0.5 * (1.0 - gaussNode)
-                    collocationPoints.append((1.0 - alpha) * knot0 + alpha * knot1)
-                    if abs(gaussNode) > 1.0e-5:
-                        collocationPoints.append(alpha * knot0 + (1.0 - alpha) * knot1)
-        collocationPoints = np.sort(collocationPoints)
+                    collocationPoints.append((1.0 - gaussNode) * knot0 + gaussNode * knot1)
         n = nDep * currentGuess.nCoef[0]
         bestGuess = np.reshape(currentGuess.coefs.T, (n,))
 
@@ -826,7 +955,7 @@ def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = ()):
             done = linear
             continuation = 1.0
             bestContinuation = 0.0
-            continuationBest = bestGuess
+            inCaseOfEmergency = bestGuess.copy()
             previous = 0.5 * np.finfo(bestGuess[0]).max
             iteration = 0
     
@@ -869,9 +998,10 @@ def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = ()):
                 update = sp.linalg.solve_banded((bandWidth, bandWidth), collocationMatrix, residuals)
                 bestGuess[nDep * (iFirstPoint + nLeft) : nDep * (iNextPoint + nLeft)] += update[nDep * nLeft : nDep * (iNextPoint - iFirstPoint + nLeft)]
                 updateSize = np.linalg.norm(update)
-                if updateSize > 1.25 * previous and iteration >= 4:
+                if updateSize > 1.25 * previous and iteration >= 4 or \
+                   updateSize > 0.01 and iteration > 50:
                     continuation = 0.5 * (continuation + bestContinuation)
-                    bestGuess = continuationBest
+                    bestGuess = inCaseOfEmergency.copy()
                     if continuation - bestContinuation < 0.01:
                         break
                     previous = 0.5 * np.finfo(bestGuess[0]).max
@@ -886,7 +1016,7 @@ def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = ()):
                 if updateSize < math.sqrt(n) * scale * math.sqrt(np.finfo(update.dtype).eps):
                     if continuation < 1.0:
                         bestContinuation = continuation
-                        continuationBest = bestGuess
+                        inCaseOfEmergency = bestGuess.copy()
                         continuation = min(1.0, 1.2 * continuation)
                         previous = 0.5 * np.finfo(bestGuess[0]).max
                         iteration = 0