Regina Calculation Engine
Public Member Functions | Public Attributes
regina::NSatAnnulus Struct Reference

Represents an annulus formed from a pair of faces in a Seifert fibred space. More...

#include <nsatannulus.h>

List of all members.

Public Member Functions

 NSatAnnulus ()
 Creates a new uninitialised structure.
 NSatAnnulus (const NSatAnnulus &cloneMe)
 Creates a clone of the given structure.
 NSatAnnulus (NTetrahedron *t0, NPerm r0, NTetrahedron *t1, NPerm r1)
 Creates a new structure initialised to the given values.
NSatAnnulusoperator= (const NSatAnnulus &cloneMe)
 Makes this equal to a clone of the given structure.
bool operator== (const NSatAnnulus &other) const
 Determines whether or not this and the given structure describe the same annulus with the same representation.
bool operator!= (const NSatAnnulus &other) const
 Determines whether or not this and the given structure describe the same annulus with the same representation.
unsigned meetsBoundary () const
 Determines how many faces of this annulus lie on the boundary of the triangulation.
void switchSides ()
 Converts this into a representation of the same annulus from the other side.
NSatAnnulus otherSide () const
 Returns a representation of the same annulus from the other side.
void reflectVertical ()
 Reverses the direction of the vertical fibres in this annulus representation.
NSatAnnulus verticalReflection () const
 Returns a representation of this annulus in which the vertical direction of the fibres has been reversed.
void reflectHorizontal ()
 Performs a left-to-right reflection of this annulus representation.
NSatAnnulus horizontalReflection () const
 Returns a left-to-right reflected representation of this annulus.
void rotateHalfTurn ()
 Rotates the representation of this annulus by 180 degrees.
NSatAnnulus halfTurnRotation () const
 Returns a 180 degree rotated representation of this annulus.
bool isAdjacent (const NSatAnnulus &other, bool *refVert, bool *refHoriz) const
 Determines whether this and the given annulus are adjacent, possibly modulo vertical or horizontal reflections.
bool isJoined (const NSatAnnulus &other, NMatrix2 &matching) const
 Determines whether this and the given annulus are joined in some form, even if the fibres on each annulus are not consistent.
bool isTwoSidedTorus () const
 Determines whether this annulus has its boundaries identified to form an embedded two-sided torus within the surrounding triangulation.
void transform (const NTriangulation *originalTri, const NIsomorphism *iso, NTriangulation *newTri)
 Adjusts this annulus representation according to the given isomorphism between triangulations.
NSatAnnulus image (const NTriangulation *originalTri, const NIsomorphism *iso, NTriangulation *newTri) const
 Returns the image of this annulus representation under the given isomorphism between triangulations.
void attachLST (NTriangulation *tri, long alpha, long beta) const
 Attaches a layered solid torus to the this saturated annulus.

Public Attributes

NTetrahedrontet [2]
 Describes which tetrahedra provide the first and second faces.
NPerm roles [2]
 Describes how the first and second faces match up with individual tetrahedron vertices.

Detailed Description

Represents an annulus formed from a pair of faces in a Seifert fibred space.

This annulus is saturated, i.e., a union of fibres. More than that, the fibres run parallel to the two boundary edges of the annulus.

The annulus is described from one side only. The description includes an array of indices tet[] describing which two tetrahedra provide the faces of the annulus, as well as an array of permutations roles[] detailing how the annulus matches up with the individual tetrahedron vertices.

The annulus can be drawn as follows, with the upper edge identified with the lower:

            *--->---*
            |0  2 / |
     First  |    / 1|  Second
     face   |   /   |   face
            |1 /    |
            | / 2  0|
            *--->---*
 

Suppose that tet[0] and tet[1] are the tetrahedra providing the first and second faces respectively. Then the markings 0..2 on the first face above correspond to vertices roles[0][0..2] of tetrahedron tet[0], and likewise the markings 0..2 on the second face above correspond to vertices roles[1][0..2] of tetrahedron tet[1].

Note that the diagram above can also be drawn as follows.

            *--->---*
            | \ 2  1|
     First  |0 \    |  Second
     face   |   \   |   face
            |    \ 0|
            |1  2 \ |
            *--->---*
 

Note also that the labelling of the tetrahedra and their vertices establishes an orientation on the vertical fibres, as well as a left-to-right direction across the annulus.

For convenience we refer to edges roles[][0-1] as vertical, edges roles[][0-2] as horizontal, and edge roles[][1-2] as diagonal. This is illustrated in the following diagrams.

         V  Horizontal       V   Diagonal
         e  *--->---*        e  *--->---*
         r  |   g / |        r  |H\ 2  1|
         t  |  a / 1|        t  | o\    |
         i  | i /   |        i  |  r\   |
         c  |D /    |        c  |   i\ 0|
         a  | / 2  0|        a  |    z\ |
         l  *--->---*        l  *--->---*
 
Python:
The member arrays tet and roles are accessed for reading through functions tet() and roles() respectively. For instance, the first face tetrahedron for the saturated annulus a can be accessed as a.tet(0). These same member arrays are accessed for writing through functions setTet() and setRoles(), so for instance the second face vertex roles for the saturated annulus a can be modified by calling a.setRoles(1, newRoles).

Constructor & Destructor Documentation

regina::NSatAnnulus::NSatAnnulus ( ) [inline]

Creates a new uninitialised structure.

Both tetrahedra will be set to null pointers.

regina::NSatAnnulus::NSatAnnulus ( const NSatAnnulus cloneMe) [inline]

Creates a clone of the given structure.

Parameters:
cloneMethe structure to clone.
regina::NSatAnnulus::NSatAnnulus ( NTetrahedron t0,
NPerm  r0,
NTetrahedron t1,
NPerm  r1 
) [inline]

Creates a new structure initialised to the given values.

See the class notes for what the various tetrahedra and permutations mean.

Parameters:
t0the tetrahedron to assign to tet[0].
r0the permutation to assign to roles[0].
t1the tetrahedron to assign to tet[1].
r1the permutation to assign to roles[1].

Member Function Documentation

void regina::NSatAnnulus::attachLST ( NTriangulation tri,
long  alpha,
long  beta 
) const

Attaches a layered solid torus to the this saturated annulus.

The layered solid torus will be attached so that the given values alpha and beta describe how the meridinal disc cuts the vertical and horizontal edges of the annulus respectively.

The result will effectively insert an (alpha, beta) exceptional fibre into the Seifert fibred space space, where the vertical edges run parallel to the fibres and the horizontal edges represent the base orbifold. The sign of the fibre is consistent with the fibre inserted by NSatLST::adjustSFS() (in particular, negating beta will negate the fibre).

In the case of a (2,1) fibre, the layered solid torus will be degenerate (i.e., the two faces of the annulus will simply be joined together).

Precondition:
The given value alpha is not zero.
The given values alpha and beta are coprime.
Parameters:
trithe triangulation into which the new tetrahedra should be inserted.
alphadescribes how the meridinal disc of the torus should cut the vertical edges. This may be positive or negative.
betadescribes how the meridinal disc of the torus should cut the horizontal edges. Again this may be positive or negative.
NSatAnnulus regina::NSatAnnulus::halfTurnRotation ( ) const [inline]

Returns a 180 degree rotated representation of this annulus.

This structure will not be changed. See rotateHalfTurn() for further details.

Returns:
a new 180 degree rotation of this annulus.
NSatAnnulus regina::NSatAnnulus::horizontalReflection ( ) const [inline]

Returns a left-to-right reflected representation of this annulus.

This structure will not be changed. See reflectHorizontal() for further details.

Returns:
a new left-to-right reflection of this annulus.
NSatAnnulus regina::NSatAnnulus::image ( const NTriangulation originalTri,
const NIsomorphism iso,
NTriangulation newTri 
) const [inline]

Returns the image of this annulus representation under the given isomorphism between triangulations.

This annulus representation will not be changed. See transform() for further details.

Parameters:
originalTrithe triangulation currently used by this annulus representation.
isothe mapping from originalTri to newTri.
newTrithe triangulation to be used by the new annulus representation.
bool regina::NSatAnnulus::isAdjacent ( const NSatAnnulus other,
bool *  refVert,
bool *  refHoriz 
) const

Determines whether this and the given annulus are adjacent, possibly modulo vertical or horizontal reflections.

That is, this routine determines whether this and the given structure represent opposite sides of the same saturated annulus, where the fibres for both structures are consistent (though possibly reversed). See switchSides() for details on what "opposite sides" means in this context, and see reflectVertical() and reflectHorizontal() for descriptions of the various types of reflection.

Information regarding reflections is returned via the two boolean pointers refVert and refHoriz. If the two annuli are identically opposite each other as described by switchSides(), both booleans will be set to false. If the two annuli are identically opposite after one undergoes a vertical and/or horizontal reflection, then the booleans refVert and/or refHoriz will be set to true accordingly.

The critical difference between this routine and isJoined() is that this routine insists that the fibres on each annulus be consistent. This routine is thus suitable for examining joins between different sections of the same Seifert fibred space, for example.

Python:
This routine only takes a single argument (the annulus other). The return value is a tuple of three booleans: the usual return value, the value returned in refVert, and the value returned in refHoriz.
Parameters:
otherthe annulus to compare with this.
refVertreturns information on whether the annuli are adjacent modulo a vertical reflection. This is set to true if a vertical reflection is required and false if it is not. If no adjacency was found at all, this boolean is not touched. A null pointer may be passed, in which case this information will not be returned at all.
refHorizreturns information on whether the annuli are adjacent modulo a horizontal reflection. This is set to true if a horizontal reflection is required and false if it is not. If no adjacency was found at all, this boolean is not touched. A null pointer may be passed, in which case this information will not be returned at all.
Returns:
true if some adjacency was found (either with or without reflections), or false if no adjacency was found at all.
bool regina::NSatAnnulus::isJoined ( const NSatAnnulus other,
NMatrix2 matching 
) const

Determines whether this and the given annulus are joined in some form, even if the fibres on each annulus are not consistent.

This routine treats each annulus as though its boundaries are identified to form a torus (though it does not actually test whether this is true). It then examines whether this and the given annulus represent opposite sides of the same torus. More specifically, it tests whether both annuli are formed from the same pair of faces, and whether the mapping of 0/1/2 markings from one annulus to the other is the same for each face. Note that the faces are allowed to be switched (i.e., the first face of one annulus may be the second face of the other).

The critical difference between this routine and isAdjacent() is that this routine allows the fibres on each annulus to be inconsistent. This routine is thus suitable for examining joins between different Seifert fibred blocks in a graph manifold, for example.

If the two annuli are joined, the precise relationship between the curves on each annulus will be returned in the matrix matching. Specifically, let x and y be the oriented curves running from markings 0-1 and 0-2 respectively on the first face of this annulus. Likewise, let x' and y' run from markings 0-1 and 0-2 respectively on the first face of the annulus other. Then the joining between the two annuli can be expressed as follows:

     [x ]                [x']
     [  ]  =  matching * [  ].
     [y ]                [y']
 
Parameters:
otherthe annulus to compare with this.
matchingreturns details on how the curves on each annulus are related. If the this and the given annulus are not joined, then this matrix is not touched.
Returns:
true if this and the given annulus are found to be joined, or false if they are not.
bool regina::NSatAnnulus::isTwoSidedTorus ( ) const

Determines whether this annulus has its boundaries identified to form an embedded two-sided torus within the surrounding triangulation.

It will be verified that:

  • the two faces of this annulus are joined along all three pairs of edges to form a torus;
  • the three edges of this torus remain distinct (i.e., different edges of the torus do not become identified within the larger triangulation);
  • this torus is two-sided within the surrounding triangulation.
Returns:
true if this annulus forms an embedded two-sided torus as described above, or false if it does not.
unsigned regina::NSatAnnulus::meetsBoundary ( ) const

Determines how many faces of this annulus lie on the boundary of the triangulation.

Note that this routine can also be used as a boolean function to determine whether any faces of the annulus lie on the triangulation boundary.

Returns:
the number of faces of this annulus that lie on the boundary of the triangulation; this will be 0, 1 or 2.
bool regina::NSatAnnulus::operator!= ( const NSatAnnulus other) const [inline]

Determines whether or not this and the given structure describe the same annulus with the same representation.

This requires both structures to have identical tet[] and roles[] arrays.

Parameters:
otherthe structure to compare with this.
Returns:
true if the structures do not describe the same annulus with the same representation, or false if they do.
NSatAnnulus & regina::NSatAnnulus::operator= ( const NSatAnnulus cloneMe) [inline]

Makes this equal to a clone of the given structure.

Parameters:
cloneMethe structure to clone.
Returns:
a reference to this structure.
bool regina::NSatAnnulus::operator== ( const NSatAnnulus other) const [inline]

Determines whether or not this and the given structure describe the same annulus with the same representation.

This requires both structures to have identical tet[] and roles[] arrays.

Parameters:
otherthe structure to compare with this.
Returns:
true if the structures describe the same annulus with the same representation, or false if they do not.
NSatAnnulus regina::NSatAnnulus::otherSide ( ) const [inline]

Returns a representation of the same annulus from the other side.

This structure will not be changed. See switchSides() for further details.

Precondition:
Neither face of this annulus is a boundary face of the triangulation.
Returns:
a new representation of this annulus from the other side.
void regina::NSatAnnulus::reflectHorizontal ( ) [inline]

Performs a left-to-right reflection of this annulus representation.

The vertical direction of the fibres will remain unchanged, but the first and second faces will be switched (and the 0..2 markings changed to compensate).

void regina::NSatAnnulus::reflectVertical ( ) [inline]

Reverses the direction of the vertical fibres in this annulus representation.

The first and second faces (as described in the class notes) will remain unchanged, but the markings 0 and 1 on each face will be switched.

void regina::NSatAnnulus::rotateHalfTurn ( ) [inline]

Rotates the representation of this annulus by 180 degrees.

This has the effect of switching the first and second faces and also reversing the direction of the vertical fibres.

Calling this routine is equivalent to calling reflectVertical() and then reflectHorizontal().

void regina::NSatAnnulus::switchSides ( )

Converts this into a representation of the same annulus from the other side.

The first and second faces and their 0..2 markings (as described in the class notes) remain unchanged. However, the two tetrahedra that are used to describe the annulus will be replaced by their counterparts on the other side of the annulus (i.e., the two new tetrahedra that meet the two original tetrahedra along the annulus itself).

Precondition:
Neither face of this annulus is a boundary face of the triangulation.
void regina::NSatAnnulus::transform ( const NTriangulation originalTri,
const NIsomorphism iso,
NTriangulation newTri 
)

Adjusts this annulus representation according to the given isomorphism between triangulations.

The given isomorphism must describe a mapping from originalTri to newTri, and this annulus must refer to tetrahedra in originalTri. This routine will adjust this annulus according to the given isomorphism, so that it refers to the corresponding tetrahedra in newTri (with the roles permutations also updated accordingly).

Precondition:
This annulus refers to tetrahedra in originalTri, and iso describes a mapping from originalTri to newTri.
Parameters:
originalTrithe triangulation currently used by this annulus representation.
isothe mapping from originalTri to newTri.
newTrithe triangulation to be used by the updated annulus representation.
NSatAnnulus regina::NSatAnnulus::verticalReflection ( ) const [inline]

Returns a representation of this annulus in which the vertical direction of the fibres has been reversed.

This structure will not be changed. See reflectVertical() for further details.

Returns:
a new representation of this annulus in which fibres have been reversed.

Member Data Documentation

Describes how the first and second faces match up with individual tetrahedron vertices.

See the class notes for details.

Describes which tetrahedra provide the first and second faces.

See the class notes for details.


The documentation for this struct was generated from the following file:

Copyright © 1999-2009, Ben Burton
This software is released under the GNU General Public License.
For further information, or to submit a bug or other problem, please contact Ben Burton (bab@debian.org).