SheafSystem  0.0.0.0
sec_met_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_met_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/met_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_MET_E2
45 //==============================================================================
46 
47 // ===========================================================
48 // HOST FACTORY FACET OF CLASS SEC_MET_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_met_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) == 2);
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_met_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_met_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_met_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_met_e2>(xns, xbase_path, xrep_path, xfiber_suffix, xauto_access));
132 
133  // Body:
134 
135  poset_path lstd_path = standard_host_path<sec_met_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_met_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_met_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_met_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) == 2);
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_met_e2::new_host." << endl;
191  return result;
192 }
193 
194 // PROTECTED MEMBER FUNCTIONS
195 
196 // PRIVATE MEMBER FUNCTIONS
197 
198 
199 //==============================================================================
200 // MET_E2 FACET OF CLASS SEC_MET_E2
201 //==============================================================================
202 
203 // PUBLIC MEMBER FUNCTIONS
204 
207 {
208  // Preconditions:
209 
210  // Body:
211 
212  // Postconditions:
213 
214 }
215 
218 {
219  // Preconditions:
220 
221  require(xhost != 0);
222  require(xhost->state_is_read_accessible());
223  require(xhost->contains_member(xhub_id));
224 
225  // Body:
226 
227  attach_to_state(xhost, xhub_id);
228 
229  // Postconditions:
230 
231  ensure(invariant());
232  //ensure(host() == xhost);
233  ensure(index() == xhub_id);
234  ensure(is_attached());
235  ensure(!is_restricted());
236 }
237 
239 sec_met_e2(const sec_rep_space* xhost, const scoped_index& xid)
240 {
241  // Preconditions:
242 
243  require(xhost != 0);
244  require(xhost->state_is_read_accessible());
245  require(xhost->contains_member(xid));
246 
247  // Body:
248 
249  attach_to_state(xhost, xid.hub_pod());
250 
251  // Postconditions:
252 
253  ensure(invariant());
254  //ensure(host() == xhost);
255  ensure(index() ==~ xid);
256  ensure(is_attached());
257  ensure(!is_restricted());
258 }
259 
261 sec_met_e2(const sec_rep_space* xhost, const std::string& xname)
262 {
263 
264  // Preconditions:
265 
266  require(xhost != 0);
267  require(xhost->state_is_read_accessible());
268  require(!xname.empty());
269  require(xhost->contains_member(xname));
270 
271  // Body:
272 
273  attach_to_state(xhost, xname);
274 
275  // Postconditions:
276 
277  ensure(invariant());
278  //ensure(host() == xhost);
279  ensure(name() == xname);
280  ensure(is_attached());
281  ensure(!is_restricted());
282 
283 }
284 
285 
287 sec_met_e2(const namespace_poset* xnamespace,
288  const poset_path& xpath,
289  bool xauto_access)
290 {
291 
292  // Preconditions:
293 
294  require(precondition_of(attach_to_state(same args)));
295 
296  // Body:
297 
298  attach_to_state(xnamespace, xpath, xauto_access);
299 
300  // Postconditions:
301 
302  ensure(postcondition_of(attach_to_state(same args)));
303 
304  // Exit:
305 
306  return;
307 }
308 
309 
312 {
313 
314  // Preconditions:
315 
316  require(xother != 0);
317 
318  // Body:
319 
320  attach_to_state(xother);
321 
322  // Postconditions:
323 
324  ensure(invariant());
325  ensure(is_attached());
326  ensure(is_same_state(xother));
327  ensure(is_same_restriction(xother));
328 
329 }
330 
332 sec_met_e2(sec_rep_space* xhost, section_dof_map* xdof_map, bool xauto_access)
333 {
334 
335  // Preconditions:
336 
337  require(precondition_of(new_jim_state(xhost, xdof_map, false, xauto_access)));
338 
339  // Body:
340 
341  new_jim_state(xhost, xdof_map, false, xauto_access);
342 
343  // Postconditions:
344 
345  ensure(postcondition_of(new_jim_state(xhost, xdof_map, false, xauto_access)));
346 
347  // Exit:
348 
349  return;
350 }
351 
355 {
356  // Preconditions:
357 
358  require(is_ancestor_of(&xother));
359  require(precondition_of(attach_to_state(&xother)));
360 
361  // Body:
362 
363  attach_to_state(&xother);
364 
365  // Postconditions:
366 
367  ensure(postcondition_of(attach_to_state(&xother)));
368 
369  // Exit:
370 
371  return *this;
372 }
373 
376 operator=(const sec_met_e2& xother)
377 {
378  // Preconditions:
379 
380  require(precondition_of(attach_to_state(&xother)));
381 
382  // Body:
383 
384  attach_to_state(&xother);
385 
386  // Postconditions:
387 
388  ensure(postcondition_of(attach_to_state(&xother)));
389 
390  // Exit:
391 
392  return *this;
393 }
394 
397 operator=(const met_e2& xfiber)
398 {
399  // Preconditions:
400 
401  require(precondition_of(sec_vd::operator=(xfiber)));
402 
403  // Body:
404 
405  sec_vd::operator=(xfiber);
406 
407  // Postconditions:
408 
409  ensure(postcondition_of(sec_vd::operator=(xfiber)));
410 
411  // Exit:
412 
413  return *this;
414 }
415 
418 operator=(const met_e2_lite& xfiber)
419 {
420  // Preconditions:
421 
422  require(precondition_of(sec_vd::operator=(xfiber)));
423 
424  // Body:
425 
426  sec_vd::operator=(xfiber);
427 
428  // Postconditions:
429 
430  ensure(postcondition_of(sec_vd::operator=(xfiber)));
431 
432  // Exit:
433 
434  return *this;
435 }
436 
439 {
440  // Preconditions:
441 
442  // Body:
443 
444  // Postconditions:
445 
446 }
447 
451 {
452  // Preconditions:
453 
454  // Body:
455 
456  static const fiber_type result;
457 
458  // Postconditions:
459 
460  // Exit:
461 
462  return result;
463 }
464 
465 // PROTECTED MEMBER FUNCTIONS
466 
467 // PRIVATE MEMBER FUNCTIONS
468 
469 
470 //==============================================================================
471 // MET_ED FACET OF CLASS SEC_MET_E2
472 //==============================================================================
473 
474 // PUBLIC MEMBER FUNCTIONS
475 
476 // PROTECTED MEMBER FUNCTIONS
477 
478 // PRIVATE MEMBER FUNCTIONS
479 
480 
481 //==============================================================================
482 // MET FACET OF CLASS SEC_MET_E2
483 //==============================================================================
484 
485 // PUBLIC MEMBER FUNCTIONS
486 
487 // PROTECTED MEMBER FUNCTIONS
488 
489 // PRIVATE MEMBER FUNCTIONS
490 
491 
492 //==============================================================================
493 // ST2 FACET OF CLASS SEC_MET_E2
494 //==============================================================================
495 
496 // PUBLIC MEMBER FUNCTIONS
497 
498 // PROTECTED MEMBER FUNCTIONS
499 
500 // PRIVATE MEMBER FUNCTIONS
501 
502 
503 //==============================================================================
504 // STP FACET OF CLASS SEC_MET_E2
505 //==============================================================================
506 
507 // PUBLIC MEMBER FUNCTIONS
508 
509 // PROTECTED MEMBER FUNCTIONS
510 
511 // PRIVATE MEMBER FUNCTIONS
512 
513 
514 //==============================================================================
515 // TP FACET OF CLASS SEC_MET_E2
516 //==============================================================================
517 
518 // PUBLIC MEMBER FUNCTIONS
519 
520 // PROTECTED MEMBER FUNCTIONS
521 
522 // PRIVATE MEMBER FUNCTIONS
523 
524 
525 //==============================================================================
526 // VD FACET OF CLASS SEC_MET_E2
527 //==============================================================================
528 
529 // PUBLIC MEMBER FUNCTIONS
530 
531 // PROTECTED MEMBER FUNCTIONS
532 
533 // PRIVATE MEMBER FUNCTIONS
534 
535 
536 //==============================================================================
537 // TUPLE FACET OF CLASS SEC_MET_E2
538 //==============================================================================
539 
540 // PUBLIC MEMBER FUNCTIONS
541 
542 
543 // PROTECTED MEMBER FUNCTIONS
544 
545 // PRIVATE MEMBER FUNCTIONS
546 
547 
548 //==============================================================================
549 // ABSTRACT POSET MEMBER FACET OF CLASS SEC_MET_E2
550 //==============================================================================
551 
552 // PUBLIC MEMBER FUNCTIONS
553 
554 const std::string&
556 class_name() const
557 {
558  // Preconditions:
559 
560  // Body:
561 
562  const string& result = static_class_name();
563 
564  // Postconditions:
565 
566  ensure(!result.empty());
567 
568  // Exit:
569 
570  return result;
571 }
572 
573 const std::string&
576 {
577  // Preconditions:
578 
579  // Body:
580 
581  static const string result("sec_met_e2");
582 
583  // Postconditions:
584 
585  ensure(!result.empty());
586 
587  // Exit:
588 
589  return result;
590 }
591 
594 clone() const
595 {
596 
597  // Preconditions:
598 
599  // Body:
600 
601  // create new handle of the current class.
602 
603  sec_met_e2 *result = new sec_met_e2();
604 
605  // Postconditions:
606 
607  ensure(result != 0);
608  ensure(result->invariant());
609 
610  // Exit:
611 
612  return result;
613 
614 }
615 
616 // PROTECTED MEMBER FUNCTIONS
617 
618 // PRIVATE MEMBER FUNCTIONS
619 
620 
621 //==============================================================================
622 // ANY FACET OF CLASS SEC_MET_E2
623 //==============================================================================
624 
625 // PUBLIC MEMBER FUNCTIONS
626 
627 bool
629 fiber_is_ancestor_of(const any* xother) const
630 {
631 
632  // Preconditions:
633 
634  require(xother != 0);
635 
636  // Body:
637 
638  // If xother may be dynamically cast to the type of this fiber then this
639  // fiber is an ancestor of xother.
640 
641  bool result = dynamic_cast<const met_e2*>(xother) != 0;
642 
643  // Postconditions:
644 
645  ensure(invariant());
646  ensure(xother->invariant());
647 
648  // Exit:
649 
650  return result;
651 
652 }
653 
654 bool
656 is_ancestor_of(const any* xother) const
657 {
658  // Preconditions:
659 
660  require(xother != 0);
661 
662  // Body:
663 
664  // If other may be dynamically cast to the type of this then this is an
665  // ancestor of other.
666 
667  bool result = dynamic_cast<const sec_met_e2*>(xother) != 0;
668 
669  // Postconditions:
670 
671  //ensure(invariant());
672 
673  return result;
674 
675 }
676 
677 bool
679 invariant() const
680 {
681  bool result = true;
682 
683  // Preconditions:
684 
685  // Body:
686 
687  // Must satisfy base class invariant
688 
689  invariance(sec_met_ed::invariant());
690 
691  if (invariant_check())
692  {
693  // Prevent recursive calls to invariant
694 
695  disable_invariant_check();
696 
697  invariance(is_attached() ? df() == 3 : true);
698 
699  // Finished, turn invariant checking back on.
700 
701  enable_invariant_check();
702  }
703 
704  // Postconditions:
705 
706  ensure(is_derived_query);
707 
708  return result;
709 }
710 
711 // PROTECTED MEMBER FUNCTIONS
712 
713 // PRIVATE MEMBER FUNCTIONS
714 
715 
716 //==============================================================================
717 // NON-MEMBER FUNCTIONS
718 //==============================================================================
719 
720 namespace
721 {
722 
723 using namespace fiber_bundle::met_algebra;
724 
725 class lower_functor
726 {
727 public:
728  void operator()(const met_e2_lite& x0, const e2_lite& x1,
729  e2_lite& xresult) const
730  {
731  lower(x0, x1, xresult);
732  }
733 };
734 
735 class raise_functor
736 {
737 public:
738  void operator()(const met_e2_lite& x0, const e2_lite& x1,
739  e2_lite& xresult) const
740  {
741  raise(x0, x1, xresult);
742  }
743 };
744 
745 } //end unnamed namespace
746 
747 //==============================================================================
748 //==============================================================================
749 
750 #include "SheafSystem/sec_e2.h"
751 #include "SheafSystem/sec_vd.impl.h"
752 
753 using namespace fiber_bundle::sec_vd_algebra;
754 
755 void
757 lower(const sec_met_e2& xmetric, const sec_e2& xvector, sec_e2& xresult,
758  bool xauto_access)
759 {
760  // Preconditions:
761 
762  require(xmetric.state_is_auto_read_accessible(xauto_access));
763  require(xvector.state_is_auto_read_accessible(xauto_access));
764  require(xresult.state_is_auto_read_write_accessible(xauto_access));
765 
766  // Body:
767 
768  binary_op(xmetric, xvector, xresult, lower_functor(), xauto_access);
769 
770  // Postconditions:
771 
772 
773  // Exit:
774 
775  return;
776 }
777 
778 void
780 raise(const sec_met_e2& xmetric, const sec_e2& xcovector, sec_e2& xresult,
781  bool xauto_access)
782 {
783  // Preconditions:
784 
785  require(xmetric.state_is_auto_read_accessible(xauto_access));
786  require(xcovector.state_is_auto_read_accessible(xauto_access));
787  require(xresult.state_is_auto_read_write_accessible(xauto_access));
788 
789  // Body:
790 
791  binary_op(xmetric, xcovector, xresult, raise_functor(), xauto_access);
792 
793  // Postconditions:
794 
795 
796  // Exit:
797 
798  return;
799 }
800 
SHEAF_DLL_SPEC void lower(const met &xmetric, const ed &xvector, ed &xresult, bool xauto_access)
Lower vector (pre-allocated version for persistent type).
Definition: met.cc:943
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
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_met_e2.cc:106
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.
sec_met_e2()
default constructor
Definition: sec_met_e2.cc:206
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...
bool state_is_auto_read_accessible(bool xauto_access) const
True if the state is auto accessible for read, that is, if the state is already accessible for read o...
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.
Namespace containing the metric tensor algrebra functions for the fiber_bundles component of the shea...
Definition: met.h:463
poset_path vector_space_path() const
The path of the underlying vector space.
STL namespace.
SHEAF_DLL_SPEC void lower(const sec_met &xmetric, const sec_ed &xvector, sec_ed &xresult, bool xauto_access)
Lower vector (pre-allocated version).
Definition: sec_met.cc:668
A schema poset for a section space. A binary Cartesian product subspace of the binary tensor product ...
static const std::string & static_class_name()
The name of this class.
Definition: sec_met_e2.cc:575
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 metric tensor over an abstract vector space (persistent version).
Definition: met.h:208
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)
A metric tensor over a 2 dimensional Euclidean vector space (persistent version). ...
Definition: met_e2.h:448
virtual sec_met_e2 * clone() const
Make a new handle, no state instance of current.
Definition: sec_met_e2.cc:594
bool invariant() const
Class invariant.
Definition: sec_met_e2.cc:679
Euclidean vector space of dimension 2 (volatile version).
Definition: e2.h:112
virtual int d(int xp, int xdd) const
Dimension d() as a function of degree xp and domain dimension xdd.
void binary_op(const S0 &x0, const S1 &x1, SR &xresult, F xfunctor, bool xauto_access)
Binary operator.
Definition: sec_vd.impl.h:48
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. ...
virtual const fiber_type & fiber_prototype() const
Virtual constructor for the associated fiber type.
Definition: sec_met_e2.cc:450
bool is_ancestor_of(const any *xother) const
True if xother conforms to current.
Definition: sec_met_e2.cc:656
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
virtual sec_met_e2 & operator=(const abstract_poset_member &xother)
Assignment operator; synonym for attach_to_state(&xother).
Definition: sec_met_e2.cc:354
virtual const std::string & class_name() const
The name of this class.
Definition: sec_met_e2.cc:556
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).
Namespace containing the algrebra functions for a a section of a fiber bundle with a d-dimensional ve...
Definition: sec_vd.h:691
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_met_e2.cc:55
An abstract client handle for a member of a poset.
SHEAF_DLL_SPEC void raise(const sec_met &xmetric, const sec_ed &xcovector, sec_ed &xresult, bool xauto_access)
Raise covector (pre-allocated version).
Definition: sec_met.cc:722
std::string path() const
The full path as a string.
Definition: poset_path.cc:450
A metric tensor over a 2 dimensional Euclidean vector space (volatile version).
Definition: met_e2.h:142
A section of a bundle with fiber type met_e2.
Definition: sec_met_e2.h:48
An abstract symmetric tensor space of degree p.
Definition: stp_space.h:42
Namespace for the fiber_bundles component of the sheaf system.
~sec_met_e2()
Destructor.
Definition: sec_met_e2.cc:438
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_met_e2.cc:629
pod_type hub_pod() const
The pod value of this mapped to the unglued hub id space.
Definition: scoped_index.h:710
A section of a fiber bundle with a 2-dimensional Euclidean vector space fiber.
Definition: sec_e2.h:48
A handle for a poset whose members are numerical representations of sections of a fiber bundle...
Definition: sec_rep_space.h:61