fespace.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_FESPACE
#define MFEM_FESPACE

#include "../config/config.hpp"
#include "../linalg/sparsemat.hpp"
#include "../mesh/mesh.hpp"
#include "fe_coll.hpp"
#include <iostream>

namespace mfem
{

/* Class FiniteElementSpace - responsible for providing FEM view of the mesh
   (mainly managing the set of degrees of freedom). */

class Ordering
{
public:
   enum Type { byNODES, byVDIM };
};

typedef int RefinementType;

class RefinementData
{
public:
   RefinementType type;
   int num_fine_elems;
   int num_fine_dofs;
   Table * fl_to_fc;
   DenseMatrix * I;
   ~RefinementData() { delete fl_to_fc; delete I;}
};

class NURBSExtension;

class FiniteElementSpace
{
protected:
   Mesh *mesh;

   int vdim;

   int ndofs;

   int ordering;

   const FiniteElementCollection *fec;
   int nvdofs, nedofs, nfdofs, nbdofs;
   int *fdofs, *bdofs;

   Array<RefinementData *> RefData;

   Table *elem_dof;
   Table *bdrElem_dof;
   Array<int> dof_elem_array, dof_ldof_array;

   NURBSExtension *NURBSext;
   int own_ext;

   // Matrix representing the prolongation from the global conforming dofs to
   // a set of intermediate partially conforming dofs, e.g. the dofs associated
   // with a "cut" space on a non-conforming mesh.
   SparseMatrix *cP;
   // Conforming restriction matrix such that cR.cP=I.
   SparseMatrix *cR;

   void UpdateNURBS();

   void Constructor();
   void Destructor();   // does not destroy 'RefData'

   /* Create a FE space stealing all data (except RefData) from the
      given FE space. This is used in SaveUpdate() */
   FiniteElementSpace(FiniteElementSpace &);

   void ConstructRefinementData(int k, int cdofs, RefinementType type);

   DenseMatrix *LocalInterpolation(int k, int cdofs,
                                   RefinementType type,
                                   Array<int> &rows);

   SparseMatrix *NC_GlobalRestrictionMatrix(FiniteElementSpace* cfes,
                                            NCMesh* ncmesh);

   void GetEdgeFaceDofs(int type, int index, Array<int> &dofs);

   void GetConformingInterpolation();

   void MakeVDimMatrix(SparseMatrix &mat) const;

public:
   FiniteElementSpace(Mesh *m, const FiniteElementCollection *f,
                      int vdim = 1, int ordering = Ordering::byNODES);

   inline Mesh *GetMesh() const { return mesh; }

   NURBSExtension *GetNURBSext() { return NURBSext; }
   NURBSExtension *StealNURBSext();

   bool Conforming() const { return mesh->ncmesh == NULL; }
   bool Nonconforming() const { return mesh->ncmesh != NULL; }

   const SparseMatrix *GetConformingProlongation();
   const SparseMatrix *GetConformingRestriction();
   virtual const SparseMatrix *GetRestrictionMatrix()
   { return GetConformingRestriction(); }

   inline int GetVDim() const { return vdim; }

   int GetOrder(int i) const;
   int GetFaceOrder(int i) const;

   inline int GetNDofs() const { return ndofs; }

   inline int GetVSize() const { return vdim * ndofs; }

   virtual int GetTrueVSize() { return GetConformingVSize(); }

   int GetNConformingDofs();

   int GetConformingVSize() { return vdim * GetNConformingDofs(); }

   inline int GetOrdering() const { return ordering; }

   const FiniteElementCollection *FEColl() const { return fec; }

   int GetNVDofs() const { return nvdofs; }
   int GetNEDofs() const { return nedofs; }
   int GetNFDofs() const { return nfdofs; }

   inline int GetNE() const { return mesh->GetNE(); }

   inline int GetNV() const { return mesh->GetNV(); }

   inline int GetNBE() const { return mesh->GetNBE(); }

   inline int GetElementType(int i) const
   { return mesh->GetElementType(i); }

   inline void GetElementVertices(int i, Array<int> &vertices) const
   { mesh->GetElementVertices(i, vertices); }

   inline int GetBdrElementType(int i) const
   { return mesh->GetBdrElementType(i); }

   ElementTransformation *GetElementTransformation(int i) const
   { return mesh->GetElementTransformation(i); }

   void GetElementTransformation(int i, IsoparametricTransformation *ElTr)
   { mesh->GetElementTransformation(i, ElTr); }

   ElementTransformation *GetBdrElementTransformation(int i) const
   { return mesh->GetBdrElementTransformation(i); }

   int GetAttribute(int i) const { return mesh->GetAttribute(i); }

   int GetBdrAttribute(int i) const { return mesh->GetBdrAttribute(i); }

   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;

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

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

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

   int GetNumElementInteriorDofs(int i) const
   { return fec->DofForGeometry(mesh->GetElementBaseGeometry(i)); }

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

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

   void DofsToVDofs(int vd, Array<int> &dofs, int ndofs = -1) const;

   int DofToVDof(int dof, int vd, int ndofs = -1) const;

   int VDofToDof(int vdof) const
   { return (ordering == Ordering::byNODES) ? (vdof%ndofs) : (vdof/vdim); }

   static void AdjustVDofs(Array<int> &vdofs);

   void GetElementVDofs(int i, Array<int> &vdofs) const;

   void GetBdrElementVDofs(int i, Array<int> &vdofs) const;

   void GetFaceVDofs(int i, Array<int> &vdofs) const;

   void GetEdgeVDofs(int i, Array<int> &vdofs) const;

   void GetVertexVDofs(int i, Array<int> &vdofs) const;

   void GetElementInteriorVDofs(int i, Array<int> &vdofs) const;

   void GetEdgeInteriorVDofs(int i, Array<int> &vdofs) const;

   void BuildElementToDofTable();

   void BuildDofToArrays();

   const Table &GetElementToDofTable() const { return *elem_dof; }
   const Table &GetBdrElementToDofTable() const { return *bdrElem_dof; }

   int GetElementForDof(int i) { return dof_elem_array[i]; }
   int GetLocalDofForDof(int i) { return dof_ldof_array[i]; }

   const FiniteElement *GetFE(int i) const;

   const FiniteElement *GetBE(int i) const;

   const FiniteElement *GetFaceElement(int i) const;

   const FiniteElement *GetEdgeElement(int i) const;

   const FiniteElement *GetTraceElement(int i, int geom_type) const;

   SparseMatrix *GlobalRestrictionMatrix(FiniteElementSpace *cfes,
                                         int one_vdim = -1);

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

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

   static void MarkerToList(const Array<int> &marker, Array<int> &list);
   static void ListToMarker(const Array<int> &list, int marker_size,
                            Array<int> &marker, int mark_val = -1);

   void ConvertToConformingVDofs(const Array<int> &dofs, Array<int> &cdofs);

   void ConvertFromConformingVDofs(const Array<int> &cdofs, Array<int> &dofs);

   void EliminateEssentialBCFromGRM(FiniteElementSpace *cfes,
                                    Array<int> &bdr_attr_is_ess,
                                    SparseMatrix *R);

   SparseMatrix *GlobalRestrictionMatrix(FiniteElementSpace *cfes,
                                         Array<int> &bdr_attr_is_ess,
                                         int one_vdim = -1);

   SparseMatrix *D2C_GlobalRestrictionMatrix(FiniteElementSpace *cfes);

   SparseMatrix *D2Const_GlobalRestrictionMatrix(FiniteElementSpace *cfes);

   SparseMatrix *H2L_GlobalRestrictionMatrix(FiniteElementSpace *lfes);

   virtual void Update();

   virtual void UpdateAndInterpolate(int num_grid_fns, ...);

   void UpdateAndInterpolate(GridFunction* gf) { UpdateAndInterpolate(1, gf); }

   virtual FiniteElementSpace *SaveUpdate();

   void Save (std::ostream &out) const;

   virtual ~FiniteElementSpace();
};

}

#endif