pfespace.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_PFESPACE
#define MFEM_PFESPACE

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

#ifdef MFEM_USE_MPI

#include "../linalg/hypre.hpp"
#include "../mesh/pmesh.hpp"
#include "../mesh/nurbs.hpp"
#include "fespace.hpp"

namespace mfem
{

class ParFiniteElementSpace : public FiniteElementSpace
{
private:
   MPI_Comm MyComm;
   int NRanks, MyRank;

   ParMesh *pmesh;

   GroupCommunicator *gcomm;

   int ltdof_size;

   Array<int> ldof_group;

   Array<int> ldof_ltdof;

   Array<HYPRE_Int> dof_offsets;

   Array<HYPRE_Int> tdof_offsets;

   Array<HYPRE_Int> tdof_nb_offsets;

   Array<HYPRE_Int> old_dof_offsets;

   Array<int> ldof_sign;

   HypreParMatrix *P;

   SparseMatrix *R;

   ParNURBSExtension *pNURBSext()
   { return dynamic_cast<ParNURBSExtension *>(NURBSext); }

   GroupTopology &GetGroupTopo()
   { return (NURBSext) ? pNURBSext()->gtopo : pmesh->gtopo; }

   void Construct();
   void Destroy();

   // ldof_type = 0 : DOFs communicator, otherwise VDOFs communicator
   void GetGroupComm(GroupCommunicator &gcomm, int ldof_type,
                     Array<int> *ldof_sign = NULL);

   void GenerateGlobalOffsets();

   void ConstructTrueDofs();
   void ConstructTrueNURBSDofs();

   void ApplyLDofSigns(Array<int> &dofs) const;

   struct Dependency
   {
      int rank, dof; 
      double coef;
      Dependency(int r, int d, double c) : rank(r), dof(d), coef(c) {}
   };

   struct DepList
   {
      Array<Dependency> list;
      int type; 

      DepList() : type(0) {}

      bool IsTrueDof(int my_rank) const
      { return type == 0 || (type == 1 && list[0].rank == my_rank); }
   };

   void AddSlaveDependencies(DepList deps[], int master_rank,
                             const Array<int> &master_dofs, int master_ndofs,
                             const Array<int> &slave_dofs, DenseMatrix& I);

   void Add1To1Dependencies(DepList deps[], int owner_rank,
                            const Array<int> &owner_dofs, int owner_ndofs,
                            const Array<int> &dependent_dofs);

   void GetDofs(int type, int index, Array<int>& dofs);
   void ReorderFaceDofs(Array<int> &dofs, int orient);

   // Used when the ParMesh is non-conforming, i.e. pmesh->pncmesh != NULL.
   // Constructs the matrices P and R. Determines ltdof_size. Calls
   // GenerateGlobalOffsets(). Constructs ldof_ltdof.
   void GetParallelConformingInterpolation();

   HypreParMatrix* RebalanceMatrix(int old_ndofs,
                                   const Table* old_elem_dof);

   HypreParMatrix* ParallelDerefinementMatrix(int old_ndofs,
                                              const Table *old_elem_dof);

public:
   // Face-neighbor data
   // Number of face-neighbor dofs
   int num_face_nbr_dofs;
   // Face-neighbor-element to face-neighbor dof
   Table face_nbr_element_dof;
   // Face-neighbor to ldof in the face-neighbor numbering
   Table face_nbr_ldof;
   // The global ldof indices of the face-neighbor dofs
   Array<HYPRE_Int> face_nbr_glob_dof_map;
   // Local face-neighbor data: face-neighbor to ldof
   Table send_face_nbr_ldof;

   ParFiniteElementSpace(ParMesh *pm, const FiniteElementCollection *f,
                         int dim = 1, int ordering = Ordering::byNODES);

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

   inline ParMesh *GetParMesh() { return pmesh; }

   int GetDofSign(int i)
   { return NURBSext || Nonconforming() ? 1 : ldof_sign[VDofToDof(i)]; }
   HYPRE_Int *GetDofOffsets()     { return dof_offsets; }
   HYPRE_Int *GetTrueDofOffsets() { return tdof_offsets; }
   HYPRE_Int GlobalVSize()
   { return Dof_TrueDof_Matrix()->GetGlobalNumRows(); }
   HYPRE_Int GlobalTrueVSize()
   { return Dof_TrueDof_Matrix()->GetGlobalNumCols(); }

   virtual int GetTrueVSize() { return ltdof_size; }

   virtual void GetElementDofs(int i, Array<int> &dofs) const;

   virtual void GetBdrElementDofs(int i, Array<int> &dofs) const;

   virtual void GetFaceDofs(int i, Array<int> &dofs) const;

   HypreParMatrix *Dof_TrueDof_Matrix();

   HypreParMatrix *GetPartialConformingInterpolation();

   HypreParVector *NewTrueDofVector()
   { return (new HypreParVector(MyComm,GlobalTrueVSize(),GetTrueDofOffsets()));}

   void DivideByGroupSize(double *vec);

   GroupCommunicator &GroupComm() { return *gcomm; }

   GroupCommunicator *ScalarGroupComm();

   void Synchronize(Array<int> &ldof_marker) const;

   virtual void GetEssentialVDofs(const Array<int> &bdr_attr_is_ess,
                                  Array<int> &ess_dofs) const;

   virtual void GetEssentialTrueDofs(const Array<int> &bdr_attr_is_ess,
                                     Array<int> &ess_tdof_list);

   int GetLocalTDofNumber(int ldof);
   HYPRE_Int GetGlobalTDofNumber(int ldof);
   HYPRE_Int GetGlobalScalarTDofNumber(int sldof);

   HYPRE_Int GetMyDofOffset() const;
   HYPRE_Int GetMyTDofOffset() const;

   virtual const SparseMatrix *GetRestrictionMatrix()
   { if (!R) { Dof_TrueDof_Matrix(); } return R; }

   // Face-neighbor functions
   void ExchangeFaceNbrData();
   int GetFaceNbrVSize() const { return num_face_nbr_dofs; }
   void GetFaceNbrElementVDofs(int i, Array<int> &vdofs) const;
   void GetFaceNbrFaceVDofs(int i, Array<int> &vdofs) const;
   const FiniteElement *GetFaceNbrFE(int i) const;
   const FiniteElement *GetFaceNbrFaceFE(int i) const;
   const HYPRE_Int *GetFaceNbrGlobalDofMap() { return face_nbr_glob_dof_map; }

   void Lose_Dof_TrueDof_Matrix();
   void LoseDofOffsets() { dof_offsets.LoseData(); }
   void LoseTrueDofOffsets() { tdof_offsets.LoseData(); }

   bool Conforming() const { return pmesh->pncmesh == NULL; }
   bool Nonconforming() const { return pmesh->pncmesh != NULL; }

   virtual void Update(bool want_transform = true);

   virtual void UpdatesFinished()
   {
      FiniteElementSpace::UpdatesFinished();
      old_dof_offsets.DeleteAll();
   }

   virtual ~ParFiniteElementSpace() { Destroy(); }

   // Obsolete, kept for backward compatibility
   int TrueVSize() { return ltdof_size; }
};

}

#endif // MFEM_USE_MPI

#endif