SheafSystem  0.0.0.0
sec_stp.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_stp.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/section_space_schema_member.impl.h"
28 #include "SheafSystem/section_space_schema_poset.h"
29 #include "SheafSystem/sec_at1.h"
30 #include "SheafSystem/sec_at1_space.h"
31 #include "SheafSystem/sec_stp_space.h"
32 #include "SheafSystem/sec_tuple_space.impl.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_STP
41 //==============================================================================
42 
43 // ===========================================================
44 // HOST FACTORY FACET OF CLASS SEC_ATP
45 // ===========================================================
46 
47 // PUBLIC MEMBER FUNCTIONS
48 
52  const poset_path& xhost_path,
53  const poset_path& xschema_path,
54  const poset_path& xvector_space_path,
55  bool xauto_access)
56 {
57  // cout << endl << "Entering sec_stp::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<vector_space_type::host_type>(xvector_space_path, xauto_access));
71 
72  require(host_type::same_vector_fiber_space(xns, xschema_path, xvector_space_path, xauto_access));
73 
74  // Body:
75 
76  host_type& result = host_type::new_table(xns, xhost_path, xschema_path, xvector_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.scalar_space_path(true) ==
88  xns.member_poset<vector_space_type::host_type>(xvector_space_path, xauto_access).scalar_space_path(xauto_access));
89  ensure(result.p(true) == result.schema(true).fiber_space<fiber_type::host_type>().p(xauto_access));
90  ensure(result.dd(true) == result.schema(true).fiber_space<fiber_type::host_type>().dd(xauto_access));
91  ensure(result.vector_space_path(true) == xvector_space_path);
92 
93  // Exit:
94 
95  // cout << "Leaving sec_stp::new_host." << endl;
96  return result;
97 }
98 
99 // PROTECTED MEMBER FUNCTIONS
100 
101 // PRIVATE MEMBER FUNCTIONS
102 
103 
104 //==============================================================================
105 // STP FACET OF CLASS SEC_STP
106 //==============================================================================
107 
108 // PUBLIC MEMBER FUNCTIONS
109 
112 {
113 
114  // Preconditions:
115 
116  // Body:
117 
118  // Postconditions:
119 
120  ensure(invariant());
121 }
122 
124 sec_stp(const sec_rep_space* xhost, pod_index_type xhub_id)
125 {
126  // Preconditions:
127 
128  require(xhost != 0);
129  require(xhost->state_is_read_accessible());
130  require(xhost->contains_member(xhub_id));
131 
132  // Body:
133 
134  attach_to_state(xhost, xhub_id);
135 
136  // Postconditions:
137 
138  ensure(invariant());
139  //ensure(host() == xhost);
140  ensure(index() == xhub_id);
141  ensure(is_attached());
142  ensure(!is_restricted());
143 }
144 
146 sec_stp(const sec_rep_space* xhost, const scoped_index& xid)
147 {
148  // Preconditions:
149 
150  require(xhost != 0);
151  require(xhost->state_is_read_accessible());
152  require(xhost->contains_member(xid));
153 
154  // Body:
155 
156  attach_to_state(xhost, xid.hub_pod());
157 
158  // Postconditions:
159 
160  ensure(invariant());
161  //ensure(host() == xhost);
162  ensure(index() ==~ xid);
163  ensure(is_attached());
164  ensure(!is_restricted());
165 }
166 
168 sec_stp(const sec_rep_space* xhost, const std::string& xname)
169 {
170 
171  // Preconditions:
172 
173  require(xhost != 0);
174  require(xhost->state_is_read_accessible());
175  require(!xname.empty());
176  require(xhost->contains_member(xname));
177 
178  // Body:
179 
180  attach_to_state(xhost, xname);
181 
182  // Postconditions:
183 
184  ensure(invariant());
185  //ensure(host() == xhost);
186  ensure(name() == xname);
187  ensure(is_attached());
188  ensure(!is_restricted());
189 
190 }
191 
192 
194 sec_stp(const namespace_poset* xnamespace,
195  const poset_path& xpath,
196  bool xauto_access)
197 {
198 
199  // Preconditions:
200 
201  require(precondition_of(attach_to_state(same args)));
202 
203  // Body:
204 
205  attach_to_state(xnamespace, xpath, xauto_access);
206 
207  // Postconditions:
208 
209  ensure(postcondition_of(attach_to_state(same args)));
210 
211  // Exit:
212 
213  return;
214 }
215 
216 
219 {
220 
221  // Preconditions:
222 
223  require(xother != 0);
224 
225  // Body:
226 
227  attach_to_state(xother);
228 
229  // Postconditions:
230 
231  ensure(invariant());
232  ensure(is_attached());
233  ensure(is_same_state(xother));
234  ensure(is_same_restriction(xother));
235 
236 }
237 
239 sec_stp(sec_rep_space* xhost, section_dof_map* xdof_map, bool xauto_access)
240 {
241 
242  // Preconditions:
243 
244  require(precondition_of(new_jim_state(xhost, xdof_map, false, xauto_access)));
245 
246  // Body:
247 
248  new_jim_state(xhost, xdof_map, false, xauto_access);
249 
250  // Postconditions:
251 
252  ensure(postcondition_of(new_jim_state(xhost, xdof_map, false, xauto_access)));
253 
254  // Exit:
255 
256  return;
257 }
258 
261  abstract_poset_member& xbase_mbr,
262  int xbase_version, bool xauto_access)
263 {
264 
265  // Preconditions:
266 
267  require(precondition_of(new_jim_state(xhost, xbase_mbr, xbase_version, xauto_access)));
268 
269  // Body:
270 
271  new_jim_state(xhost, xbase_mbr, xbase_version, xauto_access);
272 
273  // Postconditions:
274 
275  ensure(postcondition_of(new_jim_state(xhost, xbase_mbr, xbase_version, xauto_access)));
276 
277  // Exit:
278 
279  return;
280 }
281 
285 {
286  // Preconditions:
287 
288  require(is_ancestor_of(&xother));
289  require(precondition_of(attach_to_state(&xother)));
290 
291  // Body:
292 
293  attach_to_state(&xother);
294 
295  // Postconditions:
296 
297  ensure(postcondition_of(attach_to_state(&xother)));
298 
299  // Exit:
300 
301  return *this;
302 }
303 
306 operator=(const sec_stp& xother)
307 {
308  // Preconditions:
309 
310  require(precondition_of(attach_to_state(&xother)));
311 
312  // Body:
313 
314  attach_to_state(&xother);
315 
316  // Postconditions:
317 
318  ensure(postcondition_of(attach_to_state(&xother)));
319 
320  // Exit:
321 
322  return *this;
323 }
324 
327 operator=(const stp& xfiber)
328 {
329  // Preconditions:
330 
331  require(precondition_of(sec_vd::operator=(xfiber)));
332 
333  // Body:
334 
335  sec_vd::operator=(xfiber);
336 
337  // Postconditions:
338 
339  ensure(postcondition_of(sec_vd::operator=(xfiber)));
340 
341  // Exit:
342 
343  return *this;
344 }
345 
348 operator=(const stp_lite& xfiber)
349 {
350  // Preconditions:
351 
352  require(precondition_of(sec_vd::operator=(xfiber)));
353 
354  // Body:
355 
356  sec_vd::operator=(xfiber);
357 
358  // Postconditions:
359 
360  ensure(postcondition_of(sec_vd::operator=(xfiber)));
361 
362  // Exit:
363 
364  return *this;
365 }
366 
369 {
370 
371  // Preconditions:
372 
373 
374  // Body:
375 
376 
377  // Postconditions:
378 
379 }
380 
384 {
385  // Preconditions:
386 
387  // Body:
388 
389  static const fiber_type result;
390 
391  // Postconditions:
392 
393  // Exit:
394 
395  return result;
396 }
397 
398 // PROTECTED MEMBER FUNCTIONS
399 
400 // PRIVATE MEMBER FUNCTIONS
401 
402 
403 //==============================================================================
404 // TP FACET OF CLASS SEC_STP
405 //==============================================================================
406 
407 // PUBLIC MEMBER FUNCTIONS
408 
409 // PROTECTED MEMBER FUNCTIONS
410 
411 // PRIVATE MEMBER FUNCTIONS
412 
413 
414 //==============================================================================
415 // VD FACET OF CLASS SEC_STP
416 //==============================================================================
417 
418 // PUBLIC MEMBER FUNCTIONS
419 
420 // PROTECTED MEMBER FUNCTIONS
421 
422 // PRIVATE MEMBER FUNCTIONS
423 
424 
425 //==============================================================================
426 // TUPLE FACET OF CLASS SEC_STP
427 //==============================================================================
428 
429 // PUBLIC MEMBER FUNCTIONS
430 
431 // PROTECTED MEMBER FUNCTIONS
432 
433 // PRIVATE MEMBER FUNCTIONS
434 
435 
436 //==============================================================================
437 // ABSTRACT POSET MEMBER FACET OF CLASS SEC_STP
438 //==============================================================================
439 
440 // PUBLIC MEMBER FUNCTIONS
441 
442 const std::string&
444 class_name() const
445 {
446  // Preconditions:
447 
448  // Body:
449 
450  const string& result = static_class_name();
451 
452  // Postconditions:
453 
454  ensure(!result.empty());
455 
456  // Exit:
457 
458  return result;
459 }
460 
461 const std::string&
464 {
465  // Preconditions:
466 
467  // Body:
468 
469  static const string result("sec_stp");
470 
471  // Postconditions:
472 
473  ensure(!result.empty());
474 
475  // Exit:
476 
477  return result;
478 }
479 
482 clone() const
483 {
484 
485  // Preconditions:
486 
487  // Body:
488 
489  // create new handle of the current class.
490 
491  sec_stp *result = new sec_stp();
492 
493  // Postconditions:
494 
495  ensure(result != 0);
496  ensure(result->invariant());
497 
498  // Exit:
499 
500  return result;
501 
502 }
503 
504 // PROTECTED MEMBER FUNCTIONS
505 
506 // PRIVATE MEMBER FUNCTIONS
507 
508 
509 // ===========================================================
510 // POSET_COMPONENT FACET
511 // ===========================================================
512 
513 // PUBLIC MEMBER FUNCTIONS
514 
517 host() const
518 {
519  return reinterpret_cast<host_type*>(_host);
520 }
521 
522 bool
525 {
526  return dynamic_cast<const host_type*>(xother) != 0;
527 }
528 
529 // PROTECTED MEMBER FUNCTIONS
530 
531 // PRIVATE MEMBER FUNCTIONS
532 
533 
534 //==============================================================================
535 // ANY FACET OF CLASS SEC_STP
536 //==============================================================================
537 
538 // PUBLIC MEMBER FUNCTIONS
539 
540 bool
542 fiber_is_ancestor_of(const any* xother) const
543 {
544 
545  // Preconditions:
546 
547  require(xother != 0);
548 
549  // Body:
550 
551  // If xother may be dynamically cast to the type of this fiber then this
552  // fiber is an ancestor of xother.
553 
554  bool result = dynamic_cast<const stp*>(xother) != 0;
555 
556  // Postconditions:
557 
558  ensure(invariant());
559  ensure(xother->invariant());
560 
561  // Exit:
562 
563  return result;
564 
565 }
566 
567 bool
569 is_ancestor_of(const any* xother) const
570 {
571  // Preconditions:
572 
573  require(xother != 0);
574 
575  // Body:
576 
577  // If other may be dynamically cast to the type of this then this is an
578  // ancestor of other.
579 
580  bool result = dynamic_cast<const sec_stp*>(xother) != 0;
581 
582  // Postconditions:
583 
584  //ensure(invariant());
585 
586  // Exit:
587 
588  return result;
589 
590 }
591 
592 bool
594 invariant() const
595 {
596  bool result = true;
597 
598  // Preconditions:
599 
600  // Body:
601 
602  // Must satisfy base class invariant
603 
604  invariance(sec_tp::invariant());
605 
606  if (invariant_check())
607  {
608  // Prevent recursive calls to invariant
609 
610  disable_invariant_check();
611 
612  //@issue What do we want here?
613  //invariance(is_attached() ? ( (u() == 0) && (p() == v()) ) || ( (v() == 0) && (p() == u()) ) : true);
614 
615  // Finished, turn invariant checking back on.
616 
617  enable_invariant_check();
618  }
619 
620  // Postconditions:
621 
622  ensure(is_derived_query);
623 
624  // Exit:
625 
626  return result;
627 }
628 
629 // PROTECTED MEMBER FUNCTIONS
630 
631 // PRIVATE MEMBER FUNCTIONS
632 
633 
634 //==============================================================================
635 // NON-MEMBER FUNCTIONS
636 //==============================================================================
637 
638 void
640 symmetric_product(const sec_stp& x0, const sec_stp& x1, sec_stp& xresult,
641  bool xauto_access)
642 {
643  // Preconditions:
644 
645  // Body:
646 
647  //$$SCRIBBLE: Currently all symmetric_product functions are
648  // "not_implemented()" because meaningful
649  // results would be like Sym(st2 (X) st2) = st4.
650  // But we have not yet implemented any st4 classes.
651 
652  not_implemented();
653 
654  // Postconditions:
655 
656  // Exit:
657 
658  return;
659 }
660 
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
A symmetric tensor of degree p over an abstract vector space.
Definition: stp.h:190
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 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...
A client handle for a general, abstract partially order set.
virtual const std::string & class_name() const
The name of this class.
Definition: sec_stp.cc:444
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.
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.
SHEAF_DLL_SPEC void symmetric_product(const sec_stp &x0, const sec_stp &x1, sec_stp &xresult, bool xauto_access)
The symmetric product of two general tensors (pre-allocated version).
Definition: sec_stp.cc:640
virtual bool host_is_ancestor_of(const poset_state_handle *other) const
True if other conforms to host.
Definition: sec_stp.cc:524
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_stp.cc:51
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 invariant() const
Class invariant.
Definition: sec_stp.cc:594
host_type * host() const
The poset this is a member of.
Definition: sec_stp.cc:517
virtual int d(int xp, int xdd) const
Dimension d() as a function of degree xp and domain dimension xdd.
bool owns(const poset_state_handle &xposet, bool xauto_access) const
True if and only if this contains the poset xposet. synonym for contains_poset(xposet.poset_path(true), xauto_access)
An index within the external ("client") scope of a given id space.
Definition: scoped_index.h:116
bool contains_path(const poset_path &xpath, bool xauto_access=true) const
True if this contains the poset or poset member specified by xpath.
A section of a bundle with fiber type stp.
Definition: sec_stp.h:48
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 sec_stp * clone() const
Make a new handle, no state instance of current.
Definition: sec_stp.cc:482
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
~sec_stp()
Destructor.
Definition: sec_stp.cc:368
virtual const fiber_type & fiber_prototype() const
Virtual constructor for the associated fiber type.
Definition: sec_stp.cc:383
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).
virtual sec_stp & operator=(const abstract_poset_member &xother)
Assignment operator; synonym for attach_to_state(&xother).
Definition: sec_stp.cc:284
An abstract client handle for a member of a poset.
sec_stp()
Default constructor.
Definition: sec_stp.cc:111
static const std::string & static_class_name()
The name of this class.
Definition: sec_stp.cc:463
A symmetric tensor of degree p over an abstract vector space (volatile version).
Definition: stp.h:44
An abstract symmetric tensor space of degree p.
Definition: stp_space.h:42
Namespace for the fiber_bundles component of the sheaf system.
bool fiber_is_ancestor_of(const any *xother) const
True if xother conforms to an instance of the fiber of current.
Definition: sec_stp.cc:542
bool is_ancestor_of(const any *xother) const
True if xother conforms to current.
Definition: sec_stp.cc:569
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