/usr/include/dolfin/function/GenericFunction.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 | // Copyright (C) 2009 Anders Logg
//
// 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 Garth N. Wells, 2009.
//
// First added: 2009-09-28
// Last changed: 2011-01-19
#ifndef __GENERIC_FUNCTION_H
#define __GENERIC_FUNCTION_H
#include <ufc.h>
#include <dolfin/common/Array.h>
#include <dolfin/common/Variable.h>
namespace dolfin
{
class Mesh;
class Cell;
class Point;
class FiniteElement;
/// This is a common base class for functions. Functions can be
/// evaluated at a given point and they can be restricted to a given
/// cell in a finite element mesh. This functionality is implemented
/// by sub-classes that implement the eval() and restrict() functions.
///
/// DOLFIN provides two implementations of the GenericFunction
/// interface in the form of the classes Function and Expression.
///
/// Sub-classes may optionally implement the update() function that
/// will be called prior to restriction when running in parallel.
class GenericFunction : public ufc::function, public Variable
{
public:
/// Constructor
GenericFunction();
/// Destructor
virtual ~GenericFunction();
//--- Functions that must be implemented by sub-classes ---
/// Return value rank
virtual std::size_t value_rank() const = 0;
/// Return value dimension for given axis
virtual std::size_t value_dimension(std::size_t i) const = 0;
/// Evaluate at given point in given cell
virtual void eval(Array<double>& values, const Array<double>& x,
const ufc::cell& cell) const;
/// Evaluate at given point
virtual void eval(Array<double>& values, const Array<double>& x) const;
/// Restrict function to local cell (compute expansion coefficients w)
virtual void restrict(double* w,
const FiniteElement& element,
const Cell& dolfin_cell,
const double* vertex_coordinates,
const ufc::cell& ufc_cell) const = 0;
/// Compute values at all mesh vertices
virtual void compute_vertex_values(std::vector<double>& vertex_values,
const Mesh& mesh) const = 0;
//--- Optional functions to be implemented by sub-classes ---
/// Update off-process ghost coefficients
virtual void update() const {}
//--- Convenience functions ---
/// Evaluation at given point (scalar function)
double operator() (double x);
/// Evaluation at given point (scalar function)
double operator() (double x, double y);
/// Evaluation at given point (scalar function)
double operator() (double x, double y, double z);
/// Evaluation at given point (scalar function)
double operator() (const Point& p);
/// Evaluation at given point (vector-valued function)
void operator() (Array<double>& values, double x);
/// Evaluation at given point (vector-valued function)
void operator() (Array<double>& values, double x, double y);
/// Evaluation at given point (vector-valued function)
void operator() (Array<double>& values, double x, double y, double z);
/// Evaluation at given point (vector-valued function)
void operator() (Array<double>& values, const Point& p);
/// Evaluation at given point
/// Return value size (product of value dimensions)
std::size_t value_size() const;
//--- Implementation of ufc::function interface ---
/// Evaluate function at given point in cell
virtual void evaluate(double* values,
const double* coordinates,
const ufc::cell& cell) const;
protected:
// Restrict as UFC function (by calling eval)
void restrict_as_ufc_function(double* w,
const FiniteElement& element,
const Cell& dolfin_cell,
const double* vertex_coordinates,
const ufc::cell& ufc_cell) const;
};
}
#endif
|