SheafSystem  0.0.0.0
sec_e1.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_e1.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_tuple.impl.h"
33 #include "SheafSystem/sec_tuple_space.impl.h"
34 #include "SheafSystem/sec_vd.impl.h"
35 
36 
37 using namespace std;
38 using namespace fiber_bundle; // Workaround for MS C++ bug.
39 
40 //==============================================================================
41 // CLASS SEC_E1
42 //==============================================================================
43 
44 // ===========================================================
45 // HOST FACTORY FACET OF CLASS SEC_E1
46 // ===========================================================
47 
48 // PUBLIC MEMBER FUNCTIONS
49 
53  const poset_path& xhost_path,
54  const poset_path& xschema_path,
55  const poset_path& xscalar_space_path,
56  bool xauto_access)
57 {
58  // cout << endl << "Entering sec_e1::new_host." << endl;
59 
60  // Preconditions:
61 
62  require(xns.state_is_auto_read_write_accessible(xauto_access));
63 
64  require(!xhost_path.empty());
65  require(!xns.contains_path(xhost_path, xauto_access));
66 
67  require(xschema_path.full());
68  require(xns.path_is_auto_read_accessible<schema_type::host_type>(xschema_path, xauto_access));
69  require(host_type::fiber_space_conforms<fiber_type::host_type>(xns, xschema_path, xauto_access));
70 
71  require(xns.path_is_auto_read_accessible<scalar_type::host_type>(xscalar_space_path, xauto_access));
72 
73  require(host_type::same_scalar_fiber_space(xns, xschema_path, xscalar_space_path, xauto_access));
74 
75  // Body:
76 
77  host_type& result = host_type::new_table(xns, xhost_path, xschema_path, xscalar_space_path, xauto_access);
78 
79  // Postconditions:
80 
81  ensure(xns.owns(result, xauto_access));
82  ensure(result.path(true) == xhost_path);
83  ensure(result.state_is_not_read_accessible());
84  ensure(result.schema(true).path(xauto_access) == xschema_path);
85 
86  ensure(result.factor_ct(true) == result.schema(true).fiber_space<fiber_type::host_type>().factor_ct(xauto_access));
87  ensure(result.d(true) == result.schema(true).fiber_space<fiber_type::host_type>().d(xauto_access));
88  ensure(result.d(true) == result.dd(true));
89  ensure(result.scalar_space_path(true) == xscalar_space_path);
90  ensure(result.p(true) == result.schema(true).fiber_space<fiber_type::host_type>().p(xauto_access));
91  ensure(result.p(true) == 1);
92  ensure(result.dd(true) == result.schema(true).fiber_space<fiber_type::host_type>().dd(xauto_access));
93  ensure(result.vector_space_path(true) == xhost_path);
94 
95  // Exit:
96 
97  // cout << "Leaving sec_e1::new_host." << endl;
98  return result;
99 }
100 
104  const poset_path& xbase_path,
105  const poset_path& xrep_path,
106  const std::string& xsection_suffix,
107  const std::string& xfiber_suffix,
108  bool xauto_access)
109 {
110  // cout << endl << "Entering sec_e1::new_host." << endl;
111 
112  // Preconditions:
113 
114  require(xns.state_is_auto_read_write_accessible(xauto_access));
115 
116  require(xbase_path.full());
117  require(xns.path_is_auto_read_accessible<base_space_poset>(xbase_path, xauto_access));
118 
119  require(xrep_path.empty() || xrep_path.full());
120  require(xrep_path.empty() || xns.path_is_auto_read_accessible<sec_rep_descriptor_poset>(xrep_path, xauto_access));
121 
122  require(xsection_suffix.empty() || poset_path::is_valid_name(xsection_suffix));
123 
124  require(xfiber_suffix.empty() || poset_path::is_valid_name(xfiber_suffix));
125 
126  require(standard_host_is_available<sec_e1>(xns, xbase_path, xrep_path, xsection_suffix, xfiber_suffix, xauto_access));
127  require(fiber_type::standard_host_is_available<fiber_type>(xns, xfiber_suffix, xauto_access));
128  require(schema_type::standard_host_is_available<sec_e1>(xns, xbase_path, xrep_path, xfiber_suffix, xauto_access));
129 
130  // Body:
131 
132  poset_path lstd_path = standard_host_path<sec_e1>(xbase_path, xrep_path, xsection_suffix, xfiber_suffix);
133 
134  host_type* lresult_ptr;
135 
136  if(xns.contains_path(lstd_path, xauto_access))
137  {
138  // Standard host already exists, just return it.
139 
140  lresult_ptr = &xns.member_poset<host_type>(lstd_path, xauto_access);
141  }
142  else
143  {
144  // Standard host doesn't exist, have to create it.
145 
146  // Apply default for rep path if needed.
147 
148  poset_path lrep_path = (!xrep_path.empty() ? xrep_path : standard_rep_path());
149 
150  // Find or create the standard schema member.
151 
152  poset_path lstd_schema_path =
153  schema_type::standard_member<sec_e1>(xns, xbase_path, lrep_path, xfiber_suffix, xauto_access);
154 
155  // Find or create the standard scalar space.
156 
157  poset_path lscalar_space_path =
158  scalar_type::standard_host(xns, xbase_path, lrep_path, xsection_suffix, xfiber_suffix, xauto_access).path(xauto_access);
159 
160  // Create the standard host.
161 
162  lresult_ptr = &new_host(xns, lstd_path, lstd_schema_path, lscalar_space_path, xauto_access);
163  }
164 
165  host_type& result = *lresult_ptr;
166 
167  // Postconditions:
168 
169  ensure(xns.owns(result, xauto_access));
170  ensure(result.path(true) == standard_host_path<sec_e1>(xbase_path, xrep_path, xsection_suffix, xfiber_suffix));
171  ensure(result.state_is_not_read_accessible());
172  ensure(result.schema(true).path(xauto_access) ==
173  schema_type::standard_member_path<sec_e1>(xbase_path, xrep_path, xfiber_suffix));
174 
175  ensure(result.factor_ct(true) == result.schema(true).fiber_space<fiber_type::host_type>().factor_ct(xauto_access));
176  ensure(result.d(true) == result.schema(true).fiber_space<fiber_type::host_type>().d(xauto_access));
177  ensure(result.d(true) == result.dd(true));
178  ensure(result.scalar_space_path(true) ==
179  scalar_type::standard_host_path<scalar_type>(xbase_path, result.rep().path(xauto_access), xsection_suffix, xfiber_suffix));
180  ensure(result.p(true) == result.schema(true).fiber_space<fiber_type::host_type>().p(xauto_access));
181  ensure(result.p(true) == 1);
182  ensure(result.dd(true) == result.schema(true).fiber_space<fiber_type::host_type>().dd(xauto_access));
183  ensure(result.vector_space_path(true) == result.path(true));
184 
185  // Exit:
186 
187  // cout << "Leaving sec_e1::new_host." << endl;
188  return result;
189 }
190 
191 // PROTECTED MEMBER FUNCTIONS
192 
193 // PRIVATE MEMBER FUNCTIONS
194 
195 
196 //==============================================================================
197 // E1 FACET OF CLASS SEC_E1
198 //==============================================================================
199 
200 // PUBLIC MEMBER FUNCTIONS
201 
204 {
205  // Preconditions:
206 
207  // Body:
208 
209  // Postconditions:
210 
211  ensure(invariant());
212 }
213 
215 sec_e1(const sec_rep_space* xhost, pod_index_type xhub_id)
216 {
217  // Preconditions:
218 
219  require(xhost != 0);
220  require(xhost->state_is_read_accessible());
221  require(xhost->contains_member(xhub_id));
222 
223  // Body:
224 
225  attach_to_state(xhost, xhub_id);
226 
227  // Postconditions:
228 
229  ensure(invariant());
230  //ensure(host() == xhost);
231  ensure(index() == xhub_id);
232  ensure(is_attached());
233  ensure(!is_restricted());
234 }
235 
237 sec_e1(const sec_rep_space* xhost, const scoped_index& xid)
238 {
239  // Preconditions:
240 
241  require(xhost != 0);
242  require(xhost->state_is_read_accessible());
243  require(xhost->contains_member(xid));
244 
245  // Body:
246 
247  attach_to_state(xhost, xid.hub_pod());
248 
249  // Postconditions:
250 
251  ensure(invariant());
252  //ensure(host() == xhost);
253  ensure(index() ==~ xid);
254  ensure(is_attached());
255  ensure(!is_restricted());
256 }
257 
259 sec_e1(const sec_rep_space* xhost, const std::string& xname)
260 {
261  // Preconditions:
262 
263  require(xhost != 0);
264  require(xhost->state_is_read_accessible());
265  require(!xname.empty());
266  require(xhost->contains_member(xname));
267 
268  // Body:
269 
270  attach_to_state(xhost, xname);
271 
272  // Postconditions:
273 
274  ensure(invariant());
275  //ensure(host() == xhost);
276  ensure(name() == xname);
277  ensure(is_attached());
278  ensure(!is_restricted());
279 
280 }
281 
283 sec_e1(const namespace_poset* xnamespace,
284  const poset_path& xpath,
285  bool xauto_access)
286 {
287  // Preconditions:
288 
289  require(precondition_of(attach_to_state(same args)));
290 
291  // Body:
292 
293  attach_to_state(xnamespace, xpath, xauto_access);
294 
295  // Postconditions:
296 
297  ensure(postcondition_of(attach_to_state(same args)));
298 
299  // Exit:
300 
301  return;
302 }
303 
306 {
307  // Preconditions:
308 
309  require(xother != 0);
310 
311  // Body:
312 
313  attach_to_state(xother);
314 
315  // Postconditions:
316 
317  ensure(invariant());
318  ensure(is_attached());
319  ensure(is_same_state(xother));
320  ensure(is_same_restriction(xother));
321 
322 }
323 
325 sec_e1(sec_rep_space* xhost, section_dof_map* xdof_map, bool xauto_access)
326 {
327  // Preconditions:
328 
329  require(precondition_of(new_jim_state(xhost, xdof_map, false, xauto_access)));
330 
331  // Body:
332 
333  new_jim_state(xhost, xdof_map, false, xauto_access);
334 
335  // Postconditions:
336 
337  ensure(postcondition_of(new_jim_state(xhost, xdof_map, false, xauto_access)));
338 
339  // Exit:
340 
341  return;
342 }
343 
346  abstract_poset_member& xbase_mbr,
347  int xbase_version, bool xauto_access)
348 {
349  // Preconditions:
350 
351  require(precondition_of(\
352  new_jim_state(xhost, xbase_mbr, xbase_version, xauto_access)));
353 
354  // Body:
355 
356  new_jim_state(xhost, xbase_mbr, xbase_version, xauto_access);
357 
358  // Postconditions:
359 
360  ensure(postcondition_of(\
361  new_jim_state(xhost, xbase_mbr, xbase_version, xauto_access)));
362 
363  // Exit:
364 
365  return;
366 }
367 
369 sec_e1(sec_rep_space* xhost, const subposet& xbase_parts, bool xauto_access)
370 {
371  // Preconditions:
372 
373  require(precondition_of(new_jim_state(xhost, xbase_parts, xauto_access)));
374 
375  // Body:
376 
377  new_jrm_state(xhost, xbase_parts, xauto_access);
378 
379  // Postconditions:
380 
381  require(postcondition_of(new_jim_state(xhost, xbase_parts, xauto_access)));
382 
383  // Exit:
384 
385  return;
386 }
387 
391 {
392  // Preconditions:
393 
394  require(is_ancestor_of(&xother));
395  require(precondition_of(attach_to_state(&xother)));
396 
397  // Body:
398 
399  attach_to_state(&xother);
400 
401  // Postconditions:
402 
403  ensure(postcondition_of(attach_to_state(&xother)));
404 
405  // Exit:
406 
407  return *this;
408 }
409 
412 operator=(const sec_e1& xother)
413 {
414  // Preconditions:
415 
416  require(precondition_of(attach_to_state(&xother)));
417 
418  // Body:
419 
420  attach_to_state(&xother);
421 
422  // Postconditions:
423 
424  ensure(postcondition_of(attach_to_state(&xother)));
425 
426  // Exit:
427 
428  return *this;
429 }
430 
433 operator=(const e1& xfiber)
434 {
435  // Preconditions:
436 
437  require(precondition_of(sec_vd::operator=(xfiber)));
438 
439  // Body:
440 
441  sec_vd::operator=(xfiber);
442 
443  // Postconditions:
444 
445  ensure(postcondition_of(sec_vd::operator=(xfiber)));
446 
447  // Exit:
448 
449  return *this;
450 }
451 
454 operator=(const e1_lite& xfiber)
455 {
456  // Preconditions:
457 
458  require(precondition_of(sec_vd::operator=(xfiber)));
459 
460  // Body:
461 
462  sec_vd::operator=(xfiber);
463 
464  // Postconditions:
465 
466  ensure(postcondition_of(sec_vd::operator=(xfiber)));
467 
468  // Exit:
469 
470  return *this;
471 }
472 
475 {
476  // Preconditions:
477 
478  // Body:
479 
480  // Postconditions:
481 
482 }
483 
487 {
488  // Preconditions:
489 
490  // Body:
491 
492  static const fiber_type result;
493 
494  // Postconditions:
495 
496  // Exit:
497 
498  return result;
499 }
500 
501 // PROTECTED MEMBER FUNCTIONS
502 
503 // PRIVATE MEMBER FUNCTIONS
504 
505 
506 //==============================================================================
507 // ED FACET OF CLASS SEC_E1
508 //==============================================================================
509 
510 // PUBLIC MEMBER FUNCTIONS
511 
512 // PROTECTED MEMBER FUNCTIONS
513 
514 // PRIVATE MEMBER FUNCTIONS
515 
516 
517 //==============================================================================
518 // AT1 FACET OF CLASS SEC_E1
519 //==============================================================================
520 
521 // PUBLIC MEMBER FUNCTIONS
522 
523 // PROTECTED MEMBER FUNCTIONS
524 
525 // PRIVATE MEMBER FUNCTIONS
526 
527 
528 //==============================================================================
529 // ATP FACET OF CLASS SEC_E1
530 //==============================================================================
531 
532 // PUBLIC MEMBER FUNCTIONS
533 
534 // PROTECTED MEMBER FUNCTIONS
535 
536 // PRIVATE MEMBER FUNCTIONS
537 
538 
539 //==============================================================================
540 // TP FACET OF CLASS SEC_E1
541 //==============================================================================
542 
543 // PUBLIC MEMBER FUNCTIONS
544 
545 // PROTECTED MEMBER FUNCTIONS
546 
547 // PRIVATE MEMBER FUNCTIONS
548 
549 
550 //==============================================================================
551 // VD FACET OF CLASS SEC_E1
552 //==============================================================================
553 
554 // PUBLIC MEMBER FUNCTIONS
555 
556 // PROTECTED MEMBER FUNCTIONS
557 
558 // PRIVATE MEMBER FUNCTIONS
559 
560 
561 //==============================================================================
562 // TUPLE FACET OF CLASS SEC_E1
563 //==============================================================================
564 
565 // PUBLIC MEMBER FUNCTIONS
566 
567 // PROTECTED MEMBER FUNCTIONS
568 
569 // PRIVATE MEMBER FUNCTIONS
570 
571 
572 //==============================================================================
573 // ABSTRACT POSET MEMBER FACET OF CLASS SEC_E1
574 //==============================================================================
575 
576 // PUBLIC MEMBER FUNCTIONS
577 
578 const std::string&
580 class_name() const
581 {
582  // Preconditions:
583 
584  // Body:
585 
586  const string& result = static_class_name();
587 
588  // Postconditions:
589 
590  ensure(!result.empty());
591 
592  // Exit:
593 
594  return result;
595 }
596 
597 const std::string&
600 {
601  // Preconditions:
602 
603  // Body:
604 
605  static const string result("sec_e1");
606 
607  // Postconditions:
608 
609  ensure(!result.empty());
610 
611  // Exit:
612 
613  return result;
614 }
615 
618 clone() const
619 {
620 
621  // Preconditions:
622 
623  // Body:
624 
625  // Create new handle of the current class.
626 
627  sec_e1* result = new sec_e1();
628 
629  // Postconditions:
630 
631  ensure(result != 0);
632  ensure(result->invariant());
633 
634  // Exit:
635 
636  return result;
637 
638 }
639 
640 // PROTECTED MEMBER FUNCTIONS
641 
642 // PRIVATE MEMBER FUNCTIONS
643 
644 
645 //==============================================================================
646 // ANY FACET OF CLASS SEC_E1
647 //==============================================================================
648 
649 // PUBLIC MEMBER FUNCTIONS
650 
651 bool
653 fiber_is_ancestor_of(const any* xother) const
654 {
655  // Preconditions:
656 
657  require(xother != 0);
658 
659  // Body:
660 
661  // If xother may be dynamically cast to the type of this fiber then this
662  // fiber is an ancestor of xother.
663 
664  bool result = dynamic_cast<const e1*>(xother) != 0;
665 
666  // Postconditions:
667 
668  //ensure(invariant());
669 
670  // Exit:
671 
672  return result;
673 
674 }
675 
676 bool
678 is_ancestor_of(const any* xother) const
679 {
680 
681  // Preconditions:
682 
683  require(xother != 0);
684 
685  // Body:
686 
687  // If other may be dynamically cast to the type of this then this is an
688  // ancestor of other.
689 
690  bool result = dynamic_cast<const sec_e1*>(xother) != 0;
691 
692  // Postconditions:
693 
694  //ensure(invariant());
695 
696  // Exit:
697 
698  return result;
699 
700 }
701 
702 bool
704 invariant() const
705 {
706  bool result = true;
707 
708  // Preconditions:
709 
710  // Body:
711 
712  // Must satisfy base class invariant.
713 
714  invariance(sec_ed::invariant());
715 
716  if (invariant_check())
717  {
718  // Prevent recursive calls to invariant.
719 
720  disable_invariant_check();
721 
722  invariance(is_attached() ? df() == 1 : true);
723 
724  // Finished, turn invariant checking back on.
725 
726  enable_invariant_check();
727  }
728 
729  // Postconditions:
730 
731  ensure(is_derived_query);
732 
733  // Exit:
734 
735  return result;
736 }
737 
738 // PROTECTED MEMBER FUNCTIONS
739 
740 // PRIVATE MEMBER FUNCTIONS
741 
virtual sec_e1 * clone() const
make a new handle, no state instance of current
Definition: sec_e1.cc:618
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 ...
A client handle for a subposet.
Definition: subposet.h:86
sec_e1()
default constructor
Definition: sec_e1.cc:203
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_e1.cc:704
A Cartesian product section space.
The abstract map from section dof ids to section dof values of heterogeneous type.
static host_type & new_host(namespace_type &xns, const poset_path &xhost_path, const poset_path &xschema_path, const poset_path &xscalar_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_e1.cc:52
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.
A general antisymmetric tensor of degree 1 over an abstract vector space (persistent version)...
Definition: at1.h:211
The standard fiber bundles name space; extends the standard sheaves namespace by defining base space...
virtual const fiber_type & fiber_prototype() const
Virtual constructor for the associated fiber type.
Definition: sec_e1.cc:486
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 *other) const
true if other conforms to current
Definition: sec_e1.cc:678
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.
Euclidean vector space of dimension 1 (persistent version).
Definition: e1.h:400
virtual sec_e1 & operator=(const abstract_poset_member &xother)
Assignment operator; synonym for attach_to_state(&xother).
Definition: sec_e1.cc:390
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)
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
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_e1.cc:103
virtual const std::string & class_name() const
The name of this class.
Definition: sec_e1.cc:580
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. ...
bool fiber_is_ancestor_of(const any *xother) const
True if xother conforms to an instance of the fiber of current.
Definition: sec_e1.cc:653
int dd() const
The dimension of the underlying ("domain") vector space.
bool empty() const
True if both poset name and member name are empty.
Definition: poset_path.cc:291
An abstract vector space viewed as an antisymmetric tensor space of degree 1.
Definition: at1_space.h:42
static const std::string & static_class_name()
The name of this class.
Definition: sec_e1.cc:599
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 section of a fiber bundle with a 1-dimensional Euclidean vector space fiber.
Definition: sec_e1.h:47
Euclidean vector space of dimension 1 (volatile version).
Definition: e1.h:113
An abstract client handle for a member of a poset.
~sec_e1()
Destructor.
Definition: sec_e1.cc:474
std::string path() const
The full path as a string.
Definition: poset_path.cc:450
Namespace for the fiber_bundles component of the sheaf system.
virtual int d(int xp, int xdd) const
Dimension d() as a function of degree xp and domain dimension xdd.
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