utility_types.hh

Go to the documentation of this file.

/*
    @@@@@@@@  @@           @@@@@@   @@@@@@@@ @@
   /@@/////  /@@          @@////@@ @@////// /@@
   /@@       /@@  @@@@@  @@    // /@@       /@@
   /@@@@@@@  /@@ @@///@@/@@       /@@@@@@@@@/@@
   /@@////   /@@/@@@@@@@/@@       ////////@@/@@
   /@@       /@@/@@//// //@@    @@       /@@/@@
   /@@       @@@//@@@@@@ //@@@@@@  @@@@@@@@ /@@
   //       ///  //////   //////  ////////  //

   Copyright (c) 2016, Triad National Security, LLC
   All rights reserved.
                                                                              */
#pragma once

#if !defined(__FLECSI_PRIVATE__)
#error Do not include this file directly!
#endif

#include "flecsi/util/typeify.hh"

namespace flecsi {
namespace topo {

//----------------------------------------------------------------------------//
// Type creation utilities to create C++ types from size_t ids.
//----------------------------------------------------------------------------//

template<size_t TOPOLOGICAL_DIMENSION>
using topological_dimension = util::typeify<size_t, TOPOLOGICAL_DIMENSION>;

template<size_t TOPOLOGICAL_DOMAIN>
using topological_domain = util::typeify<size_t, TOPOLOGICAL_DOMAIN>;

template<size_t INDEX_SUBSPACE>
using index_subspace = util::typeify<size_t, INDEX_SUBSPACE>;

//----------------------------------------------------------------------------//
// Simple Types.
//----------------------------------------------------------------------------//

using id_vector_t = std::vector<util::id_t>;
using connection_vector_t = std::vector<id_vector_t>;

// Hash type use for mappings in building topology connectivity

struct id_vector_hash_t {
  size_t operator()(const id_vector_t & v) const {
    size_t h = 0;
    for(util::id_t id : v) {
      h |= static_cast<size_t>(id.local_id());
    } // for

    return h;
  } // operator()

}; // struct id_vector_hash_t

// Map type used when building the topology connectivities.

using id_vector_map_t =
  std::unordered_map<id_vector_t, util::id_t, id_vector_hash_t>;

// The second topology vector holds the offsets into to from dimension

using index_vector_t = std::vector<size_t>;
//-----------------------------------------------------------------//
//-----------------------------------------------------------------//

class entity_base_
{
public:
  using id_t = util::id_t;
};

template<size_t NUM_DOMAINS>
class entity_base : public entity_base_
{
public:
  ~entity_base() {}

  //-----------------------------------------------------------------//
  //-----------------------------------------------------------------//
  template<size_t DOM = 0>
  id_t global_id() const {
    return ids_[DOM];
  } // id

  id_t global_id(size_t domain) const {
    return ids_[domain];
  } // id

  template<size_t DOM = 0>
  size_t id() const {
    return ids_[DOM].entity();
  } // id

  size_t id(size_t domain) const {
    return ids_[domain].entity();
  } // id

  template<size_t DOM = 0>
  uint16_t info() const {
    return ids_[DOM] >> 48;
  } // info

  //-----------------------------------------------------------------//
  //-----------------------------------------------------------------//
  template<size_t DOM = 0>
  void set_global_id(const id_t & id) {
    ids_[DOM] = id;
  } // id

  static constexpr size_t get_dim_(size_t meshDim, size_t dim) {
    return dim > meshDim ? meshDim : dim;
  } // get_dim_

protected:
  template<size_t DOM = 0>
  void set_info(uint16_t info) {
    ids_[DOM] = (uint64_t(info) << 48) | ids_[DOM];
  } // set_info

private:
  std::array<id_t, NUM_DOMAINS> ids_;

}; // class entity_base

//-----------------------------------------------------------------//
//-----------------------------------------------------------------//
template<size_t NUM_DOMAINS>
using entity_vector_t = std::vector<entity_base<NUM_DOMAINS> *>;

} // namespace topo
} // namespace flecsi