de/df5/t4__e2_8cc_source.html

 //
 // Copyright (c) 2014 Limit Point Systems, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //


 #include "SheafSystem/t4_e2.impl.h"

 #include "SheafSystem/abstract_poset_member.impl.h"
 #include "SheafSystem/assert_contract.h"
 #include "SheafSystem/at0.h"
 #include "SheafSystem/at1_space.h"
 #include "SheafSystem/fiber_bundles_namespace.h"
 #include "SheafSystem/schema_poset_member.h"
 #include "SheafSystem/tp_space.h"
 #include "SheafSystem/wsv_block.h"

 #include "SheafSystem/st4_e2.h"
 #include "SheafSystem/std_sstream.h"

 using namespace std;
 using namespace fiber_bundle; // Workaround for MS C++ bug.


 //==============================================================================
 // CLASS T4_E2_LITE
 //==============================================================================

 //==============================================================================
 // T4_E2 FACET OF CLASS T4_E2_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 fiber_bundle::t4_e2_lite::
 t4_e2_lite()
 {

   // Preconditions:

   // Body:

   // Postconditions:

   ensure(invariant());

   // Exit:
 }

 fiber_bundle::t4_e2_lite::
 t4_e2_lite(const t4_e2_lite& xother)
 {
   // Preconditions:

   // Body:

   *this = xother;

   // Postconditions:

   ensure(invariant());

   // Exit:
 }

 fiber_bundle::t4_e2_lite&
 fiber_bundle::t4_e2_lite::
 operator=(const t4_e2_lite& xother)
 {

   // Preconditions:

   // Body:

   if(this == &xother)
     return *this;

   _row_dofs = xother._row_dofs;

   // Postconditions:

   ensure(invariant());
   ensure_for_all(i, 0, d(), component(i) == xother[i]);

   // Exit:

   return *this;
 }

 fiber_bundle::t4_e2_lite::
 ~t4_e2_lite()
 {
   // Preconditions:

   // Body:

   // Postconditions:

   // Exit:

 }


 fiber_bundle::t4_e2_lite::
 t4_e2_lite(const st4_e2_lite& xother)
 {
   // Preconditions:

   // Body:

   *this = xother;

   // Postconditions:

   ensure(invariant());

   // Exit:
 }

 fiber_bundle::t4_e2_lite&
 fiber_bundle::t4_e2_lite::
 operator=(const st4_e2_lite& xother)
 {
   // Preconditions:

   // Body:

   for(int i=0; i<2; i++)
   {
     for(int j=0; j<2; j++)
     {
       for(int k=0; k<2; k++)
       {
         for(int l=0; l<2; l++)
         {
           value_type lcomp = xother.component(i, j, k, l);
           put_component(i, j, k, l, lcomp);
         }
       }
     }
   }

   // Postconditions:

   ensure(invariant());

   // Exit:

   return *this;
 }

 fiber_bundle::t4_e2_lite::
 t4_e2_lite(const row_dofs_type& xrow_dofs)
 {
   // Preconditions:

   // Body:

   *this = xrow_dofs;

   // Postconditions:

   ensure(invariant());

   // Exit:
 }

 fiber_bundle::t4_e2_lite&
 fiber_bundle::t4_e2_lite::
 operator=(const row_dofs_type& xrow_dofs)
 {
   // Preconditions:

   // Body:

   _row_dofs = xrow_dofs;

   // Postconditions:

   ensure(invariant());

   // Exit:

   return *this;

 }

 fiber_bundle::t4_e2_lite::
 operator t4_e2_lite::row_dofs_type& ()
 {
   // Preconditions:

   // Body:

   row_dofs_type& result = _row_dofs;

   // Postconditions:

   // Exit:

   return result;
 }

 fiber_bundle::t4_e2_lite::
 operator const t4_e2_lite::row_dofs_type& () const
 {
   // Preconditions:

   // Body:

   const row_dofs_type& result = _row_dofs;

   // Postconditions:

   // Exit:

   return result;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // T4 FACET OF CLASS T4_E2_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // TENSOR ALGEBRA (TP) FACET OF CLASS T4_E2_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 int
 fiber_bundle::t4_e2_lite::
 dd() const
 {
   // Preconditions:

   // Body:

   int result = 2;

   // Postconditions:

   ensure(invariant());
   ensure(result == 2);

   // Exit:

   return result;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // VECTOR ALGEBRA (VD) FACET OF CLASS T4_E2_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 const fiber_bundle::tp_lite&
 fiber_bundle::t4_e2_lite::
 tp_prototype(int xp) const
 {
   // Preconditions:

   require(precondition_of(e2_lite::static_tp_prototype(xp)));

   // Body:

   const tp_lite& result = e2_lite::static_tp_prototype(xp);

   // Postconditions:

   ensure(postcondition_of(e2_lite::static_tp_prototype(xp)));

   // Exit:

   return result;
 }

 const fiber_bundle::atp_lite&
 fiber_bundle::t4_e2_lite::
 atp_prototype(int xp) const
 {
   // Preconditions:

   require(precondition_of(e2_lite::static_atp_prototype(xp)));

   // Body:

   const atp_lite& result = e2_lite::static_atp_prototype(xp);

   // Postconditions:

   ensure(postcondition_of(e2_lite::static_atp_prototype(xp)));

   // Exit:

   return result;
 }

 const fiber_bundle::stp_lite&
 fiber_bundle::t4_e2_lite::
 stp_prototype(int xp) const
 {
   // Preconditions:

   require(precondition_of(e2_lite::static_stp_prototype(xp)));

   // Body:

   const stp_lite& result = e2_lite::static_stp_prototype(xp);

   // Postconditions:

   ensure(postcondition_of(e2_lite::static_stp_prototype(xp)));

   // Exit:

   return result;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // CARTESIAN ALGEBRA (TUPLE) FACET OF CLASS T4_E2_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // ABSTRACT POSET MEMBER FACET OF CLASS T4_E2_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 const std::string&
 fiber_bundle::t4_e2_lite::
 class_name() const
 {
   // Preconditions:

   // Body:

   const string& result = static_class_name();

   // Postconditions:

   ensure(!result.empty());

   // Exit:

   return result;
 }

 const std::string&
 fiber_bundle::t4_e2_lite::
 static_class_name()
 {
   // Preconditions:

   // Body:

   static const string result("t4_e2_lite");

   // Postconditions:

   ensure(!result.empty());

   // Exit:

   return result;
 }

 fiber_bundle::t4_e2_lite*
 fiber_bundle::t4_e2_lite::
 clone() const
 {
   t4_e2_lite* result = 0;

   // Preconditions:

   // Body:

   result = new t4_e2_lite();

   // Postconditions:

   ensure(result != 0);
   ensure(is_same_type(*result));

   // Exit:

   return result;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // ANY FACET OF CLASS T4_E2_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 bool
 fiber_bundle::t4_e2_lite::
 is_ancestor_of(const any_lite& xother) const
 {
   // Preconditions:

   require(&xother != 0);

   // Body:

   // True if other conforms to this.

   bool result = dynamic_cast<const t4_e2_lite*>(&xother) != 0;

   // Postconditions:

   return result;
 }

 bool
 fiber_bundle::t4_e2_lite::
 invariant() const
 {
   bool result = true;

   if(invariant_check())
   {
     // Prevent recursive calls to invariant.

     disable_invariant_check();

     // Must satisfy base class invariant.

     invariance(t4_lite::invariant());

     // Invariances for this class:

     // Finished, turn invariant checking back on.

     enable_invariant_check();
   }

   // Exit

   return result;
 }

 void*
 fiber_bundle::t4_e2_lite::
 row_dofs()
 {
   return &_row_dofs;
 }

 const void*
 fiber_bundle::t4_e2_lite::
 row_dofs() const
 {
   return &_row_dofs;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // CLASS T4_E2
 //==============================================================================

 // ===========================================================
 // HOST FACTORY FACET OF CLASS T4_E2
 // ===========================================================

 // PUBLIC MEMBER FUNCTIONS

 const sheaf::poset_path&
 fiber_bundle::t4_e2::
 standard_schema_path()
 {
   // Preconditions:


   // Body:

   static const poset_path result(standard_schema_poset_name(), "t4_e2_schema");

   // Postconditions:

   // Exit:

   return result;
 }

 void
 fiber_bundle::t4_e2::
 make_standard_schema(namespace_poset& xns)
 {
   // Preconditions:

   require(xns.state_is_read_write_accessible());
   require(xns.contains_poset(standard_schema_poset_name()));
   require(!xns.contains_poset_member(standard_schema_path()));

   // Body:

   string lcomp_names[16] = {
     "xxxx", "xxxy", "xxyx", "xxyy", "xyxx", "xyxy", "xyyx", "xyyy",
     "yxxx", "yxxy", "yxyx", "yxyy", "yyxx", "yyxy", "yyyx", "yyyy"};

   ostringstream los;
   for(int i=0; i<16; ++i)
   {
     los << lcomp_names[i] << " DOUBLE false ";
   }

   string lmember_names = los.str();

   schema_poset_member lschema(xns,
                               standard_schema_path().member_name(),
                               t4::standard_schema_path(),
                               lmember_names,
                               false);

   lschema.detach_from_state();

   // Postconditions:

   ensure(xns.contains_poset_member(standard_schema_path()));

   // Exit:

   return;
 }

 fiber_bundle::t4_e2::host_type&
 fiber_bundle::t4_e2::
 new_host(namespace_type& xns,
          const poset_path& xhost_path,
          const poset_path& xschema_path,
          const poset_path& xvector_space_path,
          bool xauto_access)
 {
   // cout << endl << "Entering t4_e2::new_host." << endl;

   // Preconditions:

   require(xns.state_is_auto_read_write_accessible(xauto_access));

   require(!xhost_path.empty());
   require(!xns.contains_path(xhost_path, xauto_access));

   require(xschema_path.full());
   require(xns.path_is_auto_read_accessible(xschema_path, xauto_access));
   require(schema_poset_member::conforms_to(xns, xschema_path, standard_schema_path()));
   require(schema_poset_member::row_dof_ct(xns, xschema_path, xauto_access) == 16);

   require(xns.path_is_auto_read_accessible(xvector_space_path, xauto_access));
   require(xns.contains_poset<vector_space_type::host_type>(xvector_space_path, xauto_access));
   require(xns.member_poset(xvector_space_path, xauto_access).schema(xauto_access).conforms_to(vector_space_type::standard_schema_path()));
   require(xns.member_poset<vector_space_type::host_type>(xvector_space_path, xauto_access).d(xauto_access) == 2);

   require(host_type::d(xns, xschema_path, xauto_access) == host_type::d(xns, 4, xvector_space_path, xauto_access));

   // Body:

   host_type& result =
     host_type::new_table(xns, xhost_path, xschema_path, 4, xvector_space_path, xauto_access);

   // Postconditions:

   ensure(xns.owns(result, xauto_access));
   ensure(result.path(true) == xhost_path);
   ensure(result.state_is_not_read_accessible());
   ensure(result.schema(true).path(xauto_access) == xschema_path);

   ensure(result.factor_ct(true) == 16);
   ensure(result.d(true) == 16);
   ensure(result.scalar_space_path(true) == xns.member_poset<vector_space_type::host_type>(xvector_space_path, xauto_access).scalar_space_path());
   ensure(result.p(true) == 4);
   ensure(result.dd(true) == 2);
   ensure(result.vector_space_path(true) == xvector_space_path);

   // Exit:

   // cout << "Leaving t4_e2::new_host." << endl;
   return result;
 }

 fiber_bundle::t4_e2::host_type&
 fiber_bundle::t4_e2::
 standard_host(namespace_type& xns, const std::string& xsuffix, bool xauto_access)
 {
   // cout << endl << "Entering t4_e2::new_host." << endl;

   // Preconditions:

   require(xns.state_is_auto_read_write_accessible(xauto_access));

   require(xsuffix.empty() || poset_path::is_valid_name(xsuffix));
   require(standard_host_is_available<t4_e2>(xns, xsuffix, xauto_access));

   require(xns.path_is_auto_read_accessible(standard_schema_path(), xauto_access));

   require(xns.path_is_auto_read_available(standard_host_path<vector_space_type>(xsuffix), xauto_access));

   // Body:

   // Create the vector space if necessary.

   poset_path lvector_space_path = vector_space_type::standard_host(xns, xsuffix, xauto_access).path(true);

   poset_path lpath(standard_host_path<t4_e2>(xsuffix));

   host_type* result_ptr;
   if(xns.contains_path(lpath, xauto_access))
   {
     result_ptr = &xns.member_poset<host_type>(lpath, xauto_access);
   }
   else
   {
     result_ptr = &new_host(xns, lpath, standard_schema_path(), lvector_space_path, xauto_access);
   }

   host_type& result = *result_ptr;

   // Postconditions:

   ensure(xns.owns(result, xauto_access));
   ensure(result.path(true) == standard_host_path<t4_e2>(xsuffix));
   ensure(result.state_is_not_read_accessible());
   ensure(result.schema(true).path(xauto_access) == standard_schema_path());

   ensure(result.factor_ct(true) == 16);
   ensure(result.d(true) == 16);
   ensure(result.scalar_space_path(true) == standard_host_path<vector_space_type::scalar_type>(xsuffix) );
   ensure(result.p(true) == 4);
   ensure(result.dd(true) == 2);
   ensure(result.vector_space_path(true) == standard_host_path<vector_space_type>(xsuffix) );

   // Exit:

   // cout << "Leaving t4_e2::new_host." << endl;
   return result;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // T4_E2 FACET OF CLASS T4_E2
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 fiber_bundle::t4_e2::
 t4_e2()
 {
   // Preconditions:

   // Body:

   // Postconditions:

   ensure(invariant());

   // Exit:

   return;
 }

 fiber_bundle::t4_e2::
 t4_e2(const t4_e2& xother)
 {

   // Preconditions:


   // Body:

   attach_to_state(&xother);

   // Postconditions:

   ensure(invariant());

   // Exit:

   return;
 }

 fiber_bundle::t4_e2&
 fiber_bundle::t4_e2::
 operator=(const abstract_poset_member& xother)
 {
   // Preconditions:

   require(is_ancestor_of(&xother));
   require(precondition_of(attach_to_state(&xother)));

   // Body:

   attach_to_state(&xother);

   // Postconditions:

   ensure(postcondition_of(attach_to_state(&xother)));

   // Exit:

   return *this;
 }

 fiber_bundle::t4_e2&
 fiber_bundle::t4_e2::
 operator=(const t4_e2& xother)
 {
   // Preconditions:

   require(precondition_of(attach_to_state(&xother)));

   // Body:

   attach_to_state(&xother);

   // Postconditions:

   ensure(postcondition_of(attach_to_state(&xother)));

   // Exit:

   return *this;
 }

 fiber_bundle::t4_e2::
 ~t4_e2()
 {

   // Preconditions:

   // Body:

   // Postconditions:

   // Exit:

   return;
 }

 const fiber_bundle::t4_e2::volatile_type&
 fiber_bundle::t4_e2::
 lite_prototype() const
 {
   // Preconditions:

   // Body:

   static const volatile_type result;

   // Postconditions:

   // Exit:

   return result;
 }

 fiber_bundle::t4_e2::volatile_type*
 fiber_bundle::t4_e2::
 lite_type() const
 {
   // Preconditions:

   // Body:

   volatile_type* result = new volatile_type(sheaf::row_dofs(*this));

   // Postconditions:

   // Exit:

   return result;
 }

 fiber_bundle::t4_e2::
 t4_e2(poset* xhost, bool xauto_access)
 {

   // Preconditions:

   require(precondition_of(new_jim_state(xhost, 0, false, xauto_access)));

   // Body:

   new_jim_state(xhost, 0, false, xauto_access);

   // Postconditions:

   ensure(postcondition_of(new_jim_state(xhost, 0, false, xauto_access)));

   // Exit:

   return;
 }

 fiber_bundle::t4_e2::
 t4_e2(poset_state_handle& xhost,
        const row_dofs_type& xrdt,
        bool xauto_access)
 {

   // Preconditions:

   require(precondition_of(new_jim_state(&xhost, 0, false, xauto_access)));

   // Body:

   new_jim_state(&xhost, 0, false, xauto_access);

   if(xauto_access)
   {
     xhost.get_read_write_access();
   }

   *this = xrdt;

   if(xauto_access)
   {
     xhost.release_access();
   }

   // Postconditions:

   ensure(postcondition_of(new_jim_state(&xhost, 0, false, xauto_access)));

   // Exit:

   return;
 }

 fiber_bundle::t4_e2&
 fiber_bundle::t4_e2::
 operator=(const row_dofs_type& xrdt)
 {
   // Preconditions:

   require(state_is_read_write_accessible());

   // Body:

   sheaf::row_dofs(*this) = xrdt;

   // Postconditions:

   ensure_for_all(i, 0, d(), component(i) == xrdt.components[i]);

   // Exit:

   return *this;

 }

 fiber_bundle::t4_e2::
 t4_e2(const poset* xhost, pod_index_type xhub_id)
 {
   // Preconditions:

   require(xhost != 0);
   require(xhost->state_is_read_accessible());
   require(xhost->contains_member(xhub_id));

   // Body:

   attach_to_state(xhost, xhub_id);

   // Postconditions:

   ensure(invariant());
   ensure(is_attached());
   // ensure(host() == xhost);
   ensure(index() == xhub_id);
 }

 fiber_bundle::t4_e2::
 t4_e2(const poset* xhost, const scoped_index& xid)
 {
   // Preconditions:

   require(xhost != 0);
   require(xhost->state_is_read_accessible());
   require(xhost->contains_member(xid));

   // Body:

   attach_to_state(xhost, xid.hub_pod());

   // Postconditions:

   ensure(invariant());
   ensure(is_attached());
   // ensure(host() == xhost);
   ensure(index() ==~ xid);
 }

 fiber_bundle::t4_e2::
 t4_e2(const poset* xhost, const std::string& xname)
 {

   // Preconditions:

   require(xhost != 0);
   require(xhost->state_is_read_accessible());
   require(!xname.empty());
   require(xhost->contains_member(xname));

   // Body:

   attach_to_state(xhost, xname);

   // Postconditions:

   ensure(invariant());
   ensure(is_attached());
   // ensure(host() == xhost);
   ensure(name() == xname);

 }

 fiber_bundle::t4_e2::
 operator t4_e2::row_dofs_type& ()
 {
   // Preconditions:

   require(state_is_read_write_accessible());

   // Body:

   row_dofs_type& result = sheaf::row_dofs(*this);

   // Postconditions:

   // Exit:

   return result;
 }

 fiber_bundle::t4_e2::
 operator const t4_e2::row_dofs_type& () const
 {
   // Preconditions:

   require(state_is_read_accessible());

   // Body:

   const row_dofs_type& result = sheaf::row_dofs(*this);

   // Postconditions:

   // Exit:

   return result;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // T4 FACET OF CLASS T4_E2
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // TP FACET OF CLASS T4_E2
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // VD FACET OF CLASS T4_E2
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // TUPLE FACET OF CLASS T4_E2
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 fiber_bundle::tp*
 fiber_bundle::t4_e2::
 new_tp(int xp, bool xauto_access) const
 {
   // Preconditions:

   require(precondition_of(e2::new_tp(vector_space(xauto_access), xp)));

   // Body:

   tp* result = e2::new_tp(vector_space(xauto_access), xp);

   // Postconditions:

   ensure(postcondition_of(e2::new_tp(vector_space(xauto_access), xp)));

   // Exit:

   return result;
 }

 fiber_bundle::atp*
 fiber_bundle::t4_e2::
 new_atp(int xp, bool xauto_access) const
 {
   // Preconditions:

   require(precondition_of(e2::new_atp(vector_space(xauto_access), xp)));

   // Body:

   atp* result = e2::new_atp(vector_space(xauto_access), xp);

   // Postconditions:

   ensure(postcondition_of(e2::new_atp(vector_space(xauto_access), xp)));

   // Exit:

   return result;
 }

 fiber_bundle::stp*
 fiber_bundle::t4_e2::
 new_stp(int xp, bool xauto_access) const
 {
   // Preconditions:

   require(precondition_of(e2::new_stp(vector_space(xauto_access), xp)));

   // Body:

   stp* result = e2::new_stp(vector_space(xauto_access), xp);

   // Postconditions:

   ensure(postcondition_of(e2::new_stp(vector_space(xauto_access), xp)));

   // Exit:

   return result;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // ABSTRACT POSET MEMBER FACET OF CLASS T4_E2
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 const std::string&
 fiber_bundle::t4_e2::
 class_name() const
 {
   // Preconditions:

   // Body:

   const string& result = static_class_name();

   // Postconditions:

   ensure(!result.empty());

   // Exit:

   return result;
 }

 const std::string&
 fiber_bundle::t4_e2::
 static_class_name()
 {
   // Preconditions:

   // Body:

   static const string result("t4_e2");

   // Postconditions:

   ensure(!result.empty());

   // Exit:

   return result;
 }

 fiber_bundle::t4_e2*
 fiber_bundle::t4_e2::
 clone() const
 {

   // Preconditions:

   // Body:

   // Create new handle of the current class.

   t4_e2 *result = new t4_e2();

   // Postconditions:

   ensure(result != 0);
   ensure(result->invariant());

   // Exit:

   return result;

 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // ANY FACET OF CLASS T4_E2
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS


 bool
 fiber_bundle::t4_e2::
 invariant() const
 {
   bool result = true;

   // Body:

   if(invariant_check())
   {
     // Prevent recursive calls to invariant.

     disable_invariant_check();

     // Must satisfy base class invariant.

     invariance(t4::invariant());

     // Invariances for this class:

     invariance(state_is_read_accessible() ? dd() == 2 : true);

     // Finished, turn invariant checking back on.

     enable_invariant_check();
   }

   // Exit:

   return result;
 }

 bool
 fiber_bundle::t4_e2::
 is_ancestor_of(const any* xother) const
 {
   // Preconditions:

   require(xother != 0);

   // Body:

   // True if xother conforms to this.

   bool result = dynamic_cast<const t4_e2*>(xother) != 0;

   // Postconditions:

   ensure(invariant());

   // Exit:

   return result;

 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // NON-MEMBER FUNCTIONS
 //==============================================================================

 #include "SheafSystem/st4_e2.h"

 void
 fiber_bundle::tp_algebra::
 sym(const t4_e2_lite& x0, st4_e2_lite& xresult)
 {
   // Preconditions:

   // Body:

   //@todo Implement a more efficient version using knowledge
   //      about the components.

   int ldd = x0.dd();

   for(int i=0; i<ldd; ++i)
   {
     for(int j=i; j<ldd; ++j)
     {
       for(int k=j; k<ldd; ++k)
       {
         for(int l=k; l<ldd; ++l)
         {
           vd_value_type lvalue = x0.component(i,j,k,l)
                                + x0.component(i,j,l,k)
                                + x0.component(i,k,j,l)
                                + x0.component(i,l,j,k)
                                + x0.component(i,k,l,j)
                                + x0.component(i,l,k,j)
                                + x0.component(j,i,k,l)
                                + x0.component(j,i,l,k)
                                + x0.component(k,i,j,l)
                                + x0.component(l,i,j,k)
                                + x0.component(k,i,l,j)
                                + x0.component(l,i,k,j)
                                + x0.component(j,k,i,l)
                                + x0.component(j,l,i,k)
                                + x0.component(k,j,i,l)
                                + x0.component(l,j,i,k)
                                + x0.component(k,l,i,j)
                                + x0.component(l,k,i,j)
                                + x0.component(j,k,l,i)
                                + x0.component(j,l,k,i)
                                + x0.component(k,j,l,i)
                                + x0.component(l,j,k,i)
                                + x0.component(k,l,j,i)
                                + x0.component(l,k,j,i);

           lvalue /= 24.0; // 4!
           xresult.put_component(i, j, k, l, lvalue);
         }
       }
     }
   }

   // Postconditions:

   ensure(unexecutable("xresult is equal to the symmetric part of x0"));

   // Exit:

   return;
 }

 void
 fiber_bundle::tp_algebra::
 sym(const t4_e2& x0, st4_e2& xresult, bool xauto_access)
 {
   // Preconditions:

   require(x0.state_is_auto_read_accessible(xauto_access));
   require(xresult.state_is_auto_read_accessible(xauto_access));
   require(!x0.variance(xauto_access).is_mixed());

   // Body:

   if(xauto_access)
   {
     x0.get_read_access();
     xresult.get_read_write_access(true);
   }

   int ldd = x0.dd();

   for(int i=0; i<ldd; ++i)
   {
     for(int j=i; j<ldd; ++j)
     {
       for(int k=j; k<ldd; ++k)
       {
         for(int l=k; l<ldd; ++l)
         {
           vd_value_type lvalue = x0.component(i,j,k,l)
                                + x0.component(i,j,l,k)
                                + x0.component(i,k,j,l)
                                + x0.component(i,l,j,k)
                                + x0.component(i,k,l,j)
                                + x0.component(i,l,k,j)
                                + x0.component(j,i,k,l)
                                + x0.component(j,i,l,k)
                                + x0.component(k,i,j,l)
                                + x0.component(l,i,j,k)
                                + x0.component(k,i,l,j)
                                + x0.component(l,i,k,j)
                                + x0.component(j,k,i,l)
                                + x0.component(j,l,i,k)
                                + x0.component(k,j,i,l)
                                + x0.component(l,j,i,k)
                                + x0.component(k,l,i,j)
                                + x0.component(l,k,i,j)
                                + x0.component(j,k,l,i)
                                + x0.component(j,l,k,i)
                                + x0.component(k,j,l,i)
                                + x0.component(l,j,k,i)
                                + x0.component(k,l,j,i)
                                + x0.component(l,k,j,i);

           lvalue /= 24.0; // 4!
           xresult.put_component(i, j, k, l, lvalue);
         }
       }
     }
   }

   // Set the variance of the result.
   // Variance of result is same as variance of x0.

   xresult.put_variance(x0.variance(false), false);

   if(xauto_access)
   {
     x0.release_access();
     xresult.release_access();
   }

   // Postconditions:

   ensure(xresult.variance(xauto_access) == x0.variance(xauto_access));
   ensure(unexecutable("xresult is equal to the antisymmetric part of x0"));

   // Exit:

   return;
 }

sheaf::poset_state_handle::get_read_write_access
virtual void get_read_write_access(bool xrelease_read_only_access=false)
Get read write access to the state associated with this. If release_read_only_access is requested...
Definition: poset_state_handle.cc:399

sheaf::poset_state_handle::path
virtual poset_path path(bool xauto_access=true) const
The path of this poset.
Definition: poset_state_handle.cc:1241

sheaf::read_write_monitor_handle::state_is_auto_read_write_accessible
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 ...
Definition: read_write_monitor_handle.cc:387

fiber_bundle::t4_e2_lite::~t4_e2_lite
virtual ~t4_e2_lite()
Destructor.
Definition: t4_e2.cc:105

fiber_bundle::st4::put_component
virtual void put_component(int xi, int xj, int xk, int xl, value_type xvalue)
Sets the component with indices xi, xj, xk, xl to xvalue.
Definition: st4.cc:851

fiber_bundle::t4_e2_lite::row_dofs
virtual void * row_dofs()
The row dofs for this instance (mutable version).
Definition: t4_e2.cc:492

fiber_bundle::t4_e2_lite::invariant
bool invariant() const
Class invariant.
Definition: t4_e2.cc:464

fiber_bundle::st4_lite::put_component
virtual void put_component(int xi, int xj, int xk, int xl, value_type xvalue)
Sets the component with indices xi, xj, xk, xl to xvalue.
Definition: st4.cc:214

fiber_bundle::stp
A symmetric tensor of degree p over an abstract vector space.
Definition: stp.h:190

fiber_bundle::vd_lite::value_type
vd_value_type value_type
The type of component in the fiber; the scalar type in the fiber vector space.
Definition: vd.h:129

fiber_bundle::tp::dd
virtual int dd() const
Dimension of the underlying vector space.
Definition: tp.cc:788

sheaf::poset_path::full
bool full() const
True if both poset name and member name are not empty.
Definition: poset_path.cc:311

fiber_bundle::tp::put_variance
void put_variance(const tensor_variance &xvariance, bool xauto_access)
Sets the variance to xvariance.
Definition: tp.cc:1039

fiber_bundle::atp
An antisymmetric tensor of degree p.
Definition: atp.h:190

fiber_bundle::t4_e2::standard_host
static host_type & standard_host(namespace_type &xns, const std::string &xsuffix, bool xauto_access)
The host with path standard_host_path<t4_e2>(xsuffix). Returns the host if it already exists...
Definition: t4_e2.cc:634

fiber_bundle::t4_e2_row_dofs_type::components
T components[16]
The dofs are in the following order:
Definition: t4_e2.h:122

fiber_bundle::t4_e2::is_ancestor_of
virtual bool is_ancestor_of(const any *other) const
Conformance test; true if other conforms to this.
Definition: t4_e2.cc:1237

fiber_bundle::atp_space::d
static int d(const namespace_poset &xns, int xp, const poset_path &xvector_space_path, bool xauto_access)
The tensor dimension implied by tensor degree xp and the dimension of the domain vector space specifi...
Definition: atp_space.cc:86

fiber_bundle::t4_e2_lite::tp_prototype
virtual const tp_lite & tp_prototype(int xp) const
Prototype for general tensors of degree xp over this vector space.
Definition: t4_e2.cc:289

fiber_bundle::t4_lite::component
virtual value_type component(int xi, int xj, int xk, int xl) const
The component with indices xi, xj, xk, xl.
Definition: t4.cc:209

sheaf::poset_component::path
poset_path path(bool xauto_access=true) const
A path to this component.
Definition: poset_component.cc:787

sheaf::schema_poset_member::conforms_to
bool conforms_to(const schema_poset_member &xother) const
True if the dofs defined by this agree in type and in order with the dofs defined by xother...
Definition: schema_poset_member.cc:1497

sheaf::namespace_poset
The default name space; a poset which contains other posets as members.
Definition: namespace_poset.h:68

sheaf::read_write_monitor_handle::state_is_read_accessible
bool state_is_read_accessible() const
True if this is attached and if the state is accessible for read or access control is disabled...
Definition: read_write_monitor_handle.cc:244

sheaf::namespace_poset::path_is_auto_read_accessible
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.
Definition: namespace_poset.cc:1127

fiber_bundle::fiber_bundles_namespace
The standard fiber bundles name space; extends the standard sheaves namespace by defining base space...
Definition: fiber_bundles_namespace.h:53

fiber_bundle::tp_space::vector_space_path
poset_path vector_space_path() const
The path of the underlying vector space.
Definition: tp_space.cc:365

fiber_bundle::t4_e2_lite::operator=
t4_e2_lite & operator=(const t4_e2_lite &xother)
Assignment operator.
Definition: t4_e2.cc:82

sheaf::namespace_poset::contains_poset_member
bool contains_poset_member(pod_index_type xposet_hub_id, pod_index_type xmember_hub_id, bool xauto_access=true) const
True if this contains a poset with hub id xposet_hub_id which contains a member with hub id xmember_h...
Definition: namespace_poset.cc:425

sheaf::read_write_monitor_handle::state_is_auto_read_accessible
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...
Definition: read_write_monitor_handle.cc:309

sheaf::poset_state_handle
A client handle for a general, abstract partially order set.
Definition: poset_state_handle.h:136

fiber_bundle::tp_algebra::sym
SHEAF_DLL_SPEC void sym(const t2_lite &x0, st2_lite &xresult)
The symmetric part of tensor x0 (pre-allocated version for volatile types).
Definition: t2.cc:1301

sheaf::poset_path
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

fiber_bundle::t4_e2
A tensor of degree 4 over a Euclidean vector space of dimension 2 (persistent version).
Definition: t4_e2.h:378

std
STL namespace.

sheaf::poset_component::get_read_access
virtual void get_read_access() const
Get read access to the state associated with this.
Definition: poset_component.cc:1519

sheaf::namespace_poset::member_poset
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.
Definition: namespace_poset.cc:601

fiber_bundle::t4_e2::class_name
virtual const std::string & class_name() const
The name of this class.
Definition: t4_e2.cc:1131

sheaf::row_dofs
T::row_dofs_type & row_dofs(T &x0)
The row dofs pod type for x0 (mutable version).
Definition: abstract_poset_member.impl.h:130

fiber_bundle::t4_e2::lite_type
virtual volatile_type * lite_type() const
Virtual conversion to the associated volatile type.
Definition: t4_e2.cc:816

fiber_bundle::tensor_variance::is_mixed
bool is_mixed() const
True if and only if there exists at least one index that is covariant and at least one that is contra...
Definition: tensor_variance.cc:312

fiber_bundle::t4_e2::static_class_name
static const std::string & static_class_name()
The name of this class.
Definition: t4_e2.cc:1150

fiber_bundle::atp_lite
An antisymmetric tensor of degree p over an abstract vector space (volatile version).
Definition: atp.h:44

fiber_bundle::tp
A general tensor of "degree" p and given "variance" over an abstract vector space.
Definition: tp.h:253

sheaf::poset_component::release_access
virtual void release_access(bool xall=false) const
Release access. If xall is true, release all levels of access. Otherwise, release one level of access...
Definition: poset_component.cc:1561

fiber_bundle::any_lite
Abstract base class with useful features for all volatile objects.
Definition: any_lite.h:48

sheaf::any
Abstract base class with useful features for all objects.
Definition: any.h:39

fiber_bundle::t4_e2::t4_e2
t4_e2()
Default constructor.
Definition: t4_e2.cc:701

sheaf::poset_state_handle::schema
virtual schema_poset_member & schema()
The schema for this poset (mutable version).
Definition: poset_state_handle.cc:6212

fiber_bundle::t4_e2_lite::clone
virtual t4_e2_lite * clone() const
Virtual constructor, makes a new instance of the same type as this.
Definition: t4_e2.cc:412

fiber_bundle::t4_e2_lite::class_name
virtual const std::string & class_name() const
The name of this class.
Definition: t4_e2.cc:374

sheaf::poset
A client handle for a mutable partially ordered set.
Definition: poset.h:40

sheaf::read_write_monitor_handle::state_is_read_write_accessible
bool state_is_read_write_accessible() const
True if this is attached and if the state is accessible for read and write or access control is disab...
Definition: read_write_monitor_handle.cc:333

sheaf::namespace_poset::owns
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)
Definition: namespace_poset.cc:404

sheaf::schema_poset_member::detach_from_state
virtual void detach_from_state()
Detach this handle from its state, if any.
Definition: schema_poset_member.cc:3753

sheaf::scoped_index
An index within the external ("client") scope of a given id space.
Definition: scoped_index.h:116

sheaf::namespace_poset::contains_path
bool contains_path(const poset_path &xpath, bool xauto_access=true) const
True if this contains the poset or poset member specified by xpath.
Definition: namespace_poset.cc:1095

fiber_bundle::st4_lite::component
virtual value_type component(int xi, int xj, int xk, int xl) const
The component with indices xi, xj, xk, xl.
Definition: st4.cc:190

sheaf::poset_state_handle::contains_member
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. ...
Definition: poset_state_handle.cc:1776

fiber_bundle::tp_space::p
int p(int xd, int xdd) const
Tensor degree as a function of tensor dimension xd and domain dimension xdd.
Definition: tp_space.cc:235

fiber_bundle::t4_e2_lite::_row_dofs
row_dofs_type _row_dofs
Row_dofs_type.
Definition: t4_e2.h:214

fiber_bundle::t4_e2::new_atp
virtual atp * new_atp(int xp, bool xauto_access) const
Virtual constructor for antisymmetric tensors of degree xp over vector space xvector_space.
Definition: t4_e2.cc:1078

fiber_bundle::st4_e2
A symmetric rank 3 tensor over a 3D Euclidean vector space (persistent version).
Definition: st4_e2.h:376

sheaf::poset_path::empty
bool empty() const
True if both poset name and member name are empty.
Definition: poset_path.cc:291

sheaf::poset_state_handle::release_access
virtual void release_access(bool xall=false) const
Release access. If xall is true, release all levels of access. Otherwise, release one level of access...
Definition: poset_state_handle.cc:425

fiber_bundle::t4_e2::standard_schema_path
static const poset_path & standard_schema_path()
The path to the standard schema for this class.
Definition: t4_e2.cc:521

fiber_bundle::tp_lite
A general tensor of degree p over an abstract vector space (volatile version). Volatile version does ...
Definition: tp.h:59

fiber_bundle::t4_e2::clone
virtual t4_e2 * clone() const
Make a new handle, no state instance of current.
Definition: t4_e2.cc:1169

fiber_bundle::t4_e2::operator=
virtual t4_e2 & operator=(const abstract_poset_member &xother)
Assignment operator; synonym for attach_to_state(&xother).
Definition: t4_e2.cc:739

fiber_bundle::t4_e2::make_standard_schema
static void make_standard_schema(namespace_poset &xns)
Creates the standard schema for this class in namespace xns.
Definition: t4_e2.cc:539

sheaf::namespace_poset::contains_poset
bool contains_poset(pod_index_type xhub_id, bool xauto_access=true) const
True if this contains a poset with hub id xhub_id..
Definition: namespace_poset.cc:326

fiber_bundle::st4_e2_lite
A symmetric rank 4 tensor over a Euclidean vector space of dimension 3. (volatile version)...
Definition: st4_e2.h:124

fiber_bundle::t4_e2::new_host
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: t4_e2.cc:580

sheaf::namespace_poset::path_is_auto_read_available
bool path_is_auto_read_available(const poset_path &xpath, bool xauto_access) const
True if the state referred to xpath does not exist or exists and is auto read accessible.
Definition: namespace_poset.cc:1174

fiber_bundle::t4_e2_lite::stp_prototype
virtual const stp_lite & stp_prototype(int xp) const
Prototype for symmetric tensors of degree xp over this vector space.
Definition: t4_e2.cc:331

fiber_bundle::t4_lite
A tensor of degree 4 over an abstract vector space (volatile version).
Definition: t4.h:43

fiber_bundle::t4::component
virtual value_type component(int xi, int xj, int xk, int xl) const
The component with indices xi, xj, xk, xl.
Definition: t4.cc:788

fiber_bundle::vd_space::scalar_space_path
poset_path scalar_space_path() const
The path of the underlying space of scalars.
Definition: vd_space.cc:250

fiber_bundle::t4_e2_lite::atp_prototype
virtual const atp_lite & atp_prototype(int xp) const
Prototype for antisymmetric tensors of degree xp over this vector space.
Definition: t4_e2.cc:310

sheaf::poset_component::get_read_write_access
virtual void get_read_write_access(bool xrelease_read_only_access=false)
Get read write access to the state associated with this. If release_read_only_access is requested...
Definition: poset_component.cc:1539

fiber_bundle::at1_space
An abstract vector space viewed as an antisymmetric tensor space of degree 1.
Definition: at1_space.h:42

fiber_bundle::tp_space::d
static int d(const namespace_poset &xns, const poset_path &xschema_path, bool xauto_access)
The tensor dimension implied by the schema specified by xschema_path.
Definition: tp_space.cc:83

fiber_bundle::vd_space::factor_ct
static int factor_ct(int xd)
Factor_ct() as a function of dimension xd.
Definition: vd_space.cc:167

fiber_bundle::t4_e2::new_tp
virtual tp * new_tp(int xp, bool xauto_access) const
Virtual constructor for general tensors of degree xp over vector space xvector_space.
Definition: t4_e2.cc:1057

sheaf::pod_index_type
int_type pod_index_type
The plain old data index type.
Definition: pod_types.h:49

fiber_bundle::t4_e2_lite::t4_e2_lite
t4_e2_lite()
Default constructor.
Definition: t4_e2.cc:50

fiber_bundle::tp_space::dd
int dd() const
The dimension of the underlying ("domain") vector space.
Definition: tp_space.cc:317

fiber_bundle::t4_e2::invariant
virtual bool invariant() const
Class invariant.
Definition: t4_e2.cc:1205

fiber_bundle::t4_e2::new_stp
virtual stp * new_stp(int xp, bool xauto_access) const
Virtual constructor for symmetric tensors of degree xp over vector space xvector_space.
Definition: t4_e2.cc:1099

fiber_bundle::t4_e2_lite::dd
virtual int dd() const
Dimension of the underlying vector space.
Definition: t4_e2.cc:258

fiber_bundle::tp::variance
virtual tensor_variance variance(bool xauto_access) const
The variance.
Definition: tp.cc:1001

fiber_bundle::t4_e2_lite::static_class_name
static const std::string & static_class_name()
The name of this class.
Definition: t4_e2.cc:393

fiber_bundle::t4_e2::lite_prototype
virtual const volatile_type & lite_prototype() const
Virtual constructor for the associated volatile type.
Definition: t4_e2.cc:798

sheaf::abstract_poset_member
An abstract client handle for a member of a poset.
Definition: abstract_poset_member.h:164

fiber_bundle::t4_e2_lite
A tensor of degree 4 over a Euclidean vector space of dimension 2 (volatile version).
Definition: t4_e2.h:140

sheaf::poset_path::path
std::string path() const
The full path as a string.
Definition: poset_path.cc:450

fiber_bundle::tp_space
An abstract tensor space of degree p.
Definition: tp_space.h:47

fiber_bundle::stp_lite
A symmetric tensor of degree p over an abstract vector space (volatile version).
Definition: stp.h:44

fiber_bundle
Namespace for the fiber_bundles component of the sheaf system.
Definition: base_space_crg_interval.h:36

fiber_bundle::t4_e2_lite::is_ancestor_of
virtual bool is_ancestor_of(const any_lite &xother) const
Conformance test; true if other conforms to this.
Definition: t4_e2.cc:445

fiber_bundle::t4_e2_row_dofs_type< double >

fiber_bundle::t4_e2::~t4_e2
virtual ~t4_e2()
Destructor.
Definition: t4_e2.cc:782

sheaf::read_write_monitor_handle::state_is_not_read_accessible
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...
Definition: read_write_monitor_handle.cc:276

sheaf::schema_poset_member
A client handle for a poset member which has been prepared for use as a schema.
Definition: schema_poset_member.h:75

fiber_bundle::vd_value_type
double vd_value_type
The type of component in the fiber; the scalar type in the fiber vector space.
Definition: fiber_bundle.h:63

sheaf::scoped_index::hub_pod
pod_type hub_pod() const
The pod value of this mapped to the unglued hub id space.
Definition: scoped_index.h:710