FunctionSpace.h

// Copyright (C) 2008-2019 Anders Logg and Garth N. Wells
//
// This file is part of DOLFINx (https://www.fenicsproject.org)
//
// SPDX-License-Identifier:    LGPL-3.0-or-later
 
#pragma once
 
#include <cstddef>
#include <functional>
#include <map>
#include <memory>
#include <vector>
#include <xtensor/xtensor.hpp>
 
namespace dolfinx
{
 
namespace mesh
{
class Mesh;
}
 
namespace fem
{
class DofMap;
class FiniteElement;
 
 
class FunctionSpace
{
public:
  FunctionSpace(std::shared_ptr<const mesh::Mesh> mesh,
                std::shared_ptr<const fem::FiniteElement> element,
                std::shared_ptr<const fem::DofMap> dofmap);
 
  // Copy constructor (deleted)
  FunctionSpace(const FunctionSpace& V) = delete;
 
  FunctionSpace(FunctionSpace&& V) = default;
 
  virtual ~FunctionSpace() = default;
 
  // Assignment operator (delete)
  FunctionSpace& operator=(const FunctionSpace& V) = delete;
 
  FunctionSpace& operator=(FunctionSpace&& V) = default;
 
  bool operator==(const FunctionSpace& V) const;
 
  bool operator!=(const FunctionSpace& V) const;
 
  std::shared_ptr<FunctionSpace> sub(const std::vector<int>& component) const;
 
  bool contains(const FunctionSpace& V) const;
 
  std::pair<std::shared_ptr<FunctionSpace>, std::vector<std::int32_t>>
  collapse() const;
 
  std::vector<int> component() const;
 
  xt::xtensor<double, 2> tabulate_dof_coordinates(bool transpose) const;
 
  std::size_t id() const;
 
  std::shared_ptr<const mesh::Mesh> mesh() const;
 
  std::shared_ptr<const fem::FiniteElement> element() const;
 
  std::shared_ptr<const fem::DofMap> dofmap() const;
 
private:
  // The mesh
  std::shared_ptr<const mesh::Mesh> _mesh;
 
  // The finite element
  std::shared_ptr<const fem::FiniteElement> _element;
 
  // The dofmap
  std::shared_ptr<const fem::DofMap> _dofmap;
 
  // The component w.r.t. to root space
  std::vector<int> _component;
 
  // Unique identifier
  std::size_t _id;
 
  // The identifier of root space
  std::size_t _root_space_id;
 
  // Cache of subspaces
  mutable std::map<std::vector<int>, std::weak_ptr<FunctionSpace>> _subspaces;
};
 
std::array<std::vector<std::shared_ptr<const FunctionSpace>>, 2>
common_function_spaces(
    const std::vector<
        std::vector<std::array<std::shared_ptr<const FunctionSpace>, 2>>>& V);
} // namespace fem
} // namespace dolfinx