// inlining and thus faster code.
+/**
+ * This is a switch class which only declares a @p typedef. It is meant to
+ * determine which class a DoFObjectAccessor class is to be derived
+ * from. By default, <tt>DoFObjectAccessor<celldim,dim></tt> derives from
+ * the @p typedef in the general <tt>DoFObjectAccessor_Inheritance<celldim,dim></tt>
+ * class, which is <tt>TriaObjectAccessor<celldim,dim></tt>,
+ * but if <tt>celldim==dim</tt>, then the specialization <tt>DoFObjectAccessor_Inheritance<dim,dim></tt>
+ * is used which declares its local type to be <tt>CellAccessor<dim></tt>. Therefore,
+ * the inheritance is automatically chosen to be from CellAccessor if the
+ * object under consideration has full dimension, i.e. constitutes a cell.
+ *
+ * @ingroup dofs
+ * @ingroup Accessors
+ * @author Wolfgang Bangerth, 1999
+ */
+template <int celldim, int dim>
+class DoFObjectAccessor_Inheritance
+{
+ public:
+ /**
+ * Declaration of the @p typedef.
+ * See the full documentation for
+ * more information.
+ */
+ typedef TriaObjectAccessor<celldim,dim> BaseClass;
+};
+
+
+/**
+ * This is a switch class which only declares a @p typedef. It is meant to
+ * determine which class a DoFObjectAccessor class is to be derived
+ * from. By default, <tt>DoFObjectAccessor<celldim,dim></tt> derives from
+ * the @p typedef in the general <tt>DoFObjectAccessor_Inheritance<celldim,dim></tt>
+ * class, which is <tt>TriaObjectAccessor<celldim,dim></tt>,
+ * but if <tt>celldim==dim</tt>, then the specialization <tt>DoFObjectAccessor_Inheritance<dim,dim></tt>
+ * is used which declares its local type to be <tt>CellAccessor<dim></tt>. Therefore,
+ * the inheritance is automatically chosen to be from CellAccessor if the
+ * object under consideration has full dimension, i.e. constitutes a cell.
+ *
+ * @ingroup dofs
+ * @ingroup Accessors
+ * @author Wolfgang Bangerth, 1999
+ */
+template <int dim>
+class DoFObjectAccessor_Inheritance<dim,dim>
+{
+ public:
+ /**
+ * Declaration of the @p typedef.
+ * See the full documentation for
+ * more information.
+ */
+ typedef CellAccessor<dim> BaseClass;
+};
+
+
+/* -------------------------------------------------------------------------- */
+
+
+
/**
* Define the base class for accessors to the degrees of
* freedom. Accessors are used to, well, access the data that pertains
* to edges, faces, and cells of a triangulation. The concept is
* explained in more detail in connection to @ref Iterators.
*
- * The template argument of this class refers to the type of DoF
- * handler we should work on. It can either be ::DoFHandler<dim> or
+ * The first template argument of this class refers to the structural
+ * dimension of the thing accessed: it is 1 for lines, 2 for quads, or
+ * 3 for hexes. The second argument denotes the type of DoF handler we
+ * should work on. It can either be ::DoFHandler<dim> or
* hp::DoFHandler<dim>. The space dimension of the object we are to
* work on is automatically extracted from the DH template argument.
*
+ * Depending on whether the structural dimension of the object
+ * accessed equals the space dimension on which the DoF handler object
+ * operates, this class is derived from CellAccessor or
+ * TriaObjectAccessor. This means that, for example accessors to quads
+ * in 2d have access to all the mesh aspects of cells, whereas
+ * accessors to quads in 3d can only access things that make sense for
+ * faces.
+ *
* @ingroup dofs
* @ingroup Accessors
* @author Wolfgang Bangerth, 1998
*/
-template <class DH>
-class DoFAccessor
+template <int structdim, class DH>
+class DoFAccessor : public DoFObjectAccessor_Inheritance<structdim, DH::dimension>::BaseClass
{
public:
/**
- * Constructor
+ * Declare a typedef to the base
+ * class to make accessing some
+ * of the exception classes
+ * simpler.
*/
- DoFAccessor ();
+ typedef
+ typename DoFObjectAccessor_Inheritance<structdim, DH::dimension>::BaseClass
+ BaseClass;
+
+ /**
+ * Data type passed by the iterator class.
+ */
+ typedef DH AccessorData;
/**
- * This should be the default constructor.
- * We cast away the constness of the
- * pointer which clearly is EVIL but
- * we can't help without making all
- * functions which could somehow use
- * iterators (directly or indirectly) make
- * non-const, even if they preserve
- * constness.
+ * Default constructor. Provides
+ * an accessor that can't be
+ * used.
+ */
+ DoFAccessor ();
+
+ /**
+ * Constructor
*/
- DoFAccessor (const DH *dof_handler);
+ DoFAccessor (const Triangulation<DH::dimension> *tria,
+ const int level,
+ const int index,
+ const DH *local_data);
/**
* Reset the DoF handler pointer.
/**
* Copy operator.
*/
- DoFAccessor<DH> &
- operator = (const DoFAccessor<DH> &da);
+ DoFAccessor<structdim,DH> &
+ operator = (const DoFAccessor<structdim,DH> &da);
+
+ /**
+ * Implement the copy operator needed
+ * for the iterator classes.
+ */
+ void copy_from (const DoFAccessor<structdim, DH> &a);
/**
* Exception for child classes
DeclException0 (ExcCantCompareIterators);
protected:
- /**
- * Compare for equality.
- */
- bool operator == (const DoFAccessor &) const;
-
- /**
- * Compare for inequality.
- */
- bool operator != (const DoFAccessor &) const;
- protected:
/**
* Store the address of the DoFHandler object
* to be accessed.
*/
- DH *dof_handler;
-};
-
+ DH *dof_handler;
-/* -------------------------------------------------------------------------- */
-
-/**
- * This is a switch class which only declares a @p typedef. It is meant to
- * determine which class a DoFObjectAccessor class is to be derived
- * from. By default, <tt>DoFObjectAccessor<celldim,dim></tt> derives from
- * the @p typedef in the general <tt>DoFObjectAccessor_Inheritance<celldim,dim></tt>
- * class, which is <tt>TriaObjectAccessor<celldim,dim></tt>,
- * but if <tt>celldim==dim</tt>, then the specialization <tt>DoFObjectAccessor_Inheritance<dim,dim></tt>
- * is used which declares its local type to be <tt>CellAccessor<dim></tt>. Therefore,
- * the inheritance is automatically chosen to be from CellAccessor if the
- * object under consideration has full dimension, i.e. constitutes a cell.
- *
- * @ingroup dofs
- * @ingroup Accessors
- * @author Wolfgang Bangerth, 1999
- */
-template <int celldim, int dim>
-class DoFObjectAccessor_Inheritance
-{
- public:
/**
- * Declaration of the @p typedef.
- * See the full documentation for
- * more information.
+ * Compare for equality.
*/
- typedef TriaObjectAccessor<celldim,dim> BaseClass;
-};
-
-
-/**
- * This is a switch class which only declares a @p typedef. It is meant to
- * determine which class a DoFObjectAccessor class is to be derived
- * from. By default, <tt>DoFObjectAccessor<celldim,dim></tt> derives from
- * the @p typedef in the general <tt>DoFObjectAccessor_Inheritance<celldim,dim></tt>
- * class, which is <tt>TriaObjectAccessor<celldim,dim></tt>,
- * but if <tt>celldim==dim</tt>, then the specialization <tt>DoFObjectAccessor_Inheritance<dim,dim></tt>
- * is used which declares its local type to be <tt>CellAccessor<dim></tt>. Therefore,
- * the inheritance is automatically chosen to be from CellAccessor if the
- * object under consideration has full dimension, i.e. constitutes a cell.
- *
- * @ingroup dofs
- * @ingroup Accessors
- * @author Wolfgang Bangerth, 1999
- */
-template <int dim>
-class DoFObjectAccessor_Inheritance<dim,dim>
-{
- public:
+ bool operator == (const DoFAccessor &) const;
+
/**
- * Declaration of the @p typedef.
- * See the full documentation for
- * more information.
+ * Compare for inequality.
*/
- typedef CellAccessor<dim> BaseClass;
+ bool operator != (const DoFAccessor &) const;
+
+ /**
+ * Iterator classes need to be friends
+ * because they need to access operator==
+ * and operator!=.
+ */
+ template <int, typename> friend class TriaRawIterator;
};
* @author Wolfgang Bangerth, 1998; Guido Kanschat, 1999
*/
template <int celldim, class DH>
-class DoFObjectAccessor : public DoFAccessor<DH>,
- public TriaObjectAccessor<celldim, DH::dimension>
+class DoFObjectAccessor : public DoFAccessor<celldim, DH>
{
public:
/**
* access to the DoF data.
*/
TriaIterator<dim,DoFObjectAccessor<celldim, DH> > child (const unsigned int) const;
-
- /**
- * Implement the copy operator needed
- * for the iterator classes.
- */
- void copy_from (const DoFObjectAccessor<celldim, DH> &a);
-
- protected:
- /**
- * Compare for equality.
- */
- bool operator == (const DoFObjectAccessor &) const;
-
- /**
- * Compare for inequality.
- */
- bool operator != (const DoFObjectAccessor &) const;
-
-
- /**
- * Iterator classes need to be friends
- * because they need to access operator==
- * and operator!=.
- */
- template <int, typename> friend class TriaRawIterator;
};
* @ingroup Accessors
*/
template <class DH>
-class DoFObjectAccessor<0, DH> : public DoFAccessor<DH>,
- public DoFObjectAccessor_Inheritance<0,DH::dimension>::BaseClass
+class DoFObjectAccessor<0, DH> : public DoFAccessor<0, DH>
{
public:
/**
* @author Wolfgang Bangerth, 1998
*/
template <class DH>
-class DoFObjectAccessor<1, DH> :
- public DoFAccessor<DH>,
- public DoFObjectAccessor_Inheritance<1,DH::dimension>::BaseClass
+class DoFObjectAccessor<1, DH> : public DoFAccessor<1,DH>
{
public:
/**
* Declare base class as a local typedef
* for simpler access.
*/
- typedef typename DoFObjectAccessor_Inheritance<1,dim>::BaseClass BaseClass;
+ typedef DoFAccessor<1,DH> BaseClass;
/**
* Default constructor, unused thus
* access to the DoF data.
*/
TriaIterator<DH::dimension,DoFObjectAccessor<1,DH> > child (const unsigned int) const;
-
- /**
- * Implement the copy operator needed
- * for the iterator classes.
- */
- void copy_from (const DoFObjectAccessor<1,DH> &a);
-
- protected:
- /**
- * Compare for equality.
- */
- bool operator == (const DoFObjectAccessor<1,DH> &) const;
-
- /**
- * Compare for inequality.
- */
- bool operator != (const DoFObjectAccessor<1,DH> &) const;
-
-
- /**
- * Iterator classes need to be friends
- * because they need to access operator==
- * and operator!=.
- */
- template <int, typename> friend class TriaRawIterator;
};
* @ingroup Accessors
*/
template <class DH>
-class DoFObjectAccessor<2, DH> :
- public DoFAccessor<DH>,
- public DoFObjectAccessor_Inheritance<2,DH::dimension>::BaseClass
+class DoFObjectAccessor<2, DH> : public DoFAccessor<2,DH>
{
public:
/**
* Declare base class as a local typedef
* for simpler access.
*/
- typedef typename DoFObjectAccessor_Inheritance<2,dim>::BaseClass BaseClass;
+ typedef DoFAccessor<2,DH> BaseClass;
/**
* Default constructor, unused thus
*/
TriaIterator<DH::dimension,DoFObjectAccessor<2, DH> >
child (const unsigned int) const;
-
- /**
- * Implement the copy operator needed
- * for the iterator classes.
- */
- void copy_from (const DoFObjectAccessor<2, DH> &a);
-
- protected:
- /**
- * Compare for equality.
- */
- bool operator == (const DoFObjectAccessor<2,DH> &) const;
-
- /**
- * Compare for inequality.
- */
- bool operator != (const DoFObjectAccessor<2,DH> &) const;
-
-
- /**
- * Iterator classes need to be friends
- * because they need to access operator==
- * and operator!=.
- */
- template <int, typename> friend class TriaRawIterator;
};
* @ingroup Accessors
*/
template <class DH>
-class DoFObjectAccessor<3, DH> :
- public DoFAccessor<DH>,
- public DoFObjectAccessor_Inheritance<3,DH::dimension>::BaseClass
+class DoFObjectAccessor<3, DH> : public DoFAccessor<3,DH>
{
public:
/**
* Declare base class as a local typedef
* for simpler access.
*/
- typedef typename DoFObjectAccessor_Inheritance<3,dim>::BaseClass BaseClass;
+ typedef DoFAccessor<1,DH> BaseClass;
/**
* Default constructor, unused thus
* access to the DoF data.
*/
TriaIterator<DH::dimension,DoFObjectAccessor<3, DH> > child (const unsigned int) const;
-
- /**
- * Implement the copy operator needed
- * for the iterator classes.
- */
- void copy_from (const DoFObjectAccessor<3, DH> &a);
-
- protected:
- /**
- * Compare for equality.
- */
- bool operator == (const DoFObjectAccessor<3,DH> &) const;
-
- /**
- * Compare for inequality.
- */
- bool operator != (const DoFObjectAccessor<3,DH> &) const;
-
-
- /**
- * Iterator classes need to be friends
- * because they need to access operator==
- * and operator!=.
- */
- template <int, typename> friend class TriaRawIterator;
};
* classes.
*/
typedef typename DoFObjectAccessor<DH::dimension,DH>::AccessorData AccessorData;
+
+ /**
+ * Declare a typedef to the base
+ * class to make accessing some
+ * of the exception classes
+ * simpler.
+ */
+ typedef DoFObjectAccessor<DH::dimension,DH> BaseClass;
/**
* Constructor
/*------------------------- Functions: DoFAccessor ---------------------------*/
-template <class DH>
-DoFAccessor<DH>::DoFAccessor ()
+template <int structdim, class DH>
+DoFAccessor<structdim,DH>::DoFAccessor ()
:
+ DoFObjectAccessor_Inheritance<structdim, DH::dimension>::BaseClass (0,
+ deal_II_numbers::invalid_unsigned_int,
+ deal_II_numbers::invalid_unsigned_int),
dof_handler(0)
{
Assert (false, ExcInvalidObject());
-template <class DH>
+template <int structdim, class DH>
inline
-DoFAccessor<DH>::DoFAccessor (const DH *dof_handler)
+DoFAccessor<structdim,DH>::DoFAccessor (const Triangulation<DH::dimension> *tria,
+ const int level,
+ const int index,
+ const DH *dof_handler)
:
- dof_handler(const_cast<DH*>(dof_handler))
+ DoFObjectAccessor_Inheritance<structdim, DH::dimension>::BaseClass (tria,
+ level,
+ index),
+ dof_handler(const_cast<DH*>(dof_handler))
{}
-template <class DH>
+template <int structdim, class DH>
void
-DoFAccessor<DH>::set_dof_handler (DH *dh)
+DoFAccessor<structdim,DH>::set_dof_handler (DH *dh)
{
Assert (dh != 0, ExcInvalidObject());
this->dof_handler = dh;
-template <class DH>
+template <int structdim, class DH>
inline
const DH &
-DoFAccessor<DH>::get_dof_handler () const
+DoFAccessor<structdim,DH>::get_dof_handler () const
{
return *this->dof_handler;
}
-template <class DH>
+template <int structdim, class DH>
inline
-DoFAccessor<DH> &
-DoFAccessor<DH>::operator = (const DoFAccessor<DH> &da)
+DoFAccessor<structdim,DH> &
+DoFAccessor<structdim,DH>::operator = (const DoFAccessor<structdim,DH> &da)
{
this->set_dof_handler (da.dof_handler);
return *this;
-template <class DH>
+template <int structdim, class DH>
+void
+DoFAccessor<structdim,DH>::copy_from (const DoFAccessor<structdim,DH> &a)
+{
+ BaseClass::copy_from (a);
+ set_dof_handler (a.dof_handler);
+}
+
+
+
+template <int structdim, class DH>
inline
bool
-DoFAccessor<DH>::operator == (const DoFAccessor<DH> &a) const
+DoFAccessor<structdim,DH>::operator == (const DoFAccessor<structdim,DH> &a) const
{
Assert (this->dof_handler == a.dof_handler, ExcCantCompareIterators());
-
- // there is no real data to compare, except
- // to make sure that the this->dof_handler
- // objects in use are the same
- return true;
+ return (BaseClass::operator == (a));
}
-
-template <class DH>
+template <int structdim, class DH>
inline
bool
-DoFAccessor<DH>::operator != (const DoFAccessor<DH> &a) const
+DoFAccessor<structdim,DH>::operator != (const DoFAccessor<structdim,DH> &a) const
{
Assert (this->dof_handler == a.dof_handler, ExcCantCompareIterators());
-
- // there is no real data to compare, except
- // to make sure that the this->dof_handler
- // objects in use are the same. this is
- // checked above, and apart from this there
- // is no reason for us to believe that the
- // two accessors are different
- return false;
+ return (BaseClass::operator != (a));
}
const int index,
const AccessorData *local_data)
:
- DoFAccessor<DH> (local_data),
- DoFObjectAccessor_Inheritance<1,DH::dimension>::BaseClass (tria,
- level,
- index)
+ DoFAccessor<1,DH> (tria, level, index, local_data)
{}
-template <class DH>
-inline
-void
-DoFObjectAccessor<1,DH>::copy_from (const DoFObjectAccessor<1,DH> &a)
-{
- BaseClass::copy_from (a);
- this->set_dof_handler (a.dof_handler);
-}
-
-
-
-template <class DH>
-inline
-bool
-DoFObjectAccessor<1,DH>::operator == (const DoFObjectAccessor<1,DH> &a) const
-{
- return (TriaObjectAccessor<1,dim>::operator == (a)
- &&
- DoFAccessor<DH>::operator == (a));
-}
-
-
-template <class DH>
-inline
-bool
-DoFObjectAccessor<1,DH>::operator != (const DoFObjectAccessor<1,DH> &a) const
-{
- return (TriaObjectAccessor<1,dim>::operator != (a)
- ||
- DoFAccessor<DH>::operator != (a));
-}
-
/*------------------------- Functions: DoFObjectAccessor<2,dim> -----------------------*/
const int index,
const AccessorData *local_data)
:
- DoFAccessor<DH> (local_data),
- DoFObjectAccessor_Inheritance<2,dim>::BaseClass (tria,
- level,
- index)
+ DoFAccessor<2,DH> (tria, level, index, local_data)
{}
-template <class DH>
-inline
-void
-DoFObjectAccessor<2,DH>::copy_from (const DoFObjectAccessor<2,DH> &a)
-{
- BaseClass::copy_from (a);
- this->set_dof_handler (a.dof_handler);
-}
-
-
-
-template <class DH>
-inline
-bool
-DoFObjectAccessor<2,DH>::operator == (const DoFObjectAccessor<2,DH> &a) const
-{
- return (TriaObjectAccessor<2,dim>::operator == (a)
- &&
- DoFAccessor<DH>::operator == (a));
-}
-
-
-template <class DH>
-inline
-bool
-DoFObjectAccessor<2,DH>::operator != (const DoFObjectAccessor<2,DH> &a) const
-{
- return (TriaObjectAccessor<2,dim>::operator != (a)
- ||
- DoFAccessor<DH>::operator != (a));
-}
-
-
-
/*------------------------- Functions: DoFObjectAccessor<3,dim> -----------------------*/
template <class DH>
const int index,
const AccessorData *local_data)
:
- DoFAccessor<DH> (local_data),
- DoFObjectAccessor_Inheritance<3,dim>::BaseClass (tria,
- level,
- index)
+ DoFAccessor<3,DH> (tria, level, index, local_data)
{}
TriaIterator<DH::dimension,DoFObjectAccessor<1,DH> >
DoFObjectAccessor<3,DH>::line (const unsigned int i) const
{
- TriaIterator<dim,TriaObjectAccessor<1,dim> > l = BaseClass::line(i);
+ TriaIterator<dim,TriaObjectAccessor<1,dim> > l = TriaObjectAccessor<3,DH::dimension>::line(i);
return TriaIterator<dim,DoFObjectAccessor<1,DH> >
(
this->tria,
}
-template <class DH>
-void DoFObjectAccessor<3,DH>::copy_from (const DoFObjectAccessor<3,DH> &a)
-{
- BaseClass::copy_from (a);
- this->set_dof_handler (a.dof_handler);
-}
-
-
-
-template <class DH>
-inline
-bool
-DoFObjectAccessor<3,DH>::operator == (const DoFObjectAccessor<3,DH> &a) const
-{
- return (TriaObjectAccessor<3,dim>::operator == (a)
- &&
- DoFAccessor<DH>::operator == (a));
-}
-
-
-template <class DH>
-inline
-bool
-DoFObjectAccessor<3,DH>::operator != (const DoFObjectAccessor<3,DH> &a) const
-{
- return (TriaObjectAccessor<3,dim>::operator != (a)
- ||
- DoFAccessor<DH>::operator != (a));
-}
-
-
/*--------------- Functions: DoFObjectAccessor<1,DoFHandler> -----------*/
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
- Assert (this->dof_handler != 0, DoFAccessor<DoFHandler<1> >::ExcInvalidObject());
+ Assert (this->dof_handler != 0, BaseClass::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<DoFHandler<1> >::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, BaseClass::ExcInvalidObject());
Assert (i<this->dof_handler->get_fe().dofs_per_line,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_line));
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
- Assert (this->dof_handler != 0, DoFAccessor<DoFHandler<1> >::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<DoFHandler<1> >::ExcInvalidObject());
+ Assert (this->dof_handler != 0, BaseClass::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, BaseClass::ExcInvalidObject());
Assert (vertex<2, ExcIndexRange (i,0,2));
Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_vertex));
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
- Assert (this->dof_handler != 0, DoFAccessor<DoFHandler<1> >::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<DoFHandler<1> >::ExcInvalidObject());
+ Assert (this->dof_handler != 0, BaseClass::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, BaseClass::ExcInvalidObject());
Assert (dof_indices.size() == (2*this->dof_handler->get_fe().dofs_per_vertex +
this->dof_handler->get_fe().dofs_per_line),
- DoFAccessor<DoFHandler<1> >::ExcVectorDoesNotMatch());
+ BaseClass::ExcVectorDoesNotMatch());
// this function really only makes
// sense on non-active objects if
Assert (!this->has_children() ||
(this->dof_handler->get_fe().dofs_per_cell ==
2*this->dof_handler->get_fe().dofs_per_vertex),
- DoFAccessor<DoFHandler<1> >::ExcNotActive());
+ BaseClass::ExcNotActive());
const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
dofs_per_line = this->dof_handler->get_fe().dofs_per_line;
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
- Assert (this->dof_handler != 0, DoFAccessor<DoFHandler<2> >::ExcInvalidObject());
+ Assert (this->dof_handler != 0, BaseClass::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<DoFHandler<2> >::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, BaseClass::ExcInvalidObject());
Assert (i<this->dof_handler->get_fe().dofs_per_line,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_line));
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
- Assert (this->dof_handler != 0, DoFAccessor<DoFHandler<2> >::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<DoFHandler<2> >::ExcInvalidObject());
+ Assert (this->dof_handler != 0, BaseClass::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, BaseClass::ExcInvalidObject());
Assert (vertex<2, ExcIndexRange (i,0,2));
Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_vertex));
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
- Assert (this->dof_handler != 0, DoFAccessor<DoFHandler<2> >::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<DoFHandler<2> >::ExcInvalidObject());
+ Assert (this->dof_handler != 0, BaseClass::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, BaseClass::ExcInvalidObject());
Assert (dof_indices.size() == (2*this->dof_handler->get_fe().dofs_per_vertex +
this->dof_handler->get_fe().dofs_per_line),
- DoFAccessor<DoFHandler<2> >::ExcVectorDoesNotMatch());
+ BaseClass::ExcVectorDoesNotMatch());
// this function really only makes
// sense on non-active objects if
Assert (!this->has_children() ||
(this->dof_handler->get_fe().dofs_per_cell ==
2*this->dof_handler->get_fe().dofs_per_vertex),
- DoFAccessor<DoFHandler<2> >::ExcNotActive());
+ BaseClass::ExcNotActive());
const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
dofs_per_line = this->dof_handler->get_fe().dofs_per_line;
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
- Assert (this->dof_handler != 0, DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ Assert (this->dof_handler != 0, BaseClass::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, BaseClass::ExcInvalidObject());
Assert (i<this->dof_handler->get_fe().dofs_per_line,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_line));
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
- Assert (this->dof_handler != 0, DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ Assert (this->dof_handler != 0, BaseClass::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, BaseClass::ExcInvalidObject());
Assert (vertex<2, ExcIndexRange (i,0,2));
Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_vertex));
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
- Assert (this->dof_handler != 0, DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ Assert (this->dof_handler != 0, BaseClass::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, BaseClass::ExcInvalidObject());
Assert (dof_indices.size() == (2*this->dof_handler->get_fe().dofs_per_vertex +
this->dof_handler->get_fe().dofs_per_line),
- DoFAccessor<DoFHandler<3> >::ExcVectorDoesNotMatch());
+ BaseClass::ExcVectorDoesNotMatch());
// this function really only makes
// sense on non-active objects if
Assert (!this->has_children() ||
(this->dof_handler->get_fe().dofs_per_cell ==
2*this->dof_handler->get_fe().dofs_per_vertex),
- DoFAccessor<DoFHandler<3> >::ExcNotActive());
+ BaseClass::ExcNotActive());
const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
dofs_per_line = this->dof_handler->get_fe().dofs_per_line;
Assert (fe_index == DoFHandler<2>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
Assert (this->dof_handler != 0,
- DoFAccessor<DoFHandler<2> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
Assert (&this->dof_handler->get_fe() != 0,
- DoFAccessor<DoFHandler<2> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (i<this->dof_handler->get_fe().dofs_per_quad,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_quad));
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
Assert (fe_index == DoFHandler<2>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
Assert (this->dof_handler != 0,
- DoFAccessor<DoFHandler<2> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (&this->dof_handler->get_fe() != 0,
- DoFAccessor<DoFHandler<2> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (vertex<4, ExcIndexRange (i,0,4));
Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_vertex));
Assert (fe_index == DoFHandler<2>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
Assert (this->dof_handler != 0,
- DoFAccessor<DoFHandler<2> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (&this->dof_handler->get_fe() != 0,
- DoFAccessor<DoFHandler<2> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (dof_indices.size() == (4*this->dof_handler->get_fe().dofs_per_vertex +
4*this->dof_handler->get_fe().dofs_per_line +
this->dof_handler->get_fe().dofs_per_quad),
- DoFAccessor<DoFHandler<2> >::ExcVectorDoesNotMatch());
+ BaseClass::ExcVectorDoesNotMatch());
// this function really only makes
// sense on non-active objects if
Assert (!this->has_children() ||
(this->dof_handler->get_fe().dofs_per_cell ==
4*this->dof_handler->get_fe().dofs_per_vertex),
- DoFAccessor<DoFHandler<2> >::ExcNotActive());
+ BaseClass::ExcNotActive());
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
Assert (fe_index == DoFHandler<3>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
Assert (this->dof_handler != 0,
- DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
Assert (&this->dof_handler->get_fe() != 0,
- DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (i<this->dof_handler->get_fe().dofs_per_quad,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_quad));
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
Assert (fe_index == DoFHandler<3>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
Assert (this->dof_handler != 0,
- DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (&this->dof_handler->get_fe() != 0,
- DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (vertex<4, ExcIndexRange (i,0,4));
Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_vertex));
Assert (fe_index == DoFHandler<3>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
Assert (this->dof_handler != 0,
- DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (&this->dof_handler->get_fe() != 0,
- DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (dof_indices.size() == (4*this->dof_handler->get_fe().dofs_per_vertex +
4*this->dof_handler->get_fe().dofs_per_line +
this->dof_handler->get_fe().dofs_per_quad),
- DoFAccessor<DoFHandler<3> >::ExcVectorDoesNotMatch());
+ BaseClass::ExcVectorDoesNotMatch());
// this function really only makes
// sense on non-active objects if
Assert (!this->has_children() ||
(this->dof_handler->get_fe().dofs_per_cell ==
4*this->dof_handler->get_fe().dofs_per_vertex),
- DoFAccessor<DoFHandler<3> >::ExcNotActive());
+ BaseClass::ExcNotActive());
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
Assert (fe_index == DoFHandler<3>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
Assert (this->dof_handler != 0,
- DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
Assert (&this->dof_handler->get_fe() != 0,
- DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (i<this->dof_handler->get_fe().dofs_per_hex,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_hex));
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
Assert (fe_index == DoFHandler<3>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
Assert (this->dof_handler != 0,
- DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (&this->dof_handler->get_fe() != 0,
- DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (vertex<8, ExcIndexRange (i,0,8));
Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_vertex));
Assert (fe_index == DoFHandler<3>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
Assert (this->dof_handler != 0,
- DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (&this->dof_handler->get_fe() != 0,
- DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (dof_indices.size() == (8*this->dof_handler->get_fe().dofs_per_vertex +
12*this->dof_handler->get_fe().dofs_per_line +
6*this->dof_handler->get_fe().dofs_per_quad +
this->dof_handler->get_fe().dofs_per_hex),
- DoFAccessor<DoFHandler<3> >::ExcVectorDoesNotMatch());
+ BaseClass::ExcVectorDoesNotMatch());
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
Assert (!this->has_children() ||
(this->dof_handler->get_fe().dofs_per_cell ==
8*this->dof_handler->get_fe().dofs_per_vertex),
- DoFAccessor<DoFHandler<3> >::ExcNotActive());
+ BaseClass::ExcNotActive());
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
- Assert (this->dof_handler != 0, DoFAccessor<hp::DoFHandler<1> >::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<hp::DoFHandler<1> >::ExcInvalidObject());
+ Assert (this->dof_handler != 0, BaseClass::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, BaseClass::ExcInvalidObject());
Assert (dof_indices.size() == (2*this->dof_handler->get_fe()[fe_index].dofs_per_vertex +
this->dof_handler->get_fe()[fe_index].dofs_per_line),
- DoFAccessor<hp::DoFHandler<1> >::ExcVectorDoesNotMatch());
+ BaseClass::ExcVectorDoesNotMatch());
// this function really only makes
// sense on non-active objects if
Assert (!this->has_children() ||
(this->dof_handler->get_fe()[fe_index].dofs_per_cell ==
2*this->dof_handler->get_fe()[fe_index].dofs_per_vertex),
- DoFAccessor<hp::DoFHandler<1> >::ExcNotActive());
+ BaseClass::ExcNotActive());
const unsigned int dofs_per_vertex = this->dof_handler->get_fe()[fe_index].dofs_per_vertex,
dofs_per_line = this->dof_handler->get_fe()[fe_index].dofs_per_line;
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
- Assert (this->dof_handler != 0, DoFAccessor<hp::DoFHandler<2> >::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<hp::DoFHandler<2> >::ExcInvalidObject());
+ Assert (this->dof_handler != 0, BaseClass::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, BaseClass::ExcInvalidObject());
Assert (dof_indices.size() == (2*this->dof_handler->get_fe()[fe_index].dofs_per_vertex +
this->dof_handler->get_fe()[fe_index].dofs_per_line),
- DoFAccessor<hp::DoFHandler<2> >::ExcVectorDoesNotMatch());
+ BaseClass::ExcVectorDoesNotMatch());
// this function really only makes
// sense on non-active objects if
Assert (!this->has_children() ||
(this->dof_handler->get_fe()[fe_index].dofs_per_cell ==
2*this->dof_handler->get_fe()[fe_index].dofs_per_vertex),
- DoFAccessor<hp::DoFHandler<2> >::ExcNotActive());
+ BaseClass::ExcNotActive());
const unsigned int dofs_per_vertex = this->dof_handler->get_fe()[fe_index].dofs_per_vertex,
dofs_per_line = this->dof_handler->get_fe()[fe_index].dofs_per_line;
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
- Assert (this->dof_handler != 0, DoFAccessor<hp::DoFHandler<3> >::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<hp::DoFHandler<3> >::ExcInvalidObject());
+ Assert (this->dof_handler != 0, BaseClass::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, BaseClass::ExcInvalidObject());
Assert (dof_indices.size() == (2*this->dof_handler->get_fe()[fe_index].dofs_per_vertex +
this->dof_handler->get_fe()[fe_index].dofs_per_line),
- DoFAccessor<hp::DoFHandler<3> >::ExcVectorDoesNotMatch());
+ BaseClass::ExcVectorDoesNotMatch());
// this function really only makes
// sense on non-active objects if
Assert (!this->has_children() ||
(this->dof_handler->get_fe()[fe_index].dofs_per_cell ==
2*this->dof_handler->get_fe()[fe_index].dofs_per_vertex),
- DoFAccessor<hp::DoFHandler<3> >::ExcNotActive());
+ BaseClass::ExcNotActive());
const unsigned int dofs_per_vertex = this->dof_handler->get_fe()[fe_index].dofs_per_vertex,
dofs_per_line = this->dof_handler->get_fe()[fe_index].dofs_per_line;
const unsigned int fe_index) const
{
Assert (this->dof_handler != 0,
- DoFAccessor<hp::DoFHandler<2> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (&this->dof_handler->get_fe() != 0,
- DoFAccessor<hp::DoFHandler<2> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (dof_indices.size() == (4*this->dof_handler->get_fe()[fe_index].dofs_per_vertex +
4*this->dof_handler->get_fe()[fe_index].dofs_per_line +
this->dof_handler->get_fe()[fe_index].dofs_per_quad),
- DoFAccessor<hp::DoFHandler<2> >::ExcVectorDoesNotMatch());
+ BaseClass::ExcVectorDoesNotMatch());
// this function really only makes
// sense on non-active objects if
Assert (!this->has_children() ||
(this->dof_handler->get_fe()[fe_index].dofs_per_cell ==
4*this->dof_handler->get_fe()[fe_index].dofs_per_vertex),
- DoFAccessor<hp::DoFHandler<2> >::ExcNotActive());
+ BaseClass::ExcNotActive());
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
const unsigned int fe_index) const
{
Assert (this->dof_handler != 0,
- DoFAccessor<hp::DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (&this->dof_handler->get_fe() != 0,
- DoFAccessor<hp::DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (dof_indices.size() == (4*this->dof_handler->get_fe()[fe_index].dofs_per_vertex +
4*this->dof_handler->get_fe()[fe_index].dofs_per_line +
this->dof_handler->get_fe()[fe_index].dofs_per_quad),
- DoFAccessor<hp::DoFHandler<3> >::ExcVectorDoesNotMatch());
+ BaseClass::ExcVectorDoesNotMatch());
// this function really only makes
// sense on non-active objects if
Assert (!this->has_children() ||
(this->dof_handler->get_fe()[fe_index].dofs_per_cell ==
4*this->dof_handler->get_fe()[fe_index].dofs_per_vertex),
- DoFAccessor<hp::DoFHandler<3> >::ExcNotActive());
+ BaseClass::ExcNotActive());
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
const unsigned int fe_index) const
{
Assert (this->dof_handler != 0,
- DoFAccessor<hp::DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (&this->dof_handler->get_fe() != 0,
- DoFAccessor<hp::DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (dof_indices.size() == (8*this->dof_handler->get_fe()[fe_index].dofs_per_vertex +
12*this->dof_handler->get_fe()[fe_index].dofs_per_line +
6*this->dof_handler->get_fe()[fe_index].dofs_per_quad +
this->dof_handler->get_fe()[fe_index].dofs_per_hex),
- DoFAccessor<hp::DoFHandler<3> >::ExcVectorDoesNotMatch());
+ BaseClass::ExcVectorDoesNotMatch());
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
Assert (!this->has_children() ||
(this->dof_handler->get_fe()[fe_index].dofs_per_cell ==
8*this->dof_handler->get_fe()[fe_index].dofs_per_vertex),
- DoFAccessor<hp::DoFHandler<3> >::ExcNotActive());
+ BaseClass::ExcNotActive());
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
void
DoFCellAccessor<DH>::set_active_fe_index (const unsigned int i)
{
- Assert (i == 0, typename DoFAccessor<DH>::ExcInvalidObject());
+ Assert (i == 0, typename BaseClass::BaseClass::ExcInvalidObject());
}
DoFCellAccessor<hp::DoFHandler<1> >::set_active_fe_index (const unsigned int i)
{
Assert (this->dof_handler != 0,
- DoFAccessor<hp::DoFHandler<1> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (static_cast<unsigned int>(this->present_level) <
this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
DoFCellAccessor<hp::DoFHandler<2> >::set_active_fe_index (const unsigned int i)
{
Assert (this->dof_handler != 0,
- DoFAccessor<hp::DoFHandler<2> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (static_cast<unsigned int>(this->present_level) <
this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
DoFCellAccessor<hp::DoFHandler<3> >::set_active_fe_index (const unsigned int i)
{
Assert (this->dof_handler != 0,
- DoFAccessor<hp::DoFHandler<3> >::ExcInvalidObject());
+ BaseClass::ExcInvalidObject());
Assert (static_cast<unsigned int>(this->present_level) <
this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
distribute_local_to_global (const Vector<number> &local_source,
OutputVector &global_destination) const
{
- // since the exception classes are
- // from a template dependent base
- // class, we have to fully qualify
- // them. to work around more
- // trouble, typedef the template
- // dependent base class to a
- // non-template dependent name and
- // use that to specify the
- // qualified exception names
- typedef DoFAccessor<DH> BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (&this->get_fe() != 0,
distribute_local_to_global (const FullMatrix<number> &local_source,
OutputMatrix &global_destination) const
{
- // since the exception classes are
- // from a template dependent base
- // class, we have to fully qualify
- // them. to work around more
- // trouble, typedef the template
- // dependent base class to a
- // non-template dependent name and
- // use that to specify the
- // qualified exception names
- typedef DoFAccessor<DH> BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (&this->get_fe() != 0,
{
Assert (fe_index == DoFHandler<1>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
- typedef DoFAccessor<DH> BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
// make sure a FE has been selected
{
Assert (fe_index == DoFHandler<1>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
- // since the exception classes are
- // from a template dependent base
- // class, we have to fully qualify
- // them. to work around more
- // trouble, typedef the template
- // dependent base class to a
- // non-template dependent name and
- // use that to specify the
- // qualified exception names
- typedef DoFAccessor<DH> BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (&this->dof_handler->get_fe() != 0,
{
Assert (fe_index == DoFHandler<1>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
- typedef DoFAccessor<DH> BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
// make sure a FE has been selected
{
Assert (fe_index == DoFHandler<1>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
- typedef DoFAccessor<DH> BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (&this->dof_handler->get_fe() != 0,
{
Assert (fe_index == DoFHandler<1>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
- typedef DoFAccessor<DH> BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
// make sure a FE has been selected
{
Assert (fe_index == DoFHandler<1>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
- typedef DoFAccessor<DH> BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (&this->dof_handler->get_fe() != 0,
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
- Assert (this->dof_handler != 0, DoFAccessor<DoFHandler<1> >::ExcInvalidObject());
- Assert (&this->get_fe() != 0, DoFAccessor<DoFHandler<1> >::ExcInvalidObject());
+ Assert (this->dof_handler != 0, BaseClass::ExcInvalidObject());
+ Assert (&this->get_fe() != 0, BaseClass::ExcInvalidObject());
// check as in documentation that
// cell is either active, or dofs
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
- Assert (this->dof_handler != 0, DoFAccessor<DoFHandler<2> >::ExcInvalidObject());
- Assert (&this->get_fe() != 0, DoFAccessor<DoFHandler<2> >::ExcInvalidObject());
+ Assert (this->dof_handler != 0, BaseClass::ExcInvalidObject());
+ Assert (&this->get_fe() != 0, BaseClass::ExcInvalidObject());
// check as in documentation that
// cell is either active, or dofs
Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
ExcMessage ("DoFHandler not initialized"));
- Assert (this->dof_handler != 0, DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
- Assert (&this->get_fe() != 0, DoFAccessor<DoFHandler<3> >::ExcInvalidObject());
+ Assert (this->dof_handler != 0, BaseClass::ExcInvalidObject());
+ Assert (&this->get_fe() != 0, BaseClass::ExcInvalidObject());
// check as in documentation that
// cell is either active, or dofs
const FiniteElement<dim> &fe = this->get_fe();
const unsigned int dofs_per_cell = fe.dofs_per_cell;
- typedef DoFAccessor<DH> BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (&fe != 0,
OutputVector &values) const
{
const unsigned int dofs_per_cell = this->get_fe().dofs_per_cell;
- typedef DoFAccessor<DH> BaseClass;
-
+
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (&this->get_fe() != 0,
#endif
-template class DoFAccessor<DoFHandler<deal_II_dimension> >;
-
#if deal_II_dimension == 1
+template class DoFAccessor<1, DoFHandler<1> >;
template class DoFObjectAccessor<1, DoFHandler<1> >;
#endif
#if deal_II_dimension == 2
+template class DoFAccessor<1, DoFHandler<2> >;
+template class DoFAccessor<2, DoFHandler<2> >;
+
template class DoFObjectAccessor<1, DoFHandler<2> >;
template class DoFObjectAccessor<2, DoFHandler<2> >;
#endif
#if deal_II_dimension == 3
+template class DoFAccessor<1, DoFHandler<3> >;
+template class DoFAccessor<2, DoFHandler<3> >;
+template class DoFAccessor<3, DoFHandler<3> >;
+
template class DoFObjectAccessor<1, DoFHandler<3> >;
template class DoFObjectAccessor<2, DoFHandler<3> >;
template class DoFObjectAccessor<3, DoFHandler<3> >;
#endif
-template class DoFAccessor<hp::DoFHandler<deal_II_dimension> >;
-
#if deal_II_dimension == 1
+template class DoFAccessor<1, hp::DoFHandler<1> >;
template class DoFObjectAccessor<1, hp::DoFHandler<1> >;
#endif
#if deal_II_dimension == 2
+template class DoFAccessor<1, hp::DoFHandler<2> >;
+template class DoFAccessor<2, hp::DoFHandler<2> >;
+
template class DoFObjectAccessor<1, hp::DoFHandler<2> >;
template class DoFObjectAccessor<2, hp::DoFHandler<2> >;
#if deal_II_dimension == 3
+template class DoFAccessor<1, hp::DoFHandler<3> >;
+template class DoFAccessor<2, hp::DoFHandler<3> >;
+template class DoFAccessor<3, hp::DoFHandler<3> >;
+
template class DoFObjectAccessor<1, hp::DoFHandler<3> >;
template class DoFObjectAccessor<2, hp::DoFHandler<3> >;
template class DoFObjectAccessor<3, hp::DoFHandler<3> >;
template <int dim>
unsigned int MGDoFObjectAccessor<1, dim>::mg_dof_index (const unsigned int i) const
{
- typedef DoFAccessor<DoFHandler<dim> > BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
void MGDoFObjectAccessor<1, dim>::set_mg_dof_index (const unsigned int i,
const unsigned int index) const
{
- typedef DoFAccessor<DoFHandler<dim> > BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
unsigned int MGDoFObjectAccessor<1, dim>::mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i) const
{
- typedef DoFAccessor<DoFHandler<dim> > BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
const unsigned int i,
const unsigned int index) const
{
- typedef DoFAccessor<DoFHandler<dim> > BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
void
MGDoFObjectAccessor<1, dim>::get_mg_dof_indices (std::vector<unsigned int> &dof_indices) const
{
- typedef DoFAccessor<DoFHandler<dim> > BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
MGDoFObjectAccessor<1,dim>::get_mg_dof_values (const Vector<number> &values,
Vector<number> &dof_values) const
{
- typedef DoFAccessor<DoFHandler<1> > BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
template <int dim>
unsigned int MGDoFObjectAccessor<2, dim>::mg_dof_index (const unsigned int i) const
{
- typedef DoFAccessor<DoFHandler<dim> > BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
void MGDoFObjectAccessor<2, dim>::set_mg_dof_index (const unsigned int i,
const unsigned int index) const
{
- typedef DoFAccessor<DoFHandler<dim> > BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
unsigned int MGDoFObjectAccessor<2, dim>::mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i) const
{
- typedef DoFAccessor<DoFHandler<dim> > BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
const unsigned int i,
const unsigned int index) const
{
- typedef DoFAccessor<DoFHandler<dim> > BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
void
MGDoFObjectAccessor<2, dim>::get_mg_dof_indices (std::vector<unsigned int> &dof_indices) const
{
- typedef DoFAccessor<DoFHandler<dim> > BaseClass;
- typedef DoFAccessor<DoFHandler<2> > BaseClass2D;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
Assert (dof_indices.size() == (4*this->dof_handler->get_fe().dofs_per_vertex +
4*this->dof_handler->get_fe().dofs_per_line +
this->dof_handler->get_fe().dofs_per_quad),
- typename BaseClass2D::ExcVectorDoesNotMatch());
+ typename BaseClass::ExcVectorDoesNotMatch());
const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
dofs_per_line = this->dof_handler->get_fe().dofs_per_line,
MGDoFObjectAccessor<2,dim>::get_mg_dof_values (const Vector<number> &values,
Vector<number> &dof_values) const
{
- typedef DoFAccessor<DoFHandler<2> > BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
template <int dim>
unsigned int MGDoFObjectAccessor<3, dim>::mg_dof_index (const unsigned int i) const
{
- typedef DoFAccessor<DoFHandler<dim> > BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
void MGDoFObjectAccessor<3, dim>::set_mg_dof_index (const unsigned int i,
const unsigned int index) const
{
- typedef DoFAccessor<DoFHandler<dim> > BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
unsigned int MGDoFObjectAccessor<3, dim>::mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i) const
{
- typedef DoFAccessor<DoFHandler<dim> > BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
const unsigned int i,
const unsigned int index) const
{
- typedef DoFAccessor<DoFHandler<dim> > BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
void
MGDoFObjectAccessor<3, dim>::get_mg_dof_indices (std::vector<unsigned int> &dof_indices) const
{
- typedef DoFAccessor<DoFHandler<dim> > BaseClass;
- typedef DoFAccessor<DoFHandler<3> > BaseClass3D;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
12*this->dof_handler->get_fe().dofs_per_line +
6*this->dof_handler->get_fe().dofs_per_quad +
this->dof_handler->get_fe().dofs_per_hex),
- typename BaseClass3D::ExcVectorDoesNotMatch());
+ typename BaseClass::ExcVectorDoesNotMatch());
const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
dofs_per_line = this->dof_handler->get_fe().dofs_per_line,
MGDoFObjectAccessor<3,dim>::get_mg_dof_values (const Vector<number> &values,
Vector<number> &dof_values) const
{
- typedef DoFAccessor<DoFHandler<3> > BaseClass;
-
Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
Assert (this->mg_dof_handler != 0,
projects / dealii.git / commitdiff