/usr/include/dolfin/fem/GenericDofMap.h is in libdolfin-dev 1.4.0+dfsg-4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 | // Copyright (C) 2010-2013 Anders Logg and Garth N. Wells
//
// This file is part of DOLFIN.
//
// DOLFIN 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, either version 3 of the License, or
// (at your option) any later version.
//
// DOLFIN is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with DOLFIN. If not, see <http://www.gnu.org/licenses/>.
//
// Modified by Joachim B Haga, 2012
// Modified by Jan Blechta, 2013
//
// First added: 2010-05-26
// Last changed: 2013-03-04
#ifndef __GENERIC_DOF_MAP_H
#define __GENERIC_DOF_MAP_H
#include <map>
#include <utility>
#include <vector>
#include <boost/multi_array.hpp>
#include <memory>
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>
#include <dolfin/common/types.h>
#include <dolfin/common/Variable.h>
namespace ufc
{
class cell;
}
namespace dolfin
{
class Cell;
class GenericVector;
class Mesh;
class Restriction;
class SubDomain;
/// This class provides a generic interface for dof maps
class GenericDofMap : public Variable
{
public:
/// Constructor
GenericDofMap() : block_size(1) {}
/// True if dof map is a view into another map (is a sub-dofmap)
virtual bool is_view() const = 0;
/// Return the dimension of the global finite element function
/// space
virtual std::size_t global_dimension() const = 0;
/// Return the dimension of the local finite element function
/// space on a cell
virtual std::size_t cell_dimension(std::size_t index) const = 0;
/// Return the maximum dimension of the local finite element
/// function space
virtual std::size_t max_cell_dimension() const = 0;
/// Return the number of dofs for a given entity dimension
virtual std::size_t num_entity_dofs(std::size_t dim) const = 0;
/// Return the geometric dimension of the coordinates this dof map
// provides
virtual std::size_t geometric_dimension() const = 0;
/// Return number of facet dofs
virtual std::size_t num_facet_dofs() const = 0;
/// Restriction if any. If the dofmap is not restricted, a null
/// pointer is returned.
virtual std::shared_ptr<const Restriction> restriction() const = 0;
/// Return the ownership range (dofs in this range are owned by
/// this process)
virtual std::pair<std::size_t, std::size_t> ownership_range() const = 0;
/// Return map from nonlocal-dofs (that appear in local dof map)
/// to owning process
virtual const boost::unordered_map<std::size_t, unsigned int>&
off_process_owner() const = 0;
/// Local-to-global mapping of dofs on a cell
virtual const std::vector<dolfin::la_index>&
cell_dofs(std::size_t cell_index) const = 0;
/// Tabulate local-local facet dofs
virtual void tabulate_facet_dofs(std::vector<std::size_t>& dofs,
std::size_t local_facet) const = 0;
/// Tabulate the local-to-local mapping of dofs on entity
/// (dim, local_entity)
virtual void tabulate_entity_dofs(std::vector<std::size_t>& dofs,
std::size_t dim,
std::size_t local_entity) const = 0;
/// Tabulate the coordinates of all dofs on a cell (UFC cell version)
virtual
void tabulate_coordinates(boost::multi_array<double, 2>& coordinates,
const std::vector<double>& vertex_coordinates,
const Cell& cell) const = 0;
/// Tabulate the coordinates of all dofs owned by this
/// process. This function is typically used by preconditioners
/// that require the spatial coordinates of dofs, for example
/// for re-partitioning or nullspace computations. The format for
/// the return vector is [x0, y0, z0, x1, y1, z1, . . .].
virtual std::vector<double>
tabulate_all_coordinates(const Mesh& mesh) const = 0;
/// Create a copy of the dof map
virtual std::shared_ptr<GenericDofMap> copy() const = 0;
/// Create a new dof map on new mesh
virtual std::shared_ptr<GenericDofMap>
create(const Mesh& new_mesh) const = 0;
/// Extract sub dofmap component
virtual std::shared_ptr<GenericDofMap>
extract_sub_dofmap(const std::vector<std::size_t>& component,
const Mesh& mesh) const = 0;
/// Create a "collapsed" a dofmap (collapses from a sub-dofmap view)
virtual std::shared_ptr<GenericDofMap>
collapse(boost::unordered_map<std::size_t, std::size_t>& collapsed_map,
const Mesh& mesh) const = 0;
/// Return list of global dof indices on this process
virtual std::vector<dolfin::la_index> dofs() const = 0;
/// Set dof entries in vector to a specified value. Parallel
/// layout of vector must be consistent with dof map range. This
/// function is typically used to construct the null space of a
/// matrix operator
virtual void set(GenericVector& x, double value) const = 0;
/// Set dof entries in vector to the value*x[i], where x[i] is the
/// spatial coordinate of the dof. Parallel layout of vector must
/// be consistent with dof map range. This function is typically
/// used to construct the null space of a matrix operator, e.g. rigid
/// body rotations.
virtual void set_x(GenericVector& x, double value, std::size_t component,
const Mesh& mesh) const = 0;
/// Return map from shared dofs to the processes (not including
/// the current process) that share it.
virtual const boost::unordered_map<std::size_t,
std::vector<unsigned int> >& shared_dofs() const = 0;
/// Return set of processes that share dofs with the this process
virtual const std::set<std::size_t>& neighbours() const = 0;
/// Return informal string representation (pretty-print)
virtual std::string str(bool verbose) const = 0;
/// Subdomain mapping constrained boundaries, e.g. periodic conditions
std::shared_ptr<const SubDomain> constrained_domain;
/// Dofmap block size, e.g. 3 for 3D elasticity with a suitable
// ordered dofmap
std::size_t block_size;
};
}
#endif
|