// that the <code>refine_mesh</code> function takes arguments for the
// minimal and maximal mesh refinement level. The purpose of this is
// discussed in the introduction.
- template<int dim>
+ template <int dim>
class HeatEquation
{
public:
// right hand side is chosen as discussed at the end of the
// introduction. For boundary values, we choose zero values, but this is
// easily changed below.
- template<int dim>
+ template <int dim>
class RightHandSide : public Function<dim>
{
public:
- template<int dim>
+ template <int dim>
double RightHandSide<dim>::value (const Point<dim> &p,
const unsigned int component) const
{
- template<int dim>
+ template <int dim>
class BoundaryValues : public Function<dim>
{
public:
- template<int dim>
+ template <int dim>
double BoundaryValues<dim>::value (const Point<dim> &/*p*/,
const unsigned int component) const
{
// on the right hand side was set to 0.2 above, so we resolve each
// period with 100 time steps) and chooses the Crank Nicolson method
// by setting $\theta=1/2$.
- template<int dim>
+ template <int dim>
HeatEquation<dim>::HeatEquation ()
:
fe(1),
// that defaults to an empty object). This is because we are going to
// condense the constraints in run() after combining the matrices for the
// current time-step.
- template<int dim>
+ template <int dim>
void HeatEquation<dim>::setup_system()
{
dof_handler.distribute_dofs(fe);
//
// The next function is the one that solves the actual linear system
// for a single time step. There is nothing surprising here:
- template<int dim>
+ template <int dim>
void HeatEquation<dim>::solve_time_step()
{
SolverControl solver_control(1000, 1e-8 * system_rhs.l2_norm());
// @sect4{<code>HeatEquation::output_results</code>}
//
// Neither is there anything new in generating graphical output:
- template<int dim>
+ template <int dim>
void HeatEquation<dim>::output_results() const
{
DataOut<dim> data_out;
// as here. Instead of trying to justify the occurrence here,
// let's first look at the code and we'll come back to the issue
// at the end of function.
- template<int dim>
+ template <int dim>
void HeatEquation<dim>::run()
{
const unsigned int initial_global_refinement = 2;
// as an argument is the index of the unit support point where the
// singularity is located.
- template<>
+ template <>
const Quadrature<2> &BEMProblem<3>::get_singular_quadrature(
const DoFHandler<2,3>::active_cell_iterator &,
const unsigned int index) const
}
- template<>
+ template <>
const Quadrature<1> &BEMProblem<2>::get_singular_quadrature(
const DoFHandler<1,2>::active_cell_iterator &cell,
const unsigned int index) const
*
* @ingroup output
*/
- template<typename FlagsType>
+ template <typename FlagsType>
struct OutputFlagsBase
{
/**
};
- template<typename FlagsType>
+ template <typename FlagsType>
void OutputFlagsBase<FlagsType>::declare_parameters (ParameterHandler &)
{}
- template<typename FlagsType>
+ template <typename FlagsType>
void OutputFlagsBase<FlagsType>::parse_parameters (const ParameterHandler &)
{}
- template<typename FlagsType>
+ template <typename FlagsType>
std::size_t OutputFlagsBase<FlagsType>::memory_consumption () const
{
return sizeof(FlagsType);
* the point already exists and we are filtering redundant values, the
* provided index will internally refer to another recorded point.
*/
- template<int dim>
+ template <int dim>
void write_point(const unsigned int &index, const Point<dim> &p);
/**
* Record a deal.II cell in the internal reordered format.
*/
- template<int dim>
+ template <int dim>
void write_cell(unsigned int index, unsigned int start, unsigned int d1, unsigned int d2, unsigned int d3);
/**
* Set the flags to be used for output. This method expects <tt>flags</tt>
* to be a member of one of the child classes of <tt>OutputFlagsBase</tt>.
*/
- template<typename FlagType>
+ template <typename FlagType>
void set_flags (const FlagType &flags);
* @ingroup functions
* @author: Guido Kanschat, 1999
*/
- template<int dim>
+ template <int dim>
class SquareFunction : public Function<dim>
{
public:
* @ingroup functions
* @author: Guido Kanschat, 2000
*/
- template<int dim>
+ template <int dim>
class Q1WedgeFunction : public Function<dim>
{
public:
* @ingroup functions
* @author: Guido Kanschat, 1999
*/
- template<int dim>
+ template <int dim>
class PillowFunction : public Function<dim>
{
public:
* @ingroup functions
* @author Guido Kanschat, 1999
*/
- template<int dim>
+ template <int dim>
class CosineFunction : public Function<dim>
{
public:
* @ingroup functions
* @author Guido Kanschat, 2010
*/
- template<int dim>
+ template <int dim>
class CosineGradFunction : public Function<dim>
{
public:
* @ingroup functions
* @author Guido Kanschat, 1999
*/
- template<int dim>
+ template <int dim>
class ExpFunction : public Function<dim>
{
public:
* @ingroup functions
* @author: Guido Kanschat, 2000
*/
- template<int dim>
+ template <int dim>
class JumpFunction : public Function<dim>
{
public:
* @ingroup functions
* @author Guido Kanschat, 2001, 2002
*/
- template<int dim>
+ template <int dim>
class CutOffFunctionLinfty : public CutOffFunctionBase<dim>
{
public:
* @ingroup functions
* @author Guido Kanschat, 2001, 2002
*/
- template<int dim>
+ template <int dim>
class CutOffFunctionW1 : public CutOffFunctionBase<dim>
{
public:
* @ingroup functions
* @author Guido Kanschat, 2001, 2002
*/
- template<int dim>
+ template <int dim>
class CutOffFunctionCinfty : public CutOffFunctionBase<dim>
{
public:
#ifndef DOXYGEN
-template<typename Number>
+template <typename Number>
inline Number
FunctionTime<Number>::get_time () const
{
DEAL_II_NAMESPACE_OPEN
-template<typename Number>
+template <typename Number>
FunctionTime<Number>::FunctionTime(const Number initial_time)
:
time(initial_time)
-template<typename Number>
+template <typename Number>
FunctionTime<Number>::~FunctionTime()
{}
-template<typename Number>
+template <typename Number>
void
FunctionTime<Number>::set_time (const Number new_time)
{
}
-template<typename Number>
+template <typename Number>
void
FunctionTime<Number>::advance_time (const Number delta_t)
{
* @note This returns the size of the pointer, not the size of the object
* pointed to.
*/
- template<typename T>
+ template <typename T>
inline
std::size_t
memory_consumption (const T *const);
- template<typename T>
+ template <typename T>
inline
std::size_t
memory_consumption(const T *const)
* @ingroup data
* @author Wolfgang Bangerth, Guido Kanschat, 1999, 2005, 2010
*/
-template<class Object>
+template <class Object>
class MGLevelObject : public Subscriptor
{
public:
/* ------------------------------------------------------------------- */
-template<class Object>
+template <class Object>
MGLevelObject<Object>::MGLevelObject(const unsigned int min,
const unsigned int max)
:
}
-template<class Object>
+template <class Object>
Object &
MGLevelObject<Object>::operator[] (const unsigned int i)
{
}
-template<class Object>
+template <class Object>
const Object &
MGLevelObject<Object>::operator[] (const unsigned int i) const
{
}
-template<class Object>
+template <class Object>
void
MGLevelObject<Object>::resize (const unsigned int new_minlevel,
const unsigned int new_maxlevel)
}
-template<class Object>
+template <class Object>
MGLevelObject<Object> &
MGLevelObject<Object>::operator = (const double d)
{
}
-template<class Object>
+template <class Object>
void
MGLevelObject<Object>::clear () // DEPRECATED
{
}
-template<class Object>
+template <class Object>
void
MGLevelObject<Object>::clear_elements ()
{
}
-template<class Object>
+template <class Object>
unsigned int
MGLevelObject<Object>::min_level () const
{
}
-template<class Object>
+template <class Object>
unsigned int
MGLevelObject<Object>::max_level () const
{
}
-template<class Object>
+template <class Object>
std::size_t
MGLevelObject<Object>::memory_consumption () const
{
template <int dim, typename Number>
-template<typename OtherNumber>
+template <typename OtherNumber>
inline
Point<dim,typename ProductType<Number, typename EnableIfScalar<OtherNumber>::type>::type>
Point<dim,Number>::operator * (const OtherNumber factor) const
template <int dim, typename Number>
-template<typename OtherNumber>
+template <typename OtherNumber>
inline
Point<dim,typename ProductType<Number, typename EnableIfScalar<OtherNumber>::type>::type>
Point<dim,Number>::operator / (const OtherNumber factor) const
}
-template<int dim>
+template <int dim>
inline
unsigned int
PolynomialSpace<dim>::n() const
-template<int dim>
+template <int dim>
inline
unsigned int
PolynomialSpace<dim>::degree() const
// ------------------- inline and template functions ----------------
-template<int dim>
+template <int dim>
inline
unsigned int
Quadrature<dim>::size () const
* @pre The type @p T needs to either equal @p DataType, or be a class derived
* from @p DataType. @p T needs to be default constructible.
*/
- template<typename T=DataType>
+ template <typename T=DataType>
void initialize(const CellIteratorType &cell,
const unsigned int number_of_data_points_per_cell);
* until, but not including, @p cell_end for all locally owned cells, i.e.
* for which `cell->is_locally_owned()==true` .
*/
- template<typename T=DataType>
+ template <typename T=DataType>
void initialize(const CellIteratorType &cell_start,
const CellIteratorType &cell_end,
const unsigned int number_of_data_points_per_cell);
*
* @pre The type @p T needs to match the class provided to initialize() .
*/
- template<typename T=DataType>
+ template <typename T=DataType>
std::vector<std::shared_ptr<T> > get_data(const CellIteratorType &cell);
/**
*
* @pre The type @p T needs to match the class provided to initialize() .
*/
- template<typename T=DataType>
+ template <typename T=DataType>
std::vector<std::shared_ptr<const T> > get_data(const CellIteratorType &cell) const;
private:
template <typename CellIteratorType, typename DataType>
-template<typename T>
+template <typename T>
void CellDataStorage<CellIteratorType,DataType>::initialize(const CellIteratorType &cell,
const unsigned int n_q_points)
{
template <typename CellIteratorType, typename DataType>
-template<typename T>
+template <typename T>
void CellDataStorage<CellIteratorType,DataType>::initialize(const CellIteratorType &cell_start,
const CellIteratorType &cell_end,
const unsigned int number)
* whereas the second index represents different values stored at each
* quadrature point in the DataType class.
*/
-template<typename CellIteratorType, typename DataType>
+template <typename CellIteratorType, typename DataType>
void pack_cell_data
(const CellIteratorType &cell,
const CellDataStorage<CellIteratorType,DataType> *data_storage,
/*
* the opposite of the pack function above.
*/
-template<typename CellIteratorType, typename DataType>
+template <typename CellIteratorType, typename DataType>
void unpack_to_cell_data
(const CellIteratorType &cell,
const FullMatrix<double> &values_at_qp,
{
namespace distributed
{
- template<int dim, typename DataType>
+ template <int dim, typename DataType>
ContinuousQuadratureDataTransfer<dim,DataType>::ContinuousQuadratureDataTransfer
(const FiniteElement<dim> &projection_fe_,
const Quadrature<dim> &lhs_quadrature,
- template<int dim, typename DataType>
+ template <int dim, typename DataType>
ContinuousQuadratureDataTransfer<dim,DataType>::~ContinuousQuadratureDataTransfer()
{}
- template<int dim, typename DataType>
+ template <int dim, typename DataType>
void ContinuousQuadratureDataTransfer<dim,DataType>::prepare_for_coarsening_and_refinement
(parallel::distributed::Triangulation<dim> &tr_,
CellDataStorage<CellIteratorType,DataType> &data_storage_)
- template<int dim, typename DataType>
+ template <int dim, typename DataType>
void ContinuousQuadratureDataTransfer<dim,DataType>::interpolate ()
{
triangulation->notify_ready_to_unpack(offset,
- template<int dim, typename DataType>
+ template <int dim, typename DataType>
void ContinuousQuadratureDataTransfer<dim,DataType>::pack_function
(const typename parallel::distributed::Triangulation<dim,dim>::cell_iterator &cell,
const typename parallel::distributed::Triangulation<dim,dim>::CellStatus /*status*/,
- template<int dim, typename DataType>
+ template <int dim, typename DataType>
void ContinuousQuadratureDataTransfer<dim,DataType>::
unpack_function (const typename parallel::distributed::Triangulation<dim,dim>::cell_iterator &cell,
const typename parallel::distributed::Triangulation<dim,dim>::CellStatus status,
* @ingroup Quadrature
* @author Ralf Schulz, 2003
*/
-template<int dim>
+template <int dim>
class QuadratureSelector : public Quadrature<dim>
{
public:
* @ingroup memory
* @author Guido Kanschat, Wolfgang Bangerth, 1998 - 2009
*/
-template<typename T, typename P = void>
+template <typename T, typename P = void>
class SmartPointer
{
public:
* This function requires that the type <tt>T2</tt> is convertible to
* <tt>T</tt>.
*/
- template<typename T2>
+ template <typename T2>
TableBase<N,T> &operator = (const TableBase<N,T2> &src);
/**
*/
template <class Archive>
void save(Archive &ar, const unsigned int version) const;
- template<class Archive>
+ template <class Archive>
void load(Archive &ar, const unsigned int version);
BOOST_SERIALIZATION_SPLIT_MEMBER()
-template<class Archive>
+template <class Archive>
void
TableHandler::Column::load(Archive &ar, const unsigned int /*version*/)
{
/**
* Test for equality of two tensors.
*/
- template<typename OtherNumber>
+ template <typename OtherNumber>
bool operator == (const Tensor<0,dim,OtherNumber> &rhs) const;
/**
* Test for inequality of two tensors.
*/
- template<typename OtherNumber>
+ template <typename OtherNumber>
bool operator != (const Tensor<0,dim,OtherNumber> &rhs) const;
/**
* Add another scalar
*/
- template<typename OtherNumber>
+ template <typename OtherNumber>
Tensor<0,dim,Number> &operator += (const Tensor<0,dim,OtherNumber> &rhs);
/**
* Subtract another scalar.
*/
- template<typename OtherNumber>
+ template <typename OtherNumber>
Tensor<0,dim,Number> &operator -= (const Tensor<0,dim,OtherNumber> &rhs);
/**
*
* @ingroup CUDAWrappers
*/
- template<typename OtherNumber>
+ template <typename OtherNumber>
DEAL_II_CUDA_HOST_DEV Tensor<0,dim,Number> &operator *= (const OtherNumber factor);
/**
* Divide the scalar by <tt>factor</tt>.
*/
- template<typename OtherNumber>
+ template <typename OtherNumber>
Tensor<0,dim,Number> &operator /= (const OtherNumber factor);
/**
* @relates Tensor
* @author Matthias Maier, 2015, Jean-Paul Pelteret 2017
*/
-template <template<int, int, typename> class TensorT1,
- template<int, int, typename> class TensorT2,
- template<int, int, typename> class TensorT3,
+template <template <int, int, typename> class TensorT1,
+ template <int, int, typename> class TensorT2,
+ template <int, int, typename> class TensorT3,
int rank_1, int rank_2, int dim,
typename T1, typename T2, typename T3>
typename ProductType<T1, typename ProductType<T2, T3>::type>::type
* <code>operator[](unsigned int)</code> that returns a (const or non-const)
* reference of <code>value_type</code>:
* @code
- * template<...>
+ * template <...>
* class T
* {
* typedef ... value_type;
*
* @author Matthias Maier, 2015
*/
- template<int rank, typename T, typename ArrayType> typename
+ template <int rank, typename T, typename ArrayType> typename
ReturnType<rank, T>::value_type &
extract(T &t, const ArrayType &indices)
{
* StoreIndex and ReorderedIndexView that return rvalues, we have to
* return by value.
*/
- template<typename T>
+ template <typename T>
struct ReferenceType
{
typedef T &type;
// Straightforward recursion implemented by specializing ExtractHelper
// for position == rank. We use the type trait ReturnType<rank, T> to
// have an idea what the final type will be.
- template<int position, int rank>
+ template <int position, int rank>
struct ExtractHelper
{
- template<typename T, typename ArrayType>
+ template <typename T, typename ArrayType>
inline
static
typename ReturnType<rank - position, T>::value_type &
// For position == rank there is nothing to extract, just return the
// object.
- template<int rank>
+ template <int rank>
struct ExtractHelper<rank, rank>
{
- template<typename T, typename ArrayType>
+ template <typename T, typename ArrayType>
inline
static
T &extract(T &t,
class Contract
{
public:
- template<typename T1, typename T2, typename T3>
+ template <typename T1, typename T2, typename T3>
inline DEAL_II_ALWAYS_INLINE static
void contract(T1 &result, const T2 &left, const T3 &right)
{
class Contract<no_contr, no_contr, rank_2, dim>
{
public:
- template<typename T1, typename T2, typename T3>
+ template <typename T1, typename T2, typename T3>
inline DEAL_II_ALWAYS_INLINE static
void contract(T1 &result, const T2 &left, const T3 &right)
{
class Contract<no_contr, no_contr, no_contr, dim>
{
public:
- template<typename T1, typename T2, typename T3>
+ template <typename T1, typename T2, typename T3>
inline DEAL_II_ALWAYS_INLINE static
void contract(T1 &result, const T2 &left, const T3 &right)
{
class Contract2
{
public:
- template<typename T1, typename T2, typename T3>
+ template <typename T1, typename T2, typename T3>
inline DEAL_II_ALWAYS_INLINE static
T1 contract2(const T2 &left, const T3 &right)
{
class Contract2<0, dim>
{
public:
- template<typename T1, typename T2, typename T3>
+ template <typename T1, typename T2, typename T3>
inline DEAL_II_ALWAYS_INLINE static
T1 contract2(const T2 &left, const T3 &right)
{
class Contract3
{
public:
- template<typename T1, typename T2, typename T3, typename T4>
+ template <typename T1, typename T2, typename T3, typename T4>
static inline
T1 contract3(const T2 &left, const T3 &middle, const T4 &right)
{
class Contract3<0, rank_2, dim>
{
public:
- template<typename T1, typename T2, typename T3, typename T4>
+ template <typename T1, typename T2, typename T3, typename T4>
static inline
T1 contract3(const T2 &left, const T3 &middle, const T4 &right)
{
class Contract3<0, 0, dim>
{
public:
- template<typename T1, typename T2, typename T3, typename T4>
+ template <typename T1, typename T2, typename T3, typename T4>
static inline
T1 contract3(const T2 &left, const T3 &middle, const T4 &right)
{
* This function simply makes the assumption that the sequence is sorted,
* and we simply don't do the additional check.
*/
- template<typename Iterator, typename T>
+ template <typename Iterator, typename T>
Iterator
lower_bound (Iterator first,
Iterator last,
* compare individual elements of the sequence of objects pointed to by the
* iterators.
*/
- template<typename Iterator, typename T, typename Comp>
+ template <typename Iterator, typename T, typename Comp>
Iterator
lower_bound (Iterator first,
Iterator last,
- template<typename Iterator, typename T>
+ template <typename Iterator, typename T>
inline
Iterator
lower_bound (Iterator first,
- template<typename Iterator, typename T, typename Comp>
+ template <typename Iterator, typename T, typename Comp>
inline
Iterator
lower_bound (Iterator first,
// Enable the EnableIfScalar type trait for VectorizedArray<Number> such
// that it can be used as a Number type in Tensor<rank,dim,Number>, etc.
-template<typename Number>
+template <typename Number>
struct EnableIfScalar<VectorizedArray<Number> >
{
typedef VectorizedArray<typename EnableIfScalar<Number>::type> type;
/**
* Specialization for float and AVX512.
*/
-template<>
+template <>
class VectorizedArray<float>
{
public:
/**
* Specialization for float and AVX.
*/
-template<>
+template <>
class VectorizedArray<float>
{
public:
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
static
types::global_dof_index
mg_vertex_dof_index (const dealii::DoFHandler<dim,spacedim> &dof_handler,
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
static
types::global_dof_index
mg_vertex_dof_index (const dealii::hp::DoFHandler<dim,spacedim> &,
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
static
void
set_mg_vertex_dof_index (dealii::DoFHandler<dim,spacedim> &dof_handler,
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
static
void
set_mg_vertex_dof_index (dealii::hp::DoFHandler<dim,spacedim> &,
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
static
types::global_dof_index
get_vertex_dof_index (const dealii::hp::DoFHandler<dim,spacedim> &dof_handler,
* Return the number of different finite elements that are active on a
* given vertex.
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
static
unsigned int
n_active_vertex_fe_indices (const dealii::hp::DoFHandler<dim,spacedim> &dof_handler,
* Return the fe index of the n-th finite element active on a given
* vertex.
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
static
unsigned int
nth_active_vertex_fe_index (const dealii::hp::DoFHandler<dim,spacedim> &dof_handler,
* Return whether a particular finite element index is active on the
* specified vertex.
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
static
bool
fe_is_active_on_vertex (const dealii::hp::DoFHandler<dim,spacedim> &dof_handler,
}
}
- template<typename DoFHandlerType, bool level_dof_access>
+ template <typename DoFHandlerType, bool level_dof_access>
static
void set_mg_dof_indices (const dealii::DoFAccessor<1,DoFHandlerType,level_dof_access> &,
const int,
- template<typename DoFHandlerType, bool level_dof_access>
+ template <typename DoFHandlerType, bool level_dof_access>
static
void set_mg_dof_indices (dealii::DoFAccessor<2, DoFHandlerType,level_dof_access> &accessor,
const int level,
- template<typename DoFHandlerType, bool level_dof_access>
+ template <typename DoFHandlerType, bool level_dof_access>
static
void set_mg_dof_indices
(const dealii::DoFAccessor<3, DoFHandlerType,level_dof_access> &accessor,
}
-template<int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
inline
types::global_dof_index
DoFAccessor<structdim, DoFHandlerType,level_dof_access>::mg_dof_index (const int level,
}
-template<int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
inline
types::global_dof_index
DoFAccessor<structdim, DoFHandlerType,level_dof_access>::mg_vertex_dof_index (const int level,
}
-template<int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
inline
void
DoFAccessor<structdim, DoFHandlerType,level_dof_access>::set_mg_vertex_dof_index
}
-template<int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
inline
void
DoFAccessor<structdim, DoFHandlerType,level_dof_access>::set_mg_dof_index
- template<typename DoFHandlerType, bool level_dof_access>
+ template <typename DoFHandlerType, bool level_dof_access>
void get_mg_dof_indices
(const dealii::DoFAccessor<1, DoFHandlerType,level_dof_access> &accessor,
const int level,
- template<typename DoFHandlerType, bool level_dof_access>
+ template <typename DoFHandlerType, bool level_dof_access>
void get_mg_dof_indices (const dealii::DoFAccessor<2, DoFHandlerType,level_dof_access> &accessor,
const int level,
std::vector<types::global_dof_index> &dof_indices,
- template<typename DoFHandlerType, bool level_dof_access>
+ template <typename DoFHandlerType, bool level_dof_access>
void get_mg_dof_indices
(const dealii::DoFAccessor<3, DoFHandlerType,level_dof_access> &accessor,
const int level,
-template<int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
inline
void DoFAccessor<structdim, DoFHandlerType,level_dof_access>::get_mg_dof_indices
(const int level,
}
-template<int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
inline
void DoFAccessor<structdim, DoFHandlerType,level_dof_access>::set_mg_dof_indices
(const int level,
}
- template<bool level_dof_access>
+ template <bool level_dof_access>
inline
typename dealii::internal::DoFHandler::Iterators<dealii::DoFHandler<2,2>, level_dof_access>::quad_iterator
get_quad(const dealii::Triangulation<2,2> *,
return typename dealii::internal::DoFHandler::Iterators<dealii::DoFHandler<2,2>, level_dof_access>::line_iterator();
}
- template<bool level_dof_access>
+ template <bool level_dof_access>
inline
typename dealii::internal::DoFHandler::Iterators<dealii::DoFHandler<2,3>, level_dof_access>::quad_iterator
get_quad(const dealii::Triangulation<2,3> *,
return typename dealii::internal::DoFHandler::Iterators<dealii::DoFHandler<2,3>, level_dof_access>::line_iterator();
}
- template<bool level_dof_access>
+ template <bool level_dof_access>
inline
typename dealii::internal::DoFHandler::Iterators<dealii::hp::DoFHandler<2,2>, level_dof_access>::quad_iterator
get_quad(const dealii::Triangulation<2,2> *,
return typename dealii::internal::DoFHandler::Iterators<dealii::hp::DoFHandler<2,2>, level_dof_access>::line_iterator();
}
- template<bool level_dof_access>
+ template <bool level_dof_access>
inline
typename dealii::internal::DoFHandler::Iterators<dealii::hp::DoFHandler<2,3>, level_dof_access>::quad_iterator
get_quad(const dealii::Triangulation<2,3> *,
-template<typename DoFHandlerType, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
inline
void DoFCellAccessor<DoFHandlerType,level_dof_access>::get_mg_dof_indices
(std::vector<types::global_dof_index> &dof_indices) const
-template<typename DoFHandlerType, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
inline
void DoFCellAccessor<DoFHandlerType,level_dof_access>::set_mg_dof_indices
(const std::vector<types::global_dof_index> &dof_indices)
-template<typename DoFHandlerType, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
inline
void DoFCellAccessor<DoFHandlerType,level_dof_access>::get_active_or_mg_dof_indices
(std::vector<types::global_dof_index> &dof_indices) const
*
* @author Tobias Leicht, 2006
*/
- template<int dim>
+ template <int dim>
class DoFFaces
{
/**
*
* @author Tobias Leicht, 2006
*/
- template<>
+ template <>
class DoFFaces<1>
{
public:
*
* @author Tobias Leicht, 2006
*/
- template<>
+ template <>
class DoFFaces<2>
{
public:
*
* @author Tobias Leicht, 2006
*/
- template<>
+ template <>
class DoFFaces<3>
{
public:
*
* The type of boundary_ids equals typename FunctionMap<spacedim,number>::type .
*/
- template<typename number>
+ template <typename number>
types::global_dof_index
n_boundary_dofs (const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_ids) const;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
inline
types::global_dof_index DoFHandler<dim, spacedim>::n_dofs (const unsigned int level) const
{
*
* Defined in dof_handler.cc.
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
std::string policy_to_string(const dealii::internal::DoFHandler::Policy::PolicyBase<dim,spacedim> &policy);
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
inline
void
DoFHandler<dim, spacedim>::MGVertexDoFs::set_index (const unsigned int level,
*
* @ingroup constraints
*/
- template<typename DoFHandlerType, typename SparsityPatternType>
+ template <typename DoFHandlerType, typename SparsityPatternType>
void
make_flux_sparsity_pattern (const DoFHandlerType &dof_handler,
SparsityPatternType &sparsity_pattern);
*
* @ingroup constraints
*/
- template<typename DoFHandlerType, typename SparsityPatternType>
+ template <typename DoFHandlerType, typename SparsityPatternType>
void
make_flux_sparsity_pattern (const DoFHandlerType &dof_handler,
SparsityPatternType &sparsity_pattern,
*
* @author Matthias Maier, 2012 - 2015
*/
- template<typename FaceIterator>
+ template <typename FaceIterator>
void
make_periodicity_constraints
(const FaceIterator &face_1,
*
* @author Daniel Arndt, Matthias Maier, 2013 - 2015
*/
- template<typename DoFHandlerType>
+ template <typename DoFHandlerType>
void
make_periodicity_constraints
(const std::vector<GridTools::PeriodicFacePair<typename DoFHandlerType::cell_iterator> >
*
* @author Matthias Maier, 2012
*/
- template<typename DoFHandlerType>
+ template <typename DoFHandlerType>
void
make_periodicity_constraints
(const DoFHandlerType &dof_handler,
* @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
* for further information.
*/
- template<typename DoFHandlerType>
+ template <typename DoFHandlerType>
void
make_periodicity_constraints
(const DoFHandlerType &dof_handler,
* @ingroup functions
* @author Wolfgang Bangerth, Ralf Hartmann, 2001
*/
-template<int dim,typename Number=double>
+template <int dim,typename Number=double>
struct FunctionMap
{
/**
* While the first vector is checked to have the correct size, the second
* one is reinitialized for convenience.
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void compute_component_wise(
const FiniteElement<dim,spacedim> &fe,
std::vector<unsigned int> &renumbering,
* indicates the index which this degree of freedom receives in a numbering
* scheme, where the first block is numbered completely before the second.
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void compute_block_renumbering (
const FiniteElement<dim,spacedim> &fe,
std::vector<types::global_dof_index> &renumbering,
*
* @author Wolfgang Bangerth, 2001, 2015
*/
-template<int dim, int spacedim=dim>
+template <int dim, int spacedim=dim>
class MappingC1 : public MappingQ<dim,spacedim>
{
public:
#ifndef DOXYGEN
-template<int dim, int spacedim>
+template <int dim, int spacedim>
inline
void
MappingManifold<dim,spacedim>::InternalData::store_vertices (const typename Triangulation<dim,spacedim>::cell_iterator &cell) const
#ifndef DOXYGEN
-template<int dim, int spacedim>
+template <int dim, int spacedim>
inline
const double &
MappingQGeneric<dim,spacedim>::InternalData::shape (const unsigned int qpoint,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
inline
double &
MappingQGeneric<dim,spacedim>::InternalData::shape (const unsigned int qpoint,
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
inline
const Tensor<1,dim> &
MappingQGeneric<dim,spacedim>::InternalData::derivative (const unsigned int qpoint,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
inline
Tensor<1,dim> &
MappingQGeneric<dim,spacedim>::InternalData::derivative (const unsigned int qpoint,
/**
* Return a compact and fast binary representation of this CellId.
*/
- template<int dim>
+ template <int dim>
binary_type to_binary() const;
/**
* Return a cell_iterator to the cell represented by this CellId.
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
typename Triangulation<dim,spacedim>::cell_iterator
to_cell(const Triangulation<dim,spacedim> &tria) const;
* and 6 in 3d). If @p colorize is set to false, then flat faces get the
* number 0 and the hole gets number 1.
*/
- template<int dim>
+ template <int dim>
void hyper_cube_with_cylindrical_hole (
Triangulation<dim> &triangulation,
const double inner_radius = .25,
// declaration of explicit specializations
-template<>
+template <>
void
GridReordering<2>::invert_all_cells_of_negative_grid(const std::vector<Point<2> > &all_vertices,
std::vector<CellData<2> > &cells);
-template<>
+template <>
void
GridReordering<2,3>::invert_all_cells_of_negative_grid(const std::vector<Point<3> > &all_vertices,
std::vector<CellData<2> > &cells);
-template<>
+template <>
void
GridReordering<3>::invert_all_cells_of_negative_grid(const std::vector<Point<3> > &all_vertices,
std::vector<CellData<3> > &cells);
namespace internal
{
- template<int dim, int spacedim, class MeshType>
+ template <int dim, int spacedim, class MeshType>
class ActiveCellIterator
{
public:
typedef typename MeshType::active_cell_iterator type;
};
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
class ActiveCellIterator<dim, spacedim, dealii::DoFHandler<dim, spacedim> >
{
public:
#endif
};
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
class ActiveCellIterator<dim, spacedim, dealii::hp::DoFHandler<dim, spacedim> >
{
public:
*
* @note Implemented for dim=1, 2, and 3.
*/
- template<int dim>
+ template <int dim>
void
rotate (const double angle,
const unsigned int axis,
*
* @author Mauro Bardelloni, Luca Heltai, Andrea Mola, 2016
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
remove_hanging_nodes( Triangulation<dim,spacedim> &tria,
const bool isotropic = false,
*
* @author Mauro Bardelloni, Luca Heltai, Andrea Mola, 2016
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
remove_anisotropy( Triangulation<dim,spacedim> &tria,
const double max_ratio = 1.6180339887,
* right thing with anisotropically refined meshes. It needs to be checked
* for this case.
*/
- template<int dim, template <int, int> class MeshType, int spacedim>
+ template <int dim, template <int, int> class MeshType, int spacedim>
#ifndef _MSC_VER
std::vector<typename MeshType<dim, spacedim>::active_cell_iterator>
#else
* evaluating the solution) may not be possible and you will have to decide
* what to do in that case.
*/
- template <int dim, template<int, int> class MeshType, int spacedim>
+ template <int dim, template <int, int> class MeshType, int spacedim>
#ifndef _MSC_VER
std::pair<typename MeshType<dim, spacedim>::active_cell_iterator, Point<dim> >
#else
* An example of a custom predicate is one that checks for a given material
* id
* @code
- * template<int dim>
+ * template <int dim>
* bool
* pred_mat_id(const typename Triangulation<dim>::active_cell_iterator & cell)
* {
* For a description of how predicate works,
* see compute_active_cell_halo_layer()
*/
- template<class MeshType>
+ template <class MeshType>
std::pair< Point<MeshType::space_dimension>, Point<MeshType::space_dimension> >
compute_bounding_box
( const MeshType &mesh,
*
* @author Mauro Bardelloni, Luca Heltai, Andrea Mola, 2016
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
std::pair<unsigned int, double>
get_longest_direction(typename Triangulation<dim, spacedim>::active_cell_iterator cell);
* constraints and a periodic p4est forest with respect to two 'periodic'
* cell faces.
*/
- template<typename CellIterator>
+ template <typename CellIterator>
struct PeriodicFacePair
{
/**
*
* @author Matthias Maier, 2012
*/
- template<typename FaceIterator>
+ template <typename FaceIterator>
bool
orthogonal_equality (std::bitset<3> &orientation,
const FaceIterator &face1,
/**
* Same function as above, but doesn't return the actual orientation
*/
- template<typename FaceIterator>
+ template <typename FaceIterator>
bool
orthogonal_equality (const FaceIterator &face1,
const FaceIterator &face2,
namespace GridTools
{
- template<typename CellIterator> struct PeriodicFacePair;
+ template <typename CellIterator> struct PeriodicFacePair;
}
template <int, int, int> class TriaAccessor;
* functions below. It takes an iterator range and returns the sum of
* values.
*/
- template<typename T>
+ template <typename T>
struct CellWeightSum
{
typedef T result_type;
- template<typename InputIterator>
+ template <typename InputIterator>
T operator()(InputIterator first, InputIterator last) const
{
return std::accumulate (first, last, T());
* @ingroup Accessors
* @author Bruno Turcksin, 2015
*/
-template<int dim, int spacedim>
+template <int dim, int spacedim>
class TriaAccessor<0, dim, spacedim>
{
public:
* partial templates. we use this auxiliary function that is then called
* from point_inside.
*/
- template<int dim_,int spacedim_ >
+ template <int dim_,int spacedim_ >
bool point_inside_codim(const Point<spacedim_> &p) const;
* @author Tobias Leicht, 2006
*/
- template<int dim>
+ template <int dim>
class TriaFaces
{
private:
* <tt>dim@>=2</tt> the use of TriaFaces is reasonable, for <tt>dim=1</tt>
* the class is empty.
*/
- template<>
+ template <>
class TriaFaces<1>
{
/**
* In <tt>dim=2</tt> the cells are quads, the faces accordingly are lines.
*/
- template<>
+ template <>
class TriaFaces<2>
{
public:
* In <tt>dim=3</tt> the cells are hexes, the faces accordingly are quads.
* In addition to that we also have to enable the storage of lines.
*/
- template<>
+ template <>
class TriaFaces<3>
{
public:
* instead of TriaObjects. Refer to the documentation of the general class
* template for details.
*/
- template<>
+ template <>
class TriaLevel<3>
{
public:
}
- template<typename G>
+ template <typename G>
inline
bool
TriaObjects<G>::
}
- template<typename G>
+ template <typename G>
inline
void *&
TriaObjects<G>::user_pointer (const unsigned int i)
}
- template<typename G>
+ template <typename G>
inline
const void *
TriaObjects<G>::user_pointer (const unsigned int i) const
}
- template<typename G>
+ template <typename G>
inline
unsigned int &
TriaObjects<G>::user_index (const unsigned int i)
}
- template<typename G>
+ template <typename G>
inline
void
TriaObjects<G>::clear_user_data (const unsigned int i)
{}
- template<typename G>
+ template <typename G>
inline
unsigned int TriaObjects<G>::user_index (const unsigned int i) const
{
}
- template<typename G>
+ template <typename G>
inline
void TriaObjects<G>::clear_user_data ()
{
}
- template<typename G>
+ template <typename G>
inline
void TriaObjects<G>::clear_user_flags ()
{
}
- template<typename G>
+ template <typename G>
template <class Archive>
void
TriaObjects<G>::UserData::serialize (Archive &ar,
// declaration of explicit specializations
- template<>
+ template <>
void
TriaObjects<TriaObject<2> >::monitor_memory (const unsigned int) const;
* @ingroup dofs
* @author Tobias Leicht, 2006
*/
- template<int dim>
+ template <int dim>
class DoFIndicesOnFaces;
* @ingroup hp
* @author Tobias Leicht, 2006
*/
- template<>
+ template <>
class DoFIndicesOnFaces<1>
{
public:
* @ingroup hp
* @author Tobias Leicht, 2006
*/
- template<>
+ template <>
class DoFIndicesOnFaces<2>
{
public:
* @ingroup hp
* @author Tobias Leicht, 2006
*/
- template<>
+ template <>
class DoFIndicesOnFaces<3>
{
public:
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
inline
const hp::FECollection<dim,spacedim> &
DoFHandler<dim,spacedim>::get_fe () const
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
inline
const Triangulation<dim,spacedim> &
DoFHandler<dim,spacedim>::get_triangulation () const
*
* @author Oliver Kayser-Herold, 2005
*/
- template<int dim, int spacedim=dim>
+ template <int dim, int spacedim=dim>
class MappingCollection : public Subscriptor
{
public:
* collection can then be used in all of those places where such a
* collection is needed.
*/
- template<int dim, int spacedim=dim>
+ template <int dim, int spacedim=dim>
struct StaticMappingQ1
{
public:
/* --------------- inline functions ------------------- */
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
inline
unsigned int
MappingCollection<dim,spacedim>::size () const
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
inline
const Mapping<dim,spacedim> &
MappingCollection<dim,spacedim>::operator[] (const unsigned int index) const
* @author Guido Kanschat
* @date 2012
*/
- template<int dim>
+ template <int dim>
void cell_matrix (
FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
* @author Guido Kanschat
* @date 2011
*/
- template<int dim>
+ template <int dim>
void
u_dot_n_matrix (
FullMatrix<double> &M,
* @author Guido Kanschat
* @date 2011
*/
- template<int dim, typename number>
+ template <int dim, typename number>
void
u_dot_n_residual (
Vector<number> &result,
* @author Guido Kanschat
* @date 2013
*/
- template<int dim, typename number>
+ template <int dim, typename number>
void
u_times_n_residual (
Vector<number> &result,
* @author Guido Kanschat
* @date 2011
*/
- template<int dim>
+ template <int dim>
void
u_dot_n_matrix (
FullMatrix<double> &M11,
* @author Guido Kanschat
* @date 2011
*/
- template<int dim>
+ template <int dim>
void
u_dot_n_jump_matrix (
FullMatrix<double> &M11,
* @author Guido Kanschat
* @date 2013
*/
- template<int dim, typename number>
+ template <int dim, typename number>
void
ip_residual(
Vector<number> &result1,
* @author Guido Kanschat
* @date 2016
*/
- template<int dim>
+ template <int dim>
void
ip_residual(
Vector<double> &result1,
* @author Guido Kanschat
* @date 2008, 2009, 2010
*/
- template<int dim>
+ template <int dim>
void cell_matrix (
FullMatrix<double> &M,
const FEValuesBase<dim> &fe,
* @author Guido Kanschat
* @date 2012
*/
- template<int dim>
+ template <int dim>
void
ip_residual(
Vector<double> &result1,
* @author Guido Kanschat
* @date 2012
*/
- template<int dim>
+ template <int dim>
void
ip_residual(
Vector<double> &result1,
{
namespace BlockLinearOperator
{
- template<typename PayloadBlockType = internal::LinearOperator::EmptyPayload>
+ template <typename PayloadBlockType = internal::LinearOperator::EmptyPayload>
class EmptyBlockPayload;
}
}
* an object @p op for which the conversion function
* <code>block_operator</code> is defined.
*/
- template<typename Op>
+ template <typename Op>
BlockLinearOperator(const Op &op)
{
*this = block_operator<Range, Domain, BlockPayload, Op>(op);
* LinearOperator. This constructor calls the corresponding block_operator()
* specialization.
*/
- template<size_t m, size_t n>
+ template <size_t m, size_t n>
BlockLinearOperator(const std::array<std::array<BlockType, n>, m> &ops)
{
*this = block_operator<m, n, Range, Domain, BlockPayload>(ops);
* @p ops of LinearOperator. This constructor calls the corresponding
* block_operator() specialization.
*/
- template<size_t m>
+ template <size_t m>
BlockLinearOperator(const std::array<BlockType, m> &ops)
{
*this = block_diagonal_operator<m, Range, Domain, BlockPayload>(ops);
*
* @ingroup LAOperators
*/
- template<typename PayloadBlockType>
+ template <typename PayloadBlockType>
class EmptyBlockPayload
{
public:
* Constructor initializing all data fields. A PointerMatrix object is
* generated for <tt>matrix</tt>.
*/
- template<typename MatrixType>
+ template <typename MatrixType>
Entry (const MatrixType &matrix,
size_type row,
size_type col,
* @ref GlossBlockLA "Block (linear algebra)"
* @author Guido Kanschat, 2002, 2003
*/
-template<typename Number>
+template <typename Number>
class BlockSparseMatrixEZ : public Subscriptor
{
public:
* A helper class used internally in linear_operator.h. Specialization for
* BlockVector<number>.
*/
- template<typename number>
+ template <typename number>
class ReinitHelper<BlockVector<number> >
{
public:
DEAL_II_NAMESPACE_OPEN
-template<typename number> class Vector;
-template<typename number> class FullMatrix;
+template <typename number> class Vector;
+template <typename number> class FullMatrix;
/*! @addtogroup Matrix1
*@{
{
namespace ChunkSparseMatrix
{
- template<typename T>
+ template <typename T>
void zero_subrange (const unsigned int begin,
const unsigned int end,
T *dst)
DEAL_II_NAMESPACE_OPEN
-template<int dim, class T> class Table;
+template <int dim, class T> class Table;
template <typename> class FullMatrix;
class SparsityPattern;
class DynamicSparsityPattern;
* See the general documentation of this class for more detailed
* information.
*/
- template<typename number>
+ template <typename number>
void condense (SparseMatrix<number> &matrix) const;
/**
* See the general documentation of this class for more detailed
* information.
*/
- template<typename number, class VectorType>
+ template <typename number, class VectorType>
void condense (SparseMatrix<number> &matrix,
VectorType &vector) const;
DEAL_II_NAMESPACE_OPEN
-template<typename number>
+template <typename number>
void
ConstraintMatrix::condense (SparseMatrix<number> &uncondensed) const
{
-template<class VectorType>
+template <class VectorType>
void
ConstraintMatrix::condense (const VectorType &vec_ghosted,
VectorType &vec) const
-template<typename number, class VectorType>
+template <typename number, class VectorType>
void
ConstraintMatrix::condense (SparseMatrix<number> &uncondensed,
VectorType &vec) const
{
typedef types::global_dof_index size_type;
- template<class VEC>
+ template <class VEC>
void set_zero_parallel(const std::vector<size_type> &cm, VEC &vec, size_type shift = 0)
{
Assert(!vec.has_ghost_elements(), ExcInternalError());
}
}
- template<typename Number>
+ template <typename Number>
void set_zero_parallel(const std::vector<size_type> &cm, LinearAlgebra::distributed::Vector<Number> &vec, size_type shift = 0)
{
for (typename std::vector<size_type>::const_iterator it = cm.begin();
vec.zero_out_ghosts();
}
- template<class VEC>
+ template <class VEC>
void set_zero_in_parallel(const std::vector<size_type> &cm, VEC &vec, internal::bool2type<false>)
{
set_zero_parallel(cm, vec, 0);
}
// in parallel for BlockVectors
- template<class VEC>
+ template <class VEC>
void set_zero_in_parallel(const std::vector<size_type> &cm, VEC &vec, internal::bool2type<true>)
{
size_type start_shift = 0;
}
}
- template<class VEC>
+ template <class VEC>
void set_zero_serial(const std::vector<size_type> &cm, VEC &vec)
{
for (typename std::vector<size_type>::const_iterator it = cm.begin();
vec(*it) = 0.;
}
- template<class VEC>
+ template <class VEC>
void set_zero_all(const std::vector<size_type> &cm, VEC &vec)
{
set_zero_in_parallel<VEC>(cm, vec, internal::bool2type<IsBlockVector<VEC>::value>());
}
- template<class T>
+ template <class T>
void set_zero_all(const std::vector<size_type> &cm, dealii::Vector<T> &vec)
{
set_zero_serial(cm, vec);
}
- template<class T>
+ template <class T>
void set_zero_all(const std::vector<size_type> &cm, dealii::BlockVector<T> &vec)
{
set_zero_serial(cm, vec);
// resolves constraints of one column at the innermost loop. goes through
// the origin of each global entry and finds out which data we need to
// collect.
- template<typename LocalType>
+ template <typename LocalType>
static inline
LocalType resolve_matrix_entry (const GlobalRowsFromLocal &global_rows,
const GlobalRowsFromLocal &global_cols,
// Resolve the constraints from the vector and apply inhomogeneities.
-template< typename LocalType>
+template < typename LocalType>
inline
LocalType
ConstraintMatrix::
//--------------------------------Iterators--------------------------------------//
-template<typename VectorType>
+template <typename VectorType>
inline
FilteredMatrix<VectorType>::Accessor::Accessor
(const FilteredMatrix<VectorType> *matrix,
-template<typename VectorType>
+template <typename VectorType>
inline
types::global_dof_index
FilteredMatrix<VectorType>::Accessor::row() const
-template<typename VectorType>
+template <typename VectorType>
inline
types::global_dof_index
FilteredMatrix<VectorType>::Accessor::column() const
-template<typename VectorType>
+template <typename VectorType>
inline
double
FilteredMatrix<VectorType>::Accessor::value() const
-template<typename VectorType>
+template <typename VectorType>
inline
void
FilteredMatrix<VectorType>::Accessor::advance()
-template<typename VectorType>
+template <typename VectorType>
inline
FilteredMatrix<VectorType>::const_iterator::const_iterator
(const FilteredMatrix<VectorType> *matrix,
-template<typename VectorType>
+template <typename VectorType>
inline
typename FilteredMatrix<VectorType>::const_iterator &
FilteredMatrix<VectorType>::const_iterator::operator++ ()
// forward declarations
-template<typename number> class Vector;
+template <typename number> class Vector;
/*! @addtogroup Matrix2
*
* @author Guido Kanschat, 2005
*/
-template<typename number>
+template <typename number>
class Householder : private FullMatrix<number>
{
public:
/**
* Create an object holding the QR-decomposition of a matrix.
*/
- template<typename number2>
+ template <typename number2>
Householder (const FullMatrix<number2> &);
/**
* Compute the QR-decomposition of another matrix.
*/
- template<typename number2>
+ template <typename number2>
void
initialize (const FullMatrix<number2> &);
* problem. It will be changed during the algorithm and is unusable on
* return.
*/
- template<typename number2>
+ template <typename number2>
double least_squares (Vector<number2> &dst,
const Vector<number2> &src) const;
/**
* This function does the same as the one for BlockVectors.
*/
- template<typename number2>
+ template <typename number2>
double least_squares (BlockVector<number2> &dst,
const BlockVector<number2> &src) const;
* A wrapper to least_squares(), implementing the standard MatrixType
* interface.
*/
- template<class VectorType>
+ template <class VectorType>
void vmult (VectorType &dst, const VectorType &src) const;
- template<class VectorType>
+ template <class VectorType>
void Tvmult (VectorType &dst, const VectorType &src) const;
DEAL_II_NAMESPACE_OPEN
// forward declarations
-template<typename number> class Vector;
-template<typename number> class BlockVector;
-template<typename number> class FullMatrix;
-template<typename number> class SparseMatrix;
+template <typename number> class Vector;
+template <typename number> class BlockVector;
+template <typename number> class FullMatrix;
+template <typename number> class SparseMatrix;
/**
* The final two arguments allow to enter a multiple of the source or its
* transpose.
*/
- template<typename MatrixType>
+ template <typename MatrixType>
void fill (const MatrixType &src,
const size_type dst_offset_i = 0,
const size_type dst_offset_j = 0,
/// Template wrapper for LAPACK functions daxpy and saxpy
-template<typename number1, typename number2, typename number3>
+template <typename number1, typename number2, typename number3>
inline void
axpy (const int *, const number1 *, const number2 *, const int *, number3 *, const int *)
{
/// Template wrapper for LAPACK functions dgemv and sgemv
-template<typename number1, typename number2, typename number3, typename number4, typename number5>
+template <typename number1, typename number2, typename number3, typename number4, typename number5>
inline void
gemv (const char *, const int *, const int *, const number1 *, const number2 *, const int *, const number3 *, const int *, const number4 *, number5 *, const int *)
{
/// Template wrapper for LAPACK functions dgemm and sgemm
-template<typename number1, typename number2, typename number3, typename number4, typename number5>
+template <typename number1, typename number2, typename number3, typename number4, typename number5>
inline void
gemm (const char *, const char *, const int *, const int *, const int *, const number1 *, const number2 *, const int *, const number3 *, const int *, const number4 *, number5 *, const int *)
{
/// Template wrapper for LAPACK functions dgetrf and sgetrf
-template<typename number1>
+template <typename number1>
inline void
getrf (const int *, const int *, number1 *, const int *, int *, int *)
{
/// Template wrapper for LAPACK functions dgetrs and sgetrs
-template<typename number1, typename number2>
+template <typename number1, typename number2>
inline void
getrs (const char *, const int *, const int *, const number1 *, const int *, const int *, number2 *, const int *, int *)
{
/// Template wrapper for LAPACK functions dgetri and sgetri
-template<typename number1, typename number2>
+template <typename number1, typename number2>
inline void
getri (const int *, number1 *, const int *, int *, number2 *, const int *, int *)
{
/// Template wrapper for LAPACK functions dgeqrf and sgeqrf
-template<typename number1, typename number2, typename number3>
+template <typename number1, typename number2, typename number3>
inline void
geqrf (const int *, const int *, number1 *, const int *, number2 *, number3 *, const int *, int *)
{
/// Template wrapper for LAPACK functions dormqr and sormqr
-template<typename number1, typename number2, typename number3, typename number4>
+template <typename number1, typename number2, typename number3, typename number4>
inline void
ormqr (const char *, const char *, const int *, const int *, const int *, const number1 *, const int *, const number2 *, number3 *, const int *, number4 *, const int *, int *)
{
/// Template wrapper for LAPACK functions dorgqr and sorgqr
-template<typename number1, typename number2, typename number3>
+template <typename number1, typename number2, typename number3>
inline void
orgqr (const int *, const int *, const int *, const number1 *, const int *, const number2 *, number3 *, const int *, int *)
{
/// Template wrapper for LAPACK functions dtrtrs and strtrs
-template<typename number1, typename number2>
+template <typename number1, typename number2>
inline void
trtrs (const char *, const char *, const char *, const int *, const int *, const number1 *, const int *, number2 *, const int *, int *)
{
/// Template wrapper for LAPACK functions dgeev and sgeev
-template<typename number1, typename number2, typename number3, typename number4, typename number5, typename number6>
+template <typename number1, typename number2, typename number3, typename number4, typename number5, typename number6>
inline void
geev (const char *, const char *, const int *, number1 *, const int *, number2 *, number3 *, number4 *, const int *, number5 *, const int *, number6 *, const int *, int *)
{
/// Template wrapper for LAPACK functions dgeevx and sgeevx
-template<typename number1, typename number2, typename number3, typename number4, typename number5, typename number6, typename number7, typename number8, typename number9, typename number10>
+template <typename number1, typename number2, typename number3, typename number4, typename number5, typename number6, typename number7, typename number8, typename number9, typename number10>
inline void
geevx (const char *, const char *, const char *, const char *, const int *, number1 *, const int *, number2 *, number3 *, number4 *, const int *, number5 *, const int *, int *, int *, number6 *, number7 *, number8 *, number9 *, number10 *, const int *, int *, int *)
{
/// Template wrapper for LAPACK functions dsyev and ssyev
-template<typename number1, typename number2, typename number3>
+template <typename number1, typename number2, typename number3>
inline void
syev (const char *, const char *, const int *, number1 *, const int *, number2 *, number3 *, const int *, int *)
{
/// Template wrapper for LAPACK functions dsyevx and ssyevx
-template<typename number1, typename number2, typename number3, typename number4, typename number5, typename number6, typename number7>
+template <typename number1, typename number2, typename number3, typename number4, typename number5, typename number6, typename number7>
inline void
syevx (const char *, const char *, const char *, const int *, number1 *, const int *, const number2 *, const number3 *, const int *, const int *, const number4 *, int *, number5 *, number6 *, const int *, number7 *, const int *, int *, int *, int *)
{
/// Template wrapper for LAPACK functions dsygv and ssygv
-template<typename number1, typename number2, typename number3, typename number4>
+template <typename number1, typename number2, typename number3, typename number4>
inline void
sygv (const int *, const char *, const char *, const int *, number1 *, const int *, number2 *, const int *, number3 *, number4 *, const int *, int *)
{
/// Template wrapper for LAPACK functions dsygvx and ssygvx
-template<typename number1, typename number2, typename number3, typename number4, typename number5, typename number6, typename number7, typename number8>
+template <typename number1, typename number2, typename number3, typename number4, typename number5, typename number6, typename number7, typename number8>
inline void
sygvx (const int *, const char *, const char *, const char *, const int *, number1 *, const int *, number2 *, const int *, const number3 *, const number4 *, const int *, const int *, const number5 *, int *, number6 *, number7 *, const int *, number8 *, const int *, int *, int *, int *)
{
/// Template wrapper for LAPACK functions dgesdd and sgesdd
-template<typename number1, typename number2, typename number3, typename number4, typename number5>
+template <typename number1, typename number2, typename number3, typename number4, typename number5>
inline void
gesdd (const char *, const int *, const int *, number1 *, const int *, number2 *, number3 *, const int *, number4 *, const int *, number5 *, const int *, int *, int *)
{
/// Template wrapper for LAPACK functions dgesvd and sgesvd
-template<typename number1, typename number2, typename number3, typename number4, typename number5>
+template <typename number1, typename number2, typename number3, typename number4, typename number5>
inline void
gesvd (int *, int *, const int *, const int *, number1 *, const int *, number2 *, number3 *, const int *, number4 *, const int *, number5 *, const int *, int *)
{
/// Template wrapper for LAPACK functions dgelsd and sgelsd
-template<typename number1, typename number2, typename number3, typename number4, typename number5>
+template <typename number1, typename number2, typename number3, typename number4, typename number5>
inline void
gelsd (const int *, const int *, const int *, const number1 *, const int *, number2 *, const int *, number3 *, const number4 *, int *, number5 *, const int *, int *, int *)
{
/// Template wrapper for LAPACK functions dstev and sstev
-template<typename number1, typename number2, typename number3, typename number4>
+template <typename number1, typename number2, typename number3, typename number4>
inline void
stev (const char *, const int *, number1 *, number2 *, number3 *, const int *, number4 *, int *)
{
* object @p op for which the conversion function
* <code>linear_operator</code> is defined.
*/
- template<typename Op,
- typename = typename std::enable_if<!std::is_base_of<LinearOperator<Range, Domain, Payload>, Op>::value>::type>
+ template <typename Op,
+ typename = typename std::enable_if<!std::is_base_of<LinearOperator<Range, Domain, Payload>, Op>::value>::type>
LinearOperator (const Op &op)
{
*this = linear_operator<Range, Domain, Payload, Op>(op);
* This class is specialized for more complicated data structures, such as
* TrilinosWrappers::MPI::Vector, etc.
*/
- template<typename Vector>
+ template <typename Vector>
class ReinitHelper
{
public:
* MatrixType. No index computations are done, thus, the vectors need to
* have sizes matching #matrix.
*/
- template<class VectorType>
+ template <class VectorType>
void vmult (VectorType &w, const VectorType &v) const;
/**
* MatrixType. No index computations are done, thus, the vectors need to
* have sizes matching #matrix.
*/
- template<class VectorType>
+ template <class VectorType>
void vmult_add (VectorType &w, const VectorType &v) const;
/**
* MatrixType. No index computations are done, thus, the vectors need to
* have sizes matching #matrix.
*/
- template<class VectorType>
+ template <class VectorType>
void Tvmult (VectorType &w, const VectorType &v) const;
/**
* MatrixType. No index computations are done, thus, the vectors need to
* have sizes matching #matrix.
*/
- template<class VectorType>
+ template <class VectorType>
void Tvmult_add (VectorType &w, const VectorType &v) const;
/**
DEAL_II_NAMESPACE_OPEN
-template<typename number> class Vector;
-template<typename number> class BlockVector;
-template<typename number> class SparseMatrix;
+template <typename number> class Vector;
+template <typename number> class BlockVector;
+template <typename number> class SparseMatrix;
/*! @addtogroup Matrix2
*@{
* A helper class used internally in linear_operator.h. Specialization for
* PETScWrappers::MPI::BlockVector.
*/
- template<>
+ template <>
class ReinitHelper<PETScWrappers::MPI::BlockVector>
{
public:
* A helper class used internally in linear_operator.h. Specialization for
* PETScWrappers::MPI::Vector.
*/
- template<>
+ template <>
class ReinitHelper<PETScWrappers::MPI::Vector>
{
public:
DEAL_II_NAMESPACE_OPEN
-template<typename VectorType> class VectorMemory;
+template <typename VectorType> class VectorMemory;
class IdentityMatrix;
template <typename number> class FullMatrix;
*
* @author Guido Kanschat, 2000, 2001, 2002
*/
-template<typename VectorType>
+template <typename VectorType>
class PointerMatrixBase : public Subscriptor
{
public:
*
* @author Guido Kanschat 2000, 2001, 2002
*/
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
class PointerMatrix : public PointerMatrixBase<VectorType>
{
public:
*
* @author Guido Kanschat 2006
*/
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
class PointerMatrixAux : public PointerMatrixBase<VectorType>
{
public:
/*@}*/
//---------------------------------------------------------------------------
-template<typename VectorType>
+template <typename VectorType>
inline
PointerMatrixBase<VectorType>::~PointerMatrixBase ()
{}
//----------------------------------------------------------------------//
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
PointerMatrix<MatrixType, VectorType>::PointerMatrix (const MatrixType *M)
: m(M, typeid(*this).name())
{}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
PointerMatrix<MatrixType, VectorType>::PointerMatrix (const char *name)
: m(nullptr, name)
{}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
PointerMatrix<MatrixType, VectorType>::PointerMatrix (const MatrixType *M,
const char *name)
: m(M, name)
{}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
inline void
PointerMatrix<MatrixType, VectorType>::clear ()
{
}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
inline const PointerMatrix<MatrixType, VectorType> &
PointerMatrix<MatrixType, VectorType>::operator= (const MatrixType *M)
{
}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
inline bool
PointerMatrix<MatrixType, VectorType>::empty () const
{
return m->empty();
}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
inline void
PointerMatrix<MatrixType, VectorType>::vmult (VectorType &dst,
const VectorType &src) const
}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
inline void
PointerMatrix<MatrixType, VectorType>::Tvmult (VectorType &dst,
const VectorType &src) const
}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
inline void
PointerMatrix<MatrixType, VectorType>::vmult_add (VectorType &dst,
const VectorType &src) const
}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
inline void
PointerMatrix<MatrixType, VectorType>::Tvmult_add (VectorType &dst,
const VectorType &src) const
//----------------------------------------------------------------------//
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
PointerMatrixAux<MatrixType, VectorType>::PointerMatrixAux (VectorMemory<VectorType> *mem,
const MatrixType *M)
: mem(mem, typeid(*this).name()),
}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
PointerMatrixAux<MatrixType, VectorType>::PointerMatrixAux (VectorMemory<VectorType> *mem,
const char *name)
: mem(mem, name),
}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
PointerMatrixAux<MatrixType, VectorType>::PointerMatrixAux (VectorMemory<VectorType> *mem,
const MatrixType *M,
const char *name)
}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
inline void
PointerMatrixAux<MatrixType, VectorType>::clear ()
{
}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
inline const PointerMatrixAux<MatrixType, VectorType> &
PointerMatrixAux<MatrixType, VectorType>::operator= (const MatrixType *M)
{
}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
inline void
PointerMatrixAux<MatrixType, VectorType>::set_memory(VectorMemory<VectorType> *M)
{
}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
inline bool
PointerMatrixAux<MatrixType, VectorType>::empty () const
{
return m->empty();
}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
inline void
PointerMatrixAux<MatrixType, VectorType>::vmult (VectorType &dst,
const VectorType &src) const
}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
inline void
PointerMatrixAux<MatrixType, VectorType>::Tvmult (VectorType &dst,
const VectorType &src) const
}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
inline void
PointerMatrixAux<MatrixType, VectorType>::vmult_add (VectorType &dst,
const VectorType &src) const
}
-template<typename MatrixType, typename VectorType>
+template <typename MatrixType, typename VectorType>
inline void
PointerMatrixAux<MatrixType, VectorType>::Tvmult_add (VectorType &dst,
const VectorType &src) const
//----------------------------------------------------------------------//
-template<typename number>
+template <typename number>
PointerMatrixVector<number>::PointerMatrixVector (const Vector<number> *M)
: m(M, typeid(*this).name())
{}
-template<typename number>
+template <typename number>
PointerMatrixVector<number>::PointerMatrixVector (const char *name)
: m(0, name)
{}
-template<typename number>
+template <typename number>
PointerMatrixVector<number>::PointerMatrixVector (const Vector<number> *M,
const char *name)
: m(M, name)
{}
-template<typename number>
+template <typename number>
inline void
PointerMatrixVector<number>::clear ()
{
}
-template<typename number>
+template <typename number>
inline const PointerMatrixVector<number> &
PointerMatrixVector<number>::operator= (const Vector<number> *M)
{
}
-template<typename number>
+template <typename number>
inline bool
PointerMatrixVector<number>::empty () const
{
return m->empty();
}
-template<typename number>
+template <typename number>
inline void
PointerMatrixVector<number>::vmult (Vector<number> &dst,
const Vector<number> &src) const
}
-template<typename number>
+template <typename number>
inline void
PointerMatrixVector<number>::Tvmult (Vector<number> &dst,
const Vector<number> &src) const
}
-template<typename number>
+template <typename number>
inline void
PointerMatrixVector<number>::vmult_add (Vector<number> &dst,
const Vector<number> &src) const
}
-template<typename number>
+template <typename number>
inline void
PointerMatrixVector<number>::Tvmult_add (Vector<number> &dst,
const Vector<number> &src) const
/**
* Apply preconditioner.
*/
- template<class VectorType>
+ template <class VectorType>
void vmult (VectorType &, const VectorType &) const;
/**
* Apply transpose preconditioner. Since this is the identity, this function
* is the same as vmult().
*/
- template<class VectorType>
+ template <class VectorType>
void Tvmult (VectorType &, const VectorType &) const;
/**
* Apply preconditioner, adding to the previous value.
*/
- template<class VectorType>
+ template <class VectorType>
void vmult_add (VectorType &, const VectorType &) const;
/**
* Apply transpose preconditioner, adding. Since this is the identity, this
* function is the same as vmult_add().
*/
- template<class VectorType>
+ template <class VectorType>
void Tvmult_add (VectorType &, const VectorType &) const;
/**
/**
* Apply preconditioner.
*/
- template<class VectorType>
+ template <class VectorType>
void vmult (VectorType &, const VectorType &) const;
/**
* Apply transpose preconditioner. Since this is the identity, this function
* is the same as vmult().
*/
- template<class VectorType>
+ template <class VectorType>
void Tvmult (VectorType &, const VectorType &) const;
/**
* Apply preconditioner, adding to the previous value.
*/
- template<class VectorType>
+ template <class VectorType>
void vmult_add (VectorType &, const VectorType &) const;
/**
* Apply transpose preconditioner, adding. Since this is the identity, this
* function is the same as vmult_add().
*/
- template<class VectorType>
+ template <class VectorType>
void Tvmult_add (VectorType &, const VectorType &) const;
/**
*
* @author Guido Kanschat, Wolfgang Bangerth, 1999
*/
-template<typename MatrixType = SparseMatrix<double>, class VectorType = Vector<double> >
+template <typename MatrixType = SparseMatrix<double>, class VectorType = Vector<double> >
class PreconditionUseMatrix : public Subscriptor
{
public:
* @author Guido Kanschat, 2000; extension for full compatibility with
* LinearOperator class: Jean-Paul Pelteret, 2015
*/
-template<typename MatrixType = SparseMatrix<double> >
+template <typename MatrixType = SparseMatrix<double> >
class PreconditionRelaxation : public Subscriptor
{
public:
/**
* Apply preconditioner.
*/
- template<class VectorType>
+ template <class VectorType>
void vmult (VectorType &, const VectorType &) const;
/**
* Apply transpose preconditioner. Since this is a symmetric preconditioner,
* this function is the same as vmult().
*/
- template<class VectorType>
+ template <class VectorType>
void Tvmult (VectorType &, const VectorType &) const;
/**
* Perform one step of the preconditioned Richardson iteration.
*/
- template<class VectorType>
+ template <class VectorType>
void step (VectorType &x, const VectorType &rhs) const;
/**
* Perform one transposed step of the preconditioned Richardson iteration.
*/
- template<class VectorType>
+ template <class VectorType>
void Tstep (VectorType &x, const VectorType &rhs) const;
};
/**
* Apply preconditioner.
*/
- template<class VectorType>
+ template <class VectorType>
void vmult (VectorType &, const VectorType &) const;
/**
* Apply transpose preconditioner.
*/
- template<class VectorType>
+ template <class VectorType>
void Tvmult (VectorType &, const VectorType &) const;
/**
* Perform one step of the preconditioned Richardson iteration.
*/
- template<class VectorType>
+ template <class VectorType>
void step (VectorType &x, const VectorType &rhs) const;
/**
* Perform one transposed step of the preconditioned Richardson iteration.
*/
- template<class VectorType>
+ template <class VectorType>
void Tstep (VectorType &x, const VectorType &rhs) const;
};
/**
* Apply preconditioner.
*/
- template<class VectorType>
+ template <class VectorType>
void vmult (VectorType &, const VectorType &) const;
/**
* Apply transpose preconditioner. Since this is a symmetric preconditioner,
* this function is the same as vmult().
*/
- template<class VectorType>
+ template <class VectorType>
void Tvmult (VectorType &, const VectorType &) const;
/**
* Perform one step of the preconditioned Richardson iteration
*/
- template<class VectorType>
+ template <class VectorType>
void step (VectorType &x, const VectorType &rhs) const;
/**
* Perform one transposed step of the preconditioned Richardson iteration.
*/
- template<class VectorType>
+ template <class VectorType>
void Tstep (VectorType &x, const VectorType &rhs) const;
private:
/**
* Apply preconditioner.
*/
- template<class VectorType>
+ template <class VectorType>
void vmult (VectorType &, const VectorType &) const;
/**
* Apply transpose preconditioner.
*/
- template<class VectorType>
+ template <class VectorType>
void Tvmult (VectorType &, const VectorType &) const;
private:
/**
}
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionIdentity::vmult (VectorType &dst, const VectorType &src) const
{
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionIdentity::Tvmult (VectorType &dst, const VectorType &src) const
{
dst = src;
}
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionIdentity::vmult_add (VectorType &dst, const VectorType &src) const
{
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionIdentity::Tvmult_add (VectorType &dst, const VectorType &src) const
{
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionRichardson::vmult (VectorType &dst, const VectorType &src) const
{
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionRichardson::Tvmult (VectorType &dst, const VectorType &src) const
{
dst.equ(relaxation,src);
}
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionRichardson::vmult_add (VectorType &dst, const VectorType &src) const
{
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionRichardson::Tvmult_add (VectorType &dst, const VectorType &src) const
{
//---------------------------------------------------------------------------
template <typename MatrixType>
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionJacobi<MatrixType>::vmult (VectorType &dst, const VectorType &src) const
{
template <typename MatrixType>
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionJacobi<MatrixType>::Tvmult (VectorType &dst, const VectorType &src) const
{
template <typename MatrixType>
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionJacobi<MatrixType>::step (VectorType &dst, const VectorType &src) const
{
template <typename MatrixType>
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionJacobi<MatrixType>::Tstep (VectorType &dst, const VectorType &src) const
{
//---------------------------------------------------------------------------
template <typename MatrixType>
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionSOR<MatrixType>::vmult (VectorType &dst, const VectorType &src) const
{
template <typename MatrixType>
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionSOR<MatrixType>::Tvmult (VectorType &dst, const VectorType &src) const
{
template <typename MatrixType>
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionSOR<MatrixType>::step (VectorType &dst, const VectorType &src) const
{
template <typename MatrixType>
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionSOR<MatrixType>::Tstep (VectorType &dst, const VectorType &src) const
{
template <typename MatrixType>
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionSSOR<MatrixType>::vmult (VectorType &dst, const VectorType &src) const
{
template <typename MatrixType>
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionSSOR<MatrixType>::Tvmult (VectorType &dst, const VectorType &src) const
{
template <typename MatrixType>
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionSSOR<MatrixType>::step (VectorType &dst, const VectorType &src) const
{
template <typename MatrixType>
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionSSOR<MatrixType>::Tstep (VectorType &dst, const VectorType &src) const
{
template <typename MatrixType>
-template<class VectorType>
+template <class VectorType>
inline void
PreconditionPSOR<MatrixType>::Tvmult (VectorType &dst, const VectorType &src) const
{
//---------------------------------------------------------------------------
-template<typename MatrixType, class VectorType>
+template <typename MatrixType, class VectorType>
PreconditionUseMatrix<MatrixType,VectorType>::PreconditionUseMatrix(const MatrixType &M,
const function_ptr method)
:
-template<typename MatrixType, class VectorType>
+template <typename MatrixType, class VectorType>
void
PreconditionUseMatrix<MatrixType,VectorType>::vmult (VectorType &dst,
const VectorType &src) const
//---------------------------------------------------------------------------
-template<typename MatrixType>
+template <typename MatrixType>
inline
PreconditionRelaxation<MatrixType>::AdditionalData::
AdditionalData (const double relaxation)
mutable Number *dst;
};
- template<typename Number>
+ template <typename Number>
struct VectorUpdatesRange : public parallel::ParallelForInteger
{
VectorUpdatesRange(const VectorUpdater<Number> &updater,
* @author Ralf Hartmann, Guido Kanschat
* @date 1999, 2000, 2010
*/
-template<typename MatrixType, typename inverse_type = typename MatrixType::value_type>
+template <typename MatrixType, typename inverse_type = typename MatrixType::value_type>
class PreconditionBlock
: public virtual Subscriptor,
protected PreconditionBlockBase<inverse_type>
*
* @author Ralf Hartmann, Guido Kanschat, 1999, 2000, 2003
*/
-template<typename MatrixType, typename inverse_type = typename MatrixType::value_type>
+template <typename MatrixType, typename inverse_type = typename MatrixType::value_type>
class PreconditionBlockJacobi : public virtual Subscriptor,
private PreconditionBlock<MatrixType, inverse_type>
{
*
* @author Ralf Hartmann, Guido Kanschat, 1999, 2000, 2001, 2002, 2003
*/
-template<typename MatrixType, typename inverse_type = typename MatrixType::value_type>
+template <typename MatrixType, typename inverse_type = typename MatrixType::value_type>
class PreconditionBlockSOR : public virtual Subscriptor,
protected PreconditionBlock<MatrixType, inverse_type>
{
*
* @author Ralf Hartmann, Guido Kanschat, 1999, 2000
*/
-template<typename MatrixType, typename inverse_type = typename MatrixType::value_type>
+template <typename MatrixType, typename inverse_type = typename MatrixType::value_type>
class PreconditionBlockSSOR : public virtual Subscriptor,
private PreconditionBlockSOR<MatrixType, inverse_type>
{
#ifndef DOXYGEN
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline bool
PreconditionBlock<MatrixType, inverse_type>::empty () const
{
}
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline inverse_type
PreconditionBlock<MatrixType, inverse_type>::el (
size_type i,
//---------------------------------------------------------------------------
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline
PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::Accessor::
Accessor (const PreconditionBlockJacobi<MatrixType, inverse_type> *matrix,
}
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline
typename PreconditionBlockJacobi<MatrixType, inverse_type>::size_type
PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::Accessor::row() const
}
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline
typename PreconditionBlockJacobi<MatrixType, inverse_type>::size_type
PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::Accessor::column() const
}
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline
inverse_type
PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::Accessor::value() const
}
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline
PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::
const_iterator(const PreconditionBlockJacobi<MatrixType, inverse_type> *matrix,
{}
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline
typename PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator &
PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::operator++ ()
}
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline
const typename PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::Accessor &
PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::operator* () const
}
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline
const typename PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::Accessor *
PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::operator-> () const
}
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline
bool
PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::
}
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline
bool
PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::
}
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline
bool
PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::
}
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline
typename PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator
PreconditionBlockJacobi<MatrixType, inverse_type>::begin () const
}
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline
typename PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator
PreconditionBlockJacobi<MatrixType, inverse_type>::end () const
}
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline
typename PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator
PreconditionBlockJacobi<MatrixType, inverse_type>::begin (
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
inline
typename PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator
PreconditionBlockJacobi<MatrixType, inverse_type>::end (
DEAL_II_NAMESPACE_OPEN
-template<typename MatrixType, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
PreconditionBlock<MatrixType, inverse_type>::AdditionalData::
AdditionalData (const size_type block_size,
const double relaxation,
* @author Guido Kanschat
* @date 2010
*/
-template<typename MatrixType,
- typename InverseNumberType = typename MatrixType::value_type,
- typename VectorType = Vector<double> >
+template <typename MatrixType,
+ typename InverseNumberType = typename MatrixType::value_type,
+ typename VectorType = Vector<double> >
class RelaxationBlockJacobi : public virtual Subscriptor,
protected RelaxationBlock<MatrixType, InverseNumberType, VectorType>
{
* @author Guido Kanschat
* @date 2010
*/
-template<typename MatrixType,
- typename InverseNumberType = typename MatrixType::value_type,
- typename VectorType = Vector<double> >
+template <typename MatrixType,
+ typename InverseNumberType = typename MatrixType::value_type,
+ typename VectorType = Vector<double> >
class RelaxationBlockSOR : public virtual Subscriptor,
protected RelaxationBlock<MatrixType, InverseNumberType, VectorType>
{
* @author Guido Kanschat
* @date 2010
*/
-template<typename MatrixType,
- typename InverseNumberType = typename MatrixType::value_type,
- typename VectorType = Vector<double> >
+template <typename MatrixType,
+ typename InverseNumberType = typename MatrixType::value_type,
+ typename VectorType = Vector<double> >
class RelaxationBlockSSOR : public virtual Subscriptor,
protected RelaxationBlock<MatrixType, InverseNumberType, VectorType>
{
}
-template<class VectorType>
+template <class VectorType>
inline
Solver<VectorType>::Solver (SolverControl &solver_control,
VectorMemory<VectorType> &vector_memory)
-template<class VectorType>
+template <class VectorType>
inline
Solver<VectorType>::Solver (SolverControl &solver_control)
:
-template<class VectorType>
+template <class VectorType>
inline
boost::signals2::connection
Solver<VectorType>::
/**
* Solve primal problem only.
*/
- template<typename MatrixType, typename PreconditionerType>
+ template <typename MatrixType, typename PreconditionerType>
void
solve (const MatrixType &A,
VectorType &x,
* The iteration loop itself. The function returns a structure indicating
* what happened in this function.
*/
- template<typename MatrixType, typename PreconditionerType>
+ template <typename MatrixType, typename PreconditionerType>
IterationResult
iterate(const MatrixType &A,
const PreconditionerType &precondition);
#ifndef DOXYGEN
-template<typename VectorType>
+template <typename VectorType>
SolverBicgstab<VectorType>::IterationResult::IterationResult
(const bool breakdown,
const SolverControl::State state,
{}
-template<typename VectorType>
+template <typename VectorType>
SolverBicgstab<VectorType>::SolverBicgstab (SolverControl &cn,
VectorMemory<VectorType> &mem,
const AdditionalData &data)
-template<typename VectorType>
+template <typename VectorType>
SolverBicgstab<VectorType>::SolverBicgstab (SolverControl &cn,
const AdditionalData &data)
:
-template<typename VectorType>
+template <typename VectorType>
SolverBicgstab<VectorType>::~SolverBicgstab ()
{}
-template<typename VectorType>
+template <typename VectorType>
void
SolverBicgstab<VectorType>::print_vectors(const unsigned int,
const VectorType &,
-template<typename VectorType>
-template<typename MatrixType, typename PreconditionerType>
+template <typename VectorType>
+template <typename MatrixType, typename PreconditionerType>
typename SolverBicgstab<VectorType>::IterationResult
SolverBicgstab<VectorType>::iterate(const MatrixType &A,
const PreconditionerType &precondition)
}
-template<typename VectorType>
-template<typename MatrixType, typename PreconditionerType>
+template <typename VectorType>
+template <typename MatrixType, typename PreconditionerType>
void
SolverBicgstab<VectorType>::solve(const MatrixType &A,
VectorType &x,
-template<typename VectorType>
+template <typename VectorType>
boost::signals2::connection
SolverCG<VectorType>::connect_coefficients_slot
(const std::function<void(double,double)> &slot)
-template<typename VectorType>
+template <typename VectorType>
boost::signals2::connection
SolverCG<VectorType>::connect_condition_number_slot
(const std::function<void(double)> &slot,
-template<typename VectorType>
+template <typename VectorType>
boost::signals2::connection
SolverCG<VectorType>::connect_eigenvalues_slot
(const std::function<void (const std::vector<double> &)> &slot,
/**
* Solve the linear system $Ax=b$ for x.
*/
- template<typename MatrixType, typename PreconditionerType>
+ template <typename MatrixType, typename PreconditionerType>
void
solve (const MatrixType &A,
VectorType &x,
/**
* Solve the linear system $Ax=b$ for x.
*/
- template<typename MatrixType, typename PreconditionerType>
+ template <typename MatrixType, typename PreconditionerType>
void
solve (const MatrixType &A,
VectorType &x,
-template<class VectorType>
+template <class VectorType>
inline void
SolverGMRES<VectorType>::compute_eigs_and_cond
(const FullMatrix<double> &H_orig,
-template<class VectorType>
-template<typename MatrixType, typename PreconditionerType>
+template <class VectorType>
+template <typename MatrixType, typename PreconditionerType>
void
SolverGMRES<VectorType>::solve (const MatrixType &A,
VectorType &x,
-template<class VectorType>
+template <class VectorType>
boost::signals2::connection
SolverGMRES<VectorType>::connect_condition_number_slot
(const std::function<void(double)> &slot,
-template<class VectorType>
+template <class VectorType>
boost::signals2::connection
SolverGMRES<VectorType>::connect_eigenvalues_slot
(const std::function<void (const std::vector<std::complex<double> > &)> &slot,
-template<class VectorType>
+template <class VectorType>
boost::signals2::connection
SolverGMRES<VectorType>::connect_hessenberg_slot
(const std::function<void (const FullMatrix<double> &)> &slot,
-template<class VectorType>
+template <class VectorType>
boost::signals2::connection
SolverGMRES<VectorType>::connect_krylov_space_slot
(const std::function<void (const internal::SolverGMRES::TmpVectors<VectorType> &)> &slot)
-template<class VectorType>
+template <class VectorType>
double
SolverGMRES<VectorType>::criterion ()
{
-template<class VectorType>
-template<typename MatrixType, typename PreconditionerType>
+template <class VectorType>
+template <typename MatrixType, typename PreconditionerType>
void
SolverFGMRES<VectorType>::solve (const MatrixType &A,
VectorType &x,
/**
* Solve the linear system $Ax=b$ for x.
*/
- template<typename MatrixType, typename PreconditionerType>
+ template <typename MatrixType, typename PreconditionerType>
void
solve (const MatrixType &A,
VectorType &x,
#ifndef DOXYGEN
-template<class VectorType>
+template <class VectorType>
SolverMinRes<VectorType>::SolverMinRes (SolverControl &cn,
VectorMemory<VectorType> &mem,
const AdditionalData &)
-template<class VectorType>
+template <class VectorType>
SolverMinRes<VectorType>::SolverMinRes (SolverControl &cn,
const AdditionalData &)
:
{}
-template<class VectorType>
+template <class VectorType>
SolverMinRes<VectorType>::~SolverMinRes ()
{}
-template<class VectorType>
+template <class VectorType>
double
SolverMinRes<VectorType>::criterion()
{
}
-template<class VectorType>
+template <class VectorType>
void
SolverMinRes<VectorType>::print_vectors(const unsigned int,
const VectorType &,
-template<class VectorType>
-template<typename MatrixType, typename PreconditionerType>
+template <class VectorType>
+template <typename MatrixType, typename PreconditionerType>
void
SolverMinRes<VectorType>::solve (const MatrixType &A,
VectorType &x,
/**
* Solve the linear system $Ax=b$ for x.
*/
- template<typename MatrixType, typename PreconditionerType>
+ template <typename MatrixType, typename PreconditionerType>
void
solve (const MatrixType &A,
VectorType &x,
* The iteration loop itself. The function returns a structure indicating
* what happened in this function.
*/
- template<typename MatrixType, typename PreconditionerType>
+ template <typename MatrixType, typename PreconditionerType>
IterationResult
iterate (const MatrixType &A,
const PreconditionerType &precondition);
#ifndef DOXYGEN
-template<class VectorType>
+template <class VectorType>
SolverQMRS<VectorType>::IterationResult::IterationResult (const SolverControl::State state,
const double last_residual)
:
{}
-template<class VectorType>
+template <class VectorType>
SolverQMRS<VectorType>::SolverQMRS (SolverControl &cn,
VectorMemory<VectorType> &mem,
const AdditionalData &data)
-template<class VectorType>
+template <class VectorType>
SolverQMRS<VectorType>::SolverQMRS(SolverControl &cn,
const AdditionalData &data)
:
-template<class VectorType>
+template <class VectorType>
double
SolverQMRS<VectorType>::criterion()
{
-template<class VectorType>
+template <class VectorType>
void
SolverQMRS<VectorType>::print_vectors(const unsigned int,
const VectorType &,
-template<class VectorType>
-template<typename MatrixType, typename PreconditionerType>
+template <class VectorType>
+template <typename MatrixType, typename PreconditionerType>
void
SolverQMRS<VectorType>::solve (const MatrixType &A,
VectorType &x,
-template<class VectorType>
-template<typename MatrixType, typename PreconditionerType>
+template <class VectorType>
+template <typename MatrixType, typename PreconditionerType>
typename SolverQMRS<VectorType>::IterationResult
SolverQMRS<VectorType>::iterate(const MatrixType &A,
const PreconditionerType &precondition)
* R(x_k,b)$. The matrix <i>A</i> itself is only used to compute the
* residual.
*/
- template<typename MatrixType, class RelaxationType>
+ template <typename MatrixType, class RelaxationType>
void
solve (const MatrixType &A,
VectorType &x,
/**
* Solve the linear system $Ax=b$ for x.
*/
- template<typename MatrixType, typename PreconditionerType>
+ template <typename MatrixType, typename PreconditionerType>
void
solve (const MatrixType &A,
VectorType &x,
/**
* Solve $A^Tx=b$ for $x$.
*/
- template<typename MatrixType, typename PreconditionerType>
+ template <typename MatrixType, typename PreconditionerType>
void
Tsolve (const MatrixType &A,
VectorType &x,
* SolverName was specified in the constructor.
*
*/
- template<class Matrix, class Preconditioner>
+ template <class Matrix, class Preconditioner>
void solve (const Matrix &A,
VectorType &x,
const VectorType &b,
template <typename VectorType>
-template<class Matrix, class Preconditioner>
+template <class Matrix, class Preconditioner>
void
SolverSelector<VectorType>::solve (const Matrix &A,
VectorType &x,
* Copies the passed SparseMatrix onto this object. This object's sparsity
* pattern remains unchanged.
*/
- template<typename somenumber>
+ template <typename somenumber>
void copy_from (const SparseMatrix<somenumber> &matrix);
/**
DEAL_II_NAMESPACE_OPEN
-template<typename number>
+template <typename number>
SparseLUDecomposition<number>::SparseLUDecomposition()
:
SparseMatrix<number>(),
-template<typename number>
+template <typename number>
SparseLUDecomposition<number>::~SparseLUDecomposition()
{
clear();
}
-template<typename number>
+template <typename number>
void SparseLUDecomposition<number>::clear()
{
std::vector<const size_type *> tmp;
-template<typename number>
+template <typename number>
template <typename somenumber>
void SparseLUDecomposition<number>::initialize (
const SparseMatrix<somenumber> &matrix,
-template<typename number>
+template <typename number>
void
SparseLUDecomposition<number>::prebuild_lower_bound()
{
{
typedef types::global_dof_index size_type;
- template<typename T>
+ template <typename T>
void zero_subrange (const size_type begin,
const size_type end,
T *dst)
DEAL_II_NAMESPACE_OPEN
-template<typename number> class Vector;
-template<typename number> class FullMatrix;
+template <typename number> class Vector;
+template <typename number> class FullMatrix;
/**
* @addtogroup Matrix1
return result;
}
-template<typename number>
+template <typename number>
template <typename MatrixType>
inline
SparseMatrixEZ<number> &
return *this;
}
-template<typename number>
+template <typename number>
template <typename MatrixType>
inline
void
-template<typename number>
+template <typename number>
template <typename MatrixTypeA, typename MatrixTypeB>
inline void
SparseMatrixEZ<number>::conjugate_add (const MatrixTypeA &A,
* @author Guido Kanschat, Wolfgang Bangerth; 1999, 2000; extension for full
* compatibility with LinearOperator class: Jean-Paul Pelteret, 2015
*/
-template<typename number>
+template <typename number>
class SparseVanka
{
public:
* Do the preconditioning. This function takes the residual in @p src and
* returns the resulting update vector in @p dst.
*/
- template<typename number2>
+ template <typename number2>
void vmult (Vector<number2> &dst,
const Vector<number2> &src) const;
* Apply transpose preconditioner. This function takes the residual in @p
* src and returns the resulting update vector in @p dst.
*/
- template<typename number2>
+ template <typename number2>
void Tvmult (Vector<number2> &dst,
const Vector<number2> &src) const;
* The @p vmult of this class of course calls this function with a null
* pointer
*/
- template<typename number2>
+ template <typename number2>
void apply_preconditioner (Vector<number2> &dst,
const Vector<number2> &src,
const std::vector<bool> *const dof_mask = nullptr) const;
*
* @author Wolfgang Bangerth, 2000
*/
-template<typename number>
+template <typename number>
class SparseBlockVanka : public SparseVanka<number>
{
public:
/**
* Apply the preconditioner.
*/
- template<typename number2>
+ template <typename number2>
void vmult (Vector<number2> &dst,
const Vector<number2> &src) const;
#ifndef DOXYGEN
-template<typename number>
+template <typename number>
inline typename SparseVanka<number>::size_type
SparseVanka<number>::m () const
{
return _m;
}
-template<typename number>
+template <typename number>
inline typename SparseVanka<number>::size_type
SparseVanka<number>::n () const
{
return _n;
}
-template<typename number>
-template<typename number2>
+template <typename number>
+template <typename number2>
inline void
SparseVanka<number>::Tvmult (Vector<number2> &/*dst*/,
const Vector<number2> &/*src*/) const
DEAL_II_NAMESPACE_OPEN
-template<typename number>
+template <typename number>
SparseVanka<number>::SparseVanka()
:
matrix (),
}
-template<typename number>
+template <typename number>
SparseVanka<number>::SparseVanka(const SparseMatrix<number> &M,
const std::vector<bool> &selected_dofs,
const bool conserve_mem,
}
-template<typename number>
+template <typename number>
SparseVanka<number>::~SparseVanka()
{
typename std::vector<SmartPointer<FullMatrix<float>,SparseVanka<number> > >::iterator i;
}
-template<typename number>
+template <typename number>
void
SparseVanka<number>::initialize(const SparseMatrix<number> &M,
const AdditionalData &additional_data)
}
-template<typename number>
-template<typename number2>
+template <typename number>
+template <typename number2>
void
SparseVanka<number>::vmult (Vector<number2> &dst,
const Vector<number2> &src) const
}
-template<typename number>
-template<typename number2>
+template <typename number>
+template <typename number2>
void
SparseVanka<number>::apply_preconditioner (Vector<number2> &dst,
const Vector<number2> &src,
DEAL_II_NAMESPACE_OPEN
// forward declarations
-template<typename number> class Vector;
+template <typename number> class Vector;
/*! @addtogroup Matrix1
* @ingroup Matrix1
* @author Guido Kanschat, 2005, 2006
*/
-template<typename number>
+template <typename number>
class TridiagonalMatrix
{
public:
//---------------------------------------------------------------------------
#ifndef DOXYGEN
-template<typename number>
+template <typename number>
types::global_dof_index
TridiagonalMatrix<number>::m() const
{
-template<typename number>
+template <typename number>
types::global_dof_index
TridiagonalMatrix<number>::n() const
{
}
-template<typename number>
+template <typename number>
inline
number
TridiagonalMatrix<number>::operator()(size_type i, size_type j) const
}
-template<typename number>
+template <typename number>
inline
number &
TridiagonalMatrix<number>::operator()(size_type i, size_type j)
*
* @ingroup TrilinosWrappers
*/
- template<typename PayloadBlockType>
+ template <typename PayloadBlockType>
class TrilinosBlockPayload
{
public:
namespace BlockLinearOperator
{
- template<typename PayloadBlockType>
+ template <typename PayloadBlockType>
class TrilinosBlockPayload;
}
}
* A helper class used internally in linear_operator.h. Specialization for
* TrilinosWrappers::MPI::BlockVector.
*/
- template<>
+ template <>
class ReinitHelper<TrilinosWrappers::MPI::BlockVector>
{
public:
* The solve function is used to set properly the Epetra_LinearProblem,
* once it is done this function solves the linear problem.
*/
- template<typename Preconditioner>
+ template <typename Preconditioner>
void do_solve(const Preconditioner &preconditioner);
/**
* A function that sets the preconditioner that the solver will apply
*/
- template<typename Preconditioner>
+ template <typename Preconditioner>
void set_preconditioner (AztecOO &solver,
const Preconditioner &preconditioner);
/**
* The specialization for a const Accessor.
*/
- template<>
+ template <>
class Accessor<true> : public AccessorBase
{
public:
/**
* The specialization for a mutable Accessor.
*/
- template<>
+ template <>
class Accessor<false> : public AccessorBase
{
class Reference
* This is a collective operation that needs to be called on all
* processors in order to avoid a dead lock.
*/
- template<typename SparsityPatternType>
+ template <typename SparsityPatternType>
void reinit (const SparsityPatternType &sparsity_pattern);
/**
*
* @deprecated Use the respective method with IndexSet argument instead.
*/
- template<typename SparsityPatternType>
+ template <typename SparsityPatternType>
void reinit (const Epetra_Map ¶llel_partitioning,
const SparsityPatternType &sparsity_pattern,
const bool exchange_data = false) DEAL_II_DEPRECATED;
*
* @deprecated Use the respective method with IndexSet argument instead.
*/
- template<typename SparsityPatternType>
+ template <typename SparsityPatternType>
void reinit (const Epetra_Map &row_parallel_partitioning,
const Epetra_Map &col_parallel_partitioning,
const SparsityPatternType &sparsity_pattern,
* This is a collective operation that needs to be called on all
* processors in order to avoid a dead lock.
*/
- template<typename SparsityPatternType>
+ template <typename SparsityPatternType>
void reinit (const IndexSet ¶llel_partitioning,
const SparsityPatternType &sparsity_pattern,
const MPI_Comm &communicator = MPI_COMM_WORLD,
* This is a collective operation that needs to be called on all
* processors in order to avoid a dead lock.
*/
- template<typename SparsityPatternType>
+ template <typename SparsityPatternType>
void reinit (const IndexSet &row_parallel_partitioning,
const IndexSet &col_parallel_partitioning,
const SparsityPatternType &sparsity_pattern,
* running on one processor, since the matrix object is inherently
* distributed. Otherwise, an exception will be thrown.
*/
- template<typename VectorType>
+ template <typename VectorType>
void vmult (VectorType &dst,
const VectorType &src) const;
* distributed. Otherwise, an exception will be thrown.
*
*/
- template<typename VectorType>
+ template <typename VectorType>
void vmult_add (VectorType &dst,
const VectorType &src) const;
* parallel, this function uses an ad-hoc partitioning of the rows and
* columns.
*/
- template<typename SparsityPatternType>
+ template <typename SparsityPatternType>
void
copy_from (const SparsityPatternType &nontrilinos_sparsity_pattern);
*
* @deprecated Use the respective method with IndexSet argument instead.
*/
- template<typename SparsityPatternType>
+ template <typename SparsityPatternType>
void
reinit (const Epetra_Map &row_parallel_partitioning,
const Epetra_Map &col_parallel_partitioning,
*
* @deprecated Use the respective method with IndexSet argument instead.
*/
- template<typename SparsityPatternType>
+ template <typename SparsityPatternType>
void
reinit (const Epetra_Map ¶llel_partitioning,
const SparsityPatternType &nontrilinos_sparsity_pattern,
* constructed. This feature is only implemented for input sparsity
* patterns of type DynamicSparsityPattern.
*/
- template<typename SparsityPatternType>
+ template <typename SparsityPatternType>
void
reinit (const IndexSet &row_parallel_partitioning,
const IndexSet &col_parallel_partitioning,
* that is not fully constructed. This feature is only implemented for
* input sparsity patterns of type DynamicSparsityPattern.
*/
- template<typename SparsityPatternType>
+ template <typename SparsityPatternType>
void
reinit (const IndexSet ¶llel_partitioning,
const SparsityPatternType &nontrilinos_sparsity_pattern,
* A helper class used internally in linear_operator.h. Specialization for
* TrilinosWrappers::MPI::Vector.
*/
- template<>
+ template <>
class ReinitHelper<TrilinosWrappers::MPI::Vector>
{
public:
}
#endif
-template<typename number> class LAPACKFullMatrix;
+template <typename number> class LAPACKFullMatrix;
template <typename> class BlockVector;
*
* @author Guido Kanschat, 1998-2003
*/
-template<typename VectorType = dealii::Vector<double> >
+template <typename VectorType = dealii::Vector<double> >
class VectorMemory : public Subscriptor
{
public:
* This class allocates and deletes vectors as needed from the global heap,
* i.e. performs no specially adapted actions for memory management.
*/
-template<typename VectorType = dealii::Vector<double> >
+template <typename VectorType = dealii::Vector<double> >
class PrimitiveVectorMemory : public VectorMemory<VectorType>
{
public:
*
* @author Guido Kanschat, 1999, 2007
*/
-template<typename VectorType = dealii::Vector<double> >
+template <typename VectorType = dealii::Vector<double> >
class GrowingVectorMemory : public VectorMemory<VectorType>
{
public:
}
-template<typename VectorType>
+template <typename VectorType>
inline
GrowingVectorMemory<VectorType>::~GrowingVectorMemory()
{
-template<typename VectorType>
+template <typename VectorType>
inline
VectorType *
GrowingVectorMemory<VectorType>::alloc ()
-template<typename VectorType>
+template <typename VectorType>
inline
void
GrowingVectorMemory<VectorType>::free(const VectorType *const v)
-template<typename VectorType>
+template <typename VectorType>
inline
void
GrowingVectorMemory<VectorType>::release_unused_memory ()
-template<typename VectorType>
+template <typename VectorType>
inline
std::size_t
GrowingVectorMemory<VectorType>::memory_consumption () const
*
* @author Uwe Koecher, 2017
*/
-template<typename T>
+template <typename T>
struct is_serial_vector;
*
* @author Luca Heltai, 2009
*/
-template<typename Number>
+template <typename Number>
class VectorView : public Vector<Number>
{
public:
#ifndef DOXYGEN
-template<typename Number>
+template <typename Number>
inline
VectorView<Number>::VectorView(const size_type new_size, Number *ptr)
{
-template<typename Number>
+template <typename Number>
inline
VectorView<Number>::VectorView(const size_type new_size, const Number *ptr)
{
-template<typename Number>
+template <typename Number>
inline
VectorView<Number>::~VectorView()
{
}
-template<typename Number>
+template <typename Number>
inline
void VectorView<Number>::reinit(const size_type N,
const bool omit_zeroing_entries)
}
-template<typename Number>
+template <typename Number>
inline
void VectorView<Number>::reinit(const size_type new_size, Number *ptr)
{
}
-template<typename Number>
+template <typename Number>
inline
void VectorView<Number>::reinit(const size_type new_size, const Number *ptr)
{
}
-template<typename Number>
+template <typename Number>
inline
void VectorView<Number>::swap(Vector<Number> &)
{
* writes to @p n_components blocks of the block vector starting at the
* index @p first_index. For non-block vectors, @p first_index is ignored.
*/
- template<typename VectorType>
+ template <typename VectorType>
void distribute_local_to_global (VectorType &dst,
const unsigned int first_index = 0) const;
* writes to @p n_components blocks of the block vector starting at the
* index @p first_index. For non-block vectors, @p first_index is ignored.
*/
- template<typename VectorType>
+ template <typename VectorType>
void set_dof_values (VectorType &dst,
const unsigned int first_index = 0) const;
* @p distribute_local_to_global, and @p set_dof_values. It performs the
* operation for several vectors at a time.
*/
- template<typename VectorType, typename VectorOperation>
+ template <typename VectorType, typename VectorOperation>
void read_write_operation (const VectorOperation &operation,
VectorType *vectors[]) const;
* function DoFAccessor::read_dof_values. Note that if vectorization is
* enabled, the DoF values for several cells are set.
*/
- template<typename VectorType>
+ template <typename VectorType>
void read_dof_values_plain (const VectorType *src_data[]);
/**
template <int dim, int n_components_, typename Number>
-template<typename VectorType, typename VectorOperation>
+template <typename VectorType, typename VectorOperation>
inline
void
FEEvaluationBase<dim,n_components_,Number>
template <int dim, int n_components_, typename Number>
-template<typename VectorType>
+template <typename VectorType>
inline
void
FEEvaluationBase<dim,n_components_,Number>
template <int dim, int n_components_, typename Number>
-template<typename VectorType>
+template <typename VectorType>
inline
void
FEEvaluationBase<dim,n_components_,Number>
template <int dim, int n_components_, typename Number>
-template<typename VectorType>
+template <typename VectorType>
inline
void
FEEvaluationBase<dim,n_components_,Number>
template <int dim, int n_components_, typename Number>
-template<typename VectorType>
+template <typename VectorType>
inline
void
FEEvaluationBase<dim,n_components_,Number>
template <int dim, int n_components_, typename Number>
-template<typename VectorType>
+template <typename VectorType>
inline
void
FEEvaluationBase<dim,n_components_,Number>
* in the use cases for this class, but be careful when using it in other
* contexts.
*/
- template<typename Number>
+ template <typename Number>
struct FPArrayComparator
{
FPArrayComparator (const Number scaling);
- template<int dim, typename Number>
+ template <int dim, typename Number>
void
MappingInfo<dim,Number>::evaluate_on_cell (const dealii::Triangulation<dim> &tria,
const std::pair<unsigned int,unsigned int> *cells,
// helper functions to select the blocks and template magic.
namespace internal
{
- template<typename VectorStruct>
+ template <typename VectorStruct>
bool update_ghost_values_start_block (const VectorStruct &vec,
const unsigned int channel,
internal::bool2type<true>);
- template<typename VectorStruct>
+ template <typename VectorStruct>
void reset_ghost_values_block (const VectorStruct &vec,
const bool zero_out_ghosts,
internal::bool2type<true>);
- template<typename VectorStruct>
+ template <typename VectorStruct>
void update_ghost_values_finish_block (const VectorStruct &vec,
internal::bool2type<true>);
- template<typename VectorStruct>
+ template <typename VectorStruct>
void compress_start_block (const VectorStruct &vec,
const unsigned int channel,
internal::bool2type<true>);
- template<typename VectorStruct>
+ template <typename VectorStruct>
void compress_finish_block (const VectorStruct &vec,
internal::bool2type<true>);
- template<typename VectorStruct>
+ template <typename VectorStruct>
bool update_ghost_values_start_block (const VectorStruct &,
const unsigned int,
internal::bool2type<false>)
{
return false;
}
- template<typename VectorStruct>
+ template <typename VectorStruct>
void reset_ghost_values_block (const VectorStruct &,
const bool,
internal::bool2type<false>)
{}
- template<typename VectorStruct>
+ template <typename VectorStruct>
void update_ghost_values_finish_block (const VectorStruct &,
internal::bool2type<false>)
{}
- template<typename VectorStruct>
+ template <typename VectorStruct>
void compress_start_block (const VectorStruct &,
const unsigned int,
internal::bool2type<false>)
{}
- template<typename VectorStruct>
+ template <typename VectorStruct>
void compress_finish_block (const VectorStruct &,
internal::bool2type<false>)
{}
// returns true if the vector was in a state without ghost values before,
// i.e., we need to zero out ghosts in the very end
- template<typename VectorStruct>
+ template <typename VectorStruct>
inline
bool update_ghost_values_start (const VectorStruct &vec,
const unsigned int channel = 0)
- template<typename Number>
+ template <typename Number>
inline
bool update_ghost_values_start (const LinearAlgebra::distributed::Vector<Number> &vec,
const unsigned int channel = 0)
- template<typename VectorStruct>
+ template <typename VectorStruct>
inline
bool update_ghost_values_start_block (const VectorStruct &vec,
const unsigned int channel,
// if the input vector did not have ghosts imported, clear them here again
// in order to avoid subsequent operations e.g. in linear solvers to work
// with ghosts all the time
- template<typename VectorStruct>
+ template <typename VectorStruct>
inline
void reset_ghost_values (const VectorStruct &vec,
const bool zero_out_ghosts)
- template<typename Number>
+ template <typename Number>
inline
void reset_ghost_values (const LinearAlgebra::distributed::Vector<Number> &vec,
const bool zero_out_ghosts)
- template<typename VectorStruct>
+ template <typename VectorStruct>
inline
void reset_ghost_values_block (const VectorStruct &vec,
const bool zero_out_ghosts,
namespace partition
{
- template<typename Worker>
+ template <typename Worker>
class CellWork : public tbb::task
{
public:
- template<typename Worker>
+ template <typename Worker>
class PartitionWork : public tbb::task
{
public:
};
- template<typename Worker>
+ template <typename Worker>
class PartitionWork : public tbb::task
{
public:
} // end of namespace color
- template<typename VectorStruct>
+ template <typename VectorStruct>
class MPIComDistribute : public tbb::task
{
public:
- template<typename VectorStruct>
+ template <typename VectorStruct>
class MPIComCompress : public tbb::task
{
public:
namespace
{
- template<typename Number>
+ template <typename Number>
bool
non_negative(const VectorizedArray<Number> &n)
{
/**
* Assemble the local residuals into the global residuals.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info);
/**
* Assemble both local residuals into the global residuals.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info1,
const DOFINFO &info2);
private:
/**
* Assemble the local matrices into the global matrices.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info);
/**
* Assemble all local matrices into the global matrices.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info1,
const DOFINFO &info2);
/**
* Assemble the local matrices into the global matrices.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info);
/**
* Assemble all local matrices into the global matrices.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info1,
const DOFINFO &info2);
* @ingroup MeshWorker
* @author Guido Kanschat, 2009
*/
- template<int dim, int spacedim = dim, typename number = double>
+ template <int dim, int spacedim = dim, typename number = double>
class DoFInfo : public LocalResults<number>
{
public:
}
- template<int dim, int spacedim, typename number>
+ template <int dim, int spacedim, typename number>
template <class DHFaceIterator>
inline void
DoFInfo<dim,spacedim,number>::set_face(
}
- template<int dim, int spacedim, typename number>
+ template <int dim, int spacedim, typename number>
template <class DHCellIterator, class DHFaceIterator>
inline void
DoFInfo<dim,spacedim,number>::reinit(
}
- template<int dim, int spacedim, typename number>
+ template <int dim, int spacedim, typename number>
template <class DHFaceIterator>
inline void
DoFInfo<dim,spacedim,number>::set_subface(
}
- template<int dim, int spacedim, typename number>
+ template <int dim, int spacedim, typename number>
template <class DHCellIterator, class DHFaceIterator>
inline void
DoFInfo<dim,spacedim,number>::reinit(
}
- template<int dim, int spacedim, typename number>
+ template <int dim, int spacedim, typename number>
inline const BlockIndices &
DoFInfo<dim,spacedim,number>::local_indices() const
{
/**
* Assemble the local values into the global vectors.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info);
/**
* Assemble both local values into the global vectors.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info1,
const DOFINFO &info2);
/**
* Assemble the local values into the global vectors.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info);
/**
* Assemble both local values into the global vectors.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info1,
const DOFINFO &info2);
* @ingroup MeshWorker
* @author Guido Kanschat, 2009
*/
- template<int dim, int spacedim = dim>
+ template <int dim, int spacedim = dim>
class IntegrationInfo
{
private:
* Use the finite element functions in #global_data and fill the vectors
* #values, #gradients and #hessians.
*/
- template<typename number>
+ template <typename number>
void fill_local_data(const DoFInfo<dim, spacedim, number> &info, bool split_fevalues);
/**
//----------------------------------------------------------------------//
- template<int dim, int sdim>
+ template <int dim, int sdim>
inline
IntegrationInfo<dim,sdim>::IntegrationInfo()
:
{}
- template<int dim, int sdim>
+ template <int dim, int sdim>
inline
IntegrationInfo<dim,sdim>::IntegrationInfo(const IntegrationInfo<dim,sdim> &other)
:
- template<int dim, int sdim>
+ template <int dim, int sdim>
template <class FEVALUES>
inline void
IntegrationInfo<dim,sdim>::initialize(
namespace MeshWorker
{
- template<int dim, int sdim>
+ template <int dim, int sdim>
void
IntegrationInfo<dim,sdim>::initialize_data(
const std::shared_ptr<VectorDataBase<dim,sdim> > &data)
}
- template<int dim, int sdim>
+ template <int dim, int sdim>
void
IntegrationInfo<dim,sdim>::clear()
{
- template<int dim, int sdim>
+ template <int dim, int sdim>
template <typename number>
void
IntegrationInfo<dim,sdim>::fill_local_data(const DoFInfo<dim, sdim, number> &info, bool split_fevalues)
}
- template<int dim, int sdim>
+ template <int dim, int sdim>
std::size_t
IntegrationInfo<dim,sdim>::memory_consumption () const
{
//----------------------------------------------------------------------//
- template<int dim, int sdim>
+ template <int dim, int sdim>
IntegrationInfoBox<dim,sdim>::IntegrationInfoBox()
{
cell_flags = update_default;
}
- template<int dim, int sdim>
+ template <int dim, int sdim>
void
IntegrationInfoBox<dim,sdim>::initialize_update_flags (bool neighbor_geometry)
{
}
- template<int dim, int sdim>
+ template <int dim, int sdim>
std::size_t
IntegrationInfoBox<dim,sdim>::memory_consumption () const
{
return true;
}
- template<int dim, class DOFINFO, class A>
+ template <int dim, class DOFINFO, class A>
void assemble(const MeshWorker::DoFInfoBox<dim, DOFINFO> &dinfo, A *assembler)
{
dinfo.assemble(*assembler);
* @author Guido Kanschat
* @date 2010
*/
- template<class INFOBOX, class DOFINFO, int dim, int spacedim, class ITERATOR>
+ template <class INFOBOX, class DOFINFO, int dim, int spacedim, class ITERATOR>
void cell_action(
ITERATOR cell,
DoFInfoBox<dim, DOFINFO> &dof_info,
* @ingroup MeshWorker
* @author Guido Kanschat, 2009
*/
- template<int dim, int spacedim, class DOFINFO, class INFOBOX, class ASSEMBLER, class ITERATOR>
+ template <int dim, int spacedim, class DOFINFO, class INFOBOX, class ASSEMBLER, class ITERATOR>
void loop(ITERATOR begin,
typename identity<ITERATOR>::type end,
DOFINFO &dinfo,
* @ingroup MeshWorker
* @author Guido Kanschat, 2009
*/
- template<int dim, int spacedim, class ITERATOR, class ASSEMBLER>
+ template <int dim, int spacedim, class ITERATOR, class ASSEMBLER>
void integration_loop(ITERATOR begin,
typename identity<ITERATOR>::type end,
DoFInfo<dim, spacedim> &dof_info,
/**
* Write the patch to the output stream.
*/
- template<int dim>
+ template <int dim>
void assemble(const DoFInfo<dim> &info);
/**
* @warning Not implemented yet
*/
- template<int dim>
+ template <int dim>
void assemble(const DoFInfo<dim> &info1,
const DoFInfo<dim> &info2);
* Write the object T either to the stream #os, if initialize_stream()
* has been called, or to @p deallog if no pointer has been set.
*/
- template<typename T>
+ template <typename T>
void write(const T &t) const;
/**
/**
* Assemble both local residuals into the global residuals.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info1,
const DOFINFO &info2);
protected:
* Assemble the local matrices associated with a single cell into the
* global matrix.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info);
/**
* Assemble all local matrices associated with an interior face in the
* info objects into the global matrix.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info1,
const DOFINFO &info2);
protected:
/**
* Assemble the matrix DoFInfo::M1[0] into the global matrix.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info);
/**
* Assemble both local matrices in the info objects into the global
* matrices.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info1,
const DOFINFO &info2);
private:
/**
* Assemble the matrix DoFInfo::M1[0] into the global matrix.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info);
/**
* Assemble both local matrices in the info objects into the global
* matrix.
*/
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info1,
const DOFINFO &info2);
DEAL_II_NAMESPACE_OPEN
-template<int,int> class FEValuesBase;
+template <int,int> class FEValuesBase;
namespace MeshWorker
{
*
* @author Denis Davydov, 2016.
*/
-template<class VectorType = Vector<double> >
+template <class VectorType = Vector<double> >
class MGCoarseGridApplySmoother : public MGCoarseGridBase<VectorType>
{
public:
*
* @author Guido Kanschat, 1999, Ralf Hartmann, 2002.
*/
-template<typename SolverType, class VectorType = Vector<double> >
+template <typename SolverType, class VectorType = Vector<double> >
class MGCoarseGridLACIteration : public MGCoarseGridBase<VectorType>
{
public:
* Constructor. Store solver, matrix and preconditioning method for later
* use.
*/
- template<typename MatrixType, typename PreconditionerType>
+ template <typename MatrixType, typename PreconditionerType>
MGCoarseGridLACIteration (SolverType &,
const MatrixType &,
const PreconditionerType &);
/**
* Initialize new data.
*/
- template<typename MatrixType, typename PreconditionerType>
+ template <typename MatrixType, typename PreconditionerType>
void initialize (SolverType &,
const MatrixType &,
const PreconditionerType &);
* This class provides a wrapper for a deal.II iterative solver with a given
* matrix and preconditioner as a coarse grid operator.
*/
-template<class VectorType,
- class SolverType,
- class MatrixType,
- class PreconditionerType>
+template <class VectorType,
+ class SolverType,
+ class MatrixType,
+ class PreconditionerType>
class MGCoarseGridIterativeSolver : public MGCoarseGridBase<VectorType>
{
public:
*
* @author Guido Kanschat, 2003, 2012
*/
-template<typename number = double, class VectorType = Vector<number> >
+template <typename number = double, class VectorType = Vector<number> >
class MGCoarseGridHouseholder : public MGCoarseGridBase<VectorType>
{
public:
*
* @author Guido Kanschat, 2003, 2012
*/
-template<typename number = double, class VectorType = Vector<number> >
+template <typename number = double, class VectorType = Vector<number> >
class MGCoarseGridSVD : public MGCoarseGridBase<VectorType>
{
public:
#ifndef DOXYGEN
/* ------------------ Functions for MGCoarseGridApplySmoother -----------*/
-template<class VectorType>
+template <class VectorType>
MGCoarseGridApplySmoother<VectorType>::MGCoarseGridApplySmoother ()
: coarse_smooth(nullptr)
{
}
-template<class VectorType>
+template <class VectorType>
MGCoarseGridApplySmoother<VectorType>::MGCoarseGridApplySmoother (const MGSmootherBase<VectorType> &coarse_smooth)
: coarse_smooth(nullptr)
{
}
-template<class VectorType>
+template <class VectorType>
void
MGCoarseGridApplySmoother<VectorType>::initialize (const MGSmootherBase<VectorType> &coarse_smooth_)
{
}
-template<class VectorType>
+template <class VectorType>
void
MGCoarseGridApplySmoother<VectorType>::clear()
{
}
-template<class VectorType>
+template <class VectorType>
void
MGCoarseGridApplySmoother<VectorType>::operator() (const unsigned int level,
VectorType &dst,
DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
-template<typename SolverType, class VectorType>
+template <typename SolverType, class VectorType>
MGCoarseGridLACIteration<SolverType, VectorType>
::MGCoarseGridLACIteration()
:
{}
-template<typename SolverType, class VectorType>
-template<typename MatrixType, typename PreconditionerType>
+template <typename SolverType, class VectorType>
+template <typename MatrixType, typename PreconditionerType>
MGCoarseGridLACIteration<SolverType, VectorType>
::MGCoarseGridLACIteration (SolverType &s,
const MatrixType &m,
}
-template<typename SolverType, class VectorType>
+template <typename SolverType, class VectorType>
MGCoarseGridLACIteration<SolverType, VectorType>
::~MGCoarseGridLACIteration()
{
}
-template<typename SolverType, class VectorType>
-template<typename MatrixType, typename PreconditionerType>
+template <typename SolverType, class VectorType>
+template <typename MatrixType, typename PreconditionerType>
void
MGCoarseGridLACIteration<SolverType, VectorType>
::initialize (SolverType &s,
}
-template<typename SolverType, class VectorType>
+template <typename SolverType, class VectorType>
void
MGCoarseGridLACIteration<SolverType, VectorType>
::clear()
}
-template<typename SolverType, class VectorType>
+template <typename SolverType, class VectorType>
void
MGCoarseGridLACIteration<SolverType, VectorType>
::operator() (const unsigned int /* level */,
}
-template<typename SolverType, class VectorType>
-template<typename MatrixType>
+template <typename SolverType, class VectorType>
+template <typename MatrixType>
void
MGCoarseGridLACIteration<SolverType, VectorType>
::set_matrix(const MatrixType &m)
/* ------------------ Functions for MGCoarseGridHouseholder ------------ */
-template<typename number, class VectorType>
+template <typename number, class VectorType>
MGCoarseGridHouseholder<number, VectorType>::MGCoarseGridHouseholder
(const FullMatrix<number> *A)
{
-template<typename number, class VectorType>
+template <typename number, class VectorType>
void
MGCoarseGridHouseholder<number, VectorType>::initialize(const FullMatrix<number> &A)
{
-template<typename number, class VectorType>
+template <typename number, class VectorType>
void
MGCoarseGridHouseholder<number, VectorType>::operator() (const unsigned int /*level*/,
VectorType &dst,
-template<typename number, class VectorType>
+template <typename number, class VectorType>
void
MGCoarseGridSVD<number, VectorType>::initialize (const FullMatrix<number> &A,
double threshold)
}
-template<typename number, class VectorType>
+template <typename number, class VectorType>
void
MGCoarseGridSVD<number, VectorType>::operator() (
const unsigned int /*level*/,
}
-template<typename number, class VectorType>
+template <typename number, class VectorType>
void
MGCoarseGridSVD<number, VectorType>::log() const
{
* @author Guido Kanschat,
* @date 2003, 2009, 2010
*/
- template<class RelaxationType, typename VectorType>
+ template <class RelaxationType, typename VectorType>
class SmootherRelaxation : public MGLevelObject<RelaxationType>, public MGSmoother<VectorType>
{
public:
*
* @author Guido Kanschat, 2003
*/
-template<typename MatrixType, class RelaxationType, typename VectorType>
+template <typename MatrixType, class RelaxationType, typename VectorType>
class MGSmootherRelaxation : public MGSmoother<VectorType>
{
public:
*
* @author Guido Kanschat, 2009
*/
-template<typename MatrixType, typename PreconditionerType, typename VectorType>
+template <typename MatrixType, typename PreconditionerType, typename VectorType>
class MGSmootherPrecondition : public MGSmoother<VectorType>
{
public:
* This function is a front-end for the same function in
* MGTransferBlockBase.
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void build_matrices (const DoFHandler<dim,spacedim> &dof,
const DoFHandler<dim,spacedim> &mg_dof,
const std::vector<bool> &selected);
* @arg mg_selected: Number of the component for which the transfer matrices
* should be built.
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void build_matrices (const DoFHandler<dim,spacedim> &dof,
const DoFHandler<dim,spacedim> &mg_dof,
unsigned int selected);
*/
unsigned int debug;
- template<int dim, class OtherVectorType, class TRANSFER> friend class PreconditionMG;
+ template <int dim, class OtherVectorType, class TRANSFER> friend class PreconditionMG;
};
*
* @author Guido Kanschat, 1999, 2000, 2001, 2002
*/
-template<int dim, typename VectorType, class TRANSFER>
+template <int dim, typename VectorType, class TRANSFER>
class PreconditionMG : public Subscriptor
{
public:
*
* This is the operator used by LAC iterative solvers.
*/
- template<class OtherVectorType>
+ template <class OtherVectorType>
void vmult (OtherVectorType &dst,
const OtherVectorType &src) const;
* Preconditioning operator. Calls the @p vcycle function of the @p MG
* object passed to the constructor.
*/
- template<class OtherVectorType>
+ template <class OtherVectorType>
void vmult_add (OtherVectorType &dst,
const OtherVectorType &src) const;
*
* Not implemented, but the definition may be needed.
*/
- template<class OtherVectorType>
+ template <class OtherVectorType>
void Tvmult (OtherVectorType &dst,
const OtherVectorType &src) const;
*
* Not implemented, but the definition may be needed.
*/
- template<class OtherVectorType>
+ template <class OtherVectorType>
void Tvmult_add (OtherVectorType &dst,
const OtherVectorType &src) const;
/* --------------------------- inline functions --------------------- */
-template<int dim, typename VectorType, class TRANSFER>
+template <int dim, typename VectorType, class TRANSFER>
PreconditionMG<dim, VectorType, TRANSFER>
::PreconditionMG(const DoFHandler<dim> &dof_handler,
Multigrid<VectorType> &mg,
transfer(&transfer)
{}
-template<int dim, typename VectorType, class TRANSFER>
+template <int dim, typename VectorType, class TRANSFER>
inline bool
PreconditionMG<dim, VectorType, TRANSFER>::empty () const
{
return false;
}
-template<int dim, typename VectorType, class TRANSFER>
-template<class OtherVectorType>
+template <int dim, typename VectorType, class TRANSFER>
+template <class OtherVectorType>
void
PreconditionMG<dim, VectorType, TRANSFER>::vmult
(OtherVectorType &dst,
}
-template<int dim, typename VectorType, class TRANSFER>
+template <int dim, typename VectorType, class TRANSFER>
IndexSet
PreconditionMG<dim, VectorType, TRANSFER>::locally_owned_range_indices() const
{
}
-template<int dim, typename VectorType, class TRANSFER>
+template <int dim, typename VectorType, class TRANSFER>
IndexSet
PreconditionMG<dim, VectorType, TRANSFER>::locally_owned_domain_indices() const
{
}
-template<int dim, typename VectorType, class TRANSFER>
+template <int dim, typename VectorType, class TRANSFER>
MPI_Comm
PreconditionMG<dim, VectorType, TRANSFER>::get_mpi_communicator() const
{
}
-template<int dim, typename VectorType, class TRANSFER>
-template<class OtherVectorType>
+template <int dim, typename VectorType, class TRANSFER>
+template <class OtherVectorType>
void
PreconditionMG<dim, VectorType, TRANSFER>::vmult_add
(OtherVectorType &dst,
}
-template<int dim, typename VectorType, class TRANSFER>
-template<class OtherVectorType>
+template <int dim, typename VectorType, class TRANSFER>
+template <class OtherVectorType>
void
PreconditionMG<dim, VectorType, TRANSFER>::Tvmult
(OtherVectorType &,
}
-template<int dim, typename VectorType, class TRANSFER>
-template<class OtherVectorType>
+template <int dim, typename VectorType, class TRANSFER>
+template <class OtherVectorType>
void
PreconditionMG<dim, VectorType, TRANSFER>::Tvmult_add
(OtherVectorType &,
* @ingroup output
* @author Guido Kanschat, 2000
*/
-template<int dim, typename SolverType, class VectorType = Vector<double> >
+template <int dim, typename SolverType, class VectorType = Vector<double> >
class DoFPrintSolverStep : public SolverType
{
public:
/* ----------------------- template functions --------------- */
-template<int dim, typename SolverType, class VectorType>
+template <int dim, typename SolverType, class VectorType>
DoFPrintSolverStep<dim, SolverType, VectorType>::DoFPrintSolverStep
(SolverControl &control,
VectorMemory<VectorType> &mem,
{}
-template<int dim, typename SolverType, class VectorType>
+template <int dim, typename SolverType, class VectorType>
void
DoFPrintSolverStep<dim, SolverType, VectorType>::print_vectors
(const unsigned int step,
template <int dim> class Quadrature;
-template<typename number> class Vector;
-template<typename number> class FullMatrix;
-template<typename number> class SparseMatrix;
+template <typename number> class Vector;
+template <typename number> class FullMatrix;
+template <typename number> class SparseMatrix;
template <typename number> class BlockSparseMatrix;
template <typename Number> class BlockVector;
* @author Ralf Hartmann, 1999, Oliver Kayser-Herold and Wolfgang Bangerth,
* 2006, Wolfgang Bangerth 2014
*/
-template<int dim,
- typename VectorType = Vector<double>,
- typename DoFHandlerType = DoFHandler<dim> >
+template <int dim,
+ typename VectorType = Vector<double>,
+ typename DoFHandlerType = DoFHandler<dim> >
class SolutionTransfer
{
#ifndef DEAL_II_MSVC
* @see
* @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
- template<int dim>
+ template <int dim>
void project_boundary_values_div_conforming
(const DoFHandler<dim> &dof_handler,
const unsigned int first_vector_component,
* @see
* @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
- template<int dim>
+ template <int dim>
void project_boundary_values_div_conforming
(const hp::DoFHandler<dim> &dof_handler,
const unsigned int first_vector_component,
}
- template<int dim, int spacedim, typename VectorType,
- template <int,int> class DoFHandlerType>
+ template <int dim, int spacedim, typename VectorType,
+ template <int,int> class DoFHandlerType>
void
interpolate_based_on_material_id
(const Mapping<dim,spacedim> &mapping,
// This function computes the
// projection of the boundary
// function on edges for 3D.
- template<typename cell_iterator>
+ template <typename cell_iterator>
void
compute_edge_projection (const cell_iterator &cell,
const unsigned int face,
// dummy implementation of above
// function for all other
// dimensions
- template<int dim, typename cell_iterator>
+ template <int dim, typename cell_iterator>
void
compute_edge_projection (const cell_iterator &,
const unsigned int,
// projection of the boundary
// function on the interior of
// faces.
- template<int dim, typename cell_iterator>
+ template <int dim, typename cell_iterator>
void
compute_face_projection_curl_conforming (const cell_iterator &cell,
const unsigned int face,
namespace internals
{
- template<typename cell_iterator>
+ template <typename cell_iterator>
void
compute_edge_projection_l2 (const cell_iterator &cell,
const unsigned int face,
}
- template<int dim, typename cell_iterator>
+ template <int dim, typename cell_iterator>
void
compute_edge_projection_l2 (const cell_iterator &,
const unsigned int,
Assert (false, ExcInternalError ());
}
- template<int dim, typename cell_iterator>
+ template <int dim, typename cell_iterator>
void
compute_face_projection_curl_conforming_l2
(const cell_iterator &cell,
}
// dummy implementation of above function for all other dimensions
- template<int dim, typename cell_iterator>
+ template <int dim, typename cell_iterator>
void
compute_face_projection_div_conforming (const cell_iterator &,
const unsigned int,
// This function computes the projection of the boundary function on the
// boundary in 3d.
- template<typename cell_iterator>
+ template <typename cell_iterator>
void
compute_face_projection_div_conforming
(const cell_iterator &cell,
// dummy implementation of above
// function for all other
// dimensions
- template<int dim, typename cell_iterator>
+ template <int dim, typename cell_iterator>
void
compute_face_projection_div_conforming (const cell_iterator &,
const unsigned int,
namespace
{
- template<typename number>
+ template <typename number>
double mean_to_double(const number &mean_value)
{
return mean_value;
}
- template<typename number>
+ template <typename number>
double mean_to_double(const std::complex<number> &mean_value)
{
// we need to return double as a norm, but mean value is a complex
}
- template<int dim, int spacedim, template <int,int> class DoFHandlerType,
- typename VectorType>
+ template <int dim, int spacedim, template <int,int> class DoFHandlerType,
+ typename VectorType>
void get_position_vector(const DoFHandlerType<dim,spacedim> &dh,
VectorType &vector,
const ComponentMask &mask)
*
* @param[in] angle The rotation angle (about the z-axis) in radians
*/
- template<typename Number>
+ template <typename Number>
Tensor<2,2,Number>
rotation_matrix_2d (const Number &angle);
* @param[in] axis A unit vector that defines the axis of rotation
* @param[in] angle The rotation angle in radians
*/
- template<typename Number>
+ template <typename Number>
Tensor<2,3,Number>
rotation_matrix_3d (const Point<3,Number> &axis,
const Number &angle);
*
* @dealiiHolzapfelA{75,2.55} @dealiiWriggersA{23,3.11}
*/
- template<int dim, typename Number>
+ template <int dim, typename Number>
Tensor<1,dim,Number>
nansons_formula (const Tensor<1,dim,Number> &N,
const Tensor<2,dim,Number> &F);
-template<typename Number>
+template <typename Number>
Tensor<2,2,Number>
Physics::Transformations::Rotations::rotation_matrix_2d (const Number &angle)
{
-template<typename Number>
+template <typename Number>
Tensor<2,3,Number>
Physics::Transformations::Rotations::rotation_matrix_3d (const Point<3,Number> &axis,
const Number &angle)
-template<int dim, typename Number>
+template <int dim, typename Number>
inline Tensor<1,dim,Number>
Physics::Transformations::nansons_formula (const Tensor<1,dim,Number> &N,
const Tensor<2,dim,Number> &F)
// DataOutFilter class member functions
//----------------------------------------------------------------------//
-template<int dim>
+template <int dim>
void DataOutBase::DataOutFilter::write_point(const unsigned int &index, const Point<dim> &p)
{
Map3DPoint::const_iterator it;
}
}
-template<int dim>
+template <int dim>
void
DataOutBase::DataOutFilter::write_cell(
unsigned int index,
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
static
void
compute_sizes(const std::vector<DataOutBase::Patch<dim, spacedim> > &patches,
*
* @ingroup output
*/
- template<typename FlagsType>
+ template <typename FlagsType>
class StreamBase
{
public:
* some output formats require
* this number to be printed.
*/
- template<typename data>
+ template <typename data>
void write_dataset (const unsigned int index,
const std::vector<data> &values);
};
* some output formats require
* this number to be printed.
*/
- template<typename data>
+ template <typename data>
void write_dataset (const unsigned int index,
const std::vector<data> &values);
};
{}
- template<int dim>
+ template <int dim>
void
DXStream::write_point (const unsigned int,
const Point<dim> &p)
- template<int dim>
+ template <int dim>
void
DXStream::write_cell (unsigned int,
unsigned int start,
- template<typename data>
+ template <typename data>
inline
void
DXStream::write_dataset (const unsigned int,
{}
- template<int dim>
+ template <int dim>
void
GmvStream::write_point (const unsigned int,
const Point<dim> &p)
- template<int dim>
+ template <int dim>
void
GmvStream::write_cell (unsigned int,
unsigned int s,
{}
- template<int dim>
+ template <int dim>
void
TecplotStream::write_point (const unsigned int,
const Point<dim> &p)
- template<int dim>
+ template <int dim>
void
TecplotStream::write_cell (unsigned int,
unsigned int s,
{}
- template<int dim>
+ template <int dim>
void
UcdStream::write_point (const unsigned int index,
const Point<dim> &p)
- template<int dim>
+ template <int dim>
void
UcdStream::write_cell (unsigned int index,
unsigned int start,
- template<typename data>
+ template <typename data>
inline
void
UcdStream::write_dataset (const unsigned int index,
{}
- template<int dim>
+ template <int dim>
void
VtkStream::write_point (const unsigned int,
const Point<dim> &p)
- template<int dim>
+ template <int dim>
void
VtkStream::write_cell (unsigned int,
unsigned int start,
{}
- template<int dim>
+ template <int dim>
void
VtuStream::write_point (const unsigned int,
const Point<dim> &p)
}
- template<int dim>
+ template <int dim>
void
VtuStream::write_cell (unsigned int,
unsigned int start,
namespace Functions
{
- template<int dim>
+ template <int dim>
FlowFunction<dim>::FlowFunction()
:
Function<dim>(dim+1),
{}
- template<int dim>
+ template <int dim>
FlowFunction<dim>::~FlowFunction()
{}
- template<int dim>
+ template <int dim>
void
FlowFunction<dim>::pressure_adjustment(double p)
{
}
- template<int dim>
+ template <int dim>
void FlowFunction<dim>::vector_value_list (
const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const
}
- template<int dim>
+ template <int dim>
void FlowFunction<dim>::vector_value (
const Point<dim> &point,
Vector<double> &value) const
}
- template<int dim>
+ template <int dim>
double FlowFunction<dim>::value (
const Point<dim> &point,
const unsigned int comp) const
}
- template<int dim>
+ template <int dim>
void FlowFunction<dim>::vector_gradient_list (
const std::vector<Point<dim> > &points,
std::vector<std::vector<Tensor<1,dim> > > &values) const
}
- template<int dim>
+ template <int dim>
void FlowFunction<dim>::vector_laplacian_list (
const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const
}
- template<int dim>
+ template <int dim>
std::size_t
FlowFunction<dim>::memory_consumption () const
{
//----------------------------------------------------------------------//
- template<int dim>
+ template <int dim>
PoisseuilleFlow<dim>::PoisseuilleFlow(const double r,
const double Re)
:
}
- template<int dim>
+ template <int dim>
PoisseuilleFlow<dim>::~PoisseuilleFlow()
{}
- template<int dim>
+ template <int dim>
void PoisseuilleFlow<dim>::vector_values (
const std::vector<Point<dim> > &points,
std::vector<std::vector<double> > &values) const
- template<int dim>
+ template <int dim>
void PoisseuilleFlow<dim>::vector_gradients (
const std::vector<Point<dim> > &points,
std::vector<std::vector<Tensor<1,dim> > > &values) const
- template<int dim>
+ template <int dim>
void PoisseuilleFlow<dim>::vector_laplacians (
const std::vector<Point<dim> > &points,
std::vector<std::vector<double> > &values) const
//----------------------------------------------------------------------//
- template<int dim>
+ template <int dim>
StokesCosine<dim>::StokesCosine(const double nu, const double r)
:
viscosity(nu), reaction(r)
{}
- template<int dim>
+ template <int dim>
StokesCosine<dim>::~StokesCosine()
{}
- template<int dim>
+ template <int dim>
void
StokesCosine<dim>::set_parameters(const double nu, const double r)
{
}
- template<int dim>
+ template <int dim>
void StokesCosine<dim>::vector_values (
const std::vector<Point<dim> > &points,
std::vector<std::vector<double> > &values) const
- template<int dim>
+ template <int dim>
void StokesCosine<dim>::vector_gradients (
const std::vector<Point<dim> > &points,
std::vector<std::vector<Tensor<1,dim> > > &values) const
- template<int dim>
+ template <int dim>
void StokesCosine<dim>::vector_laplacians (
const std::vector<Point<dim> > &points,
std::vector<std::vector<double> > &values) const
{
- template<int dim>
+ template <int dim>
double
SquareFunction<dim>::value (const Point<dim> &p,
const unsigned int) const
}
- template<int dim>
+ template <int dim>
void
SquareFunction<dim>::vector_value (const Point<dim> &p,
Vector<double> &values) const
}
- template<int dim>
+ template <int dim>
void
SquareFunction<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
}
- template<int dim>
+ template <int dim>
double
SquareFunction<dim>::laplacian (const Point<dim> &,
const unsigned int) const
}
- template<int dim>
+ template <int dim>
void
SquareFunction<dim>::laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
- template<int dim>
+ template <int dim>
Tensor<1,dim>
SquareFunction<dim>::gradient (const Point<dim> &p,
const unsigned int) const
}
- template<int dim>
+ template <int dim>
void
SquareFunction<dim>::vector_gradient (
const Point<dim> &p,
- template<int dim>
+ template <int dim>
void
SquareFunction<dim>::gradient_list (const std::vector<Point<dim> > &points,
std::vector<Tensor<1,dim> > &gradients,
//////////////////////////////////////////////////////////////////////
- template<int dim>
+ template <int dim>
double
Q1WedgeFunction<dim>::value (const Point<dim> &p,
const unsigned int) const
- template<int dim>
+ template <int dim>
void
Q1WedgeFunction<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
}
- template<int dim>
+ template <int dim>
void
Q1WedgeFunction<dim>::vector_value_list (
const std::vector<Point<dim> > &points,
}
- template<int dim>
+ template <int dim>
double
Q1WedgeFunction<dim>::laplacian (const Point<dim> &,
const unsigned int) const
}
- template<int dim>
+ template <int dim>
void
Q1WedgeFunction<dim>::laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
- template<int dim>
+ template <int dim>
Tensor<1,dim>
Q1WedgeFunction<dim>::gradient (const Point<dim> &p,
const unsigned int) const
- template<int dim>
+ template <int dim>
void
Q1WedgeFunction<dim>::gradient_list (const std::vector<Point<dim> > &points,
std::vector<Tensor<1,dim> > &gradients,
}
- template<int dim>
+ template <int dim>
void
Q1WedgeFunction<dim>::vector_gradient_list (
const std::vector<Point<dim> > &points,
//////////////////////////////////////////////////////////////////////
- template<int dim>
+ template <int dim>
PillowFunction<dim>::PillowFunction (const double offset)
:
offset(offset)
{}
- template<int dim>
+ template <int dim>
double
PillowFunction<dim>::value (const Point<dim> &p,
const unsigned int) const
return 0.;
}
- template<int dim>
+ template <int dim>
void
PillowFunction<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
- template<int dim>
+ template <int dim>
double
PillowFunction<dim>::laplacian (const Point<dim> &p,
const unsigned int) const
return 0.;
}
- template<int dim>
+ template <int dim>
void
PillowFunction<dim>::laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
}
}
- template<int dim>
+ template <int dim>
Tensor<1,dim>
PillowFunction<dim>::gradient (const Point<dim> &p,
const unsigned int) const
return result;
}
- template<int dim>
+ template <int dim>
void
PillowFunction<dim>::gradient_list (const std::vector<Point<dim> > &points,
std::vector<Tensor<1,dim> > &gradients,
- template<int dim>
+ template <int dim>
double
CosineFunction<dim>::value (const Point<dim> &p,
const unsigned int) const
return 0.;
}
- template<int dim>
+ template <int dim>
void
CosineFunction<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
}
- template<int dim>
+ template <int dim>
void
CosineFunction<dim>::vector_value_list (
const std::vector<Point<dim> > &points,
}
- template<int dim>
+ template <int dim>
double
CosineFunction<dim>::laplacian (const Point<dim> &p,
const unsigned int) const
return 0.;
}
- template<int dim>
+ template <int dim>
void
CosineFunction<dim>::laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
values[i] = laplacian(points[i]);
}
- template<int dim>
+ template <int dim>
Tensor<1,dim>
CosineFunction<dim>::gradient (const Point<dim> &p,
const unsigned int) const
return result;
}
- template<int dim>
+ template <int dim>
void
CosineFunction<dim>::gradient_list (const std::vector<Point<dim> > &points,
std::vector<Tensor<1,dim> > &gradients,
}
}
- template<int dim>
+ template <int dim>
SymmetricTensor<2,dim>
CosineFunction<dim>::hessian (const Point<dim> &p,
const unsigned int) const
return result;
}
- template<int dim>
+ template <int dim>
void
CosineFunction<dim>::hessian_list (const std::vector<Point<dim> > &points,
std::vector<SymmetricTensor<2,dim> > &hessians,
{}
- template<int dim>
+ template <int dim>
double
CosineGradFunction<dim>::value (
const Point<dim> &p,
}
- template<int dim>
+ template <int dim>
void
CosineGradFunction<dim>::vector_value (
const Point<dim> &p,
}
- template<int dim>
+ template <int dim>
void
CosineGradFunction<dim>::value_list (
const std::vector<Point<dim> > &points,
}
- template<int dim>
+ template <int dim>
void
CosineGradFunction<dim>::vector_value_list (
const std::vector<Point<dim> > &points,
}
- template<int dim>
+ template <int dim>
double
CosineGradFunction<dim>::laplacian (
const Point<dim> &p,
}
- template<int dim>
+ template <int dim>
Tensor<1,dim>
CosineGradFunction<dim>::gradient (
const Point<dim> &p,
}
- template<int dim>
+ template <int dim>
void
CosineGradFunction<dim>::gradient_list (
const std::vector<Point<dim> > &points,
}
- template<int dim>
+ template <int dim>
void
CosineGradFunction<dim>::vector_gradient_list (
const std::vector<Point<dim> > &points,
//////////////////////////////////////////////////////////////////////
- template<int dim>
+ template <int dim>
double
ExpFunction<dim>::value (const Point<dim> &p,
const unsigned int) const
return 0.;
}
- template<int dim>
+ template <int dim>
void
ExpFunction<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
}
}
- template<int dim>
+ template <int dim>
double
ExpFunction<dim>::laplacian (const Point<dim> &p,
const unsigned int) const
return 0.;
}
- template<int dim>
+ template <int dim>
void
ExpFunction<dim>::laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
}
}
- template<int dim>
+ template <int dim>
Tensor<1,dim>
ExpFunction<dim>::gradient (const Point<dim> &p,
const unsigned int) const
return result;
}
- template<int dim>
+ template <int dim>
void
ExpFunction<dim>::gradient_list (const std::vector<Point<dim> > &points,
std::vector<Tensor<1,dim> > &gradients,
//////////////////////////////////////////////////////////////////////
- template<int dim>
+ template <int dim>
JumpFunction<dim>::JumpFunction(const Point<dim> &direction,
const double steepness)
:
- template<int dim>
+ template <int dim>
double
JumpFunction<dim>::value (const Point<dim> &p,
const unsigned int) const
- template<int dim>
+ template <int dim>
void
JumpFunction<dim>::value_list (const std::vector<Point<dim> > &p,
std::vector<double> &values,
}
- template<int dim>
+ template <int dim>
double
JumpFunction<dim>::laplacian (const Point<dim> &p,
const unsigned int) const
}
- template<int dim>
+ template <int dim>
void
JumpFunction<dim>::laplacian_list (const std::vector<Point<dim> > &p,
std::vector<double> &values,
- template<int dim>
+ template <int dim>
Tensor<1,dim>
JumpFunction<dim>::gradient (const Point<dim> &p,
const unsigned int) const
- template<int dim>
+ template <int dim>
void
JumpFunction<dim>::gradient_list (const std::vector<Point<dim> > &p,
std::vector<Tensor<1,dim> > &gradients,
- template<int dim>
+ template <int dim>
void
Monomial<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
namespace Functions
{
- template<int dim>
+ template <int dim>
CutOffFunctionBase<dim>::CutOffFunctionBase (const double r,
const Point<dim> p,
const unsigned int n_components,
{}
- template<int dim>
+ template <int dim>
void
CutOffFunctionBase<dim>::new_center (const Point<dim> &p)
{
}
- template<int dim>
+ template <int dim>
void
CutOffFunctionBase<dim>::new_radius (const double r)
{
//////////////////////////////////////////////////////////////////////
- template<int dim>
+ template <int dim>
CutOffFunctionLinfty<dim>::CutOffFunctionLinfty (const double r,
const Point<dim> p,
const unsigned int n_components,
{}
- template<int dim>
+ template <int dim>
double
CutOffFunctionLinfty<dim>::value (const Point<dim> &p,
const unsigned int component) const
}
- template<int dim>
+ template <int dim>
void
CutOffFunctionLinfty<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
}
- template<int dim>
+ template <int dim>
void
CutOffFunctionLinfty<dim>::vector_value_list (
const std::vector<Point<dim> > &points,
}
- template<int dim>
+ template <int dim>
CutOffFunctionW1<dim>::CutOffFunctionW1 (const double r,
const Point<dim> p,
const unsigned int n_components,
{}
- template<int dim>
+ template <int dim>
double
CutOffFunctionW1<dim>::value (const Point<dim> &p,
const unsigned int component) const
}
- template<int dim>
+ template <int dim>
void
CutOffFunctionW1<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
- template<int dim>
+ template <int dim>
void
CutOffFunctionW1<dim>::vector_value_list (
const std::vector<Point<dim> > &points,
}
- template<int dim>
+ template <int dim>
CutOffFunctionCinfty<dim>::CutOffFunctionCinfty (const double r,
const Point<dim> p,
const unsigned int n_components,
{}
- template<int dim>
+ template <int dim>
double
CutOffFunctionCinfty<dim>::value (const Point<dim> &p,
const unsigned int component) const
}
- template<int dim>
+ template <int dim>
void
CutOffFunctionCinfty<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
}
- template<int dim>
+ template <int dim>
void
CutOffFunctionCinfty<dim>::vector_value_list (
const std::vector<Point<dim> > &points,
- template<int dim>
+ template <int dim>
Tensor<1,dim>
CutOffFunctionCinfty<dim>::gradient (const Point<dim> &p,
const unsigned int) const
};
-template<int dim>
+template <int dim>
unsigned int
GeometryInfo<dim>::n_children(const RefinementCase<dim> &ref_case)
{
}
-template<>
+template <>
unsigned int
GeometryInfo<1>::n_subfaces(const internal::SubfaceCase<1> &)
{
-template<>
+template <>
unsigned int
GeometryInfo<2>::n_subfaces(const internal::SubfaceCase<2> &subface_case)
{
-template<>
+template <>
unsigned int
GeometryInfo<3>::n_subfaces(const internal::SubfaceCase<3> &subface_case)
{
}
-template<>
+template <>
double
GeometryInfo<1>::subface_ratio(const internal::SubfaceCase<1> &,
const unsigned int)
}
-template<>
+template <>
double
GeometryInfo<2>::subface_ratio(const internal::SubfaceCase<2> &subface_case,
const unsigned int)
}
-template<>
+template <>
double
GeometryInfo<3>::subface_ratio(const internal::SubfaceCase<3> &subface_case,
const unsigned int subface_no)
-template<>
+template <>
RefinementCase<0>
GeometryInfo<1>::face_refinement_case(const RefinementCase<1> &,
const unsigned int,
}
-template<>
+template <>
RefinementCase<1>
GeometryInfo<2>::face_refinement_case(const RefinementCase<2> &cell_refinement_case,
const unsigned int face_no,
}
-template<>
+template <>
RefinementCase<2>
GeometryInfo<3>::face_refinement_case(const RefinementCase<3> &cell_refinement_case,
const unsigned int face_no,
-template<>
+template <>
RefinementCase<1>
GeometryInfo<1>::line_refinement_case(const RefinementCase<1> &cell_refinement_case,
const unsigned int line_no)
}
-template<>
+template <>
RefinementCase<1>
GeometryInfo<2>::line_refinement_case(const RefinementCase<2> &cell_refinement_case,
const unsigned int line_no)
}
-template<>
+template <>
RefinementCase<1>
GeometryInfo<3>::line_refinement_case(const RefinementCase<3> &cell_refinement_case,
const unsigned int line_no)
-template<>
+template <>
RefinementCase<1>
GeometryInfo<1>::min_cell_refinement_case_for_face_refinement(const RefinementCase<0> &,
const unsigned int,
}
-template<>
+template <>
RefinementCase<2>
GeometryInfo<2>::min_cell_refinement_case_for_face_refinement(const RefinementCase<1> &face_refinement_case,
const unsigned int face_no,
}
-template<>
+template <>
RefinementCase<3>
GeometryInfo<3>::min_cell_refinement_case_for_face_refinement(const RefinementCase<2> &face_refinement_case,
const unsigned int face_no,
-template<>
+template <>
RefinementCase<1>
GeometryInfo<1>::min_cell_refinement_case_for_line_refinement(const unsigned int line_no)
{
}
-template<>
+template <>
RefinementCase<2>
GeometryInfo<2>::min_cell_refinement_case_for_line_refinement(const unsigned int line_no)
{
}
-template<>
+template <>
RefinementCase<3>
GeometryInfo<3>::min_cell_refinement_case_for_line_refinement(const unsigned int line_no)
{
-template<int dim>
+template <int dim>
unsigned int
GeometryInfo<dim>::face_to_cell_lines (const unsigned int,
const unsigned int,
DEAL_II_NAMESPACE_OPEN
-template<int dim>
+template <int dim>
PolynomialsNedelec<dim>::PolynomialsNedelec (const unsigned int k) :
my_degree (k), polynomial_space (create_polynomials (k)),
n_pols (compute_n_pols (k))
{
}
-template<int dim>
+template <int dim>
std::vector<std::vector< Polynomials::Polynomial<double> > >
PolynomialsNedelec<dim>::create_polynomials (const unsigned int k)
{
// Compute the values, gradients
// and double gradients of the
// polynomial at the given point.
-template<int dim>
+template <int dim>
void
PolynomialsNedelec<dim>::compute (const Point<dim> &unit_point,
std::vector<Tensor<1,dim> > &values,
}
-template<int dim>
+template <int dim>
unsigned int
PolynomialsNedelec<dim>::compute_n_pols (unsigned int k)
{
//---------------------------------------------------------------------------
-template<int dim>
+template <int dim>
QAnisotropic<dim>::QAnisotropic(const Quadrature<1> &qx)
: Quadrature<dim>(qx.size())
{
-template<int dim>
+template <int dim>
QAnisotropic<dim>::QAnisotropic(const Quadrature<1> &qx,
const Quadrature<1> &qy)
: Quadrature<dim>(qx.size()
-template<int dim>
+template <int dim>
QAnisotropic<dim>::QAnisotropic(const Quadrature<1> &qx,
const Quadrature<1> &qy,
const Quadrature<1> &qz)
}
-// template<>
+// template <>
// void
// QIterated<1>::fill(Quadrature<1>& dst,
// const Quadrature<1> &base_quadrature,
}
-template<>
+template <>
QGaussLogR<1>::QGaussLogR(const unsigned int n,
const Point<1> origin,
const double alpha,
}
-template<>
+template <>
unsigned int QGaussOneOverR<2>::quad_size(const Point<2> singularity,
const unsigned int n)
{
return (8*n*n);
}
-template<>
+template <>
QGaussOneOverR<2>::QGaussOneOverR(const unsigned int n,
const Point<2> singularity,
const bool factor_out_singularity) :
}
-template<>
+template <>
QGaussOneOverR<2>::QGaussOneOverR(const unsigned int n,
const unsigned int vertex_index,
const bool factor_out_singularity) :
-template<int dim>
+template <int dim>
unsigned int
AnisotropicPolynomials<dim>::n() const
{
namespace distributed
{
- template<int dim, typename VectorType, typename DoFHandlerType>
+ template <int dim, typename VectorType, typename DoFHandlerType>
SolutionTransfer<dim, VectorType, DoFHandlerType>::SolutionTransfer (const DoFHandlerType &dof)
:
dof_handler(&dof, typeid(*this).name()),
- template<int dim, typename VectorType, typename DoFHandlerType>
+ template <int dim, typename VectorType, typename DoFHandlerType>
SolutionTransfer<dim, VectorType, DoFHandlerType>::~SolutionTransfer ()
{}
- template<int dim, typename VectorType, typename DoFHandlerType>
+ template <int dim, typename VectorType, typename DoFHandlerType>
void
SolutionTransfer<dim, VectorType, DoFHandlerType>::
prepare_for_coarsening_and_refinement (const std::vector<const VectorType *> &all_in)
- template<int dim, typename VectorType, typename DoFHandlerType>
+ template <int dim, typename VectorType, typename DoFHandlerType>
void
SolutionTransfer<dim, VectorType, DoFHandlerType>::register_data_attach (const std::size_t size)
{
- template<int dim, typename VectorType, typename DoFHandlerType>
+ template <int dim, typename VectorType, typename DoFHandlerType>
void
SolutionTransfer<dim, VectorType, DoFHandlerType>::
prepare_for_coarsening_and_refinement (const VectorType &in)
- template<int dim, typename VectorType, typename DoFHandlerType>
+ template <int dim, typename VectorType, typename DoFHandlerType>
void
SolutionTransfer<dim, VectorType, DoFHandlerType>::prepare_serialization (const VectorType &in)
{
- template<int dim, typename VectorType, typename DoFHandlerType>
+ template <int dim, typename VectorType, typename DoFHandlerType>
void
SolutionTransfer<dim, VectorType, DoFHandlerType>::prepare_serialization
(const std::vector<const VectorType *> &all_in)
- template<int dim, typename VectorType, typename DoFHandlerType>
+ template <int dim, typename VectorType, typename DoFHandlerType>
void
SolutionTransfer<dim, VectorType, DoFHandlerType>::deserialize (VectorType &in)
{
- template<int dim, typename VectorType, typename DoFHandlerType>
+ template <int dim, typename VectorType, typename DoFHandlerType>
void
SolutionTransfer<dim, VectorType, DoFHandlerType>::deserialize (std::vector<VectorType *> &all_in)
{
}
- template<int dim, typename VectorType, typename DoFHandlerType>
+ template <int dim, typename VectorType, typename DoFHandlerType>
void
SolutionTransfer<dim, VectorType, DoFHandlerType>::interpolate (std::vector<VectorType *> &all_out)
{
- template<int dim, typename VectorType, typename DoFHandlerType>
+ template <int dim, typename VectorType, typename DoFHandlerType>
void
SolutionTransfer<dim, VectorType, DoFHandlerType>::interpolate (VectorType &out)
{
- template<int dim, typename VectorType, typename DoFHandlerType>
+ template <int dim, typename VectorType, typename DoFHandlerType>
unsigned int
SolutionTransfer<dim, VectorType, DoFHandlerType>::get_data_size() const
{
}
- template<int dim, typename VectorType, typename DoFHandlerType>
+ template <int dim, typename VectorType, typename DoFHandlerType>
void
SolutionTransfer<dim, VectorType, DoFHandlerType>::
pack_callback(const typename Triangulation<dim,DoFHandlerType::space_dimension>::cell_iterator &cell_,
}
- template<int dim, typename VectorType, typename DoFHandlerType>
+ template <int dim, typename VectorType, typename DoFHandlerType>
void
SolutionTransfer<dim, VectorType, DoFHandlerType>::unpack_callback
(const typename Triangulation<dim,DoFHandlerType::space_dimension>::cell_iterator &cell_,
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
std::vector<bool>
Triangulation<dim,spacedim>
::mark_locally_active_vertices_on_level (const int level) const
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
Triangulation<dim,spacedim>::add_periodicity
(const std::vector<GridTools::PeriodicFacePair<cell_iterator> > &
DEAL_II_NAMESPACE_OPEN
-template<int dim, int spacedim>
+template <int dim, int spacedim>
const unsigned int DoFHandler<dim,spacedim>::dimension;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
const unsigned int DoFHandler<dim,spacedim>::space_dimension;
template <int dim, int spacedim>
namespace internal
{
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
std::string policy_to_string(const dealii::internal::DoFHandler::Policy::PolicyBase<dim,spacedim> &policy)
{
std::string policy_name;
}
}
- template<int spacedim>
+ template <int spacedim>
static
void reserve_space_mg (DoFHandler<1, spacedim> &dof_handler)
{
}
}
- template<int spacedim>
+ template <int spacedim>
static
void reserve_space_mg (DoFHandler<2, spacedim> &dof_handler)
{
}
}
- template<int spacedim>
+ template <int spacedim>
static
void reserve_space_mg (DoFHandler<3, spacedim> &dof_handler)
{
- template<int spacedim>
+ template <int spacedim>
static
types::global_dof_index
get_dof_index (
return mg_level.dof_object.get_dof_index (dof_handler, obj_index, fe_index, local_index);
}
- template<int spacedim>
+ template <int spacedim>
static
types::global_dof_index
get_dof_index (const DoFHandler<2, spacedim> &dof_handler, internal::DoFHandler::DoFLevel<2> &, internal::DoFHandler::DoFFaces<2> &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const int2type<1>)
return mg_faces.lines.get_dof_index (dof_handler, obj_index, fe_index, local_index);
}
- template<int spacedim>
+ template <int spacedim>
static
types::global_dof_index
get_dof_index (const DoFHandler<2, spacedim> &dof_handler, internal::DoFHandler::DoFLevel<2> &mg_level, internal::DoFHandler::DoFFaces<2> &, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const int2type<2>)
return mg_level.dof_object.get_dof_index (dof_handler, obj_index, fe_index, local_index);
}
- template<int spacedim>
+ template <int spacedim>
static
types::global_dof_index
get_dof_index (const DoFHandler<3, spacedim> &dof_handler, internal::DoFHandler::DoFLevel<3> &, internal::DoFHandler::DoFFaces<3> &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const int2type<1>)
return mg_faces.lines.get_dof_index (dof_handler, obj_index, fe_index, local_index);
}
- template<int spacedim>
+ template <int spacedim>
static
types::global_dof_index
get_dof_index (const DoFHandler<3, spacedim> &dof_handler, internal::DoFHandler::DoFLevel<3> &, internal::DoFHandler::DoFFaces<3> &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const int2type<2>)
return mg_faces.quads.get_dof_index (dof_handler, obj_index, fe_index, local_index);
}
- template<int spacedim>
+ template <int spacedim>
static
types::global_dof_index
get_dof_index (const DoFHandler<3, spacedim> &dof_handler, internal::DoFHandler::DoFLevel<3> &mg_level, internal::DoFHandler::DoFFaces<3> &, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const int2type<3>)
return mg_level.dof_object.get_dof_index (dof_handler, obj_index, fe_index, local_index);
}
- template<int spacedim>
+ template <int spacedim>
static
void set_dof_index (const DoFHandler<1, spacedim> &dof_handler, internal::DoFHandler::DoFLevel<1> &mg_level, internal::DoFHandler::DoFFaces<1> &, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const int2type<1>)
{
mg_level.dof_object.set_dof_index (dof_handler, obj_index, fe_index, local_index, global_index);
}
- template<int spacedim>
+ template <int spacedim>
static
void set_dof_index (const DoFHandler<2, spacedim> &dof_handler, internal::DoFHandler::DoFLevel<2> &, internal::DoFHandler::DoFFaces<2> &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const int2type<1>)
{
mg_faces.lines.set_dof_index (dof_handler, obj_index, fe_index, local_index, global_index);
}
- template<int spacedim>
+ template <int spacedim>
static
void set_dof_index (const DoFHandler<2, spacedim> &dof_handler, internal::DoFHandler::DoFLevel<2> &mg_level, internal::DoFHandler::DoFFaces<2> &, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const int2type<2>)
{
mg_level.dof_object.set_dof_index (dof_handler, obj_index, fe_index, local_index, global_index);
}
- template<int spacedim>
+ template <int spacedim>
static
void set_dof_index (const DoFHandler<3, spacedim> &dof_handler, internal::DoFHandler::DoFLevel<3> &, internal::DoFHandler::DoFFaces<3> &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const int2type<1>)
{
mg_faces.lines.set_dof_index (dof_handler, obj_index, fe_index, local_index, global_index);
}
- template<int spacedim>
+ template <int spacedim>
static
void set_dof_index (const DoFHandler<3, spacedim> &dof_handler, internal::DoFHandler::DoFLevel<3> &, internal::DoFHandler::DoFFaces<3> &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const int2type<2>)
{
mg_faces.quads.set_dof_index (dof_handler, obj_index, fe_index, local_index, global_index);
}
- template<int spacedim>
+ template <int spacedim>
static
void set_dof_index (const DoFHandler<3, spacedim> &dof_handler, internal::DoFHandler::DoFLevel<3> &mg_level, internal::DoFHandler::DoFFaces<3> &, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const int2type<3>)
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
DoFHandler<dim,spacedim>::DoFHandler (const Triangulation<dim,spacedim> &tria)
:
tria(&tria, typeid(*this).name()),
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
DoFHandler<dim,spacedim>::DoFHandler ()
:
tria(nullptr, typeid(*this).name()),
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
DoFHandler<dim,spacedim>::
initialize(const Triangulation<dim,spacedim> &t,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
types::global_dof_index DoFHandler<dim,spacedim>::n_boundary_dofs () const
{
std::set<int> boundary_dofs;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
std::size_t
DoFHandler<dim,spacedim>::memory_consumption () const
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void DoFHandler<dim,spacedim>::distribute_dofs (const FiniteElement<dim,spacedim> &ff)
{
selected_fe = &ff;
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void DoFHandler<dim, spacedim>::distribute_mg_dofs (const FiniteElement<dim, spacedim> &fe)
{
(void)fe;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void DoFHandler<dim, spacedim>::reserve_space ()
{
//TODO: move this to distribute_mg_dofs and remove function
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void DoFHandler<dim, spacedim>::clear_mg_space ()
{
mg_levels.clear ();
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void DoFHandler<dim,spacedim>::initialize_local_block_info ()
{
block_info_object.initialize_local(*this);
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void DoFHandler<dim,spacedim>::clear ()
{
// release lock to old fe
}
-template<>
+template <>
void DoFHandler<1>::renumber_dofs (const unsigned int level,
const std::vector<types::global_dof_index> &new_numbers)
{
-template<>
+template <>
void DoFHandler<2>::renumber_dofs (const unsigned int level,
const std::vector<types::global_dof_index> &new_numbers)
{
-template<>
+template <>
void DoFHandler<3>::renumber_dofs (const unsigned int level,
const std::vector<types::global_dof_index> &new_numbers)
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void DoFHandler<dim,spacedim>::clear_space ()
{
levels.clear ();
-template<int dim, int spacedim>
-template<int structdim>
+template <int dim, int spacedim>
+template <int structdim>
types::global_dof_index
DoFHandler<dim, spacedim>::get_dof_index (const unsigned int obj_level,
const unsigned int obj_index,
-template<int dim, int spacedim>
-template<int structdim>
+template <int dim, int spacedim>
+template <int structdim>
void DoFHandler<dim, spacedim>::set_dof_index (const unsigned int obj_level,
const unsigned int obj_index,
const unsigned int fe_index,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
DoFHandler<dim, spacedim>::MGVertexDoFs::MGVertexDoFs ()
:
coarsest_level (numbers::invalid_unsigned_int),
-template<int dim, int spacedim>
+template <int dim, int spacedim>
DoFHandler<dim, spacedim>::MGVertexDoFs::~MGVertexDoFs ()
{
delete[] indices;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void DoFHandler<dim, spacedim>::MGVertexDoFs::init (const unsigned int cl,
const unsigned int fl,
const unsigned int dofs_per_vertex)
-template<int dim, int spacedim>
+template <int dim, int spacedim>
unsigned int DoFHandler<dim, spacedim>::MGVertexDoFs::get_coarsest_level () const
{
return coarsest_level;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
unsigned int DoFHandler<dim, spacedim>::MGVertexDoFs::get_finest_level () const
{
return finest_level;
- template<typename DoFHandlerType>
+ template <typename DoFHandlerType>
void
extract_level_dofs (const unsigned int level,
const DoFHandlerType &dof,
- template<typename DoFHandlerType>
+ template <typename DoFHandlerType>
void
extract_level_dofs (const unsigned int level,
const DoFHandlerType &dof,
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
map_dofs_to_support_points(const hp::MappingCollection<dim, spacedim> &mapping,
const hp::DoFHandler<dim, spacedim> &dof_handler,
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
map_dofs_to_support_points(const hp::MappingCollection<dim, spacedim> &mapping,
const hp::DoFHandler<dim, spacedim> &dof_handler,
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
convert_couplings_to_blocks
(const DoFHandler<dim,spacedim> &dof_handler,
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
convert_couplings_to_blocks (const hp::DoFHandler<dim,spacedim> &dof_handler,
const Table<2, Coupling> &table,
// Build up a (possibly rotated) interpolation matrix that is used in
// set_periodicity_constraints with the help of user supplied matrix
// and first_vector_components.
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
FullMatrix<double> compute_transformation(
const FiniteElement<dim, spacedim> &fe,
const FullMatrix<double> &matrix,
- template<typename DoFHandlerType>
+ template <typename DoFHandlerType>
void
make_periodicity_constraints
(const std::vector<GridTools::PeriodicFacePair<typename DoFHandlerType::cell_iterator> >
// High level interface variants:
- template<typename DoFHandlerType>
+ template <typename DoFHandlerType>
void
make_periodicity_constraints (const DoFHandlerType &dof_handler,
const types::boundary_id b_id1,
- template<typename DoFHandlerType>
+ template <typename DoFHandlerType>
void
make_periodicity_constraints (const DoFHandlerType &dof_handler,
const types::boundary_id b_id,
-template<int dim>
+template <int dim>
bool FiniteElementData<dim>::operator== (const FiniteElementData<dim> &f) const
{
return ((dofs_per_vertex == f.dofs_per_vertex) &&
};
- template<int dim>
+ template <int dim>
void generate_unit_points (const unsigned int,
std::vector<Point<dim> > &);
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void compute_component_wise(
const FiniteElement<dim,spacedim> &element,
std::vector<unsigned int> &renumbering,
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void compute_block_renumbering (
const FiniteElement<dim,spacedim> &element,
std::vector<types::global_dof_index> &renumbering,
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
FullMatrix<double>
compute_node_matrix(const FiniteElement<dim,spacedim> &fe)
{
/*
- template<>
+ template <>
void
compute_embedding_matrices(const FiniteElement<1,2> &,
std::vector<std::vector<FullMatrix<double> > > &,
}
- template<>
+ template <>
void
compute_embedding_matrices(const FiniteElement<1,3> &,
std::vector<std::vector<FullMatrix<double> > > &,
- template<>
+ template <>
void
compute_embedding_matrices(const FiniteElement<2,3>&,
std::vector<std::vector<FullMatrix<double> > >&,
namespace
{
- template<int dim, typename number, int spacedim>
+ template <int dim, typename number, int spacedim>
void
compute_embedding_for_shape_function (
const unsigned int i,
- template<int dim, typename number, int spacedim>
+ template <int dim, typename number, int spacedim>
void
compute_embedding_matrices_for_refinement_case (
const FiniteElement<dim, spacedim> &fe,
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
Point<dim-1>
Mapping<dim,spacedim>::
project_real_point_to_unit_point_on_face (
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingC1<dim,spacedim>::MappingC1Generic::add_line_support_points (const typename Triangulation<dim>::cell_iterator &,
std::vector<Point<dim> > &) const
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingC1<dim,spacedim>::MappingC1Generic::add_quad_support_points (const typename Triangulation<dim>::cell_iterator &,
std::vector<Point<dim> > &) const
-template<int dim, int spacedim>
+template <int dim, int spacedim>
Mapping<dim, spacedim> *
MappingC1<dim,spacedim>::clone () const
{
DEAL_II_NAMESPACE_OPEN
-template<int dim, int spacedim>
+template <int dim, int spacedim>
const unsigned int MappingCartesian<dim,spacedim>::invalid_face_number;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
MappingCartesian<dim, spacedim>::InternalData::InternalData (const Quadrature<dim> &q)
:
cell_extents (numbers::signaling_nan<Tensor<1,dim> >()),
-template<int dim, int spacedim>
+template <int dim, int spacedim>
std::size_t
MappingCartesian<dim, spacedim>::InternalData::memory_consumption () const
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
UpdateFlags
MappingCartesian<dim, spacedim>::requires_update_flags (const UpdateFlags in) const
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
typename Mapping<dim, spacedim>::InternalDataBase *
MappingCartesian<dim, spacedim>::get_data (const UpdateFlags update_flags,
const Quadrature<dim> &q) const
-template<int dim, int spacedim>
+template <int dim, int spacedim>
typename Mapping<dim, spacedim>::InternalDataBase *
MappingCartesian<dim, spacedim>::get_face_data (const UpdateFlags update_flags,
const Quadrature<dim-1>& quadrature) const
-template<int dim, int spacedim>
+template <int dim, int spacedim>
typename Mapping<dim, spacedim>::InternalDataBase *
MappingCartesian<dim, spacedim>::get_subface_data (const UpdateFlags update_flags,
const Quadrature<dim-1> &quadrature) const
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingCartesian<dim, spacedim>::compute_fill (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
const unsigned int face_no,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
CellSimilarity::Similarity
MappingCartesian<dim, spacedim>::
fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingCartesian<dim, spacedim>::
fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingCartesian<dim, spacedim>::
fill_fe_subface_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingCartesian<dim,spacedim>::
transform (const ArrayView<const Tensor<1,dim> > &input,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingCartesian<dim,spacedim>::
transform (const ArrayView<const DerivativeForm<1, dim,spacedim> > &input,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingCartesian<dim,spacedim>::
transform (const ArrayView<const Tensor<2, dim> > &input,
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingCartesian<dim,spacedim>::
transform (const ArrayView<const DerivativeForm<2, dim, spacedim> > &input,
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingCartesian<dim,spacedim>::
transform (const ArrayView<const Tensor<3,dim> > &input,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
Point<dim>
MappingCartesian<dim, spacedim>::transform_real_to_unit_cell (
const typename Triangulation<dim,spacedim>::cell_iterator &cell,
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
Mapping<dim, spacedim> *
MappingCartesian<dim, spacedim>::clone () const
{
DEAL_II_NAMESPACE_OPEN
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::InternalData::InternalData
(const FiniteElement<dim,spacedim> &fe,
const ComponentMask mask)
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
std::size_t
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::InternalData::memory_consumption () const
{
-template<int dim, int spacedim, typename DoFHandlerType, typename VectorType>
+template <int dim, int spacedim, typename DoFHandlerType, typename VectorType>
double &
MappingFEField<dim,spacedim,DoFHandlerType,VectorType>::InternalData::shape
(const unsigned int qpoint,
}
-template<int dim, int spacedim, typename DoFHandlerType, typename VectorType>
+template <int dim, int spacedim, typename DoFHandlerType, typename VectorType>
const Tensor<1,dim> &
MappingFEField<dim,spacedim,DoFHandlerType,VectorType>::InternalData::derivative
(const unsigned int qpoint,
-template<int dim, int spacedim, typename DoFHandlerType, typename VectorType>
+template <int dim, int spacedim, typename DoFHandlerType, typename VectorType>
Tensor<1,dim> &
MappingFEField<dim,spacedim,DoFHandlerType,VectorType>::InternalData::derivative
(const unsigned int qpoint,
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::MappingFEField
(const DoFHandlerType &euler_dof_handler,
const VectorType &euler_vector,
}
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::MappingFEField
(const MappingFEField<dim,spacedim,VectorType,DoFHandlerType> &mapping)
:
-template<int dim, int spacedim, typename DoFHandlerType, typename VectorType>
+template <int dim, int spacedim, typename DoFHandlerType, typename VectorType>
inline
const double &
MappingFEField<dim,spacedim,DoFHandlerType,VectorType>::InternalData::shape
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
void
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
compute_shapes_virtual (const std::vector<Point<dim> > &unit_points,
}
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
UpdateFlags
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::requires_update_flags (const UpdateFlags in) const
{
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
void
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::compute_data
(const UpdateFlags update_flags,
}
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
void
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::compute_face_data
(const UpdateFlags update_flags,
}
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
typename
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::InternalData *
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::get_data (const UpdateFlags update_flags,
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
typename Mapping<dim,spacedim>::InternalDataBase *
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::get_face_data
(const UpdateFlags update_flags,
}
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
typename Mapping<dim,spacedim>::InternalDataBase *
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::get_subface_data
(const UpdateFlags update_flags,
* 'data_set' to differentiate whether we will work on a face (and if so,
* which one) or subface.
*/
- template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+ template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
void
do_fill_fe_face_values (const dealii::Mapping<dim,spacedim> &mapping,
const typename dealii::Triangulation<dim,spacedim>::cell_iterator &cell,
// Note that the CellSimilarity flag is modifiable, since MappingFEField can need to
// recalculate data even when cells are similar.
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
CellSimilarity::Similarity
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
void
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
}
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
void
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
fill_fe_subface_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
namespace
{
- template<int dim, int spacedim, int rank, typename VectorType, typename DoFHandlerType>
+ template <int dim, int spacedim, int rank, typename VectorType, typename DoFHandlerType>
void
transform_fields(const ArrayView<const Tensor<rank,dim> > &input,
const MappingType mapping_type,
}
- template<int dim, int spacedim, int rank, typename VectorType, typename DoFHandlerType>
+ template <int dim, int spacedim, int rank, typename VectorType, typename DoFHandlerType>
void
transform_differential_forms
(const ArrayView<const DerivativeForm<rank, dim,spacedim> > &input,
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
void
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
transform (const ArrayView<const Tensor<1,dim> > &input,
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
void
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
transform (const ArrayView<const DerivativeForm<1, dim, spacedim> > &input,
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
void
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
transform (const ArrayView<const Tensor<2, dim> > &input,
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
void
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
transform (const ArrayView<const DerivativeForm<2, dim, spacedim> > &input,
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
void
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
transform (const ArrayView<const Tensor<3,dim> > &input,
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
Point<spacedim>
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
transform_unit_to_real_cell (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
}
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
Point<spacedim>
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
do_transform_unit_to_real_cell (const InternalData &data) const
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
Point<dim>
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
transform_real_to_unit_cell (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
}
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
Point<dim>
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
do_transform_real_to_unit_cell
}
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
unsigned int
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::get_degree() const
{
}
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
ComponentMask
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::get_component_mask() const
{
}
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
Mapping<dim,spacedim> *
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::clone () const
{
}
-template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
void
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::update_internal_dofs
(const typename Triangulation<dim,spacedim>::cell_iterator &cell,
DEAL_II_NAMESPACE_OPEN
-template<int dim, int spacedim>
+template <int dim, int spacedim>
MappingManifold<dim,spacedim>::InternalData::InternalData ()
{}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
std::size_t
MappingManifold<dim,spacedim>::InternalData::memory_consumption () const
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
MappingManifold<dim,spacedim>::MappingManifold ()
{}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
MappingManifold<dim,spacedim>::MappingManifold (const MappingManifold<dim,spacedim> &)
{}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
Mapping<dim,spacedim> *
MappingManifold<dim,spacedim>::clone () const
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
Point<dim>
MappingManifold<dim,spacedim>::
transform_real_to_unit_cell (const typename Triangulation<dim,spacedim>::cell_iterator &,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
Point<spacedim>
MappingManifold<dim,spacedim>::
transform_unit_to_real_cell (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
UpdateFlags
MappingManifold<dim,spacedim>::requires_update_flags (const UpdateFlags in) const
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
typename MappingManifold<dim,spacedim>::InternalData *
MappingManifold<dim,spacedim>::get_data (const UpdateFlags update_flags,
const Quadrature<dim> &q) const
-template<int dim, int spacedim>
+template <int dim, int spacedim>
typename MappingManifold<dim,spacedim>::InternalData *
MappingManifold<dim,spacedim>::get_face_data (const UpdateFlags update_flags,
const Quadrature<dim-1> &quadrature) const
-template<int dim, int spacedim>
+template <int dim, int spacedim>
typename MappingManifold<dim,spacedim>::InternalData *
MappingManifold<dim,spacedim>::get_subface_data (const UpdateFlags update_flags,
const Quadrature<dim-1>& quadrature) const
* are no Manifolds associated to faces. The mapping argument is
* only used to help the compiler infer dim and spacedim.
*/
- template<int spacedim>
+ template <int spacedim>
const dealii::Manifold<1, spacedim> &
get_face_manifold(const MappingManifold<1,spacedim> &,
const typename dealii::Triangulation<1,spacedim>::cell_iterator &cell,
* Some specialization for face Manifolds. The mapping argument is
* only used to help the compiler infer dim and spacedim.
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
const dealii::Manifold<dim,spacedim> &
get_face_manifold(const MappingManifold<dim,spacedim> &,
const typename dealii::Triangulation<dim,spacedim>::cell_iterator &cell,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
CellSimilarity::Similarity
MappingManifold<dim,spacedim>::
fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
* using the 'data_set' to differentiate whether we will
* work on a face (and if so, which one) or subface.
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
do_fill_fe_face_values (const dealii::MappingManifold<dim,spacedim> &mapping,
const typename dealii::Triangulation<dim,spacedim>::cell_iterator &cell,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingManifold<dim,spacedim>::
fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingManifold<dim,spacedim>::
fill_fe_subface_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
- template<int dim, int spacedim, int rank>
+ template <int dim, int spacedim, int rank>
void
transform_differential_forms(const ArrayView<const DerivativeForm<rank, dim,spacedim> > &input,
const MappingType mapping_type,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingManifold<dim,spacedim>::
transform (const ArrayView<const Tensor<1, dim> > &input,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingManifold<dim,spacedim>::
transform (const ArrayView<const DerivativeForm<1, dim,spacedim> > &input,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingManifold<dim,spacedim>::
transform (const ArrayView<const Tensor<2, dim> > &input,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingManifold<dim,spacedim>::
transform (const ArrayView<const DerivativeForm<2, dim, spacedim> > &input,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingManifold<dim,spacedim>::
transform (const ArrayView<const Tensor<3,dim> > &input,
DEAL_II_NAMESPACE_OPEN
-template<int dim, int spacedim>
+template <int dim, int spacedim>
MappingQ<dim,spacedim>::InternalData::InternalData ()
:
use_mapping_q1_on_current_cell(false)
-template<int dim, int spacedim>
+template <int dim, int spacedim>
std::size_t
MappingQ<dim,spacedim>::InternalData::memory_consumption () const
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
MappingQ<dim,spacedim>::MappingQ (const unsigned int degree,
const bool use_mapping_q_on_all_cells)
:
-template<int dim, int spacedim>
+template <int dim, int spacedim>
MappingQ<dim,spacedim>::MappingQ (const MappingQ<dim,spacedim> &mapping)
:
polynomial_degree (mapping.polynomial_degree),
-template<int dim, int spacedim>
+template <int dim, int spacedim>
unsigned int
MappingQ<dim,spacedim>::get_degree() const
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
UpdateFlags
MappingQ<dim,spacedim>::requires_update_flags (const UpdateFlags in) const
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
typename MappingQ<dim,spacedim>::InternalData *
MappingQ<dim,spacedim>::get_data (const UpdateFlags update_flags,
const Quadrature<dim> &quadrature) const
-template<int dim, int spacedim>
+template <int dim, int spacedim>
typename MappingQ<dim,spacedim>::InternalData *
MappingQ<dim,spacedim>::get_face_data (const UpdateFlags update_flags,
const Quadrature<dim-1>& quadrature) const
-template<int dim, int spacedim>
+template <int dim, int spacedim>
typename MappingQ<dim,spacedim>::InternalData *
MappingQ<dim,spacedim>::get_subface_data (const UpdateFlags update_flags,
const Quadrature<dim-1>& quadrature) const
// Note that the CellSimilarity flag is modifiable, since MappingQ can need to
// recalculate data even when cells are similar.
-template<int dim, int spacedim>
+template <int dim, int spacedim>
CellSimilarity::Similarity
MappingQ<dim,spacedim>::
fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingQ<dim,spacedim>::
fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingQ<dim,spacedim>::
fill_fe_subface_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingQ<dim,spacedim>::
transform (const ArrayView<const Tensor<1,dim> > &input,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingQ<dim,spacedim>::
transform (const ArrayView<const DerivativeForm<1, dim, spacedim> > &input,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingQ<dim,spacedim>::
transform (const ArrayView<const Tensor<2, dim> > &input,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingQ<dim,spacedim>::
transform (const ArrayView<const DerivativeForm<2, dim,spacedim> > &input,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void MappingQ<dim,spacedim>::
transform (const ArrayView<const Tensor<3, dim> > &input,
const MappingType mapping_type,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
Point<spacedim>
MappingQ<dim,spacedim>::
transform_unit_to_real_cell (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
Point<dim>
MappingQ<dim,spacedim>::
transform_real_to_unit_cell (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
Mapping<dim,spacedim> *
MappingQ<dim,spacedim>::clone () const
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
MappingQ1<dim,spacedim>::MappingQ1 ()
:
MappingQGeneric<dim,spacedim> (1)
-template<int dim, int spacedim>
+template <int dim, int spacedim>
MappingQ1<dim,spacedim> *
MappingQ1<dim,spacedim>::clone () const
{
//---------------------------------------------------------------------------
-template<int dim, int spacedim>
+template <int dim, int spacedim>
MappingQGeneric<dim,spacedim>
StaticMappingQ1<dim,spacedim>::mapping = MappingQGeneric<dim,spacedim>(1);
-template<int dim, class VectorType, int spacedim>
+template <int dim, class VectorType, int spacedim>
std::vector<Point<spacedim> >
MappingQ1Eulerian<dim,VectorType,spacedim>::
compute_mapping_support_points(const typename Triangulation<dim,spacedim>::cell_iterator &cell) const
-template<int dim, class VectorType, int spacedim>
+template <int dim, class VectorType, int spacedim>
CellSimilarity::Similarity
MappingQ1Eulerian<dim,VectorType,spacedim>::
fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-template<int dim, class VectorType, int spacedim>
+template <int dim, class VectorType, int spacedim>
CellSimilarity::Similarity
MappingQEulerian<dim,VectorType,spacedim>::
fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
// expanded before the compiler eliminates code due to the 'if (dim ==
// spacedim)' statement (see the body of the general
// transform_real_to_unit_cell).
- template<int spacedim>
+ template <int spacedim>
Point<1>
transform_real_to_unit_cell
(const std::array<Point<spacedim>, GeometryInfo<1>::vertices_per_cell> &vertices,
- template<int spacedim>
+ template <int spacedim>
Point<2>
transform_real_to_unit_cell
(const std::array<Point<spacedim>, GeometryInfo<2>::vertices_per_cell> &vertices,
- template<int spacedim>
+ template <int spacedim>
Point<3>
transform_real_to_unit_cell
(const std::array<Point<spacedim>, GeometryInfo<3>::vertices_per_cell> &/*vertices*/,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
MappingQGeneric<dim,spacedim>::InternalData::InternalData (const unsigned int polynomial_degree)
:
polynomial_degree (polynomial_degree),
-template<int dim, int spacedim>
+template <int dim, int spacedim>
std::size_t
MappingQGeneric<dim,spacedim>::InternalData::memory_consumption () const
{
-template<>
+template <>
void
MappingQGeneric<1,1>::InternalData::
compute_shape_function_values (const std::vector<Point<1> > &unit_points)
}
}
-template<>
+template <>
void
MappingQGeneric<2,2>::InternalData::
compute_shape_function_values (const std::vector<Point<2> > &unit_points)
}
}
-template<>
+template <>
void
MappingQGeneric<3,3>::InternalData::
compute_shape_function_values (const std::vector<Point<3> > &unit_points)
}
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingQGeneric<dim,spacedim>::InternalData::
compute_shape_function_values (const std::vector<Point<dim> > &unit_points)
* For the definition of the <tt>support_point_weights_on_quad(hex)</tt> please
* refer to equation (8) of the `mapping' report.
*/
- template<int dim>
+ template <int dim>
Table<2,double>
compute_laplace_vector(const unsigned int polynomial_degree)
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
MappingQGeneric<dim,spacedim>::MappingQGeneric (const unsigned int p)
:
polynomial_degree(p),
-template<int dim, int spacedim>
+template <int dim, int spacedim>
MappingQGeneric<dim,spacedim>::MappingQGeneric (const MappingQGeneric<dim,spacedim> &mapping)
:
polynomial_degree(mapping.polynomial_degree),
-template<int dim, int spacedim>
+template <int dim, int spacedim>
Mapping<dim,spacedim> *
MappingQGeneric<dim,spacedim>::clone () const
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
unsigned int
MappingQGeneric<dim,spacedim>::get_degree() const
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
Point<spacedim>
MappingQGeneric<dim,spacedim>::
transform_unit_to_real_cell (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
* support points (stored in data.mapping_support_points), compute
* the mapped location of that point in real space.
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
Point<spacedim>
compute_mapped_location_of_point (const typename MappingQGeneric<dim,spacedim>::InternalData &data)
{
// use template specialization to make sure we pick up the right function to
// call:
-template<int dim, int spacedim>
+template <int dim, int spacedim>
Point<dim>
MappingQGeneric<dim,spacedim>::
transform_real_to_unit_cell_internal
return Point<dim>();
}
-template<>
+template <>
Point<1>
MappingQGeneric<1,1>::
transform_real_to_unit_cell_internal
return do_transform_real_to_unit_cell_internal<1>(cell, p, initial_p_unit, *mdata);
}
-template<>
+template <>
Point<2>
MappingQGeneric<2, 2>::
transform_real_to_unit_cell_internal
return do_transform_real_to_unit_cell_internal<2>(cell, p, initial_p_unit, *mdata);
}
-template<>
+template <>
Point<3>
MappingQGeneric<3, 3>::
transform_real_to_unit_cell_internal
return do_transform_real_to_unit_cell_internal<3>(cell, p, initial_p_unit, *mdata);
}
-template<>
+template <>
Point<1>
MappingQGeneric<1, 2>::
transform_real_to_unit_cell_internal
return do_transform_real_to_unit_cell_internal_codim1<1>(cell, p, initial_p_unit, *mdata);
}
-template<>
+template <>
Point<2>
MappingQGeneric<2, 3>::
transform_real_to_unit_cell_internal
return do_transform_real_to_unit_cell_internal_codim1<2>(cell, p, initial_p_unit, *mdata);
}
-template<>
+template <>
Point<1>
MappingQGeneric<1, 3>::
transform_real_to_unit_cell_internal
-template<int dim, int spacedim>
+template <int dim, int spacedim>
Point<dim>
MappingQGeneric<dim,spacedim>::
transform_real_to_unit_cell (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
UpdateFlags
MappingQGeneric<dim,spacedim>::requires_update_flags (const UpdateFlags in) const
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
typename MappingQGeneric<dim,spacedim>::InternalData *
MappingQGeneric<dim,spacedim>::get_data (const UpdateFlags update_flags,
const Quadrature<dim> &q) const
-template<int dim, int spacedim>
+template <int dim, int spacedim>
typename MappingQGeneric<dim,spacedim>::InternalData *
MappingQGeneric<dim,spacedim>::get_face_data (const UpdateFlags update_flags,
const Quadrature<dim-1> &quadrature) const
-template<int dim, int spacedim>
+template <int dim, int spacedim>
typename MappingQGeneric<dim,spacedim>::InternalData *
MappingQGeneric<dim,spacedim>::get_subface_data (const UpdateFlags update_flags,
const Quadrature<dim-1>& quadrature) const
-template<int dim, int spacedim>
+template <int dim, int spacedim>
CellSimilarity::Similarity
MappingQGeneric<dim,spacedim>::
fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
* using the 'data_set' to differentiate whether we will
* work on a face (and if so, which one) or subface.
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
do_fill_fe_face_values (const dealii::MappingQGeneric<dim,spacedim> &mapping,
const typename dealii::Triangulation<dim,spacedim>::cell_iterator &cell,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingQGeneric<dim,spacedim>::
fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingQGeneric<dim,spacedim>::
fill_fe_subface_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
- template<int dim, int spacedim, int rank>
+ template <int dim, int spacedim, int rank>
void
transform_differential_forms(const ArrayView<const DerivativeForm<rank, dim,spacedim> > &input,
const MappingType mapping_type,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingQGeneric<dim,spacedim>::
transform (const ArrayView<const Tensor<1, dim> > &input,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingQGeneric<dim,spacedim>::
transform (const ArrayView<const DerivativeForm<1, dim,spacedim> > &input,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingQGeneric<dim,spacedim>::
transform (const ArrayView<const Tensor<2, dim> > &input,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingQGeneric<dim,spacedim>::
transform (const ArrayView<const DerivativeForm<2, dim, spacedim> > &input,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
MappingQGeneric<dim,spacedim>::
transform (const ArrayView<const Tensor<3,dim> > &input,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
std::vector<Point<spacedim> >
MappingQGeneric<dim,spacedim>::
compute_mapping_support_points(const typename Triangulation<dim,spacedim>::cell_iterator &cell) const
- template<int spacedim>
+ template <int spacedim>
void
colorize_subdivided_hyper_rectangle (Triangulation<1,spacedim> &tria,
const Point<spacedim> &,
- template<>
+ template <>
void
torus<2,3> (Triangulation<2,3> &tria,
const double R,
tria.set_all_manifold_ids(0);
}
- template<>
+ template <>
void
torus<3,3> (Triangulation<3,3> &tria,
const double R,
- template<>
+ template <>
void
parallelogram (Triangulation<3> &,
const Point<3> ( &/*corners*/)[3],
Assert (false, ExcNotImplemented());
}
- template<>
+ template <>
void
parallelogram (Triangulation<1> &,
const Point<1> ( &/*corners*/)[1],
}
// Implementation for 2D only
- template<>
+ template <>
void
parallelogram (Triangulation<2> &tria,
const Point<2> (&corners)[2],
- template<int dim>
+ template <int dim>
void
parallelepiped (Triangulation<dim> &tria,
const Point<dim> (&corners) [dim],
colorize);
}
- template<int dim>
+ template <int dim>
void
subdivided_parallelepiped (Triangulation<dim> &tria,
const unsigned int n_subdivisions,
colorize);
}
- template<int dim>
+ template <int dim>
void
subdivided_parallelepiped (Triangulation<dim> &tria,
#ifndef _MSC_VER
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void GridIn<dim, spacedim>::read_vtk(std::istream &in)
{
Assert((dim == 2)||(dim == 3), ExcNotImplemented());
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void GridIn<dim, spacedim>::read_unv(std::istream &in)
{
Assert(tria != nullptr, ExcNoTriangulationSelected());
-template<>
+template <>
void
GridReordering<1>::invert_all_cells_of_negative_grid(const std::vector<Point<1> > &,
std::vector<CellData<1> > &)
-template<>
+template <>
void
GridReordering<1,2>::invert_all_cells_of_negative_grid(const std::vector<Point<2> > &,
std::vector<CellData<1> > &)
-template<>
+template <>
void
GridReordering<1,3>::invert_all_cells_of_negative_grid(const std::vector<Point<3> > &,
std::vector<CellData<1> > &)
}
-template<>
+template <>
void
GridReordering<2>::invert_all_cells_of_negative_grid(const std::vector<Point<2> > &all_vertices,
std::vector<CellData<2> > &cells)
-template<>
+template <>
void
GridReordering<2,3>::invert_all_cells_of_negative_grid(const std::vector<Point<3> > &,
std::vector<CellData<2> > &)
-template<>
+template <>
void
GridReordering<3>::invert_all_cells_of_negative_grid(const std::vector<Point<3> > &all_vertices,
std::vector<CellData<3> > &cells)
transform (Rotate2d(angle), triangulation);
}
- template<int dim>
+ template <int dim>
void
rotate (const double angle,
const unsigned int axis,
}
- template<int dim, template<int, int> class MeshType, int spacedim>
+ template <int dim, template <int, int> class MeshType, int spacedim>
#ifndef _MSC_VER
std::vector<typename MeshType<dim, spacedim>::active_cell_iterator>
#else
namespace
{
- template <int dim, template<int, int> class MeshType, int spacedim>
+ template <int dim, template <int, int> class MeshType, int spacedim>
void find_active_cell_around_point_internal
(const MeshType<dim,spacedim> &mesh,
#ifndef _MSC_VER
}
}
- template <int dim, template<int, int> class MeshType, int spacedim>
+ template <int dim, template <int, int> class MeshType, int spacedim>
#ifndef _MSC_VER
typename MeshType<dim, spacedim>::active_cell_iterator
#else
namespace
{
- template<class MeshType>
+ template <class MeshType>
bool
contains_locally_owned_cells (const std::vector<typename MeshType::active_cell_iterator> &cells)
{
return false;
}
- template<class MeshType>
+ template <class MeshType>
bool
contains_artificial_cells (const std::vector<typename MeshType::active_cell_iterator> &cells)
{
- template< class MeshType>
+ template < class MeshType>
std::pair< Point<MeshType::space_dimension>, Point<MeshType::space_dimension> >
compute_bounding_box
( const MeshType &mesh,
* matrix.point1 + offset - point2
* is parallel to the unit vector in <direction>
*/
- template<int spacedim>
+ template <int spacedim>
inline bool orthogonal_equality (const Point<spacedim> &point1,
const Point<spacedim> &point2,
const int direction,
* documentation of make_periodicity_constraints and
* collect_periodic_faces for details
*/
- template<int dim> struct OrientationLookupTable {};
+ template <int dim> struct OrientationLookupTable {};
- template<> struct OrientationLookupTable<1>
+ template <> struct OrientationLookupTable<1>
{
typedef std::array<unsigned int, GeometryInfo<1>::vertices_per_face> MATCH_T;
static inline std::bitset<3> lookup (const MATCH_T &)
}
};
- template<> struct OrientationLookupTable<2>
+ template <> struct OrientationLookupTable<2>
{
typedef std::array<unsigned int, GeometryInfo<2>::vertices_per_face> MATCH_T;
static inline std::bitset<3> lookup (const MATCH_T &matching)
}
};
- template<> struct OrientationLookupTable<3>
+ template <> struct OrientationLookupTable<3>
{
typedef std::array<unsigned int, GeometryInfo<3>::vertices_per_face> MATCH_T;
static inline std::bitset<3> lookup (const MATCH_T &matching)
- template<typename FaceIterator>
+ template <typename FaceIterator>
inline bool
orthogonal_equality (std::bitset<3> &orientation,
const FaceIterator &face1,
- template<typename FaceIterator>
+ template <typename FaceIterator>
inline bool
orthogonal_equality (const FaceIterator &face1,
const FaceIterator &face2,
/*
* Internally used in collect_periodic_faces
*/
- template<typename CellIterator>
+ template <typename CellIterator>
void
match_periodic_face_pairs
(std::set<std::pair<CellIterator, unsigned int> > &pairs1,
- template<typename MeshType>
+ template <typename MeshType>
void
collect_periodic_faces
(const MeshType &mesh,
- template<typename MeshType>
+ template <typename MeshType>
void
collect_periodic_faces
(const MeshType &mesh,
}
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
std::pair<unsigned int, double>
get_longest_direction(typename Triangulation<dim, spacedim>::active_cell_iterator cell)
{
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
remove_hanging_nodes( Triangulation<dim,spacedim> &tria,
const bool isotropic,
}
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
remove_anisotropy( Triangulation<dim,spacedim> &tria,
const double max_ratio,
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void regularize_corner_cells (Triangulation<dim,spacedim> &tria,
const double limit_angle_fraction)
{
-template<>
+template <>
Tensor<1,3>
Manifold<3, 3>::
normal_vector (const Triangulation<3, 3>::face_iterator &face,
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void
Triangulation<dim, spacedim>::clear_despite_subscriptions()
{
-template<int dim, int spacedim>
+template <int dim, int spacedim>
Triangulation<dim, spacedim>::DistortedCellList::~DistortedCellList () noexcept
{
// don't do anything here. the compiler will automatically convert
// 1) project point onto manifold and
// 2) transform to the unit cell with a Q1 mapping
// 3) then check if inside unit cell
-template<int dim, int spacedim>
-template<int dim_,int spacedim_ >
+template <int dim, int spacedim>
+template <int dim_,int spacedim_ >
bool CellAccessor<dim,spacedim>::
point_inside_codim(const Point<spacedim_> &p) const
{
-template<>
+template <>
Point<3>
CylinderBoundary<3>::
get_new_point_on_quad (const Triangulation<3>::quad_iterator &quad) const
point_on_axis);
}
-template<>
+template <>
Point<3>
CylinderBoundary<2,3>::
get_new_point_on_quad (const Triangulation<2,3>::quad_iterator &quad) const
//======================================================================//
-template<int dim>
+template <int dim>
ConeBoundary<dim>::ConeBoundary (const double radius_0,
const double radius_1,
const Point<dim> x_0,
-template<int dim>
+template <int dim>
double ConeBoundary<dim>::get_radius (Point<dim> x) const
{
for (unsigned int i = 0; i < dim; ++i)
-template<int dim>
+template <int dim>
void
ConeBoundary<dim>::
get_intermediate_points_between_points (const Point<dim> &p0,
}
}
-template<int dim>
+template <int dim>
Point<dim>
ConeBoundary<dim>::
get_new_point_on_line (const typename Triangulation<dim>::line_iterator &line) const
-template<int dim>
+template <int dim>
Point<dim>
ConeBoundary<dim>::
get_new_point_on_quad (const typename Triangulation<dim>::quad_iterator &) const
-template<int dim>
+template <int dim>
void
ConeBoundary<dim>::
get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
-template<>
+template <>
void
ConeBoundary<3>::
get_intermediate_points_on_quad (const Triangulation<3>::quad_iterator &quad,
-template<>
+template <>
void
ConeBoundary<1>::
get_normals_at_vertices (const Triangulation<1>::face_iterator &,
-template<int dim>
+template <int dim>
void
ConeBoundary<dim>::
get_normals_at_vertices (const typename Triangulation<dim>::face_iterator &face,
-template<>
+template <>
void
TorusBoundary<2,3>::
get_intermediate_points_on_line (const Triangulation<2, 3>::line_iterator &line,
-template<>
+template <>
void
TorusBoundary<2,3>::
get_intermediate_points_on_quad (const Triangulation< 2, 3 >::quad_iterator &quad,
-template<>
+template <>
void
TorusBoundary<2,3>::
get_normals_at_vertices (const Triangulation<2,3 >::face_iterator &face,
{
namespace Triangulation
{
- template<class G>
+ template <class G>
void
TriaObjects<G>::reserve_space (const unsigned int new_objects_in_pairs,
const unsigned int new_objects_single)
}
- template<>
+ template <>
void
TriaObjects<TriaObject<1> >::monitor_memory (const unsigned int) const
{
}
- template<>
+ template <>
void
TriaObjects<TriaObject<2> >::monitor_memory (const unsigned int) const
{
}
- template<typename G>
+ template <typename G>
std::size_t
TriaObjects<G>::memory_consumption () const
{
* same in all space
* dimensions.
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
static
void
reserve_space_vertices (DoFHandler<dim,spacedim> &dof_handler)
namespace hp
{
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
const unsigned int DoFHandler<dim,spacedim>::dimension;
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
const types::global_dof_index DoFHandler<dim,spacedim>::invalid_dof_index;
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
const unsigned int DoFHandler<dim,spacedim>::default_fe_index;
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
DoFHandler<dim,spacedim>::DoFHandler (const Triangulation<dim,spacedim> &tria)
:
tria(&tria, typeid(*this).name()),
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
DoFHandler<dim,spacedim>::~DoFHandler ()
{
// unsubscribe as a listener to refinement
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
types::global_dof_index DoFHandler<dim,spacedim>::n_boundary_dofs () const
{
Assert (finite_elements != nullptr, ExcNoFESelected());
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
types::global_dof_index
DoFHandler<dim,spacedim>::n_boundary_dofs (const std::set<types::boundary_id> &boundary_ids) const
{
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
std::size_t
DoFHandler<dim,spacedim>::memory_consumption () const
{
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
DoFHandler<dim,spacedim>::
compute_vertex_dof_identities (std::vector<types::global_dof_index> &new_dof_indices) const
{}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
DoFHandler<dim,spacedim>::
compute_line_dof_identities (std::vector<types::global_dof_index> &new_dof_indices) const
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void DoFHandler<dim,spacedim>::distribute_dofs (const hp::FECollection<dim,spacedim> &ff)
{
Assert (tria->n_levels() > 0, ExcInvalidTriangulation());
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void DoFHandler<dim,spacedim>::clear ()
{
// release lock to old fe
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void DoFHandler<dim,spacedim>::renumber_dofs (const std::vector<types::global_dof_index> &new_numbers)
{
Assert (new_numbers.size() == n_dofs(), ExcRenumberingIncomplete());
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
DoFHandler<dim,spacedim>::
renumber_dofs_internal (const std::vector<types::global_dof_index> &new_numbers,
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
DoFHandler<dim,spacedim>::
renumber_dofs_internal (const std::vector<types::global_dof_index> &new_numbers,
//TODO: Merge the following three functions -- they are identical
- template<>
+ template <>
void
DoFHandler<2,2>::
renumber_dofs_internal (const std::vector<types::global_dof_index> &new_numbers,
- template<>
+ template <>
void
DoFHandler<2,3>::
renumber_dofs_internal (const std::vector<types::global_dof_index> &new_numbers,
}
- template<>
+ template <>
void
DoFHandler<3,3>::
renumber_dofs_internal (const std::vector<types::global_dof_index> &new_numbers,
}
- template<>
+ template <>
void
DoFHandler<3,3>::
renumber_dofs_internal (const std::vector<types::global_dof_index> &new_numbers,
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void DoFHandler<dim,spacedim>::create_active_fe_table ()
{
// Create sufficiently many
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
DoFHandler<dim,spacedim>::post_refinement_action ()
{
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void DoFHandler<dim,spacedim>::clear_space ()
{
levels.clear ();
namespace hp
{
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
MappingCollection<dim,spacedim>::MappingCollection ()
{}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
MappingCollection<dim,spacedim>::
MappingCollection (const Mapping<dim,spacedim> &mapping)
{
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
MappingCollection<dim,spacedim>::
MappingCollection (const MappingCollection<dim,spacedim> &mapping_collection)
:
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
std::size_t
MappingCollection<dim,spacedim>::memory_consumption () const
{
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
void
MappingCollection<dim,spacedim>::push_back (const Mapping<dim,spacedim> &new_mapping)
{
* reference to a static object that will be constructed the first time
* this function is called.
*/
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
MappingQGeneric<dim,spacedim> &
get_static_mapping_q1()
{
}
}
- template<int dim, int spacedim>
+ template <int dim, int spacedim>
MappingCollection<dim,spacedim>
StaticMappingQ1<dim,spacedim>::mapping_collection
= MappingCollection<dim,spacedim>(get_static_mapping_q1<dim,spacedim>());
{
#define SCRATCH_INITIALIZER(Number,Name) \
ConstraintMatrixData<Number>::ScratchData scratch_data_initializer_##Name; \
- template<> Threads::ThreadLocalStorage<ConstraintMatrixData<Number>::ScratchData> \
+ template <> Threads::ThreadLocalStorage<ConstraintMatrixData<Number>::ScratchData> \
ConstraintMatrixData<Number>::scratch_data(scratch_data_initializer_##Name)
SCRATCH_INITIALIZER(double,double);
using namespace LAPACKSupport;
-template<typename number>
+template <typename number>
TridiagonalMatrix<number>::TridiagonalMatrix(
size_type size,
bool symmetric)
{}
-template<typename number>
+template <typename number>
void
TridiagonalMatrix<number>::reinit(
size_type size,
}
-template<typename number>
+template <typename number>
bool
TridiagonalMatrix<number>::all_zero() const
{
}
-template<typename number>
+template <typename number>
void
TridiagonalMatrix<number>::vmult (
Vector<number> &w,
}
-template<typename number>
+template <typename number>
void
TridiagonalMatrix<number>::vmult_add (
Vector<number> &w,
}
-template<typename number>
+template <typename number>
void
TridiagonalMatrix<number>::Tvmult (
Vector<number> &w,
}
-template<typename number>
+template <typename number>
void
TridiagonalMatrix<number>::Tvmult_add (
Vector<number> &w,
}
-template<typename number>
+template <typename number>
number
TridiagonalMatrix<number>::matrix_scalar_product(
const Vector<number> &w,
}
-template<typename number>
+template <typename number>
number
TridiagonalMatrix<number>::matrix_norm_square(
const Vector<number> &v) const
}
-template<>
+template <>
void
TridiagonalMatrix<double>::compute_eigenvalues()
{
}
-template<typename number>
+template <typename number>
number
TridiagonalMatrix<number>::eigenvalue(const size_type i) const
{
/*
-template<typename number>
+template <typename number>
TridiagonalMatrix<number>::
{
}
}
- template<typename Preconditioner>
+ template <typename Preconditioner>
void
SolverBase::do_solve(const Preconditioner &preconditioner)
{
- template<>
+ template <>
void
SolverBase::set_preconditioner(AztecOO &solver,
const PreconditionBase &preconditioner)
}
- template<>
+ template <>
void
SolverBase::set_preconditioner(AztecOO &solver,
const Epetra_Operator &preconditioner)
- template<typename SparsityPatternType>
+ template <typename SparsityPatternType>
void
SparsityPattern::reinit (const IndexSet &row_parallel_partitioning,
const IndexSet &col_parallel_partitioning,
- template<typename SparsityPatternType>
+ template <typename SparsityPatternType>
void
SparsityPattern::reinit (const IndexSet ¶llel_partitioning,
const SparsityPatternType &nontrilinos_sparsity_pattern,
DEAL_II_NAMESPACE_OPEN
-template<int dim, typename Number>
+template <int dim, typename Number>
MGTransferMatrixFree<dim,Number>::MGTransferMatrixFree ()
:
fe_degree(0),
-template<int dim, typename Number>
+template <int dim, typename Number>
MGTransferMatrixFree<dim,Number>::MGTransferMatrixFree (const MGConstrainedDoFs &mg_c)
:
fe_degree(0),
DEAL_II_NAMESPACE_OPEN
-template<typename VectorType>
+template <typename VectorType>
MGTransferPrebuilt<VectorType>::MGTransferPrebuilt ()
{}
-template<typename VectorType>
+template <typename VectorType>
MGTransferPrebuilt<VectorType>::MGTransferPrebuilt (const MGConstrainedDoFs &mg_c)
{
this->mg_constrained_dofs = &mg_c;
-template<typename VectorType>
+template <typename VectorType>
MGTransferPrebuilt<VectorType>::MGTransferPrebuilt (const ConstraintMatrix &/*c*/, const MGConstrainedDoFs &mg_c)
{
this->mg_constrained_dofs = &mg_c;
//----------------------------------------------------------------------//
-template<typename number>
+template <typename number>
MGTransferSelect<number>::MGTransferSelect ()
:
selected_component (0),
{}
-template<typename number>
+template <typename number>
MGTransferSelect<number>::MGTransferSelect (const ConstraintMatrix &c)
:
selected_component (0),
DEAL_II_NAMESPACE_OPEN
-template<int dim, typename VectorType, typename DoFHandlerType>
+template <int dim, typename VectorType, typename DoFHandlerType>
SolutionTransfer<dim, VectorType, DoFHandlerType>::
SolutionTransfer(const DoFHandlerType &dof)
:
-template<int dim, typename VectorType, typename DoFHandlerType>
+template <int dim, typename VectorType, typename DoFHandlerType>
SolutionTransfer<dim, VectorType, DoFHandlerType>::~SolutionTransfer()
{
clear ();
-template<int dim, typename VectorType, typename DoFHandlerType>
+template <int dim, typename VectorType, typename DoFHandlerType>
void SolutionTransfer<dim, VectorType, DoFHandlerType>::clear ()
{
indices_on_cell.clear();
-template<int dim, typename VectorType, typename DoFHandlerType>
+template <int dim, typename VectorType, typename DoFHandlerType>
void SolutionTransfer<dim, VectorType, DoFHandlerType>::prepare_for_pure_refinement()
{
Assert(prepared_for!=pure_refinement, ExcAlreadyPrepForRef());
-template<int dim, typename VectorType, typename DoFHandlerType>
+template <int dim, typename VectorType, typename DoFHandlerType>
void
SolutionTransfer<dim, VectorType, DoFHandlerType>::refine_interpolate
(const VectorType &in,
-template<int dim, typename VectorType, typename DoFHandlerType>
+template <int dim, typename VectorType, typename DoFHandlerType>
void
SolutionTransfer<dim, VectorType, DoFHandlerType>::
prepare_for_coarsening_and_refinement(const std::vector<VectorType> &all_in)
-template<int dim, typename VectorType, typename DoFHandlerType>
+template <int dim, typename VectorType, typename DoFHandlerType>
void
SolutionTransfer<dim, VectorType, DoFHandlerType>::prepare_for_coarsening_and_refinement
(const VectorType &in)
-template<int dim, typename VectorType, typename DoFHandlerType>
+template <int dim, typename VectorType, typename DoFHandlerType>
void SolutionTransfer<dim, VectorType, DoFHandlerType>::
interpolate (const std::vector<VectorType> &all_in,
std::vector<VectorType> &all_out) const
-template<int dim, typename VectorType, typename DoFHandlerType>
+template <int dim, typename VectorType, typename DoFHandlerType>
void SolutionTransfer<dim, VectorType, DoFHandlerType>::interpolate
(const VectorType &in,
VectorType &out) const
-template<int dim, typename VectorType, typename DoFHandlerType>
+template <int dim, typename VectorType, typename DoFHandlerType>
std::size_t
SolutionTransfer<dim, VectorType, DoFHandlerType>::memory_consumption () const
{
-template<int dim, typename VectorType, typename DoFHandlerType>
+template <int dim, typename VectorType, typename DoFHandlerType>
std::size_t
SolutionTransfer<dim, VectorType, DoFHandlerType>::Pointerstruct::memory_consumption () const
{
tolerance(tolerance)
{}
- template<>
+ template <>
Point<2>
NURBSPatchManifold<2, 3>::
pull_back(const Point<3> &space_point) const
return Point<2>(u,v);
}
- template<>
+ template <>
Point<3>
NURBSPatchManifold<2, 3>::
push_forward(const Point<2> &chart_point) const
return ::dealii::OpenCASCADE::push_forward(face, chart_point[0], chart_point[1]);
}
- template<>
+ template <>
DerivativeForm<1,2,3>
NURBSPatchManifold<2, 3>::
push_forward_gradient(const Point<2> &chart_point) const
return DX;
}
- template<>
+ template <>
std::tuple<double, double, double, double>
NURBSPatchManifold<2, 3>::
get_uv_bounds() const
-template<int dim>
+template <int dim>
void test_embedding (const FiniteElement<dim> &fe)
{
const std::string refine_case_names[8]=
}
-template<int dim>
+template <int dim>
void test_projection (const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2,
std::ostream &out)
}
-template<int dim>
+template <int dim>
void test_projection (std::ostream &out)
{
FE_DGQ<dim> q0(0);
#include <vector>
-template<int dim>
+template <int dim>
class MyFunction : public Function<dim>
{
public:
using namespace Polynomials;
-template<int dim, class PolynomialType1, class PolynomialType2>
+template <int dim, class PolynomialType1, class PolynomialType2>
void check_poly(const Point<dim> &x,
const PolynomialType1 &p,
const PolynomialType2 &q)
using namespace dealii;
-template<int dim>
+template <int dim>
class MyFunction : public Function<dim>
{
public:
/**
* Loop over quadrature points and check that value is the same as given by the function.
*/
-template<int dim,typename DATA>
+template <int dim,typename DATA>
void check_qph(Triangulation<dim> &tr,
const CellDataStorage<typename Triangulation<dim,dim>::cell_iterator,DATA> &manager,
const Quadrature<dim> &rhs_quadrature,
dof_handler.clear();
}
-template<int dim>
+template <int dim>
void test()
{
const MyFunction<dim> my_func;
using namespace dealii;
-template<int dim>
+template <int dim>
class MyFunction : public Function<dim>
{
public:
<< arg1 <<" != "<< arg2 << " with delta = " << arg3 );
-template<int dim>
+template <int dim>
void test()
{
const MyFunction<dim> my_func;
// WRITE(eps);
}
-template<int dim>
+template <int dim>
struct PatchInfo
{
static double vertices[GeometryInfo<dim>::vertices_per_cell][3];
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test(std::ostream &out)
{
std::vector<DataOutBase::Patch<dim, spacedim> > patches;
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
#if SEPARATE_FILES == 0
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
#if SEPARATE_FILES == 0
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
#if SEPARATE_FILES == 0
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
#if SEPARATE_FILES == 0
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
#if SEPARATE_FILES == 0
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
#if SEPARATE_FILES == 0
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
#if SEPARATE_FILES == 0
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
#if SEPARATE_FILES == 0
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all()
{
char name[100];
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
#if SEPARATE_FILES == 0
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
#if SEPARATE_FILES == 0
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
#if SEPARATE_FILES == 0
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
#if SEPARATE_FILES == 0
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
#if SEPARATE_FILES == 0
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
for (unsigned int i = 0; i < 4; ++i)
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
#if SEPARATE_FILES == 0
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
#if SEPARATE_FILES == 0
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check_all(std::ostream &log)
{
#if SEPARATE_FILES == 0
typedef typename Sacado::Fad::DFad<double> Sdouble;
typedef typename Sacado::Fad::DFad<Sdouble> SSdouble;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
Tensor<1,dim,SSdouble> x;
#include <deal.II/base/derivative_form.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
DerivativeForm<1,dim,spacedim> dF;
#include <deal.II/base/derivative_form.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
DerivativeForm<1,dim,spacedim,std::complex<double> > dF;
#include <deal.II/base/derivative_form.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
DerivativeForm<1,dim,spacedim,std::complex<double> > dF;
#include <string>
-template<int dim>
+template <int dim>
void
check_derivative_order(const std::vector<Tensor<1,dim> > &gradients,
FunctionDerivative<dim> &df,
}
-template<int dim>
+template <int dim>
void
check_hessian_order(const std::vector<double> &values,
FunctionDerivative<dim> &df,
}
-template<int dim>
+template <int dim>
void
check_sine(unsigned int nquad)
{
// quadrature points in each direction, and the threshold above which
// we consider values unequal
-template<int dim>
+template <int dim>
void
check_function_value_consistency(
const Function<dim> &f,
}
// Same for gradients
-template<int dim>
+template <int dim>
void
check_function_gradient_consistency(
const Function<dim> &f,
}
-template<int dim>
+template <int dim>
void DerivativeTestFunction<dim>::vector_value (
const Point<dim> &point,
Vector<double> &value) const
}
-template<int dim>
+template <int dim>
double DerivativeTestFunction<dim>::value (
const Point<dim> &point,
const unsigned int comp) const
// Check whether the difference quotients converge to the gradient
-template<int dim>
+template <int dim>
void
check_gradient(
const Function<dim> &f,
#include "functions.h"
-template<int dim>
+template <int dim>
void
check_function(const Functions::FlowFunction<dim> &f,
unsigned int sub,
// Fill a tensor with values:
-template<int rank, int dim>
+template <int rank, int dim>
struct FillTensor
{
static void fill_tensor(Tensor<rank, dim> &tensor, int base)
}
};
-template<int dim>
+template <int dim>
struct FillTensor<1, dim>
{
static void fill_tensor(Tensor<1, dim> &tensor, int base)
// Print a tensor of arbitrary rank to the console:
-template<int rank, int dim>
+template <int rank, int dim>
struct PrintTensor
{
static void print_tensor(const Tensor<rank, dim> &tensor)
}
};
-template<int dim>
+template <int dim>
struct PrintTensor<1, dim>
{
static void print_tensor(const Tensor<1, dim> &tensor)
}
// test different number of vector components
-template<int dim, typename Number>
+template <int dim, typename Number>
void test_n_components(const std::vector<NUMBER> &component_data)
{
#define N_COMPONENT_CASE 3
#include <fstream>
#include <string>
-template<int dim>
+template <int dim>
void
check_function_consistency(
const Function<dim> &f,
}
-template<int dim>
+template <int dim>
void
check_function_derivative(const Functions::FlowFunction<dim> &f,
unsigned int sub,
// reference function f(x) = exp (-Z*r)
-template<int dim>
+template <int dim>
class ExpFunc : public Function<dim>
{
public:
// same as above but using Functions::Spherical
-template<int dim>
+template <int dim>
class ExpFunc2 : public Functions::Spherical<dim>
{
public:
-template<int dim>
+template <int dim>
class RefFunc : public Function<dim>
{
public:
// same as above but using Functions::Spherical
-template<int dim>
+template <int dim>
class SphFunc : public Functions::Spherical<dim>
{
public:
//
-template<int dim>
+template <int dim>
void test_vertices()
{
deallog << dim << "D:" << std::endl;
}
-template<int dim>
+template <int dim>
void test_lines()
{
deallog << dim << "D:" << std::endl;
using namespace dealii;
-template<typename T>
+template <typename T>
struct EqualityWithSizeofTest
{
EqualityWithSizeofTest()
};
-template<typename T>
+template <typename T>
struct EqualityWithSizeofTest<T *>
{
EqualityWithSizeofTest()
using namespace Polynomials;
-template<int dim, class PolynomialType>
+template <int dim, class PolynomialType>
void check_poly(const Point<dim> &x,
const PolynomialType &p)
{
using namespace std;
-template<int dim, class PolynomialType>
+template <int dim, class PolynomialType>
void check_point (const Point<dim> &x,
const PolynomialType &p)
{
}
-template<int dim>
+template <int dim>
void check_bdm ()
{
Point<dim> x;
check_point(x, p4);
}
-template<int dim>
+template <int dim>
void check_rt ()
{
Point<dim> x;
#include <deal.II/base/geometry_info.h>
#include <cmath>
-template<int dim>
+template <int dim>
void check_line(Quadrature<1> &quadrature)
{
Point<dim> p1;
deallog << "length: " << s << std::endl;
}
-template<int dim>
+template <int dim>
void check_face(Quadrature<1> &q1)
{
deallog << "Checking dim " << dim
}
}
-template<int dim>
+template <int dim>
void check_faces (Quadrature<1> &q1)
{
const unsigned int nq = q1.size();
using namespace dealii;
-template<typename quadrature_type, unsigned short startn>
+template <typename quadrature_type, unsigned short startn>
void check_quadrature (double *);
void check_GRC_right(double *);
}
-template<typename quadrature_type,unsigned short startn>
+template <typename quadrature_type,unsigned short startn>
void check_quadrature(double *exact_monomials)
{
using namespace dealii;
-template<int dim>
+template <int dim>
class MyFunction : public Function<dim>
{
public:
/**
* Loop over quadrature points and check that value is the same as given by the function.
*/
-template<int dim,typename DATA>
+template <int dim,typename DATA>
void check_qph(parallel::distributed::Triangulation<dim> &tr,
const CellDataStorage<typename Triangulation<dim,dim>::cell_iterator,DATA> &manager,
const Quadrature<dim> &rhs_quadrature,
dof_handler.clear();
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
using namespace dealii;
-template<int dim>
+template <int dim>
class MyFunction : public Function<dim>
{
public:
/**
* Loop over quadrature points and check that value is the same as given by the function.
*/
-template<int dim,typename DATA>
+template <int dim,typename DATA>
void check_qph(parallel::distributed::Triangulation<dim> &tr,
const CellDataStorage<typename Triangulation<dim,dim>::cell_iterator,DATA> &manager,
const Quadrature<dim> &rhs_quadrature,
dof_handler.clear();
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
using namespace dealii;
-template<int dim>
+template <int dim>
class MyFunction : public Function<dim>
{
public:
/**
* Loop over quadrature points and check that value is the same as given by the function.
*/
-template<int dim>
+template <int dim>
void check_qph(parallel::distributed::Triangulation<dim> &tr,
const CellDataStorage<typename Triangulation<dim,dim>::cell_iterator,MyDataBase> &manager,
const Quadrature<dim> &rhs_quadrature,
dof_handler.clear();
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
// for example, complex numbers cannot be converted to primitive numbers
// So in these cases we disable the test if NumberType1 cannot be constructed
// from NumberType2
-template<int rank, int dim,
- template<int,int,typename> class TensorType,
- typename NumberType1,
- typename NumberType2>
+template <int rank, int dim,
+ template <int,int,typename> class TensorType,
+ typename NumberType1,
+ typename NumberType2>
typename std::enable_if<!std::is_constructible<NumberType1,NumberType2>::value,void>::type
test_tensor_constructor (const std::string &, const std::string &)
{}
-template<int rank, int dim,
- template<int,int,typename> class TensorType,
- typename NumberType1,
- typename NumberType2>
+template <int rank, int dim,
+ template <int,int,typename> class TensorType,
+ typename NumberType1,
+ typename NumberType2>
typename std::enable_if<std::is_constructible<NumberType1,NumberType2>::value,void>::type
test_tensor_constructor (const std::string &type1, const std::string &type2)
{
deallog << "OK" << std::endl;
}
-template<int rank, int dim,
- template<int,int,typename> class TensorType,
- typename NumberType1>
+template <int rank, int dim,
+ template <int,int,typename> class TensorType,
+ typename NumberType1>
void
test_fixed_NT_2(const std::string &type1)
{
test_tensor_constructor<rank,dim,TensorType,NumberType1,std::complex<double> >(type1, "std::complex<double>");
}
-template<int rank, int dim,
- template<int,int,typename> class TensorType>
+template <int rank, int dim,
+ template <int,int,typename> class TensorType>
void
test_fixed_NT_1()
{
test_fixed_NT_2<rank,dim,TensorType,std::complex<double> >("std::complex<double>");
}
-template<int rank, int dim>
+template <int rank, int dim>
void
test_fixed_TensorType()
{
test_fixed_NT_1<rank,dim,SymmetricTensor>();
}
-template<int dim>
+template <int dim>
void
test_fixed_rank()
{
// Although not strictly required, in this test it is expected that T1 or T3
// (or both) are a symmetric tensor
-template<int rank1, int rank2, int rank3, int dim, typename number,
- template<int,int,typename> class T1,
- template<int,int,typename> class T3>
+template <int rank1, int rank2, int rank3, int dim, typename number,
+ template <int,int,typename> class T1,
+ template <int,int,typename> class T3>
void test_symm_tensor_contract_3(const T1<rank1,dim,number> &l,
const Tensor<rank2,dim,number> &m,
const T3<rank3,dim,number> &r)
#include <deal.II/base/logstream.h>
#include <deal.II/base/table.h>
-template<int dim>
+template <int dim>
void test()
{
dealii::TableIndices<dim> new_size;
#include <vector>
-template<int dim>
+template <int dim>
double
value(const Point<dim> &p)
{
namespace
{
- template<int dim>
+ template <int dim>
struct Scratch
{
Scratch(const FiniteElement<dim> &fe, const Quadrature<dim> &quadrature) :
}
-template<int dim>
+template <int dim>
void
mass_assembler(const typename Triangulation<dim>::active_cell_iterator &cell,
Scratch<dim> &data, CopyData ©_data)
#include <vector>
-template<int dim>
+template <int dim>
double
value(const Point<dim> &p)
{
namespace
{
- template<int dim>
+ template <int dim>
struct Scratch
{
Scratch(const FiniteElement<dim> &fe, const Quadrature<dim> &quadrature) :
}
-template<int dim>
+template <int dim>
void
mass_assembler(const typename Triangulation<dim>::active_cell_iterator &cell,
Scratch<dim> &data, CopyData ©_data)
#include <deal.II/lac/precondition.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/precondition.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
};
-template<int dim>
+template <int dim>
void test()
{
const HyperBallBoundary<dim> boundary_description;
};
-template<int dim>
+template <int dim>
void test()
{
const HyperBallBoundary<dim> boundary_description;
};
-template<int dim>
+template <int dim>
void test()
{
const HyperBallBoundary<dim> boundary_description;
-template<int dim>
+template <int dim>
void test()
{
const HyperBallBoundary<dim> boundary_description;
-template<int dim>
+template <int dim>
void test()
{
const HyperBallBoundary<dim> boundary_description;
-template<int dim>
+template <int dim>
void test()
{
const HyperBallBoundary<dim> boundary_description;
-template<int dim>
+template <int dim>
void test()
{
const HyperBallBoundary<dim> boundary_description;
-template<int dim>
+template <int dim>
void test()
{
// 0 components is not okay
#include <iomanip>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
};
-template<int dim>
+template <int dim>
class MyExpFunction : public Function<dim>
{
public:
#include <iomanip>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
};
-template<int dim>
+template <int dim>
class MyExpFunction : public Function<dim>
{
public:
#include <iomanip>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
};
-template<int dim>
+template <int dim>
class MyExpFunction : public Function<dim>
{
public:
#include <iomanip>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
};
-template<int dim>
+template <int dim>
class MyExpFunction : public Function<dim>
{
public:
#include <iomanip>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
};
-template<int dim>
+template <int dim>
class MyExpFunction : public Function<dim>
{
public:
#include <iomanip>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
};
-template<int dim>
+template <int dim>
class MyExpFunction : public Function<dim>
{
public:
#include <iomanip>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
};
-template<int dim>
+template <int dim>
class MyExpFunction : public Function<dim>
{
public:
#include <iomanip>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
};
-template<int dim>
+template <int dim>
class MyExpFunction : public Function<dim>
{
public:
#include <iomanip>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
};
-template<int dim>
+template <int dim>
class MyExpFunction : public Function<dim>
{
public:
#include <iomanip>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
};
-template<int dim>
+template <int dim>
class MyExpFunction : public Function<dim>
{
public:
#include <vector>
-template<int dim>
+template <int dim>
class MyFunction : public Function<dim>
{
public:
std::ofstream logfile("output");
-template<int spacedim>
+template <int spacedim>
class BEM
{
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
return q;
}
-template<>
+template <>
Quadrature<0> &
get_q_face <1>()
{
// function is x^2+2xy
-template<int dim>
+template <int dim>
class MyFunction : public Function<dim>
{
public:
// normal derivative of function above is 0 except for x=1, y=1 with n=(0,1,0)
-template<int dim>
+template <int dim>
class MyNormalDerivative : public Function<dim>
{
public:
return q;
}
-template<>
+template <>
Quadrature<0> &
get_q_face <1>()
{
#include <deal.II/fe/mapping_q_eulerian.h>
#include <deal.II/fe/mapping_fe_field.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test(const unsigned int refs,
const unsigned int degree,
const unsigned int subdivisions)
#include <fstream>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
if (true)
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <deal.II/grid/grid_in.h>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
if (true)
#include <fstream>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
deallog << "hyper_cube" << std::endl;
#include <fstream>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
for (unsigned int i=0; i<GeometryInfo<dim>::max_children_per_cell; ++i)
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
{
#include <fstream>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
// mesh, uncomment the following macro definition.
// #define __WRITE_VTU__
-template<int dim> class Location;
+template <int dim> class Location;
-template<int dim>
+template <int dim>
class TriaTest
{
private:
};
// Equip class Point<dim> with operator < in order to sort the cell center coordinates.
-template<int dim>
+template <int dim>
class Location: public Point<dim>
{
public:
return (0);
}
-template<int dim>
+template <int dim>
TriaTest<dim>::TriaTest(const typename dealii::Triangulation<dim>::MeshSmoothing smoothing_option)
:
mpi_communicator(MPI_COMM_WORLD),
// triangulation.refine_global(1);
}
-template<int dim>
+template <int dim>
void TriaTest<dim>::run(std::vector<unsigned int> &n_cell,
std::set<Location<dim> > &position_list)
{
return;
}
-template<int dim>
+template <int dim>
void TriaTest<dim>::write_vtu(const unsigned int counter) const
{
#ifdef __WRITE_VTU__
#include <fstream>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
if (true)
-template<int dim>
+template <int dim>
void test(const char *filename)
{
const char *p = strrchr(filename,'/');
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <deal.II/grid/grid_in.h>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <deal.II/grid/grid_in.h>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
if (true)
#include <fstream>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
for (unsigned int i=0; i<GeometryInfo<dim>::max_children_per_cell; ++i)
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
{
#include <fstream>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
{
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
// mesh, uncomment the following macro definition.
// #define __WRITE_VTU__
-template<int dim> class Location;
+template <int dim> class Location;
-template<int dim>
+template <int dim>
class TriaTest
{
private:
};
// Equip class Point<dim> with operator < in order to sort the cell center coordinates.
-template<int dim>
+template <int dim>
class Location: public Point<dim>
{
public:
return (0);
}
-template<int dim>
+template <int dim>
TriaTest<dim>::TriaTest(const typename dealii::Triangulation<dim>::MeshSmoothing smoothing_option)
:
mpi_communicator(MPI_COMM_WORLD),
// triangulation.refine_global(1);
}
-template<int dim>
+template <int dim>
void TriaTest<dim>::run(std::vector<unsigned int> &n_cell,
std::set<Location<dim> > &position_list)
{
return;
}
-template<int dim>
+template <int dim>
void TriaTest<dim>::write_vtu(const unsigned int counter) const
{
#ifdef __WRITE_VTU__
#include <fstream>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim,spacedim> tr(MPI_COMM_WORLD);
#include <deal.II/distributed/tria.h>
#include <deal.II/grid/grid_generator.h>
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> tr1;
#include <cstdlib>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim>
#include <cstdlib>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim>
#include <cstdlib>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim>
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
#include <cstdlib>
-template<int dim>
+template <int dim>
class MyFunction : public Function<dim>
{
public:
};
};
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
MyFunction<dim> func;
#include <deal.II/grid/grid_out.h>
-template<int dim>
+template <int dim>
class MyFunction : public Function<dim>
{
public:
};
};
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
MyFunction<dim> func;
#include <cstdlib>
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void testit(parallel::distributed::Triangulation<dim> &tr)
{
GridGenerator::hyper_cube(tr);
}
-template<int dim>
+template <int dim>
void test(std::ostream & /*out*/)
{
{
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> tr (MPI_COMM_WORLD);
}
-template<int dim>
+template <int dim>
void init_tria (Triangulation<dim> &tr)
{
GridGenerator::hyper_cube(tr);
}
-template<int dim>
+template <int dim>
void init_dofs (DoFHandler<dim> &dof,
const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
}
-template<int dim>
+template <int dim>
void test_fe (const FiniteElement<dim> &fe)
{
Triangulation<dim> tr(Triangulation<dim>::limit_level_difference_at_vertices);
}
-template<int dim>
+template <int dim>
void test_fe (const FiniteElement<dim> &fe)
{
Triangulation<dim> tr(Triangulation<dim>::limit_level_difference_at_vertices);
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation (Triangulation<dim>::limit_level_difference_at_vertices);
#include <cstdlib>
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation (Triangulation<dim>::limit_level_difference_at_vertices);
#include <cstdlib>
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation (Triangulation<dim>::limit_level_difference_at_vertices);
* Print out all face DoFs and support points as well as the actual
* matching via make_periodicity_constraints
*/
-template<int dim>
+template <int dim>
void print_matching(DoFHandler<dim> &dof_handler, bool constrain_only_velocity = false)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
* Print out all face DoFs and support points as well as the actual
* matching via make_periodicity_constraints
*/
-template<int dim>
+template <int dim>
void print_matching(DoFHandler<dim> &dof_handler)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
* Print out all face DoFs and support points as well as the actual
* matching via make_periodicity_constraints
*/
-template<int dim>
+template <int dim>
void print_matching(DoFHandler<dim> &dof_handler)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
* Print out all face DoFs and support points as well as the actual
* matching via make_periodicity_constraints
*/
-template<int dim>
+template <int dim>
void print_matching(DoFHandler<dim> &dof_handler)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
* Print out all face DoFs and support points as well as the actual
* matching via make_periodicity_constraints
*/
-template<int dim>
+template <int dim>
void print_matching(DoFHandler<dim> &dof_handler, bool constrain_only_velocity = false)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
#include <cstdio>
-template<int dim>
+template <int dim>
bool
pred_d(const typename DoFHandler<dim>::active_cell_iterator &cell)
{
#include <cstdio>
-template<int dim>
+template <int dim>
bool
pred_d(const typename DoFHandler<dim>::active_cell_iterator &cell)
{
#include <cstdio>
-template<int dim>
+template <int dim>
bool
pred_left(const typename DoFHandler<dim>::active_cell_iterator &cell)
{
return (cell->center()(0) < 0.49);
}
-template<int dim>
+template <int dim>
bool
pred_right(const typename DoFHandler<dim>::active_cell_iterator &cell)
{
}
-template<int dim>
+template <int dim>
bool
pred_r(const typename Triangulation<dim>::active_cell_iterator &cell)
{
".vtu";
}
-template<int dim>
+template <int dim>
bool
pred_d(const typename DoFHandler<dim>::active_cell_iterator &cell)
{
return (cell->center()(0) < 0.49);
}
-template<int dim>
+template <int dim>
bool
pred_r(const typename Triangulation<dim>::active_cell_iterator &cell)
{
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation (Triangulation<dim>::limit_level_difference_at_vertices);
-template<int dim>
+template <int dim>
void test()
{
parallel::shared::Triangulation<dim>
#include <string>
-template<int dim>
+template <int dim>
void check()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void
test(const unsigned int degree)
{
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
-template<unsigned int dim>
+template <unsigned int dim>
void test (const unsigned int degree)
{
FE_ABF<dim> fe(degree);
-template<int dim>
+template <int dim>
inline void
plot_shape_functions(const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
-template<int dim>
+template <int dim>
void
plot_shape_functions(const unsigned int degree)
{
-template<int dim>
+template <int dim>
void
test(const unsigned int degree)
{
-template<int dim>
+template <int dim>
void
test(const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_Q<dim> fe(1);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_Q<dim> fe(2);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_Q<dim> fe(1);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_Q<dim> fe(2);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_Q<dim> fe(1);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_Q<dim> fe(2);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_Q<dim> fe(1);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_Q<dim> fe(2);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_Q<dim> fe(1);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_Q<dim> fe(2);
#include <fstream>
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_Q<dim> fe(2);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPMonomial<dim> fe(1);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPMonomial<dim> fe(2);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPMonomial<dim> fe(1);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPMonomial<dim> fe(2);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPMonomial<dim> fe(1);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPMonomial<dim> fe(2);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPMonomial<dim> fe(1);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPMonomial<dim> fe(2);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPMonomial<dim> fe(1);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPMonomial<dim> fe(2);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPNonparametric<dim> fe(1);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPNonparametric<dim> fe(2);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPNonparametric<dim> fe(1);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPNonparametric<dim> fe(2);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPNonparametric<dim> fe(1);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPNonparametric<dim> fe(2);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPNonparametric<dim> fe(1);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPNonparametric<dim> fe(2);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPNonparametric<dim> fe(1);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr)
{
FE_DGPNonparametric<dim> fe(2);
-template<int dim>
+template <int dim>
void
test(const unsigned int degree)
{
ConvergenceTable convergence_table;
};
// EXACT SOLUTION CLASS
-template<int dim>
+template <int dim>
class ExactSolution : public Function<dim>
{
public:
template <int dim> const double RightHandSide<dim>::bc_constant = 0.1;
// DEFINE EXACT SOLUTION MEMBERS
-template<int dim>
+template <int dim>
double ExactSolution<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
return val;
}
-template<int dim>
+template <int dim>
void ExactSolution<dim>::vector_value(const Point<dim> &p,
Vector<double> &result) const
{
dof_handler.clear ();
}
-template<int dim>
+template <int dim>
double MaxwellProblem<dim>::dotprod(const Tensor<1,dim> &A, const Tensor<1,dim> &B) const
{
double return_val = 0;
return return_val;
}
-template<int dim>
+template <int dim>
double MaxwellProblem<dim>::dotprod(const Tensor<1,dim> &A, const Vector<double> &B) const
{
double return_val = 0;
constraints.distribute (solution);
}
-template<int dim>
+template <int dim>
void MaxwellProblem<dim>::process_solution(const unsigned int cycle)
{
const ExactSolution<dim> exact_solution;
#include <string>
-template<int dim>
+template <int dim>
inline void
plot_derivatives(Mapping<dim> &mapping,
FiniteElement<dim> &finel,
-template<int dim>
+template <int dim>
void plot_FE_Q_shape_functions()
{
MappingQGeneric<dim> m(1);
}
-template<int dim>
+template <int dim>
void plot_FE_DGQ_shape_functions()
{
MappingQGeneric<dim> m(1);
#include <deal.II/fe/fe_bernstein.h>
//#include "../../include/fe_bernstein.h"
-template<int dim>
+template <int dim>
inline void
plot_derivatives(Mapping<dim> &mapping,
FiniteElement<dim> &finel,
-template<int dim>
+template <int dim>
void plot_FE_Bernstein_shape_functions()
{
MappingQGeneric<dim> m(1);
#include <string>
-template<int dim>
+template <int dim>
inline void
plot_derivatives(Mapping<dim> &mapping,
FiniteElement<dim> &finel,
-template<int dim>
+template <int dim>
void plot_FE_Q_shape_functions()
{
MappingQGeneric<dim> m(1);
}
-template<int dim>
+template <int dim>
void plot_FE_DGQ_shape_functions()
{
MappingQGeneric<dim> m(1);
-template<int dim>
+template <int dim>
void
test(const unsigned int degree)
{
-template<int dim>
+template <int dim>
void
test(const unsigned int degree)
{
-template<int dim>
+template <int dim>
void
test(const unsigned int degree1,
const unsigned int degree2)
-template<int dim>
+template <int dim>
void
test(const unsigned int degree1,
const unsigned int degree2)
#include <string>
-template<int dim>
+template <int dim>
void print_constant_modes(const FiniteElement<dim> &fe)
{
deallog << "Testing " << fe.get_name() << std::endl;
}
-template<int dim>
+template <int dim>
void test()
{
print_constant_modes(FE_Q<dim>(1));
#include <deal.II/base/logstream.h>
#include <deal.II/fe/fe_q.h>
-template<int dim>
+template <int dim>
void test()
{
FE_Q<dim> fe(1);
#include <deal.II/base/logstream.h>
#include <deal.II/fe/fe_q.h>
-template<int dim>
+template <int dim>
void test()
{
FE_Q<dim> fe(2);
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-template<int dim>
+template <int dim>
void test()
{
FESystem<dim> fe(FE_Q<dim>(2), 1,
#include <deal.II/base/logstream.h>
#include <deal.II/fe/fe_q.h>
-template<int dim>
+template <int dim>
void test()
{
FE_Q<dim> fe(3);
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_system.h>
-template<int dim>
+template <int dim>
void test()
{
FESystem<dim> fe(FE_Q<dim>(3), 1,
#include <deal.II/base/logstream.h>
#include <deal.II/fe/fe_q.h>
-template<int dim>
+template <int dim>
void test()
{
FE_Q<dim> fe(4);
-template<int dim>
+template <int dim>
Tensor<1,dim> ones ()
{
Tensor<1,dim> result;
return result;
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe,
const double tolerance)
-template<int dim>
+template <int dim>
void test_hyper_cube(const double tolerance)
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test_fe_datas()
{
std::vector<FiniteElement<dim> *> fe_datas;
#include <sstream>
#include <fstream>
-template<int dim>
+template <int dim>
Tensor<1,dim> ones ()
{
Tensor<1,dim> result;
return result;
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe,
const double tolerance)
-template<int dim>
+template <int dim>
void test_hyper_ball(const double tolerance)
{
Triangulation<dim> tr;
#include <sstream>
#include <fstream>
-template<int dim>
+template <int dim>
Tensor<1,dim> ones ()
{
Tensor<1,dim> result;
return result;
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe,
const double tolerance)
-template<int dim>
+template <int dim>
void test_hyper_ball(const double tolerance)
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
Tensor<1,dim> ones ()
{
Tensor<1,dim> result;
return result;
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe,
const double tolerance)
-template<int dim>
+template <int dim>
void test_hyper_ball(const double tolerance)
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
Tensor<1,dim> ones ()
{
Tensor<1,dim> result;
return result;
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe,
const double tolerance)
-template<int dim>
+template <int dim>
void test_hyper_ball(const double tolerance)
{
Triangulation<dim> tr;
using namespace dealii;
-template<int dim>
+template <int dim>
class EnrichmentFunction : public Function<dim>
{
public:
}
};
-template<int dim>
+template <int dim>
void test_base()
{
deallog << "Test basic functions:"<<std::endl;
// uncomment when debugging
// #define DATA_OUT_FE_ENRICHED
-template<int dim>
+template <int dim>
class EnrichmentFunction : public Function<dim>
{
public:
}
};
-template<int dim>
+template <int dim>
void test1()
{
deallog << "FEValues.shape_value()"<<std::endl;
using namespace dealii;
-template<int dim>
+template <int dim>
class EnrichmentFunction : public Function<dim>
{
public:
// uncomment when debugging
// #define DATA_OUT_FE_ENRICHED
-template<int dim>
+template <int dim>
class EnrichmentFunction : public Function<dim>
{
public:
};
-template<int dim>
+template <int dim>
void test3()
{
deallog << "FEValues.get_function_values()"<<std::endl;
// uncomment when debugging
// #define DATA_OUT_FE_ENRICHED
-template<int dim>
+template <int dim>
class EnrichmentFunction : public Function<dim>
{
public:
// uncomment when debugging
// #define DATA_OUT_FE_ENRICHED
-template<int dim>
+template <int dim>
class EnrichmentFunction : public Function<dim>
{
public:
// uncomment when debugging
// #define DATA_OUT_FE_ENRICHED
-template<int dim>
+template <int dim>
class EnrichmentFunction : public Function<dim>
{
public:
// uncomment when debugging
// #define DATA_OUT_FE_ENRICHED
-template<int dim>
+template <int dim>
class EnrichmentFunction : public Function<dim>
{
public:
};
-template<int dim>
+template <int dim>
void test2cells(const unsigned int p_feq=2,
const unsigned int p_feen=1)
{
using namespace dealii;
-template<int dim>
+template <int dim>
void test2cellsFESystem(const unsigned int p_feq=2,
const unsigned int p_feen=1)
{
using namespace dealii;
-template<int dim>
+template <int dim>
class EnrichmentFunction : public Function<dim>
{
public:
ExcInternalError());
}
-template<int dim>
+template <int dim>
void test(const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2,
const Quadrature<dim> &volume_quad,
using namespace dealii;
-template<int dim>
+template <int dim>
class EnrichmentFunction : public Function<dim>
{
public:
/**
* {fe_en1,1}, {fe_en2,2} => 3 functions
*/
-template<int dim>
+template <int dim>
void test(const FiniteElement<dim> &fe_base,
const FiniteElement<dim> &fe_en1,
const FiniteElement<dim> &fe_en2,
/**
* Coulomb potential
*/
-template<int dim>
+template <int dim>
class PotentialFunction : public Function<dim>
{
public:
const unsigned int component = 0 ) const;
};
-template<int dim>
+template <int dim>
double PotentialFunction<dim>::value(const Point<dim> &p,
const unsigned int ) const
{
return -1.0 / std::sqrt(p.square());
}
-template<int dim>
+template <int dim>
class EnrichmentFunction : public Function<dim>
{
public:
mass_matrix.compress (VectorOperation::add);
}
- template<int dim>
+ template <int dim>
std::pair<unsigned int, double>
EigenvalueProblem<dim>::solve()
{
/**
* Coulomb potential
*/
-template<int dim>
+template <int dim>
class PotentialFunction : public dealii::Function<dim>
{
public:
const unsigned int component = 0 ) const;
};
-template<int dim>
+template <int dim>
double PotentialFunction<dim>::value(const dealii::Point<dim> &p,
const unsigned int ) const
{
return -1.0 / std::sqrt(p.square());
}
-template<int dim>
+template <int dim>
class EnrichmentFunction : public Function<dim>
{
public:
mass_matrix.compress (dealii::VectorOperation::add);
}
- template<int dim>
+ template <int dim>
std::pair<unsigned int, double>
EigenvalueProblem<dim>::solve()
{
-template<int dim>
+template <int dim>
inline void
plot_faces(Mapping<dim> &mapping,
FiniteElement<dim> &fe,
-template<int dim>
+template <int dim>
inline void
plot_subfaces(Mapping<dim> &mapping,
FiniteElement<dim> &fe,
}
-template<int dim>
+template <int dim>
void mapping_test()
{
deallog << "dim=" << dim << std::endl;
-template<int dim>
+template <int dim>
Tensor<1,dim> ones ()
{
Tensor<1,dim> result;
return result;
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe,
const double tolerance)
-template<int dim>
+template <int dim>
void test_hyper_ball(const double tolerance)
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
Tensor<1,dim> ones ()
{
Tensor<1,dim> result;
return result;
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe,
const double tolerance)
-template<int dim>
+template <int dim>
void test_hyper_ball(const double tolerance)
{
Triangulation<dim> tr;
using namespace dealii;
-template<int dim>
+template <int dim>
void test2cells(const unsigned int p1=2,
const unsigned int p2=1)
{
static const unsigned n_vertices = sizeof(vertices_rectangular) / sizeof(vertices_rectangular[0]);\r
static const unsigned n_cells = 4;\r
\r
-template<int dim>\r
+template <int dim>\r
class VectorFunction : public Function<dim>\r
{\r
public:\r
virtual void vector_value(const Point<dim> &p, Vector<double> &values) const;\r
};\r
\r
-template<>\r
+template <>\r
double VectorFunction<2>::value(const Point<2> &p, const unsigned int component) const\r
{\r
Assert (component < 2, ExcIndexRange (component, 0, 1));\r
return val;\r
}\r
\r
-template<int dim>\r
+template <int dim>\r
void VectorFunction<dim>::vector_value(const Point<dim> &p, Vector<double> &values) const\r
{\r
for (int i = 0; i < dim; ++i)\r
static const unsigned n_vertices = sizeof(vertices_rectangular) / sizeof(vertices_rectangular[0]);\r
static const unsigned n_cells = 8;\r
\r
-template<int dim>\r
+template <int dim>\r
class VectorFunction : public Function<dim>\r
{\r
public:\r
virtual Tensor< 1, dim > gradient (const Point< dim > &p, const unsigned int component=0) const;\r
};\r
\r
-template<>\r
+template <>\r
double VectorFunction<3>::value(const Point<3> &p, const unsigned int component) const\r
{\r
Assert (component < 3, ExcIndexRange (component, 0, 2));\r
return val;\r
}\r
\r
-template<int dim>\r
+template <int dim>\r
void VectorFunction<dim>::vector_value(const Point<dim> &p, Vector<double> &values) const\r
{\r
for (int i = 0; i < dim; ++i)\r
values(i) = value(p, i);\r
}\r
\r
-template<>\r
+template <>\r
Tensor<1, 3> VectorFunction<3>::gradient(const Point<3> &p, const unsigned int component) const\r
{\r
const double PI = numbers::PI;\r
#include <sstream>
#include <fstream>
-template<int dim>
+template <int dim>
Tensor<1,dim> ones ()
{
Tensor<1,dim> result;
return result;
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe,
const double tolerance)
-template<int dim>
+template <int dim>
void test_hyper_ball(const double tolerance)
{
Triangulation<dim> tr;
}
//squared l^2 norm of divergence of velocity
- template<int dim>
+ template <int dim>
void StokesProblem<dim>::divergence_velocity
(const BlockVector<double> &calc_solution,
Vector<double> &output_vector,
-template<int dim>
+template <int dim>
Tensor<1,dim> ones ()
{
Tensor<1,dim> result;
return result;
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe,
const double tolerance)
-template<int dim>
+template <int dim>
void test_hyper_ball(const double tolerance)
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
Tensor<1,dim> ones ()
{
Tensor<1,dim> result;
return result;
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe,
const double tolerance)
-template<int dim>
+template <int dim>
void test_hyper_ball(const double tolerance)
{
Triangulation<dim> tr;
#include <sstream>
#include <fstream>
-template<int dim>
+template <int dim>
Tensor<1,dim> ones ()
{
Tensor<1,dim> result;
return result;
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe,
const double tolerance)
-template<int dim>
+template <int dim>
void test_hyper_ball(const double tolerance)
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
Tensor<1,dim> ones ()
{
Tensor<1,dim> result;
return result;
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe,
const double tolerance)
// at the time of writing this test, RaviartThomas elements did not pass
// the hyper_ball version of the test, perhaps due to issues on the boundary.
-template<int dim>
+template <int dim>
void test_hyper_cube(const double tolerance)
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
Tensor<1,dim> ones ()
{
Tensor<1,dim> result;
return result;
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe,
const double tolerance)
// at the time of writing this test, RaviartThomas elements did not pass
// the hyper_ball version of the test, perhaps due to issues on the boundary.
-template<int dim>
+template <int dim>
void test_hyper_cube(const double tolerance)
{
Triangulation<dim> tr;
/**
* A 1D function given by input legendre coefficients
*/
-template<int dim>
+template <int dim>
class LegendreFunction : public Function<dim>
{
public:
const std::vector<double> coefficients;
};
-template<int dim>
+template <int dim>
double LegendreFunction<dim>::value(const dealii::Point<dim> &point,
const unsigned int ) const
{
return f;
}
-template<int dim>
+template <int dim>
void test(const LegendreFunction<dim> &func,
const unsigned int poly_degree)
{
using namespace dealii;
-template<int dim>
+template <int dim>
class LegendreFunction : public Function<dim>
{
public:
const unsigned int component = 0 ) const;
};
-template<int dim>
+template <int dim>
double LegendreFunction<dim>::value(const Point<dim> &point,
const unsigned int ) const
{
}
-template<int dim>
+template <int dim>
void test(const LegendreFunction<dim> &func,
const unsigned int poly_degree)
{
using namespace dealii;
-template<int dim>
+template <int dim>
class LegendreFunction : public Function<dim>
{
public:
return res;
}
-template<>
+template <>
double LegendreFunction<2>::value(const dealii::Point<2> &point,
const unsigned int ) const
{
return f;
}
-template<>
+template <>
double LegendreFunction<3>::value(const dealii::Point<3> &point,
const unsigned int ) const
{
-template<int dim>
+template <int dim>
void test(const LegendreFunction<dim> &func,
const unsigned int poly_degree)
{
#include <sstream>
#include <fstream>
-template<int dim>
+template <int dim>
Tensor<1,dim> ones ()
{
Tensor<1,dim> result;
return result;
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe,
const double tolerance)
-template<int dim>
+template <int dim>
void test_hyper_ball(const double tolerance)
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test_embedding (const FiniteElement<dim> &fe)
{
const unsigned int n = fe.dofs_per_cell;
}
-template<int dim>
+template <int dim>
void test_projection (const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2,
std::ostream &out)
}
-template<int dim>
+template <int dim>
void test_projection (std::ostream &out)
{
FE_DGQ<dim> q0(0);
}
-template<int dim>
+template <int dim>
void test_renumbering(const FiniteElement<dim> &fe)
{
std::vector<unsigned int> v(fe.dofs_per_cell);
}
-template<int dim>
+template <int dim>
void test_renumbering()
{
deallog.push("Renumber");
}
-template<int dim>
+template <int dim>
void test_renumbering(const FiniteElement<dim> &fe)
{
std::vector<types::global_dof_index> v(fe.dofs_per_cell);
}
-template<int dim>
+template <int dim>
void test_renumbering()
{
deallog.push("Renumber");
}
-template<int dim>
+template <int dim>
void test(const Triangulation<dim> &tria,
const Mapping<dim> &mapping,
const FiniteElement<dim> &fe1,
const unsigned int q;
};
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> tria;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
#include <iostream>
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe,
const unsigned int degree)
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
#include <fstream>
-template<int dim>
+template <int dim>
class VectorFunction : public Function<dim>
{
public:
virtual void vector_value(const Point<dim> &p, Vector<double> &values) const;
};
-template<>
+template <>
double VectorFunction<2>::value(const Point<2> &p, const unsigned int component) const
{
Assert (component < 2, ExcIndexRange (component, 0, 1));
return val;
}
-template<>
+template <>
double VectorFunction<3>::value(const Point<3> &p, const unsigned int component) const
{
Assert (component < 3, ExcIndexRange (component, 0, 2));
return val;
}
-template<int dim>
+template <int dim>
void VectorFunction<dim>::vector_value(const Point<dim> &p, Vector<double> &values) const
{
for (int i = 0; i < dim; ++i)
values(i) = value(p, i);
}
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> tr;
// Call this function with a system consisting of several copies of
// the SAME element
-template<int dim>
+template <int dim>
void vector_values(const FiniteElement<dim> &fe)
{
Assert(fe.n_base_elements() == 1, ExcNotImplemented());
deallog.pop();
}
-template<int dim>
+template <int dim>
void test_vectors()
{
FE_Q<dim> q1(1);
// Local implementation for any dimension
-template<int dim, int degree, int COMP=1>
+template <int dim, int degree, int COMP=1>
class
Q1WedgeFunction : public Function<dim>
{
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> tria;
#include <deal.II/grid/grid_generator.h>
#include <deal.II/grid/tria_boundary_lib.h>
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> tria;
#include <deal.II/grid/tria.h>
#include <deal.II/grid/grid_generator.h>
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> tria;
#include <deal.II/grid/tria_boundary_lib.h>
#include <deal.II/numerics/vector_tools.h>
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> tria;
-template<int dim>
+template <int dim>
inline void
plot_shape_functions(const unsigned int degree)
{
-template<int dim>
+template <int dim>
inline void
check (const unsigned int p)
{
-template<int dim>
+template <int dim>
inline void
check (const unsigned int p)
{
namespace polytest
{
- template<int dim>
+ template <int dim>
class SimplePolynomial : public Function<dim>
{
public:
std::vector<Vector<double> > &values) const;
};
- template<int dim>
+ template <int dim>
void SimplePolynomial<dim>::vector_value_list (const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const
{
}
- template<int dim>
+ template <int dim>
void SimplePolynomial<dim>::rhs_value_list (const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const
{
}
- template<int dim>
+ template <int dim>
class polytest
{
public:
};
- template<int dim>
+ template <int dim>
polytest<dim>::polytest (unsigned int degree)
:
p_order(degree),
dof_handler.clear ();
}
- template<int dim>
+ template <int dim>
void polytest<dim>::setup_system()
{
dof_handler.distribute_dofs (fe);
system_matrix.reinit (sparsity_pattern);
}
- template<int dim>
+ template <int dim>
void polytest<dim>::assemble_system()
{
const QGauss<dim> test_quad(quad_order);
}
}
- template<int dim>
+ template <int dim>
void polytest<dim>::solve()
{
SparseDirectUMFPACK direct;
constraints.distribute (solution);
}
- template<int dim>
+ template <int dim>
void polytest<dim>::output_error()
{
SimplePolynomial<dim> exact_solution;
deallog << "p=" << p_order << " L2_error: " << L2_error << std::endl;
}
- template<int dim>
+ template <int dim>
void polytest<dim>::run()
{
GridGenerator::hyper_cube (tria, -1.2, 1.3);
using namespace dealii;
// Dirichlet BCs / exact solution:.
- template<int dim>
+ template <int dim>
class ExactSolution : public Function<dim>
{
public:
std::vector<Vector<double> > &value_list);
};
- template<int dim>
+ template <int dim>
ExactSolution<dim>::ExactSolution()
:
Function<dim> (dim)
{
dof_handler.clear ();
}
- template<int dim>
+ template <int dim>
double MaxwellProblem<dim>::calcErrorHcurlNorm()
{
QGauss<dim> quadrature_formula(quad_order);
constraints.distribute (solution);
}
- template<int dim>
+ template <int dim>
void MaxwellProblem<dim>::process_solution(const unsigned int cycle)
{
-template<int dim>
+template <int dim>
void
check()
{
-template<int dim>
+template <int dim>
Point<dim> stretch (const Point<dim> &p)
{
Point<dim> q = p;
-template<int dim>
+template <int dim>
void
check()
{
-template<int dim>
+template <int dim>
Point<dim> affine (const Point<dim> &p)
{
Point<dim> q = p;
-template<int dim>
+template <int dim>
void
check()
{
-template<int dim>
+template <int dim>
Point<dim> bilinear (const Point<dim> &p)
{
Point<dim> q = p;
-template<int dim>
+template <int dim>
void
check()
{
-template<int dim>
+template <int dim>
void
check()
{
-template<int dim>
+template <int dim>
Point<dim> stretch (const Point<dim> &p)
{
Point<dim> q = p;
-template<int dim>
+template <int dim>
void
check()
{
-template<int dim>
+template <int dim>
Point<dim> affine (const Point<dim> &p)
{
Point<dim> q = p;
-template<int dim>
+template <int dim>
void
check()
{
-template<int dim>
+template <int dim>
Point<dim> bilinear (const Point<dim> &p)
{
Point<dim> q = p;
-template<int dim>
+template <int dim>
void
check()
{
-template<int dim>
+template <int dim>
void
test(const FE_Q<dim> &fe_q)
{
-template<int dim>
+template <int dim>
void
test(const FE_Q<dim> &fe_q)
{
-template<int dim>
+template <int dim>
void
test(const FE_Q<dim> &fe_q)
{
-template<int dim>
+template <int dim>
void
test(const FE_Q<dim> fe1,
const FE_Q<dim> fe2)
-template<int dim>
+template <int dim>
inline void
plot_shape_functions(const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
-template<int dim>
+template <int dim>
void
plot_shape_functions(const unsigned int degree)
{
-template<int dim>
+template <int dim>
void
test(const unsigned int degree)
{
-template<int dim>
+template <int dim>
void
test(const unsigned int degree)
{
-template<int dim>
+template <int dim>
void
plot_shape_functions(const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
std::ofstream logfile ("output");
-template<int dim>
+template <int dim>
void
test (const unsigned int degree)
{
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
}
-template<int dim>
+template <int dim>
void
test (unsigned int degree)
{
-template<int dim>
+template <int dim>
void
plot_shape_functions(const unsigned int degree)
{
-template<int dim>
+template <int dim>
void test ()
{
for (unsigned int degree=0; degree<9-2*dim; ++degree)
//
// x (y) (z) value[0]+1 value[1]+1 ...
////////////////////////////////////////////////////////////////////////////
-template<int dim>
+template <int dim>
inline void
plot_shape_functions(Mapping<dim> &mapping,
FiniteElement<dim> &finel,
-template<int dim>
+template <int dim>
inline void
plot_face_shape_functions(
Mapping<dim> &mapping,
}
-template<>
+template <>
void plot_face_shape_functions (Mapping<1> &, FiniteElement<1> &, const char *, UpdateFlags)
{}
-template<int dim>
+template <int dim>
void test_compute_functions (const Mapping<dim> &mapping,
const FiniteElement<dim> &fe,
const char *)
#define PRECISION 8
-template<int dim>
+template <int dim>
void plot_FE_Bernstein_shape_functions()
{
MappingQGeneric<dim> m(1);
#define PRECISION 8
-template<int dim>
+template <int dim>
void plot_FE_DGP_shape_functions()
{
MappingQGeneric<dim> m(1);
#define PRECISION 8
-template<int dim>
+template <int dim>
void plot_FE_DGPMonomial_shape_functions()
{
MappingQGeneric<dim> m(1);
#define PRECISION 8
-template<int dim>
+template <int dim>
void plot_FE_DGPNonparametric_shape_functions()
{
MappingQGeneric<dim> m(1);
#define PRECISION 8
-template<int dim>
+template <int dim>
void plot_FE_DGQ_shape_functions()
{
MappingQGeneric<dim> m(1);
#define PRECISION 8
-template<int dim>
+template <int dim>
void plot_FE_FaceQ_shape_functions()
{
MappingQGeneric<dim> m(1);
#define PRECISION 8
-template<int dim>
+template <int dim>
void plot_FE_Nedelec_shape_functions()
{
MappingQGeneric<dim> m(1);
#define PRECISION 8
-template<int dim>
+template <int dim>
void plot_FE_Q_shape_functions()
{
MappingQGeneric<dim> m(1);
#define PRECISION 7
-template<int dim>
+template <int dim>
void plot_FE_Q_Bubbles_shape_functions()
{
MappingQGeneric<dim> m(1);
#define PRECISION 8
-template<int dim>
+template <int dim>
void plot_FE_Q_DG0_shape_functions()
{
MappingQGeneric<dim> m(1);
#define PRECISION 8
-template<int dim>
+template <int dim>
void plot_FE_Q_Hierarchical_shape_functions()
{
MappingQGeneric<dim> m(1);
#define PRECISION 8
-template<int dim>
+template <int dim>
void plot_FE_Q_shape_functions()
{
MappingQGeneric<dim> m(1);
#define PRECISION 8
-template<int dim>
+template <int dim>
void plot_FE_System_shape_functions()
{
MappingQGeneric<dim> m(1);
#define PRECISION 8
-template<int dim>
+template <int dim>
void plot_FE_System_shape_functions()
{
MappingQGeneric<dim> m(1);
#define PRECISION 8
-template<int dim>
+template <int dim>
void plot_FE_TraceQ_shape_functions()
{
MappingQGeneric<dim> m(1);
-template<int dim>
+template <int dim>
void
check(const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2)
-template<int dim>
+template <int dim>
void
check(FESystem<dim> &fe)
{
-template<int dim>
+template <int dim>
void
check_fe(const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void check()
{
FE_DGQ<dim> co(0);
deallog << # el << '<' << dim << ">(" << deg << ')' << std::endl; \
print_matrix(tr ## dim, l, fe, #el); }
-template<int dim>
+template <int dim>
inline void
print_matrix(Triangulation<dim> &tr,
unsigned int level,
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation (Triangulation<dim>::limit_level_difference_at_vertices);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation (Triangulation<dim>::limit_level_difference_at_vertices);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation (Triangulation<dim>::limit_level_difference_at_vertices);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation (Triangulation<dim>::limit_level_difference_at_vertices);
}
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation (Triangulation<dim>::limit_level_difference_at_vertices);
}
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation (Triangulation<dim>::limit_level_difference_at_vertices);
}
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation (Triangulation<dim>::limit_level_difference_at_vertices);
#define PRECISION 5
-template<int dim>
+template <int dim>
void create_triangulation(const unsigned int,
Triangulation<dim> &)
{
}
-template<>
+template <>
void create_triangulation(const unsigned int case_no,
Triangulation<2> &tria)
{
}
-template<>
+template <>
void create_triangulation(const unsigned int case_no,
Triangulation<3> &tria)
{
}
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> tria;
}
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> tria;
#include <deal.II/dofs/dof_accessor.h>
#include "../tests.h"
-template<int dim>
+template <int dim>
void
test()
{
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation (Triangulation<dim>::limit_level_difference_at_vertices);
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation (Triangulation<dim>::limit_level_difference_at_vertices);
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation (Triangulation<dim>::limit_level_difference_at_vertices);
using namespace dealii;
-template<int dim>
+template <int dim>
void test()
{
using namespace dealii;
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
// create 2 triangulations with the
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
// create 2 triangulations with the
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
// create 2 triangulations with the
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation (Triangulation<dim>::limit_level_difference_at_vertices);
#include <iomanip>
-template<int dim>
+template <int dim>
void test(std::ostream &out)
{
Point<dim> p1;
#include <iomanip>
-template<int dim>
+template <int dim>
void test(std::ostream &out)
{
Point<dim> p1;
#include <iomanip>
-template<int dim>
+template <int dim>
void test(std::ostream &out)
{
Point<dim> p1;
#include <iomanip>
-template<int dim>
+template <int dim>
void test(std::ostream &out)
{
Point<dim> p1;
-template<int dim>
+template <int dim>
void test(std::ostream &out)
{
Point<dim> p1;
#include <iomanip>
-template<int dim>
+template <int dim>
void test(std::ostream &out)
{
GridOut go;
#include <iomanip>
-template<int dim>
+template <int dim>
void test(std::ostream &out)
{
Point<dim> p1;
#include <iomanip>
-template<int dim>
+template <int dim>
void test(std::ostream &out)
{
Triangulation<2> triangulation;
#include <iomanip>
-template<int dim>
+template <int dim>
void test(std::ostream &out)
{
Triangulation<dim> triangulation;
#include <iomanip>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test(std::ostream &out)
{
Point<dim> p1;
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check_rect1 (unsigned int n, bool color, bool log)
{
Point<dim> left;
#include <iomanip>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test(std::ostream &out)
{
Triangulation<dim,spacedim> triangulation;
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check (double r1, double r2, unsigned int n)
{
deallog << "dim=" << dim << std::endl;
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check (double r1, double r2, unsigned int n)
{
Point<dim> center;
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check (double r1, double r2, unsigned int n)
{
Point<dim> center;
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check (double r1, double r2, unsigned int n)
{
Point<dim> center;
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check (const unsigned int n)
{
deallog << "n=" << n << std::endl;
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check (double r1, double r2, unsigned int n)
{
Point<dim> center;
}
-template<int dim>
+template <int dim>
void check_file (const std::string name,
typename GridIn<dim>::Format format)
{
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check_file (const std::string name,
typename GridIn<dim>::Format format)
{
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check_file (const std::string name,
typename GridIn<dim>::Format format)
{
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check_file (const std::string name,
typename GridIn<dim>::Format format)
{
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check_file (const std::string name,
typename GridIn<dim>::Format format)
{
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check_file (const std::string name,
typename GridIn<dim>::Format format)
{
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check_file (const std::string name,
typename GridIn<dim>::Format format)
{
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check_file (const std::string name,
typename GridIn<dim>::Format format)
{
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check_file (const std::string name,
typename GridIn<dim>::Format format)
{
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check_file (const std::string name,
typename GridIn<dim>::Format format)
{
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check_file (const std::string name,
typename GridIn<dim>::Format format)
{
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check_file (const std::string name,
typename GridIn<dim>::Format format)
{
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void check_file (const std::string name,
typename GridIn<dim>::Format format)
{
#include <fstream>
-template<int dim>
+template <int dim>
void output(const parallel::distributed::Triangulation<dim> &tr,
const std::string &filename,
const bool view_levels,
AssertThrow(false, ExcNotImplemented());
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void output(const parallel::shared::Triangulation<dim> &tr,
const std::string &filename,
const bool view_levels,
AssertThrow(false, ExcNotImplemented());
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void output(parallel::distributed::Triangulation<dim> &tr, std::ostream &stream)
{
GridOut out;
out.write_vtk(tr, stream);
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <iomanip>
-template<int dim>
+template <int dim>
void test(std::ostream &out)
{
GridOut go;
// The simplest test case is to create a parallelepiped grid, output
// the result, and hope for the best.
-template<int dim>
+template <int dim>
void check_parallelepiped (bool colorize, bool log)
{
// Data structure defining dim coordinates that make up a
// grid), this test is not entirely trivial.
//
// Here is the implementation in nd:
-template<int dim>
+template <int dim>
void check_nd_parallelepiped_by_comparison (bool log)
{
// The simplest test case is to create a parallelepiped grid with a
// number of subdivisions and output the result.
-template<int dim>
+template <int dim>
void check_subdivided_parallelepiped (bool colorize, bool log)
{
// Data structure defining dim coordinates that make up a
#include <iomanip>
#include <map>
-template<int dim>
+template <int dim>
void check_parallelepiped (bool colorize, bool log, const unsigned int (&subd)[dim])
{
deallog << "* checking dim=" << dim
// The simplest test case is to create a parallelepiped grid with a
// number of subdivisions and output the result.
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void check (bool subdivide)
{
deallog << "dim " << dim << " spacedim " << spacedim << std::endl;
/*
* Print out the face vertices as well as the orientation of a match:
*/
-template<typename FaceIterator>
+template <typename FaceIterator>
void print_match(const FaceIterator &face_1,
const FaceIterator &face_2,
const std::bitset<3> &orientation)
/*
* Print out the face vertices as well as the orientation of a match:
*/
-template<typename FaceIterator>
+template <typename FaceIterator>
void print_match(const FaceIterator &face_1,
const FaceIterator &face_2,
const std::bitset<3> &orientation)
#include <deal.II/grid/grid_tools.h>
#include <deal.II/grid/grid_out.h>
-template<int dim>
+template <int dim>
bool
pred_mat_id(const typename Triangulation<dim>::active_cell_iterator &cell)
{
#include <vector>
#include <cmath>
-template<int dim>
+template <int dim>
bool
pred_mat_id(const typename Triangulation<dim>::active_cell_iterator &cell)
{
#include <deal.II/grid/grid_tools.h>
#include <deal.II/grid/grid_out.h>
-template<int dim>
+template <int dim>
bool
pred_mat_id(const typename Triangulation<dim>::active_cell_iterator &cell)
{
#include <deal.II/grid/grid_tools.h>
#include <deal.II/grid/grid_out.h>
-template<int dim>
+template <int dim>
bool
pred_mat_id(const typename Triangulation<dim>::active_cell_iterator &cell)
{
#include <fstream>
#include <iomanip>
-template<int dim>
+template <int dim>
Point<dim> trans_func(Point<dim> &p);
-template<>
+template <>
Point<2> trans_func(Point<2> &p)
{
Point<2> r(p(0)+p(1)*p(1),p(1));
return r;
}
-template<>
+template <>
Point<3> trans_func(Point<3> &p)
{
Point<3> r(p(0)+p(1)*p(1),p(1),p(2));
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
// create 3 triangulations
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
// create 3 triangulations
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
// create 3 triangulations
#define PRECISION 5
-template<int dim>
+template <int dim>
void create_triangulation(const unsigned int,
Triangulation<dim> &)
{
}
-template<>
+template <>
void create_triangulation(const unsigned int case_no,
Triangulation<2> &tria)
{
}
-template<>
+template <>
void create_triangulation(const unsigned int case_no,
Triangulation<3> &tria)
{
}
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> tria;
#define PRECISION 5
-template<int dim>
+template <int dim>
void create_triangulation(const unsigned int,
Triangulation<dim> &)
{
}
-template<>
+template <>
void create_triangulation(const unsigned int case_no,
Triangulation<2> &tria)
{
}
-template<>
+template <>
void create_triangulation(const unsigned int case_no,
Triangulation<3> &tria)
{
}
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> tria;
std::ofstream logfile("output");
-template<int dim>
+template <int dim>
void mesh_info(const Triangulation<dim> &tria)
{
deallog << "Mesh info:" << std::endl
// eps image of the mesh so we can see the nodes are at the right
// place.
-template<int dim>
+template <int dim>
void mesh_info(const Triangulation<dim> &tria,
const std::string &filename)
{
-template<int dim>
+template <int dim>
void test()
{
for (unsigned int t=0; t<2; ++t)
return;
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void f_pre_coarsening_on_cell (const typename Triangulation<dim, spacedim>::cell_iterator &)
{
++signal_counter_pre_coarsening_on_cell;
return;
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void f_post_refinement_on_cell (const typename Triangulation<dim, spacedim>::cell_iterator &)
{
++signal_counter_post_refinement_on_cell;
return;
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void f_copy (const Triangulation<dim, spacedim> &)
{
++signal_counter_copy;
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
signal_counter_create = 0;
* when this function is called for invalid input.
*/
-template<int dim>
+template <int dim>
void check_parallelepiped (std::ofstream &logfile)
{
// Data structure defining dim coordinates that make up a
* this function is called for invalid input.
*/
-template<int dim>
+template <int dim>
void check_parallelepiped (std::ofstream &logfile)
{
// Data structure defining dim coordinates that make up a
/**
* Check if user pointers are the same as entered below
*/
-template<int dim>
+template <int dim>
void
check_user_pointers(Triangulation<dim> &tr)
{
/**
* Check if user indices are the same as entered below
*/
-template<int dim>
+template <int dim>
void
check_user_indices(Triangulation<dim> &tr)
{
}
-template<int dim>
+template <int dim>
void
user_pointers(Triangulation<dim> &tr)
{
}
-template<int dim>
+template <int dim>
void
user_indices(Triangulation<dim> &tr)
{
#include <cstdlib>
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation (Triangulation<dim>::limit_level_difference_at_vertices);
using namespace dealii;
-template<int dim>
+template <int dim>
void test2cells(const unsigned int p1=2,
const unsigned int p2=1)
{
// |-----| 2 |
// |1 |1 | |
// ------------
-template<int dim>
+template <int dim>
void test2cells(const FiniteElement<dim> &fe_0,
const FiniteElement<dim> &fe_1,
const FiniteElement<dim> &fe_2,
using namespace dealii;
-template<int dim>
+template <int dim>
void test(const bool apply_constrains, const unsigned int hp)
{
Triangulation<dim> triangulation;
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <cstdlib>
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> triangulation;
};
-template<int dim>
+template <int dim>
void test()
{
// create 2 triangulations with the
};
-template<int dim>
+template <int dim>
void test()
{
HyperBallBoundary<dim> boundary;
};
-template<int dim>
+template <int dim>
void test()
{
// create 2 triangulations with the
// a linear function that should be transferred exactly with Q1 and Q2
// elements
-template<int dim>
+template <int dim>
class MyFunction : public Function<dim>
{
public:
// - FE_Q_Hierarchical
// - manual interpolation as there is no general interpolation implemented
// for this FE currently, thus VectorTools::interpolate can't be used.
-template<int dim>
+template <int dim>
class MyFunction : public Function<dim>
{
public:
std::pair<bool,unsigned int>
predicate_ind(const TableIndices<dim> &ind);
- template<>
+ template <>
std::pair<bool,unsigned int>
predicate_ind<2>(const TableIndices<2> &ind)
{
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
/*
* Main class
*/
-template<int dim>
+template <int dim>
class MeshWorkerConstraintMatrixTest
{
public:
};
-template<int dim>
+template <int dim>
MeshWorkerConstraintMatrixTest<dim>::MeshWorkerConstraintMatrixTest(const FiniteElement<dim> &fe) :
mapping(),
dof_handler(triangulation),
}
-template<int dim>
+template <int dim>
void MeshWorkerConstraintMatrixTest<dim>::setup_system()
{
dof_handler.distribute_dofs(fe);
/*
* Assemble with SystemSimple
*/
-template<int dim>
+template <int dim>
void MeshWorkerConstraintMatrixTest<dim>::assemble_system_MeshWorker()
{
/*
* Assemble matrix and vector seperately
*/
-template<int dim>
+template <int dim>
void MeshWorkerConstraintMatrixTest<dim>::assemble_MeshWorker()
{
}
-template<int dim>
+template <int dim>
void MeshWorkerConstraintMatrixTest<dim>::run()
{
setup_system();
}
-template<int dim>
+template <int dim>
void
test(const FiniteElement<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void
test(const FiniteElement<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void
test(const FiniteElement<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void
test(const FiniteElement<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void
test(const FiniteElement<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void
test(const FiniteElement<dim> &fe)
{
#include <fstream>
-template<typename VectorType>
+template <typename VectorType>
void test (const FilteredMatrix<VectorType> &M)
{
deallog << "Iterator";
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
-template<typename number>
+template <typename number>
void
checkVmult(FullMatrix<number> &A, Vector<number> &V,
bool expect_constrained_source = false)
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
-template<typename number>
+template <typename number>
void
checkTvmult(FullMatrix<number> &A, Vector<number> &V,
bool expect_constrained_source = false)
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
-template<typename number>
+template <typename number>
void
checkVmult_Add(FullMatrix<number> &A, Vector<number> &V,
bool expect_constrained_source = false)
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
-template<typename number>
+template <typename number>
void
checkTvmult_Add(FullMatrix<number> &A, Vector<number> &V,
bool expect_constrained_source = false)
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
-template<typename number>
+template <typename number>
void
checkApply_Constraints(FullMatrix<number> &A, Vector<number> &V,
bool matrix_is_symmetric = false)
#include <deal.II/lac/solver_gmres.h>
#include <deal.II/lac/precondition.h>
-template<class NUMBER>
+template <class NUMBER>
void output_eigenvalues(const std::vector<NUMBER> &eigenvalues,const std::string &text)
{
deallog<< text;
#include <iomanip>
#include <cmath>
-template<typename number>
+template <typename number>
void
check_vmult()
{
#include <iomanip>
#include <cmath>
-template<typename number>
+template <typename number>
void
check_vmult()
{
#include <iomanip>
#include <cmath>
-template<typename number>
+template <typename number>
void
check_vmult()
{
#include <iomanip>
#include <cmath>
-template<typename number>
+template <typename number>
void
check_vmult()
{
#include <iomanip>
#include <cmath>
-template<typename number>
+template <typename number>
void
check_vmult()
{
#include <iomanip>
#include <cmath>
-template<typename number>
+template <typename number>
void
check_vmult()
{
return 1;
};
- template<typename OutVector, typename InVector>
+ template <typename OutVector, typename InVector>
void vmult(OutVector &, const InVector &) const
{
deallog << "MyMatrix3::vmult" << std::endl;
}
- template<typename OutVector, typename InVector>
+ template <typename OutVector, typename InVector>
void Tvmult(OutVector &, const InVector &) const
{
deallog << "MyMatrix3::Tvmult" << std::endl;
}
- template<typename OutVector, typename InVector>
+ template <typename OutVector, typename InVector>
void vmult_add(OutVector &, const InVector &) const
{
deallog << "MyMatrix3::vmult_add" << std::endl;
}
- template<typename OutVector, typename InVector>
+ template <typename OutVector, typename InVector>
void Tvmult_add(OutVector &, const InVector &) const
{
deallog << "MyMatrix3::Tvmult_add" << std::endl;
return 1;
};
- template<typename OutVector, typename InVector>
+ template <typename OutVector, typename InVector>
void vmult(OutVector &, const InVector &, bool = true) const
{
deallog << "MyMatrix4::vmult" << std::endl;
}
- template<typename OutVector, typename InVector>
+ template <typename OutVector, typename InVector>
void Tvmult(OutVector &, const InVector &, bool = true) const
{
deallog << "MyMatrix4::Tvmult" << std::endl;
}
- template<typename OutVector, typename InVector>
+ template <typename OutVector, typename InVector>
void vmult_add(OutVector &, const InVector &, bool = true) const
{
deallog << "MyMatrix4::vmult_add" << std::endl;
}
- template<typename OutVector, typename InVector>
+ template <typename OutVector, typename InVector>
void Tvmult_add(OutVector &, const InVector &, bool = true) const
{
deallog << "MyMatrix4::Tvmult_add" << std::endl;
return 1;
};
- template<typename number>
+ template <typename number>
void vmult(Vector<number> &, const Vector<number> &, bool = true) const
{
deallog << "MyMatrix5::vmult" << std::endl;
}
- template<typename number>
+ template <typename number>
void Tvmult(Vector<number> &, const Vector<number> &, bool = true) const
{
deallog << "MyMatrix5::Tvmult" << std::endl;
}
- template<typename number>
+ template <typename number>
void vmult_add(Vector<number> &, const Vector<number> &, bool = true) const
{
deallog << "MyMatrix5::vmult_add" << std::endl;
}
- template<typename number>
+ template <typename number>
void Tvmult_add(Vector<number> &, const Vector<number> &, bool = true) const
{
deallog << "MyMatrix5::Tvmult_add" << std::endl;
return 1;
};
- template<typename number, typename number2>
+ template <typename number, typename number2>
void vmult(Vector<number> &, const Vector<number2> &, bool = true) const
{
deallog << "MyMatrix6::vmult" << std::endl;
}
- template<typename number, typename number2>
+ template <typename number, typename number2>
void Tvmult(Vector<number> &, const Vector<number2> &, bool = true) const
{
deallog << "MyMatrix6::Tvmult" << std::endl;
}
- template<typename number, typename number2>
+ template <typename number, typename number2>
void vmult_add(Vector<number> &, const Vector<number2> &, bool = true) const
{
deallog << "MyMatrix6::vmult_add" << std::endl;
using namespace dealii;
-template<class PRECONDITIONER, typename MatrixType, typename VectorType,
- class ADDITIONAL_DATA = typename PRECONDITIONER::AdditionalData>
+template <class PRECONDITIONER, typename MatrixType, typename VectorType,
+ class ADDITIONAL_DATA = typename PRECONDITIONER::AdditionalData>
void
test_preconditioner_block (const MatrixType &A,
const VectorType &b,
// For Vector <double>
// Cannot use more generic function as Vector <double>
// does not define vector_type
-template<class PRECONDITIONER>
+template <class PRECONDITIONER>
void
test_preconditioner (const SparseMatrix<double> &A,
const Vector<double> &b,
}
}
-template<typename SolverType>
+template <typename SolverType>
void
test_solver (const SparseMatrix<double> &A,
const Vector<double> &b)
matrix.n_block_cols());
}
- template<typename VectorType>
+ template <typename VectorType>
void
vmult(VectorType &dst, const VectorType &src) const
{
dst = src;
}
- template<typename VectorType>
+ template <typename VectorType>
void
Tvmult(VectorType &dst, const VectorType &src) const
{
using namespace dealii;
-template<typename VECTOR>
+template <typename VECTOR>
void
print (const VECTOR &vec)
{
}
-template<class PRECONDITIONER, class MATRIX, class VECTOR,
- class ADDITIONAL_DATA = typename PRECONDITIONER::AdditionalData>
+template <class PRECONDITIONER, class MATRIX, class VECTOR,
+ class ADDITIONAL_DATA = typename PRECONDITIONER::AdditionalData>
void
test_preconditioner (const MATRIX &A,
const VECTOR &b,
deallog.pop();
}
-template<class SOLVER, class MATRIX, class VECTOR>
+template <class SOLVER, class MATRIX, class VECTOR>
void
test_solver (const MATRIX &A,
const VECTOR &b)
using namespace dealii;
-template<typename VECTOR>
+template <typename VECTOR>
void
print (const VECTOR &vec)
{
}
-template<class PRECONDITIONER, class MATRIX, class VECTOR,
- class ADDITIONAL_DATA = typename PRECONDITIONER::AdditionalData>
+template <class PRECONDITIONER, class MATRIX, class VECTOR,
+ class ADDITIONAL_DATA = typename PRECONDITIONER::AdditionalData>
void
test_preconditioner (const MATRIX &A,
const VECTOR &b,
deallog.pop();
}
-template<class SOLVER, class MATRIX, class VECTOR>
+template <class SOLVER, class MATRIX, class VECTOR>
void
test_solver (const MATRIX &A,
const VECTOR &b)
using namespace dealii;
-template<int dim>
+template <int dim>
void build_matrix_vector(TrilinosWrappers::BlockSparseMatrix &matrix,
TrilinosWrappers::MPI::BlockVector &vector,
const FE_Q<dim> &fe_test,
using namespace dealii;
-template<int dim>
+template <int dim>
void build_matrix_vector(TrilinosWrappers::BlockSparseMatrix &matrix,
TrilinosWrappers::MPI::BlockVector &vector,
const FE_Q<dim> &fe_test,
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
-template<typename number>
+template <typename number>
void
checkConstructor1()
{
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
-template<typename number>
+template <typename number>
void
checkConstructor2(FullMatrix<number> &A)
{
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
-template<typename number>
+template <typename number>
void
checkConstructor3(char *name)
{
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
-template<typename number>
+template <typename number>
void
checkConstructor4(const FullMatrix<number> &A, char *name)
{
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
-template<typename number>
+template <typename number>
void
checkVmult(FullMatrix<number> &A, Vector<number> &V, char *name =
"Test Matrix")
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
-template<typename number>
+template <typename number>
void
checkTvmult(FullMatrix<number> &A, Vector<number> &V, char *name =
"Test Matrix")
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
-template<typename number>
+template <typename number>
void
checkTvmult_add(FullMatrix<number> &A, Vector<number> &V, char *name =
"Test Matrix")
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
-template<typename number>
+template <typename number>
void
checkVmult_add(FullMatrix<number> &A, Vector<number> &V, char *name =
"Test Matrix")
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
-template<typename number>
+template <typename number>
void
checkClear(FullMatrix<number> &A)
{
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
-template<typename number>
+template <typename number>
void
checkAssign(FullMatrix<number> &A, FullMatrix<number> &B)
{
* The diagonal is scaled to 1, resulting in an effective mesh width of 1/2.
*/
-template<typename number>
+template <typename number>
class QuickMatrix
{
public:
};
-template<typename number>
+template <typename number>
QuickMatrix<number>::QuickMatrix(unsigned int nx, unsigned int ny)
:
nx(nx), ny(ny)
{}
-template<typename number>
+template <typename number>
template <typename number2>
void
QuickMatrix<number>::vmult(Vector<number2> &d,
#include <deal.II/lac/solver_qmrs.h>
#include <deal.II/lac/precondition.h>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverType &solver,
const MatrixType &A,
}
}
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_Tsolve (SolverType &solver,
const MatrixType &A,
#include <deal.II/lac/precondition.h>
#include <deal.II/base/point.h>
-template<typename SolverType>
+template <typename SolverType>
void test()
{
const unsigned int size = 3;
#include <deal.II/lac/solver_relaxation.h>
#include <deal.II/lac/precondition.h>
-template<typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverControl &solver_control,
const MatrixType &A,
#include <deal.II/lac/solver_relaxation.h>
#include <deal.II/lac/precondition.h>
-template<typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverControl &solver_control,
const MatrixType &A,
#include <deal.II/lac/solver_relaxation.h>
#include <deal.II/lac/precondition.h>
-template<typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverControl &solver_control,
const MatrixType &A,
#include <deal.II/lac/solver_relaxation.h>
#include <deal.II/lac/precondition.h>
-template<typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverControl &solver_control,
const MatrixType &A,
#include <deal.II/lac/solver_qmrs.h>
#include <deal.II/lac/precondition.h>
-template<typename SolverType, typename MatrixType, typename VectorType>
+template <typename SolverType, typename MatrixType, typename VectorType>
void
check_solve (const MatrixType &A,
VectorType &u,
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverType &solver,
const MatrixType &A,
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverType &solver,
const MatrixType &A,
#include <deal.II/lac/solver_relaxation.h>
#include <deal.II/lac/precondition.h>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
double
check_solve (SolverType &solver,
const MatrixType &A,
#include <deal.II/lac/precondition_block.h>
#include <deal.II/lac/relaxation_block.h>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
double
check_solve (SolverType &solver,
const MatrixType &A,
#include <deal.II/lac/precondition_block.h>
#include <deal.II/lac/relaxation_block.h>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
double
check_solve (SolverType &solver,
const MatrixType &A,
#include <iomanip>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
double
check_solve (SolverType &solver,
const MatrixType &A,
deallog<<"alpha: "<< alpha << " beta: "<< beta << std::endl;
}
-template<class NUMBER>
+template <class NUMBER>
void output_eigenvalues(const std::vector<NUMBER> &eigenvalues,const std::string &text)
{
deallog<< text;
deallog << std::endl;
}
-template<class NUMBER>
+template <class NUMBER>
void output_hessenberg_matrix(const FullMatrix<NUMBER> &H,const std::string &text)
{
deallog << text << std::endl;
}
}
-template<class NUMBER>
+template <class NUMBER>
void output_arnoldi_vectors_norms(const internal::SolverGMRES::TmpVectors<Vector<NUMBER> > &tmp_vector,const std::string &text)
{
deallog << text << std::endl;
deallog << tmp_vector[i].l2_norm() << std::endl;
}
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const MatrixType &A,
deallog.pop(); \
residuals.push_back(control.last_value())
-template<typename MatrixType>
+template <typename MatrixType>
void
check_vmult_quadratic (std::vector<double> &residuals,
const MatrixType &A,
// Symmetric matrix with constant diagonals [-1,2,-1]
-template<typename number>
+template <typename number>
void
matrix1(TridiagonalMatrix<number> &M)
{
// Nonsymmetric matrix with constant diagonals [-1,2,-3]
-template<typename number>
+template <typename number>
void
matrix2(TridiagonalMatrix<number> &M)
{
// Matrix with increasing diagonals and symmetric rows
-template<typename number>
+template <typename number>
void
matrix3(TridiagonalMatrix<number> &M)
{
// Symmetric matrix with increasing diagonals
-template<typename number>
+template <typename number>
void
matrix4(TridiagonalMatrix<number> &M)
{
// Nonsymmetric matrix with increasing diagonals
-template<typename number>
+template <typename number>
void
matrix5(TridiagonalMatrix<number> &M)
{
}
-template<typename number>
+template <typename number>
void
check_vmult(TridiagonalMatrix<number> &M)
{
}
-template<typename number>
+template <typename number>
void
check(unsigned int size)
{
// Symmetric matrix with constant diagonals [-1,2,-1]
-template<typename number>
+template <typename number>
void
matrix1(TridiagonalMatrix<number> &M)
{
// Symmetric matrix with increasing diagonals
-template<typename number>
+template <typename number>
void
matrix4(TridiagonalMatrix<number> &M)
{
}
-template<typename number>
+template <typename number>
void
check_vmult(TridiagonalMatrix<number> &M)
{
}
-template<typename number>
+template <typename number>
void
check(unsigned int size)
{
using namespace dealii;
-template<typename VectorType>
+template <typename VectorType>
void
test_leak()
{
}
-template<typename VectorType>
+template <typename VectorType>
void
test_stat()
{
deallog << std::endl;
}
-template<typename T>
+template <typename T>
void fill( T &a)
{
for (unsigned int i=0; i<a.size(); ++i)
#include <fstream>
#include <iomanip>
-template<typename number>
+template <typename number>
void
checkReadOnlyConstructor(const Vector<number> &V)
{
#include <fstream>
#include <iomanip>
-template<typename number, typename size_type>
+template <typename number, typename size_type>
void
checkReinit1(const size_type N, const bool fast = false)
{
#include <fstream>
#include <iomanip>
-template<typename number>
+template <typename number>
void
checkReinit3(const Vector<number> &V)
{
#include <fstream>
#include <iomanip>
-template<typename number>
+template <typename number>
void
checkReinit2(Vector<number> &V)
{
#include <fstream>
#include <iomanip>
-template<typename number>
+template <typename number>
void
checkReadWriteConstructor(Vector<number> &V)
{
deallog<<text<< input<<std::endl;
}
-template<class NUMBER>
+template <class NUMBER>
void output_eigenvalues(const std::vector<NUMBER> &eigenvalues,const std::string &text)
{
deallog<< text;
}
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverType &solver,
const MatrixType &A,
}
}
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_Tsolve (SolverType &solver,
const MatrixType &A,
#include <deal.II/grid/grid_tools.h>
#include <deal.II/grid/grid_out.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void print_info(Triangulation<dim,spacedim> &tria)
{
typename Triangulation<dim,spacedim>::active_cell_iterator cell;
#include <deal.II/grid/grid_tools.h>
#include <deal.II/grid/grid_out.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void print_info(Triangulation<dim,spacedim> &tria)
{
typename Triangulation<dim,spacedim>::active_cell_iterator cell;
#include <numeric>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
#include <deal.II/grid/grid_tools.h>
#include <deal.II/grid/grid_out.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void print_info(Triangulation<dim,spacedim> &tria)
{
typename Triangulation<dim,spacedim>::active_cell_iterator cell;
#include <deal.II/grid/grid_tools.h>
#include <deal.II/grid/grid_out.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void print_info(Triangulation<dim,spacedim> &tria)
{
typename Triangulation<dim,spacedim>::active_cell_iterator cell;
-template<int dim>
+template <int dim>
inline void
plot_faces(Mapping<dim> &mapping,
FiniteElement<dim> &fe,
-template<int dim>
+template <int dim>
inline void
plot_subfaces(Mapping<dim> &mapping,
FiniteElement<dim> &fe,
}
-template<int dim>
+template <int dim>
void mapping_test()
{
deallog << "dim=" << dim << std::endl;
-template<int dim>
+template <int dim>
inline void
plot_faces(Mapping<dim> &mapping,
FiniteElement<dim> &fe,
-template<int dim>
+template <int dim>
inline void
plot_subfaces(Mapping<dim> &mapping,
FiniteElement<dim> &fe,
}
-template<int dim>
+template <int dim>
void mapping_test()
{
deallog << "dim=" << dim << std::endl;
#define PRECISION 2
-template<int dim>
+template <int dim>
inline void
plot_transformation(Mapping<dim> &mapping,
FiniteElement<dim> &fe,
-template<int dim>
+template <int dim>
inline void
plot_faces(Mapping<dim> &mapping,
FiniteElement<dim> &fe,
-template<int dim>
+template <int dim>
inline void
plot_subfaces(Mapping<dim> &mapping,
FiniteElement<dim> &fe,
-template<>
+template <>
inline void
plot_faces(Mapping<1> &,
FiniteElement<1> &,
-template<>
+template <>
inline void
plot_subfaces(Mapping<1> &,
FiniteElement<1> &,
-template<int dim>
+template <int dim>
inline void
compute_area(Mapping<dim> &mapping,
FiniteElement<dim> &fe,
}
-template<int dim>
+template <int dim>
void create_triangulations(std::vector<Triangulation<dim> *> &,
std::vector<Boundary<dim> *> &,
std::vector<double> &)
unsigned int mapping_size;
-template<>
+template <>
void create_triangulations(std::vector<Triangulation<1> *> &tria_ptr,
std::vector<Boundary<1> *> &,
std::vector<double> &exact_areas)
-template<>
+template <>
void create_triangulations(std::vector<Triangulation<2> *> &tria_ptr,
std::vector<Boundary<2> *> &boundary_ptr,
std::vector<double> &exact_areas)
-template<>
+template <>
void create_triangulations(std::vector<Triangulation<3> *> &tria_ptr,
std::vector<Boundary<3> *> &boundary_ptr,
std::vector<double> &exact_areas)
}
-template<int dim>
+template <int dim>
void mapping_test()
{
deallog << "dim=" << dim << std::endl;
#define PRECISION 2
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test(const unsigned int degree)
{
deallog << "dim = " << dim << ", spacedim = " << spacedim << std::endl;
using namespace dealii;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
using namespace dealii;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
using namespace dealii;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
using namespace dealii;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
using namespace dealii;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
using namespace dealii;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
using namespace dealii;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
using namespace dealii;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
using namespace dealii;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
using namespace dealii;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
using namespace dealii;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
using namespace dealii;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
#include <deal.II/fe/mapping_manifold.h>
#include <deal.II/grid/manifold_lib.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_values.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_values.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_values.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_values.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
#include <deal.II/fe/fe_values.h>
#include <deal.II/grid/manifold_lib.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
std::ostream &out = deallog.get_file_stream();
#include <deal.II/fe/fe_values.h>
#include <deal.II/grid/manifold_lib.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
std::ostream &out = deallog.get_file_stream();
-template<int dim>
+template <int dim>
inline void
show_values(FiniteElement<dim> &fe,
const char *name)
-template<int dim>
+template <int dim>
void show_values()
{
FE_Q<dim> q1(1);
return (xh * exp(-xh*xh - yh*yh)) / 10.;
}
-template<int dim>
+template <int dim>
class Geometry: public ChartManifold<dim>
{
public:
virtual Point<dim> push_forward(const Point<dim> &chart_point) const;
};
-template<int dim>
+template <int dim>
Point<dim> Geometry<dim>::pull_back(const Point<dim> &space_point) const
{
const double d = space_point[dim - 1];
return p;
}
-template<int dim>
+template <int dim>
Point<dim> Geometry<dim>::push_forward(const Point<dim> &chart_point) const
{
const double d_hat = chart_point[dim - 1];
-template<int dim>
+template <int dim>
class TranscendentalManufacturedSolution : public Function<dim>
{
public:
return (xh * exp(-xh*xh - yh*yh)) / 10.;
}
-template<int dim>
+template <int dim>
class Geometry: public ChartManifold<dim>
{
public:
virtual Point<dim> push_forward(const Point<dim> &chart_point) const;
};
-template<int dim>
+template <int dim>
Point<dim> Geometry<dim>::pull_back(const Point<dim> &space_point) const
{
const double d = space_point[dim - 1];
return p;
}
-template<int dim>
+template <int dim>
Point<dim> Geometry<dim>::push_forward(const Point<dim> &chart_point) const
{
const double d_hat = chart_point[dim - 1];
return p;
}
-template<int dim>
+template <int dim>
class VectorFunction : public Function<dim>
{
public:
virtual void vector_value(const Point<dim> &p, Vector<double> &values) const;
};
-template<>
+template <>
double VectorFunction<3>::value(const Point<3> &p, const unsigned int component) const
{
return (1 - p(0)*p(0)) * (1 - p(1)*p(1)) * (1 - p(2)*p(2));
}
-template<>
+template <>
double VectorFunction<2>::value(const Point<2> &p, const unsigned int component) const
{
return (1 - p(0)*p(0)) * (1 - p(1)*p(1));
}
-template<int dim>
+template <int dim>
void VectorFunction<dim>::value(const Point<dim> &p, Vector<double> &values) const
{
for (unsigned i = 0; i < values.size(); ++i)
values[i] = value(p, i);
}
-template<int dim>
+template <int dim>
void VectorFunction<dim>::vector_value(const Point<dim> &p, Vector<double> &values) const
{
for (int i = 0; i < dim; ++i)
return y_m;
}
-template<int dim>
+template <int dim>
class PushForward : public Function<dim>
{
public:
};
-template<int dim>
+template <int dim>
double PushForward<dim>::value(const Point<dim> &p,const unsigned int component) const
{
double result = 0;
return result;
}
-template<int dim>
+template <int dim>
class PullBack : public Function<dim>
{
public:
const double y_FoR;
};
-template<int dim>
+template <int dim>
double PullBack<dim>::value(const Point<dim> &p,const unsigned int component) const
{
double result = 0;
-template<int dim>
+template <int dim>
void test2()
{
const HyperBallBoundary<dim> boundary_description;
#include <deal.II/fe/mapping_q1.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
#include <deal.II/fe/mapping_q1.h>
-template<int dim>
+template <int dim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << std::endl;
#include <deal.II/fe/mapping_q.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
#include <deal.II/fe/mapping_q.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
#include <deal.II/fe/mapping_q.h>
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test_real_to_unit_cell()
{
deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
-template<typename MatrixType, typename Number>
+template <typename MatrixType, typename Number>
class MGCoarseIterative : public MGCoarseGridBase<LinearAlgebra::distributed::Vector<Number> >
{
public:
-template<typename MatrixType, typename Number>
+template <typename MatrixType, typename Number>
class MGCoarseIterative : public MGCoarseGridBase<LinearAlgebra::distributed::Vector<Number> >
{
public:
-template<typename MatrixType, typename Number>
+template <typename MatrixType, typename Number>
class MGCoarseIterative : public MGCoarseGridBase<LinearAlgebra::distributed::Vector<Number> >
{
public:
-template<typename MatrixType, typename Number>
+template <typename MatrixType, typename Number>
class MGCoarseIterative : public MGCoarseGridBase<LinearAlgebra::distributed::Vector<Number> >
{
public:
-template<typename MatrixType, typename Number>
+template <typename MatrixType, typename Number>
class MGCoarseIterative : public MGCoarseGridBase<LinearAlgebra::distributed::Vector<Number> >
{
public:
-template<typename MatrixType, typename Number>
+template <typename MatrixType, typename Number>
class MGCoarseIterative : public MGCoarseGridBase<LinearAlgebra::distributed::Vector<Number> >
{
public:
-template<typename MatrixType, typename Number>
+template <typename MatrixType, typename Number>
class MGCoarseIterative : public MGCoarseGridBase<LinearAlgebra::distributed::Vector<Number> >
{
public:
-template<typename MatrixType, typename Number>
+template <typename MatrixType, typename Number>
class MGCoarseIterative : public MGCoarseGridBase<LinearAlgebra::distributed::Vector<Number> >
{
public:
using namespace dealii;
-template<int dim,int spacedim>
+template <int dim,int spacedim>
class TestIntegrator : public MeshWorker::LocalIntegrator<dim,spacedim>
{
public:
{};
};
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
MappingQ1<dim,spacedim> mapping;
#include <fstream>
-template<int dim>
+template <int dim>
void pack_function (const typename parallel::distributed::Triangulation<dim,dim>::cell_iterator &cell,
const typename parallel::distributed::Triangulation<dim,dim>::CellStatus status,
void *data)
++some_number;
}
-template<int dim>
+template <int dim>
void unpack_function (const typename parallel::distributed::Triangulation<dim,dim>::cell_iterator &cell,
const typename parallel::distributed::Triangulation<dim,dim>::CellStatus status,
const void *data)
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
return current_cell_weight++;
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
return 100;
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
return cell_weight;
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
return cell_weight;
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
0);
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
0);
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test(std::ostream & /*out*/)
{
parallel::distributed::Triangulation<dim,spacedim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
const unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
const unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
};
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
const unsigned int myid = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <numeric>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim>
#include <cstdlib>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim>
#include <cstdlib>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim>
#include <numeric>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim>
#include <numeric>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim>
#include <cstdlib>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim>
#include <cstdlib>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim>
#include <numeric>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> triangulation(MPI_COMM_WORLD);
#include <numeric>
-template<int dim>
+template <int dim>
void test(FiniteElement<dim> &fe)
{
deallog << "dim=" << dim << std::endl;
#include <fstream>
using namespace dealii;
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation < dim > tr(MPI_COMM_WORLD);
{
using namespace dealii;
- template<int dim>
+ template <int dim>
class AdvectionProblem
{
public:
- template<int dim>
+ template <int dim>
AdvectionProblem<dim>::AdvectionProblem()
: triangulation(MPI_COMM_WORLD),
fe(1),
p0, p1);
}
- template<int dim>
+ template <int dim>
void AdvectionProblem<dim>::setup_system()
{
dof_handler.distribute_dofs(fe);
- template<int dim>
+ template <int dim>
void AdvectionProblem<dim>::calculate_flux_terms
(const TriaActiveIterator<DoFCellAccessor<DoFHandler<dim>, false> > ¤t_cell,
FEFaceValues<dim> ¤t_face_values,
- template<int dim>
+ template <int dim>
void AdvectionProblem<dim>::assemble_system()
{
const unsigned int dofs_per_cell = fe.dofs_per_cell;
- template<int dim>
+ template <int dim>
void AdvectionProblem<dim>::run()
{
setup_system();
#include <numeric>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim>
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
};
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
};
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
};
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
//#define DISTRIBUTED
-template<int dim>
+template <int dim>
void test_int(const unsigned int n_global = 0,
const unsigned int n_local = 0)
{
};
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <sstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <sstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
};
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
}
};
-template<int dim>
+template <int dim>
void setup(DoFHandler<dim> &dh,
FE_Q<dim> &fe,
LA::MPI::Vector &vec,
lr_vec.reinit(locally_relevant, MPI_COMM_WORLD);
}
-template<int dim>
+template <int dim>
void output(DoFHandler<dim> &dh, LA::MPI::Vector &v, unsigned int loop, const std::string filename_)
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
}
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
public:
template <class DOFINFO>
void initialize_info(DOFINFO &info, bool face) const {}
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info) {}
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info1,
const DOFINFO &info2) {}
// lctrl);
}
-template<int dim>
+template <int dim>
void test_loop(DoFHandler<dim> &dofs, MeshWorker::LoopControl &lctrl)
{
deallog << "* own_cells=" << lctrl.own_cells
test_simple(dofs, lctrl);
}
-template<int dim>
+template <int dim>
void
test()
{
public:
template <class DOFINFO>
void initialize_info(DOFINFO &info, bool face) const {}
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info) {}
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info1,
const DOFINFO &info2) {}
// lctrl);
}
-template<int dim>
+template <int dim>
void test_loop(DoFHandler<dim> &dofs, MeshWorker::LoopControl &lctrl)
{
deallog << "* own_cells=" << lctrl.own_cells
test_simple(dofs, lctrl);
}
-template<int dim>
+template <int dim>
void
test()
{
public:
template <class DOFINFO>
void initialize_info(DOFINFO &info, bool face) const {}
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info) {}
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info1,
const DOFINFO &info2) {}
// lctrl);
}
-template<int dim>
+template <int dim>
void test_loop(DoFHandler<dim> &dofs, MeshWorker::LoopControl &lctrl)
{
deallog << "* own_cells=" << lctrl.own_cells
test_simple(dofs, lctrl);
}
-template<int dim>
+template <int dim>
void
test()
{
public:
template <class DOFINFO>
void initialize_info(DOFINFO &info, bool face) const {}
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info) {}
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info1,
const DOFINFO &info2) {}
// lctrl);
}
-template<int dim>
+template <int dim>
void test_loop(DoFHandler<dim> &dofs, MeshWorker::LoopControl &lctrl)
{
deallog << "* own_cells=" << lctrl.own_cells
test_simple(dofs, lctrl);
}
-template<int dim>
+template <int dim>
void
test()
{
public:
template <class DOFINFO>
void initialize_info(DOFINFO &info, bool face) const {}
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info) {}
- template<class DOFINFO>
+ template <class DOFINFO>
void assemble(const DOFINFO &info1,
const DOFINFO &info2) {}
// lctrl);
}
-template<int dim>
+template <int dim>
void test_loop(DoFHandler<dim> &dofs, MeshWorker::LoopControl &lctrl)
{
deallog << "* own_cells=" << lctrl.own_cells
test_simple(dofs, lctrl);
}
-template<int dim>
+template <int dim>
void
test()
{
}
-template<int dim>
+template <int dim>
void
test(const FiniteElement<dim> &fe)
{
#include <fstream>
-template<int dim>
+template <int dim>
void output(parallel::distributed::Triangulation<dim> &tr)
{
const std::string filename = ("mesh." +
out.write_xfig(tr, stream);
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void output(parallel::distributed::Triangulation<dim> &tr)
{
const std::string filename = ("mesh." +
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void output(parallel::distributed::Triangulation<dim> &tr)
{
const std::string filename = ("mesh." +
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void output(parallel::distributed::Triangulation<dim> &tr)
{
const std::string filename = ("mesh." +
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void output(parallel::distributed::Triangulation<dim> &tr)
{
const std::string filename = ("mg_06/mesh." +
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
#include <sstream>
-template<int dim>
+template <int dim>
void test()
{
Assert (dim == 3, ExcNotImplemented());
#include <fstream>
#include <sstream>
-template<int dim>
+template <int dim>
void test()
{
Assert (dim == 3, ExcNotImplemented());
#include <fstream>
#include <sstream>
-template<int dim>
+template <int dim>
void test()
{
Assert (dim == 3, ExcNotImplemented());
#include <fstream>
#include <sstream>
-template<int dim>
+template <int dim>
void test()
{
Assert (dim == 3, ExcNotImplemented());
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
#include <sstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
#include <sstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <sstream>
-template<int dim>
+template <int dim>
class FilteredDataOut : public DataOut<dim>
{
public:
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
-template<int dim>
+template <int dim>
class FilteredDataOut : public DataOut<dim>
{
public:
}
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <deal.II/fe/fe_q.h>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
#include <ostream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
#include <sstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
#include <sstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
-template<int dim>
+template <int dim>
class FilteredDataOut : public DataOut<dim>
{
public:
}
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
#include <ostream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
#include <ostream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
#include <ostream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <ostream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
#include <ostream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
triangulation.create_triangulation(vertices, cells, SubCellData());
}
-template<int dim>
+template <int dim>
void check
(const unsigned int orientation,
bool reverse)
#include <fstream>
//#include <mpi.h>
-template<class v>
+template <class v>
void testit()
{
GrowingVectorMemory<v> m;
#include <fstream>
#include <iostream>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim> triangulation(MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <boost/concept_check.hpp>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void pack_function (const typename parallel::distributed::Triangulation<dim,dim>::cell_iterator &cell,
const typename parallel::distributed::Triangulation<dim,dim>::CellStatus status,
void *data)
++some_number;
}
-template<int dim>
+template <int dim>
void unpack_function (const typename parallel::distributed::Triangulation<dim,dim>::cell_iterator &cell,
const typename parallel::distributed::Triangulation<dim,dim>::CellStatus status,
const void *data)
}
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <fstream>
-template<int dim>
+template <int dim>
void print_cells(parallel::distributed::Triangulation<dim> &tr)
{
for (typename Triangulation<dim>::active_cell_iterator
deallog << cell->id() << std::endl;
}
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <sstream>
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<2> tria(MPI_COMM_WORLD,
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
#include <cstdlib>
-template<int dim>
+template <int dim>
void test()
{
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
return;
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void f_pre_coarsening_on_cell (const typename Triangulation<dim, spacedim>::cell_iterator &)
{
++signal_counter_pre_coarsening_on_cell;
return;
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void f_post_refinement_on_cell (const typename Triangulation<dim, spacedim>::cell_iterator &)
{
++signal_counter_post_refinement_on_cell;
return;
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void f_copy (const Triangulation<dim, spacedim> &)
{
++signal_counter_copy;
}
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
signal_counter_create = 0;
// calls and then compare the result against n_active_cells reported by Tria
// object. Absolute value change in n_active_cells is not concerned in this test.
-template<int dim, int spacedim>
+template <int dim, int spacedim>
class SignalListener
{
public:
};
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
typedef parallel::distributed::Triangulation<dim, spacedim> TriaType;
// This test is based on tria_signals_02. The difference is here we have random
// and mix refinement and coarsening.
-template<int dim, int spacedim>
+template <int dim, int spacedim>
class SignalListener
{
public:
};
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
typedef parallel::distributed::Triangulation<dim, spacedim> TriaType;
// smoothing flags enabled. Also increase refine fraction to one third to prevent
// refine flags getting smoothed out.
-template<int dim, int spacedim>
+template <int dim, int spacedim>
class SignalListener
{
public:
};
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
typedef parallel::distributed::Triangulation<dim, spacedim> TriaType;
// that p4est is doing mesh smoothing beyond class Triangulation. The case setup
// is borrowed from tests/distributed_grids/2d_refinement_10.
-template<int dim, int spacedim>
+template <int dim, int spacedim>
class SignalListener
{
public:
};
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
typedef parallel::distributed::Triangulation<dim, spacedim> TriaType;
//
// This test is modified from tria_signals_04.
-template<int dim, int spacedim>
+template <int dim, int spacedim>
class SignalListener
{
public:
};
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
typedef parallel::distributed::Triangulation<dim, spacedim> TriaType;
}
}
- template<typename VECTOR>
+ template <typename VECTOR>
class MGCoarseAMG : public MGCoarseGridBase<VECTOR>
{
public:
}
-template<int dim>
+template <int dim>
void refine_mesh (Triangulation<dim> &triangulation)
{
bool cell_refined = false;
}
-template<int dim>
+template <int dim>
void refine_mesh (Triangulation<dim> &triangulation)
{
bool cell_refined = false;
/**
* Apply preconditioner.
*/
- template<typename VectorType>
+ template <typename VectorType>
void vmult (VectorType &, const VectorType &) const;
/**
* the same as
* vmult().
*/
- template<typename VectorType>
+ template <typename VectorType>
void Tvmult (VectorType &, const VectorType &) const;
/**
* Apply preconditioner, adding to the previous value.
*/
- template<typename VectorType>
+ template <typename VectorType>
void vmult_add (VectorType &, const VectorType &) const;
/**
* the same as
* vmult_add().
*/
- template<typename VectorType>
+ template <typename VectorType>
void Tvmult_add (VectorType &, const VectorType &) const;
private:
//----------------------------------------------------------------------//
-template<typename number>
+template <typename number>
ScalingMatrix<number>::ScalingMatrix(number factor)
:
factor(factor)
{}
-template<typename number>
-template<typename VectorType>
+template <typename number>
+template <typename VectorType>
inline void
ScalingMatrix<number>::vmult (VectorType &dst, const VectorType &src) const
{
dst.equ(factor, src);
}
-template<typename number>
-template<typename VectorType>
+template <typename number>
+template <typename VectorType>
inline void
ScalingMatrix<number>::Tvmult (VectorType &dst, const VectorType &src) const
{
dst.equ(factor, src);
}
-template<typename number>
-template<typename VectorType>
+template <typename number>
+template <typename VectorType>
inline void
ScalingMatrix<number>::vmult_add (VectorType &dst, const VectorType &src) const
{
-template<typename number>
-template<typename VectorType>
+template <typename number>
+template <typename VectorType>
inline void
ScalingMatrix<number>::Tvmult_add (VectorType &dst, const VectorType &src) const
{
//----------------------------------------------------------------------//
-template<typename MatrixType, class RELAX>
+template <typename MatrixType, class RELAX>
void check_smoother(const MGLevelObject<MatrixType> &m,
const MGLevelObject<RELAX> &r)
{
}
-template<int dim>
+template <int dim>
void refine_mesh (Triangulation<dim> &triangulation)
{
bool cell_refined = false;
}
-template<int dim>
+template <int dim>
void refine_mesh (Triangulation<dim> &triangulation)
{
bool cell_refined = false;
}
-template<int dim>
+template <int dim>
void refine_mesh (Triangulation<dim> &triangulation)
{
bool cell_refined = false;
}
-template<int dim>
+template <int dim>
void refine_mesh (Triangulation<dim> &triangulation)
{
bool cell_refined = false;
}
-template<int dim>
+template <int dim>
void refine_mesh (Triangulation<dim> &triangulation)
{
bool cell_refined = false;
}
-template<int dim>
+template <int dim>
void refine_mesh (Triangulation<dim> &triangulation)
{
bool cell_refined = false;
}
-template<int dim>
+template <int dim>
void refine_mesh (Triangulation<dim> &triangulation)
{
bool cell_refined = false;
}
-template<int dim>
+template <int dim>
void refine_mesh (Triangulation<dim> &triangulation)
{
bool cell_refined = false;
}
-template<int dim>
+template <int dim>
void refine_mesh (Triangulation<dim> &triangulation)
{
bool cell_refined = false;
}
-template<int dim>
+template <int dim>
void refine_mesh (Triangulation<dim> &triangulation)
{
bool cell_refined = false;
using namespace std;
-template<int dim>
+template <int dim>
void refine_mesh (Triangulation<dim> &triangulation)
{
bool cell_refined = false;
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <deal.II/fe/fe_dgq.h>
-template<int dim>
+template <int dim>
class FilteredDataOut : public DataOut<dim>
{
public:
const double a=4,b=5;
-template<int dim>
+template <int dim>
class MyFunction : public Function<dim>
{
public:
const double a=4,b=5;
-template<int dim>
+template <int dim>
class MyFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
using namespace dealii;
-template<int dim>
+template <int dim>
class MyFunction : public dealii::Function<dim>
{
public:
const double k;
};
-template<int dim>
+template <int dim>
MyFunction<dim>::MyFunction(const double k)
:
dealii::Function<dim>(1),
}
-template<int dim>
+template <int dim>
double MyFunction<dim>::value(const dealii::Point<dim> &point,
const unsigned int ) const
{
return k * x;
}
-template<int dim>
+template <int dim>
double MyFunction<dim>::get_k() const
{
return k;
}
// neuman bc
-template<int dim>
+template <int dim>
class NeumanBC : public dealii::Function<dim>
{
public:
const double c;
};
-template<int dim>
+template <int dim>
NeumanBC<dim>::NeumanBC(const double c)
:
dealii::Function<dim>(1),
{
}
-template<int dim>
+template <int dim>
double NeumanBC<dim>::value(const dealii::Point<dim> &point,
const unsigned int ) const
{
return c;
}
-template<int dim>
+template <int dim>
double NeumanBC<dim>::get_c() const
{
return c;
// helper function to get diagonal and
// area of the squared element with lenght h
-template<int dim>
+template <int dim>
void get_h_area(double &h, double &a, const double L);
-template<>
+template <>
void get_h_area<2>(double &h, double &a, const double L)
{
h = L;
a = L;
}
-template<>
+template <>
void get_h_area<3>(double &h, double &a, const double L)
{
h = std::sqrt(2.0)*L;
// helper function to get diagonal and area of the
// h-refined face.
-template<int dim>
+template <int dim>
void get_h_area_sub(double &h, double &a, const double L);
-template<>
+template <>
void get_h_area_sub<2>(double &h, double &a, const double L)
{
h = L/2;
a = L/2;
}
-template<>
+template <>
void get_h_area_sub<3>(double &h, double &a, const double L)
{
h = std::sqrt(2.0)*L/2;
}
// output for inspection
-template<int dim>
+template <int dim>
void output(const std::string name,
const Triangulation<dim> &triangulation,
const hp::DoFHandler<dim> &dof_handler,
}
// case 1)
-template<int dim>
+template <int dim>
void test_neumann(const NeumanBC<dim> &func)
{
deallog << "NeumanBC case:"<<std::endl;
}
// case 2)
-template<int dim>
+template <int dim>
void test_regular(const MyFunction<dim> &func)
{
deallog << std::endl;
}
// case 3)
-template<int dim>
+template <int dim>
void test_irregular(const MyFunction<dim> &func)
{
deallog << std::endl;
dof_handler.clear();
}
-template<int dim>
+template <int dim>
class MySecondFunction : public dealii::Function<dim>
{
public:
const unsigned int component = 0 ) const;
};
-template<int dim>
+template <int dim>
MySecondFunction<dim>::MySecondFunction()
:
dealii::Function<dim>(1)
}
-template<int dim>
+template <int dim>
double MySecondFunction<dim>::value(const dealii::Point<dim> &point,
const unsigned int ) const
{
return (1.-x)*(1.-y)*(1.-y)+std::pow(1.0-y,4)*std::exp(-x);
}
-template<int dim>
+template <int dim>
void test(const MySecondFunction<dim> &func)
{
deallog << std::endl;
#include <fstream>
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
#include <fstream>
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
#include <fstream>
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
#include <fstream>
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const hp::FECollection<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const hp::FECollection<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
#include <fstream>
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const hp::FECollection<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const hp::FECollection<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const hp::FECollection<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
#include <fstream>
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
#include <fstream>
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
-template<int dim>
+template <int dim>
void test_hyper_sphere()
{
Triangulation<dim> tr;
#include <fstream>
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const hp::FECollection<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
#include <fstream>
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
};
-template<int dim>
+template <int dim>
void test()
{
// create 2 triangulations with the
};
-template<int dim>
+template <int dim>
void test()
{
HyperBallBoundary<dim> boundary;
};
-template<int dim>
+template <int dim>
void test()
{
// create 2 triangulations with the
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
/**
* A vector-valued polynomial for testing RT elements.
*/
-template<int dim>
+template <int dim>
class TestFunction : public Function<dim>
{
public:
};
-template<int dim>
+template <int dim>
TestFunction<dim>::TestFunction (unsigned int p)
:
Function<dim>(dim), degree(p)
{}
-template<int dim>
+template <int dim>
void
TestFunction<dim>::vector_value_list (const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const
-template<int dim>
+template <int dim>
double integrate_error(const DoFHandler<dim> &dof,
FEFaceValues<dim> &fe,
const Vector<double> &u,
}
-template<int dim>
+template <int dim>
void test_projection (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void test_hyper_cube(const FiniteElement<dim> &fe)
{
Triangulation<dim> tr;
#include <fstream>
-template<int dim>
+template <int dim>
void test (const Triangulation<dim> &tr,
const FiniteElement<dim> &fe)
{
}
-template<int dim>
+template <int dim>
void test_hyper_cube()
{
Triangulation<dim> tr;
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <fstream>
-template<int dim>
+template <int dim>
class MySquareFunction : public Function<dim>
{
public:
#include <vector>
-template<typename MatrixType>
+template <typename MatrixType>
void test (MatrixType &m)
{
m.add(0,0,1);
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve(SolverType &solver,
const SolverControl &solver_control,
using namespace dealii;
-template<int dim>
+template <int dim>
void test (const unsigned int poly_degree = 1)
{
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template <class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
void
check_solve( SOLVER &solver, const MATRIX &A,
VECTOR &u, VECTOR &f, const PRECONDITION &P)
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template <class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
void
check_solve( SOLVER &solver, const MATRIX &A,
VECTOR &u, VECTOR &f, const PRECONDITION &P)
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template <class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
void
check_solve( SOLVER &solver, const MATRIX &A,
VECTOR &u, VECTOR &f, const PRECONDITION &P)
using namespace dealii::Physics;
using namespace dealii::Physics::Elasticity;
-template<int dim>
+template <int dim>
void
test_kinematic_tensors ()
{
// where I1 = I1(C), I2 = I2(C)
// Then dI1/dC = I and dI2/dC = I1.I - C
// and S = 2 dpsi/dC
-template<int dim>
+template <int dim>
SymmetricTensor<2,dim>
get_S (const Tensor<2,dim> &F)
{
// For isotropic media, tau = 2.b.dpsi/db == 2.dpsi/db . b
// where b = F.F^{T}, I1(b) == I1(C) and
// I2(b) == I2(C)
-template<int dim>
+template <int dim>
SymmetricTensor<2,dim>
get_tau (const Tensor<2,dim> &F)
{
return symmetrize(static_cast< Tensor<2,dim> >(tmp)*static_cast< Tensor<2,dim> >(b));
}
-template<int dim>
+template <int dim>
void
test_standard_tensors ()
{
using namespace dealii;
-template<int dim>
+template <int dim>
void test()
{
parallel::distributed::Triangulation<dim>
#include <deal.II/distributed/shared_tria.h>
#include <deal.II/grid/grid_generator.h>
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> tr1;
#include <numeric>
-template<int dim>
+template <int dim>
void test()
{
parallel::shared::Triangulation<dim>
#include <numeric>
-template<int dim>
+template <int dim>
void test()
{
parallel::shared::Triangulation<dim>
#include <numeric>
-template<int dim>
+template <int dim>
void test()
{
parallel::shared::Triangulation<dim>
#include <numeric>
-template<int dim>
+template <int dim>
void test()
{
parallel::shared::Triangulation<dim>
-template<int dim>
+template <int dim>
void test()
{
parallel::shared::Triangulation<dim> tr(MPI_COMM_WORLD);
-template<int dim>
+template <int dim>
void test()
{
parallel::shared::Triangulation<dim> tr(MPI_COMM_WORLD,
}
}
-template<int dim>
+template <int dim>
void test()
{
parallel::shared::Triangulation<dim> shared_tria(MPI_COMM_WORLD,typename Triangulation<dim>::MeshSmoothing
}
}
-template<int dim>
+template <int dim>
void test()
{
parallel::shared::Triangulation<dim> shared_tria(MPI_COMM_WORLD,typename Triangulation<dim>::MeshSmoothing
#include <sstream>
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
Triangulation<dim> tr1;
}
-template<int dim>
+template <int dim>
void test()
{
parallel::shared::Triangulation<dim> shared_tria(MPI_COMM_WORLD,typename Triangulation<dim>::MeshSmoothing
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
parallel::shared::Triangulation<dim> shared_tria(MPI_COMM_WORLD,typename Triangulation<dim>::MeshSmoothing
}
-template<int dim>
+template <int dim>
void test()
{
parallel::shared::Triangulation<dim> shared_tria(MPI_COMM_WORLD,typename Triangulation<dim>::MeshSmoothing
#include <fstream>
-template<int dim>
+template <int dim>
void test()
{
parallel::shared::Triangulation<dim> shared_tria(MPI_COMM_WORLD,typename Triangulation<dim>::MeshSmoothing
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType>
+template <typename SolverType, typename MatrixType, typename VectorType>
void
check_solve( SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType>
+template <typename SolverType, typename MatrixType, typename VectorType>
void
check_solve( SolverType &solver,
const unsigned int solver_number,
}
-template<typename MatrixType>
+template <typename MatrixType>
inline
void
FDDiagMatrix::diag(MatrixType &A) const
}
}
-template<typename number>
+template <typename number>
inline
void
FDDiagMatrix::gnuplot_print(std::ostream &s, const Vector<number> &V) const
}
-template<typename MatrixType>
+template <typename MatrixType>
inline
void
FD1DLaplaceMatrix::three_point(MatrixType &A) const
-template<typename MatrixType>
+template <typename MatrixType>
void
FDMatrix::nine_point(MatrixType &A, bool) const
{
}
}
-template<typename MatrixType>
+template <typename MatrixType>
inline
void
FDMatrix::five_point(MatrixType &A, bool nonsymmetric) const
-template<typename MatrixType>
+template <typename MatrixType>
inline
void
FDMatrix::upwind(MatrixType &A, bool back) const
}
}
-template<typename number>
+template <typename number>
inline
void
FDMatrix::gnuplot_print(std::ostream &s, const Vector<number> &V) const
}
#endif
-template<typename number>
+template <typename number>
number get_real_assert_zero_imag(const std::complex<number> &a)
{
Assert (a.imag() == 0.0, ExcInternalError());
return a.real();
}
-template<typename number>
+template <typename number>
number get_real_assert_zero_imag(const number &a)
{
return a;
#include <vector>
-template<typename MatrixType>
+template <typename MatrixType>
void test (MatrixType &m)
{
m.set(0,0,1.);
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverType &solver,
const SolverControl &solver_control,
{
using namespace dealii;
- template<int dim>
+ template <int dim>
class AdvectionProblem
{
public:
- template<int dim>
+ template <int dim>
AdvectionProblem<dim>::AdvectionProblem()
: n_mpi_processes (Utilities::MPI::n_mpi_processes(MPI_COMM_WORLD)),
this_mpi_process (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)),
p0, p1);
}
- template<int dim>
+ template <int dim>
void AdvectionProblem<dim>::setup_system ()
{
dof_handler.distribute_dofs(fe);
- template<int dim>
+ template <int dim>
void AdvectionProblem<dim>::calculate_flux_terms
(const TriaActiveIterator<DoFCellAccessor<DoFHandler<dim>, false> > ¤t_cell,
FEFaceValues<dim> ¤t_face_values,
}
- template<int dim>
+ template <int dim>
void AdvectionProblem<dim>::assemble_system()
{
const unsigned int dofs_per_cell = fe.dofs_per_cell;
}
- template<int dim>
+ template <int dim>
void AdvectionProblem<dim>::run()
{
setup_system();
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename SolverType, typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverType &solver,
const SolverControl &solver_control,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverControl &solver_control,
const MatrixType &A,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverControl &solver_control,
const MatrixType &A,
#include <deal.II/lac/vector_memory.h>
#include <typeinfo>
-template<typename MatrixType, typename VectorType, class PRECONDITION>
+template <typename MatrixType, typename VectorType, class PRECONDITION>
void
check_solve (SolverControl &solver_control,
const MatrixType &A,
using namespace dealii;
-template<typename MATRIX>
+template <typename MATRIX>
void out_matrix_size(const MATRIX &M,
const std::string &name)
{
projects / dealii.git / commitdiff