Subgraph.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_Subgraph_h)
#define LCM_Topology_Subgraph_h

#include <stk_mesh/base/FieldData.hpp>

#include "Topology_Types.h"

namespace LCM {

class Subgraph: public Graph {
public:

  Subgraph(RCP<Albany::AbstractSTKMeshStruct> stk_mesh_struct,
      std::set<EntityKey>::iterator first_vertex,
      std::set<EntityKey>::iterator last_vertex,
      std::set<stkEdge>::iterator first_edge,
      std::set<stkEdge>::iterator last_edge);

  EntityKey
  localToGlobal(Vertex local_vertex);

  Vertex
  globalToLocal(EntityKey global_vertex_key);

  Vertex
  addVertex(EntityRank vertex_rank);

  Vertex
  cloneVertex(Vertex & old_vertex);

  void
  removeVertex(Vertex const vertex);

  std::pair<Edge, bool>
  addEdge(
      EdgeId const edge_id,
      Vertex const local_source_vertex,
      Vertex const local_target_vertex);

  void
  removeEdge(
      Vertex const & local_source_vertex,
      Vertex const & local_target_vertex);

  EntityRank
  getVertexRank(Vertex const vertex);

  EdgeId
  getEdgeId(Edge const edge);

  typedef std::map<Vertex, size_t> ComponentMap;
  void
  testArticulationPoint(
      Vertex const input_vertex,
      size_t & number_components,
      ComponentMap & component_map);

  void
  cloneBoundaryEntity(Vertex & vertex, Vertex & newVertex,
      std::map<EntityKey, bool> & entity_open);

  Vertex
  cloneBoundaryEntity(Vertex vertex);

  std::map<Entity*, Entity*>
  splitArticulationPoint(Vertex vertex,
      std::map<EntityKey, bool> & entity_open);

  std::map<Entity*, Entity*>
  splitArticulationPoint(Vertex vertex);

  void
  cloneOutEdges(Vertex old_vertex, Vertex new_vertex);

  void
  outputToGraphviz(std::string & gviz_output,
      std::map<EntityKey, bool> entity_open);

  size_t const
  getSpaceDimension() {return static_cast<size_t>(getSTKMeshStruct()->numDim);}

  RCP<Albany::AbstractSTKMeshStruct> &
  getSTKMeshStruct()
  {return stk_mesh_struct_;}

  BulkData *
  getBulkData()
  {return stk_mesh_struct_->bulkData;}

  stk::mesh::fem::FEMMetaData *
  getMetaData()
  {return stk_mesh_struct_->metaData;}

  EntityRank const
  getCellRank() {return getMetaData()->element_rank();}

  EntityRank const
  getBoundaryRank()
  {
    assert(getCellRank() > 0);
    return getCellRank() - 1;
  }

  IntScalarFieldType &
  getFractureState()
  {return *(stk_mesh_struct_->getFieldContainer()->getFractureState());}

  //
  // Set fracture state. Do nothing for cells (elements).
  //
  void
  setFractureState(Entity const & e, FractureState const fs)
  {
    if (e.entity_rank() < getCellRank()) {
      *(stk::mesh::field_data(getFractureState(), e)) = static_cast<int>(fs);
    }
  }

  //
  // Get fracture state. Return CLOSED for cells (elements).
  //
  FractureState
  getFractureState(Entity const & e)
  {
    return e.entity_rank() >= getCellRank() ?
    CLOSED :
    static_cast<FractureState>(*(stk::mesh::field_data(getFractureState(), e)));
  }

  bool
  isInternal(Entity const & e) {

    assert(e.entity_rank() == getBoundaryRank());

    Vertex
    vertex = globalToLocal(e.key());

    boost::graph_traits<Graph>::degree_size_type
    number_in_edges = boost::in_degree(vertex, *this);

    assert(number_in_edges == 1 || number_in_edges == 2);

    return number_in_edges == 2;
  }

  bool
  isOpen(Entity const & e) {
    return getFractureState(e) == OPEN;
  }

  bool
  isInternalAndOpen(Entity const & e) {
    return isInternal(e) == true && isOpen(e) == true;
  }

private:

  Subgraph(const Subgraph&);

  Subgraph& operator=(const Subgraph&);

  RCP<Albany::AbstractSTKMeshStruct> stk_mesh_struct_;

  std::map<Vertex, EntityKey> local_global_vertex_map_;

  std::map<EntityKey, Vertex> global_local_vertex_map_;

  void
  communicate_and_create_shared_entities(Entity   & node,
      EntityKey   new_node_key);

  void
  bcast_key(unsigned root, EntityKey&   node_key);


};
// class Subgraph

}// namespace LCM

#endif // LCM_Topology_Subgraph_h