SheafSystem  0.0.0.0
sec_met.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.h"
22 
23 #include "SheafSystem/assert_contract.h"
24 #include "SheafSystem/binary_section_space_schema_member.impl.h"
25 #include "SheafSystem/binary_section_space_schema_poset.h"
26 #include "SheafSystem/fiber_bundles_namespace.h"
27 #include "SheafSystem/sec_at0.h"
28 #include "SheafSystem/sec_at0_space.h"
29 #include "SheafSystem/sec_stp_space.h"
30 #include "SheafSystem/sec_tuple_space.impl.h"
31 #include "SheafSystem/section_space_schema_member.impl.h"
32 #include "SheafSystem/section_space_schema_poset.h"
33 #include "SheafSystem/stp.h"
34 #include "SheafSystem/stp_space.h"
35 
36 using namespace std;
37 using namespace fiber_bundle; // Workaround for MS C++ bug.
38 
39 //==============================================================================
40 // CLASS SEC_MET
41 //==============================================================================
42 
43 // ===========================================================
44 // HOST FACTORY FACET OF CLASS SEC_ST2
45 // ===========================================================
46 
47 // PUBLIC MEMBER FUNCTIONS
48 
52  const poset_path& xhost_path,
53  const poset_path& xschema_path,
54  const poset_path& xscalar_space_path,
55  bool xauto_access)
56 {
57  // cout << endl << "Entering sec_met::new_host." << endl;
58 
59  // Preconditions:
60 
61  require(xns.state_is_auto_read_write_accessible(xauto_access));
62 
63  require(!xhost_path.empty());
64  require(!xns.contains_path(xhost_path, xauto_access));
65 
66  require(xschema_path.full());
67  require(xns.path_is_auto_read_accessible<schema_type::host_type>(xschema_path, xauto_access));
68  require(host_type::fiber_space_conforms<fiber_type::host_type>(xns, xschema_path, xauto_access));
69 
70  require(xns.path_is_auto_read_accessible<scalar_type::host_type>(xscalar_space_path, xauto_access));
71 
72  require(host_type::same_scalar_fiber_space(xns, xschema_path, xscalar_space_path, xauto_access));
73 
74  // Body:
75 
76  host_type& result = host_type::new_table(xns, xhost_path, xschema_path, xscalar_space_path, xauto_access);
77 
78  // Postconditions:
79 
80  ensure(xns.owns(result, xauto_access));
81  ensure(result.path(true) == xhost_path);
82  ensure(result.state_is_not_read_accessible());
83  ensure(result.schema(true).path(xauto_access) == xschema_path);
84 
85  ensure(result.factor_ct(true) == result.schema(true).fiber_space<fiber_type::host_type>().factor_ct(xauto_access));
86  ensure(result.d(true) == result.schema(true).fiber_space<fiber_type::host_type>().d(xauto_access));
87  ensure(result.d(true) == result.dd(true));
88  ensure(result.scalar_space_path(true) == xscalar_space_path);
89  ensure(result.p(true) == result.schema(true).fiber_space<fiber_type::host_type>().p(xauto_access));
90  ensure(result.p(true) == 2);
91  ensure(result.dd(true) == result.schema(true).fiber_space<fiber_type::host_type>().dd(xauto_access));
92  ensure(result.vector_space_path(true) == xhost_path);
93 
94  // Exit:
95 
96  // cout << "Leaving sec_met::new_host." << endl;
97  return result;
98 }
99 
100 // PROTECTED MEMBER FUNCTIONS
101 
102 // PRIVATE MEMBER FUNCTIONS
103 
104 
105 //==============================================================================
106 // MET FACET OF CLASS SEC_MET
107 //==============================================================================
108 
109 // PUBLIC MEMBER FUNCTIONS
110 
113 {
114  // Preconditions:
115 
116  // Body:
117 
118  // Postconditions:
119 
120 }
121 
123 sec_met(const sec_rep_space* xhost, pod_index_type xhub_id)
124 {
125  // Preconditions:
126 
127  require(xhost != 0);
128  require(xhost->state_is_read_accessible());
129  require(xhost->contains_member(xhub_id));
130 
131  // Body:
132 
133  attach_to_state(xhost, xhub_id);
134 
135  // Postconditions:
136 
137  ensure(invariant());
138  //ensure(host() == xhost);
139  ensure(index() == xhub_id);
140  ensure(is_attached());
141  ensure(!is_restricted());
142 }
143 
145 sec_met(const sec_rep_space* xhost, const scoped_index& xid)
146 {
147  // Preconditions:
148 
149  require(xhost != 0);
150  require(xhost->state_is_read_accessible());
151  require(xhost->contains_member(xid));
152 
153  // Body:
154 
155  attach_to_state(xhost, xid.hub_pod());
156 
157  // Postconditions:
158 
159  ensure(invariant());
160  //ensure(host() == xhost);
161  ensure(index() ==~ xid);
162  ensure(is_attached());
163  ensure(!is_restricted());
164 }
165 
167 sec_met(const sec_rep_space* xhost, const std::string& xname)
168 {
169 
170  // Preconditions:
171 
172  require(xhost != 0);
173  require(xhost->state_is_read_accessible());
174  require(!xname.empty());
175  require(xhost->contains_member(xname));
176 
177  // Body:
178 
179  attach_to_state(xhost, xname);
180 
181  // Postconditions:
182 
183  ensure(invariant());
184  //ensure(host() == xhost);
185  ensure(name() == xname);
186  ensure(is_attached());
187  ensure(!is_restricted());
188 
189 }
190 
191 
193 sec_met(const namespace_poset* xnamespace,
194  const poset_path& xpath,
195  bool xauto_access)
196 {
197 
198  // Preconditions:
199 
200  require(precondition_of(attach_to_state(same args)));
201 
202  // Body:
203 
204  attach_to_state(xnamespace, xpath, xauto_access);
205 
206  // Postconditions:
207 
208  ensure(postcondition_of(attach_to_state(same args)));
209 
210  // Exit:
211 
212  return;
213 }
214 
215 
218 {
219 
220  // Preconditions:
221 
222  require(xother != 0);
223 
224  // Body:
225 
226  attach_to_state(xother);
227 
228  // Postconditions:
229 
230  ensure(invariant());
231  ensure(is_attached());
232  ensure(is_same_state(xother));
233  ensure(is_same_restriction(xother));
234 
235 }
236 
238 sec_met(sec_rep_space* xhost, section_dof_map* xdof_map, bool xauto_access)
239 {
240 
241  // Preconditions:
242 
243  require(precondition_of(new_jim_state(xhost, xdof_map, false, xauto_access)));
244 
245  // Body:
246 
247  new_jim_state(xhost, xdof_map, false, xauto_access);
248 
249  // Postconditions:
250 
251  ensure(postcondition_of(new_jim_state(xhost, xdof_map, false, xauto_access)));
252 
253  // Exit:
254 
255  return;
256 }
257 
261 {
262  // Preconditions:
263 
264  require(is_ancestor_of(&xother));
265  require(precondition_of(attach_to_state(&xother)));
266 
267  // Body:
268 
269  attach_to_state(&xother);
270 
271  // Postconditions:
272 
273  ensure(postcondition_of(attach_to_state(&xother)));
274 
275  // Exit:
276 
277  return *this;
278 }
279 
282 operator=(const sec_met& xother)
283 {
284  // Preconditions:
285 
286  require(precondition_of(attach_to_state(&xother)));
287 
288  // Body:
289 
290  attach_to_state(&xother);
291 
292  // Postconditions:
293 
294  ensure(postcondition_of(attach_to_state(&xother)));
295 
296  // Exit:
297 
298  return *this;
299 }
300 
303 operator=(const met& xfiber)
304 {
305  // Preconditions:
306 
307  require(precondition_of(sec_vd::operator=(xfiber)));
308 
309  // Body:
310 
311  sec_vd::operator=(xfiber);
312 
313  // Postconditions:
314 
315  ensure(postcondition_of(sec_vd::operator=(xfiber)));
316 
317  // Exit:
318 
319  return *this;
320 }
321 
324 operator=(const met_lite& xfiber)
325 {
326  // Preconditions:
327 
328  require(precondition_of(sec_vd::operator=(xfiber)));
329 
330  // Body:
331 
332  sec_vd::operator=(xfiber);
333 
334  // Postconditions:
335 
336  ensure(postcondition_of(sec_vd::operator=(xfiber)));
337 
338  // Exit:
339 
340  return *this;
341 }
342 
345 {
346  // Preconditions:
347 
348  // Body:
349 
350  // Postconditions:
351 
352 }
353 
357 {
358  // Preconditions:
359 
360  // Body:
361 
362  static const fiber_type result;
363 
364  // Postconditions:
365 
366  // Exit:
367 
368  return result;
369 }
370 
371 // PROTECTED MEMBER FUNCTIONS
372 
373 // PRIVATE MEMBER FUNCTIONS
374 
375 
376 //==============================================================================
377 // ST2 FACET OF CLASS SEC_MET
378 //==============================================================================
379 
380 // PUBLIC MEMBER FUNCTIONS
381 
382 // PROTECTED MEMBER FUNCTIONS
383 
384 // PRIVATE MEMBER FUNCTIONS
385 
386 
387 //==============================================================================
388 // STP FACET OF CLASS SEC_MET
389 //==============================================================================
390 
391 // PUBLIC MEMBER FUNCTIONS
392 
393 // PROTECTED MEMBER FUNCTIONS
394 
395 // PRIVATE MEMBER FUNCTIONS
396 
397 
398 //==============================================================================
399 // TP FACET OF CLASS SEC_MET
400 //==============================================================================
401 
402 // PUBLIC MEMBER FUNCTIONS
403 
404 // PROTECTED MEMBER FUNCTIONS
405 
406 // PRIVATE MEMBER FUNCTIONS
407 
408 
409 //==============================================================================
410 // VD FACET OF CLASS SEC_MET
411 //==============================================================================
412 
413 // PUBLIC MEMBER FUNCTIONS
414 
415 // PROTECTED MEMBER FUNCTIONS
416 
417 // PRIVATE MEMBER FUNCTIONS
418 
419 
420 //==============================================================================
421 // TUPLE FACET OF CLASS SEC_MET
422 //==============================================================================
423 
424 // PUBLIC MEMBER FUNCTIONS
425 
426 // PROTECTED MEMBER FUNCTIONS
427 
428 // PRIVATE MEMBER FUNCTIONS
429 
430 
431 //==============================================================================
432 // ABSTRACT POSET MEMBER FACET OF CLASS SEC_MET
433 //==============================================================================
434 
435 // PUBLIC MEMBER FUNCTIONS
436 
437 const std::string&
439 class_name() const
440 {
441  // Preconditions:
442 
443  // Body:
444 
445  const string& result = static_class_name();
446 
447  // Postconditions:
448 
449  ensure(!result.empty());
450 
451  // Exit:
452 
453  return result;
454 }
455 
456 const std::string&
459 {
460  // Preconditions:
461 
462  // Body:
463 
464  static const string result("sec_met");
465 
466  // Postconditions:
467 
468  ensure(!result.empty());
469 
470  // Exit:
471 
472  return result;
473 }
474 
477 clone() const
478 {
479 
480  // Preconditions:
481 
482  // Body:
483 
484  // create new handle of the current class.
485 
486  sec_met *result = new sec_met();
487 
488  // Postconditions:
489 
490  ensure(result != 0);
491  ensure(result->invariant());
492 
493  // Exit:
494 
495  return result;
496 
497 }
498 
499 // PROTECTED MEMBER FUNCTIONS
500 
501 // PRIVATE MEMBER FUNCTIONS
502 
503 
504 //==============================================================================
505 // ANY FACET OF CLASS SEC_MET
506 //==============================================================================
507 
508 // PUBLIC MEMBER FUNCTIONS
509 
510 bool
512 fiber_is_ancestor_of(const any* xother) const
513 {
514 
515  // Preconditions:
516 
517  require(xother != 0);
518 
519  // Body:
520 
521  // If xother may be dynamically cast to the type of this fiber then this
522  // fiber is an ancestor of xother.
523 
524  bool result = dynamic_cast<const met*>(xother) != 0;
525 
526  // Postconditions:
527 
528  ensure(invariant());
529  ensure(xother->invariant());
530 
531  // Exit:
532 
533  return result;
534 
535 }
536 
537 bool
539 is_ancestor_of(const any* xother) const
540 {
541 
542  // Preconditions:
543 
544  require(xother != 0);
545 
546  // Body:
547 
548  // If other may be dynamically cast to the type of this then this is an
549  // ancestor of other.
550 
551  bool result = dynamic_cast<const sec_met*>(xother) != 0;
552 
553  // Postconditions:
554 
555  //ensure(invariant());
556 
557  // Exit:
558 
559  return result;
560 
561 }
562 
563 bool
565 invariant() const
566 {
567 
568  bool result = true;
569 
570  // Preconditions:
571 
572  // Body:
573 
574  // Must satisfy base class invariant
575 
576  invariance(sec_st2::invariant());
577 
578  if (invariant_check())
579  {
580  // Prevent recursive calls to invariant
581 
582  disable_invariant_check();
583 
584  // Finished, turn invariant checking back on.
585 
586  enable_invariant_check();
587  }
588 
589  // Postconditions:
590 
591  ensure(is_derived_query);
592 
593  return result;
594 
595 }
596 
597 // PROTECTED MEMBER FUNCTIONS
598 
599 // PRIVATE MEMBER FUNCTIONS
600 
601 
602 //##############################################################################
603 //##############################################################################
604 
605 // fiber_bundle::sec_met::scalar_type*
606 // fiber_bundle::sec_met::
607 // comp2(int row, int col)
608 // {
609 
610 // // Preconditions:
611 
612 // require(0 <= row && row <= dd());
613 // require(0 <= col && col <= dd());
614 
615 // // Body:
616 
617 // int index = index_for_row_column(row, col);
618 // scalar_type* result = comp(index);
619 
620 // // Postconditions:
621 
622 // ensure(result != 0);
623 // ensure(invariant());
624 // ensure(result->invariant());
625 
626 // return result;
627 
628 // }
629 
630 
631 // void
632 // fiber_bundle::sec_met::
633 // set_comp2(int row, int col, scalar_type* new_comp)
634 // {
635 
636 // // Preconditions:
637 
638 // require(0 <= row && row <= dd());
639 // require(0 <= col && col <= dd());
640 // require(new_comp != 0);
641 
642 // // Body:
643 
644 // int index = index_for_row_column(row, col);
645 // set_comp(index, new_comp);
646 
647 // // Postconditions:
648 
649 // ensure(comp(index) == new_comp);
650 // ensure(invariant());
651 
652 // }
653 
654 //==============================================================================
655 // NON-MEMBER FUNCTIONS
656 //==============================================================================
657 
658 #include "SheafSystem/error_message.h"
659 #include "SheafSystem/sec_e1.h"
660 #include "SheafSystem/sec_e2.h"
661 #include "SheafSystem/sec_e3.h"
662 #include "SheafSystem/sec_met_e1.h"
663 #include "SheafSystem/sec_met_e2.h"
664 #include "SheafSystem/sec_met_e3.h"
665 
666 void
668 lower(const sec_met& xmetric, const sec_ed& xvector, sec_ed& xresult,
669  bool xauto_access)
670 {
671  // Preconditions:
672 
673  require(xmetric.state_is_auto_read_accessible(xauto_access));
674  require(xvector.state_is_auto_read_accessible(xauto_access));
675  require(xresult.state_is_auto_read_write_accessible(xauto_access));
676  require(xmetric.is_covariant(0, xauto_access));
677  require(xvector.is_contravariant(0, xauto_access)); // !is_dual;
678 
679  // Body:
680 
681  const sec_met_e1* met_e1_xmetric = dynamic_cast<const sec_met_e1*>(&xmetric);
682  const sec_met_e2* met_e2_xmetric = dynamic_cast<const sec_met_e2*>(&xmetric);
683  const sec_met_e3* met_e3_xmetric = dynamic_cast<const sec_met_e3*>(&xmetric);
684 
685  const sec_e1* e1_xvector = dynamic_cast<const sec_e1*>(&xvector);
686  const sec_e2* e2_xvector = dynamic_cast<const sec_e2*>(&xvector);
687  const sec_e3* e3_xvector = dynamic_cast<const sec_e3*>(&xvector);
688 
689  sec_e1* e1_xresult = dynamic_cast<sec_e1*>(&xresult);
690  sec_e2* e2_xresult = dynamic_cast<sec_e2*>(&xresult);
691  sec_e3* e3_xresult = dynamic_cast<sec_e3*>(&xresult);
692 
693  if(met_e1_xmetric && e1_xvector && e1_xresult)
694  {
695  lower(*met_e1_xmetric, *e1_xvector, *e1_xresult, xauto_access);
696  }
697  else if(met_e2_xmetric && e2_xvector && e2_xresult)
698  {
699  lower(*met_e2_xmetric, *e2_xvector, *e2_xresult, xauto_access);
700  }
701  else if(met_e3_xmetric && e3_xvector && e3_xresult)
702  {
703  lower(*met_e3_xmetric, *e3_xvector, *e3_xresult, xauto_access);
704  }
705  else
706  {
707  post_fatal_error_message(\
708  "Unsupported argument types in call to lower(...)");
709  }
710 
711  // Postconditions:
712 
713  ensure(xresult.is_covariant(0, xauto_access)); // is_dual
714 
715  // Exit:
716 
717  return;
718 }
719 
720 void
722 raise(const sec_met& xmetric, const sec_ed& xcovector, sec_ed& xresult,
723  bool xauto_access)
724 {
725  // Preconditions:
726 
727  require(xmetric.state_is_auto_read_accessible(xauto_access));
728  require(xcovector.state_is_auto_read_accessible(xauto_access));
729  require(xresult.state_is_auto_read_write_accessible(xauto_access));
730  require(xmetric.is_contravariant(0, xauto_access));
731  require(xcovector.is_covariant(0, xauto_access)); // is_dual;
732 
733  // Body:
734 
735  const sec_met_e1* met_e1_xmetric = dynamic_cast<const sec_met_e1*>(&xmetric);
736  const sec_met_e2* met_e2_xmetric = dynamic_cast<const sec_met_e2*>(&xmetric);
737  const sec_met_e3* met_e3_xmetric = dynamic_cast<const sec_met_e3*>(&xmetric);
738 
739  const sec_e1* e1_xcovector = dynamic_cast<const sec_e1*>(&xcovector);
740  const sec_e2* e2_xcovector = dynamic_cast<const sec_e2*>(&xcovector);
741  const sec_e3* e3_xcovector = dynamic_cast<const sec_e3*>(&xcovector);
742 
743  sec_e1* e1_xresult = dynamic_cast<sec_e1*>(&xresult);
744  sec_e2* e2_xresult = dynamic_cast<sec_e2*>(&xresult);
745  sec_e3* e3_xresult = dynamic_cast<sec_e3*>(&xresult);
746 
747  if(met_e1_xmetric && e1_xcovector && e1_xresult)
748  {
749  lower(*met_e1_xmetric, *e1_xcovector, *e1_xresult, xauto_access);
750  }
751  else if(met_e2_xmetric && e2_xcovector && e2_xresult)
752  {
753  lower(*met_e2_xmetric, *e2_xcovector, *e2_xresult, xauto_access);
754  }
755  else if(met_e3_xmetric && e3_xcovector && e3_xresult)
756  {
757  lower(*met_e3_xmetric, *e3_xcovector, *e3_xresult, xauto_access);
758  }
759  else
760  {
761  post_fatal_error_message(\
762  "Unsupported argument types in call to lower(...)");
763  }
764 
765  // Postconditions:
766 
767  ensure(xresult.is_contravariant(0, xauto_access)); // !is_dual
768 
769  // Exit:
770 
771  return;
772 }
773 
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
~sec_met()
Destructor.
Definition: sec_met.cc:344
virtual const fiber_type & fiber_prototype() const
Virtual constructor for the associated fiber type.
Definition: sec_met.cc:356
bool full() const
True if both poset name and member name are not empty.
Definition: poset_path.cc:311
A Cartesian product section space.
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
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.
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 ...
bool invariant() const
Class invariant.
Definition: sec_met.cc:565
A metric tensor over an abstract vector space (volatile version).
Definition: met.h:43
virtual sec_met & operator=(const abstract_poset_member &xother)
Assignment operator; synonym for attach_to_state(&xother).
Definition: sec_met.cc:260
static const std::string & static_class_name()
The name of this class.
Definition: sec_met.cc:458
A metric tensor over an abstract vector space (persistent version).
Definition: met.h:208
virtual sec_met * clone() const
Make a new handle, no state instance of current.
Definition: sec_met.cc:477
A section of a bundle with fiber type met.
Definition: sec_met.h:46
A section of a fiber bundle with a d-dimensional Euclidean vector space fiber.
Definition: sec_ed.h:47
Abstract base class with useful features for all objects.
Definition: any.h:39
int p() const
The tensor degree of this space.
virtual section_space_schema_member & schema()
The schema for this poset (mutable version)
bool fiber_is_ancestor_of(const any *xother) const
True if xother conforms to an instance of the fiber of current.
Definition: sec_met.cc:512
virtual bool is_contravariant(bool xauto_access) const
True if and only if all tensor index positions are contravariant.
Definition: sec_tp.cc:748
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
virtual const std::string & class_name() const
The name of this class.
Definition: sec_met.cc:439
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. ...
A section of a bundle with fiber type met_e3.
Definition: sec_met_e3.h:48
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_met.cc:51
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
A section of a fiber bundle with a 3-dimensional Euclidean vector space fiber.
Definition: sec_e3.h:47
sec_met()
Default constructor.
Definition: sec_met.cc:112
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
virtual bool is_covariant(bool xauto_access) const
True if and only if all tensor index positions are covariant.
Definition: sec_tp.cc:666
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
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.
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 is_ancestor_of(const any *xother) const
True if xother conforms to current.
Definition: sec_met.cc:539
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