SheafSystem  0.0.0.0
sec_st4_e3.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_e3.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_e3.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_e3.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_E3
45 //==============================================================================
46 
47 // ===========================================================
48 // HOST FACTORY FACET OF CLASS SEC_ST4_E3
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_e3::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_e3::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_e3::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_e3>(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_e3>(xns, xbase_path, xrep_path, xfiber_suffix, xauto_access));
132 
133  // Body:
134 
135  poset_path lstd_path = standard_host_path<sec_st4_e3>(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_e3>(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_e3>(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_e3>(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_e3::new_host." << endl;
191  return result;
192 }
193 
194 // PROTECTED MEMBER FUNCTIONS
195 
196 // PRIVATE MEMBER FUNCTIONS
197 
198 
199 //==============================================================================
200 // ST4_E3 FACET OF CLASS SEC_ST4_E3
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_e3(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_e3(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_e3(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_e3(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(xhost, xbase_mbr, xbase_version, xauto_access)));
362 
363  // Body:
364 
365  new_jim_state(xhost, xbase_mbr, xbase_version, xauto_access);
366 
367  // Postconditions:
368 
369  ensure(postcondition_of(new_jim_state(xhost, xbase_mbr, xbase_version, xauto_access)));
370 
371  // Exit:
372 
373  return;
374 }
375 
379 {
380  // Preconditions:
381 
382  require(is_ancestor_of(&xother));
383  require(precondition_of(attach_to_state(&xother)));
384 
385  // Body:
386 
387  attach_to_state(&xother);
388 
389  // Postconditions:
390 
391  ensure(postcondition_of(attach_to_state(&xother)));
392 
393  // Exit:
394 
395  return *this;
396 }
397 
400 operator=(const sec_st4_e3& xother)
401 {
402  // Preconditions:
403 
404  require(precondition_of(attach_to_state(&xother)));
405 
406  // Body:
407 
408  attach_to_state(&xother);
409 
410  // Postconditions:
411 
412  ensure(postcondition_of(attach_to_state(&xother)));
413 
414  // Exit:
415 
416  return *this;
417 }
418 
421 operator=(const st4_e3& xfiber)
422 {
423  // Preconditions:
424 
425  require(precondition_of(sec_vd::operator=(xfiber)));
426 
427  // Body:
428 
429  sec_vd::operator=(xfiber);
430 
431  // Postconditions:
432 
433  ensure(postcondition_of(sec_vd::operator=(xfiber)));
434 
435  // Exit:
436 
437  return *this;
438 }
439 
442 operator=(const st4_e3_lite& xfiber)
443 {
444  // Preconditions:
445 
446  require(precondition_of(sec_vd::operator=(xfiber)));
447 
448  // Body:
449 
450  sec_vd::operator=(xfiber);
451 
452  // Postconditions:
453 
454  ensure(postcondition_of(sec_vd::operator=(xfiber)));
455 
456  // Exit:
457 
458  return *this;
459 }
460 
463 {
464  // Preconditions:
465 
466  // Body:
467 
468  // Postconditions:
469 
470 }
471 
475 {
476  // Preconditions:
477 
478  // Body:
479 
480  static const fiber_type result;
481 
482  // Postconditions:
483 
484  // Exit:
485 
486  return result;
487 }
488 
489 // PROTECTED MEMBER FUNCTIONS
490 
491 // PRIVATE MEMBER FUNCTIONS
492 
493 
494 //==============================================================================
495 // ST4 FACET OF CLASS SEC_ST4_E3
496 //==============================================================================
497 
498 // PUBLIC MEMBER FUNCTIONS
499 
500 // PROTECTED MEMBER FUNCTIONS
501 
502 // PRIVATE MEMBER FUNCTIONS
503 
504 
505 //==============================================================================
506 // STP FACET OF CLASS SEC_ST4_E3
507 //==============================================================================
508 
509 // PUBLIC MEMBER FUNCTIONS
510 
511 // PROTECTED MEMBER FUNCTIONS
512 
513 // PRIVATE MEMBER FUNCTIONS
514 
515 
516 //==============================================================================
517 // TP FACET OF CLASS SEC_ST4_E3
518 //==============================================================================
519 
520 // PUBLIC MEMBER FUNCTIONS
521 
522 // PROTECTED MEMBER FUNCTIONS
523 
524 // PRIVATE MEMBER FUNCTIONS
525 
526 
527 //==============================================================================
528 // VD FACET OF CLASS SEC_ST4_E3
529 //==============================================================================
530 
531 // PUBLIC MEMBER FUNCTIONS
532 
533 // PROTECTED MEMBER FUNCTIONS
534 
535 // PRIVATE MEMBER FUNCTIONS
536 
537 
538 //==============================================================================
539 // TUPLE FACET OF CLASS SEC_ST4_E3
540 //==============================================================================
541 
542 // PUBLIC MEMBER FUNCTIONS
543 
544 // PROTECTED MEMBER FUNCTIONS
545 
546 // PRIVATE MEMBER FUNCTIONS
547 
548 
549 //==============================================================================
550 // ABSTRACT POSET MEMBER FACET OF CLASS SEC_ST4_E3
551 //==============================================================================
552 
553 // PUBLIC MEMBER FUNCTIONS
554 
555 const std::string&
557 class_name() const
558 {
559  // Preconditions:
560 
561  // Body:
562 
563  const string& result = static_class_name();
564 
565  // Postconditions:
566 
567  ensure(!result.empty());
568 
569  // Exit:
570 
571  return result;
572 }
573 
574 const std::string&
577 {
578  // Preconditions:
579 
580  // Body:
581 
582  static const string result("sec_st4_e3");
583 
584  // Postconditions:
585 
586  ensure(!result.empty());
587 
588  // Exit:
589 
590  return result;
591 }
592 
595 clone() const
596 {
597 
598  // Preconditions:
599 
600  // Body:
601 
602  // create new handle of the current class.
603 
604  sec_st4_e3 *result = new sec_st4_e3();
605 
606  // Postconditions:
607 
608  ensure(result != 0);
609  ensure(result->invariant());
610 
611  // Exit:
612 
613  return result;
614 
615 }
616 
617 // PROTECTED MEMBER FUNCTIONS
618 
619 // PRIVATE MEMBER FUNCTIONS
620 
621 
622 //==============================================================================
623 // ANY FACET OF CLASS SEC_ST4_E3
624 //==============================================================================
625 
626 // PUBLIC MEMBER FUNCTIONS
627 
628 bool
630 fiber_is_ancestor_of(const any* xother) const
631 {
632 
633  // Preconditions:
634 
635  require(xother != 0);
636 
637  // Body:
638 
639  // If xother may be dynamically cast to the type of this fiber then this
640  // fiber is an ancestor of xother.
641 
642  bool result = dynamic_cast<const st4_e3*>(xother) != 0;
643 
644  // Postconditions:
645 
646  ensure(invariant());
647  ensure(xother->invariant());
648 
649  // Exit:
650 
651  return result;
652 
653 }
654 
655 bool
657 is_ancestor_of(const any* xother) const
658 {
659  // Preconditions:
660 
661  require(xother != 0);
662 
663  // Body:
664 
665  // If other may be dynamically cast to the type of this then this is an
666  // ancestor of other.
667 
668  bool result = dynamic_cast<const sec_st4_e3*>(xother) != 0;
669 
670  // Postconditions:
671 
672  //ensure(invariant());
673 
674  // Exit:
675 
676  return result;
677 
678 }
679 
680 bool
682 invariant() const
683 {
684  bool result = true;
685 
686  // Preconditions:
687 
688  // Body:
689 
690  // Must satisfy base class invariant
691 
692  invariance(sec_st4::invariant());
693 
694  if (invariant_check())
695  {
696  // Prevent recursive calls to invariant
697 
698  disable_invariant_check();
699 
700  invariance(is_attached() ? dd() == 3 : true);
701 
702  // Finished, turn invariant checking back on.
703 
704  enable_invariant_check();
705  }
706 
707  // Postconditions:
708 
709  ensure(is_derived_query);
710 
711  // Exit:
712 
713  return result;
714 }
715 
716 // PROTECTED MEMBER FUNCTIONS
717 
718 // PRIVATE MEMBER FUNCTIONS
719 
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 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
virtual sec_st4_e3 * clone() const
Make a new handle, no state instance of current.
Definition: sec_st4_e3.cc:595
bool full() const
True if both poset name and member name are not empty.
Definition: poset_path.cc:311
bool invariant() const
Class invariant.
Definition: sec_st4_e3.cc:682
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
virtual sec_st4_e3 & operator=(const abstract_poset_member &xother)
Assignment operator; synonym for attach_to_state(&xother).
Definition: sec_st4_e3.cc:378
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...
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.
bool is_ancestor_of(const any *xother) const
True if xother conforms to current.
Definition: sec_st4_e3.cc:657
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.
A symmetric rank 4 tensor over a Euclidean vector space of dimension 3. (volatile version)...
Definition: st4_e3.h:134
The poset for sec_rep_descriptors.
static const std::string & static_class_name()
The name of this class.
Definition: sec_st4_e3.cc:576
virtual const std::string & class_name() const
The name of this class.
Definition: sec_st4_e3.cc:557
A symmetric rank 4 tensor over an abstract vector space (persistent version).
Definition: st4.h:230
Abstract base class with useful features for all objects.
Definition: any.h:39
bool fiber_is_ancestor_of(const any *xother) const
True if xother conforms to an instance of the fiber of current.
Definition: sec_st4_e3.cc:630
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)
A section of a bundle with fiber type st4_e3.
Definition: sec_st4_e3.h:48
virtual int d(int xp, int xdd) const
Dimension d() as a function of degree xp and domain dimension xdd.
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 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. ...
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_e3.cc:106
int dd() const
The dimension of the underlying ("domain") vector space.
virtual const fiber_type & fiber_prototype() const
Virtual constructor for the associated fiber type.
Definition: sec_st4_e3.cc:474
bool empty() const
True if both poset name and member name are empty.
Definition: poset_path.cc:291
~sec_st4_e3()
Destructor.
Definition: sec_st4_e3.cc:462
sec_st4_e3()
Default constructor.
Definition: sec_st4_e3.cc:206
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).
A symmetric rank 3 tensor over a 3D Euclidean vector space (persistent version).
Definition: st4_e3.h:386
An abstract client handle for a member of a poset.
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_e3.cc:55
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.
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...
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