structured_block_3d_crg_interval.cc

Go to the documentation of this file.

//
// 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/structured_block_3d_crg_interval.h"

#include "SheafSystem/assert_contract.h"
#include "SheafSystem/base_space_poset.h"
#include "SheafSystem/constant_index_space_interval.h"
#include "SheafSystem/error_message.h"
#include "SheafSystem/explicit_index_space_interval.h"
#include "SheafSystem/factory.h"
#include "SheafSystem/offset_index_space_handle.h"
#include "SheafSystem/offset_index_space_state.h"
#include "SheafSystem/list_index_space_handle.h"
#include "SheafSystem/list_index_space_state.h"
#include "SheafSystem/ijk_adjacency_index_space_interval.h"
#include "SheafSystem/ijk_connectivity_index_space_interval.h"
#include "SheafSystem/ijk_product_structure.h"
#include "SheafSystem/index_space_iterator.h"
#include "SheafSystem/section_space_schema_member.h"
#include "SheafSystem/std_iomanip.h"
#include "SheafSystem/std_string.h"
#include "SheafSystem/std_sstream.h"
#include "SheafSystem/structured_block_3d.h"

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

// ===========================================================
// STRUCTURED_BLOCK_3D_CRG_INTERVAL FACET
// ===========================================================

// PUBLIC DATA MEMBERS

fiber_bundle::structured_block_3d_crg_interval::
structured_block_3d_crg_interval()
{
  _i_size = 0;
  _j_size = 0;
  _k_size = 0;
  _jk_size = 0;

  _i_vertex_size = 0;
  _j_vertex_size = 0;
  _k_vertex_size = 0;
  _jk_vertex_size = 0;

  _zone_begin = 0;
  _zone_size = 0;

  _vertex_begin = 0;
  _vertex_size = 0;

  // Postconditions:

  ensure(invariant());
  ensure(!is_initialized());

  return;
}

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

  // Body:

  if(is_valid(_lower_covers_begin))
  {
    // Delete the block interval.

    _id_spaces->delete_space(_lower_covers_begin);

    // Delete the zones interval.

    _id_spaces->delete_space(_lower_covers_begin + 1);

    // Delete the vertices interval.

    _id_spaces->delete_space(_lower_covers_begin + 1 + _zone_size);
  }

  if(is_valid(_upper_covers_begin))
  {
    // Delete the block interval.

    _id_spaces->delete_space(_upper_covers_begin);

    // Delete the zones interval.

    _id_spaces->delete_space(_upper_covers_begin + 1);

    // Delete the vertices interval.

    _id_spaces->delete_space(_upper_covers_begin + 1 + _zone_size);
  }

  // Postconditions:

  // Exit:

  return;
}

sheaf::size_type
fiber_bundle::structured_block_3d_crg_interval::
i_size() const
{
  return _i_size;
}

sheaf::size_type
fiber_bundle::structured_block_3d_crg_interval::
j_size() const
{
  return _j_size;
}

sheaf::size_type
fiber_bundle::structured_block_3d_crg_interval::
k_size() const
{
  return _k_size;
}


// PROTECTED DATA MEMBERS

sheaf::pod_index_type 
fiber_bundle::structured_block_3d_crg_interval::
vertex_id(pod_index_type xi, pod_index_type xj, pod_index_type xk) const
{
  // Preconditions:

  require((0 <= xi) && (xi <= i_size()));
  require((0 <= xj) && (xj <= j_size()));
  require((0 <= xk) && (xk <= k_size()));

  // Body:

  pod_index_type result =
    (xi*_j_vertex_size + xj)*_k_vertex_size + xk + _vertex_begin;

  // Postconditions:

  ensure(contains_member(result));

  // Exit:

  return result;
}

// PRIVATE DATA MEMBERS


// ===========================================================
// HOMOGENEOUS_BLOCK FACET
// ===========================================================

// PUBLIC DATA MEMBERS

// PROTECTED DATA MEMBERS

// PRIVATE DATA MEMBERS


// ===========================================================
// ZONES FACET
// ===========================================================

// PUBLIC DATA MEMBERS

// PROTECTED DATA MEMBERS

void
fiber_bundle::structured_block_3d_crg_interval::
initialize_zones(base_space_poset& xhost)
{
  // Preconditions:

  require(id_spaces_initialized());
  require(local_id_space_initialized());
  require(!zones_initialized());

  // Body:

  // Construct the zone id space.

  const string& lzone_id_space_name =
    section_space_schema_member::intersection_id_space_name(xhost.d_cells(3),
                                interval_member());

  _zones_space_id =
    offset_index_space_state::new_space(*_id_spaces,
                    lzone_id_space_name,
                    _zone_begin,
                    _zone_size).index();

  _zones_initialized = true;

  // Construct the product structure for the zone id space.

  ijk_product_structure lzone_structure(_i_size, _j_size, _k_size);
  _id_spaces->new_product_structure(_zones_space_id, lzone_structure);

  // Postconditions:

  ensure(zones_initialized());
  ensure(id_spaces().has_product_structure(zones_space_id()));
  ensure(id_spaces().product_structure_conforms_to<ijk_product_structure>(_zones_space_id));

  // Exit:

  return;
}  

// PRIVATE DATA MEMBERS


// ===========================================================
// VERTICES FACET
// ===========================================================

// PUBLIC DATA MEMBERS

// PROTECTED DATA MEMBERS

void
fiber_bundle::structured_block_3d_crg_interval::
initialize_vertices(base_space_poset& xhost)
{
  // Preconditions:

  require(id_spaces_initialized());
  require(local_id_space_initialized());
  require(!vertices_initialized());

  // Body:

  // Construct the vertex id space.

  const string& lvertex_id_space_name =
    section_space_schema_member::intersection_id_space_name(xhost.d_cells(0),
                                interval_member());

  _vertices_space_id =
    offset_index_space_state::new_space(*_id_spaces,
                    lvertex_id_space_name,
                    _vertex_begin,
                    _vertex_size).index();

  _vertices_initialized = true;

  // Construct the product structure for the vertex id space.

  ijk_product_structure lvertex_structure(_i_vertex_size, _j_vertex_size, _k_vertex_size);
  _id_spaces->new_product_structure(_vertices_space_id, lvertex_structure);

  // Postconditions:

  ensure(vertices_initialized());
  ensure(id_spaces().has_product_structure(vertices_space_id()));
  ensure(id_spaces().product_structure_conforms_to<ijk_product_structure>(_vertices_space_id));

  // Exit:

  return;
}  

// PRIVATE DATA MEMBERS


// ===========================================================
// BASE_SPACE_CRG_INTERVAL FACET
// ===========================================================

// PUBLIC DATA MEMBERS

int
fiber_bundle::structured_block_3d_crg_interval::
db(pod_index_type xmbr_id) const
{
  // Preconditions:

  require(contains_member(xmbr_id));

  // Body:

  static const int ldb[MEMBER_CLASS_END] =
    {
      3, 3, 0
    };

  int result = ldb[member_class(xmbr_id)];

  // Postconditions:


  // Exit:

  return result;
}

sheaf::pod_index_type
fiber_bundle::structured_block_3d_crg_interval::
d_cells_space_id(int xd) const
{
  // Preconditions:

  // Body:

  pod_index_type result;

  switch(xd)
  {
  case 0:
    result = _vertices_space_id;
    break;

  case 3:
    result = _zones_space_id;
    break;

  default:
    result = invalid_pod_index();
    break;
  }

  // Postconditions:

  // Exit:

  return result;
}

// PROTECTED DATA MEMBERS

// PRIVATE DATA MEMBERS


// ===========================================================
// BLOCK VERTICES FACET
// ===========================================================

// PUBLIC DATA MEMBERS

// PROTECTED DATA MEMBERS

void
fiber_bundle::structured_block_3d_crg_interval::
initialize_block_vertices()
{
  // Preconditions:

  require(!block_vertices_initialized());
  require(vertices_initialized());

  // Body:

 // Construct the block vertices id space.

  list_index_space_handle lblock_vertices_id_space =
     list_index_space_state::new_space(*_id_spaces,
                       block_vertices_name(),
                       false);

  _block_vertices_space_id = lblock_vertices_id_space.index();

  // Insert the private data into the id space.

  int I = i_size();
  int J = j_size();
  int K = k_size();

  // (0,0,0); client id 0

  lblock_vertices_id_space.push_back(_vertex_begin);

  // (I,0,0); client id 1.

  lblock_vertices_id_space.push_back(vertex_id(I, 0, 0));

  // (I,J,0); client id 2.

  lblock_vertices_id_space.push_back(vertex_id(I, J, 0));

  // (0,J,0); client id 3;

  lblock_vertices_id_space.push_back(vertex_id(0, J, 0));

  // (0,0,K); client id 4

  lblock_vertices_id_space.push_back(vertex_id(0, 0, K));

  // (I,0,K); client id 5.

  lblock_vertices_id_space.push_back(vertex_id(I, 0, K));

  // (I,J,K); client id 6.

  lblock_vertices_id_space.push_back(vertex_id(I, J, K));

  // (0,J,K); client id 7;

  lblock_vertices_id_space.push_back(vertex_id(0, J, K));

  // The block vertices is initialized.

  _block_vertices_initialized = true;

  // Postconditions:

  ensure(block_vertices_initialized());

  // Exit:

  return;
}

// PRIVATE DATA MEMBERS


// ===========================================================
// IMPLICIT_CRG_INTERVAL FACET
// ===========================================================

// PUBLIC DATA MEMBERS

// PROTECTED DATA MEMBERS

// PRIVATE DATA MEMBERS


// ===========================================================
// CRG_INTERVAL FACET
// ===========================================================

// PUBLIC DATA MEMBERS

// PROTECTED DATA MEMBERS

// PRIVATE DATA MEMBERS


// ===========================================================
// INTERVAL FACET
// ===========================================================

// PUBLIC DATA MEMBERS

void
fiber_bundle::structured_block_3d_crg_interval::
get_size(size_type xi_size, size_type xj_size, size_type xk_size, size_type& result)
{
  // Preconditions:


  // Body:

  size_type lzone_size   = xi_size*xj_size*xk_size;
  size_type lvertex_size = (xi_size + 1)*(xj_size + 1)*(xk_size + 1);

  result = 1 + lzone_size + lvertex_size;

  // Postconditions:


  // Exit:

  return;
}

// PROTECTED DATA MEMBERS

// PRIVATE DATA MEMBERS


// ===========================================================
// COVER SET FACET
// ===========================================================

// PUBLIC DATA MEMBERS

// PROTECTED DATA MEMBERS

void
fiber_bundle::structured_block_3d_crg_interval::
initialize_lower_covers()
{
  // Preconditions:

  require(id_spaces_initialized());
  require(local_id_space_initialized());
  require(!covers_initialized(LOWER));

  // Body:

  // Construct the lower cover of the block.
  //
  // The lower cover of the block is initialized to an id space that contains
  // all the zones.

  _lower_covers_begin =
    explicit_index_space_interval::new_space(*_id_spaces, 1).begin();

  offset_index_space_state::new_space(*_id_spaces,
                      _lower_covers_begin,
                      implicit_cover_name(LOWER, interval_member()),
                      _zone_begin,
                      _zone_size);

  // Construct the lower cover of the zones.
  //
  // The lower cover of the zones is initialized to the nodal connectivity.
  // The user may change the lower cover of the zones by using the explicit
  // overrides in crg_range.  However, the underlineing connectivity id space
  // interval will remain in the id space family.  For that reason, we can
  // set the connectivity begin to beginning of the connectivity id space
  // interval created below.

  _connectivity_begin =
    ijk_connectivity_index_space_interval::new_space(*_id_spaces,
                             _zone_size,
                             _vertex_begin,
                             _j_size,
                             _k_size).begin();

  // Construct the lower cover of the vertices.
  //
  // The lower cover of the vertices is initialized to bottom.

  constant_index_space_interval::new_space(*_id_spaces,
                       _vertex_size,
                       BOTTOM_INDEX);

  // The lower cover is initialized.

  _lower_covers_initialized = true;

  // Posconditions:

  ensure(covers_initialized(LOWER));

  // Exit:

  return;
}

void
fiber_bundle::structured_block_3d_crg_interval::
initialize_upper_covers()
{
  // Preconditions:

  require(id_spaces_initialized());
  require(local_id_space_initialized());
  require(!covers_initialized(UPPER));

  // Body:

  // Construct the upper cover of the block
  //
  // The upper cover of block is initialized to an empty explicit id space.

  _upper_covers_begin =
    explicit_index_space_interval::new_space(*_id_spaces, 1).begin();

  list_index_space_state::new_space(*_id_spaces,
                    _upper_covers_begin,
                    explicit_cover_name(UPPER, interval_member()),
                    false);

  // Construct the upper cover of the zones.
  //
  // The upper cover of the zones is initialized to the block.

  constant_index_space_interval::new_space(*_id_spaces,
                       _zone_size,
                       interval_member());

  // Construct the upper cover of the vertices.
  //
  // The upper cover of the vertices is initialized to the zonal adjacency.
  // The user may change the upper cover of the vertices by using the explicit
  // overrides in crg_range.  However, the underlineing adjacency id space
  // interval will remain in the id space family.  For that reason, we can
  // set the adjacency begin to the beginning of the adjacency id space
  // interval created below.

  _adjacency_begin =
    ijk_adjacency_index_space_interval::new_space(*_id_spaces,
                          _vertex_size,
                          _zone_begin,
                          _i_size,
                          _j_size,
                          _k_size).begin();

  // The upper cover is initialized.

  _upper_covers_initialized = true;

  // Posconditions:

  ensure(covers_initialized(UPPER));

  // Exit:

  return;
}

// PRIVATE DATA MEMBERS


// ===========================================================
// DOF_TUPLE_ID FACET
// ===========================================================

// PUBLIC DATA MEMBERS

void
fiber_bundle::structured_block_3d_crg_interval::
get_dof_tuple_ids(poset_state_handle& xhost,
                  size_type xi_size,
                  size_type xj_size,
                  size_type xk_size,
                  block<pod_index_type>& result)
{
  // Preconditions:


  // Body:

  result.reserve(MEMBER_CLASS_END);
  result.set_ct(MEMBER_CLASS_END);


  result[BLOCK]  = structured_block_3d::new_row_dof_map(xhost, xi_size, xj_size, xk_size, true).hub_pod();
  result[ZONE]   = base_space_member::new_row_dof_map(xhost, "hex_nodes", true).hub_pod();
  result[VERTEX] = base_space_member::new_row_dof_map(xhost, "point", true).hub_pod();

  // Postconditions:


  // Exit:

  return;
}

// PROTECTED DATA MEMBERS

// PRIVATE DATA MEMBERS


// ===========================================================
// PRIVATE_DATA FACET
// ===========================================================

// PUBLIC DATA MEMBERS

void
fiber_bundle::structured_block_3d_crg_interval::
get_private_data(size_type xi_size,
                 size_type xj_size,
                 size_type xk_size,
                 block<pod_index_type>& result)
{
  // Preconditions:

  // Body:

  result.reserve(5);
  result.set_ct(5);

  result[0] = xi_size;
  result[1] = xj_size;
  result[2] = xk_size;
  result[3] = 0;
  result[4] = 0;

  // Postconditions:

  // Exit:

  return;
}

// PROTECTED DATA MEMBERS

sheaf::size_type
fiber_bundle::structured_block_3d_crg_interval::
implicit_private_data_size() const
{
  return 3;
}

void
fiber_bundle::structured_block_3d_crg_interval::
get_implicit_private_data(block<pod_index_type>& xdata) const
{
  // Preconditions:

  // Body:

  xdata.push_back(_i_size);
  xdata.push_back(_j_size);
  xdata.push_back(_k_size);

  // Postconditions:

  ensure(xdata.ct() == implicit_private_data_size());

  // Exit:

  return;
}

void
fiber_bundle::structured_block_3d_crg_interval::
put_implicit_private_data(const block<pod_index_type>& xdata)
{
  // Preconditions:

  // Body:

  _i_size = xdata[0];
  _j_size = xdata[1];
  _k_size = xdata[2];

  _jk_size = _j_size*_k_size;

  _i_vertex_size = _i_size + 1;
  _j_vertex_size = _j_size + 1;
  _k_vertex_size = _k_size + 1;
  _jk_vertex_size = _j_vertex_size*_k_vertex_size;

  _zone_begin = implicit_begin();
  _zone_size = _i_size*_j_size*_k_size;

  _vertex_begin = _zone_begin + _zone_size;
  _vertex_size = _i_vertex_size*_jk_vertex_size;

  // Postconditions:

  ensure(invariant());

  // Exit:

  return;
}

// PRIVATE DATA MEMBERS


// ===========================================================
// FINIALIZE FACET
// ===========================================================

// PUBLIC DATA MEMBERS

void
fiber_bundle::structured_block_3d_crg_interval::
finalize(poset_state_handle& xhost)
{
  // Preconditions:

  require(dynamic_cast<base_space_poset*>(&xhost) != 0);
  require(xhost.state_is_read_accessible());

  // Body:

  base_space_poset& lhost = dynamic_cast<base_space_poset&>(xhost);

  // Initialize the zone id space.

  initialize_zones(lhost);

  // Initialize the vertex id space.

  initialize_vertices(lhost);

  // Initialize block vertices id space.

  initialize_block_vertices();

  // Initialize the cover id spaces.

  initialize_covers();

  // Now this can be inserted in the standard subposets (d-cells, etc).

  lhost.insert_interval_in_standard_subposets(*this);

  // Insert the vertices into the upper cover of bottom.

  xhost.append_upper_cover_of_bottom(_vertex_begin,
                     _vertex_begin + _vertex_size);

  homogeneous_block_crg_interval::finalize(xhost);

  // Postconditions:

  ensure(invariant());
  ensure(is_initialized());

  // Exit:

  return;
}

// PROTECTED DATA MEMBERS

// PRIVATE DATA MEMBERS


// ===========================================================
// FACTORY FACET
// ===========================================================

// PUBLIC DATA MEMBERS

const std::string&
fiber_bundle::structured_block_3d_crg_interval::
class_name() const
{
  static const string result("structured_block_3d_crg_interval");
  return result;
}

// PROTECTED DATA MEMBERS

// PRIVATE DATA MEMBERS

bool
fiber_bundle::structured_block_3d_crg_interval::
make_prototype()
{
  // Preconditions:


  // Body:

  structured_block_3d_crg_interval* lproto = new structured_block_3d_crg_interval();

  interval_factory().insert_prototype(lproto);

  // Postconditions:


  // Exit:

  return true;
}

// ===========================================================
// ANY FACET
// ===========================================================

// PUBLIC DATA MEMBERS

bool
fiber_bundle::structured_block_3d_crg_interval::
is_ancestor_of(const any* other) const
{

  // Preconditions:

  require(other != 0);

  // Body:

  // True if other conforms to this

  bool result = dynamic_cast<const structured_block_3d_crg_interval*>(other) != 0;

  // Postconditions:

  return result;
}

fiber_bundle::structured_block_3d_crg_interval*
fiber_bundle::structured_block_3d_crg_interval::
clone() const
{
  // Preconditions:

  // Body:

  structured_block_3d_crg_interval* result = new structured_block_3d_crg_interval();

  // Postconditions:

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

  // Exit:

  return result;
}

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

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

    disable_invariant_check();

    // Must satisfy base class invariant

    invariance(homogeneous_block_crg_interval::invariant());

    // Invariances for this class:

    invariance(dof_tuple_ids_initialized() ? is_valid(block_dof_tuple_id()) : true);
    invariance(dof_tuple_ids_initialized() ? is_valid(zone_dof_tuple_id()) : true);
    invariance(dof_tuple_ids_initialized() ? is_valid(vertex_dof_tuple_id()) : true);

    // Finished, turn invariant checking back on.

    enable_invariant_check();
  }

  // Exit

  return result;
}

// PROTECTED DATA MEMBERS

// PRIVATE DATA MEMBERS


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