space.hpp

// Copyright (C) 2011-2012 by the BEM++ Authors
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

#ifndef bempp_space_hpp
#define bempp_space_hpp

#include "space_identifier.hpp"

#include "../common/common.hpp"
#include "bempp/common/config_trilinos.hpp"


#include "../common/bounding_box.hpp"
#include "../common/not_implemented_error.hpp"
#include "../common/deprecated.hpp"
#include "../common/shared_ptr.hpp"
#include "../common/types.hpp"
#include "../fiber/basis.hpp"
#include "../fiber/collection_of_basis_transformations.hpp"
#include "../fiber/scalar_traits.hpp"

#include "../common/armadillo_fwd.hpp"
#include <vector>

namespace Fiber
{

template <typename ValueType> class BasisData;
template <typename CoordinateType> class GeometricalData;
} // namespace Fiber

namespace Bempp
{

class Grid;
class GridView;
class GeometryFactory;
template <int codim> class Entity;
template <int codim> class EntityPointer;
template <typename ValueType> class DiscreteSparseBoundaryOperator;
template <typename ValueType> class DiscreteBoundaryOperator;
enum DofType
{
    GLOBAL_DOFS, FLAT_LOCAL_DOFS
};

template <typename BasisFunctionType>
class Space
{
public:
    typedef typename Fiber::ScalarTraits<BasisFunctionType>::RealType CoordinateType;
    typedef typename Fiber::ScalarTraits<BasisFunctionType>::ComplexType ComplexType;
    typedef Fiber::CollectionOfShapesetTransformations<CoordinateType>
    CollectionOfShapesetTransformations;
    typedef Fiber::CollectionOfBasisTransformations<CoordinateType>
    CollectionOfBasisTransformations;

    // A grid reference is necessary because e.g. when setting the element
    // variant it is necessary to check whether the element is triangular
    // or quadrilateral. Also, requests for element refinement should probably
    // be made via Space rather than via Grid.
    explicit Space(const shared_ptr<const Grid>& grid);

    Space(const Space<BasisFunctionType>& other);

    virtual ~Space();

    Space<BasisFunctionType>& operator=(const Space<BasisFunctionType>& other);


    virtual shared_ptr<const Space<BasisFunctionType> > discontinuousSpace(
        const shared_ptr<const Space<BasisFunctionType> >& self) const = 0;

    virtual bool isDiscontinuous() const = 0;

    virtual bool isBarycentric() const = 0;

    virtual int domainDimension() const = 0;

    virtual int codomainDimension() const = 0;

    shared_ptr<const Grid> grid() const { return m_grid; }

    virtual BEMPP_DEPRECATED const Fiber::Basis<BasisFunctionType>& basis(
            const Entity<0>& element) const {
        // It might be good to print a deprecation warning
        return dynamic_cast<const Fiber::Basis<BasisFunctionType>& >(
                    shapeset(element));
    }

    virtual const Fiber::Shapeset<BasisFunctionType>& shapeset(
            const Entity<0>& element) const {
        throw NotImplementedError(
                    "Space::shapeset(): not implemented.\nNote that the "
                    "Space::basis() function has been renamed to shapeset(). "
                    "If you have implemented basis() in a subclass of Space, "
                    "please implement shapeset() instead.");
    }

    virtual BEMPP_DEPRECATED const CollectionOfBasisTransformations&
    shapeFunctionValue() const {
        return dynamic_cast<const CollectionOfBasisTransformations&>(
                    basisFunctionValue());
    }

    virtual shared_ptr<const Space<BasisFunctionType> > barycentricSpace(
            const shared_ptr<const Space<BasisFunctionType> >& self) const;

    unsigned int level() const {return m_level; }

    int gridDimension() const;

    int worldDimension() const;

    const GridView& gridView() const;

    virtual const CollectionOfShapesetTransformations&
    basisFunctionValue() const {
        throw NotImplementedError(
                    "Space::basisFunctionValue(): not implemented.\n"
                    "Note that the Space::shapeFunctionValue() function has "
                    "been renamed to basisFunctionValue(). If you have "
                    "implemented shapeFunctionValue() in a subclass of Space, "
                    "please implement basisFunctionValue() instead.");
    }

    virtual void setElementVariant(const Entity<0>& element, ElementVariant variant) = 0;

    virtual ElementVariant elementVariant(const Entity<0>& element) const = 0;

    shared_ptr<GeometryFactory> elementGeometryFactory() const {
        return m_elementGeometryFactory;
    }

    // additional functions for e.g. increasing polynomial order of all elements
    // ...

    BEMPP_DEPRECATED void assignDofs();

    BEMPP_DEPRECATED bool dofsAssigned() const;

    virtual size_t flatLocalDofCount() const = 0;

    virtual size_t globalDofCount() const = 0;

    virtual void getGlobalDofs(const Entity<0>& element,
                               std::vector<GlobalDofIndex>& dofs) const;

    virtual void getGlobalDofs(const Entity<0>& element,
                               std::vector<GlobalDofIndex>& dofs,
                               std::vector<BasisFunctionType>& localDofWeights) const;

    virtual bool gridIsIdentical(const Space<BasisFunctionType>& other) const;

    virtual SpaceIdentifier spaceIdentifier() const = 0;

    virtual bool spaceIsCompatible(const Space<BasisFunctionType>& other) const = 0;

    virtual void global2localDofs(
            const std::vector<GlobalDofIndex>& globalDofs,
            std::vector<std::vector<LocalDof> >& localDofs) const;

    virtual void global2localDofs(
            const std::vector<GlobalDofIndex>& globalDofs,
            std::vector<std::vector<LocalDof> >& localDofs,
            std::vector<std::vector<BasisFunctionType> >& localDofWeights) const;

    virtual void flatLocal2localDofs(
            const std::vector<FlatLocalDofIndex>& flatLocalDofs,
            std::vector<LocalDof>& localDofs) const = 0;

    virtual void getGlobalDofInterpolationPoints(
            arma::Mat<CoordinateType>& points) const {
        throw NotImplementedError(
                    "Space::getGlobalDofInterpolationPoints(): not implemented");
    }

    virtual void getNormalsAtGlobalDofInterpolationPoints(
            arma::Mat<CoordinateType>& normals) const {
        throw NotImplementedError(
                    "Space::getNormalsAtGlobalDofInterpolationPoints(): not implemented");
    }

    virtual void getGlobalDofInterpolationDirections(
            arma::Mat<CoordinateType>& directions) const {
        throw NotImplementedError(
                    "Space::getGlobalDofInterpolationDirections(): not implemented");
    }

    // These functions are used only by the ACA assembler.
    // For the moment, Point will always be 3D, independently from the
    // actual dimension of the space. Once Ahmed's bemcluster is made dimension-
    // independent, we may come up with a more elegant solution.
    virtual void getGlobalDofBoundingBoxes(
            std::vector<BoundingBox<CoordinateType> >& boundingBoxes) const {
        throw NotImplementedError("Space::getGlobalDofBoundingBoxes(): "
                                 "implementation missing");
    }

    virtual void getFlatLocalDofBoundingBoxes(
            std::vector<BoundingBox<CoordinateType> >& boundingBoxes) const {
        throw NotImplementedError("Space::getFlatLocalDofBoundingBoxes(): "
                                 "implementation missing");
    }

    virtual void getGlobalDofPositions(
            std::vector<Point3D<CoordinateType> >& positions) const = 0;

    virtual void getFlatLocalDofPositions(
            std::vector<Point3D<CoordinateType> >& positions) const = 0;

    virtual void getGlobalDofNormals(
            std::vector<Point3D<CoordinateType> >& normals) const {
        throw NotImplementedError("Space::getGlobalDofNormals(): not implemented");
    }

    virtual void getFlatLocalDofNormals(
            std::vector<Point3D<CoordinateType> >& normals) const {
        throw NotImplementedError("Space::getFlatLocalDofNormals(): not implemented");
    }

    BEMPP_DEPRECATED virtual void dumpClusterIds(
            const char* fileName,
            const std::vector<unsigned int>& clusterIdsOfGlobalDofs) const = 0;

    virtual void dumpClusterIdsEx(
            const char* fileName,
            const std::vector<unsigned int>& clusterIdsOfGlobalDofs,
            DofType dofType) const;
private:
    shared_ptr<const Grid> m_grid;
    shared_ptr<GeometryFactory> m_elementGeometryFactory;
    unsigned int m_level;
    std::auto_ptr<GridView> m_view;
};

template <typename BasisFunctionType>
void getAllShapesets(const Space<BasisFunctionType>& space,
        std::vector<const Fiber::Shapeset<BasisFunctionType>*>& shapesets);

template <typename BasisFunctionType>
void BEMPP_DEPRECATED getAllBases(const Space<BasisFunctionType>& space,
        std::vector<const Fiber::Basis<BasisFunctionType>*>& bases);

template <typename BasisFunctionType>
int maximumShapesetOrder(const Space<BasisFunctionType>& space);

#ifdef WITH_TRILINOS
template <typename BasisFunctionType, typename ResultType>
shared_ptr<DiscreteSparseBoundaryOperator<ResultType> >
constructOperatorMappingGlobalToFlatLocalDofs(const Space<BasisFunctionType>& space);

template <typename BasisFunctionType, typename ResultType>
shared_ptr<DiscreteSparseBoundaryOperator<ResultType> >
constructOperatorMappingFlatLocalToGlobalDofs(const Space<BasisFunctionType>& space);
#endif // WITH_TRILINOS

} //namespace Bempp

#endif