Loading...
Searching...
No Matches
UFC.h
// Copyright (C) 2007-2015 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: 2007-01-17
// Last changed: 2015-10-23
#ifndef __UFC_DATA_H
#define __UFC_DATA_H
#include <vector>
#include <memory>
#include <ufc.h>
namespace dolfin
{
class Cell;
class FiniteElement;
class Form;
class FunctionSpace;
class GenericFunction;
class Mesh;
class UFC
{
public:
UFC(const Form& form);
UFC(const UFC& ufc);
~UFC();
void init(const Form& form);
void update(const Cell& cell,
const std::vector<double>& coordinate_dofs0,
const ufc::cell& ufc_cell,
const std::vector<bool> & enabled_coefficients);
void update(const Cell& cell,
const std::vector<std::vector<double>>& coordinate_dofs0,
const std::vector<ufc::cell>& ufc_cells,
const std::vector<bool> & enabled_coefficients);
void update(const Cell& cell0,
const std::vector<double>& coordinate_dofs0,
const ufc::cell& ufc_cell0,
const Cell& cell1,
const std::vector<double>& coordinate_dofs1,
const ufc::cell& ufc_cell1,
const std::vector<bool> & enabled_coefficients);
void update(const Cell& cell,
const std::vector<double>& coordinate_dofs0,
const ufc::cell& ufc_cell);
void update(const Cell& cell0,
const std::vector<double>& coordinate_dofs0,
const ufc::cell& ufc_cell0,
const Cell& cell1,
const std::vector<double>& coordinate_dofs1,
const ufc::cell& ufc_cell1);
const double* const * w() const
{ return w_pointer.data(); }
double** w()
{ return w_pointer.data(); }
const double* const * macro_w() const
{ return macro_w_pointer.data(); }
double** macro_w()
{ return macro_w_pointer.data(); }
private:
// Finite elements for coefficients
std::vector<FiniteElement> coefficient_elements;
// Cell integrals (access through get_cell_integral to get proper
// fallback to default)
std::vector<std::shared_ptr<ufc::cell_integral>>
cell_integrals;
// Exterior facet integrals (access through
// get_exterior_facet_integral to get proper fallback to default)
std::vector<std::shared_ptr<ufc::exterior_facet_integral>>
exterior_facet_integrals;
// Interior facet integrals (access through
// get_interior_facet_integral to get proper fallback to default)
std::vector<std::shared_ptr<ufc::interior_facet_integral>>
interior_facet_integrals;
// Point integrals (access through get_vertex_integral to get
// proper fallback to default)
std::vector<std::shared_ptr<ufc::vertex_integral>>
vertex_integrals;
// Custom integrals (access through get_custom_integral to get
// proper fallback to default)
std::vector<std::shared_ptr<ufc::custom_integral>> custom_integrals;
// Cutcell integrals (access through get_cutcell_integral to get
// proper fallback to default)
std::vector<std::shared_ptr<ufc::cutcell_integral>> cutcell_integrals;
// Interface integrals (access through get_interface_integral to
// get proper fallback to default)
std::vector<std::shared_ptr<ufc::interface_integral>> interface_integrals;
// Overlap integrals (access through get_overlap_integral to get
// proper fallback to default)
std::vector<std::shared_ptr<ufc::overlap_integral>> overlap_integrals;
public:
// Default cell integral
std::shared_ptr<ufc::cell_integral>
default_cell_integral;
// Default exterior facet integral
std::shared_ptr<ufc::exterior_facet_integral>
default_exterior_facet_integral;
// Default interior facet integral
std::shared_ptr<ufc::interior_facet_integral>
default_interior_facet_integral;
// Default point integral
std::shared_ptr<ufc::vertex_integral>
default_vertex_integral;
// Default custom integral
std::shared_ptr<ufc::custom_integral> default_custom_integral;
// Default cutcell integral
std::shared_ptr<ufc::cutcell_integral> default_cutcell_integral;
// Default interface integral
std::shared_ptr<ufc::interface_integral> default_interface_integral;
// Default overlap integral
std::shared_ptr<ufc::overlap_integral> default_overlap_integral;
ufc::cell_integral*
get_cell_integral(std::size_t domain)
{
if (domain < form.max_cell_subdomain_id())
{
ufc::cell_integral * integral
= cell_integrals[domain].get();
if (integral)
return integral;
}
return default_cell_integral.get();
}
ufc::exterior_facet_integral*
get_exterior_facet_integral(std::size_t domain)
{
if (domain < form.max_exterior_facet_subdomain_id())
{
ufc::exterior_facet_integral* integral
= exterior_facet_integrals[domain].get();
if (integral)
return integral;
}
return default_exterior_facet_integral.get();
}
ufc::interior_facet_integral*
get_interior_facet_integral(std::size_t domain)
{
if (domain < form.max_interior_facet_subdomain_id())
{
ufc::interior_facet_integral* integral
= interior_facet_integrals[domain].get();
if (integral)
return integral;
}
return default_interior_facet_integral.get();
}
ufc::vertex_integral*
get_vertex_integral(std::size_t domain)
{
if (domain < form.max_vertex_subdomain_id())
{
ufc::vertex_integral * integral
= vertex_integrals[domain].get();
if (integral)
return integral;
}
return default_vertex_integral.get();
}
ufc::custom_integral * get_custom_integral(std::size_t domain)
{
if (domain < form.max_custom_subdomain_id())
{
ufc::custom_integral * integral = custom_integrals[domain].get();
if (integral)
return integral;
}
return default_custom_integral.get();
}
ufc::cutcell_integral * get_cutcell_integral(std::size_t domain)
{
if (domain < form.max_cutcell_subdomain_id())
{
ufc::cutcell_integral * integral = cutcell_integrals[domain].get();
if (integral)
return integral;
}
return default_cutcell_integral.get();
}
ufc::interface_integral * get_interface_integral(std::size_t domain)
{
if (domain < form.max_interface_subdomain_id())
{
ufc::interface_integral * integral = interface_integrals[domain].get();
if (integral)
return integral;
}
return default_interface_integral.get();
}
ufc::overlap_integral * get_overlap_integral(std::size_t domain)
{
if (domain < form.max_overlap_subdomain_id())
{
ufc::overlap_integral * integral = overlap_integrals[domain].get();
if (integral)
return integral;
}
return default_overlap_integral.get();
}
const ufc::form& form;
// FIXME AL: Check which data is actually used and remove the rest
std::vector<double> A;
std::vector<double> A_facet;
std::vector<double> macro_A;
private:
// Coefficients (std::vector<double*> is used to interface with
// UFC)
std::vector<std::vector<double>> _w;
std::vector<double*> w_pointer;
// Coefficients on macro element (std::vector<double*> is used to
// interface with UFC)
std::vector<std::vector<double>> _macro_w;
std::vector<double*> macro_w_pointer;
// Coefficient functions
const std::vector<std::shared_ptr<const GenericFunction>> coefficients;
public:
const Form& dolfin_form;
};
}
#endif
dolfin::Cell
A Cell is a MeshEntity of topological codimension 0.
Definition Cell.h:43
dolfin::FiniteElement
This is a wrapper for a UFC finite element (ufc::finite_element).
Definition FiniteElement.h:36
dolfin::Form
Base class for UFC code generated by FFC for DOLFIN with option -l.
Definition Form.h:86
dolfin::FunctionSpace
Definition FunctionSpace.h:54
dolfin::GenericFunction
Definition GenericFunction.h:54
dolfin::Mesh
Definition Mesh.h:84
dolfin::UFC::A_facet
std::vector< double > A_facet
Local tensor.
Definition UFC.h:312
dolfin::UFC::init
void init(const Form &form)
Initialise memory.
Definition UFC.cpp:53
dolfin::UFC::get_vertex_integral
ufc::vertex_integral * get_vertex_integral(std::size_t domain)
Definition UFC.h:239
dolfin::UFC::get_cutcell_integral
ufc::cutcell_integral * get_cutcell_integral(std::size_t domain)
Definition UFC.h:266
dolfin::UFC::macro_w
const double *const * macro_w() const
Definition UFC.h:112
dolfin::UFC::get_exterior_facet_integral
ufc::exterior_facet_integral * get_exterior_facet_integral(std::size_t domain)
Definition UFC.h:209
dolfin::UFC::form
const ufc::form & form
Form.
Definition UFC.h:304
dolfin::UFC::get_custom_integral
ufc::custom_integral * get_custom_integral(std::size_t domain)
Definition UFC.h:253
dolfin::UFC::A
std::vector< double > A
Local tensor.
Definition UFC.h:309
dolfin::UFC::macro_A
std::vector< double > macro_A
Local tensor for macro element.
Definition UFC.h:315
dolfin::UFC::UFC
UFC(const Form &form)
Constructor.
Definition UFC.cpp:33
dolfin::UFC::get_cell_integral
ufc::cell_integral * get_cell_integral(std::size_t domain)
Definition UFC.h:194
dolfin::UFC::dolfin_form
const Form & dolfin_form
The form.
Definition UFC.h:335
dolfin::UFC::get_interface_integral
ufc::interface_integral * get_interface_integral(std::size_t domain)
Definition UFC.h:279
dolfin::UFC::macro_w
double ** macro_w()
Definition UFC.h:117
dolfin::UFC::update
void update(const Cell &cell, const std::vector< double > &coordinate_dofs0, const ufc::cell &ufc_cell, const std::vector< bool > &enabled_coefficients)
Update current cell.
Definition UFC.cpp:174
dolfin::UFC::w
const double *const * w() const
Pointer to coefficient data. Used to support UFC interface.
Definition UFC.h:102
dolfin::UFC::get_interior_facet_integral
ufc::interior_facet_integral * get_interior_facet_integral(std::size_t domain)
Definition UFC.h:224
dolfin::UFC::~UFC
~UFC()
Destructor.
Definition UFC.cpp:47
dolfin::UFC::get_overlap_integral
ufc::overlap_integral * get_overlap_integral(std::size_t domain)
Definition UFC.h:292
dolfin::UFC::w
double ** w()
Definition UFC.h:107
dolfin
Definition adapt.h:30