A degenerate zero-tetrahedron saturated block that corresponds to attaching a Mobius band to a single annulus boundary.
More...
|
int | position () const |
| Describes how the Mobius band is attached to the boundary annulus. More...
|
|
bool | operator== (const SatBlock &other) const override |
| Determines whether this and the given object represent saturated blocks of the same type with the same combinatorial parameters. More...
|
|
void | adjustSFS (SFSpace &sfs, bool reflect) const override |
| Adjusts the given Seifert fibred space to insert the contents of this saturated block. More...
|
|
void | writeTextShort (std::ostream &out) const override |
| Writes a short text representation of this object to the given output stream. More...
|
|
void | writeAbbr (std::ostream &out, bool tex=false) const override |
| Writes an abbreviated name or symbol for this block to the given output stream. More...
|
|
size_t | countAnnuli () const |
| Returns the number of annuli on the boundary of this saturated block. More...
|
|
const SatAnnulus & | annulus (size_t which) const |
| Returns details of the requested annulus on the boundary of this saturated block. More...
|
|
bool | twistedBoundary () const |
| Is the ring of boundary annuli twisted to form a long Mobius strip? More...
|
|
bool | hasAdjacentBlock (size_t whichAnnulus) const |
| Returns whether there is another saturated block listed as being adjacent to the given boundary annulus of this block. More...
|
|
const SatBlock * | adjacentBlock (size_t whichAnnulus) const |
| Returns the saturated block listed as being adjacent to the given boundary annulus of this block. More...
|
|
size_t | adjacentAnnulus (size_t whichAnnulus) const |
| Returns which specific annulus of the adjacent block is listed as being adjacent to the given boundary annulus of this block. More...
|
|
bool | adjacentReflected (size_t whichAnnulus) const |
| Returns whether the adjacency along the given boundary annulus of this block is reflected. More...
|
|
bool | adjacentBackwards (size_t whichAnnulus) const |
| Returns whether the adjacency along the given boundary annulus of this block is backwards. More...
|
|
std::tuple< const SatBlock *, size_t, bool, bool > | nextBoundaryAnnulus (size_t thisAnnulus, bool followPrev) const |
| Finds the next (or previous) boundary annulus around from this, treating all adjacent blocks as part of a single large saturated region. More...
|
|
std::string | abbr (bool tex=false) const |
| Returns an abbreviated name or symbol for this block. More...
|
|
bool | operator< (const SatBlock &compare) const |
| Implements a consistent ordering of saturated blocks. More...
|
|
bool | operator!= (const SatBlock &other) const |
| Determines whether this and the given object do not represent saturated blocks of the same type with the same combinatorial parameters. More...
|
|
void | writeTextLong (std::ostream &out) const |
| A default implementation for detailed output. More...
|
|
std::string | str () const |
| Returns a short text representation of this object. More...
|
|
std::string | utf8 () const |
| Returns a short text representation of this object using unicode characters. More...
|
|
std::string | detail () const |
| Returns a detailed text representation of this object. More...
|
|
|
static bool | isBad (const Tetrahedron< 3 > *t, const TetList &list) |
| Determines whether the given tetrahedron is contained within the given list. More...
|
|
template<class List > |
static bool | isBad (const Tetrahedron< 3 > *t, const List &list) |
| Determines whether the given tetrahedron is contained within the given list. More...
|
|
static bool | notUnique (const Tetrahedron< 3 > *test) |
| Determines whether the given tetrahedron pointer is null. More...
|
|
static bool | notUnique (const Tetrahedron< 3 > *test, const Tetrahedron< 3 > *other1) |
| Determines whether the given tetrahedron pointer is null or equal to another from the given list. More...
|
|
static bool | notUnique (const Tetrahedron< 3 > *test, const Tetrahedron< 3 > *other1, const Tetrahedron< 3 > *other2) |
| Determines whether the given tetrahedron pointer is null or equal to another from the given list. More...
|
|
static bool | notUnique (const Tetrahedron< 3 > *test, const Tetrahedron< 3 > *other1, const Tetrahedron< 3 > *other2, const Tetrahedron< 3 > *other3) |
| Determines whether the given tetrahedron pointer is null or equal to another from the given list. More...
|
|
static bool | notUnique (const Tetrahedron< 3 > *test, const Tetrahedron< 3 > *other1, const Tetrahedron< 3 > *other2, const Tetrahedron< 3 > *other3, const Tetrahedron< 3 > *other4) |
| Determines whether the given tetrahedron pointer is null or equal to another from the given list. More...
|
|
A degenerate zero-tetrahedron saturated block that corresponds to attaching a Mobius band to a single annulus boundary.
This is a degenerate case of the layered solid torus (see the class SatLST), where instead of joining a solid torus to an annulus boundary we join a Mobius band. The Mobius band can be thought of as a zero-tetrahedron solid torus with two boundary triangles, which in fact are opposite sides of the same triangle. By attaching a zero-tetrahedron Mobius band to an annulus boundary, we are effectively joining the two triangles of the annulus together.
The meridinal disc of this zero-tetrahedron solid torus meets the three edges of the annulus in 1, 1 and 2 places, so it is in fact a degenerate (1,1,2) layered solid torus. Note that the weight 2 edge is the boundary edge of the Mobius strip.
This class does not support value semantics: it cannot be copied, swapped or manually constructed. Its memory is managed by the SatRegion class, and blocks' locations in memory define them. See SatRegion for further details.
void regina::SatMobius::adjustSFS |
( |
SFSpace & |
sfs, |
|
|
bool |
reflect |
|
) |
| const |
|
overridevirtual |
Adjusts the given Seifert fibred space to insert the contents of this saturated block.
In particular, the space should be adjusted as though an ordinary solid torus (base orbifold a disc, no twists or exceptional fibres) had been replaced by this block. This description does not make sense for blocks with twisted boundary; the twisted case is discussed below.
If the argument reflect is true
, it should be assumed that this saturated block is being reflected before being inserted into the larger Seifert fibred space. That is, any twists or exceptional fibres should be negated before being added.
Regarding the signs of exceptional fibres: Consider a saturated block containing a solid torus whose meridinal curve runs p times horizontally around the boundary in order through annuli 0,1,... and follows the fibres q times from bottom to top (as depicted in the diagram in the SatBlock class notes). Then this saturated block adds a positive (p, q) fibre to the underlying Seifert fibred space.
If the ring of saturated annuli bounding this block is twisted then the situation becomes more complex. It can be proven that such a block must contain a twisted reflector boundary in the base orbifold (use Z_2 homology with fibre-reversing paths to show that the base orbifold must contain another twisted boundary component, and then recall that real boundaries are not allowed inside blocks).
In this twisted boundary case, it should be assumed that the twisted reflector boundary is already stored in the given Seifert fibred space. This routine should make any further changes that are required (there may well be none). That is, the space should be adjusted as though a trivial Seifert fibred space over the annulus with one twisted reflector boundary (and one twisted puncture corresponding to the block boundary) had been replaced by this block. In particular, this routine should not add the reflector boundary itself.
- Parameters
-
sfs | the Seifert fibred space to adjust. |
reflect | true if this block is to be reflected, or false if it should be inserted directly. |
Implements regina::SatBlock.
std::tuple< const SatBlock *, size_t, bool, bool > regina::SatBlock::nextBoundaryAnnulus |
( |
size_t |
thisAnnulus, |
|
|
bool |
followPrev |
|
) |
| const |
|
inherited |
Finds the next (or previous) boundary annulus around from this, treating all adjacent blocks as part of a single large saturated region.
Suppose that all saturated blocks are merged together according to adjacent boundary annuli, forming larger saturated structures. The remaining annuli that do not have adjacent blocks will group together to form several large boundary rings. Note that each boundary ring might involve annuli from several different blocks, and might or might not have a twist (thus forming a large Klein bottle instead of a large torus).
This routine is used to trace around such a boundary ring. It is assumed that annulus thisAnnulus of this block forms part of a boundary ring (i.e., it has no adjacent block). This routine will then return the next/previous annulus around from this in the large boundary ring. Here "next" means in the direction following from the second triangle of this annulus, and "previous" means in the direction following from the first triangle; the boolean argument followPrev controls which we will be used. This next/previous annulus might belong to another block, or it might even be this original annulus again.
The next/previous annulus itself is not returned, but rather a reference as to how it appears within its enclosing saturated block. Specifically, a block and corresponding annulus number will be included as the first two elements of the returned tuple.
It is possible that the next/previous annulus as it appears within the returned block is oriented differently from how it appears within this large boundary ring. For this reason, two booleans are returned also. The third element of the returned tuple will describe whether the annulus is reflected vertically as it appears within the large boundary ring (i.e., the first and second triangles remain the same but the fibre direction is reversed). Similarly, the fourth element of the tuple will describe whether the annulus is reflected horizontally as it appears within the large boundary ring (i.e., first and second triangles are switched but the fibre direction is unchanged).
It is possible that both a horizontal and vertical reflection take place. Note that any kind of reflection will also affect the locations of the 0/1/2 markings as described in the SatAnnulus class notes.
Finally, note that if the large boundary ring is twisted (i.e., it forms a Klein bottle), then following the entire boundary ring around using this routine will bring you back to the starting annulus but with the vertical reflection flag set.
- Precondition
- Annulus thisAnnulus of this block has no block adjacent to it.
- Warning
- If you wish to trace around an entire boundary ring, you will need to adjust the argument followPrev according to whether or not the current annulus is reflected horizontally (since, under a horizontal reflection, "next" becomes "previous" and vice versa).
- Parameters
-
thisAnnulus | describes which original boundary annulus of this block to examine; this must be between 0 and countAnnuli()-1 inclusive. |
followPrev | true if we should find the previous boundary annulus, or false if we should find the next boundary annulus. |
- Returns
- a tuple (nextBlock, nextAnnulus, refVert, refHoriz), where: nextBlock is the block containing the next boundary annulus around from thisAnnulus; nextAnnulus is the specific annulus number within nextBlock of the next annulus around (between 0 and nextBlock->countAnnuli()-1 inclusive, and the corresponding annulus will have no block adjacent to it); refVert is
true
iff the next annulus around is vertically reflected; and refHoriz is true
iff the next annulus around is horizontally reflected (see above for details on reflections).
int regina::SatMobius::position |
( |
| ) |
const |
|
inline |
Describes how the Mobius band is attached to the boundary annulus.
The class notes discuss the weight two edge of the Mobius band (or equivalently the boundary edge of the Mobius band). The return value of this routine indicates which edge of the boundary annulus this weight two edge is joined to.
In the SatAnnulus class notes, the three edges of the annulus are denoted vertical, horizontal and boundary, and the vertices of each triangle are given markings 0, 1 and 2.
The return value of this routine takes the value 0, 1 or 2 as follows:
- 0 means that the weight two edge is joined to the diagonal edge of the annulus (markings 1 and 2);
- 1 means that the weight two edge is joined to the horizontal edge of the annulus (markings 0 and 2);
- 2 means that the weight two edge is joined to the vertical edge of the annulus (markings 0 and 1).
- Returns
- the value 0, 1 or 2 as described above.
Returns a short text representation of this object.
This text should be human-readable, should use plain ASCII characters where possible, and should not contain any newlines.
Within these limits, this short text ouptut should be as information-rich as possible, since in most cases this forms the basis for the Python __str__()
and __repr__()
functions.
- Python
- The Python "stringification" function
__str__()
will use precisely this function, and for most classes the Python __repr__()
function will incorporate this into its output.
- Returns
- a short text representation of this object.
|
protectedvirtualinherited |
Adjusts the structure of this block according to the given isomorphism between triangulations.
Any triangulation-specific information will be transformed accordingly (for instance, the routine SatAnnulus::transform() will be called for each boundary annulus).
Information regarding adjacent blocks will not be changed. Only structural information for this particular block will be updated.
The given isomorphism must describe a mapping from originalTri to newTri, and this block must currently refer to tetrahedra in originalTri. After this routine is called the block will instead refer to the corresponding tetrahedra in newTri (with changes in vertex/face numbering also accounted for).
- Precondition
- This block currently refers to tetrahedra in originalTri, and iso describes a mapping from originalTri to newTri.
- Warning
- Any subclasses of SatBlock that store additional triangulation-specific information will need to override this routine. When doing so, be sure to call SatBlock::transform() so that the generic changes defined here will still take place.
- Parameters
-
originalTri | the triangulation currently used by this saturated block. |
iso | the mapping from originalTri to newTri. |
newTri | the triangulation to be used by the updated block structure. |
Reimplemented in regina::SatLST.
Returns a short text representation of this object using unicode characters.
Like str(), this text should be human-readable, should not contain any newlines, and (within these constraints) should be as information-rich as is reasonable.
Unlike str(), this function may use unicode characters to make the output more pleasant to read. The string that is returned will be encoded in UTF-8.
- Returns
- a short text representation of this object.
void regina::SatMobius::writeAbbr |
( |
std::ostream & |
out, |
|
|
bool |
tex = false |
|
) |
| const |
|
overridevirtual |
Writes an abbreviated name or symbol for this block to the given output stream.
This name should reflect the particular block type, but need not provide thorough details.
The output should be no more than a handful of characters long, and no newline should be written. In TeX mode, no leading or trailing dollar signs should be written.
- Python
- Not present. Instead use the variant abbr() that returns a string.
- Parameters
-
out | the output stream to which to write. |
tex | true if the output should be formatted for TeX, or false if it should be in plain text format. |
Implements regina::SatBlock.