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.googlecode.com.
//
// 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

/* 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;

   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);

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

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

   NURBSExtension *GetNURBSext() { return NURBSext; }

   inline int GetVDim() const { return vdim; };

   int GetOrder(int i) const;

   inline int GetNDofs() const { return ndofs; };

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

   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) { return mesh -> GetAttribute(i); };

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

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

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

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

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

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

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

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

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

   int DofToVDof (int dof, int vd) 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> &dofs) const;

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

   void GetFaceVDofs (int iF, Array<int> &dofs) const;

   void GetEdgeVDofs (int iE, Array<int> &dofs) 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; }

   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;

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

   virtual void GetEssentialVDofs(Array<int> &bdr_attr_is_ess,
                                  Array<int> &ess_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 FiniteElementSpace *SaveUpdate();

   void Save (ostream &out) const;

   virtual ~FiniteElementSpace();
};

#endif