+template <>
QGauss2<1>::QGauss2 () :
Quadrature<1> (2)
{
+template <>
QGauss2<2>::QGauss2 () :
Quadrature<2> (4)
{
+template <>
QGauss3<1>::QGauss3 () :
Quadrature<1> (3)
{
+template <>
QGauss3<2>::QGauss3 () :
Quadrature<2> (9)
{
+template <>
QGauss4<1>::QGauss4 () :
Quadrature<1> (4)
{
+template <>
QGauss4<2>::QGauss4 () :
Quadrature<2> (16)
{
+template <>
QGauss5<1>::QGauss5 () :
Quadrature<1> (5)
{
+template <>
QGauss5<2>::QGauss5 () :
Quadrature<2> (25)
{
+template <>
QGauss6<1>::QGauss6 () :
Quadrature<1> (6)
{
+template <>
QGauss7<1>::QGauss7 () :
Quadrature<1> (7)
{
+template <>
QGauss8<1>::QGauss8 () :
Quadrature<1> (8)
{
+template <>
QMidpoint<1>::QMidpoint () :
Quadrature<1>(1)
{
+template <>
QMidpoint<2>::QMidpoint () :
Quadrature<2>(1)
{
+template <>
QSimpson<1>::QSimpson () :
Quadrature<1> (3)
{
+template <>
QSimpson<2>::QSimpson () :
Quadrature<2> (9)
{
+template <>
QTrapez<1>::QTrapez () :
Quadrature<1> (2)
{
+template <>
QTrapez<2>::QTrapez () :
Quadrature<2> (4)
{
*
* The same concept is used with #DoFQuadAccessor# classes etc.
*/
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
class DoFLineAccessor : public DoFAccessor<dim>, public BaseClass {
public:
/**
*
* @see DoFLineAccessor
*/
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
class DoFQuadAccessor : public DoFAccessor<dim>, public BaseClass {
public:
/**
* and one for #DoFCellAccessor<2>#, derived from
* #DoFQuadAccessor<2,CellAccessor<2> >#.
*/
+template <>
class DoFSubstructAccessor<1> : public DoFLineAccessor<1,CellAccessor<1> > {
public:
/**
*
* @see DoFSubstructAccessor<1>
*/
+template <>
class DoFSubstructAccessor<2> : public DoFQuadAccessor<2,CellAccessor<2> > {
public:
/**
* to think about their number in a dimension independent expression.
* This not only reduces thinking effort but also error possibilities.
*/
+template <>
struct GeometryInfo<1> {
public:
/**
* to think about their number in a dimension independent expression.
* This not only reduces thinking effort but also error possibilities.
*/
+template <>
struct GeometryInfo<2> {
public:
/**
* and one for #CellAccessor<2>#, derived from
* #QuadAccessor<2>#.
*/
+template <>
class TriaSubstructAccessor<1> : public LineAccessor<1> {
public:
/**
*
* @see TriaSubstructAccessor<1>
*/
+template <>
class TriaSubstructAccessor<2> : public QuadAccessor<2> {
public:
/**
* @see TriaDimensionInfo
* @author Wolfgang Bangerth, 1998
*/
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
class TriaRawIterator : public bidirectional_iterator<Accessor,int>{
public:
/**
* This specialization of \Ref{TriaRawIterator} provides access only to the
* {\it used} lines, quads, cells, etc.
*/
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
class TriaIterator : public TriaRawIterator<dim,Accessor> {
public:
/**
* {\it active} lines, quads, cells, etc. An active cell is a cell which is not
* refined and thus a cell on which calculations on the finest level are done.
*/
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
class TriaActiveIterator : public TriaIterator<dim,Accessor> {
public:
/**
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
inline
const Accessor &
TriaRawIterator<dim,Accessor>::operator * () const {
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
inline
Accessor &
TriaRawIterator<dim,Accessor>::operator * () {
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
inline
const Accessor *
TriaRawIterator<dim,Accessor>::operator -> () const {
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
inline
Accessor *
TriaRawIterator<dim,Accessor>::operator -> () {
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
inline
IteratorState TriaRawIterator<dim,Accessor>::state () const {
return accessor.state ();
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
inline
bool TriaRawIterator<dim,Accessor>::operator < (const TriaRawIterator &i) const {
Assert (state() != invalid, ExcDereferenceInvalidObject());
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
inline
TriaRawIterator<dim,Accessor> &
TriaRawIterator<dim,Accessor>::operator ++ () {
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
inline
TriaRawIterator<dim,Accessor> &
TriaRawIterator<dim,Accessor>::operator -- () {
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
inline
void TriaRawIterator<dim,Accessor>::print (ostream &out) const {
out << accessor.level() << "." << accessor.index();
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
inline
ostream & operator << (ostream &out, const TriaRawIterator<dim,Accessor> &i) {
i.print(out);
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
inline
ostream & operator << (ostream &out, const TriaIterator<dim,Accessor> &i) {
i.print(out);
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
inline
ostream & operator << (ostream &out, const TriaActiveIterator<dim,Accessor> &i) {
i.print(out);
/*------------------------ Functions: TriaRawIterator ------------------*/
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaRawIterator<dim,Accessor>::TriaRawIterator () :
accessor (0, -2, -2, 0) {};
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaRawIterator<dim,Accessor>::TriaRawIterator (const TriaRawIterator<dim,Accessor> &i) :
accessor (i.accessor) {};
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaRawIterator<dim,Accessor>::TriaRawIterator (Triangulation<dim> *parent,
const int level,
const int index,
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaRawIterator<dim,Accessor> &
TriaRawIterator<dim,Accessor>::operator = (const TriaRawIterator<dim,Accessor> &i) {
accessor.copy_from (i.accessor);
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
bool
TriaRawIterator<dim,Accessor>::operator == (const TriaRawIterator<dim,Accessor> &i) const {
return accessor == i.accessor;
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
bool
TriaRawIterator<dim,Accessor>::operator != (const TriaRawIterator<dim,Accessor> &i) const {
return accessor != i.accessor;
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaRawIterator<dim,Accessor> TriaRawIterator<dim,Accessor>::operator ++ (int) {
TriaRawIterator<dim,Accessor> tmp(*this);
this->operator++ ();
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaRawIterator<dim,Accessor> TriaRawIterator<dim,Accessor>::operator -- (int) {
TriaRawIterator<dim,Accessor> tmp(*this);
this->operator-- ();
/*----------------------- functions: TriaIterator ---------------*/
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaIterator<dim,Accessor>::TriaIterator () :
TriaRawIterator<dim,Accessor> () {};
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaIterator<dim,Accessor>::
TriaIterator (const TriaIterator<dim,Accessor> &i) :
TriaRawIterator<dim,Accessor> ((TriaRawIterator<dim,Accessor>)i) {};
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaIterator<dim,Accessor>::
TriaIterator (const TriaRawIterator<dim,Accessor> &i) :
TriaRawIterator<dim,Accessor> (i)
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaIterator<dim,Accessor>::TriaIterator (Triangulation<dim> *parent,
const int level,
const int index,
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaIterator<dim,Accessor> &
TriaIterator<dim,Accessor>::operator = (const TriaIterator<dim,Accessor> &i) {
accessor.copy_from (i.accessor);
};
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaIterator<dim,Accessor> &
TriaIterator<dim,Accessor>::operator = (const TriaRawIterator<dim,Accessor> &i) {
accessor.copy_from (i.accessor);
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaIterator<dim,Accessor> & TriaIterator<dim,Accessor>::operator ++ () {
while (TriaRawIterator<dim,Accessor>::operator++(),
(state() == valid))
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaIterator<dim,Accessor> TriaIterator<dim,Accessor>::operator ++ (int) {
TriaIterator<dim,Accessor> tmp(*this);
this->operator++ ();
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaIterator<dim,Accessor> & TriaIterator<dim,Accessor>::operator -- () {
while (TriaRawIterator<dim,Accessor>::operator--(),
(state() == valid))
};
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaIterator<dim,Accessor> TriaIterator<dim,Accessor>::operator -- (int) {
TriaIterator<dim,Accessor> tmp(*this);
this->operator-- ();
/*----------------------- functions: TriaActiveIterator ---------------*/
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaActiveIterator<dim,Accessor>::TriaActiveIterator () :
TriaIterator<dim,Accessor> () {};
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaActiveIterator<dim,Accessor>::
TriaActiveIterator (const TriaActiveIterator<dim,Accessor> &i) :
TriaIterator<dim,Accessor> ((TriaIterator<dim,Accessor>) i) {};
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaActiveIterator<dim,Accessor>::
TriaActiveIterator (const TriaRawIterator<dim,Accessor> &i) :
TriaIterator<dim,Accessor> (i)
// has_children() is called anyway, even if
// state==past_the_end, and will then
// throw the exception!
- if (state() != past_the_end)
+ //
+ // for egcs: write this-> to avoid internal
+ // compiler error
+ if (this->state() != past_the_end)
Assert (accessor.has_children()==false,
ExcAssignmentOfInactiveObject());
#endif
};
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaActiveIterator<dim,Accessor>::
TriaActiveIterator (const TriaIterator<dim,Accessor> &i) :
TriaIterator<dim,Accessor> (i)
// has_children() is called anyway, even if
// state==past_the_end, and will then
// throw the exception!
- if (state() != past_the_end)
+ //
+ // for egcs: write this-> to avoid internal
+ // compiler error
+ if (this->state() != past_the_end)
Assert (accessor.has_children()==false,
ExcAssignmentOfInactiveObject());
#endif
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaActiveIterator<dim,Accessor>::TriaActiveIterator (Triangulation<dim> *parent,
const int level,
const int index,
// has_children() is called anyway, even if
// state==past_the_end, and will then
// throw the exception!
- if (state() != past_the_end)
+ //
+ // for egcs: write this-> to avoid internal
+ // compiler error
+ if (this->state() != past_the_end)
Assert (accessor.has_children()==false,
ExcAssignmentOfInactiveObject());
#endif
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaActiveIterator<dim,Accessor> &
TriaActiveIterator<dim,Accessor>::operator = (const TriaActiveIterator<dim,Accessor> &i) {
accessor.copy_from (i.accessor);
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaActiveIterator<dim,Accessor> &
TriaActiveIterator<dim,Accessor>::operator = (const TriaRawIterator<dim,Accessor> &i) {
accessor.copy_from (i.accessor);
// has_chidlren() is called anyway, even if
// state==past_the_end, and will then
// throw the exception!
- if (state() != past_the_end)
+ //
+ // for egcs: write this-> to avoid internal
+ // compiler error
+ if (this->state() != past_the_end)
Assert (accessor.used() && accessor.has_children()==false,
ExcAssignmentOfInactiveObject());
#endif
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaActiveIterator<dim,Accessor> &
TriaActiveIterator<dim,Accessor>::operator = (const TriaIterator<dim,Accessor> &i) {
accessor.copy_from (i.accessor);
// has_children() is called anyway, even if
// state==past_the_end, and will then
// throw the exception!
- if (state() != past_the_end)
+ //
+ // for egcs: write this-> to avoid internal
+ // compiler error
+ if (this->state() != past_the_end)
Assert (accessor.has_children()==false,
ExcAssignmentOfInactiveObject());
#endif
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaActiveIterator<dim,Accessor> & TriaActiveIterator<dim,Accessor>::operator ++ () {
+ // for egcs: write this-> to avoid internal
+ // compiler error
while (TriaIterator<dim,Accessor>::operator++(),
- (state() == valid))
+ (this->state() == valid))
if (accessor.has_children() == false)
return *this;
return *this;
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaActiveIterator<dim,Accessor> TriaActiveIterator<dim,Accessor>::operator ++ (int) {
TriaActiveIterator<dim,Accessor> tmp(*this);
this->operator++ ();
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaActiveIterator<dim,Accessor> & TriaActiveIterator<dim,Accessor>::operator -- () {
+ // for egcs: write this-> to avoid internal
+ // compiler error
while (TriaIterator<dim,Accessor>::operator--(),
- (state() == valid))
+ (this->state() == valid))
if (accessor.has_children() == false)
return *this;
return *this;
-template <int dim, class Accessor>
+template <int dim, typename Accessor>
TriaActiveIterator<dim,Accessor> TriaActiveIterator<dim,Accessor>::operator -- (int) {
TriaActiveIterator<dim,Accessor> tmp(*this);
this->operator-- ();
+template <>
DoFHandler<1>::raw_cell_iterator
DoFHandler<1>::begin_raw (const unsigned int level) const {
return begin_raw_line (level);
+template <>
DoFHandler<1>::cell_iterator
DoFHandler<1>::begin (const unsigned int level) const {
return begin_line (level);
+template <>
DoFHandler<1>::active_cell_iterator
DoFHandler<1>::begin_active (const unsigned int level) const {
return begin_active_line (level);
+template <>
DoFHandler<1>::raw_cell_iterator
DoFHandler<1>::end () const {
return end_line ();
+template <>
DoFHandler<1>::raw_cell_iterator
DoFHandler<1>::last_raw () const {
return last_raw_line ();
+template <>
DoFHandler<1>::raw_cell_iterator
DoFHandler<1>::last_raw (const unsigned int level) const {
return last_raw_line (level);
+template <>
DoFHandler<1>::cell_iterator
DoFHandler<1>::last () const {
return last_line ();
+template <>
DoFHandler<1>::cell_iterator
DoFHandler<1>::last (const unsigned int level) const {
return last_line (level);
+template <>
DoFHandler<1>::active_cell_iterator
DoFHandler<1>::last_active () const {
return last_active_line ();
+template <>
DoFHandler<1>::active_cell_iterator
DoFHandler<1>::last_active (const unsigned int level) const {
return last_active_line (level);
+template <>
DoFHandler<2>::raw_cell_iterator
DoFHandler<2>::begin_raw (const unsigned int level) const {
return begin_raw_quad (level);
+template <>
DoFHandler<2>::cell_iterator
DoFHandler<2>::begin (const unsigned int level) const {
return begin_quad (level);
+template <>
DoFHandler<2>::active_cell_iterator
DoFHandler<2>::begin_active (const unsigned int level) const {
return begin_active_quad (level);
+template <>
DoFHandler<2>::raw_cell_iterator
DoFHandler<2>::end () const {
return end_quad ();
+template <>
DoFHandler<2>::raw_cell_iterator
DoFHandler<2>::last_raw () const {
return last_raw_quad ();
+template <>
DoFHandler<2>::raw_cell_iterator
DoFHandler<2>::last_raw (const unsigned int level) const {
return last_raw_quad (level);
+template <>
DoFHandler<2>::cell_iterator
DoFHandler<2>::last () const {
return last_quad ();
+template <>
DoFHandler<2>::cell_iterator
DoFHandler<2>::last (const unsigned int level) const {
return last_quad (level);
+template <>
DoFHandler<2>::active_cell_iterator
DoFHandler<2>::last_active () const {
return last_active_quad ();
+template <>
DoFHandler<2>::active_cell_iterator
DoFHandler<2>::last_active (const unsigned int level) const {
return last_active_quad (level);
+template <>
DoFDimensionInfo<1>::raw_face_iterator
DoFHandler<1>::begin_raw_face (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
+template <>
DoFDimensionInfo<1>::face_iterator
DoFHandler<1>::begin_face (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
+template <>
DoFDimensionInfo<1>::active_face_iterator
DoFHandler<1>::begin_active_face (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
+template <>
DoFDimensionInfo<1>::raw_face_iterator
DoFHandler<1>::end_face () const {
Assert (false, ExcFunctionNotUseful());
+template <>
DoFDimensionInfo<1>::raw_face_iterator
DoFHandler<1>::last_raw_face () const {
Assert (false, ExcFunctionNotUseful());
+template <>
DoFDimensionInfo<1>::raw_face_iterator
DoFHandler<1>::last_raw_face (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
+template <>
DoFDimensionInfo<1>::face_iterator
DoFHandler<1>::last_face () const {
Assert (false, ExcFunctionNotUseful());
+template <>
DoFDimensionInfo<1>::face_iterator
DoFHandler<1>::last_face (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
+template <>
DoFDimensionInfo<1>::active_face_iterator
DoFHandler<1>::last_active_face () const {
Assert (false, ExcFunctionNotUseful());
+template <>
DoFDimensionInfo<1>::active_face_iterator
DoFHandler<1>::last_active_face (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
+template <>
DoFDimensionInfo<2>::raw_face_iterator
DoFHandler<2>::begin_raw_face (const unsigned int level) const {
return begin_raw_line (level);
+template <>
DoFDimensionInfo<2>::face_iterator
DoFHandler<2>::begin_face (const unsigned int level) const {
return begin_line (level);
+template <>
DoFDimensionInfo<2>::active_face_iterator
DoFHandler<2>::begin_active_face (const unsigned int level) const {
return begin_active_line (level);
+template <>
DoFDimensionInfo<2>::raw_face_iterator
DoFHandler<2>::end_face () const {
return end_line ();
+template <>
DoFDimensionInfo<2>::raw_face_iterator
DoFHandler<2>::last_raw_face () const {
return last_raw_line ();
+template <>
DoFDimensionInfo<2>::raw_face_iterator
DoFHandler<2>::last_raw_face (const unsigned int level) const {
return last_raw_line (level);
+template <>
DoFDimensionInfo<2>::face_iterator
DoFHandler<2>::last_face () const {
return last_line ();
+template <>
DoFDimensionInfo<2>::face_iterator
DoFHandler<2>::last_face (const unsigned int level) const {
return last_line (level);
+template <>
DoFDimensionInfo<2>::active_face_iterator
DoFHandler<2>::last_active_face () const {
return last_active_line ();
+template <>
DoFDimensionInfo<2>::active_face_iterator
DoFHandler<2>::last_active_face (const unsigned int level) const {
return last_active_line (level);
+template <>
DoFHandler<1>::raw_quad_iterator
DoFHandler<1>::begin_raw_quad (const unsigned int) const {
Assert (false, ExcNotImplemented());
+template <>
DoFHandler<1>::quad_iterator
DoFHandler<1>::begin_quad (const unsigned int) const {
Assert (false, ExcNotImplemented());
+template <>
DoFHandler<1>::active_quad_iterator
DoFHandler<1>::begin_active_quad (const unsigned int) const {
Assert (false, ExcNotImplemented());
+template <>
DoFHandler<1>::raw_quad_iterator
DoFHandler<1>::end_quad () const {
Assert (false, ExcNotImplemented());
+template <>
DoFHandler<1>::raw_quad_iterator
DoFHandler<1>::last_raw_quad (const unsigned int) const {
Assert (false, ExcNotImplemented());
+template <>
DoFHandler<1>::quad_iterator
DoFHandler<1>::last_quad (const unsigned int) const {
Assert (false, ExcNotImplemented());
+template <>
DoFHandler<1>::active_quad_iterator
DoFHandler<1>::last_active_quad (const unsigned int) const {
Assert (false, ExcNotImplemented());
+template <>
DoFHandler<1>::raw_quad_iterator
DoFHandler<1>::last_raw_quad () const {
Assert (false, ExcNotImplemented());
+template <>
DoFHandler<1>::quad_iterator
DoFHandler<1>::last_quad () const {
Assert (false, ExcNotImplemented());
+template <>
DoFHandler<1>::active_quad_iterator
DoFHandler<1>::last_active_quad () const {
Assert (false, ExcNotImplemented());
+template <>
unsigned int DoFHandler<1>::n_boundary_dofs () const {
Assert (selected_fe != 0, ExcNoFESelected());
Assert (false, ExcNotImplemented());
+template <>
unsigned int DoFHandler<1>::n_boundary_dofs (const FunctionMap &) const {
Assert (selected_fe != 0, ExcNoFESelected());
Assert (false, ExcNotImplemented());
+template <>
unsigned int DoFHandler<1>::distribute_dofs_on_cell (active_cell_iterator &cell,
unsigned int next_free_dof) {
+template <>
unsigned int DoFHandler<2>::distribute_dofs_on_cell (active_cell_iterator &cell,
unsigned int next_free_dof) {
if (selected_fe->dofs_per_vertex > 0)
+template <>
void DoFHandler<1>::do_renumbering (const vector<int> &new_numbers) {
// note that we can not use cell iterators
// in this function since then we would
+template <>
void DoFHandler<2>::do_renumbering (const vector<int> &new_numbers) {
for (vector<int>::iterator i=vertex_dofs.begin(); i!=vertex_dofs.end(); ++i)
if (*i != -1)
+template <>
void DoFHandler<1>::make_constraint_matrix (ConstraintMatrix &cm) const {
cm.clear ();
cm.close ();
+template <>
void DoFHandler<2>::make_constraint_matrix (ConstraintMatrix &constraints) const {
constraints.clear ();
+template <>
void DoFHandler<1>::make_boundary_sparsity_pattern (const vector<int> &,
dSMatrixStruct &) const {
Assert (selected_fe != 0, ExcNoFESelected());
+template <>
void DoFHandler<1>::make_boundary_sparsity_pattern (const FunctionMap &,
const vector<int> &,
dSMatrixStruct &) const {
+template <>
unsigned int DoFHandler<1>::max_couplings_between_dofs () const {
Assert (selected_fe != 0, ExcNoFESelected());
return 3*selected_fe->dofs_per_vertex + 2*selected_fe->dofs_per_line;
+template <>
unsigned int DoFHandler<2>::max_couplings_between_dofs () const {
Assert (selected_fe != 0, ExcNoFESelected());
+template <>
unsigned int DoFHandler<1>::max_couplings_between_boundary_dofs () const {
Assert (selected_fe != 0, ExcNoFESelected());
Assert (false, ExcInternalError());
+template <>
unsigned int DoFHandler<2>::max_couplings_between_boundary_dofs () const {
Assert (selected_fe != 0, ExcNoFESelected());
return 3*selected_fe->dofs_per_vertex + 2*selected_fe->dofs_per_line;
+template <>
unsigned int DoFHandler<1>::max_transfer_entries (const unsigned int max_level_diff) const {
Assert (max_level_diff<2, ExcOnlyOnelevelTransferImplemented());
switch (max_level_diff)
+template <>
unsigned int DoFHandler<2>::max_transfer_entries (const unsigned int max_level_diff) const {
Assert (max_level_diff<2, ExcOnlyOnelevelTransferImplemented());
switch (max_level_diff)
+template <>
void DoFHandler<1>::map_dof_to_boundary_indices (vector<int> &) const {
Assert (selected_fe != 0, ExcNoFESelected());
Assert (false, ExcNotImplemented());
+template <>
void DoFHandler<1>::map_dof_to_boundary_indices (const FunctionMap &,
vector<int> &) const {
Assert (selected_fe != 0, ExcNoFESelected());
+template <>
void DoFHandler<1>::reserve_space () {
Assert (selected_fe != 0, ExcNoFESelected());
Assert (tria->n_levels() > 0, ExcInvalidTriangulation());
+template <>
void DoFHandler<2>::reserve_space () {
Assert (selected_fe != 0, ExcNoFESelected());
Assert (tria->n_levels() > 0, ExcInvalidTriangulation());
+template <>
FiniteElementBase<1>::FiniteElementBase (const unsigned int dofs_per_vertex,
const unsigned int dofs_per_line,
const unsigned int dofs_per_quad) :
+template <>
FiniteElementBase<2>::FiniteElementBase (const unsigned int dofs_per_vertex,
const unsigned int dofs_per_line,
const unsigned int dofs_per_quad) :
/*------------------------------- FiniteElement ----------------------*/
+// declare this function to be explicitely specialized before first use
+// egcs wants this, but gcc2.8.1 produces an internal compiler error, so
+// we drop this declaration again for the time being
+//template <>
+//void FiniteElement<1>::get_ansatz_points (const DoFHandler<1>::cell_iterator &cell,
+// const Boundary<1> &,
+// vector<Point<1> > &ansatz_points) const;
+
+
+template <>
void FiniteElement<1>::fill_fe_values (const DoFHandler<1>::cell_iterator &cell,
const vector<Point<1> > &unit_points,
vector<dFMatrix> &jacobians,
+template <>
void FiniteElement<1>::fill_fe_face_values (const DoFHandler<1>::cell_iterator &,
const unsigned int ,
const vector<Point<0> > &,
+template <>
void FiniteElement<1>::fill_fe_subface_values (const DoFHandler<1>::cell_iterator &,
const unsigned int ,
const unsigned int ,
+template <>
void FiniteElement<1>::get_ansatz_points (const DoFHandler<1>::cell_iterator &cell,
const Boundary<1> &,
vector<Point<1> > &ansatz_points) const {
+template <>
FELinear<1>::FELinear () :
FiniteElement<1> (1, 0)
{
+template <>
double
FELinear<1>::shape_value(const unsigned int i,
const Point<1>& p) const
+template <>
Point<1>
FELinear<1>::shape_grad(const unsigned int i,
const Point<1>&) const
case 1: return Point<1>(1.);
}
return Point<1>();
-}
+};
+template <>
void FELinear<1>::fill_fe_values (const DoFHandler<1>::cell_iterator &cell,
const vector<Point<1> > &unit_points,
vector<dFMatrix> &jacobians,
+template <>
void FELinear<1>::get_ansatz_points (const typename DoFHandler<1>::cell_iterator &cell,
const Boundary<1> &boundary,
vector<Point<1> > &ansatz_points) const {
+template <>
void FELinear<1>::get_face_ansatz_points (const typename DoFHandler<1>::face_iterator &,
const Boundary<1> &,
vector<Point<1> > &) const {
+template <>
void FELinear<1>::get_face_jacobians (const DoFHandler<1>::face_iterator &,
const Boundary<1> &,
const vector<Point<0> > &,
+template <>
void FELinear<1>::get_subface_jacobians (const DoFHandler<1>::face_iterator &,
const unsigned int ,
const vector<Point<0> > &,
+template <>
void FELinear<1>::get_normal_vectors (const DoFHandler<1>::cell_iterator &,
const unsigned int,
const Boundary<1> &,
+template <>
void FELinear<1>::get_normal_vectors (const DoFHandler<1>::cell_iterator &,
const unsigned int,
const unsigned int,
+template <>
FELinear<2>::FELinear () :
FiniteElement<2> (1, 0, 0)
{
+template <>
double
FELinear<2>::shape_value (const unsigned int i,
const Point<2>& p) const
+template <>
Point<2>
FELinear<2>::shape_grad (const unsigned int i,
const Point<2>& p) const
+template <>
void FELinear<2>::get_face_jacobians (const DoFHandler<2>::face_iterator &face,
const Boundary<2> &,
const vector<Point<1> > &unit_points,
+template <>
void FELinear<2>::get_subface_jacobians (const DoFHandler<2>::face_iterator &face,
const unsigned int,
const vector<Point<1> > &unit_points,
+template <>
void FELinear<2>::get_normal_vectors (const DoFHandler<2>::cell_iterator &cell,
const unsigned int face_no,
const Boundary<2> &,
+template <>
void FELinear<2>::get_normal_vectors (const DoFHandler<2>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int,
+template <>
FEQuadratic<1>::FEQuadratic () :
FiniteElement<1> (1, 1) {};
+template <>
void FEQuadratic<1>::fill_fe_values (const DoFHandler<1>::cell_iterator &cell,
const vector<Point<1> > &unit_points,
vector<dFMatrix> &jacobians,
+template <>
void FEQuadratic<1>::get_ansatz_points (const typename DoFHandler<1>::cell_iterator &cell,
const Boundary<1> &boundary,
vector<Point<1> > &ansatz_points) const {
+template <>
void FEQuadratic<1>::get_face_ansatz_points (const typename DoFHandler<1>::face_iterator &,
const Boundary<1> &,
vector<Point<1> > &) const {
+template <>
void FEQuadratic<1>::get_face_jacobians (const DoFHandler<1>::face_iterator &,
const Boundary<1> &,
const vector<Point<0> > &,
+template <>
void FEQuadratic<1>::get_subface_jacobians (const DoFHandler<1>::face_iterator &,
const unsigned int ,
const vector<Point<0> > &,
+template <>
void FEQuadratic<1>::get_normal_vectors (const DoFHandler<1>::cell_iterator &,
const unsigned int,
const Boundary<1> &,
+template <>
void FEQuadratic<1>::get_normal_vectors (const DoFHandler<1>::cell_iterator &,
const unsigned int,
const unsigned int,
+template <>
FEQuadratic<2>::FEQuadratic () :
FiniteElement<2> (1, 1, 1)
{
+template <>
FECubic<1>::FECubic () :
FiniteElement<1> (1, 2) {};
+template <>
void FECubic<1>::fill_fe_values (const DoFHandler<1>::cell_iterator &cell,
const vector<Point<1> > &unit_points,
vector<dFMatrix> &jacobians,
+template <>
void FECubic<1>::get_ansatz_points (const typename DoFHandler<1>::cell_iterator &cell,
const Boundary<1> &boundary,
vector<Point<1> > &ansatz_points) const {
+template <>
void FECubic<1>::get_face_ansatz_points (const typename DoFHandler<1>::face_iterator &,
const Boundary<1> &,
vector<Point<1> > &) const {
+template <>
void FECubic<1>::get_face_jacobians (const DoFHandler<1>::face_iterator &,
const Boundary<1> &,
const vector<Point<0> > &,
+template <>
void FECubic<1>::get_subface_jacobians (const DoFHandler<1>::face_iterator &,
const unsigned int ,
const vector<Point<0> > &,
+template <>
void FECubic<1>::get_normal_vectors (const DoFHandler<1>::cell_iterator &,
const unsigned int,
const Boundary<1> &,
+template <>
void FECubic<1>::get_normal_vectors (const DoFHandler<1>::cell_iterator &,
const unsigned int,
const unsigned int,
+template <>
FECubic<2>::FECubic () :
FiniteElement<2> (1, 2, 4) {};
/*------------------------ Functions: CellAccessor<1> -----------------------*/
+template <>
bool CellAccessor<1>::at_boundary () const {
return at_boundary(0) || at_boundary(1);
};
+template <>
unsigned char CellAccessor<1>::material_id () const {
Assert (used(),
typename TriaSubstructAccessor<1>::ExcRefineCellNotUsed());
+template <>
void CellAccessor<1>::set_material_id (const unsigned char mat_id) const {
Assert (used(),
typename TriaSubstructAccessor<1>::ExcRefineCellNotUsed());
+template <>
Triangulation<1>::face_iterator
CellAccessor<1>::face (const unsigned int) const {
Assert (false, ExcNotUsefulForThisDimension());
/*------------------------ Functions: CellAccessor<2> -----------------------*/
+template <>
bool CellAccessor<2>::at_boundary () const {
return at_boundary(0) || at_boundary(1) || at_boundary(2) || at_boundary(3);
};
+template <>
unsigned char CellAccessor<2>::material_id () const {
Assert (used(),
typename TriaSubstructAccessor<2>::ExcRefineCellNotUsed());
+template <>
void CellAccessor<2>::set_material_id (const unsigned char mat_id) const {
Assert (used(),
typename TriaSubstructAccessor<2>::ExcRefineCellNotUsed());
+template <>
Triangulation<2>::face_iterator
CellAccessor<2>::face (const unsigned int i) const {
return line(i);