This file is indexed.

/usr/include/dolfin/refinement/refine.h is in libdolfin-dev 2016.2.0-2.

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
// Copyright (C) 2010 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 Anders Logg, 2010.
//
// First added:  2010-02-10
// Last changed: 2013-05-12
//
// This file defines free functions for mesh refinement.
//

#ifndef __DOLFIN_REFINE_H
#define __DOLFIN_REFINE_H

namespace dolfin
{

  // Forward declarations
  class Mesh;
  class MeshHierarchy;
  template <typename T> class MeshFunction;

  /// Create uniformly refined mesh
  ///
  /// *Arguments*
  ///     mesh (_Mesh_)
  ///         The mesh to refine.
  ///     redistribute (_bool_)
  ///         Optional argument to redistribute the refined mesh if mesh is a
  ///         distributed mesh.
  ///
  /// *Returns*
  ///     _Mesh_
  ///         The refined mesh.
  ///
  /// *Example*
  ///     .. code-block:: c++
  ///
  ///         mesh = refine(mesh);
  ///
  Mesh refine(const Mesh& mesh, bool redistribute = true);

  /// Refine a MeshHierarchy
  std::shared_ptr<const MeshHierarchy> refine(
              const MeshHierarchy& hierarchy,
              const MeshFunction<bool>& markers);

  /// Create uniformly refined mesh
  ///
  /// *Arguments*
  ///     refined_mesh (_Mesh_)
  ///         The mesh that will be the refined mesh.
  ///     mesh (_Mesh_)
  ///         The original mesh.
  ///     redistribute (_bool_)
  ///         Optional argument to redistribute the refined mesh if mesh is a
  ///         distributed mesh.
  void refine(Mesh& refined_mesh, const Mesh& mesh,
              bool redistribute = true);

  /// Create locally refined mesh
  ///
  /// *Arguments*
  ///     mesh (_Mesh_)
  ///         The mesh to refine.
  ///     cell_markers (_MeshFunction_ <bool>)
  ///         A mesh function over booleans specifying which cells
  ///         that should be refined (and which should not).
  ///     redistribute (_bool_)
  ///         Optional argument to redistribute the refined mesh if mesh is a
  ///         distributed mesh.
  ///
  /// *Returns*
  ///     _Mesh_
  ///         The locally refined mesh.
  ///
  /// *Example*
  ///     .. code-block:: c++
  ///
  ///         CellFunction<bool> cell_markers(mesh);
  ///         cell_markers.set_all(false);
  ///         Point origin(0.0, 0.0, 0.0);
  ///         for (CellIterator cell(mesh); !cell.end(); ++cell)
  ///         {
  ///             Point p = cell->midpoint();
  ///             if (p.distance(origin) < 0.1)
  ///                 cell_markers[*cell] = true;
  ///         }
  ///         mesh = refine(mesh, cell_markers);
  ///
  Mesh refine(const Mesh& mesh, const MeshFunction<bool>& cell_markers,
              bool redistribute = true);

  /// Create locally refined mesh
  ///
  /// *Arguments*
  ///     refined_mesh (_Mesh_)
  ///         The mesh that will be the refined mesh.
  ///     mesh (_Mesh_)
  ///         The original mesh.
  ///     cell_markers (_MeshFunction_ <bool>)
  ///         A mesh function over booleans specifying which cells
  ///         that should be refined (and which should not).
  ///     redistribute (_bool_)
  ///         Optional argument to redistribute the refined mesh if mesh is a
  ///         distributed mesh.
  void refine(Mesh& refined_mesh, const Mesh& mesh,
              const MeshFunction<bool>& cell_markers, bool redistribute = true);

  /// Increase the polynomial order of the mesh from 1 to 2, i.e. add points
  /// at the Edge midpoints, to make a quadratic mesh.
  ///
  /// *Arguments*
  ///     refined_mesh (_Mesh_)
  ///         The mesh that will be the quadratic mesh.
  ///     mesh (_Mesh_)
  ///         The original linear mesh.
  void p_refine(Mesh& refined_mesh, const Mesh& mesh);

  /// Return a p_refined mesh
  /// Increase the polynomial order of the mesh from 1 to 2, i.e. add points
  /// at the Edge midpoints, to make a quadratic mesh.
  ///
  /// *Arguments*
  ///     mesh (_Mesh_)
  ///         The original linear mesh.
  Mesh p_refine(const Mesh& mesh);
}

#endif