snappy 3.1.1__cp38-cp38-win_amd64.whl → 3.2__cp38-cp38-win_amd64.whl

snappy/drilling/__init__.py

@@ -2,62 +2,63 @@ from . import exceptions
 from . import epsilons
 from . import debug
 from .tracing import trace_geodesic
-from .crush import crush_geodesic_pieces
-from .line import R13LineWithMatrix
-from .geometric_structure import add_r13_geometry, word_to_psl2c_matrix
-from .geodesic_info import GeodesicInfo, sample_line
 from .perturb import perturb_geodesics
 from .subdivide import traverse_geodesics_to_subdivide
+from .barycentric import mark_subtetrahedra_about_geodesic_pieces
+from .shorten import shorten_in_barycentric_subdivision
+from .crush import crush_geodesic_pieces
 from .cusps import (
     CuspPostDrillInfo,
     index_geodesics_and_add_post_drill_infos,
     reorder_vertices_and_get_post_drill_infos,
     refill_and_adjust_peripheral_curves)
 
+from .. import Manifold, ManifoldHP
+
+from ..geometric_structure.geodesic.geodesic_start_point_info import GeodesicStartPointInfo, compute_geodesic_start_point_info
+from ..geometric_structure import (add_r13_geometry,
+                                   add_filling_information)
+from ..geometric_structure.geodesic.add_core_curves import add_r13_core_curves
+from ..geometric_structure.geodesic.line import R13LineWithMatrix
 from ..snap.t3mlite import Mcomplex
 from ..exceptions import InsufficientPrecisionError
 
-
-import functools
-from typing import Sequence
-
+from typing import Optional, Sequence
 
 def drill_word(manifold,
                word : str,
                verified : bool = False,
-               bits_prec=None,
-               verbose : bool = False):
+               bits_prec : Optional[int] = None,
+               verbose : bool = False) -> Manifold:
     """
     Drills the geodesic corresponding to the given word in the unsimplified
-    fundamental group.
+    fundamental group. Here is an example::
 
-        >>> from snappy import Manifold
         >>> M = Manifold("m004")
-        >>> M.length_spectrum(1.2, include_words = True, grouped = False)
-        mult  length                                  topology     parity word
-        1     1.08707014499574 -  1.72276844987009*I  circle       +      a
-        1     1.08707014499574 +  1.72276844987009*I  circle       +      bC
+        >>> M.length_spectrum_alt(max_len=1.2) # doctest: +NUMERIC9
+        [Length                                      Core curve  Word
+         1.08707014499574 + 1.72276844987009*I       -           bC,
+         1.08707014499574 - 1.72276844987009*I       -           a]
         >>> N = M.drill_word('a')
         >>> N.identify()
         [m129(0,0)(0,0), 5^2_1(0,0)(0,0), L5a1(0,0)(0,0), ooct01_00001(0,0)(0,0)]
 
-    The last cusp of the new manifold corresponds to the drilled
-    geodesic and the longitude and meridian for that cusp are chosen such that
-    (1,0)-filling results in the original (undrilled) manifold. The orientation
-    of the new longitude is chosen so that it is parallel to the closed geodesic.
-    That is, the new longitude is homotopic to the closed geodesic when embedding
-    the drilled manifold into the original manifold.
+    The last cusp of the resulting manifold corresponds to the drilled
+    geodesic. The longitude and meridian for that cusp are chosen such that
+    ``(1,0)``-filling the last cusp results in the given (undrilled) manifold::
 
-        >>> N.dehn_fill((1,0),1)
+        >>> N.dehn_fill((1,0),-1)
         >>> M.is_isometric_to(N)
         True
         >>> N.cusp_info(1)['core_length'] # doctest: +NUMERIC9
         1.08707014499574 - 1.72276844987009*I
+    
+    The orientation of the new longitude is chosen so that it is parallel to
+    the closed geodesic. That is, the new longitude is homotopic to the closed
+    geodesic when embedding the drilled manifold into the given manifold.
 
-    If the drilled geodesic coincides with a core curve of a filled cusp, the
-    cusp is unfilled instead and the longitude and meridian changed so that
-    the above again applies. The cusp order is also changed so that the unfilled
-    cusp becomes the last cusp.
+    If the given geodesic coincides with a core curve of a filled cusp, the
+    cusp is unfilled instead::
 
         >>> M = Manifold("m004(2,3)")
         >>> M.volume() # doctest: +NUMERIC9
@@ -71,29 +72,19 @@ def drill_word(manifold,
         m004_drilled(0,0)
         >>> N.num_cusps()
         1
-        >>> N.dehn_fill((1,0))
+    
+    In this case, the peripheral information is also
+    updated such that the above remark about ``(1,0)``-filling applies again::
+
+        >>> N.dehn_fill((1,0), -1)
         >>> N.volume() # doctest: +NUMERIC9
         1.73712388065
 
-    Even though the output of the drilling geodesic algorithm is a
-    triangulation and thus combinatorial in nature, the intermediate
-    computations to compute the intersections of the geodesic with the
-    faces of the tetrahedra is numerical. Sometimes it is necessary to increase
-    the precision with `bits_prec` to make this computation accurate or succeed.
-    If `verified = True` is specified, intervals are used for all computations
-    and the result is provably correct (only supported when used inside
-    SageMath).
-    That is, the algorithm will fail with an exception (most likely
-    InsufficientPrecisionError) if insufficient precision is used. Example of
-    verified computation::
+    That is, the longitude and meridian of the unfilled cusps are reinstalled
+    and the cusps reindexed so that the unfilled cusp becomes the last cusp.
 
-        sage: M = Manifold("m004(2,3)")
-        sage: M.drill_word('caa', verified = True, bits_prec = 100)
-        m004_drilled(2,3)(0,0)
-
-    An example where we drill the core geodesic::
+    Here is another example where we drill the core geodesic::
 
-        >>> from snappy import Manifold
         >>> M = Manifold("v2986(3,4)")
         >>> N = M.drill_word('EdFgabcGEdFgaDcc')
         >>> N.is_isometric_to(Manifold("v2986"), return_isometries = True) # doctest: +NORMALIZE_WHITESPACE
@@ -101,6 +92,42 @@ def drill_word(manifold,
          [3 -1]
          [4 -1]
          Does not extend to link]
+
+    While the result of drilling a geodesic is a triangulation and thus
+    combinatorial in nature, some intermediate computations (for example,
+    to compute the intersections of the geodesic with the faces of the
+    tetrahedra) are numerical. Sometimes, it is necessary to increase the
+    precision with :attr:`bits_prec` to make the method succeed and produce
+    the correct result.
+    
+    **Verified computation**
+
+    If :attr:`verified = False`, floating-point issues can arise resulting
+    in drilling the wrong loop. The method can be made
+    :ref:`verified <verify-primer>` by passing :attr:`verified = True`::
+
+        sage: M = Manifold("m004(2,3)")
+        sage: M.drill_word('caa', verified = True, bits_prec = 100)
+        m004_drilled(2,3)(0,0)
+
+    That is, if the precision is insufficient to prove the result is correct,
+    the algorithm fails with an exception (most likely
+    ``InsufficientPrecisionError``).
+
+    :param word:
+             The word in the unsimplified fundamental group specifying the
+             geodesic to be drilled.
+    :param bits_prec:
+             The precision used in the intermediate computation. Increase
+             if the computation failed.
+    :param verified:
+             Use :ref:`verified computation <verify-primer>`.
+    :param verbose:
+             Print intermediate results and statistics.
+
+    :return:
+            Manifold obtained by drilling geodesic. ``(1,0)``-filling the
+            last cusp gives the given (undrilled) manifold.
     """
 
     return drill_words(manifold,
@@ -113,17 +140,17 @@ def drill_word(manifold,
 def drill_words(manifold,
                 words : Sequence[str],
                 verified : bool = False,
-                bits_prec=None,
-                verbose : bool = False):
+                bits_prec : Optional[int] = None,
+                verbose : bool = False) -> Manifold:
     """
-    A generalization of M.drill_word taking a list of words to
-    drill several geodesics simultaneously.
-
-    Here is an example where we drill the core curve corresponding to the third cusp
-    and a geodesic that is not a core curve:
+    A generalization of :meth:`drill_word <Manifold.drill_word>` to drill
+    several geodesics simultaneously. It takes a list of words in the
+    unsimplified fundamental group.
 
+    Here is an example where we drill two geodesics. One of the geodesics is
+    the core curve corresponding to the third cusp. The other geodesic is not
+    a core curve::
 
-        >>> from snappy import Manifold
         >>> M=Manifold("t12047(0,0)(1,3)(1,4)(1,5)")
         >>> [ info.get('core_length') for info in M.cusp_info() ] # doctest: +NUMERIC9
         [None,
@@ -139,17 +166,19 @@ def drill_words(manifold,
         >>> N
         t12047_drilled(0,0)(1,3)(1,5)(0,0)(0,0)
 
-    The last n cusps correspond to the n geodesics that were drilled, appearing
-    in the same order the words for the geodesics were given. Note that in the
-    above example, the drilled manifold has only five cusps even though the
-    original manifold had four cusps and we drilled two geodesics. This is
-    because one geodesic was a core curve. The corresponding cusp was unfilled
-    (from (1,4)) and grouped with the other cusps coming from drilling.
+    Let n be the number of geodesics that were drilled. Then the last n
+    cusps correspond to the drilled geodesics and appear in the same order than
+    the geodesics were given as words. Note that in the above example, we expect
+    six cusps since we started with four cusps and drilled two geodesics. However,
+    we only obtain five cusps because one geodesic was a core curve. The
+    corresponding cusp was unfilled (from ``(1,4)``) and grouped with the other
+    cusps coming from drilling.
 
-    We obtain the original (undrilled) manifold by (1,0)-filling the last n cusps.
+    We obtain the given (undrilled) manifold by ``(1,0)``-filling the last n
+    cusps.
 
-        >>> N.dehn_fill((1,0), 3)
-        >>> N.dehn_fill((1,0), 4)
+        >>> N.dehn_fill((1,0), -2)
+        >>> N.dehn_fill((1,0), -1)
         >>> M.is_isometric_to(N)
         True
         >>> [ info.get('core_length') for info in N.cusp_info() ] # doctest: +NUMERIC9
@@ -159,6 +188,21 @@ def drill_words(manifold,
          0.317363079597924 + 1.48157893409218*I,
          1.43914411734251 + 2.66246879992796*I]
 
+    :param word:
+             The words in the unsimplified fundamental group specifying the
+             geodesics to be drilled.
+    :param bits_prec:
+             The precision used in the intermediate computation. Increase
+             if the computation failed.
+    :param verified:
+             Use :ref:`verified computation <verify-primer>`.
+    :param verbose:
+             Print intermediate results and statistics.
+
+    :return:
+            Manifold obtained by drilling geodesics. ``(1,0)``-filling the
+            last n cusps gives the given (undrilled) manifold where n is the
+            number of given words.
     """
 
     if isinstance(words, str):
@@ -227,13 +271,15 @@ def drill_words_implementation(
     add_r13_geometry(mcomplex,
                      manifold,
                      verified=verified, bits_prec=bits_prec)
+    add_filling_information(mcomplex, manifold)
+    add_r13_core_curves(mcomplex, manifold)
 
     # For the words compute basic information such as the corresponding
     # matrix and the end points and a sample point on the fixed line.
     # Try to conjugate/translate matrix and end points such that the
     # line intersects the fundamental domain.
-    geodesics : Sequence[GeodesicInfo] = [
-        compute_geodesic_info(mcomplex, word)
+    geodesics : Sequence[GeodesicStartPointInfo] = [
+        compute_geodesic_start_point_info(mcomplex, word)
         for word in words ]
 
     # Record information in the geodesics and triangulation needed
@@ -246,6 +292,11 @@ def drill_words_implementation(
     geodesics_to_drill = [ g for g in geodesics
                            if not g.core_curve_cusp ]
 
+    if verbose:
+        for g in geodesics:
+            if g.core_curve_cusp:
+                print("%s is core curve" % g.word)
+
     if perturb:
         # Move the sample point for each geodesic a bit and use it
         # as start point. Much of perturb_geodesics is about computing
@@ -300,60 +351,8 @@ def drill_words_implementation(
 
     return drilled_manifold
 
-
-def _verify_not_parabolic(m, mcomplex, word):
-    """
-    Raise exception when user gives a word corresponding to a parabolic
-    matrix.
-    """
-
-    if mcomplex.verified:
-        epsilon = 0
-    else:
-        epsilon = epsilons.compute_epsilon(mcomplex.RF)
-
-    tr = m.trace()
-    if not (abs(tr - 2) > epsilon and abs(tr + 2) > epsilon):
-        raise exceptions.WordAppearsToBeParabolic(word, tr)
-
-
-def compute_geodesic_info(mcomplex : Mcomplex,
-                          word) -> GeodesicInfo:
-    """
-    Compute basic information about a geodesic given a word.
-
-    add_r13_geometry must have been called on the Mcomplex.
-    """
-
-    m = word_to_psl2c_matrix(mcomplex, word)
-    _verify_not_parabolic(m, mcomplex, word)
-    # Line fixed by matrix
-    line = R13LineWithMatrix.from_psl2c_matrix(m)
-
-    # Pick a point on the line
-    start_point = sample_line(line)
-
-    g = GeodesicInfo(
-        mcomplex=mcomplex,
-        trace=m.trace(),
-        unnormalised_start_point=start_point,
-        unnormalised_end_point=line.o13_matrix * start_point,
-        line=line)
-
-    # Determines whether geodesic corresponds to a core curve.
-    # Applies Decktransformations so that start point lies within
-    # the interior of one tetrahedron in the fundamental domain or
-    # within the union of two tetrahedra neighboring in the hyperboloid
-    # model.
-    #
-    # See GeodesicInfo for details.
-    g.find_tet_or_core_curve()
-
-    return g
-
-
 def drill_geodesics(mcomplex : Mcomplex,
-                    geodesics : Sequence[GeodesicInfo],
+                    geodesics : Sequence[GeodesicStartPointInfo],
                     verbose : bool = False) -> Mcomplex:
     """
     Given a triangulation with geometric structure attached with
@@ -361,7 +360,7 @@ def drill_geodesics(mcomplex : Mcomplex,
     the triangulation (with finite vertices) obtained by drilling
     the geodesics.
 
-    Each provided GeodesicInfo is supposed to have a start point and
+    Each provided GeodesicStartPointInfo is supposed to have a start point and
     a tetrahedron in the fundamental domain that contains the start point
     in its interior and an end point such that the line segment from the
     start to the endpoint forms a closed curve in the manifold.
@@ -400,10 +399,20 @@ def drill_geodesics(mcomplex : Mcomplex,
         print("Number of tets after subdividing: %d" % (
             len(tetrahedra)))
 
+    # Mark which subtetrahedra in the barycentric subdivision
+    # are adjacent to the closed curve we traced.
+    mark_subtetrahedra_about_geodesic_pieces(tetrahedra)
+
+    # If the simple closed curve is having two consecutive pieces
+    # adjacent to the same face, making it shorter by replacing
+    # the two pieces by just one corresponding to the third edge
+    # of the triangle.
+    shorten_in_barycentric_subdivision(tetrahedra, verbose)
+
     # Perform a barycentric subdivision. Then crush all tetrahedra
     # touching the closed curve we traced. Note that
     # crush_geodesic_pieces is actually doing the subdivision and
-    # crushing in just one step.
+    # crushing of the subsimplices marked above in just one step.
     result : Mcomplex = crush_geodesic_pieces(tetrahedra)
 
     # Sanity checks while we are still testing the new features.
@@ -412,21 +421,31 @@ def drill_geodesics(mcomplex : Mcomplex,
 
     return result
 
-# Create a version of drill_word and drill_words suitable
-# for ManifoldHP.
-# Use @functools.wraps to carry forward the argument names
-# and default values and the doc string.
-
-
-@functools.wraps(drill_word)
-def drill_word_hp(*args, **kwargs):
-    return drill_word(*args, **kwargs).high_precision()
-
-
-@functools.wraps(drill_words)
-def drill_words_hp(*args, **kwargs):
-    return drill_words(*args, **kwargs).high_precision()
-
+def drill_word_hp(manifold,
+                  word : str,
+                  verified : bool = False,
+                  bits_prec : Optional[int] = None,
+                  verbose : bool = False) -> ManifoldHP:
+    return drill_word(
+        manifold,
+        word = word,
+        verified = verified,
+        bits_prec = bits_prec,
+        verbose = verbose).high_precision()
+drill_word_hp.__doc__ = drill_word.__doc__
+
+def drill_words_hp(manifold,
+                   words : Sequence[str],
+                   verified : bool = False,
+                   bits_prec : Optional[int] = None,
+                   verbose : bool = False) -> ManifoldHP:
+    return drill_words(
+        manifold,
+        words = words,
+        verified = verified,
+        bits_prec = bits_prec,
+        verbose = verbose).high_precision()
+drill_words_hp.__doc__ = drill_words.__doc__
 
 def _add_methods(mfld_class, high_precision=False):
     if high_precision:
@@ -435,104 +454,3 @@ def _add_methods(mfld_class, high_precision=False):
     else:
         mfld_class.drill_word = drill_word
         mfld_class.drill_words = drill_words
-
-
-def dummy_function_for_additional_doctests():
-    """
-    Test with manifold without symmetry. Note that the code in drilling is
-    deterministic but the SnapPea kernel code to remove the finite vertices
-    and simplify is not. Thus, we need canonical_retriangulation() to get
-    a consistent result:
-
-        >>> from snappy import Manifold, ManifoldHP
-        >>> from snappy.drilling.exceptions import GeodesicSystemNotSimpleError
-        >>> M = Manifold("v2986")
-        >>> M.drill_word('gB').canonical_retriangulation().triangulation_isosig(ignore_orientation=False)
-        'kLvvAQQkbhijhghgjijxxacvcccccv_baBaaBDbBa'
-
-    Test non-simple geodesic and verified computation:
-
-        sage: M = ManifoldHP("m004")
-        sage: try:
-        ...       M.drill_word('bbCC', verified = True)
-        ... except GeodesicSystemNotSimpleError as e:
-        ...     print("Not simple")
-        Not simple
-
-    Tests drilling one geodesic that intersects 1-skeleton::
-
-        >>> M = Manifold("m125")
-        >>> M.drill_word('d').triangulation_isosig(ignore_orientation=False)
-        'gLLPQcdefeffpvauppb_acbBbBaaBbacbBa'
-
-    Tests drilling two geodesics that intersect each other:
-
-        >>> try: # doctest: +NUMERIC9
-        ...     M.drill_words(['d','Ad'])
-        ... except GeodesicSystemNotSimpleError as e:
-        ...     print("Max tube radius:", e.maximal_tube_radius)
-        Max tube radius: 0.0000000000
-
-    Tests drilling geodesics that are entirely in the 2-skeleton::
-
-        >>> M.drill_words(['a','acAADa']).triangulation_isosig(ignore_orientation=False)
-        'iLMvPQcbbdfhgghhpuabpauab_acbdaBbaBbaBcBBbcbbb'
-
-    Same test as verified computation::
-
-        sage: M.drill_words(['a','acAADa'], verified = True).triangulation_isosig(ignore_orientation=False)
-        'iLMvPQcbbdfhgghhpuabpauab_acbdaBbaBbaBcBBbcbbb'
-
-    Test error when drilling something close to core curve::
-
-        >>> from snappy import Manifold
-        >>> M = Manifold("m125")
-        >>> MM = M.drill_word('d')
-        >>> MM.dehn_fill((1,0),2)
-        >>> bad_word = 'bc'
-        >>> MM.drill_word(bad_word) # doctest: +ELLIPSIS
-        Traceback (most recent call last):
-        ...
-        snappy.drilling.exceptions.GeodesicCloseToCoreCurve: The given geodesic is very close to a core curve and might intersect it.
-
-    There are two places where we detect whether the geodesic is close
-    to a core curve (rather than tiling forever). Test the other place
-    in the GeodesicTube code used to determine the maximal amount we can
-    perturb the geodesic:
-
-        >>> drill_words_implementation(MM, [bad_word], verified = False, bits_prec = 53, perturb = True) # doctest: +ELLIPSIS
-        Traceback (most recent call last):
-        ...
-        snappy.drilling.exceptions.GeodesicCloseToCoreCurve: The given geodesic is very close to a core curve and might intersect it.
-
-    A particular tricky case in terms testing that the start piece is correctly
-    handled by 2-3 moves (in particular, commit f9879d04 introduced a bug):
-
-        >>> Manifold("m004").drill_words(['CAC','CCbC']).canonical_retriangulation().triangulation_isosig(ignore_orientation=False)
-        'qLvvLvAMQQQkcgimopkllmpkonnnpixcaelchapewetvrn_bcaaBbBBbaBaBbB'
-
-
-    An interesting case where geodesic intersects triangulation in only one tetrahedron:
-
-        >>> Manifold("m019").drill_word('A').canonical_retriangulation().triangulation_isosig(ignore_orientation=False)
-        'gLLPQccdefffqffqqof_BaaBdcbb'
-
-    A bug in an earlier implementation found by Nathan Dunfield (where putting the words in one order caused a failure):
-
-        >>> import sys
-        >>> original_limit = sys.getrecursionlimit()
-        >>> sys.setrecursionlimit(100000)
-        >>> def drilled_isosig(M, words):
-        ...     for i in range(10):
-        ...         try:
-        ...             F = M.drill_words(words).filled_triangulation()
-        ...             return F.canonical_retriangulation().triangulation_isosig(ignore_orientation=False)
-        ...         except RuntimeError:
-        ...             pass
-        >>> drilled_isosig(Manifold('K11n34(0,1)'), ['iFcdbEiFJ', 'iFJ'])
-        'zLLvLLwzAwPQMQzzQkcdgijkjplssrnrotqruvwyxyxyhsgnnighueqdniblsipklpxgcr_BcaBbBba'
-        >>> drilled_isosig(Manifold('K11n34(0,1)'), ['iFJ', 'iFcdbEiFJ'])
-        'zLLvLLwzAwPQMQzzQkcdgijkjplssrnrotqruvwyxyxyhsgnnighueqdniblsipklpxgcr_babBbaBcaB'
-        >>> sys.setrecursionlimit(original_limit)
-
-    """

snappy/drilling/barycentric.py

@@ -0,0 +1,103 @@
+from .tracing import GeodesicPiece
+
+from ..snap.t3mlite import Tetrahedron, Perm4, simplex
+
+from typing import Dict, List, Sequence, Tuple
+
+def mark_subtetrahedra_about_geodesic_pieces(
+        tetrahedra : Sequence[Tetrahedron]) -> None:
+    """
+    Record which subtetrahedra of the barycentric subdivision
+    are adjacent to a piece of the geodesic.
+
+    This is recorded in the array Tetrahedron.marked_subtetrahedra.
+
+    Recall that the subtetrahedra of the barycentric subdivision
+    are indexed by S4 permutations. The index within
+    Tetrahedron.marked_subtetrahedra is given by perm_to_index(p).
+
+    The value of Tetrahedron.marked_subtetrahedra[j] is 0 if
+    the subtetrahedron is not adjacent to any piece of the geodesic.
+    Otherwise, it is +/-1 depending on whether the 0-1 edge
+    of the subtetrahedron is parallel or anti-parallel to the
+    geodesic piece. This is recorded to orient the meridian
+    and longitude.
+    """
+
+    for tet in tetrahedra:
+        tet.marked_subtetrahedra = 24 * [ 0 ]
+
+    for tet in tetrahedra:
+        for piece in tet.geodesic_pieces:
+            mark_subtetrahedra_about_edge(tet, _perm_for_piece(piece))
+
+transpositions : List[Perm4] = [ Perm4((1,0,2,3)),
+                                 Perm4((0,2,1,3)),
+                                 Perm4((0,1,3,2)) ]
+
+def perm_to_index(perm : Perm4) -> int:
+    """
+    list(Perm4.S4())[perm_to_index(p)] returns the same Perm4 p.
+    """
+    return _perm_tuple_to_index[perm.tuple()]
+
+_perm_tuple_to_index : Dict[Tuple[int, int, int, int], int] = {
+    perm.tuple() : i for i, perm in enumerate(Perm4.S4()) }
+
+def _perm_for_piece(piece : GeodesicPiece):
+    """
+    Given a GeodesicPiece with endpoints being on the vertices
+    of the tetrahedron and spanning an oriented edge of the tetrahedron,
+    find an "edge embedding permutation" (similar to regina's
+    edge embedding) that maps the 0-1 edge to the given edge.
+
+    The subtetrahedron corresponding to this permutation is
+    adjacent to half of this edge.
+    """
+
+    s0 = piece.endpoints[0].subsimplex
+    s1 = piece.endpoints[1].subsimplex
+
+    # Important to consistently always pick a permutation of the
+    # same parity and respect the ordering of the vertices V0 and V1
+    # since this affects which subtetrahedron will be chosen as peripheral
+    # base subtetrahedron - and thus ultimately affects the orientation
+    # of the meridian and longitude computed by install_peripheral_curves.
+    for perm in Perm4.A4():
+        if perm.image(simplex.V0) == s0 and perm.image(simplex.V1) == s1:
+            return perm
+
+def mark_subtetrahedra_about_edge(tet0 : Tetrahedron, perm0 : Perm4, orientation : int = 1):
+    """
+    Given a subtetrahedron in the barycentric subdivision parametrized
+    by a tetrahedron and permutation, find all subtetrahedra adjacent to the
+    same edge in the original triangulation and mark them in
+    Tetrahedron.marked_subtetrahedra.
+
+    By default (orientation = 1), the subtetrahedra are marked by +/-1 according
+    to whether each is parallel or anti-parallel to the given edge.
+    Subtetrahedra can be unmarked by forcing orientation = 0.
+    """
+
+    tet = tet0
+    perm = perm0
+
+    while True:
+        # All subtetrahedra touching the same edge in the current
+        # tetrahedron.
+        for edge_perm in [ perm,
+                           perm * transpositions[2] ]:
+            for marked_subtet, subtet_perm in [
+                    (+orientation, edge_perm),
+                    (-orientation, edge_perm * transpositions[0]) ]:
+                j = perm_to_index(subtet_perm)
+                tet.marked_subtetrahedra[j] = marked_subtet
+
+        # Find the next "edge embedding"
+        face = perm.image(simplex.F3)
+        tet, perm = (
+            tet.Neighbor[face],
+            tet.Gluing[face] * perm * transpositions[2])
+        # Stop if back at the first "edge embedding"
+        if tet is tet0 and perm.tuple() == perm0.tuple():
+            return

snappy/drilling/constants.py

@@ -1,7 +1,5 @@
-graph_trace_max_steps = 300
 trace_max_steps = 300
 
-start_point_bias = 1.2498653253
 piece_midpoint_bias = 1.818449629072142
 
 point_perturbation_direction = [0.8466, 0.3176, 0.4268]