Topology_Utils.h

Go to the documentation of this file.

//*****************************************************************//
//    Albany 2.0:  Copyright 2012 Sandia Corporation               //
//    This Software is released under the BSD license detailed     //
//    in the file "license.txt" in the top-level Albany directory  //
//*****************************************************************//

#if !defined(LCM_Topology_Utils_h)
#define LCM_Topology_Utils_h

#include "Topology_Types.h"

namespace LCM {

inline
void
display_connectivity(BulkData * bulk_data, EntityRank cell_rank)
{
  // Create a list of element entities
  EntityVector
  elements;

  stk::mesh::get_entities(*(bulk_data), cell_rank, elements);

  typedef EntityVector::size_type size_type;

  // Loop over the elements
  size_type const
  number_of_elements = elements.size();

  for (size_type i = 0; i < number_of_elements; ++i) {

    PairIterRelation
    relations = elements[i]->relations(NODE_RANK);

    EntityId const
    element_id = elements[i]->identifier();

    std::cout << std::setw(16) << element_id << ":";

    size_t const
    nodes_per_element = relations.size();

    for (size_t j = 0; j < nodes_per_element; ++j) {

      Entity const &
      node = *(relations[j].entity());

      EntityId const
      node_id = node.identifier();

      std::cout << std::setw(16) << node_id;
    }

    std::cout << '\n';
  }

  return;
}

inline
void
display_relation(Entity const & entity)
{
  std::cout << "Relations for entity (identifier,rank): ";
  std::cout << entity.identifier() << "," << entity.entity_rank();
  std::cout << '\n';

  PairIterRelation
  relations = entity.relations();

  for (size_t i = 0; i < relations.size(); ++i) {
    std::cout << "entity:\t";
    std::cout << relations[i].entity()->identifier() << ",";
    std::cout << relations[i].entity()->entity_rank();
    std::cout << "\tlocal id: ";
    std::cout << relations[i].identifier();
    std::cout << '\n';
  }
  return;
}

inline
void
display_relation(Entity const & entity, EntityRank const rank)
{
  std::cout << "Relations of rank ";
  std::cout << rank;
  std::cout << " for entity (identifier,rank): ";
  std::cout << entity.identifier() << "," << entity.entity_rank();
  std::cout << '\n';

  PairIterRelation
  relations = entity.relations(rank);

  for (size_t i = 0; i < relations.size(); ++i) {
    std::cout << "entity:\t";
    std::cout << relations[i].entity()->identifier() << ",";
    std::cout << relations[i].entity()->entity_rank();
    std::cout << "\tlocal id: ";
    std::cout << relations[i].identifier();
    std::cout << '\n';
  }
  return;
}

inline
bool
is_one_down(Entity const & entity, Relation const & relation)
{
  EntityRank const
  entity_rank = entity.entity_rank();

  EntityRank const
  target_rank = relation.entity_rank();

  return entity_rank - target_rank == 1;
}

inline
bool
is_one_up(Entity const & entity, Relation const & relation)
{
  EntityRank const
  entity_rank = entity.entity_rank();

  EntityRank const
  target_rank = relation.entity_rank();

  return target_rank - entity_rank == 1;
}

inline
bool
is_graph_relation(Entity const & source_entity, Relation const & relation)
{
  return is_one_down(source_entity, relation);
}

inline
bool
is_needed_for_stk(
    Entity const & source_entity,
    Relation const & relation,
    EntityRank const cell_rank)
{
  EntityRank const
  source_rank = source_entity.entity_rank();

  EntityRank const
  target_rank = relation.entity_rank();

  return (source_rank == cell_rank) && (target_rank == NODE_RANK);
}

// TODO: returning PairIterRelation(*relation_vector) below
// stores tenporary iterators to relation_vector that are
// invalid outside the scope of these functions.
// Perhaps change to returning the vector itself but this will require
// change of interface for functions that return relations.

inline
PairIterRelation
relations_all(Entity const & entity)
{
  return entity.relations();
}

inline
PairIterRelation
relations_one_up(Entity const & entity)
{
  return entity.relations(entity.entity_rank() + 1);
}

inline
PairIterRelation
relations_one_down(Entity const & entity)
{
  return entity.relations(entity.entity_rank() - 1);
}

inline
std::string
parallelize_string(std::string const & string)
{
  std::ostringstream
  oss;

  oss << string;

  int const
  number_processors = Teuchos::GlobalMPISession::getNProc();

  if (number_processors > 1) {

    int const
    number_digits = static_cast<int>(std::log10(number_processors));

    int const
    processor_id = Teuchos::GlobalMPISession::getRank();

    oss << "-";
    oss << std::setfill('0') << std::setw(number_digits) << processor_id;
  }

  return oss.str();
}

}// namespace LCM

#endif // LCM_Topology_Utils_h