Expression.h

// Copyright (C) 2020 Jack S. Hale
//
// This file is part of DOLFINx (https://www.fenicsproject.org)
//
// SPDX-License-Identifier:    LGPL-3.0-or-later
 
#pragma once
 
#include <dolfinx/common/array2d.h>
#include <dolfinx/fem/evaluate.h>
#include <functional>
#include <utility>
#include <vector>
#include <xtl/xspan.hpp>
 
namespace dolfinx
{
 
namespace mesh
{
class Mesh;
}
 
namespace fem
{
template <typename T>
class Constant;
 
 
template <typename T>
class Expression
{
public:
  Expression(
      const std::vector<std::shared_ptr<const fem::Function<T>>>& coefficients,
      const std::vector<std::shared_ptr<const fem::Constant<T>>>& constants,
      const std::shared_ptr<const mesh::Mesh>& mesh, const array2d<double>& X,
      const std::function<void(T*, const T*, const T*, const double*)> fn,
      const std::size_t value_size)
      : _coefficients(coefficients), _constants(constants), _mesh(mesh), _x(X),
        _fn(fn), _value_size(value_size)
  {
    // Do nothing
  }
 
  Expression(Expression&& form) = default;
 
  virtual ~Expression() = default;
 
  const std::vector<std::shared_ptr<const fem::Function<T>>>&
  coefficients() const
  {
    return _coefficients;
  }
 
  std::vector<int> coefficient_offsets() const
  {
    std::vector<int> n{0};
    for (const auto& c : _coefficients)
    {
      if (!c)
        throw std::runtime_error("Not all form coefficients have been set.");
      n.push_back(n.back() + c->function_space()->element()->space_dimension());
    }
    return n;
  }
 
  void eval(const xtl::span<const std::int32_t>& active_cells,
            array2d<T>& values) const
  {
    fem::eval(values, *this, active_cells);
  }
 
  const std::function<void(T*, const T*, const T*, const double*)>&
  get_tabulate_expression() const
  {
    return _fn;
  }
 
  const std::vector<std::shared_ptr<const fem::Constant<T>>>& constants() const
  {
    return _constants;
  }
 
  std::shared_ptr<const mesh::Mesh> mesh() const { return _mesh; }
 
  const array2d<double>& x() const { return _x; }
 
  const std::size_t value_size() const { return _value_size; }
 
  const std::size_t num_points() const { return _x.shape[0]; }
 
  using scalar_type = T;
 
private:
  // Coefficients associated with the Expression
  std::vector<std::shared_ptr<const fem::Function<T>>> _coefficients;
 
  // Constants associated with the Expression
  std::vector<std::shared_ptr<const fem::Constant<T>>> _constants;
 
  // Function to evaluate the Expression
  std::function<void(T*, const T*, const T*, const double*)> _fn;
 
  // Evaluation points on reference cell
  array2d<double> _x;
 
  // The mesh.
  std::shared_ptr<const mesh::Mesh> _mesh;
 
  // Evaluation size
  std::size_t _value_size;
};
} // namespace fem
} // namespace dolfinx