SheafSystem  0.0.0.0
sec_st4_e2.cc
Go to the documentation of this file.
1 
2 //
3 // Copyright (c) 2014 Limit Point Systems, Inc.
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
17 
20 
21 #include "SheafSystem/sec_st4_e2.h"
22 
23 #include "SheafSystem/assert_contract.h"
24 #include "SheafSystem/base_space_poset.h"
25 #include "SheafSystem/binary_section_space_schema_member.impl.h"
26 #include "SheafSystem/at1_space.h"
27 #include "SheafSystem/fiber_bundles_namespace.h"
28 #include "SheafSystem/index_space_iterator.h"
29 #include "SheafSystem/sec_at0.h"
30 #include "SheafSystem/sec_at0_space.h"
31 #include "SheafSystem/sec_at1_space.h"
32 #include "SheafSystem/sec_e2.h"
33 #include "SheafSystem/sec_stp_space.h"
34 #include "SheafSystem/sec_tuple.impl.h"
35 #include "SheafSystem/sec_tuple_space.impl.h"
36 #include "SheafSystem/sec_vd.impl.h"
37 #include "SheafSystem/st4_e2.h"
38 #include "SheafSystem/stp_space.h"
39 
40 using namespace std;
41 using namespace fiber_bundle; // Workaround for MS C++ bug.
42 
43 //==============================================================================
44 // CLASS SEC_ST4_E2
45 //==============================================================================
46 
47 // ===========================================================
48 // HOST FACTORY FACET OF CLASS SEC_ST4_E2
49 // ===========================================================
50 
51 // PUBLIC MEMBER FUNCTIONS
52 
56  const poset_path& xhost_path,
57  const poset_path& xschema_path,
58  const poset_path& xvector_space_path,
59  bool xauto_access)
60 {
61  // cout << endl << "Entering sec_st4_e2::new_host." << endl;
62 
63  // Preconditions:
64 
65  require(xns.state_is_auto_read_write_accessible(xauto_access));
66 
67  require(!xhost_path.empty());
68  require(!xns.contains_path(xhost_path, xauto_access));
69 
70  require(xschema_path.full());
71  require(xns.path_is_auto_read_accessible<schema_type::host_type>(xschema_path, xauto_access));
72  require(host_type::fiber_space_conforms<fiber_type::host_type>(xns, xschema_path, xauto_access));
73 
74  require(xns.path_is_auto_read_accessible<vector_space_type::host_type>(xvector_space_path, xauto_access));
75 
76  require(host_type::same_vector_fiber_space(xns, xschema_path, xvector_space_path, xauto_access));
77 
78  // Body:
79 
80  host_type& result = host_type::new_table(xns, xhost_path, xschema_path, xvector_space_path, xauto_access);
81 
82  // Postconditions:
83 
84  ensure(xns.owns(result, xauto_access));
85  ensure(result.path(true) == xhost_path);
86  ensure(result.state_is_not_read_accessible());
87  ensure(result.schema(true).path(xauto_access) == xschema_path);
88 
89  ensure(result.factor_ct(true) == result.schema(true).fiber_space<fiber_type::host_type>().factor_ct(xauto_access));
90  ensure(result.d(true) == result.schema(true).fiber_space<fiber_type::host_type>().d(xauto_access));
91  ensure(result.scalar_space_path(true) ==
92  xns.member_poset<vector_space_type::host_type>(xvector_space_path, xauto_access).scalar_space_path(xauto_access));
93  ensure(result.p(true) == result.schema(true).fiber_space<fiber_type::host_type>().p(xauto_access));
94  ensure(result.p(true) == 4);
95  ensure(result.dd(true) == result.schema(true).fiber_space<fiber_type::host_type>().dd(xauto_access));
96  ensure(result.vector_space_path(true) == xvector_space_path);
97 
98  // Exit:
99 
100  // cout << "Leaving sec_st4_e2::new_host." << endl;
101  return result;
102 }
103 
107  const poset_path& xbase_path,
108  const poset_path& xrep_path,
109  const std::string& xsection_suffix,
110  const std::string& xfiber_suffix,
111  bool xauto_access)
112 {
113  // cout << endl << "Entering sec_st4_e2::new_host." << endl;
114 
115  // Preconditions:
116 
117  require(xns.state_is_auto_read_write_accessible(xauto_access));
118 
119  require(xbase_path.full());
120  require(xns.path_is_auto_read_accessible<base_space_poset>(xbase_path, xauto_access));
121 
122  require(xrep_path.empty() || xrep_path.full());
123  require(xrep_path.empty() || xns.path_is_auto_read_accessible<sec_rep_descriptor_poset>(xrep_path, xauto_access));
124 
125  require(xsection_suffix.empty() || poset_path::is_valid_name(xsection_suffix));
126 
127  require(xfiber_suffix.empty() || poset_path::is_valid_name(xfiber_suffix));
128 
129  require(standard_host_is_available<sec_st4_e2>(xns, xbase_path, xrep_path, xsection_suffix, xfiber_suffix, xauto_access));
130  require(fiber_type::standard_host_is_available<fiber_type>(xns, xfiber_suffix, xauto_access));
131  require(schema_type::standard_host_is_available<sec_st4_e2>(xns, xbase_path, xrep_path, xfiber_suffix, xauto_access));
132 
133  // Body:
134 
135  poset_path lstd_path = standard_host_path<sec_st4_e2>(xbase_path, xrep_path, xsection_suffix, xfiber_suffix);
136 
137  host_type* lresult_ptr;
138 
139  if(xns.contains_path(lstd_path, xauto_access))
140  {
141  // Standard host already exists, just return it.
142 
143  lresult_ptr = &xns.member_poset<host_type>(lstd_path, xauto_access);
144  }
145  else
146  {
147  // Standard host doesn't exist, have to create it.
148 
149  // Apply default for rep path if needed.
150 
151  poset_path lrep_path = (!xrep_path.empty() ? xrep_path : standard_rep_path());
152 
153  // Find or create the standard schema member.
154 
155  poset_path lstd_schema_path =
156  schema_type::standard_member<sec_st4_e2>(xns, xbase_path, lrep_path, xfiber_suffix, xauto_access);
157 
158  // Find or create the standard vector space.
159 
160  poset_path lvector_space_path =
161  vector_space_type::standard_host(xns, xbase_path, lrep_path, xsection_suffix, xfiber_suffix, xauto_access).path(xauto_access);
162 
163  // Create the standard host.
164 
165  lresult_ptr = &new_host(xns, lstd_path, lstd_schema_path, lvector_space_path, xauto_access);
166  }
167 
168  host_type& result = *lresult_ptr;
169 
170  // Postconditions:
171 
172  ensure(xns.owns(result, xauto_access));
173  ensure(result.path(true) == standard_host_path<sec_st4_e2>(xbase_path, xrep_path, xsection_suffix, xfiber_suffix));
174  ensure(result.state_is_not_read_accessible());
175  ensure(result.schema(true).path(xauto_access) ==
176  schema_type::standard_member_path<sec_st4_e2>(xbase_path, xrep_path, xfiber_suffix));
177 
178  ensure(result.factor_ct(true) == result.schema(true).fiber_space<fiber_type::host_type>().factor_ct(xauto_access));
179  ensure(result.d(true) == result.schema(true).fiber_space<fiber_type::host_type>().d(xauto_access));
180  ensure(result.scalar_space_path(true) ==
181  scalar_type::standard_host_path<scalar_type>(xbase_path, result.rep().path(xauto_access), xsection_suffix, xfiber_suffix));
182  ensure(result.p(true) == result.schema(true).fiber_space<fiber_type::host_type>().p(xauto_access));
183  ensure(result.p(true) == 4);
184  ensure(result.dd(true) == result.schema(true).fiber_space<fiber_type::host_type>().dd(xauto_access));
185  ensure(result.vector_space_path(true) ==
186  vector_space_type::standard_host_path<vector_space_type>(xbase_path, result.rep().path(xauto_access), xsection_suffix, xfiber_suffix));
187 
188  // Exit:
189 
190  // cout << "Leaving sec_st4_e2::new_host." << endl;
191  return result;
192 }
193 
194 // PROTECTED MEMBER FUNCTIONS
195 
196 // PRIVATE MEMBER FUNCTIONS
197 
198 
199 //==============================================================================
200 // ST4_E2 FACET OF CLASS SEC_ST4_E2
201 //==============================================================================
202 
203 // PUBLIC MEMBER FUNCTIONS
204 
207 {
208  // Preconditions:
209 
210  // Body:
211 
212  // Postconditions:
213 
214  ensure(invariant());
215 }
216 
219 {
220  // Preconditions:
221 
222  require(xhost != 0);
223  require(xhost->state_is_read_accessible());
224  require(xhost->contains_member(xhub_id));
225 
226  // Body:
227 
228  attach_to_state(xhost, xhub_id);
229 
230  // Postconditions:
231 
232  ensure(invariant());
233  //ensure(host() == xhost);
234  ensure(index() == xhub_id);
235  ensure(is_attached());
236  ensure(!is_restricted());
237 }
238 
240 sec_st4_e2(const sec_rep_space* xhost, const scoped_index& xid)
241 {
242  // Preconditions:
243 
244  require(xhost != 0);
245  require(xhost->state_is_read_accessible());
246  require(xhost->contains_member(xid));
247 
248  // Body:
249 
250  attach_to_state(xhost, xid.hub_pod());
251 
252  // Postconditions:
253 
254  ensure(invariant());
255  //ensure(host() == xhost);
256  ensure(index() ==~ xid);
257  ensure(is_attached());
258  ensure(!is_restricted());
259 }
260 
262 sec_st4_e2(const sec_rep_space* xhost, const std::string& xname)
263 {
264 
265  // Preconditions:
266 
267  require(xhost != 0);
268  require(xhost->state_is_read_accessible());
269  require(!xname.empty());
270  require(xhost->contains_member(xname));
271 
272  // Body:
273 
274  attach_to_state(xhost, xname);
275 
276  // Postconditions:
277 
278  ensure(invariant());
279  //ensure(host() == xhost);
280  ensure(name() == xname);
281  ensure(is_attached());
282  ensure(!is_restricted());
283 
284 }
285 
286 
288 sec_st4_e2(const namespace_poset* xnamespace,
289  const poset_path& xpath,
290  bool xauto_access)
291 {
292 
293  // Preconditions:
294 
295  require(precondition_of(attach_to_state(same args)));
296 
297  // Body:
298 
299  attach_to_state(xnamespace, xpath, xauto_access);
300 
301  // Postconditions:
302 
303  ensure(postcondition_of(attach_to_state(same args)));
304 
305  // Exit:
306 
307  return;
308 }
309 
310 
313 {
314 
315  // Preconditions:
316 
317  require(xother != 0);
318 
319  // Body:
320 
321  attach_to_state(xother);
322 
323  // Postconditions:
324 
325  ensure(invariant());
326  ensure(is_attached());
327  ensure(is_same_state(xother));
328  ensure(is_same_restriction(xother));
329 
330 }
331 
333 sec_st4_e2(sec_rep_space* xhost, section_dof_map* xdof_map, bool xauto_access)
334 {
335 
336  // Preconditions:
337 
338  require(precondition_of(new_jim_state(xhost, xdof_map, false, xauto_access)));
339 
340  // Body:
341 
342  new_jim_state(xhost, xdof_map, false, xauto_access);
343 
344  // Postconditions:
345 
346  ensure(postcondition_of(new_jim_state(xhost, xdof_map, false, xauto_access)));
347 
348  // Exit:
349 
350  return;
351 }
352 
355  abstract_poset_member& xbase_mbr,
356  int xbase_version, bool xauto_access)
357 {
358 
359  // Preconditions:
360 
361  require(precondition_of(new_jim_state(\
362  xhost, xbase_mbr, xbase_version, xauto_access)));
363 
364  // Body:
365 
366  new_jim_state(xhost, xbase_mbr, xbase_version, xauto_access);
367 
368  // Postconditions:
369 
370  ensure(postcondition_of(new_jim_state(\
371  xhost, xbase_mbr, xbase_version, xauto_access)));
372 
373  // Exit:
374 
375  return;
376 }
377 
381 {
382  // Preconditions:
383 
384  require(is_ancestor_of(&xother));
385  require(precondition_of(attach_to_state(&xother)));
386 
387  // Body:
388 
389  attach_to_state(&xother);
390 
391  // Postconditions:
392 
393  ensure(postcondition_of(attach_to_state(&xother)));
394 
395  // Exit:
396 
397  return *this;
398 }
399 
402 operator=(const sec_st4_e2& xother)
403 {
404  // Preconditions:
405 
406  require(precondition_of(attach_to_state(&xother)));
407 
408  // Body:
409 
410  attach_to_state(&xother);
411 
412  // Postconditions:
413 
414  ensure(postcondition_of(attach_to_state(&xother)));
415 
416  // Exit:
417 
418  return *this;
419 }
420 
423 operator=(const st4_e2& xfiber)
424 {
425  // Preconditions:
426 
427  require(precondition_of(sec_vd::operator=(xfiber)));
428 
429  // Body:
430 
431  sec_vd::operator=(xfiber);
432 
433  // Postconditions:
434 
435  ensure(postcondition_of(sec_vd::operator=(xfiber)));
436 
437  // Exit:
438 
439  return *this;
440 }
441 
444 operator=(const st4_e2_lite& xfiber)
445 {
446  // Preconditions:
447 
448  require(precondition_of(sec_vd::operator=(xfiber)));
449 
450  // Body:
451 
452  sec_vd::operator=(xfiber);
453 
454  // Postconditions:
455 
456  ensure(postcondition_of(sec_vd::operator=(xfiber)));
457 
458  // Exit:
459 
460  return *this;
461 }
462 
465 {
466  // Preconditions:
467 
468  // Body:
469 
470  // Postconditions:
471 
472 }
473 
477 {
478  // Preconditions:
479 
480  // Body:
481 
482  static const fiber_type result;
483 
484  // Postconditions:
485 
486  // Exit:
487 
488  return result;
489 }
490 
491 // PROTECTED MEMBER FUNCTIONS
492 
493 // PRIVATE MEMBER FUNCTIONS
494 
495 
496 //==============================================================================
497 // ST4 FACET OF CLASS SEC_ST4_E2
498 //==============================================================================
499 
500 // PUBLIC MEMBER FUNCTIONS
501 
502 // PROTECTED MEMBER FUNCTIONS
503 
504 // PRIVATE MEMBER FUNCTIONS
505 
506 
507 //==============================================================================
508 // STP FACET OF CLASS SEC_ST4_E2
509 //==============================================================================
510 
511 // PUBLIC MEMBER FUNCTIONS
512 
513 // PROTECTED MEMBER FUNCTIONS
514 
515 // PRIVATE MEMBER FUNCTIONS
516 
517 
518 //==============================================================================
519 // TP FACET OF CLASS SEC_ST4_E2
520 //==============================================================================
521 
522 // PUBLIC MEMBER FUNCTIONS
523 
524 // PROTECTED MEMBER FUNCTIONS
525 
526 // PRIVATE MEMBER FUNCTIONS
527 
528 
529 //==============================================================================
530 // VD FACET OF CLASS SEC_ST4_E2
531 //==============================================================================
532 
533 // PUBLIC MEMBER FUNCTIONS
534 
535 // PROTECTED MEMBER FUNCTIONS
536 
537 // PRIVATE MEMBER FUNCTIONS
538 
539 
540 //==============================================================================
541 // TUPLE FACET OF CLASS SEC_ST4_E2
542 //==============================================================================
543 
544 // PUBLIC MEMBER FUNCTIONS
545 
546 // PROTECTED MEMBER FUNCTIONS
547 
548 // PRIVATE MEMBER FUNCTIONS
549 
550 
551 //==============================================================================
552 // ABSTRACT POSET MEMBER FACET OF CLASS SEC_ST4_E2
553 //==============================================================================
554 
555 // PUBLIC MEMBER FUNCTIONS
556 
557 const std::string&
559 class_name() const
560 {
561  // Preconditions:
562 
563  // Body:
564 
565  const string& result = static_class_name();
566 
567  // Postconditions:
568 
569  ensure(!result.empty());
570 
571  // Exit:
572 
573  return result;
574 }
575 
576 const std::string&
579 {
580  // Preconditions:
581 
582  // Body:
583 
584  static const string result("sec_st4_e2");
585 
586  // Postconditions:
587 
588  ensure(!result.empty());
589 
590  // Exit:
591 
592  return result;
593 }
594 
597 clone() const
598 {
599 
600  // Preconditions:
601 
602  // Body:
603 
604  // create new handle of the current class.
605 
606  sec_st4_e2 *result = new sec_st4_e2();
607 
608  // Postconditions:
609 
610  ensure(result != 0);
611  ensure(result->invariant());
612 
613  // Exit:
614 
615  return result;
616 
617 }
618 
619 // PROTECTED MEMBER FUNCTIONS
620 
621 // PRIVATE MEMBER FUNCTIONS
622 
623 
624 //==============================================================================
625 // ANY FACET OF CLASS SEC_ST4_E2
626 //==============================================================================
627 
628 // PUBLIC MEMBER FUNCTIONS
629 
630 bool
632 fiber_is_ancestor_of(const any* xother) const
633 {
634 
635  // Preconditions:
636 
637  require(xother != 0);
638 
639  // Body:
640 
641  // If xother may be dynamically cast to the type of this fiber then this
642  // fiber is an ancestor of xother.
643 
644  bool result = dynamic_cast<const st4_e2*>(xother) != 0;
645 
646  // Postconditions:
647 
648  ensure(invariant());
649  ensure(xother->invariant());
650 
651  // Exit:
652 
653  return result;
654 
655 }
656 
657 bool
659 is_ancestor_of(const any* xother) const
660 {
661  // Preconditions:
662 
663  require(xother != 0);
664 
665  // Body:
666 
667  // If other may be dynamically cast to the type of this then this is an
668  // ancestor of other.
669 
670  bool result = dynamic_cast<const sec_st4_e2*>(xother) != 0;
671 
672  // Postconditions:
673 
674  //ensure(invariant());
675 
676  // Exit:
677 
678  return result;
679 
680 }
681 
682 bool
684 invariant() const
685 {
686  bool result = true;
687 
688  // Preconditions:
689 
690  // Body:
691 
692  // Must satisfy base class invariant
693 
694  invariance(sec_st4::invariant());
695 
696  if (invariant_check())
697  {
698  // Prevent recursive calls to invariant
699 
700  disable_invariant_check();
701 
702  invariance(is_attached() ? dd() == 2 : true);
703 
704  // Finished, turn invariant checking back on.
705 
706  enable_invariant_check();
707  }
708 
709  // Postconditions:
710 
711  ensure(is_derived_query);
712 
713  // Exit:
714 
715  return result;
716 }
717 
718 // PROTECTED MEMBER FUNCTIONS
719 
720 // PRIVATE MEMBER FUNCTIONS
721 
722 
virtual bool invariant() const
Class invariant, intended to be redefined in each descendant. See below for template for invariant in...
Definition: any.cc:153
static int factor_ct(int xd)
Factor_ct() as a function of dimension xd.
virtual sec_st4_e2 & operator=(const abstract_poset_member &xother)
Assignment operator; synonym for attach_to_state(&xother).
Definition: sec_st4_e2.cc:380
bool is_ancestor_of(const any *xother) const
True if xother conforms to current.
Definition: sec_st4_e2.cc:659
virtual poset_path path(bool xauto_access=true) const
The path of this poset.
bool state_is_auto_read_write_accessible(bool xauto_access) const
True if state is auto accessible for read and write, that is, if the state is already accessible for ...
An abstract symmetric tensor section space of degree p.
Definition: sec_stp_space.h:47
static const std::string & static_class_name()
The name of this class.
Definition: sec_st4_e2.cc:578
bool full() const
True if both poset name and member name are not empty.
Definition: poset_path.cc:311
The abstract map from section dof ids to section dof values of heterogeneous type.
A space of scalars viewed as an antisymmetric tensor section space of degree 1.
Definition: sec_at1_space.h:48
poset_path path(bool xauto_access=true) const
A path to this component.
The default name space; a poset which contains other posets as members.
bool state_is_read_accessible() const
True if this is attached and if the state is accessible for read or access control is disabled...
bool path_is_auto_read_accessible(const poset_path &xpath, bool xauto_access) const
True if the state referred to xpath exists and is auto read accessible.
The standard fiber bundles name space; extends the standard sheaves namespace by defining base space...
static host_type & new_host(namespace_type &xns, const poset_path &xhost_path, const poset_path &xschema_path, const poset_path &xvector_space_path, bool xauto_access)
Creates a new host table for members of this type. The poset is created in namespace xns with path xh...
Definition: sec_st4_e2.cc:55
A path defined by a poset name and a member name separated by a forward slash (&#39;/&#39;). For example: "cell_definitions/triangle".
Definition: poset_path.h:48
A member of a sec_rep_space; a section.
poset_path vector_space_path() const
The path of the underlying vector space.
STL namespace.
A schema poset for a section space. A binary Cartesian product subspace of the binary tensor product ...
poset_state_handle & member_poset(pod_index_type xhub_id, bool xauto_access=true) const
The poset_state_handle object referred to by hub id xhub_id.
The poset for sec_rep_descriptors.
A symmetric rank 4 tensor over an abstract vector space (persistent version).
Definition: st4.h:230
virtual const std::string & class_name() const
The name of this class.
Definition: sec_st4_e2.cc:559
Abstract base class with useful features for all objects.
Definition: any.h:39
int p() const
The tensor degree of this space.
The lattice of closed cells of a cellular space; a lattice representation of a computational mesh...
sec_rep_descriptor & rep()
A representation descriptor for this sec rep space (mutable version).
virtual section_space_schema_member & schema()
The schema for this poset (mutable version)
virtual int d(int xp, int xdd) const
Dimension d() as a function of degree xp and domain dimension xdd.
static host_type & standard_host(namespace_type &xns, const poset_path &xbase_path, const poset_path &xrep_path, const std::string &xsection_suffix, const std::string &xfiber_suffix, bool xauto_access)
The standard host for sections of this type with base space xbase_path, representation xrep_path...
Definition: sec_st4_e2.cc:106
bool owns(const poset_state_handle &xposet, bool xauto_access) const
True if and only if this contains the poset xposet. synonym for contains_poset(xposet.poset_path(true), xauto_access)
An index within the external ("client") scope of a given id space.
Definition: scoped_index.h:116
bool invariant() const
Class invariant.
Definition: sec_st4_e2.cc:684
bool contains_path(const poset_path &xpath, bool xauto_access=true) const
True if this contains the poset or poset member specified by xpath.
virtual bool contains_member(pod_index_type xmbr_hub_id, bool xauto_access=true) const
True if some version of this poset contains poset member with hub id xmbr_hub_id. ...
int dd() const
The dimension of the underlying ("domain") vector space.
A symmetric rank 3 tensor over a 3D Euclidean vector space (persistent version).
Definition: st4_e2.h:376
bool empty() const
True if both poset name and member name are empty.
Definition: poset_path.cc:291
A symmetric rank 4 tensor over a Euclidean vector space of dimension 3. (volatile version)...
Definition: st4_e2.h:124
A section of a bundle with fiber type st4_e2.
Definition: sec_st4_e2.h:48
int_type pod_index_type
The plain old data index type.
Definition: pod_types.h:49
poset_path scalar_space_path() const
The path of the underlying space of scalars.
poset & fiber_space()
The fiber space for section spaces on this schema (mutable version).
virtual const fiber_type & fiber_prototype() const
Virtual constructor for the associated fiber type.
Definition: sec_st4_e2.cc:476
sec_st4_e2()
Default constructor.
Definition: sec_st4_e2.cc:206
An abstract client handle for a member of a poset.
std::string path() const
The full path as a string.
Definition: poset_path.cc:450
An abstract symmetric tensor space of degree p.
Definition: stp_space.h:42
Namespace for the fiber_bundles component of the sheaf system.
virtual sec_st4_e2 * clone() const
Make a new handle, no state instance of current.
Definition: sec_st4_e2.cc:597
~sec_st4_e2()
Destructor.
Definition: sec_st4_e2.cc:464
bool state_is_not_read_accessible() const
True if this is attached and if the state is accessible for read or if access control is disabled...
bool fiber_is_ancestor_of(const any *xother) const
True if xother conforms to an instance of the fiber of current.
Definition: sec_st4_e2.cc:632
pod_type hub_pod() const
The pod value of this mapped to the unglued hub id space.
Definition: scoped_index.h:710
A handle for a poset whose members are numerical representations of sections of a fiber bundle...
Definition: sec_rep_space.h:61