Zoltan2
Zoltan2_HyperGraphModel.hpp
Go to the documentation of this file.
1 // @HEADER
2 //
3 // ***********************************************************************
4 //
5 // Zoltan2: A package of combinatorial algorithms for scientific computing
6 // Copyright 2012 Sandia Corporation
7 //
8 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
9 // the U.S. Government retains certain rights in this software.
10 //
11 // Redistribution and use in source and binary forms, with or without
12 // modification, are permitted provided that the following conditions are
13 // met:
14 //
15 // 1. Redistributions of source code must retain the above copyright
16 // notice, this list of conditions and the following disclaimer.
17 //
18 // 2. Redistributions in binary form must reproduce the above copyright
19 // notice, this list of conditions and the following disclaimer in the
20 // documentation and/or other materials provided with the distribution.
21 //
22 // 3. Neither the name of the Corporation nor the names of the
23 // contributors may be used to endorse or promote products derived from
24 // this software without specific prior written permission.
25 //
26 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
27 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
30 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 //
38 // Questions? Contact Karen Devine (kddevin@sandia.gov)
39 // Erik Boman (egboman@sandia.gov)
40 // Siva Rajamanickam (srajama@sandia.gov)
41 //
42 // ***********************************************************************
43 //
44 // @HEADER
45 
50 #ifndef _ZOLTAN2_HYPERGRAPHMODEL_HPP_
51 #define _ZOLTAN2_HYPERGRAPHMODEL_HPP_
52 
53 #include <Zoltan2_Model.hpp>
54 #include <Zoltan2_ModelHelpers.hpp>
55 #include <Zoltan2_InputTraits.hpp>
57 #include <Zoltan2_GraphAdapter.hpp>
60 #include <Zoltan2_StridedData.hpp>
61 #include <Zoltan2_MeshAdapter.hpp>
62 
63 #include <vector>
64 #include <unordered_map>
65 #include <queue>
66 #include <Teuchos_Hashtable.hpp>
67 
68 namespace Zoltan2 {
69 
77 };
78 
80 
89 template <typename Adapter>
90 class HyperGraphModel : public Model<Adapter>
91 {
92 public:
93 
94 #ifndef DOXYGEN_SHOULD_SKIP_THIS
95  typedef typename Adapter::scalar_t scalar_t;
96  typedef typename Adapter::gno_t gno_t;
97  typedef typename Adapter::lno_t lno_t;
98  typedef typename Adapter::node_t node_t;
99  typedef typename Adapter::user_t user_t;
100  typedef typename Adapter::userCoord_t userCoord_t;
101  typedef Tpetra::Map<lno_t, gno_t> map_t;
102  typedef StridedData<lno_t, scalar_t> input_t;
103 #endif
104 
107 
120  const RCP<const Environment> &env, const RCP<const Comm<int> > &comm,
121  modelFlag_t &modelFlags, CentricView view)
122  {
123  throw std::runtime_error("Building HyperGraphModel from MatrixAdapter not implemented yet");
124  }
125 
127  const RCP<const Environment> &env, const RCP<const Comm<int> > &comm,
128  modelFlag_t &modelFlags, CentricView view)
129  {
130  throw std::runtime_error("Building HyperGraphModel from GraphAdapter not implemented yet");
131  }
132 
133  HyperGraphModel(const RCP<const MeshAdapter<user_t> > &ia,
134  const RCP<const Environment> &env, const RCP<const Comm<int> > &comm,
135  modelFlag_t &modelflags, CentricView view);
136 
138  const RCP<const Environment> &env, const RCP<const Comm<int> > &comm,
139  modelFlag_t &flags, CentricView view)
140  {
141  throw std::runtime_error("cannot build HyperGraphModel from VectorAdapter");
142  }
143 
145  const RCP<const Environment> &env, const RCP<const Comm<int> > &comm,
146  modelFlag_t &flags, CentricView view)
147  {
148  throw std::runtime_error("cannot build HyperGraphModel from IdentifierAdapter");
149  }
150 
151 
154  CentricView getCentricView() const {return view_;}
155 
158  bool areVertexIDsUnique() const {return unique;}
159 
162  size_t getLocalNumVertices() const { return numLocalVertices_; }
163 
166  size_t getLocalNumOwnedVertices() const { return numOwnedVertices_; }
167 
170  size_t getGlobalNumVertices() const { return numGlobalVertices_; }
171 
176  size_t getLocalNumHyperEdges() const { return numLocalEdges_; }
177 
180  size_t getGlobalNumHyperEdges() const { return numGlobalEdges_; }
181 
184  size_t getLocalNumPins() const {return numLocalPins_; }
185 
188  int getNumWeightsPerVertex() const { return numWeightsPerVertex_; }
189 
192  int getNumWeightsPerHyperEdge() const { return nWeightsPerEdge_; }
193 
196  int getNumWeightesPerPin() const {return nWeightsPerPin_;}
197 
200  int getCoordinateDim() const { return vCoordDim_; }
201 
210  ArrayView<const gno_t> &Ids,
211  ArrayView<input_t> &wgts) const
212  {
213  size_t nv = gids_.size();
214  Ids = gids_(0, nv);
215  wgts = vWeights_.view(0, numWeightsPerVertex_);
216  return nv;
217  }
218 
224  size_t getVertexCoords(ArrayView<input_t> &xyz) const
225  {
226  size_t nv = gids_.size();
227  xyz = vCoords_.view(0, vCoordDim_);
228  return nv;
229  }
230 
237  size_t getOwnedList(ArrayView<bool> &isOwner) const
238  {
239  size_t nv = isOwner_.size();
240  isOwner = isOwner_(0, nv);
241  return nv;
242  }
243 
251  void getVertexMaps(Teuchos::RCP<const map_t>& copiesMap, Teuchos::RCP<const map_t>& onetooneMap) const {
252  copiesMap = mapWithCopies;
253  onetooneMap = oneToOneMap;
254  }
255 
263  size_t getEdgeList(
264  ArrayView<const gno_t> &Ids,
265  ArrayView<input_t> &wgts) const
266  {
267  size_t nv = edgeGids_.size();
268  Ids = edgeGids_(0, nv);
269  wgts = eWeights_.view(0, nWeightsPerEdge_);
270  return nv;
271  }
272 
285  size_t getPinList( ArrayView<const gno_t> &pinIds,
286  ArrayView<const lno_t> &offsets,
287  ArrayView<input_t> &wgts) const
288  {
289  pinIds = pinGids_(0, numLocalPins_);
290  offsets = offsets_.view(0, offsets_.size());
291  wgts = pWeights_.view(0, nWeightsPerPin_);
292  return pinGids_.size();
293  }
294 
295 
297  // The Model interface.
299 
300  size_t getLocalNumObjects() const { return numLocalVertices_; }
301 
302  size_t getGlobalNumObjects() const { return numGlobalVertices_; }
303 
304 private:
305 
306  struct GhostCell {
307  lno_t lid; //Assumes lno_t is signed (-1 corresponds to not on this process)
308  gno_t gid;
309  unsigned int dist;
310  GhostCell(lno_t l,gno_t g, unsigned int d) {lid=l;gid=g;dist=d;}
311  bool operator<(const struct GhostCell& other) const {return dist>other.dist;}
312  };
313  template <typename AdapterWithCoords>
314  void shared_GetVertexCoords(const AdapterWithCoords *ia);
315 
316 
317  const RCP<const Environment > env_;
318  const RCP<const Comm<int> > comm_;
319 
320  CentricView view_;
321  bool unique;
322  ArrayRCP<const gno_t> gids_; // vertices of input graph
323 
324  ArrayRCP<bool> isOwner_;
325 
326  int numWeightsPerVertex_;
327  ArrayRCP<input_t> vWeights_;
328 
329  int vCoordDim_;
330  ArrayRCP<input_t> vCoords_;
331 
332  ArrayRCP<const gno_t> edgeGids_;
333 
334  int nWeightsPerEdge_;
335  ArrayRCP<input_t> eWeights_;
336 
337  ArrayRCP<const gno_t> pinGids_;
338  ArrayRCP<const lno_t> offsets_;
339 
340  int nWeightsPerPin_;
341  ArrayRCP<input_t> pWeights_;
342 
343  // For convenience
344 
345  size_t numLocalVertices_;
346  size_t numOwnedVertices_;
347  size_t numGlobalVertices_;
348  size_t numLocalEdges_;
349  size_t numGlobalEdges_;
350  size_t numLocalPins_;
351 
352  // For unique mapping
353  Teuchos::RCP<const map_t> mapWithCopies;
354  Teuchos::RCP<const map_t> oneToOneMap;
355 
356  // For debugging
357  void print();
358 
359 };
360 
361 
363 
365 //TODO get the weights hyperedges
366 //GFD Do we need weights for pins too?
367 template <typename Adapter>
369  const RCP<const MeshAdapter<user_t> > &ia,
370  const RCP<const Environment> &env,
371  const RCP<const Comm<int> > &comm,
372  modelFlag_t &modelFlags,
373  CentricView view):
374  env_(env),
375  comm_(comm),
376  view_(view),
377  gids_(),
378  isOwner_(),
379  numWeightsPerVertex_(0),
380  vWeights_(),
381  vCoordDim_(0),
382  vCoords_(),
383  edgeGids_(),
384  nWeightsPerEdge_(0),
385  eWeights_(),
386  pinGids_(),
387  offsets_(),
388  nWeightsPerPin_(0),
389  pWeights_(),
390  numLocalVertices_(0),
391  numGlobalVertices_(0),
392  numLocalEdges_(0),
393  numGlobalEdges_(0),
394  numLocalPins_(0)
395 {
396  env_->timerStart(MACRO_TIMERS, "HyperGraphModel constructed from MeshAdapter");
397  //Model Type is either traditional or ghosting
398  // Traditional:
399  // vertices == ia->getPrimaryEntityType()
400  // hyperedges == ia->getAdjacencyEntityType()
401  // pins == first adjacency between primary and adjacency types
402  // Ghosting:
403  // vertices == ia->getPrimaryEntityType()
404  // hyperedges == ia->getPrimaryEntityType()
405  // pins == k layers of second adjacency from primary through second adjacency types
406  std::string model_type("traditional");
407  const Teuchos::ParameterList &pl = env->getParameters();
408  const Teuchos::ParameterEntry *pe2 = pl.getEntryPtr("hypergraph_model_type");
409  if (pe2){
410  model_type = pe2->getValue<std::string>(&model_type);
411  }
412 
413  // Get the hypergraph types from adapter
414  Zoltan2::MeshEntityType primaryEType = ia->getPrimaryEntityType();
415  Zoltan2::MeshEntityType adjacencyEType = ia->getAdjacencyEntityType();
416 
417  // Get the IDs of the primary entity type; these are hypergraph vertices
418  gno_t const *vtxIds=NULL;
419  try {
420  numLocalVertices_ = ia->getLocalNumOf(primaryEType);
421  ia->getIDsViewOf(primaryEType, vtxIds);
422  size_t maxId = *(std::max_element(vtxIds,vtxIds+numLocalVertices_));
423  reduceAll(*comm_,Teuchos::REDUCE_MAX,1,&maxId,&numGlobalVertices_);
424  }
426 
427  gids_ = arcp<const gno_t>(vtxIds, 0, numLocalVertices_, false);
428 
429  //A mapping from gids to lids for efficiency
430  std::unordered_map<gno_t,lno_t> lid_mapping;
431  for (size_t i=0;i<numLocalVertices_;i++)
432  lid_mapping[gids_[i]]=i;
433 
434  // Define owners for each hypergraph vertex using Tpetra
435  // one to one map. This defines each hypergraph vertex to
436  // one process in the case that the adapter has copied
437  // primary entity types
438  //If the mesh adapter knows the entities are unique we can optimize out the ownership
439  unique = ia->areEntityIDsUnique(ia->getPrimaryEntityType());
440  numOwnedVertices_=numLocalVertices_;
441  isOwner_ = ArrayRCP<bool>(numLocalVertices_,true);
442  if (!unique) {
443 
444  Tpetra::global_size_t numGlobalCoords =
445  Teuchos::OrdinalTraits<Tpetra::global_size_t>::invalid();
446  mapWithCopies = rcp(new map_t(numGlobalCoords, gids_(), 0, comm));
447  oneToOneMap = Tpetra::createOneToOne<lno_t, gno_t>(mapWithCopies);
448 
449  numOwnedVertices_=oneToOneMap->getNodeNumElements();
450  for (size_t i=0;i<numLocalVertices_;i++) {
451  isOwner_[i] = oneToOneMap->isNodeGlobalElement(gids_[i]);
452  }
453  }
454 
455 
456  if (model_type=="traditional") {
457  // Traditional: Get the IDs of the adjacency entity type;
458  // these are hypergraph hyperedges
459 
460  gno_t const *edgeIds=NULL;
461  try {
462  numLocalEdges_ = ia->getLocalNumOf(adjacencyEType);
463  ia->getIDsViewOf(adjacencyEType, edgeIds);
464  size_t maxId = *(std::max_element(edgeIds,edgeIds+numLocalEdges_));
465  reduceAll(*comm_,Teuchos::REDUCE_MAX,1,&maxId,&numGlobalEdges_);
466  }
468 
469  edgeGids_ = arcp<const gno_t>(edgeIds, 0, numLocalEdges_, false);
470  }
471  else if (model_type=="ghosting") {
472  // Ghosting: Use the vertices as the hyperedges as well
473  numLocalEdges_ = numLocalVertices_;
474  edgeGids_ = arcp<const gno_t>(vtxIds, 0, numLocalVertices_, false);
475  numGlobalEdges_ = numGlobalVertices_;
476  }
477 
478  //Define the entity types to use for the pins based on the centric view
479  Zoltan2::MeshEntityType primaryPinType = primaryEType;
480  Zoltan2::MeshEntityType adjacencyPinType = adjacencyEType;
481  size_t numPrimaryPins = numLocalVertices_;
482  if (view_==HYPEREDGE_CENTRIC) {
483  primaryPinType = adjacencyEType;
484  adjacencyPinType = primaryEType;
485  numPrimaryPins = numLocalEdges_;
486  }
487  if (model_type=="traditional") {
488  //Get the pins from using the traditional method of first adjacency
489  gno_t const *nborIds=NULL;
490  lno_t const *offsets=NULL;
491 
492  try {
493  ia->getAdjsView(primaryPinType,adjacencyPinType,offsets,nborIds);
494  }
496 
497  numLocalPins_ = offsets[numPrimaryPins];
498 
499  pinGids_ = arcp<const gno_t>(nborIds, 0, numLocalPins_, false);
500  offsets_ = arcp<const lno_t>(offsets, 0, numPrimaryPins + 1, false);
501  }
502  else if (model_type=="ghosting") {
503  // set the view to either since it doesn't matter
504  // vertices==hyperedges
505  view_ = VERTEX_CENTRIC;
506  // unique set of global ids for the ghosts
507  typedef std::set<gno_t> ghost_t;
508 
509  // mapping from global id to the set of ghosts
510  typedef std::unordered_map<gno_t,ghost_t> ghost_map_t;
511 
512  primaryPinType=primaryEType;
513  adjacencyPinType =ia->getSecondAdjacencyEntityType();
514 
515  // number of layers of ghosting to do
516  unsigned int layers=2;
517  const Teuchos::ParameterEntry *pe3 = pl.getEntryPtr("ghost_layers");
518  if (pe3){
519  int l;
520  l = pe3->getValue<int>(&l);
521  layers = static_cast<unsigned int>(l);
522  }
523 
524  typedef int nonzero_t; // adjacency matrix doesn't need scalar_t
525  typedef Tpetra::CrsMatrix<nonzero_t,lno_t,gno_t,node_t> sparse_matrix_type;
526 
527  // Get an adjacency matrix representing the graph on the mesh
528  // using second adjacencies. If second adjacencies are not
529  // provided build the matrix from first adjacencies.
530  RCP<sparse_matrix_type> secondAdj;
531  if (!ia->avail2ndAdjs(primaryPinType,adjacencyPinType)) {
532  secondAdj=Zoltan2::get2ndAdjsMatFromAdjs<user_t>(ia,comm_,primaryPinType, adjacencyPinType);
533  }
534  else {
535  const lno_t* offsets;
536  const gno_t* adjacencyIds;
537  ia->get2ndAdjsView(primaryPinType,adjacencyPinType,offsets,adjacencyIds);
538  if (unique) {
539  Tpetra::global_size_t numGlobalCoords =
540  Teuchos::OrdinalTraits<Tpetra::global_size_t>::invalid();
541  oneToOneMap = rcp(new map_t(numGlobalCoords, gids_(), 0, comm));
542  }
543  secondAdj = rcp(new sparse_matrix_type(oneToOneMap,0));
544  for (size_t i=0; i<numLocalVertices_;i++) {
545  if (!isOwner_[i])
546  continue;
547  gno_t row = gids_[i];
548  lno_t num_adjs = offsets[i+1]-offsets[i];
549  ArrayRCP<nonzero_t> ones(num_adjs,1);
550  ArrayRCP<const gno_t> cols(adjacencyIds,offsets[i],num_adjs,false);
551  secondAdj->insertGlobalValues(row,cols(),ones());
552  }
553  secondAdj->fillComplete();
554  }
555 
556  //The mapping of the ghosts per hypergraph vertex
557  ghost_map_t ghosts;
558 
559  //Read the 1 layer ghosts from the second adjacency matrix
560  Array<gno_t> Indices;
561  Array<nonzero_t> Values;
562  for (unsigned int i=0;i<numLocalEdges_;i++) {
563  if (!isOwner_[i])
564  continue;
565  gno_t gid = edgeGids_[i];
566  size_t NumEntries = secondAdj->getNumEntriesInGlobalRow (gid);
567  Indices.resize (NumEntries);
568  Values.resize (NumEntries);
569  secondAdj->getGlobalRowCopy(gid,Indices(),Values(),NumEntries);
570  for (size_t j = 0; j < NumEntries; ++j) {
571  if(gid != Indices[j]) {
572  ghosts[gid].insert(Indices[j]);
573  }
574  }
575  }
576 
577  // The ith power of the second adjacency matrix is the ith layer of ghosts.
578  // Here we compute the ith power of the matrix and add the ith layer ghosts
579  // from the new matrix.
580  RCP<sparse_matrix_type> mat_old = secondAdj;
581  for (unsigned int i=1;i<layers;i++) {
582  RCP<sparse_matrix_type> mat_new =
583  rcp (new sparse_matrix_type(secondAdj->getRowMap(),0));
584  Tpetra::MatrixMatrix::Multiply(*mat_old,false,*secondAdj,false,*mat_new);
585  for (unsigned int j=0;j<numLocalEdges_;j++) {
586  if (!isOwner_[j])
587  continue;
588  gno_t gid = edgeGids_[j];
589  size_t NumEntries = mat_new->getNumEntriesInGlobalRow (gid);
590  Indices.resize(NumEntries);
591  Values.resize(NumEntries);
592  mat_new->getGlobalRowCopy(gid,Indices(),Values(),NumEntries);
593  for (size_t k = 0; k < NumEntries; ++k)
594  if(gid != Indices[k])
595  ghosts[gid].insert(Indices[k]);
596 
597  }
598  mat_old = mat_new;
599  }
600 
601  //Make the pins from the ghosts
602  for (size_t i=0;i<numLocalVertices_;i++) {//for each local entity
603  numLocalPins_+=ghosts[gids_[i]].size();
604  }
605  gno_t* temp_pins = new gno_t[numLocalPins_];
606  lno_t* temp_offsets = new lno_t[numLocalVertices_+1];
607  gno_t j=0;
608  for (size_t i=0;i<numLocalVertices_;i++) {//for each local entity
609  temp_offsets[i]=j;
610  if (!isOwner_[i])
611  continue;
612  typename ghost_t::iterator itr;
613  for (itr=ghosts[gids_[i]].begin();itr!=ghosts[gids_[i]].end();itr++) { //for each ghost of this entity
614  temp_pins[j]=*itr;
615  j++;
616 
617  }
618  }
619  temp_offsets[numLocalVertices_]=numLocalPins_;
620  pinGids_ = arcp<const gno_t>(temp_pins,0,numLocalPins_,true);
621  offsets_ = arcp<const lno_t>(temp_offsets,0,numLocalVertices_+1,true);
622 
623  //==============================Ghosting complete=================================
624  }
625 
626 
627  //Get the vertex weights
628  numWeightsPerVertex_ = ia->getNumWeightsPerID();
629 
630  if (numWeightsPerVertex_ > 0){
631  input_t *weightInfo = new input_t [numWeightsPerVertex_];
632  env_->localMemoryAssertion(__FILE__, __LINE__, numWeightsPerVertex_,
633  weightInfo);
634 
635  for (int idx=0; idx < numWeightsPerVertex_; idx++){
636  bool useNumNZ = ia->useDegreeAsWeight(idx);
637  if (useNumNZ){
638  scalar_t *wgts = new scalar_t [numLocalVertices_];
639  env_->localMemoryAssertion(__FILE__, __LINE__, numLocalVertices_, wgts);
640  ArrayRCP<const scalar_t> wgtArray =
641  arcp(wgts, 0, numLocalVertices_, true);
642  for (size_t i=0; i < numLocalVertices_; i++){
643  wgts[i] = offsets_[i+1] - offsets_[i];
644  }
645  weightInfo[idx] = input_t(wgtArray, 1);
646  }
647  else{
648  const scalar_t *weights=NULL;
649  int stride=0;
650  ia->getWeightsView(weights, stride, idx);
651  ArrayRCP<const scalar_t> wgtArray = arcp(weights, 0,
652  stride*numLocalVertices_,
653  false);
654  weightInfo[idx] = input_t(wgtArray, stride);
655  }
656  }
657 
658  vWeights_ = arcp<input_t>(weightInfo, 0, numWeightsPerVertex_, true);
659  }
660 
661  //TODO get the weights for edges, and pins(?)
662 
663  //Get the vertex coordinates from the primary types
664  typedef MeshAdapter<user_t> adapterWithCoords_t;
665  shared_GetVertexCoords<adapterWithCoords_t>(&(*ia));
666 
667  env_->timerStop(MACRO_TIMERS, "HyperGraphModel constructed from MeshAdapter");
668  print();
669 }
670 
672 
673 template <typename Adapter>
674 template <typename AdapterWithCoords>
675 void HyperGraphModel<Adapter>::shared_GetVertexCoords(const AdapterWithCoords *ia)
676 {
677  // get Vertex coordinates from input adapter
678 
679  vCoordDim_ = ia->getDimension();
680 
681  if (vCoordDim_ > 0){
682  input_t *coordInfo = new input_t [vCoordDim_];
683  env_->localMemoryAssertion(__FILE__, __LINE__, vCoordDim_, coordInfo);
684 
685  for (int dim=0; dim < vCoordDim_; dim++){
686  const scalar_t *coords=NULL;
687  int stride=0;
688  ia->getCoordinatesView(coords, stride, dim);
689  ArrayRCP<const scalar_t> coordArray = arcp(coords, 0,
690  stride*numLocalVertices_,
691  false);
692  coordInfo[dim] = input_t(coordArray, stride);
693  }
694 
695  vCoords_ = arcp<input_t>(coordInfo, 0, vCoordDim_, true);
696  }
697 }
698 
700 template <typename Adapter>
702 {
703  //only prints the model if debug status is verbose
704  if (env_->getDebugLevel() < VERBOSE_DETAILED_STATUS)
705  return;
706 
707  std::ostream *os = env_->getDebugOStream();
708 
709  int me = comm_->getRank();
710  std::string fn(" ");
711 
712  *os << me << fn
713  << " Nvtx " << gids_.size()
714  << " Nedge " << edgeGids_.size()
715  << " NPins " << numLocalPins_
716  << " NVWgt " << numWeightsPerVertex_
717  << " NEWgt " << nWeightsPerEdge_
718  << " NPWgt " << nWeightsPerPin_
719  << " CDim " << vCoordDim_
720  << std::endl;
721 
722  for (lno_t i = 0; i < gids_.size(); i++) {
723  *os << me << fn << i << " VTXGID " << gids_[i]<<" isOwner: "<<isOwner_[i];
724  if (numWeightsPerVertex_==1)
725  *os << " weight: " << vWeights_[0][i];
726  if (view_==VERTEX_CENTRIC) {
727  *os <<" pins:";
728  for (lno_t j = offsets_[i]; j< offsets_[i+1];j++)
729  *os <<" "<<pinGids_[j];
730  }
731  *os << std::endl;
732  }
733  for (lno_t i = 0; i<edgeGids_.size();i++) {
734  *os << me << fn << i << " EDGEGID " << edgeGids_[i];
735  if (view_==HYPEREDGE_CENTRIC) {
736  *os <<":";
737  for (lno_t j = offsets_[i]; j< offsets_[i+1];j++)
738  *os <<" "<<pinGids_[j];
739  }
740  *os << std::endl;
741  }
742  if (vCoordDim_) {
743  for (lno_t i = 0; i < gids_.size(); i++) {
744  *os << me << fn << i << " COORDS " << gids_[i] << ": ";
745  for (int j = 0; j < vCoordDim_; j++)
746  *os << vCoords_[j][i] << " ";
747  *os << std::endl;
748  }
749  }
750  else
751  *os << me << fn << "NO COORDINATES AVAIL " << std::endl;
752 }
753 
754 } // namespace Zoltan2
755 
756 
757 #endif
758 
Time an algorithm (or other entity) as a whole.
IdentifierAdapter defines the interface for identifiers.
#define Z2_FORWARD_EXCEPTIONS
Forward an exception back through call stack.
MatrixAdapter defines the adapter interface for matrices.
Defines the Model interface.
size_t getVertexCoords(ArrayView< input_t > &xyz) const
Sets pointers to this process&#39; vertex coordinates, if available.
GraphAdapter defines the interface for graph-based user data.
size_t global_size_t
int getNumWeightsPerHyperEdge() const
Returns the number (0 or greater) of weights per edge.
Defines the MeshAdapter interface.
CentricView getCentricView() const
Returns the centric view of the hypergraph.
MeshAdapter defines the interface for mesh input.
std::bitset< NUM_MODEL_FLAGS > modelFlag_t
size_t getPinList(ArrayView< const gno_t > &pinIds, ArrayView< const lno_t > &offsets, ArrayView< input_t > &wgts) const
Sets pointers to this process&#39; pins global Ids based on the centric view given by getCentricView() ...
HyperGraphModel(const RCP< const VectorAdapter< userCoord_t > > &ia, const RCP< const Environment > &env, const RCP< const Comm< int > > &comm, modelFlag_t &flags, CentricView view)
size_t getLocalNumObjects() const
Return the local number of objects.
Defines the IdentifierAdapter interface.
Defines the VectorAdapter interface.
HyperGraphModel(const RCP< const MatrixAdapter< user_t, userCoord_t > > &ia, const RCP< const Environment > &env, const RCP< const Comm< int > > &comm, modelFlag_t &modelFlags, CentricView view)
Constructor.
static ArrayRCP< ArrayRCP< zscalar_t > > weights
HyperGraphModel(const RCP< const GraphAdapter< user_t, userCoord_t > > &ia, const RCP< const Environment > &env, const RCP< const Comm< int > > &comm, modelFlag_t &modelFlags, CentricView view)
size_t getOwnedList(ArrayView< bool > &isOwner) const
Sets pointer to the ownership of this processes vertices.
Defines helper functions for use in the models.
bool areVertexIDsUnique() const
Returns true if the vertices are unique false otherwise.
size_t getEdgeList(ArrayView< const gno_t > &Ids, ArrayView< input_t > &wgts) const
Sets pointers to this process&#39; hyperedge Ids and their weights.
int getNumWeightesPerPin() const
Returns the number (0 or greater) of weights per pins.
size_t getLocalNumHyperEdges() const
Returns the number of hyper edges on this process. These are all hyper edges that have an adjacency t...
VectorAdapter defines the interface for vector input.
The StridedData class manages lists of weights or coordinates.
Traits for application input objects.
size_t getGlobalNumObjects() const
Return the global number of objects.
size_t getLocalNumPins() const
Returns the local number of pins.
size_t getVertexList(ArrayView< const gno_t > &Ids, ArrayView< input_t > &wgts) const
Sets pointers to this process&#39; vertex Ids and their weights.
int getCoordinateDim() const
Returns the dimension (0 to 3) of vertex coordinates.
CentricView
Enumerate the views for the pins: HYPEREDGE_CENTRIC: pins are the global ids of the vertices as seen ...
MeshEntityType
Enumerate entity types for meshes: Regions, Faces, Edges, or Vertices.
Defines the MatrixAdapter interface.
The base class for all model classes.
size_t getGlobalNumHyperEdges() const
Returns the global number hyper edges.
size_t getLocalNumVertices() const
Returns the number vertices on this process.
Defines the GraphAdapter interface.
include more detail about sub-steps
HyperGraphModel defines the interface required for hyper graph models.
size_t getGlobalNumVertices() const
Returns the global number vertices.
void getVertexMaps(Teuchos::RCP< const map_t > &copiesMap, Teuchos::RCP< const map_t > &onetooneMap) const
Sets pointers to the vertex map with copies and the vertex map without copies Note: the pointers will...
int getNumWeightsPerVertex() const
Returns the number (0 or greater) of weights per vertex.
size_t getLocalNumOwnedVertices() const
Returns the number vertices on this process that are owned.
This file defines the StridedData class.
HyperGraphModel(const RCP< const IdentifierAdapter< user_t > > &ia, const RCP< const Environment > &env, const RCP< const Comm< int > > &comm, modelFlag_t &flags, CentricView view)