pmesh.hpp

Go to the documentation of this file.

// Copyright (c) 2010, Lawrence Livermore National Security, LLC. Produced at
// the Lawrence Livermore National Laboratory. LLNL-CODE-443211. All Rights
// reserved. See file COPYRIGHT for details.
//
// This file is part of the MFEM library. For more information and source code
// availability see http://mfem.org.
//
// MFEM is free software; you can redistribute it and/or modify it under the
// terms of the GNU Lesser General Public License (as published by the Free
// Software Foundation) version 2.1 dated February 1999.

#ifndef MFEM_PMESH
#define MFEM_PMESH

#include "../config/config.hpp"

#ifdef MFEM_USE_MPI

#include "../general/communication.hpp"
#include "mesh.hpp"
#include "pncmesh.hpp"
#include <iostream>

namespace mfem
{

class ParMesh : public Mesh
{
protected:
   ParMesh() : MyComm(0), NRanks(0), MyRank(-1),
      have_face_nbr_data(false), pncmesh(NULL) {}

   MPI_Comm MyComm;
   int NRanks, MyRank;

   Array<Element *> shared_edges;
   Array<Element *> shared_faces;

   Table group_svert;
   Table group_sedge;
   Table group_sface;

   Array<int> svert_lvert;
   Array<int> sedge_ledge;
   Array<int> sface_lface;

   ParMesh(const ParNCMesh &pncmesh);

   int GetEdgeSplittings(Element *edge, const DSTable &v_to_v, int *middle);
   int GetFaceSplittings(Element *face, const DSTable &v_to_v, int *middle);

   void GetFaceNbrElementTransformation(
      int i, IsoparametricTransformation *ElTr);

   ElementTransformation* GetGhostFaceTransformation(
      FaceElementTransformations* FETr, int face_type, int face_geom);

   virtual void QuadUniformRefinement();

   virtual void HexUniformRefinement();

   virtual void NURBSUniformRefinement();

   virtual void LocalRefinement(const Array<int> &marked_el, int type = 3);

   virtual void NonconformingRefinement(const Array<Refinement> &refinements,
                                        int nc_limit = 0);

   virtual bool NonconformingDerefinement(Array<double> &elem_error,
                                          double threshold, int nc_limit = 0,
                                          int op = 1);
   void DeleteFaceNbrData();

   bool WantSkipSharedMaster(const NCMesh::Master &master) const;

public:
   explicit ParMesh(const ParMesh &pmesh, bool copy_nodes = true);

   ParMesh(MPI_Comm comm, Mesh &mesh, int *partitioning_ = NULL,
           int part_method = 1);

   MPI_Comm GetComm() const { return MyComm; }
   int GetNRanks() const { return NRanks; }
   int GetMyRank() const { return MyRank; }

   GroupTopology gtopo;

   // Face-neighbor elements and vertices
   bool             have_face_nbr_data;
   Array<int>       face_nbr_group;
   Array<int>       face_nbr_elements_offset;
   Array<int>       face_nbr_vertices_offset;
   Array<Element *> face_nbr_elements;
   Array<Vertex>    face_nbr_vertices;
   // Local face-neighbor elements and vertices ordered by face-neighbor
   Table            send_face_nbr_elements;
   Table            send_face_nbr_vertices;

   ParNCMesh* pncmesh;

   int GetNGroups() { return gtopo.NGroups(); }

   // next 6 methods do not work for the 'local' group 0
   int GroupNVertices(int group) { return group_svert.RowSize(group-1); }
   int GroupNEdges(int group)    { return group_sedge.RowSize(group-1); }
   int GroupNFaces(int group)    { return group_sface.RowSize(group-1); }

   int GroupVertex(int group, int i)
   { return svert_lvert[group_svert.GetJ()[group_svert.GetI()[group-1]+i]]; }
   void GroupEdge(int group, int i, int &edge, int &o);
   void GroupFace(int group, int i, int &face, int &o);

   void GenerateOffsets(int N, HYPRE_Int loc_sizes[],
                        Array<HYPRE_Int> *offsets[]) const;

   void ExchangeFaceNbrData();
   void ExchangeFaceNbrNodes();

   int GetNFaceNeighbors() const { return face_nbr_group.Size(); }
   int GetFaceNbrGroup(int fn) const { return face_nbr_group[fn]; }
   int GetFaceNbrRank(int fn) const;

   Table *GetFaceToAllElementTable() const;

   FaceElementTransformations *
   GetSharedFaceTransformations(int sf, bool fill2 = true);

   int GetNSharedFaces() const;

   int GetSharedFace(int sface) const;

   virtual void ReorientTetMesh();

   virtual long ReduceInt(int value) const;

   void RefineGroups(const DSTable &v_to_v, int *middle);

   void Rebalance();

   virtual void Print(std::ostream &out = std::cout) const;

   virtual void PrintXG(std::ostream &out = std::cout) const;

   void PrintAsOne(std::ostream &out = std::cout);

   void PrintAsOneXG(std::ostream &out = std::cout);

   virtual void PrintInfo(std::ostream &out = std::cout);

   virtual ~ParMesh();
};

}

#endif // MFEM_USE_MPI

#endif