unstructured_block_builder.h

//
// 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.
//

// Interface for class UNSTRUCTURED_BLOCK_BUILDER

#ifndef UNSTRUCTURED_BLOCK_BUILDER_H
#define UNSTRUCTURED_BLOCK_BUILDER_H

#ifndef SHEAF_DLL_SPEC_H
#include "SheafSystem/sheaf_dll_spec.h"
#endif

#ifndef BASE_SPACE_POSET_H
#include "SheafSystem/base_space_poset.h"
#endif

#ifndef BLOCK_H
#include "SheafSystem/block.h"
#endif

#ifndef STD_UNORDERED_MAP_H
#include "SheafSystem/std_unordered_map.h"
#endif

#ifndef STD_STACK_H
#include "SheafSystem/std_stack.h"
#endif

#ifndef STD_LIST_H
#include "SheafSystem/std_list.h"
#endif

#ifndef SUBPOSET_H
#include "SheafSystem/subposet.h"
#endif

#ifndef ZN_TO_BOOL_H
#include "SheafSystem/zn_to_bool.h"
#endif

namespace sheaf
{

class poset_member;
class triorder_iterator;

template<class T>
class ragged_array;

}

namespace fiber_bundle
{

class base_space_member;
class unstructured_block;
 
  using namespace sheaf;





class SHEAF_DLL_SPEC unstructured_block_builder
{

public:

  virtual bool  invariant() const;

  unstructured_block_builder();

  ~unstructured_block_builder();

  typedef std::list<pod_index_type> list_type;

 //$$TYPE_SAFE_IDS_TODO: Change glue_map_type to use scoped_index..

  typedef unordered::unordered_map<int, int> glue_map_type;

  //$$TYPE_SAFE_IDS_ISSUE: Remove when no longer used?

  void build_block_pa(const base_space_member* xtemplate,
                      const int* xglue,
                      size_type xglue_ub,
                      unstructured_block* result,
                      bool xcompute_upper_cover,
                      bool xauto_access);

  void build_block_pa(const base_space_member* xtemplate,
                      const scoped_index* xglue,
                      size_type xglue_ub,
                      unstructured_block* result,
                      bool xcompute_upper_cover,
                      bool xauto_access);

  static void build_block_decomposition(base_space_poset* xmesh,
                                        const block<int>& xblock_ids,
                                        const block<int>& xblock_dbs,
                                        const block<poset_path>& xblock_local_cell_paths,
                                        const ragged_array<int>& xblock_nbrs,
                                        bool xauto_access);

  static void build_block_decomposition(base_space_poset* xmesh,
                                        const block<int>& xblock_ids,
                                        int xblock_db,
                                        const poset_path& xblock_local_cell_path,
                                        const ragged_array<int>& xblock_nbrs,
                                        bool xauto_access);

  static bool name_mode();

  static void put_name_mode(bool xmode);

private:

  base_space_member* _template;

  base_space_poset _template_host;

  unordered::unordered_map<int, int> _template_map;

  int _template_db;

  void initialize_template(const base_space_member* xtemplate);

  int* _glue;

  int _glue_ub;

  int _glue_index;

  void initialize_glue(const int* xglue, int xglue_ub);

  unstructured_block* _block;

  base_space_poset _block_host;

  subposet _block_mbrs_sp;

  block<scoped_index> _block_mbrs;

  void initialize_block(unstructured_block* result);

  int _boundary_db;

  bool _template_has_boundary;

  subposet _boundary_jims;

  subposet _block_boundaries;

  void initialize_boundary();

  block<scoped_index> _dof_tuple_id_map;

  void initialize_dof_maps();

  void make_block(bool xcompute_upper_cover);

  std::stack<list_type*> _used_covers;

  std::stack<list_type*> _free_covers;

  void previsit_action(const triorder_iterator& xtmplt_itr, bool& xtruncate);

  void link_action(const triorder_iterator& xtmplt_itr);

  void postvisit_action(const triorder_iterator& xtmplt_itr);

  void make_boundary();

  void clean_up();

  void update_boundary(pod_index_type xhub_id);

  void update_boundary(const scoped_index& xid);

  static bool _name_mode;

  static void make_block_neighborhoods(base_space_poset* xmesh,
                                       const block<int>& xblock_ids,
                                       const ragged_array<int>& xblock_nbrs,
                                       const index_space_handle& xid_space);

};

} // namespace fiber_bundle

#endif // ifndef UNSTRUCTURED_BLOCK_BUILDER_H