SheafSystem  0.0.0.0
sec_met_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_met_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_e1.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_e1.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_E1
45 //==============================================================================
46 
47 // ===========================================================
48 // HOST FACTORY FACET OF CLASS SEC_MET_E1
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_e1::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_e1::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_e1::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_e1>(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_e1>(xns, xbase_path, xrep_path, xfiber_suffix, xauto_access));
132 
133  // Body:
134 
135  poset_path lstd_path = standard_host_path<sec_met_e1>(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_e1>(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_e1>(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_e1>(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_e1::new_host." << endl;
191  return result;
192 }
193 
194 // PROTECTED MEMBER FUNCTIONS
195 
196 // PRIVATE MEMBER FUNCTIONS
197 
198 
199 //==============================================================================
200 // MET_E1 FACET OF CLASS SEC_MET_E1
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_e1(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_e1(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_e1(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_e1(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_e1& 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_e1& 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_e1_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_E1
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_E1
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_E1
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_E1
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_E1
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_E1
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_E1
538 //==============================================================================
539 
540 // PUBLIC MEMBER FUNCTIONS
541 
542 // PROTECTED MEMBER FUNCTIONS
543 
544 // PRIVATE MEMBER FUNCTIONS
545 
546 
547 //==============================================================================
548 // ABSTRACT POSET MEMBER FACET OF CLASS SEC_MET_E1
549 //==============================================================================
550 
551 // PUBLIC MEMBER FUNCTIONS
552 
553 const std::string&
555 class_name() const
556 {
557  // Preconditions:
558 
559  // Body:
560 
561  const string& result = static_class_name();
562 
563  // Postconditions:
564 
565  ensure(!result.empty());
566 
567  // Exit:
568 
569  return result;
570 }
571 
572 const std::string&
575 {
576  // Preconditions:
577 
578  // Body:
579 
580  static const string result("sec_met_e1");
581 
582  // Postconditions:
583 
584  ensure(!result.empty());
585 
586  // Exit:
587 
588  return result;
589 }
590 
593 clone() const
594 {
595 
596  // Preconditions:
597 
598  // Body:
599 
600  // create new handle of the current class.
601 
602  sec_met_e1 *result = new sec_met_e1();
603 
604  // Postconditions:
605 
606  ensure(result != 0);
607  ensure(result->invariant());
608 
609  // Exit:
610 
611  return result;
612 
613 }
614 
615 // PROTECTED MEMBER FUNCTIONS
616 
617 // PRIVATE MEMBER FUNCTIONS
618 
619 
620 //==============================================================================
621 // ANY FACET OF CLASS SEC_MET_E1
622 //==============================================================================
623 
624 // PUBLIC MEMBER FUNCTIONS
625 
626 bool
628 fiber_is_ancestor_of(const any* xother) const
629 {
630 
631  // Preconditions:
632 
633  require(xother != 0);
634 
635  // Body:
636 
637  // If xother may be dynamically cast to the type of this fiber then this
638  // fiber is an ancestor of xother.
639 
640  bool result = dynamic_cast<const met_e1*>(xother) != 0;
641 
642  // Postconditions:
643 
644  ensure(invariant());
645  ensure(xother->invariant());
646 
647  // Exit:
648 
649  return result;
650 
651 }
652 
653 bool
655 is_ancestor_of(const any* xother) const
656 {
657  // Preconditions:
658 
659  require(xother != 0);
660 
661  // Body:
662 
663  // If other may be dynamically cast to the type of this then this is an
664  // ancestor of other.
665 
666  bool result = dynamic_cast<const sec_met_e1*>(xother) != 0;
667 
668  // Postconditions:
669 
670  //ensure(invariant());
671 
672  return result;
673 
674 }
675 
676 bool
678 invariant() const
679 {
680  bool result = true;
681 
682  // Preconditions:
683 
684  // Body:
685 
686  // Must satisfy base class invariant
687 
688  invariance(sec_met_ed::invariant());
689 
690  if (invariant_check())
691  {
692  // Prevent recursive calls to invariant
693 
694  disable_invariant_check();
695 
696  invariance(is_attached() ? df() == 1 : true);
697 
698  // Finished, turn invariant checking back on.
699 
700  enable_invariant_check();
701  }
702 
703  // Postconditions:
704 
705  ensure(is_derived_query);
706 
707  // Exit:
708 
709  return result;
710 
711 }
712 
713 // PROTECTED MEMBER FUNCTIONS
714 
715 // PRIVATE MEMBER FUNCTIONS
716 
717 
718 //==============================================================================
719 // NON-MEMBER FUNCTIONS
720 //==============================================================================
721 
722 namespace
723 {
724 
725 using namespace fiber_bundle::met_algebra;
726 
727 class lower_functor
728 {
729 public:
730  void operator()(const met_e1_lite& x0, const e1_lite& x1,
731  e1_lite& xresult) const
732  {
733  lower(x0, x1, xresult);
734  }
735 };
736 
737 class raise_functor
738 {
739 public:
740  void operator()(const met_e1_lite& x0, const e1_lite& x1,
741  e1_lite& xresult) const
742  {
743  raise(x0, x1, xresult);
744  }
745 };
746 
747 } //end unnamed namespace
748 
749 //==============================================================================
750 //==============================================================================
751 
752 #include "SheafSystem/sec_e1.h"
753 #include "SheafSystem/sec_vd.impl.h"
754 
755 using namespace fiber_bundle::sec_vd_algebra;
756 
757 void
759 lower(const sec_met_e1& xmetric, const sec_e1& xvector, sec_e1& xresult,
760  bool xauto_access)
761 {
762  // Preconditions:
763 
764  require(xmetric.state_is_auto_read_accessible(xauto_access));
765  require(xvector.state_is_auto_read_accessible(xauto_access));
766  require(xresult.state_is_auto_read_write_accessible(xauto_access));
767 
768  // Body:
769 
770  binary_op(xmetric, xvector, xresult, lower_functor(), xauto_access);
771 
772  // Postconditions:
773 
774 
775  // Exit:
776 
777  return;
778 }
779 
780 void
782 raise(const sec_met_e1& xmetric, const sec_e1& xcovector, sec_e1& xresult,
783  bool xauto_access)
784 {
785  // Preconditions:
786 
787  require(xmetric.state_is_auto_read_accessible(xauto_access));
788  require(xcovector.state_is_auto_read_accessible(xauto_access));
789  require(xresult.state_is_auto_read_write_accessible(xauto_access));
790 
791  // Body:
792 
793  binary_op(xmetric, xcovector, xresult, raise_functor(), xauto_access);
794 
795  // Postconditions:
796 
797 
798  // Exit:
799 
800  return;
801 }
802 
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_e1.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.
A section of a bundle with fiber type met_e1.
Definition: sec_met_e1.h:48
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 metric tensor over a 1 dimensional Euclidean vector space.
Definition: met_e1.h:396
bool invariant() const
Class invariant.
Definition: sec_met_e1.cc:678
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.
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_e1.cc:55
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
virtual const fiber_type & fiber_prototype() const
Virtual constructor for the associated fiber type.
Definition: sec_met_e1.cc:450
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.
bool is_ancestor_of(const any *xother) const
True if xother conforms to current.
Definition: sec_met_e1.cc:655
~sec_met_e1()
Destructor.
Definition: sec_met_e1.cc:438
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 const std::string & class_name() const
The name of this class.
Definition: sec_met_e1.cc:555
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.
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 fiber_is_ancestor_of(const any *xother) const
True if xother conforms to an instance of the fiber of current.
Definition: sec_met_e1.cc:628
bool contains_path(const poset_path &xpath, bool xauto_access=true) const
True if this contains the poset or poset member specified by xpath.
A metric tensor over a 1 dimensional Euclidean vector space (volatile version).
Definition: met_e1.h:116
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.
bool empty() const
True if both poset name and member name are empty.
Definition: poset_path.cc:291
virtual sec_met_e1 * clone() const
Make a new handle, no state instance of current.
Definition: sec_met_e1.cc:593
sec_met_e1()
Default constructor.
Definition: sec_met_e1.cc:206
virtual sec_met_e1 & operator=(const abstract_poset_member &xother)
Assignment operator; synonym for attach_to_state(&xother).
Definition: sec_met_e1.cc:354
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
Namespace containing the algrebra functions for a a section of a fiber bundle with a d-dimensional ve...
Definition: sec_vd.h:691
static const std::string & static_class_name()
The name of this class.
Definition: sec_met_e1.cc:574
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
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