A saturated block that is a reflector strip. More...
#include <nsatblocktypes.h>
Public Member Functions | |
NSatReflectorStrip (const NSatReflectorStrip &cloneMe) | |
Constructs a clone of the given block structure. | |
virtual NSatBlock * | clone () const |
Returns a newly created clone of this saturated block structure. | |
virtual void | adjustSFS (NSFSpace &sfs, bool reflect) const |
Adjusts the given Seifert fibred space to insert the contents of this saturated block. | |
virtual void | writeTextShort (std::ostream &out) const |
Writes this object in short text format to the given output stream. | |
virtual void | writeAbbr (std::ostream &out, bool tex=false) const |
Writes an abbreviated name or symbol for this block to the given output stream. | |
Static Public Member Functions | |
static NSatReflectorStrip * | isBlockReflectorStrip (const NSatAnnulus &annulus, TetList &avoidTets) |
Determines whether the given annulus is a boundary annulus for a block of this type (reflector strip). | |
static NSatReflectorStrip * | insertBlock (NTriangulation &tri, unsigned length, bool twisted) |
Inserts a new reflector strip into the given triangulation, and returns the corresponding block structure. | |
Protected Member Functions | |
NSatReflectorStrip (unsigned length, bool twisted) | |
Constructs a partially initialised block of the given length. |
A saturated block that is a reflector strip.
A reflector strip is a ring of triangular prisms arranged end-to-end, as illustrated in the diagram below. The top rectangle of each prism is identified with the bottom in an orientation-reversing fashion (the back edge moves to the front and vice versa), and the prisms are joined in a loop from left to right. The Seifert fibres run vertically in the diagram, with each saturated boundary annulus shaded at the rear of each prism.
The effect of a reflector strip is to create a reflector boundary in the base orbifold of the surrounding Seifert fibred space. Each prism provides a segment of this reflector boundary.
A reflector strip may have arbitrary length, and it may also include a twist as the ring of prisms wraps back around to meet itself. Note that a twisted reflector strip will have a twisted ring of boundary annuli, as described by NSatBlock::twistedBoundary().
The length of a reflector strip is defined to be the number of prisms that are joined together, or equivalently the number of saturated annuli on the boundary.
regina::NSatReflectorStrip::NSatReflectorStrip | ( | const NSatReflectorStrip & | cloneMe ) | [inline] |
Constructs a clone of the given block structure.
cloneMe | the block structure to clone. |
regina::NSatReflectorStrip::NSatReflectorStrip | ( | unsigned | length, |
bool | twisted | ||
) | [inline, protected] |
Constructs a partially initialised block of the given length.
The boundary annuli will remain uninitialised, and must be initialised before this block can be used.
length | the length of the new reflector strip, i.e., the number of boundary annuli; this must be strictly positive. |
twisted | true if the strip should be twisted (giving a twisted ring of boundary annuli), or false if not. |
virtual void regina::NSatReflectorStrip::adjustSFS | ( | NSFSpace & | sfs, |
bool | reflect | ||
) | const [virtual] |
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 NSatBlock 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.
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::NSatBlock.
NSatBlock * regina::NSatReflectorStrip::clone | ( | ) | const [inline, virtual] |
Returns a newly created clone of this saturated block structure.
A clone of the correct subclass of NSatBlock will be returned. For this reason, each subclass of NSatBlock must implement this routine.
Implements regina::NSatBlock.
static NSatReflectorStrip* regina::NSatReflectorStrip::insertBlock | ( | NTriangulation & | tri, |
unsigned | length, | ||
bool | twisted | ||
) | [static] |
Inserts a new reflector strip into the given triangulation, and returns the corresponding block structure.
The given triangulation will not be emptied before the new tetrahedra are inserted.
tri | the triangulation into which the new block should be inserted. |
length | the length of the new reflector strip, i.e., the number of boundary annuli; this must be strictly positive. |
twisted | true if the new reflector strip should be twisted (causing its ring of boundary annuli to be twisted also), or false if the new strip should not be twisted. |
static NSatReflectorStrip* regina::NSatReflectorStrip::isBlockReflectorStrip | ( | const NSatAnnulus & | annulus, |
TetList & | avoidTets | ||
) | [static] |
Determines whether the given annulus is a boundary annulus for a block of this type (reflector strip).
This routine is a specific case of NSatBlock::isBlock(); see that routine for further details.
annulus | the proposed boundary annulus that should form part of the new saturated block. |
avoidTets | the list of tetrahedra that should not be considered, and to which any new tetrahedra will be added. |
null
if none was found. void regina::NSatReflectorStrip::writeAbbr | ( | std::ostream & | out, |
bool | tex = false |
||
) | const [inline, virtual] |
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.
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::NSatBlock.
void regina::NSatReflectorStrip::writeTextShort | ( | std::ostream & | out ) | const [inline, virtual] |
Writes this object in short text format to the given output stream.
The output should fit on a single line and no newline should be written.
out | the output stream to which to write. |
Implements regina::ShareableObject.