---

AbstractFunctionSpace.h

Go to the documentation of this file.

#ifndef ABSTRACTFUNCTIONSPACE_H
#define ABSTRACTFUNCTIONSPACE_H

#include "TSFDefs.h"
#include "CellSet.h"
#include "Expr.h"
#include "Mesh.h"
#include "BasisFamily.h"
#include "TSFHashSet.h"
#include "TSFVectorSpace.h"
#include "TSFVectorType.h"
#include "DistributedDOFMap.h"
#include <string>

namespace Sundance
{
  using namespace TSF;

  using std::string;

  /** \ingroup LowLevelFE
   * An AbstractFunctionSpace describes a discretized function space
   * without reference to the vector type in which the values will be
   * stored. The createSpace() method can produce a type-specific
   * TSFVectorSpace object given a TSFVectorType.
   *
   */

  class AbstractFunctionSpace
    {
    public:
      /** empty ctor for use in container classes */
      AbstractFunctionSpace(){;}

      /** */
      AbstractFunctionSpace(const Mesh& mesh, const Expr& functions,
                            const TSFArray<TSFNonDupArray<CellSet> >& domains);

      /** */
      AbstractFunctionSpace(const Mesh& mesh, const BasisFamily& basis);

      /** */
      AbstractFunctionSpace(const Mesh& mesh, const CellSet& cellSet,
                            const BasisFamily& basis);

      /** */
      AbstractFunctionSpace(const Mesh& mesh, const TSFArray<BasisFamily>& basis);

      /** */
      AbstractFunctionSpace(const Mesh& mesh,
                            const TSFArray<BasisFamily>& basis,
                            const TSFArray<TSFNonDupArray<CellSet> >& domains);

      /** */
      AbstractFunctionSpace(const Mesh& mesh,
                            const TSFArray<BasisFamily>& basis,
                            const TSFArray<CellSet>& domains);

      /** */
      AbstractFunctionSpace(const Mesh& mesh, const CellSet& cellSet,
                            const TSFArray<BasisFamily>& basis);

      /** create a vector space object with a specified vector type */
      TSFVectorSpace createConcreteSpace(const TSFVectorType& vectorType) const ;
      /** create a vector space object with a specified vector type */
      TSFVectorSpace createSundanceSpace(const TSFVectorType& vectorType) const ;

      /** test equality */
      bool operator==(const AbstractFunctionSpace& other) const ;

      /** return the mesh */
      const Mesh& mesh() const {return mesh_;}

      /** return the basis family used by the f-th function */
      const BasisFamily& basis(int f) const {return basis_[f];}

      /** return the list of cell sets on which the f-th function
       * is defined */
      const TSFNonDupArray<CellSet>& domains(int f) const {return domains_[f];}

      /** return the DOF map for this space */
      const TSFSmartPtr<DOFMapBase>& map() const {return map_;}

      /** write to XML */
      XMLObject toXML() const ;

      /** return a hash code for the space */
      int hashCode() const ;

      /** write to a string */
      string toString() const {return "AbstractFunctionSpace";}

      /** return the number of functions */
      int nFunc() const {return basis_.length();}
    private:

      /** */
      void createMap();

      /* */
      int id_;
      /* */
      Mesh mesh_;
      /* */
      TSFArray<BasisFamily> basis_;
      /* */
      TSFArray<TSFNonDupArray<CellSet> > domains_;
      /* */
      TSFSmartPtr<DOFMapBase> map_;

      /* */
      static TSFHashtable<AbstractFunctionSpace, TSFSmartPtr<DOFMapBase> >& existingMaps();

      static int idCounter();
    };

}

namespace TSF
{
  /** \relates AbstractFunctionSpace return hash code for an
   * AbstractFunctionSpace */
  inline int hashCode(const Sundance::AbstractFunctionSpace& space)
    {
      return space.hashCode();
    }

  /** \relates AbstractFunctionSpace write to string */
  inline string toString(const Sundance::AbstractFunctionSpace& space)
    {
      return space.toString();
    }
}
#endif

---

Contact:

Kevin Long (krlong@ca.sandia.gov)


Documentation generated by