1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
|
/**************************************************************************
* *
* Regina - A Normal Surface Theory Calculator *
* Computational Engine *
* *
* Copyright (c) 1999-2011, Ben Burton *
* For further details contact Ben Burton (bab@debian.org). *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as *
* published by the Free Software Foundation; either version 2 of the *
* License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* General Public License for more details. *
* *
* You should have received a copy of the GNU General Public *
* License along with this program; if not, write to the Free *
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, *
* MA 02110-1301, USA. *
* *
**************************************************************************/
/* end stub */
/*! \file subcomplex/nplugtrisolidtorus.h
* \brief Deals with plugged triangular solid torus components of a
* triangulation.
*/
#ifndef __NPLUGTRISOLIDTORUS_H
#ifndef __DOXYGEN
#define __NPLUGTRISOLIDTORUS_H
#endif
#include "regina-core.h"
#include "subcomplex/ntrisolidtorus.h"
#include "subcomplex/nlayeredchain.h"
namespace regina {
class NComponent;
/**
* \weakgroup subcomplex
* @{
*/
/**
* Represents a plugged triangular solid torus component of a
* triangulation. Such a component is obtained as follows.
*
* Begin with a three-tetrahedron triangular solid torus (as described by
* class NTriSolidTorus). Observe that the three axis edges divide the
* boundary into three annuli.
*
* To each of these annuli a layered chain may be optionally attached.
* If present, the chain should be attached so its hinge edges are
* identified with the axis edges of the corresonding annulus and its bottom
* tetrahedron is layered over either the major edge or minor edge of the
* corresponding annulus. The top two faces of the layered chain should
* remain free.
*
* Thus we now have three annuli on the boundary, each represented as a
* square two of whose (opposite) edges are axis edges of the original
* triangular solid torus (and possibly also hinge edges of a layered
* chain).
*
* Create a \e plug by gluing two tetrahedra together along a single
* face. The six edges that do not run along this common face split the
* plug boundary into three squares. These three squares must be glued
* to the three boundary annuli previously described. Each axis edge meets
* two of the annuli; the two corresponding edges of the plug must be
* non-adjacent (have no common vertex) on the plug.
* In this way each of the six edges of the plug not running along its
* interior face corresponds to precisely one of the two instances of
* precisely one of the three axis edges.
*
* If the axis edges are directed so that they all point the
* same way around the triangular solid torus, these axis edges when
* drawn on the plug must all point from one common tip of the plug to
* the other (where the \e tips of the plug are the vertices not meeting the
* interior face). The gluings must also be made so that the resulting
* triangulation component is orientable.
*
* Of the optional NStandardTriangulation routines, getManifold() is
* implemented for most plugged triangular solid tori and
* getHomologyH1() is not implemented at all.
*
* \testpart
*/
class REGINA_API NPlugTriSolidTorus : public NStandardTriangulation {
public:
static const int CHAIN_NONE;
/**< Indicates an annulus on the triangular solid torus
boundary with no attached layered chain. */
static const int CHAIN_MAJOR;
/**< Indicates an annulus on the triangular solid torus
boundary with an attached layered chain layered over
the major edge of the annulus. */
static const int CHAIN_MINOR;
/**< Indicates an annulus on the triangular solid torus
boundary with an attached layered chain layered over
the minor edge of the annulus. */
static const int EQUATOR_MAJOR;
/**< Indicates that, if no layered chains were present, the
equator of the plug would consist of major edges of the
core triangular solid torus. */
static const int EQUATOR_MINOR;
/**< Indicates that, if no layered chains were present, the
equator of the plug would consist of minor edges of the
core triangular solid torus. */
private:
NTriSolidTorus* core;
/**< The triangular solid torus at the core of this
triangulation. */
NLayeredChain* chain[3];
/**< The layered chains attached to the annuli on the
triangular solid torus, or 0 for those annuli without
attached layered chains. */
int chainType[3];
/**< The way in which the layered chain is attached to each
annulus on the triangular solid torus, or \a CHAIN_NONE
for those annuli without attached layered chains. */
int equatorType;
/**< Indicates which types of edges form the equator of the
plug. */
public:
/**
* Destroys this plugged solid torus; note that the corresponding
* triangular solid torus and layered chains will also be destroyed.
*/
virtual ~NPlugTriSolidTorus();
/**
* Returns a newly created clone of this structure.
*
* @return a newly created clone.
*/
NPlugTriSolidTorus* clone() const;
/**
* Returns the triangular solid torus at the core of this
* triangulation.
*
* @return the core triangular solid torus.
*/
const NTriSolidTorus& getCore() const;
/**
* Returns the layered chain attached to the requested
* annulus on the boundary of the core triangular solid torus.
* If there is no attached layered chain, \c null will be returned.
*
* Note that the core triangular solid torus will be attached to
* the bottom (as opposed to the top) of the layered chain.
*
* @param annulus specifies which annulus to examine; this must
* be 0, 1 or 2.
* @return the corresponding layered chain.
*/
const NLayeredChain* getChain(int annulus) const;
/**
* Returns the way in which a layered chain is attached to the
* requested annulus on the boundary of the core triangular solid
* torus. This will be one of the chain type constants defined
* in this class.
*
* @param annulus specifies which annulus to examine; this must
* be 0, 1 or 2.
* @return the type of layered chain, or \a CHAIN_NONE
* if there is no layered chain attached to the requested annulus.
*/
int getChainType(int annulus) const;
/**
* Returns which types of edges form the equator of the plug.
* In the absence of layered chains these will either all be major
* edges or all be minor edges.
*
* Layered chains complicate matters, but the roles that the major
* and minor edges play on the boundary annuli of the triangular
* solid torus can be carried up to the annuli at the top of each
* layered chain; the edges filling the corresponding major or
* minor roles will then form the equator of the plug.
*
* @return the types of edges that form the equator of the plug;
* this will be one of the equator type constants defined in this
* class.
*/
int getEquatorType() const;
/**
* Determines if the given triangulation component is a
* plugged triangular solid torus.
*
* @param comp the triangulation component to examine.
* @return a newly created structure containing details of the
* plugged triangular solid torus, or \c null if the given
* component is not a plugged triangular solid torus.
*/
static NPlugTriSolidTorus* isPlugTriSolidTorus(NComponent* comp);
NManifold* getManifold() const;
std::ostream& writeName(std::ostream& out) const;
std::ostream& writeTeXName(std::ostream& out) const;
void writeTextLong(std::ostream& out) const;
private:
/**
* Creates a new structure with all subcomponent pointers
* initialised to \c null.
*/
NPlugTriSolidTorus();
};
/*@}*/
// Inline functions for NPlugTriSolidTorus
inline NPlugTriSolidTorus::NPlugTriSolidTorus() : core(0) {
chain[0] = chain[1] = chain[2] = 0;
chainType[0] = chainType[1] = chainType[2] = CHAIN_NONE;
}
inline const NTriSolidTorus& NPlugTriSolidTorus::getCore() const {
return *core;
}
inline const NLayeredChain* NPlugTriSolidTorus::getChain(int annulus) const {
return chain[annulus];
}
inline int NPlugTriSolidTorus::getChainType(int annulus) const {
return chainType[annulus];
}
inline int NPlugTriSolidTorus::getEquatorType() const {
return equatorType;
}
} // namespace regina
#endif
|
