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 Ordering
{
public:
   enum Type { byNODES, byVDIM };

   template <Type Ord>
   static inline int Map(int ndofs, int vdim, int dof, int vd);

   template <Type Ord>
   static void DofsToVDofs(int ndofs, int vdim, Array<int> &dofs);
};

template <> inline int
Ordering::Map<Ordering::byNODES>(int ndofs, int vdim, int dof, int vd)
{
   MFEM_ASSERT(dof < ndofs && -1-dof < ndofs && 0 <= vd && vd < vdim, "");
   return (dof >= 0) ? dof+ndofs*vd : dof-ndofs*vd;
}

template <> inline int
Ordering::Map<Ordering::byVDIM>(int ndofs, int vdim, int dof, int vd)
{
   MFEM_ASSERT(dof < ndofs && -1-dof < ndofs && 0 <= vd && vd < vdim, "");
   return (dof >= 0) ? vd+vdim*dof : -1-(vd+vdim*(-1-dof));
}


class NURBSExtension;

class FiniteElementSpace
{
protected:
   Mesh *mesh;

   const FiniteElementCollection *fec;

   int vdim;

   Ordering::Type ordering;

   int ndofs;

   int nvdofs, nedofs, nfdofs, nbdofs;
   int *fdofs, *bdofs;

   mutable Table *elem_dof;
   Table *bdrElem_dof;

   Array<int> dof_elem_array, dof_ldof_array;

   NURBSExtension *NURBSext;
   int own_ext;

   SparseMatrix *cP;
   SparseMatrix *cR;
   bool cP_is_set;

   Operator *T;
   bool own_T;

   long sequence; // should match Mesh::GetSequence

   void UpdateNURBS();

   void Construct();
   void Destroy();

   void BuildElementToDofTable() const;

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

   void GetConformingInterpolation();

   void MakeVDimMatrix(SparseMatrix &mat) const;

   SparseMatrix* RefinementMatrix(int old_ndofs, const Table* old_elem_dof);

   void GetLocalDerefinementMatrices(int geom, const CoarseFineTransformations &dt,
                                     DenseTensor &localR);

   SparseMatrix* DerefinementMatrix(int old_ndofs, const Table* old_elem_dof);


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

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

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

   bool Conforming() const { return mesh->Conforming(); }
   bool Nonconforming() const { return mesh->Nonconforming(); }

   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 Ordering::Type 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, int ndofs = -1) 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 RebuildElementToDofTable();

   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;

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

   SparseMatrix *D2C_GlobalRestrictionMatrix(FiniteElementSpace *cfes);

   SparseMatrix *D2Const_GlobalRestrictionMatrix(FiniteElementSpace *cfes);

   SparseMatrix *H2L_GlobalRestrictionMatrix(FiniteElementSpace *lfes);

   virtual void Update(bool want_transform = true);

   const Operator* GetUpdateOperator() { Update(); return T; }

   void SetUpdateOperatorOwner(bool own) { own_T = own; }

   virtual void UpdatesFinished() { if (own_T) { delete T; } T = NULL; }

   long GetSequence() const { return sequence; }

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

   virtual ~FiniteElementSpace();
};

}

#endif