// $Id$
// Version: $Name$
//
-// Copyright (C) 2001, 2002 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* 1/sqrt(2)
*/
static const double SQRT1_2 = 0.70710678118654752440;
-};
+}
#endif
DataOutBase::EpsFlags::RgbValues::is_grey () const
{
return (red == green) && (red == blue);
-};
+}
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
}
-};
+}
<< arg1 << " switch. You should either use an\n"
<< "alternative function, or configure again without\n"
<< "this switch and recompile the library.");
-};
+}
using namespace StandardExceptions;
FunctionTime::get_time () const
{
return time;
-};
+}
#endif
// the two operator<< functions
print (t);
return *this;
-};
+}
was_endl = true;
return *this;
-};
+}
unsigned int memory_consumption (const bool)
{
return sizeof(bool);
- };
+ }
unsigned int memory_consumption (const char)
{
return sizeof(char);
- };
+ }
unsigned int memory_consumption (const short int)
{
return sizeof(short int);
- };
+ }
unsigned int memory_consumption (const short unsigned int)
{
return sizeof(short unsigned int);
- };
+ }
unsigned int memory_consumption (const int)
{
return sizeof(int);
- };
+ }
unsigned int memory_consumption (const unsigned int)
{
return sizeof(unsigned int);
- };
+ }
unsigned int memory_consumption (const float)
{
return sizeof(float);
- };
+ }
unsigned int memory_consumption (const double)
{
return sizeof(double);
- };
+ }
unsigned int memory_consumption (const std::string &s)
{
return sizeof(s) + s.length();
- };
+ }
// if necessary try to work around a bug in the IBM xlC compiler
*/
virtual PatternBase * clone () const;
};
-};
+}
/**
template <int dim>
inline
Point<dim>::Point ()
-{};
+{}
inline
Point<dim>::Point (const bool initialize) :
Tensor<1,dim>(initialize)
-{};
+{}
inline
Point<dim>::Point (const Tensor<1,dim> &t) :
Tensor<1,dim>(t)
-{};
+{}
{
Assert (dim==1, ExcInvalidConstructorCalled());
this->values[0] = x;
-};
+}
Assert (dim==2, ExcInvalidConstructorCalled());
this->values[0] = x;
this->values[1] = y;
-};
+}
this->values[0] = x;
this->values[1] = y;
this->values[2] = z;
-};
+}
{
Assert (index<dim, ExcIndexRange (index, 0, dim));
return this->values[index];
-};
+}
{
Assert (index<dim, ExcIndexRange (index, 0, dim));
return this->values[index];
-};
+}
Point<dim> Point<dim>::operator + (const Tensor<1,dim> &p) const
{
return (Point<dim>(*this) += p);
-};
+}
Point<dim> Point<dim>::operator - (const Tensor<1,dim> &p) const
{
return (Point<dim>(*this) -= p);
-};
+}
for (unsigned int i=0; i<dim; ++i)
result.values[i] = -this->values[i];
return result;
-};
+}
Point<dim> Point<dim>::operator * (const double factor) const
{
return (Point<dim>(*this) *= factor);
-};
+}
{
// simply pass down
return Tensor<1,dim>::operator * (p);
-};
+}
template <int dim>
for (unsigned int i=0; i<dim; ++i)
q += this->values[i] * this->values[i];
return q;
-};
+}
template <int dim>
Point<dim> Point<dim>::operator / (const double factor) const
{
return (Point<dim>(*this) /= factor);
-};
+}
Point<dim> operator * (const double factor, const Point<dim> &p)
{
return p*factor;
-};
+}
/**
out << p[dim-1];
return out;
-};
+}
out << p[0];
return out;
-};
+}
#endif
template <typename T>
SmartPointer<T>::SmartPointer () :
t (0)
-{};
+{}
{
if (t != 0)
t->subscribe();
-};
+}
{
if (t != 0)
t->subscribe();
-};
+}
{
if (t != 0)
t->unsubscribe();
-};
+}
if (tt != 0)
tt->subscribe();
return *this;
-};
+}
if (tt != 0)
tt->subscribe();
return *this;
-};
+}
SmartPointer<T>::operator T* () const
{
return t;
-};
+}
T & SmartPointer<T>::operator * () const
{
return *t;
-};
+}
T * SmartPointer<T>::operator -> () const
{
return t;
-};
+}
void SmartPointer<T>::swap (SmartPointer<T> &tt)
{
swap (t, tt.t);
-};
+}
if (t != 0)
t->subscribe ();
-};
+}
unsigned int SmartPointer<T>::memory_consumption () const
{
return sizeof(SmartPointer<T>);
-};
+}
void swap (SmartPointer<T> &t1, SmartPointer<T> &t2)
{
t1.swap (t2);
-};
+}
void swap (SmartPointer<T> &t1, T *&t2)
{
t1.swap (t2);
-};
+}
void swap (T *&t1, SmartPointer<T> &t2)
{
t2.swap (t1);
-};
+}
#endif
friend class Accessor<N,T,C,2>;
#endif
};
-};
+}
{
Assert (i < N, ExcIndexRange (i, 0, N));
return indices[i];
-};
+}
TableIndices<1>::TableIndices ()
{
this->indices[0] = 0;
-};
+}
TableIndices<1>::TableIndices (const unsigned int index1)
{
this->indices[0] = index1;
-};
+}
TableIndices<2>::TableIndices ()
{
this->indices[0] = this->indices[1] = 0;
-};
+}
{
this->indices[0] = index1;
this->indices[1] = index2;
-};
+}
TableIndices<3>::TableIndices ()
{
this->indices[0] = this->indices[1] = this->indices[2] = 0;
-};
+}
this->indices[0] = index1;
this->indices[1] = index2;
this->indices[2] = index3;
-};
+}
inline
TableIndices<4>::TableIndices ()
{
this->indices[0] = this->indices[1] = this->indices[2] = this->indices[3] = 0;
-};
+}
this->indices[1] = index2;
this->indices[2] = index3;
this->indices[3] = index4;
-};
+}
TableIndices<5>::TableIndices ()
{
this->indices[0] = this->indices[1] = this->indices[2] = this->indices[3] = this->indices[4] = 0;
-};
+}
this->indices[2] = index3;
this->indices[3] = index4;
this->indices[4] = index5;
-};
+}
{
this->indices[0] = this->indices[1] = this->indices[2]
= this->indices[3] = this->indices[4] = 0;
-};
+}
this->indices[3] = index4;
this->indices[4] = index5;
this->indices[5] = index6;
-};
+}
:
val (0),
val_size (0)
-{};
+{}
val_size (0)
{
reinit (sizes);
-};
+}
reinit (src.table_size);
if (src.n_elements() != 0)
fill (src.data());
-};
+}
reinit (src.table_size);
if (src.n_elements() != 0)
fill (src.data());
-};
+}
:
table (table),
data (data)
- {};
+ {}
// temporary objects, so should
// not need to be copied around
Assert (false, ExcInternalError());
- };
+ }
// temporary objects, so should
// not need to be copied around
Assert (false, ExcInternalError());
- };
+ }
const pointer new_data = data + i*subobject_size;
return Accessor<N,T,C,P-1> (table, new_data);
};
- };
+ }
:
table (table),
data (data)
- {};
+ {}
// temporary objects, so should
// not need to be copied around
Assert (false, ExcInternalError());
- };
+ }
// temporary objects, so should
// not need to be copied around
Assert (false, ExcInternalError());
- };
+ }
Assert (i < table.size()[N-1],
ExcIndexRange (i, 0, table.size()[N-1]));
return data[i];
- };
+ }
Accessor<N,T,C,1>::size () const
{
return table.size()[N-1];
- };
+ }
Accessor<N,T,C,1>::begin () const
{
return data;
- };
+ }
Accessor<N,T,C,1>::end () const
{
return data+table.size()[N-1];
- };
-};
+ }
+}
{
if (val != 0)
delete[] val;
-};
+}
{
if (n_elements() != 0)
std::fill_n (val, n_elements(), T());
-};
+}
// reinitialize contents of old or
// new memory.
clear ();
-};
+}
TableBase<N,T>::size () const
{
return table_size;
-};
+}
for (unsigned int n=0; n<N; ++n)
s *= table_size[n];
return s;
-};
+}
TableBase<N,T>::empty () const
{
return (n_elements() == 0);
-};
+}
return s;
};
};
-};
+}
Assert (indices[n] < table_size[n],
ExcIndexRange (indices[n], 0, table_size[n]));
return el(indices);
-};
+}
Assert (indices[n] < table_size[n],
ExcIndexRange (indices[n], 0, table_size[n]));
return el(indices);
-};
+}
TableBase<N,T>::el (const TableIndices<N> &indices) const
{
return val[position(indices)];
-};
+}
TableBase<N,T>::el (const TableIndices<N> &indices)
{
return val[position(indices)];
-};
+}
template <typename T>
Table<1,T>::Table ()
-{};
+{}
Table<1,T>::Table (const unsigned int size)
:
TableBase<1,T> (TableIndices<1> (size))
-{};
+{}
Assert (i < this->table_size[0],
ExcIndexRange (i, 0, this->table_size[0]));
return this->val[i];
-};
+}
Assert (i < this->table_size[0],
ExcIndexRange (i, 0, this->table_size[0]));
return this->val[i];
-};
+}
Assert (i < this->table_size[0],
ExcIndexRange (i, 0, this->table_size[0]));
return this->val[i];
-};
+}
Assert (i < this->table_size[0],
ExcIndexRange (i, 0, this->table_size[0]));
return this->val[i];
-};
+}
template <typename T>
Table<2,T>::Table ()
-{};
+{}
const unsigned int size2)
:
TableBase<2,T> (TableIndices<2> (size1, size2))
-{};
+{}
const unsigned int size2)
{
this->TableBase<2,T>::reinit (TableIndices<2> (size1, size2));
-};
+}
ExcIndexRange (i, 0, this->table_size[0]));
return TableBaseAccessors::Accessor<2,T,true,1>(*this,
this->val+i*n_cols());
-};
+}
ExcIndexRange (i, 0, this->table_size[0]));
return TableBaseAccessors::Accessor<2,T,false,1>(*this,
this->val+i*n_cols());
-};
+}
Assert (j < this->table_size[1],
ExcIndexRange (j, 0, this->table_size[1]));
return this->val[i*this->table_size[1]+j];
-};
+}
Assert (j < this->table_size[1],
ExcIndexRange (j, 0, this->table_size[1]));
return this->val[i*this->table_size[1]+j];
-};
+}
const unsigned int j) const
{
return this->val[i*this->table_size[1]+j];
-};
+}
const unsigned int j)
{
return this->val[i*this->table_size[1]+j];
-};
+}
Table<2,T>::n_rows () const
{
return this->table_size[0];
-};
+}
Table<2,T>::n_cols () const
{
return this->table_size[1];
-};
+}
template <typename T>
Table<3,T>::Table ()
-{};
+{}
const unsigned int size3)
:
TableBase<3,T> (TableIndices<3> (size1, size2, size3))
-{};
+{}
return (TableBaseAccessors::Accessor<3,T,true,2>
(*this,
this->val+i*subobject_size));
-};
+}
return (TableBaseAccessors::Accessor<3,T,false,2>
(*this,
this->val+i*subobject_size));
-};
+}
ExcIndexRange (k, 0, this->table_size[2]));
return this->val[(i*this->table_size[1]+j)
*this->table_size[2] + k];
-};
+}
ExcIndexRange (k, 0, this->table_size[2]));
return this->val[(i*this->table_size[1]+j)
*this->table_size[2] + k];
-};
+}
template <typename T>
Table<4,T>::Table ()
-{};
+{}
const unsigned int size4)
:
TableBase<4,T> (TableIndices<4> (size1, size2, size3, size4))
-{};
+{}
return (TableBaseAccessors::Accessor<4,T,true,3>
(*this,
this->val+i*subobject_size));
-};
+}
return (TableBaseAccessors::Accessor<4,T,false,3>
(*this,
this->val+i*subobject_size));
-};
+}
return this->val[((i*this->table_size[1]+j)
*this->table_size[2] + k)
*this->table_size[3] + l];
-};
+}
return this->val[((i*this->table_size[1]+j)
*this->table_size[2] + k)
*this->table_size[3] + l];
-};
+}
template <typename T>
Table<5,T>::Table ()
-{};
+{}
const unsigned int size5)
:
TableBase<5,T> (TableIndices<5> (size1, size2, size3, size4, size5))
-{};
+{}
return (TableBaseAccessors::Accessor<5,T,true,4>
(*this,
this->val+i*subobject_size));
-};
+}
return (TableBaseAccessors::Accessor<5,T,false,4>
(*this,
this->val+i*subobject_size));
-};
+}
*this->table_size[2] + k)
*this->table_size[3] + l)
*this->table_size[4] + m];
-};
+}
*this->table_size[2] + k)
*this->table_size[3] + l)
*this->table_size[4] + m];
-};
+}
template <typename T>
Table<6,T>::Table ()
-{};
+{}
const unsigned int size6)
:
TableBase<6,T> (TableIndices<6> (size1, size2, size3, size4, size5, size6))
-{};
+{}
return (TableBaseAccessors::Accessor<6,T,true,5>
(*this,
this->val+i*subobject_size));
-};
+}
return (TableBaseAccessors::Accessor<6,T,false,5>
(*this,
this->val+i*subobject_size));
-};
+}
*this->table_size[3] + l)
*this->table_size[4] + m)
*this->table_size[5] + n];
-};
+}
*this->table_size[3] + l)
*this->table_size[4] + m)
*this->table_size[5] + n];
-};
+}
// default constructor. not specifying an initializer list calls
// the default constructor of the subobjects, which initialize them
// selves. therefore, the tensor is set to zero this way
-};
+}
template <int rank_, int dim>
{
for (unsigned int i=0; i<dim; ++i)
subtensor[i] = Tensor<rank_-1,dim>(initializer[i]);
-};
+}
template <int rank_, int dim>
Assert (i<dim, ExcIndexRange(i, 0, dim));
return subtensor[i];
-};
+}
template <int rank_, int dim>
Assert (i<dim, ExcIndexRange(i, 0, dim));
return subtensor[i];
-};
+}
template <int rank_, int dim>
for (unsigned int i=0; i<dim; ++i)
subtensor[i] = t.subtensor[i];
return *this;
-};
+}
template <int rank_, int dim>
for (unsigned int i=0; i<dim; ++i)
if (subtensor[i] != p.subtensor[i]) return false;
return true;
-};
+}
template <int rank_, int dim>
Tensor<rank_,dim>::operator != (const Tensor<rank_,dim> &p) const
{
return !((*this) == p);
-};
+}
template <int rank_, int dim>
for (unsigned int i=0; i<dim; ++i)
subtensor[i] += p.subtensor[i];
return *this;
-};
+}
template <int rank_, int dim>
for (unsigned int i=0; i<dim; ++i)
subtensor[i] -= p.subtensor[i];
return *this;
-};
+}
template <int rank_, int dim>
for (unsigned int i=0; i<dim; ++i)
subtensor[i] *= s;
return *this;
-};
+}
template <int rank_, int dim>
for (unsigned int i=0; i<dim; ++i)
subtensor[i] /= s;
return *this;
-};
+}
template <int rank_, int dim>
tmp.subtensor[i] += t.subtensor[i];
return tmp;
-};
+}
template <int rank_, int dim>
tmp.subtensor[i] -= t.subtensor[i];
return tmp;
-};
+}
template <int rank_, int dim>
tmp.subtensor[i] = -subtensor[i];
return tmp;
-};
+}
template <int rank_, int dim>
{
for (unsigned int i=0; i<dim; ++i)
subtensor[i].clear();
-};
+}
Tensor<rank_,dim>::memory_consumption ()
{
return sizeof(Tensor<rank_,dim>);
-};
+}
/* ----------------- Non-member functions operating on tensors. ------------ */
out << p[dim-1];
return out;
-};
+}
/**
out << p[0];
return out;
-};
+}
for (unsigned int i=0; i<dim; ++i)
for (unsigned int j=0; j<dim; ++j)
dest[i] += src1[i][j] * src2[j];
-};
+}
for (unsigned int i=0; i<dim; ++i)
for (unsigned int j=0; j<dim; ++j)
dest[i] += src1[j] * src2[j][i];
-};
+}
for (unsigned int j=0; j<dim; ++j)
for (unsigned int k=0; k<dim; ++k)
dest[i][j] += src1[i][k] * src2[k][j];
-};
+}
default:
Assert (false, (typename Tensor<2,dim>::ExcInvalidTensorIndex (index1)));
};
-};
+}
Assert (false,
(typename Tensor<2,dim>::ExcInvalidTensorIndex (index1)));
};
-};
+}
for (unsigned int k=0; k<dim; ++k)
for (unsigned int l=0; l<dim; ++l)
dest[i][j][k] += src1[i][j][l] * src2[l][k];
-};
+}
for (unsigned int k=0; k<dim; ++k)
for (unsigned int l=0; l<dim; ++l)
dest[i][j][k] += src1[i][l] * src2[l][j][k];
-};
+}
/**
for (unsigned int l=0; l<dim; ++l)
for (unsigned int m=0; m<dim; ++m)
dest[i][j][k][l] += src1[i][j][m] * src2[m][k][l];
-};
+}
for (unsigned int i=0; i<dim; ++i)
for (unsigned int j=0; j<dim; ++j)
dst[i][j] = src1[i] * src2[j];
-};
+}
for (unsigned int j=0; j<dim; ++j)
for (unsigned int k=0; k<dim; ++k)
dst[i][j][k] = src1[i] * src2[j][k];
-};
+}
for (unsigned int j=0; j<dim; ++j)
for (unsigned int k=0; k<dim; ++k)
dst[i][j][k] = src1[i][j] * src2[k];
-};
+}
{
for (unsigned int i=0; i<dim; ++i)
dst[i] = src1 * src2[i];
-};
+}
{
for (unsigned int i=0; i<dim; ++i)
dst[i] = src1[i] * src2;
-};
+}
// computable in the general
// template
return determinant(t[0]);
-};
+}
double determinant (const Tensor<1,1> &t)
{
return t[0];
-};
+}
{
return ((t[0][0] * t[1][1]) -
(t[1][0] * t[0][1]));
-};
+}
+t[1][0]*t[0][2]*t[2][1]
+t[2][0]*t[0][1]*t[1][2]
-t[2][0]*t[0][2]*t[1][1] );
-};
+}
for (unsigned int i=0; i<dim; ++i)
t += d[i][i];
return t;
-};
+}
AssertThrow (false, ExcNotImplemented());
};
return return_tensor;
-};
+}
tt[j][i] = x;
};
return tt;
-};
+}
transpose (const Tensor<2,1> &t)
{
return t;
-};
+}
{
const double x[2][2] = {{t[0][0], t[1][0]}, {t[0][1], t[1][1]}};
return Tensor<2,2>(x);
-};
+}
{t[0][1], t[1][1], t[2][1]},
{t[0][2], t[1][2], t[2][2]}};
return Tensor<2,3>(x);
-};
+}
Tensor<rank,dim> tt = t;
tt *= factor;
return tt;
-};
+}
Tensor<rank,dim> tt = t;
tt *= factor;
return tt;
-};
+}
Tensor<rank,dim> tt = t;
tt /= factor;
return tt;
-};
+}
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002 by the deal authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
if (initialize)
for (unsigned int i=0; i!=dim; ++i)
values[i] = 0;
-};
+}
{
for (unsigned int i=0; i<dim; ++i)
values[i] = initializer[i];
-};
+}
{
for (unsigned int i=0; i<dim; ++i)
values[i] = p.values[i];
-};
+}
// function that the loop end check
// always fails, we implement this
// function here
-};
+}
{
Assert (index<dim, ExcIndexRange (index, 0, dim));
return values[index];
-};
+}
{
Assert (index<dim, ExcIndexRange (index, 0, dim));
return values[index];
-};
+}
for (unsigned int i=0; i<dim; ++i)
values[i] = p.values[i];
return *this;
-};
+}
// always fails, we implement this
// function here
return *this;
-};
+}
for (unsigned int i=0; i<dim; ++i)
if (values[i] != p.values[i]) return false;
return true;
-};
+}
bool Tensor<1,dim>::operator != (const Tensor<1,dim> &p) const
{
return !((*this) == p);
-};
+}
for (unsigned int i=0; i<dim; ++i)
values[i] += p.values[i];
return *this;
-};
+}
for (unsigned int i=0; i<dim; ++i)
values[i] -= p.values[i];
return *this;
-};
+}
for (unsigned int i=0; i<dim; ++i)
values[i] *= s;
return *this;
-};
+}
for (unsigned int i=0; i<dim; ++i)
values[i] /= s;
return *this;
-};
+}
for (unsigned int i=0; i<dim; ++i)
q += values[i] * p.values[i];
return q;
-};
+}
Tensor<1,dim> Tensor<1,dim>::operator + (const Tensor<1,dim> &p) const
{
return (Tensor<1,dim>(*this) += p);
-};
+}
Tensor<1,dim> Tensor<1,dim>::operator - (const Tensor<1,dim> &p) const
{
return (Tensor<1,dim>(*this) -= p);
-};
+}
for (unsigned int i=0; i<dim; ++i)
result.values[i] = -values[i];
return result;
-};
+}
{
for (unsigned int i=0; i<dim; ++i)
values[i] = 0;
-};
+}
Tensor<1,dim>::memory_consumption ()
{
return sizeof(Tensor<1,dim>);
-};
+}
out << p[dim-1];
return out;
-};
+}
out << p[0];
return out;
-};
+}
for (unsigned int d=0; d<dim; ++d)
tt[d] = t[d] * factor;
return tt;
-};
+}
for (unsigned int d=0; d<dim; ++d)
tt[d] = t[d] * factor;
return tt;
-};
+}
for (unsigned int d=0; d<dim; ++d)
tt[d] = t[d] / factor;
return tt;
-};
+}
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
*/
void handle_unknown_exception ();
-}; // end declarations of namespace Threads
+} // end declarations of namespace Threads
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
// copying of parameters is done,
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
Arg3 arg3 = fun_data->arg3;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
Arg3 arg3 = fun_data->arg3;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
Arg3 arg3 = fun_data->arg3;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
Arg3 arg3 = fun_data->arg3;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
Arg3 arg3 = fun_data->arg3;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
Arg3 arg3 = fun_data->arg3;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
Arg3 arg3 = fun_data->arg3;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
Arg3 arg3 = fun_data->arg3;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
// copying of parameters is done,
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
Arg1 arg1 = fun_data->arg1;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
// copy the parameters
- ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
+ typename ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
-}; // end of implementation of namespace Threads
+} // end of implementation of namespace Threads
Assert (dim<=spacedim, ExcInvalidCombinationOfDimensions(dim,spacedim));
Assert (spacedim<=3, ExcNotImplemented());
-};
+}
MemoryConsumption::memory_consumption(n_subdivisions)
+
MemoryConsumption::memory_consumption(data));
-};
+}
DataOutBase::UcdFlags::UcdFlags (const bool write_preamble) :
write_preamble (write_preamble)
-{};
+{}
smooth (smooth),
bicubic_patch(bicubic_patch),
external_data(external_data)
-{};
+{}
DataOutBase::DXFlags::DXFlags (const bool write_multigrid,
{
prm.declare_entry ("Write multigrid", "true", Patterns::Bool());
prm.declare_entry ("Write neighbors", "true", Patterns::Bool());
-};
+}
{
write_multigrid = prm.get_bool ("Write multigrid");
write_neighbors = prm.get_bool ("Write neighbors");
-};
+}
// only simple data elements, so
// use sizeof operator
return sizeof (*this);
-};
+}
void DataOutBase::UcdFlags::declare_parameters (ParameterHandler &prm)
{
prm.declare_entry ("Write preamble", "true", Patterns::Bool());
-};
+}
void DataOutBase::UcdFlags::parse_parameters (ParameterHandler &prm)
{
write_preamble = prm.get_bool ("Write preamble");
-};
+}
unsigned int
// only simple data elements, so
// use sizeof operator
return sizeof (*this);
-};
+}
void DataOutBase::GnuplotFlags::declare_parameters (ParameterHandler &/*prm*/)
-{};
+{}
void DataOutBase::GnuplotFlags::parse_parameters (ParameterHandler &/*prm*/)
-{};
+{}
// only simple data elements, so
// use sizeof operator
return sizeof (*this);
-};
+}
Patterns::Bool());
prm.declare_entry ("Include external file", "true",
Patterns::Bool ());
-};
+}
smooth = prm.get_bool ("Use smooth triangles");
bicubic_patch = prm.get_bool ("Use bicubic patches");
external_data = prm.get_bool ("Include external file");
-};
+}
// only simple data elements, so
// use sizeof operator
return sizeof (*this);
-};
+}
draw_cells(draw_cells),
shade_cells(shade_cells),
color_function(color_function)
-{};
+{}
rgb_values.red = rgb_values.green = rgb_values.blue = 1;
return rgb_values;
-};
+}
rgb_values.red = rgb_values.blue = rgb_values.green
= (x-xmin)/(xmax-xmin);
return rgb_values;
-};
+}
rgb_values.red = rgb_values.blue = rgb_values.green
= 1-(x-xmin)/(xmax-xmin);
return rgb_values;
-};
+}
// note the "wrong" order in
// which we sort the elements
return depth > e.depth;
-};
+}
Patterns::Bool());
prm.declare_entry ("Color function", "default",
Patterns::Selection ("default|grey scale|reverse grey scale"));
-};
+}
// already have checked that the
// given value is valid
Assert (false, ExcInternalError());
-};
+}
// only simple data elements, so
// use sizeof operator
return sizeof (*this);
-};
+}
void DataOutBase::GmvFlags::declare_parameters (ParameterHandler &/*prm*/)
-{};
+{}
void DataOutBase::GmvFlags::parse_parameters (ParameterHandler &/*prm*/)
-{};
+{}
unsigned int
// only simple data elements, so
// use sizeof operator
return sizeof (*this);
-};
+}
DataOutBase::TecplotFlags::TecplotFlags (const char* tecplot_binary_file_name) :
tecplot_binary_file_name(tecplot_binary_file_name)
{
-};
+}
void DataOutBase::TecplotFlags::declare_parameters (ParameterHandler &/*prm*/)
-{};
+{}
void DataOutBase::TecplotFlags::parse_parameters (ParameterHandler &/*prm*/)
-{};
+{}
unsigned int
// only simple data elements, so
// use sizeof operator
return sizeof (*this);
-};
+}
void DataOutBase::VtkFlags::declare_parameters (ParameterHandler &/*prm*/)
-{};
+{}
void DataOutBase::VtkFlags::parse_parameters (ParameterHandler &/*prm*/)
-{};
+{}
unsigned int
// only simple data elements, so
// use sizeof operator
return sizeof (*this);
-};
+}
unsigned int DataOutBase::memory_consumption ()
{
return 0;
-};
+}
// assert the stream is still ok
AssertThrow (out, ExcIO());
-};
+}
out << "end" << std::endl;
// assert the stream is still ok
AssertThrow (out, ExcIO());
-};
+}
};
AssertThrow (out, ExcIO());
-};
+}
}
AssertThrow (out, ExcIO());
-};
+}
default:
Assert (false, ExcNotImplemented());
};
-};
+}
// assert the stream is still ok
AssertThrow (out, ExcIO());
-};
+}
// assert the stream is still ok
AssertThrow (out, ExcIO());
-};
+}
delete [] tecVarNames;
#endif
-};
+}
// assert the stream is still ok
AssertThrow (out, ExcIO());
-};
+}
for (unsigned int data_set=0; data_set<n_data_sets; ++data_set)
Assert (data_vectors[data_set].size() == next_value,
ExcInternalError());
-};
+}
{
DataOutBase::write_dx (get_patches(), get_dataset_names(),
dx_flags, out);
-};
+}
{
DataOutBase::write_ucd (get_patches(), get_dataset_names(),
ucd_flags, out);
-};
+}
{
DataOutBase::write_gnuplot (get_patches(), get_dataset_names(),
gnuplot_flags, out);
-};
+}
{
DataOutBase::write_povray (get_patches(), get_dataset_names(),
povray_flags, out);
-};
+}
{
DataOutBase::write_eps (get_patches(), get_dataset_names(),
eps_flags, out);
-};
+}
{
DataOutBase::write_gmv (get_patches(), get_dataset_names(),
gmv_flags, out);
-};
+}
{
DataOutBase::write_tecplot (get_patches(), get_dataset_names(),
tecplot_flags, out);
-};
+}
{
DataOutBase::write_tecplot_binary (get_patches(), get_dataset_names(),
tecplot_flags, out);
-};
+}
{
DataOutBase::write_vtk (get_patches(), get_dataset_names(),
vtk_flags, out);
-};
+}
default:
Assert (false, ExcNotImplemented());
};
-};
+}
void DataOutInterface<dim,spacedim>::set_flags (const DXFlags &flags)
{
dx_flags = flags;
-};
+}
void DataOutInterface<dim,spacedim>::set_flags (const UcdFlags &flags)
{
ucd_flags = flags;
-};
+}
void DataOutInterface<dim,spacedim>::set_flags (const GnuplotFlags &flags)
{
gnuplot_flags = flags;
-};
+}
void DataOutInterface<dim,spacedim>::set_flags (const PovrayFlags &flags)
{
povray_flags = flags;
-};
+}
void DataOutInterface<dim,spacedim>::set_flags (const EpsFlags &flags)
{
eps_flags = flags;
-};
+}
void DataOutInterface<dim,spacedim>::set_flags (const GmvFlags &flags)
{
gmv_flags = flags;
-};
+}
void DataOutInterface<dim,spacedim>::set_flags (const TecplotFlags &flags)
{
tecplot_flags = flags;
-};
+}
void DataOutInterface<dim,spacedim>::set_flags (const VtkFlags &flags)
{
vtk_flags = flags;
-};
+}
Assert (false, ExcNotImplemented());
return "";
};
-};
+}
// return something invalid
return OutputFormat(-1);
-};
+}
MemoryConsumption::memory_consumption (gmv_flags) +
MemoryConsumption::memory_consumption (tecplot_flags) +
MemoryConsumption::memory_consumption (vtk_flags));
-};
+}
ExceptionBase::ExceptionBase () :
file(""), line(0), function(""), cond(""), exc("")
-{};
+{}
ExceptionBase::ExceptionBase (const char* f, const int l, const char *func,
const char* c, const char *e) :
file(f), line(l), function(func), cond(c), exc(e)
-{};
+{}
ExceptionBase::~ExceptionBase () throw ()
-{};
+{}
function = func;
cond = c;
exc = e;
-};
+}
<< "The name and call sequence of the exception was:" << std::endl
<< " " << exc << std::endl
<< "Additional Information: " << std::endl;
-};
+}
void ExceptionBase::PrintInfo (std::ostream &out) const
{
out << "(none)" << std::endl;
-};
+}
std::abort ();
return 0;
}
-};
+}
void set_additional_assert_output (const char * const p)
{
additional_assert_output = p;
- };
+ }
}
else
std::abort ();
- };
+ }
void abort ()
{
std::abort ();
- };
+ }
}
-};
+}
// from the aclocal file:
const double initial_time) :
FunctionTime(initial_time),
n_components(n_components)
-{};
+{}
template <int dim>
Function<dim>::~Function ()
-{};
+{}
template <int dim>
{
Assert (false, ExcPureFunctionCalled());
return 0;
-};
+}
template <int dim>
Vector<double> &) const
{
Assert (false, ExcPureFunctionCalled());
-};
+}
// if necessary try to work around a bug in the IBM xlC compiler
for (unsigned int i=0; i<points.size(); ++i)
values[i] = this->value (points[i], component);
-};
+}
template <int dim>
for (unsigned int i=0; i<points.size(); ++i)
this->vector_value (points[i], values[i]);
-};
+}
template <int dim>
{
Assert (false, ExcPureFunctionCalled());
return Point<dim>();
-};
+}
template <int dim>
std::vector<Tensor<1,dim> > &) const
{
Assert (false, ExcPureFunctionCalled());
-};
+}
template <int dim>
for (unsigned int i=0; i<points.size(); ++i)
gradients[i] = gradient(points[i], component);
-};
+}
template <int dim>
// only simple data elements, so
// use sizeof operator
return sizeof (*this);
-};
+}
//------------------------------------------------------------//
const unsigned int) const
{
return 0.;
-};
+}
template <int dim>
ExcDimensionMismatch (return_value.size(), this->n_components));
std::fill (return_value.begin(), return_value.end(), 0.0);
-};
+}
template <int dim>
ExcDimensionMismatch(values.size(), points.size()));
std::fill (values.begin(), values.end(), 0.);
-};
+}
template <int dim>
ExcDimensionMismatch(values[i].size(), this->n_components));
std::fill (values[i].begin(), values[i].end(), 0.);
};
-};
+}
template <int dim>
const unsigned int) const
{
return Tensor<1,dim>();
-};
+}
template <int dim>
for (unsigned int c=0; c<this->n_components; ++c)
gradients[c].clear ();
-};
+}
template <int dim>
for (unsigned int i=0; i<points.size(); ++i)
gradients[i].clear ();
-};
+}
template <int dim>
for (unsigned int c=0; c<this->n_components; ++c)
gradients[i][c].clear ();
};
-};
+}
//------------------------------------------------------------//
const unsigned int n_components) :
ZeroFunction<dim> (n_components),
function_value (value)
-{};
+{}
template <int dim>
-ConstantFunction<dim>::~ConstantFunction () {};
+ConstantFunction<dim>::~ConstantFunction () {}
template <int dim>
const unsigned int) const
{
return function_value;
-};
+}
template <int dim>
ExcDimensionMismatch (return_value.size(), this->n_components));
std::fill (return_value.begin(), return_value.end(), function_value);
-};
+}
template <int dim>
ExcDimensionMismatch(values.size(), points.size()));
std::fill (values.begin(), values.end(), function_value);
-};
+}
template <int dim>
ExcDimensionMismatch(values[i].size(), this->n_components));
std::fill (values[i].begin(), values[i].end(), function_value);
};
-};
+}
// only simple data elements, so
// use sizeof operator
return sizeof (*this);
-};
+}
//------------------------------------------------------------//
// only simple data elements, so
// use sizeof operator
return sizeof (*this);
-};
+}
// explicit instantiations
// only simple data elements, so
// use sizeof operator
return sizeof (*this);
-};
+}
template class FourierSineSum<1>;
template class FourierSineSum<2>;
template class FourierSineSum<3>;
-};
+}
FunctionTime::set_time (const double new_time)
{
time = new_time;
-};
+}
void
FunctionTime::advance_time (const double delta_t)
{
set_time (time+delta_t);
-};
+}
void LogStream::detach ()
{
file = 0;
-};
+}
std::ostream&
pre += text;
pre += std::string(":");
prefixes.push(pre);
-};
+}
void LogStream::pop ()
{
if (prefixes.size() > 1)
prefixes.pop();
-};
+}
void
LogStream::depth_console(unsigned n)
{
std_depth = n;
-};
+}
void
LogStream::depth_file(unsigned n)
{
file_depth = n;
-};
+}
void
};
return mem;
-};
+}
for (unsigned int i=0; i<v.size(); ++i)
mem += memory_consumption(v[i]);
return mem;
- };
+ }
-};
+}
MultithreadInfo::MultithreadInfo () :
n_cpus (get_n_cpus()),
n_default_threads (n_cpus)
-{};
+{}
// only simple data elements, so
// use sizeof operator
return sizeof (MultithreadInfo);
-};
+}
{
PatternBase::~PatternBase ()
- {};
+ {}
unsigned int
return sizeof(Anything);
else
return sizeof(*this) + 32;
- };
+ }
const int upper_bound) :
lower_bound (lower_bound),
upper_bound (upper_bound)
- {};
+ {}
};
return false;
- };
+ }
// if no bounds were given, then
// return generic string
return "[Integer]";
- };
+ }
Integer::clone () const
{
return new Integer(lower_bound, upper_bound);
- };
+ }
const double upper_bound) :
lower_bound (lower_bound),
upper_bound (upper_bound)
- {};
+ {}
return true;
};
return false;
- };
+ }
// if no bounds were given, then
// return generic string
return "[Double]";
- };
+ }
PatternBase *
Double::clone () const
{
return new Double(lower_bound, upper_bound);
- };
+ }
sequence.replace (sequence.find(" |"), 2, "|");
while (sequence.find("| ") != std::string::npos)
sequence.replace (sequence.find("| "), 2, "|");
- };
+ }
// not found
return false;
- };
+ }
std::string Selection::description () const
{
return sequence;
- };
+ }
Selection::clone () const
{
return new Selection(sequence);
- };
+ }
unsigned int
{
return (sizeof(PatternBase) +
MemoryConsumption::memory_consumption(sequence));
- };
+ }
{
Assert (min_elements <= max_elements,
ExcInvalidRange (min_elements, max_elements));
- };
+ }
{
delete pattern;
pattern = 0;
- };
+ }
return false;
return true;
- };
+ }
#endif
return description.str();
- };
+ }
List::clone () const
{
return new List(*pattern, min_elements, max_elements);
- };
+ }
unsigned int
{
return (sizeof(PatternBase) +
MemoryConsumption::memory_consumption(*pattern));
- };
+ }
sequence.replace (sequence.find(" |"), 2, "|");
while (sequence.find("| ") != std::string::npos)
sequence.replace (sequence.find("| "), 2, "|");
- };
+ }
};
return true;
- };
+ }
std::string MultipleSelection::description () const
{
return sequence;
- };
+ }
MultipleSelection::clone () const
{
return new MultipleSelection(sequence);
- };
+ }
unsigned int
{
return (sizeof(PatternBase) +
MemoryConsumption::memory_consumption(sequence));
- };
+ }
Bool::Bool () :
Selection ("true|false")
- {};
+ {}
Bool::clone () const
{
return new Bool();
- };
+ }
Anything::Anything ()
- {};
+ {}
bool Anything::match (const std::string &) const
{
return true;
- };
+ }
std::string Anything::description () const
{
return "[Anything]";
- };
+ }
Anything::clone () const
{
return new Anything();
- };
+ }
} // end namespace Patterns
ParameterHandler::ParameterHandler () :
- status(true) {};
+ status(true) {}
ParameterHandler::~ParameterHandler ()
-{};
+{}
};
return status;
-};
+}
};
return status;
-};
+}
defaults.subsections.clear ();
changed_entries.subsections.clear ();
-};
+}
return false;
return true;
-};
+}
// finally enter subsection
subsection_path.push_back (subsection);
-};
+}
subsection_path.pop_back ();
return true;
-};
+}
// not changed
ptr = pd->entries.find (entry_string);
return ptr->second.first;
-};
+}
ExcConversionError(s));
return i;
-};
+}
ExcConversionError(s));
return d;
-};
+}
return true;
else
return false;
-};
+}
};
return out;
-};
+}
void
log_parameters_section (out);
out.pop();
-};
+}
Assert (false, ExcNotImplemented());
};
};
-};
+}
leave_subsection ();
out.pop();
};
-};
+}
std::cerr << "Line " << lineno << ": This line matched nothing known:" << std::endl
<< " " << line << std::endl;
return false;
-};
+}
};
return sec;
-};
+}
};
return sec;
-};
+}
};
return sec;
-};
+}
};
return sec;
-};
+}
MemoryConsumption::memory_consumption (subsection_path) +
MemoryConsumption::memory_consumption (defaults) +
MemoryConsumption::memory_consumption (changed_entries));
-};
+}
delete p->second;
subsections.clear ();
-};
+}
mem += (MemoryConsumption::memory_consumption (i->first) +
MemoryConsumption::memory_consumption (*(i->second)));
return mem;
-};
+}
MultipleParameterLoop::MultipleParameterLoop() :
n_branches(0)
-{};
+{}
MultipleParameterLoop::~MultipleParameterLoop ()
-{};
+{}
if (x)
init_branches ();
return x;
-};
+}
// function calls
// MultipleParameterLoop::Readinput(std::istream &, std::ostream &)
// which itself calls init_branches.
-};
+}
bool x = ParameterHandler::read_input (s);
init_branches ();
return x;
-};
+}
fill_entry_values (run_no);
uc.run (*this);
};
-};
+}
// other output)
for (unsigned int i=0; i<n_branches; ++i)
fill_entry_values (i);
-};
+}
init_branches_section (*s->second);
leave_subsection ();
};
-};
+}
possibilities *= choice->different_values.size();
};
-};
+}
mem += multiple_choices[i].memory_consumption ();
return mem;
-};
+}
const std::string &Name,
const std::string &Value) :
subsection_path (ssp), entry_name(Name), entry_value(Value)
-{};
+{}
type = Entry::array;
else
type = Entry::variant;
-};
+}
unsigned int
MemoryConsumption::memory_consumption (entry_value) +
MemoryConsumption::memory_consumption (different_values) +
sizeof (type));
-};
+}
namespace
{
Threads::ThreadMutex coefficients_lock;
-};
+}
namespace Polynomials
v.push_back(LagrangeEquidistant(degree,i));
return v;
};
- };
+ }
for (unsigned int i=0; i<=degree; ++i)
v.push_back (Legendre<double>(i));
return v;
- };
+ }
// now, everything is done, so
// release the lock again
coefficients_lock.release ();
- };
+ }
// change any more once computed,
// this is MT safe
return *p;
- };
+ }
for (unsigned int i=0; i<=degree; ++i)
v.push_back (Hierarchical<double>(i));
return v;
- };
+ }
}
n_pols /= (i+1);
}
return n_pols;
-};
+}
template <int dim>
template <>
Quadrature<0>::Quadrature (const unsigned int)
: n_quadrature_points(0)
-{};
+{}
template <>
Quadrature<0>::~Quadrature ()
-{};
+{}
: n_quadrature_points (0)
{
Assert (false, ExcInternalError());
-};
+}
n_quadrature_points (0)
{
Assert (false, ExcInternalError());
-};
+}
// near that.
Assert ((sum>0.999999) && (sum<1.000001), ExcInternalError());
#endif
-};
+}
template <int dim>
Quadrature<dim>::~Quadrature ()
-{};
+{}
Assert (false, ExcInternalError());
static const Point<0> dummy;
return dummy;
-};
+}
{
Assert (i<n_quadrature_points, ExcIndexRange(i, 0, n_quadrature_points));
return quadrature_points[i];
-};
+}
{
Assert (false, ExcInternalError());
return quadrature_points;
-};
+}
const std::vector<Point<dim> > & Quadrature<dim>::get_points () const
{
return quadrature_points;
-};
+}
{
Assert (false, ExcInternalError());
return 0;
-};
+}
{
Assert (i<n_quadrature_points, ExcIndexRange(i, 0, n_quadrature_points));
return weights[i];
-};
+}
const std::vector<double> & Quadrature<dim>::get_weights () const
{
return weights;
-};
+}
{
Assert (false, ExcInternalError());
return weights;
-};
+}
{
return (MemoryConsumption::memory_consumption (quadrature_points) +
MemoryConsumption::memory_consumption (weights));
-};
+}
//----------------------------------------------------------------------//
default:
Assert (false, ExcInternalError());
};
-};
+}
default:
Assert (false, ExcInternalError());
};
-};
+}
default:
Assert (false, ExcInternalError());
};
-};
+}
default:
Assert (false, ExcInternalError());
};
-};
+}
{
Assert (false, ExcImpossibleInDim(1));
return Quadrature<1>(0);
-};
+}
{
Assert (false, ExcImpossibleInDim(1));
return Quadrature<1>(0);
-};
+}
weights[i] *= (1./GeometryInfo<dim>::children_per_cell);
return Quadrature<dim> (q_points, weights);
-};
+}
};
return (at_left && at_right);
-};
+}
Assert (std::fabs(sum_of_weights-1) < 1e-15,
ExcSumOfWeightsNotOne());
#endif
-};
+}
const unsigned int N) :
Quadrature<dim> (QIterated<dim-1>(base_quadrature, N),
QIterated<1>(base_quadrature, N))
-{};
+{}
this->quadrature_points[i] = Point<1>(xpts[i]);
this->weights[i] = wts[i];
};
-};
+}
template <>
this->quadrature_points[i] = Point<1>(xpts[i]);
this->weights[i] = wts[i];
};
-};
+}
template <>
this->quadrature_points[i] = Point<1>(xpts[i]);
this->weights[i] = wts[i];
};
-};
+}
template <>
this->quadrature_points[i] = Point<1>(xpts[i]);
this->weights[i] = wts[i];
};
-};
+}
template <>
this->quadrature_points[i] = Point<1>(xpts[i]);
this->weights[i] = wts[i];
};
-};
+}
template <>
this->quadrature_points[i] = Point<1>(xpts[i]);
this->weights[i] = wts[i];
};
-};
+}
{
this->quadrature_points[0] = Point<1>(0.5);
this->weights[0] = 1.0;
-};
+}
template <>
this->quadrature_points[i] = Point<1>(xpts[i]);
this->weights[i] = wts[i];
};
-};
+}
template <>
this->quadrature_points[i] = Point<1>(xpts[i]);
this->weights[i] = wts[i];
};
-};
+}
template <>
this->quadrature_points[i] = Point<1>(xpts[i]);
this->weights[i] = wts[i];
};
-};
+}
template <>
this->quadrature_points[i] = Point<1>(xpts[i]);
this->weights[i] = wts[i];
};
-};
+}
template <int dim>
QGauss<dim>::QGauss (const unsigned int n)
: Quadrature<dim> (QGauss<dim-1>(n), QGauss<1>(n))
-{};
+{}
template <int dim>
-QGauss2<dim>::QGauss2 () : Quadrature<dim> (QGauss2<dim-1>(), QGauss2<1>()) {};
+QGauss2<dim>::QGauss2 () : Quadrature<dim> (QGauss2<dim-1>(), QGauss2<1>()) {}
template <int dim>
QGauss3<dim>::QGauss3 () :
- Quadrature<dim> (QGauss3<dim-1>(), QGauss3<1>()){};
+ Quadrature<dim> (QGauss3<dim-1>(), QGauss3<1>()){}
template <int dim>
QGauss4<dim>::QGauss4 () :
- Quadrature<dim> (QGauss4<dim-1>(), QGauss4<1>()){};
+ Quadrature<dim> (QGauss4<dim-1>(), QGauss4<1>()){}
template <int dim>
QGauss5<dim>::QGauss5 () :
- Quadrature<dim> (QGauss5<dim-1>(), QGauss5<1>()){};
+ Quadrature<dim> (QGauss5<dim-1>(), QGauss5<1>()){}
template <int dim>
QGauss6<dim>::QGauss6 () :
- Quadrature<dim> (QGauss6<dim-1>(), QGauss6<1>()){};
+ Quadrature<dim> (QGauss6<dim-1>(), QGauss6<1>()){}
template <int dim>
QGauss7<dim>::QGauss7 () :
- Quadrature<dim> (QGauss7<dim-1>(), QGauss7<1>()){};
+ Quadrature<dim> (QGauss7<dim-1>(), QGauss7<1>()){}
template <int dim>
QMidpoint<dim>::QMidpoint () :
- Quadrature<dim> (QMidpoint<dim-1>(), QMidpoint<1>()){};
+ Quadrature<dim> (QMidpoint<dim-1>(), QMidpoint<1>()){}
template <int dim>
QTrapez<dim>::QTrapez () :
- Quadrature<dim> (QTrapez<dim-1>(), QTrapez<1>()){};
+ Quadrature<dim> (QTrapez<dim-1>(), QTrapez<1>()){}
template <int dim>
QSimpson<dim>::QSimpson () :
- Quadrature<dim> (QSimpson<dim-1>(), QSimpson<1>()){};
+ Quadrature<dim> (QSimpson<dim-1>(), QSimpson<1>()){}
template <int dim>
QMilne<dim>::QMilne () :
- Quadrature<dim> (QMilne<dim-1>(), QMilne<1>()){};
+ Quadrature<dim> (QMilne<dim-1>(), QMilne<1>()){}
template <int dim>
QWeddle<dim>::QWeddle () :
- Quadrature<dim> (QWeddle<dim-1>(), QWeddle<1>()){};
+ Quadrature<dim> (QWeddle<dim-1>(), QWeddle<1>()){}
// explicit specialization
// include the huge <thread_management.h> file into the
// <subscriptor.h> file).
Threads::ThreadMutex subscription_lock;
-};
+}
Subscriptor::Subscriptor () :
counter (0),
object_info (0)
-{};
+{}
Subscriptor::Subscriptor (const Subscriptor &) :
counter (0),
object_info (0)
-{};
+{}
Subscriptor::~Subscriptor ()
{
object_info = s.object_info;
return *this;
-};
+}
subscription_lock.acquire();
++counter;
subscription_lock.release();
-};
+}
void Subscriptor::unsubscribe () const {
subscription_lock.acquire();
--counter;
subscription_lock.release();
-};
+}
unsigned int Subscriptor::n_subscriptions () const
{
return counter;
-};
+}
TensorFunction<rank, dim>::TensorFunction (const double initial_time)
:
FunctionTime (initial_time)
-{};
+{}
template <int rank, int dim>
TensorFunction<rank, dim>::~TensorFunction ()
-{};
+{}
template <int rank, int dim>
{
Assert (false, ExcPureFunctionCalled());
return Tensor<rank,dim>();
-};
+}
// if necessary try to work around a bug in the IBM xlC compiler
for (unsigned int i=0; i<points.size(); ++i)
values[i] = this->value (points[i]);
-};
+}
template <int rank, int dim>
{
Assert (false, ExcPureFunctionCalled());
return Tensor<rank+1,dim>();
-};
+}
template <int rank, int dim>
for (unsigned int i=0; i<points.size(); ++i)
gradients[i] = gradient(points[i]);
-};
+}
template class TensorFunction<1,1>;
n_existing_threads_mutex.acquire ();
++n_existing_threads_counter;
n_existing_threads_mutex.release ();
- };
+ }
Assert (n_existing_threads_counter >= 1,
ExcInternalError());
n_existing_threads_mutex.release ();
- };
+ }
<< "---------------------------------------------------------"
<< std::endl;
std::abort ();
- };
+ }
<< "---------------------------------------------------------"
<< std::endl;
std::abort ();
- };
+ }
const unsigned int n = n_existing_threads_counter;
n_existing_threads_mutex.release ();
return n;
- };
+ }
#if DEAL_II_USE_MT != 1
int /*flags*/) const
{
(*fun_ptr) (fun_data);
- };
+ }
void *)
{
Assert (count == 1, ExcBarrierSizeNotUseful(count));
- };
+ }
#else
FunDataCounter::FunDataCounter () :
n_fun_encapsulation_objects (0),
n_fun_data_base_objects (0)
- {};
+ {}
ExcObjectsExist("FunEncapsulation", n_fun_encapsulation_objects));
AssertThrow (n_fun_data_base_objects == 0,
ExcObjectsExist("FunDataBase", n_fun_data_base_objects));
- };
+ }
// keep some statistics on the
// number of variables around
++fun_data_counter.n_fun_encapsulation_objects;
- };
+ }
// keep some statistics on the
// number of variables around
++fun_data_counter.n_fun_encapsulation_objects;
- };
+ }
// keep some statistics on the
// number of variables around
++fun_data_counter.n_fun_encapsulation_objects;
- };
+ }
FunEncapsulation::~FunEncapsulation ()
// keep some statistics on the
// number of variables around
--fun_data_counter.n_fun_encapsulation_objects;
- };
+ }
const FunEncapsulation &
Assert (false, ExcNotImplemented());
const FunEncapsulation * const p = 0;
return *p;
- };
+ }
// keep some statistics on the
// number of variables around
++fun_data_counter.n_fun_data_base_objects;
- };
+ }
// keep some statistics on the
// number of variables around
++fun_data_counter.n_fun_data_base_objects;
- };
+ }
// keep some statistics on the
// number of variables around
--fun_data_counter.n_fun_data_base_objects;
- };
+ }
(void*)&fun_data,
0);
#endif
- };
+ }
{
for (unsigned int i=0; i<n_threads; ++i)
spawn (thread_manager, fun_data);
- };
+ }
return_values[i].second = end;
};
return return_values;
- };
+ };
-}; // end namespace Threads
+}; // end namespace Thread
* 1/sqrt(2)
*/
static const double SQRT1_2 = 0.70710678118654752440;
-};
+}
#endif
])
dof_handler(0)
{
Assert (false, ExcInvalidObject());
-};
+}
inline
DoFAccessor<dim>::DoFAccessor (const DoFHandler<dim> *dof_handler) :
dof_handler(const_cast<DoFHandler<dim>*>(dof_handler))
-{};
+{}
{
Assert (dh != 0, ExcInvalidObject());
dof_handler = dh;
-};
+}
DoFAccessor<dim>::get_dof_handler () const
{
return *dof_handler;
-};
+}
{
this->set_dof_handler (da.dof_handler);
return *this;
-};
+}
return this->dof_handler->levels[this->present_level]
->line_dofs[this->present_index*this->dof_handler->selected_fe->dofs_per_line+i];
-};
+}
template <int dim>
this->dof_handler->selected_fe->dofs_per_vertex +
i);
return this->dof_handler->vertex_dofs[dof_number];
-};
+}
template <int dim>
*next++ = vertex_dof_index(vertex,d);
for (unsigned int d=0; d<dofs_per_line; ++d)
*next++ = dof_index(d);
-};
+}
template <int dim>
Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
#endif
return q;
-};
+}
template <int dim>
{
BaseClass::copy_from (a);
this->set_dof_handler (a.dof_handler);
-};
+}
/*------------------------- Functions: DoFObjectAccessor<2,dim> -----------------------*/
return this->dof_handler->levels[this->present_level]
->quad_dofs[this->present_index*this->dof_handler->selected_fe->dofs_per_quad+i];
-};
+}
template <int dim>
this->dof_handler->selected_fe->dofs_per_vertex +
i);
return this->dof_handler->vertex_dofs[dof_number];
-};
+}
// if necessary try to work around a bug in the IBM xlC compiler
*next++ = this->line(line)->dof_index(d);
for (unsigned int d=0; d<dofs_per_quad; ++d)
*next++ = dof_index(d);
-};
+}
template <int dim>
this->line_index (i),
this->dof_handler
);
-};
+}
template <int dim>
Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
#endif
return q;
-};
+}
template <int dim>
{
BaseClass::copy_from (a);
this->set_dof_handler (a.dof_handler);
-};
+}
/*------------------------- Functions: DoFObjectAccessor<3,dim> -----------------------*/
return this->dof_handler->levels[this->present_level]
->hex_dofs[this->present_index*this->dof_handler->selected_fe->dofs_per_hex+i];
-};
+}
template <int dim>
this->dof_handler->selected_fe->dofs_per_vertex +
i);
return this->dof_handler->vertex_dofs[dof_number];
-};
+}
template <int dim>
*next++ = this->quad(quad)->dof_index(d);
for (unsigned int d=0; d<dofs_per_hex; ++d)
*next++ = dof_index(d);
-};
+}
l->index(),
this->dof_handler
);
-};
+}
template <int dim>
this->quad_index (i),
this->dof_handler
);
-};
+}
template <int dim>
Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
#endif
return q;
-};
+}
template <int dim>
{
BaseClass::copy_from (a);
this->set_dof_handler (a.dof_handler);
-};
+}
/*------------------------- Functions: DoFCellAccessor -----------------------*/
Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsNeighbor());
#endif
return q;
-};
+}
template <int dim>
Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
#endif
return q;
-};
+}
#endif
++next_constraint;
};
-};
+}
};
};
};
-};
+}
};
};
};
-};
+}
++next_constraint;
};
-};
+}
// nothing more to do
break;
};
-};
+}
// nothing more to do
break;
};
-};
+}
next_constraint->entries[i].second);
++next_constraint;
};
-};
+}
vec(next_constraint->line) += (vec(next_constraint->entries[i].first) *
next_constraint->entries[i].second);
};
-};
+}
#endif
unsigned int DoFHandler<dim>::n_dofs () const
{
return used_dofs;
-};
+}
{
Assert(selected_fe!=0, ExcNoFESelected());
return *selected_fe;
-};
+}
/*---------------------------- dof.h ---------------------------*/
point_to_index_map.clear ();
for (unsigned int i=0; i<dof_handler.n_dofs(); ++i)
point_to_index_map[support_points[i]] = i;
-};
+}
FiniteElementData<dim>::n_dofs_per_vertex () const
{
return dofs_per_vertex;
-};
+}
template <int dim>
FiniteElementData<dim>::n_dofs_per_line () const
{
return dofs_per_line;
-};
+}
template <int dim>
FiniteElementData<dim>::n_dofs_per_quad () const
{
return dofs_per_quad;
-};
+}
template <int dim>
FiniteElementData<dim>::n_dofs_per_hex () const
{
return dofs_per_hex;
-};
+}
template <int dim>
FiniteElementData<dim>::n_dofs_per_face () const
{
return dofs_per_face;
-};
+}
template <int dim>
FiniteElementData<dim>::n_dofs_per_cell () const
{
return dofs_per_cell;
-};
+}
template <int dim>
FiniteElementData<dim>::n_components () const
{
return components;
-};
+}
typename FiniteElementBase<dim>::ExcShapeFunctionNotPrimitive(index));
return face_system_to_component_table[index];
-};
+}
Assert(index < face_system_to_base_table.size(),
ExcIndexRange(index, 0, face_system_to_base_table.size()));
return face_system_to_base_table[index];
-};
+}
{
Assert (i < this->dofs_per_cell, ExcIndexRange (i, 0, this->dofs_per_cell));
return nonzero_components[i];
-};
+}
{
Assert (i < this->dofs_per_cell, ExcIndexRange (i, 0, this->dofs_per_cell));
return n_nonzero_components_table[i];
-};
+}
// probably more expensive than
// just comparing against 1
return (n_nonzero_components_table[i] == 1);
-};
+}
template <int dim>
FiniteElementBase<dim>::is_primitive () const
{
return cached_primitivity;
-};
+}
// component the call of this
// function refers
return this->shape_gradients[this->shape_function_to_row_table[i]][j];
-};
+}
FEValues<dim>::get_quadrature () const
{
return quadrature;
-};
+}
/*------------------------ Inline functions: FEFaceValuesBase --------------------*/
{
Assert (i<this->normal_vectors.size(), ExcIndexRange(i, 0, this->normal_vectors.size()));
Assert (this->update_flags & update_normal_vectors,
- FEValuesBase<dim>::ExcAccessToUninitializedField());
+ typename FEValuesBase<dim>::ExcAccessToUninitializedField());
return this->normal_vectors[i];
-};
+}
template <int dim>
FEFaceValuesBase<dim>::get_face() const
{
return present_face;
-};
+}
FEFaceValuesBase<dim>::get_quadrature () const
{
return quadrature;
-};
+}
}
else
return update_each;
-};
+}
Mapping<dim>::InternalDataBase::is_first_cell () const
{
return first_cell;
-};
+}
Mapping<dim>::InternalDataBase::clear_first_cell ()
{
first_cell = false;
-};
+}
#endif
const Point<dim> vertices[vertices_per_cell] =
{ Point<dim>(0.), Point<dim>(1.) };
return vertices[vertex];
-};
+}
{ Point<dim>(0., 0.), Point<dim>(1., 0.),
Point<dim>(1.,1.), Point<dim>(0.,1.) };
return vertices[vertex];
-};
+}
Point<dim>(0., 1., 0.), Point<dim>(1., 1., 0.),
Point<dim>(1., 1., 1.), Point<dim>(0., 1., 1.) };
return vertices[vertex];
-};
+}
ExcIndexRange (vertex, 0, 2));
return vertex;
-};
+}
{ {0, 1}, {1, 2}, {3, 2}, {0, 3} };
return vertex_indices[line][vertex];
-};
+}
{0, 4}, {1, 5}, {2, 6}, {3, 7} };
return vertex_indices[line][vertex];
-};
+}
const double azimut_angle = 60,
const double turn_angle = 30);
};
-};
+}
// and mark it as treated
treated_vertices[cell->vertex_index(v)] = true;
};
-};
+}
present_level = a.present_level;
present_index = a.present_index;
tria = a.tria;
-};
+}
Assert (tria == a.tria, ExcCantCompareIterators());
return ((present_index == a.present_index) &&
(present_level == a.present_level));
-};
+}
Assert (tria == a.tria, ExcCantCompareIterators());
return ((present_index != a.present_index) ||
(present_level != a.present_level));
-};
+}
TriaAccessor<dim>::level () const
{
return present_level;
-};
+}
TriaAccessor<dim>::index () const
{
return present_index;
-};
+}
return IteratorState::past_the_end;
else
return IteratorState::invalid;
-};
+}
TriaAccessor<dim>::get_triangulation () const
{
return *tria;
-};
+}
/*------------------------ Functions: LineAccessor ---------------------------*/
Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
return this->tria->levels[this->present_level]->lines.used[this->present_index];
-};
+}
{
Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
return this->tria->levels[this->present_level]->lines.user_flags[this->present_index];
-};
+}
{
Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->lines.user_flags[this->present_index] = true;
-};
+}
{
Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->lines.user_flags[this->present_index] = false;
-};
+}
typename TriaAccessor<dim>::ExcUnusedCellAsChild());
return q;
-};
+}
{
Assert (i<2, ExcIndexRange(i,0,2));
return this->tria->levels[this->present_level]->lines.children[this->present_index]+i;
-};
+}
const unsigned int depths[2] = { child(0)->max_refinement_depth() + 1,
child(1)->max_refinement_depth() + 1 };
return std::max (depths[0], depths[1]);
-};
+}
return;
};
};
-};
+}
// else
this->present_index = this->tria->levels[this->present_level]->lines.lines.size()-1;
};
-};
+}
/*------------------------ Functions: QuadAccessor ---------------------------*/
Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
return this->tria->levels[this->present_level]->quads.used[this->present_index];
-};
+}
{
Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
return this->tria->levels[this->present_level]->quads.user_flags[this->present_index];
-};
+}
{
Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->quads.user_flags[this->present_index] = true;
-};
+}
{
Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->quads.user_flags[this->present_index] = false;
-};
+}
this->present_level,
line_index (i)
);
-};
+}
Assert (i<4, ExcIndexRange(i,0,4));
return this->tria->levels[this->present_level]->quads.quads[this->present_index].line(i);
-};
+}
typename TriaAccessor<dim>::ExcUnusedCellAsChild());
return q;
-};
+}
{
Assert (i<4, ExcIndexRange(i,0,4));
return this->tria->levels[this->present_level]->quads.children[this->present_index]+i;
-};
+}
Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
return (this->tria->levels[this->present_level]->quads.children[this->present_index] != -1);
-};
+}
child(3)->max_refinement_depth() + 1 };
return std::max (std::max (depths[0], depths[1]),
std::max (depths[2], depths[3]));
-};
+}
return;
};
};
-};
+}
// else
this->present_index = this->tria->levels[this->present_level]->quads.quads.size()-1;
};
-};
+}
/*------------------------ Functions: HexAccessor ---------------------------*/
Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
return this->tria->levels[this->present_level]->hexes.used[this->present_index];
-};
+}
{
Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
return this->tria->levels[this->present_level]->hexes.user_flags[this->present_index];
-};
+}
{
Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->hexes.user_flags[this->present_index] = true;
-};
+}
{
Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->hexes.user_flags[this->present_index] = false;
-};
+}
};
Assert (false, ExcIndexRange(i,0,12));
return TriaIterator<dim,TriaObjectAccessor<1,dim> >(this->tria, -1, -1, 0);
-};
+}
this->present_level,
quad_index (i)
);
-};
+}
};
Assert (false, ExcIndexRange(i,0,12));
return 0;
-};
+}
Assert (i<6, ExcIndexRange(i,0,6));
return this->tria->levels[this->present_level]->hexes.hexes[this->present_index].quad(i);
-};
+}
typename TriaAccessor<dim>::ExcUnusedCellAsChild());
return q;
-};
+}
{
Assert (i<8, ExcIndexRange(i,0,8));
return this->tria->levels[this->present_level]->hexes.children[this->present_index]+i;
-};
+}
Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
return (this->tria->levels[this->present_level]->hexes.children[this->present_index] != -1);
-};
+}
std::max (depths[2], depths[3])),
std::max (std::max (depths[4], depths[5]),
std::max (depths[6], depths[7])));
-};
+}
return;
};
};
-};
+}
// else
this->present_index = this->tria->levels[this->present_level]->hexes.hexes.size()-1;
};
-};
+}
/*------------------------ Functions: TriaObjectAccessor ---------------------------*/
Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
return this->tria->levels[this->present_level]->hexes.used[this->present_index];
-};
+}
{
Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
return this->tria->levels[this->present_level]->hexes.user_flags[this->present_index];
-};
+}
{
Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->hexes.user_flags[this->present_index] = true;
-};
+}
{
Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->hexes.user_flags[this->present_index] = false;
-};
+}
}
return TriaIterator<dim,TriaObjectAccessor<1,dim> >(this->tria, -1, -1, 0);
-};
+}
this->present_level,
quad_index (i)
);
-};
+}
Assert(false, ExcNotImplemented());
}
return 0;
-};
+}
ExcIndexRange(i,0,GeometryInfo<celldim>::quads_per_cell));
return this->tria->levels[this->present_level]->hexes.hexes[this->present_index].quad(i);
-};
+}
typename TriaAccessor<dim>::ExcUnusedCellAsChild());
return q;
-};
+}
Assert (i < GeometryInfo<celldim>::children_per_cell,
ExcIndexRange(i,0,GeometryInfo<celldim>::children_per_cell));
return this->tria->levels[this->present_level]->hexes.children[this->present_index]+i;
-};
+}
Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
return (this->tria->levels[this->present_level]->hexes.children[this->present_index] != -1);
-};
+}
std::max (depths[2], depths[3])),
std::max (std::max (depths[4], depths[5]),
std::max (depths[6], depths[7])));
-};
+}
return;
};
};
-};
+}
// else
this->present_index = this->tria->levels[this->present_level]->hexes.hexes.size()-1;
};
-};
+}
/*------------------------ Functions: CellAccessor<dim> -----------------------*/
{
Assert (false, TriaAccessor<1>::ExcNotUsefulForThisDimension());
return TriaIterator<1,TriaObjectAccessor<0, 1> >();
-};
+}
CellAccessor<2>::face (const unsigned int i) const
{
return this->line(i);
-};
+}
CellAccessor<3>::face (const unsigned int i) const
{
return this->quad(i);
-};
+}
typename TriaAccessor<dim>::ExcInvalidNeighbor(i));
return this->tria->levels[this->present_level]->
neighbors[this->present_index*GeometryInfo<dim>::faces_per_cell+i].second;
-};
+}
typename TriaAccessor<dim>::ExcInvalidNeighbor(i));
return this->tria->levels[this->present_level]->
neighbors[this->present_index*GeometryInfo<dim>::faces_per_cell+i].first;
-};
+}
Assert (this->active() || !this->tria->levels[this->present_level]->refine_flags[this->present_index],
ExcRefineCellNotActive());
return this->tria->levels[this->present_level]->refine_flags[this->present_index];
-};
+}
ExcCellFlaggedForCoarsening());
this->tria->levels[this->present_level]->refine_flags[this->present_index] = true;
-};
+}
{
Assert (this->used() && this->active(), ExcRefineCellNotActive());
this->tria->levels[this->present_level]->refine_flags[this->present_index] = false;
-};
+}
Assert (this->active() || !this->tria->levels[this->present_level]->coarsen_flags[this->present_index],
ExcRefineCellNotActive());
return this->tria->levels[this->present_level]->coarsen_flags[this->present_index];
-};
+}
Assert (!refine_flag_set(), ExcCellFlaggedForRefinement());
this->tria->levels[this->present_level]->coarsen_flags[this->present_index] = true;
-};
+}
{
Assert (this->used() && this->active(), ExcRefineCellNotActive());
this->tria->levels[this->present_level]->coarsen_flags[this->present_index] = false;
-};
+}
typename TriaAccessor<dim>::ExcUnusedCellAsNeighbor());
return q;
-};
+}
typename TriaAccessor<dim>::ExcUnusedCellAsChild());
return q;
-};
+}
CellAccessor<dim>::active () const
{
return !this->has_children();
-};
+}
#endif
quads[3] = i3;
quads[4] = i4;
quads[5] = i5;
-};
+}
Assert ((i>=0) && (i<6),
ExcRange(i));
return quads[i];
-};
+}
Assert ((i>=0) && (i<6),
ExcRange(i));
quads[i] = index;
-};
+}
Hexahedron::memory_consumption ()
{
return sizeof(Hexahedron);
-};
+}
#endif
inline
TriaRawIterator<dim,Accessor>::TriaRawIterator (const Accessor &a) :
accessor (a)
-{};
+{}
inline
TriaRawIterator<dim,Accessor>::TriaRawIterator (const TriaRawIterator<dim,OtherAccessor> &i)
: accessor (i.accessor)
-{};
+{}
Assert (state() == IteratorState::valid,
ExcDereferenceInvalidObject(accessor));
return accessor;
-};
+}
Assert (state() == IteratorState::valid,
ExcDereferenceInvalidObject(accessor));
return accessor;
-};
+}
TriaRawIterator<dim,Accessor>::operator -> () const
{
return &(this->operator* ());
-};
+}
TriaRawIterator<dim,Accessor>::operator -> ()
{
return &(this->operator* ());
-};
+}
TriaRawIterator<dim,Accessor>::state () const
{
return accessor.state ();
-};
+}
(i.state()==IteratorState::valid) ) ||
((state()==IteratorState::valid) &&
(i.state()==IteratorState::past_the_end)));
-};
+}
template <int dim, typename Accessor>
++accessor;
return *this;
-};
+}
--accessor;
return *this;
-};
+}
TriaRawIterator<dim,Accessor>::print (std::ostream &out) const
{
out << accessor.level() << "." << accessor.index();
-};
+}
TriaRawIterator<dim,Accessor>::memory_consumption () const
{
return sizeof(TriaRawIterator<dim,Accessor>);
-};
+}
inline
TriaIterator<dim,Accessor>::TriaIterator (const TriaIterator<dim,OtherAccessor> &i)
: TriaRawIterator<dim,Accessor> (static_cast<TriaIterator<dim,OtherAccessor> >(i))
-{};
+{}
Assert (this->accessor.used(),
ExcAssignmentOfUnusedObject());
#endif
-};
+}
inline
TriaActiveIterator<dim,Accessor>::TriaActiveIterator (const TriaActiveIterator<dim,OtherAccessor> &i)
: TriaIterator<dim,Accessor> (static_cast<TriaIterator<dim,OtherAccessor> >(i))
-{};
+{}
Assert (this->accessor.has_children()==false,
ExcAssignmentOfInactiveObject());
#endif
-};
+}
{
i.print(out);
return out;
-};
+}
{
i.print(out);
return out;
-};
+}
{
i.print(out);
return out;
-};
+}
template <int dim, typename Accessor>
inline
TriaRawIterator<dim,Accessor>::TriaRawIterator () :
- accessor (0, -2, -2, 0) {};
+ accessor (0, -2, -2, 0) {}
template <int dim, typename Accessor>
inline
TriaRawIterator<dim,Accessor>::TriaRawIterator (const TriaRawIterator<dim,Accessor> &i) :
- accessor (i.accessor) {};
+ accessor (i.accessor) {}
template <int dim, typename Accessor>
const int level,
const int index,
const typename Accessor::AccessorData *local_data) :
- accessor (parent, level, index, local_data) {};
+ accessor (parent, level, index, local_data) {}
template <int dim, typename Accessor>
accessor.copy_from (i.accessor);
return *this;
-};
+}
template <int dim, typename Accessor>
bool
TriaRawIterator<dim,Accessor>::operator == (const TriaRawIterator<dim,Accessor> &i) const {
return accessor == i.accessor;
-};
+}
template <int dim, typename Accessor>
//
// Work around the problem this way:
return accessor.operator != (i.accessor);
-};
+}
template <int dim, typename Accessor>
operator++ ();
return tmp;
-};
+}
template <int dim, typename Accessor>
operator-- ();
return tmp;
-};
+}
/*----------------------- functions: TriaIterator ---------------*/
template <int dim, typename Accessor>
inline
TriaIterator<dim,Accessor>::TriaIterator () :
- TriaRawIterator<dim,Accessor> () {};
+ TriaRawIterator<dim,Accessor> () {}
template <int dim, typename Accessor>
inline
TriaIterator<dim,Accessor>::TriaIterator (const TriaIterator<dim,Accessor> &i) :
- TriaRawIterator<dim,Accessor> (static_cast<TriaRawIterator<dim,Accessor> >(i)) {};
+ TriaRawIterator<dim,Accessor> (static_cast<TriaRawIterator<dim,Accessor> >(i)) {}
template <int dim, typename Accessor>
Assert (this->accessor.used(),
ExcAssignmentOfUnusedObject());
#endif
-};
+}
template <int dim, typename Accessor>
Assert (this->accessor.used(),
ExcAssignmentOfUnusedObject());
#endif
-};
+}
template <int dim, typename Accessor>
TriaIterator<dim,Accessor>::operator = (const TriaIterator<dim,Accessor> &i) {
this->accessor.copy_from (i.accessor);
return *this;
-};
+}
template <int dim, typename Accessor>
ExcAssignmentOfUnusedObject());
#endif
return *this;
-};
+}
template <int dim, typename Accessor>
if (this->accessor.used() == true)
return *this;
return *this;
-};
+}
template <int dim, typename Accessor>
operator++ ();
return tmp;
-};
+}
template <int dim, typename Accessor>
if (this->accessor.used() == true)
return *this;
return *this;
-};
+}
template <int dim, typename Accessor>
operator-- ();
return tmp;
-};
+}
/*----------------------- functions: TriaActiveIterator ---------------*/
template <int dim, typename Accessor>
inline
TriaActiveIterator<dim,Accessor>::TriaActiveIterator () :
- TriaIterator<dim,Accessor> () {};
+ TriaIterator<dim,Accessor> () {}
template <int dim, typename Accessor>
inline
TriaActiveIterator<dim,Accessor>::TriaActiveIterator (const TriaActiveIterator<dim,Accessor> &i) :
- TriaIterator<dim,Accessor> (static_cast<TriaIterator<dim,Accessor> >(i)) {};
+ TriaIterator<dim,Accessor> (static_cast<TriaIterator<dim,Accessor> >(i)) {}
template <int dim, typename Accessor>
Assert (this->accessor.has_children()==false,
ExcAssignmentOfInactiveObject());
#endif
-};
+}
template <int dim, typename Accessor>
Assert (this->accessor.has_children()==false,
ExcAssignmentOfInactiveObject());
#endif
-};
+}
template <int dim, typename Accessor>
Assert (this->accessor.has_children()==false,
ExcAssignmentOfInactiveObject());
#endif
-};
+}
template <int dim, typename Accessor>
TriaActiveIterator<dim,Accessor>::operator = (const TriaActiveIterator<dim,Accessor> &i) {
this->accessor.copy_from (i.accessor);
return *this;
-};
+}
template <int dim, typename Accessor>
ExcAssignmentOfInactiveObject());
#endif
return *this;
-};
+}
template <int dim, typename Accessor>
ExcAssignmentOfInactiveObject());
#endif
return *this;
-};
+}
template <int dim, typename Accessor>
if (this->accessor.has_children() == false)
return *this;
return *this;
-};
+}
template <int dim, typename Accessor>
operator++ ();
return tmp;
-};
+}
template <int dim, typename Accessor>
if (this->accessor.has_children() == false)
return *this;
return *this;
-};
+}
template <int dim, typename Accessor>
operator-- ();
return tmp;
-};
+}
#endif
past_the_end,
invalid
};
-};
+}
{
end_points[0] = i0;
end_points[1] = i1;
-};
+}
Assert ((i==0) || (i==1),
ExcRange(i));
return end_points[i];
-};
+}
Assert ((i==0) || (i==1),
ExcRange(i));
end_points[i] = index;
-};
+}
Line::memory_consumption ()
{
return sizeof(Line);
-};
+}
#endif
lines[1] = i1;
lines[2] = i2;
lines[3] = i3;
-};
+}
Assert ((i>=0) && (i<4),
ExcRange(i));
return lines[i];
-};
+}
Assert ((i>=0) && (i<4),
ExcRange(i));
lines[i] = index;
-};
+}
Quad::memory_consumption ()
{
return sizeof(Quad);
-};
+}
#endif
minlevel(0)
{
resize (min, max);
-};
+}
template<class Object>
minlevel = new_minlevel;
objects.resize (new_maxlevel - new_minlevel + 1);
-};
+}
template<class Object>
typename std::vector<Object>::iterator v;
for (v = objects.begin(); v != objects.end(); ++v)
v->clear();
-};
+}
template<class Object>
MGLevelObject<Object>::get_minlevel () const
{
return minlevel;
-};
+}
template<class Object>
MGLevelObject<Object>::get_maxlevel () const
{
return minlevel + objects.size() - 1;
-};
+}
/*----------------------------------------------------------------------*/
* Reset the DoF handler pointer.
*/
void set_mg_dof_handler (MGDoFHandler<dim> *dh) {
- Assert (dh != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (dh != 0, typename DoFAccessor<dim>::ExcInvalidObject());
mg_dof_handler = dh;
};
ExcIndexRange(dof_number, 0, dofs_per_vertex));
indices[(level-coarsest_level)*dofs_per_vertex + dof_number] = index;
-};
+}
template <int dim>
ExcIndexRange (dof_number, 0, dofs_per_vertex));
return indices[(level-coarsest_level)*dofs_per_vertex + dof_number];
-};
+}
template <>
MGSmootherIdentity<VECTOR>::smooth (
const unsigned int, VECTOR&,
const VECTOR&) const
-{};
+{}
/*----------------------------------------------------------------------*/
matrix(&matrix),
relaxation(relaxation),
omega(omega)
-{};
+{}
template<class MATRIX, class VECTOR>
double,
<< "The following value does not fulfill the requirements: " << arg1);
};
-};
+}
timesteps[n_timesteps-(step-look_back)-1]->sleep(look_back);
break;
};
-};
+}
/*---------------------------- time-dependent.h ---------------------------*/
void DoFObjectAccessor<1, dim>::set_dof_index (const unsigned int i,
const unsigned int index) const
{
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (this->dof_handler->selected_fe != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler->selected_fe != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (i<this->dof_handler->selected_fe->dofs_per_line,
ExcIndexRange (i, 0, this->dof_handler->selected_fe->dofs_per_line));
this->dof_handler->levels[this->present_level]
->line_dofs[this->present_index*this->dof_handler->selected_fe->dofs_per_line+i] = index;
-};
+}
this->dof_handler->selected_fe->dofs_per_vertex +
i);
this->dof_handler->vertex_dofs[dof_number] = index;
-};
+}
// distribute cell vector
for (unsigned int j=0; j<n_dofs; ++j)
global_destination(dofs[j]) += local_source(j);
-};
+}
for (unsigned int i=0; i<n_dofs; ++i)
for (unsigned int j=0; j<n_dofs; ++j)
global_destination.add(dofs[i], dofs[j], local_source(i,j));
-};
+}
Assert (next_local_value == local_values.end(),
ExcInternalError());
-};
+}
Assert (next_local_value == local_values.end(),
ExcInternalError());
-};
+}
/*------------------------- Functions: DoFObjectAccessor<2,dim> -----------------------*/
this->dof_handler->levels[this->present_level]
->quad_dofs[this->present_index*this->dof_handler->selected_fe->dofs_per_quad+i] = index;
-};
+}
this->dof_handler->selected_fe->dofs_per_vertex +
i);
this->dof_handler->vertex_dofs[dof_number] = index;
-};
+}
// distribute cell vector
for (unsigned int j=0; j<n_dofs; ++j)
global_destination(dofs[j]) += local_source(j);
-};
+}
for (unsigned int i=0; i<n_dofs; ++i)
for (unsigned int j=0; j<n_dofs; ++j)
global_destination.add(dofs[i], dofs[j], local_source(i,j));
-};
+}
Assert (next_local_value == local_values.end(),
ExcInternalError());
-};
+}
Assert (next_local_value == local_values.end(),
ExcInternalError());
-};
+}
/*------------------------- Functions: DoFObjectAccessor<3,dim> -----------------------*/
this->dof_handler->levels[this->present_level]
->hex_dofs[this->present_index*this->dof_handler->selected_fe->dofs_per_hex+i] = index;
-};
+}
this->dof_handler->selected_fe->dofs_per_vertex +
i);
this->dof_handler->vertex_dofs[dof_number] = index;
-};
+}
// distribute cell vector
for (unsigned int j=0; j<n_dofs; ++j)
global_destination(dofs[j]) += local_source(j);
-};
+}
for (unsigned int i=0; i<n_dofs; ++i)
for (unsigned int j=0; j<n_dofs; ++j)
global_destination.add(dofs[i], dofs[j], local_source(i,j));
-};
+}
Assert (next_local_value == local_values.end(),
ExcInternalError());
-};
+}
Assert (next_local_value == local_values.end(),
ExcInternalError());
-};
+}
{
Assert (false, ExcNotUsefulForThisDimension());
return TriaIterator<1, DoFObjectAccessor<0,1> >();
-};
+}
#endif
DoFCellAccessor<2>::face (const unsigned int i) const
{
return this->line(i);
-};
+}
#endif
DoFCellAccessor<3>::face (const unsigned int i) const
{
return this->quad(i);
-};
+}
#endif
const unsigned int dofs_per_cell = fe.dofs_per_cell;
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&fe != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&fe != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (interpolated_values.size() == dofs_per_cell,
- DoFAccessor<dim>::ExcVectorDoesNotMatch());
+ typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
Assert (values.size() == this->dof_handler->n_dofs(),
- DoFAccessor<dim>::ExcVectorDoesNotMatch());
+ typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
if (!this->has_children())
// if this cell has no children: simply
interpolated_values(i) = tmp2(i);
};
};
-};
+}
{
const unsigned int dofs_per_cell = this->dof_handler->get_fe().dofs_per_cell;
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (local_values.size() == dofs_per_cell,
- DoFAccessor<dim>::ExcVectorDoesNotMatch());
+ typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
Assert (values.size() == this->dof_handler->n_dofs(),
- DoFAccessor<dim>::ExcVectorDoesNotMatch());
+ typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
if (!this->has_children())
// if this cell has no children: simply
this->child(child)->set_dof_values_by_interpolation (tmp, values);
};
};
-};
+}
ConstraintMatrix::check_zero_weight (const std::pair<unsigned int, double> &p)
{
return (p.second == 0);
-};
+}
ConstraintMatrix::ConstraintLine::operator < (const ConstraintLine &a) const
{
return line < a.line;
-};
+}
ConstraintMatrix::ConstraintLine::operator == (const ConstraintLine &a) const
{
return line == a.line;
-};
+}
{
return (MemoryConsumption::memory_consumption (line) +
MemoryConsumption::memory_consumption (entries));
-};
+}
ConstraintMatrix::ConstraintMatrix () :
lines(),
sorted(false)
-{};
+{}
void ConstraintMatrix::add_line (const unsigned int line)
// list
lines.push_back (ConstraintLine());
lines.back().line = line;
-};
+}
};
line_ptr->entries.push_back (std::make_pair(column,value));
-};
+}
line_ptr->entries.push_back (*col_val_pair);
};
-};
+}
#endif
sorted = true;
-};
+}
// state
if (object_was_sorted == true)
close ();
-};
+}
std::vector<ConstraintLine> tmp;
lines.swap (tmp);
sorted = false;
-};
+}
};
condensed.compress();
-};
+}
};
sparsity.compress();
-};
+}
.entries[q].first);
};
};
-};
+}
};
sparsity.compress();
-};
+}
};
};
};
-};
+}
unsigned int ConstraintMatrix::n_constraints () const
{
return lines.size();
-};
+}
return false;
};
-};
+}
return false;
};
-};
+}
static_cast<unsigned int>(i->entries.size()));
return return_value;
-};
+}
<< ": " << lines[i].entries[j].second << std::endl;
AssertThrow (out, ExcIO());
-};
+}
{
return (MemoryConsumption::memory_consumption (lines) +
MemoryConsumption::memory_consumption (sorted));
-};
+}
#define VectorType Vector<float>
-vector_functions;
+vector_functions
#undef VectorType
#define VectorType Vector<double>
-vector_functions;
+vector_functions
#undef VectorType
#define VectorType BlockVector<double>
-vector_functions;
+vector_functions
#undef VectorType
#define VectorType BlockVector<float>
-vector_functions;
+vector_functions
#undef VectorType
DoFHandler<dim>::DoFHandler (const Triangulation<dim> &tria) :
tria(&tria),
used_dofs (0)
-{};
+{}
template <int dim>
{
// release allocated memory
clear ();
-};
+}
#if deal_II_dimension == 1
DoFHandler<1>::raw_cell_iterator
DoFHandler<1>::begin_raw (const unsigned int level) const {
return begin_raw_line (level);
-};
+}
template <>
DoFHandler<1>::cell_iterator
DoFHandler<1>::begin (const unsigned int level) const {
return begin_line (level);
-};
+}
template <>
DoFHandler<1>::active_cell_iterator
DoFHandler<1>::begin_active (const unsigned int level) const {
return begin_active_line (level);
-};
+}
template <>
DoFHandler<1>::raw_cell_iterator
DoFHandler<1>::end () const {
return end_line ();
-};
+}
template <>
DoFHandler<1>::raw_cell_iterator
DoFHandler<1>::last_raw () const {
return last_raw_line ();
-};
+}
template <>
DoFHandler<1>::raw_cell_iterator
DoFHandler<1>::last_raw (const unsigned int level) const {
return last_raw_line (level);
-};
+}
template <>
DoFHandler<1>::cell_iterator
DoFHandler<1>::last () const {
return last_line ();
-};
+}
template <>
DoFHandler<1>::cell_iterator
DoFHandler<1>::last (const unsigned int level) const {
return last_line (level);
-};
+}
template <>
DoFHandler<1>::active_cell_iterator
DoFHandler<1>::last_active () const {
return last_active_line ();
-};
+}
template <>
DoFHandler<1>::active_cell_iterator
DoFHandler<1>::last_active (const unsigned int level) const {
return last_active_line (level);
-};
+}
template <>
DoFHandler<1>::begin_raw_face (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
template <>
DoFHandler<1>::begin_face (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
template <>
DoFHandler<1>::begin_active_face (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
template <>
DoFHandler<1>::end_face () const {
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
template <>
DoFHandler<1>::last_raw_face () const {
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
template <>
DoFHandler<1>::last_raw_face (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
template <>
DoFHandler<1>::last_face () const {
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
template <>
DoFHandler<1>::last_face (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
template <>
DoFHandler<1>::last_active_face () const {
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
template <>
DoFHandler<1>::last_active_face (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
template <>
DoFHandler<1>::begin_raw_quad (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::begin_quad (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::begin_active_quad (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::end_quad () const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::last_raw_quad (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::last_quad (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::last_active_quad (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::last_raw_quad () const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::last_quad () const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::last_active_quad () const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::begin_raw_hex (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::begin_hex (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::begin_active_hex (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::end_hex () const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::last_raw_hex (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::last_raw_hex () const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::last_hex (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::last_hex () const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::last_active_hex (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<1>::last_active_hex () const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
#endif
DoFHandler<2>::raw_cell_iterator
DoFHandler<2>::begin_raw (const unsigned int level) const {
return begin_raw_quad (level);
-};
+}
template <>
DoFHandler<2>::cell_iterator
DoFHandler<2>::begin (const unsigned int level) const {
return begin_quad (level);
-};
+}
template <>
DoFHandler<2>::active_cell_iterator
DoFHandler<2>::begin_active (const unsigned int level) const {
return begin_active_quad (level);
-};
+}
template <>
DoFHandler<2>::raw_cell_iterator
DoFHandler<2>::end () const {
return end_quad ();
-};
+}
template <>
DoFHandler<2>::raw_cell_iterator
DoFHandler<2>::last_raw () const {
return last_raw_quad ();
-};
+}
template <>
DoFHandler<2>::raw_cell_iterator
DoFHandler<2>::last_raw (const unsigned int level) const {
return last_raw_quad (level);
-};
+}
template <>
DoFHandler<2>::cell_iterator
DoFHandler<2>::last () const {
return last_quad ();
-};
+}
template <>
DoFHandler<2>::cell_iterator
DoFHandler<2>::last (const unsigned int level) const {
return last_quad (level);
-};
+}
template <>
DoFHandler<2>::active_cell_iterator
DoFHandler<2>::last_active () const {
return last_active_quad ();
-};
+}
template <>
DoFHandler<2>::active_cell_iterator
DoFHandler<2>::last_active (const unsigned int level) const {
return last_active_quad (level);
-};
+}
template <>
DoFDimensionInfo<2>::raw_face_iterator
DoFHandler<2>::begin_raw_face (const unsigned int level) const {
return begin_raw_line (level);
-};
+}
template <>
DoFDimensionInfo<2>::face_iterator
DoFHandler<2>::begin_face (const unsigned int level) const {
return begin_line (level);
-};
+}
template <>
DoFDimensionInfo<2>::active_face_iterator
DoFHandler<2>::begin_active_face (const unsigned int level) const {
return begin_active_line (level);
-};
+}
template <>
DoFDimensionInfo<2>::raw_face_iterator
DoFHandler<2>::end_face () const {
return end_line ();
-};
+}
template <>
DoFDimensionInfo<2>::raw_face_iterator
DoFHandler<2>::last_raw_face () const {
return last_raw_line ();
-};
+}
template <>
DoFDimensionInfo<2>::raw_face_iterator
DoFHandler<2>::last_raw_face (const unsigned int level) const {
return last_raw_line (level);
-};
+}
template <>
DoFDimensionInfo<2>::face_iterator
DoFHandler<2>::last_face () const {
return last_line ();
-};
+}
template <>
DoFDimensionInfo<2>::face_iterator
DoFHandler<2>::last_face (const unsigned int level) const {
return last_line (level);
-};
+}
template <>
DoFDimensionInfo<2>::active_face_iterator
DoFHandler<2>::last_active_face () const {
return last_active_line ();
-};
+}
template <>
DoFDimensionInfo<2>::active_face_iterator
DoFHandler<2>::last_active_face (const unsigned int level) const {
return last_active_line (level);
-};
+}
template <>
DoFHandler<2>::begin_raw_hex (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<2>::begin_hex (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<2>::begin_active_hex (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<2>::end_hex () const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<2>::last_raw_hex (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<2>::last_raw_hex () const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<2>::last_hex (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<2>::last_hex () const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<2>::last_active_hex (const unsigned int) const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <>
DoFHandler<2>::last_active_hex () const {
Assert (false, ExcNotImplemented());
return 0;
-};
+}
#endif
DoFHandler<3>::raw_cell_iterator
DoFHandler<3>::begin_raw (const unsigned int level) const {
return begin_raw_hex (level);
-};
+}
template <>
DoFHandler<3>::cell_iterator
DoFHandler<3>::begin (const unsigned int level) const {
return begin_hex (level);
-};
+}
template <>
DoFHandler<3>::active_cell_iterator
DoFHandler<3>::begin_active (const unsigned int level) const {
return begin_active_hex (level);
-};
+}
template <>
DoFHandler<3>::raw_cell_iterator
DoFHandler<3>::end () const {
return end_hex ();
-};
+}
template <>
DoFHandler<3>::raw_cell_iterator
DoFHandler<3>::last_raw () const {
return last_raw_hex ();
-};
+}
template <>
DoFHandler<3>::raw_cell_iterator
DoFHandler<3>::last_raw (const unsigned int level) const {
return last_raw_hex (level);
-};
+}
template <>
DoFHandler<3>::cell_iterator
DoFHandler<3>::last () const {
return last_hex ();
-};
+}
template <>
DoFHandler<3>::cell_iterator
DoFHandler<3>::last (const unsigned int level) const {
return last_hex (level);
-};
+}
template <>
DoFHandler<3>::active_cell_iterator
DoFHandler<3>::last_active () const {
return last_active_hex ();
-};
+}
template <>
DoFHandler<3>::active_cell_iterator
DoFHandler<3>::last_active (const unsigned int level) const {
return last_active_hex (level);
-};
+}
template <>
DoFHandler<3>::raw_face_iterator
DoFHandler<3>::begin_raw_face (const unsigned int level) const {
return begin_raw_quad (level);
-};
+}
template <>
DoFHandler<3>::face_iterator
DoFHandler<3>::begin_face (const unsigned int level) const {
return begin_quad (level);
-};
+}
template <>
DoFHandler<3>::active_face_iterator
DoFHandler<3>::begin_active_face (const unsigned int level) const {
return begin_active_quad (level);
-};
+}
template <>
DoFHandler<3>::raw_face_iterator
DoFHandler<3>::end_face () const {
return end_quad ();
-};
+}
template <>
DoFHandler<3>::raw_face_iterator
DoFHandler<3>::last_raw_face () const {
return last_raw_quad ();
-};
+}
template <>
DoFHandler<3>::raw_face_iterator
DoFHandler<3>::last_raw_face (const unsigned int level) const {
return last_raw_quad (level);
-};
+}
template <>
DoFHandler<3>::face_iterator
DoFHandler<3>::last_face () const {
return last_quad ();
-};
+}
template <>
DoFHandler<3>::face_iterator
DoFHandler<3>::last_face (const unsigned int level) const {
return last_quad (level);
-};
+}
template <>
DoFHandler<3>::active_face_iterator
DoFHandler<3>::last_active_face () const {
return last_active_quad ();
-};
+}
template <>
DoFHandler<3>::active_face_iterator
DoFHandler<3>::last_active_face (const unsigned int level) const {
return last_active_quad (level);
-};
+}
#endif
tria->begin_raw_line(level)->level(),
tria->begin_raw_line(level)->index(),
this);
-};
+}
template <int dim>
tria->begin_line(level)->level(),
tria->begin_line(level)->index(),
this);
-};
+}
template <int dim>
tria->begin_active_line(level)->level(),
tria->begin_active_line(level)->index(),
this);
-};
+}
template <int dim>
tria->begin_raw_quad(level)->level(),
tria->begin_raw_quad(level)->index(),
this);
-};
+}
template <int dim>
tria->begin_quad(level)->level(),
tria->begin_quad(level)->index(),
this);
-};
+}
template <int dim>
tria->begin_active_quad(level)->level(),
tria->begin_active_quad(level)->index(),
this);
-};
+}
template <int dim>
tria->begin_raw_hex(level)->level(),
tria->begin_raw_hex(level)->index(),
this);
-};
+}
template <int dim>
tria->begin_hex(level)->level(),
tria->begin_hex(level)->index(),
this);
-};
+}
template <int dim>
tria->begin_active_hex(level)->level(),
tria->begin_active_hex(level)->index(),
this);
-};
+}
template <int dim>
typename DoFHandler<dim>::raw_line_iterator
DoFHandler<dim>::end_line () const {
return raw_line_iterator (tria, -1, -1, this);
-};
+}
template <int dim>
typename DoFHandler<dim>::raw_quad_iterator
DoFHandler<dim>::end_quad () const {
return raw_quad_iterator (tria, -1, -1, this);
-};
+}
template <int dim>
typename DoFHandler<dim>::raw_hex_iterator
DoFHandler<dim>::end_hex () const {
return raw_hex_iterator (tria, -1, -1, this);
-};
+}
template <int dim>
return (level == levels.size()-1 ?
end() :
begin_raw (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
cell_iterator(end()) :
begin (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
active_cell_iterator(end()) :
begin_active (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
end_face() :
begin_raw_face (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
face_iterator(end_face()) :
begin_face (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
active_face_iterator(end_face()) :
begin_active_face (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
end_line() :
begin_raw_line (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
line_iterator(end_line()) :
begin_line (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
active_line_iterator(end_line()) :
begin_active_line (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
end_quad() :
begin_raw_quad (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
quad_iterator(end_quad()) :
begin_quad (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
active_quad_iterator(end_quad()) :
begin_active_quad (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
end_hex() :
begin_raw_hex (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
hex_iterator(end_hex()) :
begin_hex (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
active_hex_iterator(end_hex()) :
begin_active_hex (level+1));
-};
+}
template <int dim>
tria->last_raw_line(level)->level(),
tria->last_raw_line(level)->index(),
this);
-};
+}
template <int dim>
tria->last_line(level)->level(),
tria->last_line(level)->index(),
this);
-};
+}
template <int dim>
tria->last_active_line(level)->level(),
tria->last_active_line(level)->index(),
this);
-};
+}
template <int dim>
tria->last_raw_quad(level)->level(),
tria->last_raw_quad(level)->index(),
this);
-};
+}
template <int dim>
tria->last_quad(level)->level(),
tria->last_quad(level)->index(),
this);
-};
+}
template <int dim>
tria->last_active_quad(level)->level(),
tria->last_active_quad(level)->index(),
this);
-};
+}
template <int dim>
tria->last_raw_hex(level)->level(),
tria->last_raw_hex(level)->index(),
this);
-};
+}
template <int dim>
tria->last_hex(level)->level(),
tria->last_hex(level)->index(),
this);
-};
+}
template <int dim>
tria->last_active_hex(level)->level(),
tria->last_active_hex(level)->index(),
this);
-};
+}
template <int dim>
typename DoFHandler<dim>::raw_line_iterator
DoFHandler<dim>::last_raw_line () const {
return last_raw_line (levels.size()-1);
-};
+}
template <int dim>
typename DoFHandler<dim>::raw_quad_iterator
DoFHandler<dim>::last_raw_quad () const {
return last_raw_quad (levels.size()-1);
-};
+}
template <int dim>
typename DoFHandler<dim>::raw_hex_iterator
DoFHandler<dim>::last_raw_hex () const {
return last_raw_hex (levels.size()-1);
-};
+}
template <int dim>
typename DoFHandler<dim>::line_iterator
DoFHandler<dim>::last_line () const {
return last_line (levels.size()-1);
-};
+}
template <int dim>
typename DoFHandler<dim>::quad_iterator
DoFHandler<dim>::last_quad () const {
return last_quad (levels.size()-1);
-};
+}
template <int dim>
typename DoFHandler<dim>::hex_iterator
DoFHandler<dim>::last_hex () const {
return last_hex (levels.size()-1);
-};
+}
template <int dim>
typename DoFHandler<dim>::active_line_iterator
DoFHandler<dim>::last_active_line () const {
return last_active_line (levels.size()-1);
-};
+}
template <int dim>
typename DoFHandler<dim>::active_quad_iterator
DoFHandler<dim>::last_active_quad () const {
return last_active_quad (levels.size()-1);
-};
+}
template <int dim>
typename DoFHandler<dim>::active_hex_iterator
DoFHandler<dim>::last_active_hex () const {
return last_active_hex (levels.size()-1);
-};
+}
//------------------------------------------------------------------
{
Assert (selected_fe != 0, ExcNoFESelected());
return 2*selected_fe->dofs_per_vertex;
-};
+}
ExcInvalidBoundaryIndicator());
return boundary_indicators.size()*selected_fe->dofs_per_vertex;
-};
+}
ExcInvalidBoundaryIndicator());
return boundary_indicators.size()*selected_fe->dofs_per_vertex;
-};
+}
#endif
boundary_dofs.insert(dofs_on_face[i]);
};
return boundary_dofs.size();
-};
+}
boundary_dofs.insert(dofs_on_face[i]);
};
return boundary_dofs.size();
-};
+}
boundary_dofs.insert(dofs_on_face[i]);
};
return boundary_dofs.size();
-};
+}
const Triangulation<dim> & DoFHandler<dim>::get_tria () const
{
return *tria;
-};
+}
mem += MemoryConsumption::memory_consumption (*levels[i]);
return mem;
-};
+}
// finally restore the user flags
const_cast<Triangulation<dim> &>(*tria).load_user_flags(user_flags);
-};
+}
template <int dim>
// release memory
clear_space ();
-};
+}
#if deal_II_dimension == 1
cell->set_user_flag ();
return next_free_dof;
-};
+}
#endif
cell->set_user_flag ();
return next_free_dof;
-};
+}
#endif
cell->set_user_flag ();
return next_free_dof;
-};
+}
#endif
i!=levels[level]->line_dofs.end(); ++i)
if (*i != invalid_dof_index)
*i = new_numbers[*i];
-};
+}
#endif
if (*i != invalid_dof_index)
*i = new_numbers[*i];
};
-};
+}
#endif
if (*i != invalid_dof_index)
*i = new_numbers[*i];
};
-};
+}
#endif
Assert (selected_fe != 0, ExcNoFESelected());
return std::min(3*selected_fe->dofs_per_vertex +
2*selected_fe->dofs_per_line, n_dofs());
-};
+}
{
Assert (selected_fe != 0, ExcNoFESelected());
return selected_fe->dofs_per_vertex;
-};
+}
#endif
max_couplings=0;
};
return std::min(max_couplings,n_dofs());
-};
+}
{
Assert (selected_fe != 0, ExcNoFESelected());
return 3*selected_fe->dofs_per_vertex + 2*selected_fe->dofs_per_line;
-};
+}
#endif
}
return std::min(max_couplings,n_dofs());
-};
+}
template <>
return (19*selected_fe->dofs_per_vertex +
28*selected_fe->dofs_per_line +
8*selected_fe->dofs_per_quad);
-};
+}
#endif
selected_fe->dofs_per_line,
invalid_dof_index);
};
-};
+}
#endif
selected_fe->dofs_per_quad,
invalid_dof_index);
};
-};
+}
#endif
selected_fe->dofs_per_hex,
invalid_dof_index);
};
-};
+}
#endif
std::vector<unsigned int> tmp;
std::swap (vertex_dofs, tmp);
-};
+}
/*-------------- Explicit Instantiations -------------------------------*/
DoFLevel<1>::memory_consumption () const
{
return MemoryConsumption::memory_consumption (line_dofs);
-};
+}
{
return (DoFLevel<1>::memory_consumption () +
MemoryConsumption::memory_consumption (quad_dofs));
-};
+}
{
return (DoFLevel<2>::memory_consumption () +
MemoryConsumption::memory_consumption (hex_dofs));
-};
+}
// this is dimension specific and
// thus needs an own function
dof_handler.renumber_dofs (new_number);
-};
+}
#ifdef ENABLE_MULTIGRID
// this is dimension specific and
// thus needs an own function
dof_handler.renumber_dofs (level, new_number);
-};
+}
#endif
ExcInternalError());
dof_handler.renumber_dofs (new_indices);
-};
+}
ExcInternalError());
dof_handler.renumber_dofs (level, new_indices);
-};
+}
// now perform the renumbering
dof_handler.renumber_dofs (new_dof_indices);
-};
+}
template <int dim>
std::random_shuffle (new_indices.begin(), new_indices.end());
dof_handler.renumber_dofs(new_indices);
-};
+}
sparsity.add (boundary_dof_boundary_indices[i],
boundary_dof_boundary_indices[j]);
};
-};
+}
boundary_indicators[1] = 0;
make_boundary_sparsity_pattern (dof_handler, boundary_indicators,
dof_to_boundary_mapping, sparsity);
-};
+}
#endif
sparsity.add (dof_to_boundary_mapping[dofs_on_this_face[i]],
dof_to_boundary_mapping[dofs_on_this_face[j]]);
};
-};
+}
Assert (dof_to_boundary_mapping.size() == n_dofs, ExcInternalError());
Assert (boundary_indicators.find(255) == boundary_indicators.end(),
- DoFHandler<dim>::ExcInvalidBoundaryIndicator());
+ typename DoFHandler<dim>::ExcInvalidBoundaryIndicator());
Assert (sparsity.n_rows() == dof.n_boundary_dofs(boundary_indicators),
ExcDimensionMismatch (sparsity.n_rows(), dof.n_boundary_dofs(boundary_indicators)));
Assert (sparsity.n_cols() == dof.n_boundary_dofs(boundary_indicators),
sparsity.add (dof_to_boundary_mapping[dofs_on_this_face[i]],
dof_to_boundary_mapping[dofs_on_this_face[j]]);
};
-};
+}
sparsity.add (local_dof_indices[i], neighbor_dof_indices[j]);
};
};
-};
+}
#endif
ConstraintMatrix &)
{
// nothing to be done here
-};
+}
#endif
fe.constraints()(row,i));
};
};
-};
+}
#endif
fe.constraints()(row,i));
};
};
-};
+}
#endif
if (touch_count[i] != 0)
dof_data(i) /= touch_count[i];
};
-};
+}
template<int dim>
== true))
selected_dofs[face_dof_indices[i]] = true;
};
-};
+}
#else
face_system_to_component_index(i).first] == true))
selected_dofs[cell->vertex_dof_index(1,i)] = true;
};
-};
+}
#endif
std::fill_n (selected_dofs.begin(), dof_handler.n_dofs(), false);
// there are no hanging nodes in 1d
-};
+}
#endif
for (unsigned int dof=0; dof!=fe.dofs_per_line; ++dof)
selected_dofs[line->child(child)->dof_index(dof)] = true;
};
-};
+}
#endif
for (unsigned int dof=0; dof!=fe.dofs_per_quad; ++dof)
selected_dofs[face->child(child)->dof_index(dof)] = true;
};
-};
+}
#endif
for (unsigned int i=0; i<dofs_per_cell; ++i)
selected_dofs[local_dof_indices[i]] = true;
};
-};
+}
== dof_handler.n_dofs()),
ExcInternalError());
-};
+}
constraints.add_entries (global_dof, constraint_line);
};
-};
+}
transfer_representation[p][i] = j->second;
};
};
-};
+}
return n_parameters_on_fine_grid;
-};
+}
// wait for the threads to finish
thread_manager.wait ();
-};
+}
mutex.release ();
};
};
-};
+}
for (unsigned int i=0; i<dof_handler.get_fe().dofs_per_vertex; ++i)
mapping[cell->vertex_dof_index(direction,i)] = next_free_index++;
};
-};
+}
boundary_indicators.insert (0U);
boundary_indicators.insert (1U);
map_dof_to_boundary_indices (dof_handler, boundary_indicators, mapping);
-};
+}
#else
Assert (next_boundary_index == dof_handler.n_boundary_dofs(),
ExcInternalError());
-};
+}
Assert (next_boundary_index == dof_handler.n_boundary_dofs(boundary_indicators),
ExcInternalError());
-};
+}
#endif
for (unsigned int i=0; i<dofs_per_cell; ++i)
support_points[local_dof_indices[i]] = points[i];
};
-};
+}
face_system_to_component_table[j] = std::pair<unsigned,unsigned>(0,j);
face_system_to_base_table[j] = std::make_pair(std::make_pair(0U,0U),j);
}
-};
+}
template <int dim>
ExcIndexRange(child, 0, GeometryInfo<dim>::children_per_cell));
Assert (restriction[child].n() != 0, ExcProjectionVoid());
return restriction[child];
-};
+}
ExcIndexRange(child, 0, GeometryInfo<dim>::children_per_cell));
Assert (prolongation[child].n() != 0, ExcEmbeddingVoid());
return prolongation[child];
-};
+}
interface_constraints.n()));
return interface_constraints;
-};
+}
};
return TableIndices<2> (static_cast<unsigned int>(-1),
static_cast<unsigned int>(-1));
-};
+}
return ((static_cast<const FiniteElementData<dim>&>(*this) ==
static_cast<const FiniteElementData<dim>&>(f)) &&
(interface_constraints == f.interface_constraints));
-};
+}
(unit_support_points.size() == this->dofs_per_cell),
ExcInternalError());
return unit_support_points;
-};
+}
FiniteElementBase<dim>::has_support_points () const
{
return (unit_support_points.size() != 0);
-};
+}
Assert (unit_support_points.size() == this->dofs_per_cell,
ExcFEHasNoSupportPoints ());
return unit_support_points[index];
-};
+}
(unit_face_support_points.size() == this->dofs_per_face),
ExcInternalError());
return unit_face_support_points;
-};
+}
FiniteElementBase<dim>::has_face_support_points () const
{
return (unit_face_support_points.size() != 0);
-};
+}
Assert (unit_face_support_points.size() == this->dofs_per_face,
ExcFEHasNoSupportPoints ());
return unit_face_support_points[index];
-};
+}
MemoryConsumption::memory_consumption (restriction_is_additive_flags) +
MemoryConsumption::memory_consumption (nonzero_components) +
MemoryConsumption::memory_consumption (n_nonzero_components_table));
-};
+}
nonzero_components[i].end(),
true);
return retval;
-};
+}
components(n_components)
{
Assert(dofs_per_object.size()==dim+1, ExcDimensionMismatch(dofs_per_object.size()-1,dim));
-};
+}
(dofs_per_quad == f.dofs_per_quad) &&
(dofs_per_hex == f.dofs_per_hex) &&
(components == f.components));
-};
+}
template class FiniteElementData<1>;
// elements have neither support
// nor face-support points, so
// leave these fields empty
-};
+}
FE_DGP<dim>::n_base_elements () const
{
return 1;
-};
+}
{
Assert (index==0, ExcIndexRange(index, 0, 1));
return *this;
-};
+}
{
Assert (index==0, ExcIndexRange(index, 0, 1));
return 1;
-};
+}
FE_DGP<dim>::get_degree () const
{
return degree;
-};
+}
0, 0, 0, 0, 0, 1./32., 5.044891251/27.,
0, 0, 0, 0, 0., 0., 1./64.,
};
-};
+}
template <>
#else // #if deal_II_dimension
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
-namespace { void dummy () {}; };
+namespace { void dummy () {} }
#endif // #if deal_II_dimension
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1./64., 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0., 0., 0, 0., 0., 1./64.,
};
-};
+}
template <>
#else // #if deal_II_dimension
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
-namespace { void dummy () {}; };
+namespace { void dummy () {} }
#endif // #if deal_II_dimension == 2
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1./16., 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1./16.,
};
-};
+}
template <>
#else // #if deal_II_dimension
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
-namespace { void dummy () {}; };
+namespace { void dummy () {} }
#endif // #if deal_II_dimension
// elements have neither support
// nor face-support points, so
// leave these fields empty
-};
+}
FE_DGPNonparametric<dim>::n_base_elements () const
{
return 1;
-};
+}
{
Assert (index==0, ExcIndexRange(index, 0, 1));
return *this;
-};
+}
{
Assert (index==0, ExcIndexRange(index, 0, 1));
return 1;
-};
+}
FE_DGPNonparametric<dim>::get_degree () const
{
return degree;
-};
+}
// note: no face support points for
// DG elements
-};
+}
FE_DGQ<dim>::n_base_elements () const
{
return 1;
-};
+}
{
Assert (index==0, ExcIndexRange(index, 0, 1));
return *this;
-};
+}
{
Assert (index==0, ExcIndexRange(index, 0, 1));
return 1;
-};
+}
FE_DGQ<dim>::get_degree () const
{
return degree;
-};
+}
-0.012439378, 0.040990099, -0.017439155, -0.050376157, 0.0042995099, 0.054999345, 0.038394855, -0.001831157,
-0.050934606, 0.18647931, -0.15057292, -0.1043873, -0.016304977, 0.28934245, 0.015028935, -0.031932147,
};
-};
+}
#else // #if deal_II_dimension
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
-namespace { void dummy () {}; };
+namespace { void dummy () {} }
#endif // #if deal_II_dimension == 1
0.00063359485, -0.0020878146, 0.00088825647, 0.0025658897, -0.00021899385, -0.00280137, -0.0019556268, 9.3269261e-05, -0.0023196867, 0.0076438055, -0.0032520415, -0.0093941111, 0.00080176965, 0.01025624, 0.0071598461, -0.00034147289, 0.0018730335, -0.0061719988, 0.0026258644, 0.0075852849, -0.00064738975, -0.0082814118, -0.0057812253, 0.00027572265, 0.0012985131, -0.0042788457, 0.0018204262, 0.0052586309, -0.00044881422, -0.005741233, -0.0040079352, 0.00019114953, 0.00020282378, -0.00066834262, 0.00028434501, 0.00082138208, -7.010341e-05, -0.00089676305, -0.00062602722, 2.9856972e-05, -0.0035992402, 0.011860176, -0.0050458877, -0.014575961, 0.0012440307, 0.015913645, 0.011109261, -0.00052983145, -0.00018695061, 0.00061603754, -0.00026209192, -0.0007571, 6.4617056e-05, 0.00082658159, 0.00057703379, -2.752034e-05, 0.00039721606, -0.0013089019, 0.00055686965, 0.0016086189, -0.00013729258, -0.0017562472, -0.0012260302, 5.8472774e-05,
0.0025943341, -0.0094982503, 0.0076693723, 0.0053169259, 0.00083048758, -0.014737544, -0.0007654929, 0.0016264513, -0.0094982503, 0.034774534, -0.028078734, -0.019466071, -0.0030405409, 0.05395638, 0.0028025855, -0.0059546848, 0.0076693723, -0.028078734, 0.022672203, 0.0157179, 0.0024550879, -0.043567136, -0.0022629506, 0.0048081165, 0.0053169259, -0.019466071, 0.0157179, 0.010896708, 0.0017020325, -0.030203676, -0.0015688299, 0.0033333105, 0.00083048758, -0.0030405409, 0.0024550879, 0.0017020325, 0.00026585227, -0.0047177219, -0.00024504644, 0.00052065292, -0.014737544, 0.05395638, -0.043567136, -0.030203676, -0.0047177219, 0.083719052, 0.0043485089, -0.0092393256, -0.0007654929, 0.0028025855, -0.0022629506, -0.0015688299, -0.00024504644, 0.0043485089, 0.00022586889, -0.00047990617, 0.0016264513, -0.0059546848, 0.0048081165, 0.0033333105, 0.00052065292, -0.0092393256, -0.00047990617, 0.001019662,
};
-};
+}
template <>
#else // #if deal_II_dimension
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
-namespace { void dummy () {}; };
+namespace { void dummy () {} }
#endif // #if deal_II_dimension == 2
-5.6211513e-05, 0.00027635624, -0.00023302227, -0.00049874943, 1.1242303e-05, 8.9938421e-05, -0.00044216998, 0.00037283564, 0.00079799909, -1.7987684e-05, 0.00013490763, -0.00066325498, 0.00055925346, 0.0011969986, -2.6981526e-05, -0.0002338399, 0.001149642, -0.00096937266, -0.0020747976, 4.6767979e-05, -5.6211513e-05, 0.00027635624, -0.00023302227, -0.00049874943, 1.1242303e-05, 8.9938421e-05, -0.00044216998, 0.00037283564, 0.00079799909, -1.7987684e-05, -0.00014390147, 0.00070747198, -0.00059653702, -0.0012767985, 2.8780295e-05, -0.00021585221, 0.001061208, -0.00089480553, -0.0019151978, 4.3170442e-05, 0.00037414383, -0.0018394271, 0.0015509963, 0.0033196762, -7.4828767e-05, 8.9938421e-05, -0.00044216998, 0.00037283564, 0.00079799909, -1.7987684e-05, 0.00013490763, -0.00066325498, 0.00055925346, 0.0011969986, -2.6981526e-05, -0.00021585221, 0.001061208, -0.00089480553, -0.0019151978, 4.3170442e-05, -0.00032377832, 0.0015918119, -0.0013422083, -0.0028727967, 6.4755663e-05, 0.00056121575, -0.0027591407, 0.0023264944, 0.0049795143, -0.00011224315, 0.00013490763, -0.00066325498, 0.00055925346, 0.0011969986, -2.6981526e-05, -0.0002338399, 0.001149642, -0.00096937266, -0.0020747976, 4.6767979e-05, 0.00037414383, -0.0018394271, 0.0015509963, 0.0033196762, -7.4828767e-05, 0.00056121575, -0.0027591407, 0.0023264944, 0.0049795143, -0.00011224315, -0.00097277397, 0.0047825106, -0.0040325903, -0.0086311581, 0.00019455479, -0.0002338399, 0.001149642, -0.00096937266, -0.0020747976, 4.6767979e-05, -5.6211513e-05, 0.00027635624, -0.00023302227, -0.00049874943, 1.1242303e-05, 8.9938421e-05, -0.00044216998, 0.00037283564, 0.00079799909, -1.7987684e-05, 0.00013490763, -0.00066325498, 0.00055925346, 0.0011969986, -2.6981526e-05, -0.0002338399, 0.001149642, -0.00096937266, -0.0020747976, 4.6767979e-05, -5.6211513e-05, 0.00027635624, -0.00023302227, -0.00049874943, 1.1242303e-05,
0.00065409761, -0.0010465562, -0.0015698343, 0.0027210461, 0.00065409761, -0.0010465562, 0.0016744899, 0.0025117348, -0.0043536737, -0.0010465562, -0.0015698343, 0.0025117348, 0.0037676022, -0.0065305105, -0.0015698343, 0.0027210461, -0.0043536737, -0.0065305105, 0.011319552, 0.0027210461, 0.00065409761, -0.0010465562, -0.0015698343, 0.0027210461, 0.00065409761, -0.0010465562, 0.0016744899, 0.0025117348, -0.0043536737, -0.0010465562, 0.0016744899, -0.0026791838, -0.0040187757, 0.0069658779, 0.0016744899, 0.0025117348, -0.0040187757, -0.0060281636, 0.010448817, 0.0025117348, -0.0043536737, 0.0069658779, 0.010448817, -0.018111283, -0.0043536737, -0.0010465562, 0.0016744899, 0.0025117348, -0.0043536737, -0.0010465562, -0.0015698343, 0.0025117348, 0.0037676022, -0.0065305105, -0.0015698343, 0.0025117348, -0.0040187757, -0.0060281636, 0.010448817, 0.0025117348, 0.0037676022, -0.0060281636, -0.0090422454, 0.015673225, 0.0037676022, -0.0065305105, 0.010448817, 0.015673225, -0.027166924, -0.0065305105, -0.0015698343, 0.0025117348, 0.0037676022, -0.0065305105, -0.0015698343, 0.0027210461, -0.0043536737, -0.0065305105, 0.011319552, 0.0027210461, -0.0043536737, 0.0069658779, 0.010448817, -0.018111283, -0.0043536737, -0.0065305105, 0.010448817, 0.015673225, -0.027166924, -0.0065305105, 0.011319552, -0.018111283, -0.027166924, 0.047089335, 0.011319552, 0.0027210461, -0.0043536737, -0.0065305105, 0.011319552, 0.0027210461, 0.00065409761, -0.0010465562, -0.0015698343, 0.0027210461, 0.00065409761, -0.0010465562, 0.0016744899, 0.0025117348, -0.0043536737, -0.0010465562, -0.0015698343, 0.0025117348, 0.0037676022, -0.0065305105, -0.0015698343, 0.0027210461, -0.0043536737, -0.0065305105, 0.011319552, 0.0027210461, 0.00065409761, -0.0010465562, -0.0015698343, 0.0027210461, 0.00065409761,
};
-};
+}
template <>
#else // #if deal_II_dimension
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
-namespace { void dummy () {}; };
+namespace { void dummy () {} }
#endif // #if deal_II_dimension == 3
std::vector<std::pair<unsigned,unsigned> > tmp1, tmp2;
this->system_to_component_table.swap (tmp1);
this->face_system_to_component_table.swap (tmp2);
-};
+}
// right now
Assert (false, ExcNotImplemented());
};
-};
+}
#if deal_II_dimension == 1
void FE_Nedelec<1>::initialize_unit_face_support_points ()
{
// no faces in 1d, so nothing to do
-};
+}
#endif
// right now
Assert (false, ExcNotImplemented());
};
-};
+}
if (flags & update_second_derivatives)
this->compute_2nd (mapping, cell, 0, mapping_data, fe_data, data);
-};
+}
if (flags & update_second_derivatives)
this->compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
-};
+}
FE_Nedelec<dim>::n_base_elements () const
{
return 1;
-};
+}
{
Assert (index==0, ExcIndexRange(index, 0, 1));
return *this;
-};
+}
{
Assert (index==0, ExcIndexRange(index, 0, 1));
return 1;
-};
+}
FE_Nedelec<dim>::get_degree () const
{
return degree;
-};
+}
#else // #if deal_II_dimension
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
-namespace { void dummy () {}; };
+namespace { void dummy () {} }
#endif // #if deal_II_dimension == 1
0., 0., .5, 0.,
0., 0., 0., .5,
};
-}; // namespace FE_Nedelec_2d
+} // namespace FE_Nedelec_2d
// embedding matrices
1./2., 1./2.
};
-};
+}
template <>
#else // #if deal_II_dimension
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
-namespace { void dummy () {}; };
+namespace { void dummy () {} }
#endif // #if deal_II_dimension == 2
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.5,
};
-}; // namespace FE_Nedelec_3d
+} // namespace FE_Nedelec_3d
// embedding matrices
0, 0, 0, .5,
0, 0, 0, .5
};
-};
+}
#else // #if deal_II_dimension
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
-namespace { void dummy () {}; };
+namespace { void dummy () {} }
#endif // #if deal_II_dimension == 3
// on cell and face
initialize_unit_support_points ();
initialize_unit_face_support_points ();
-};
+}
this->unit_support_points[renumber[k++]] = p;
};
-};
+}
#if deal_II_dimension == 1
void FE_Q<1>::initialize_unit_face_support_points ()
{
// no faces in 1d, so nothing to do
-};
+}
#endif
this->unit_face_support_points[face_renumber[k++]] = p;
};
-};
+}
FE_Q<dim>::n_base_elements () const
{
return 1;
-};
+}
{
Assert (index==0, ExcIndexRange(index, 0, 1));
return *this;
-};
+}
{
Assert (index==0, ExcIndexRange(index, 0, 1));
return 1;
-};
+}
// we should not have gotten here
Assert (false, ExcInternalError());
return false;
-};
+}
FE_Q<dim>::get_degree () const
{
return degree;
-};
+}
-1.0546875/27., 7.3828125/27., 5.90625/27., -14.765625/27., 29.53125/27.,
};
-}; // namespace FE_Q_1d
+} // namespace FE_Q_1d
#else // #if deal_II_dimension
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
-namespace { void dummy () {}; };
+namespace { void dummy () {} }
#endif // #if deal_II_dimension == 1
0., 0., 0., 0., 1.6875/27., 0., 0., 0., 8.4375/27., 0., 0., 0., -8.4375/27., 0., 25.3125/27., 0.,
};
-}; // namespace FE_Q_2d
+} // namespace FE_Q_2d
// embedding matrices
0., 0., 0., 0., 1.,
-0.0390625, 0.2734375, 0.21875, -0.546875, 1.09375
};
-};
+}
template <>
#else // #if deal_II_dimension
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
-namespace { void dummy () {}; };
+namespace { void dummy () {} }
#endif // #if deal_II_dimension == 2
0.421875/27., 0., 0., -1.265625/27., -1.265625/27., 0., 0., 3.796875/27., 0., 0., 0., -2.53125/27., 0., 0., 0., 7.59375/27., -2.53125/27., 0., 0., 7.59375/27., 0., 0., 0., 0., 0., 15.1875/27., 0.,
0.158203125/27., -0.052734375/27., 0.158203125/27., -0.474609375/27., -0.474609375/27., 0.158203125/27., -0.474609375/27., 1.423828125/27., 0.31640625/27., 0.31640625/27., -0.94921875/27., -0.94921875/27., -0.94921875/27., -0.94921875/27., 2.84765625/27., 2.84765625/27., -0.94921875/27., 0.31640625/27., -0.94921875/27., 2.84765625/27., -1.8984375/27., 5.6953125/27., -1.8984375/27., -1.8984375/27., 5.6953125/27., 5.6953125/27., 11.390625/27.,
};
-}; // namespace FE_Q_3d
+} // namespace FE_Q_3d
// embedding matrices
.015625,-.046875,.140625,-.046875,-.09375,.28125,.28125,-.09375,.5625,
-.046875,.015625,-.046875,.140625,-.09375,-.09375,.28125,.28125,.5625
};
-};
+}
#else // #if deal_II_dimension
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
-namespace { void dummy () {}; };
+namespace { void dummy () {} }
#endif // #if deal_II_dimension == 3
// on cell and face
initialize_unit_support_points ();
initialize_unit_face_support_points ();
-};
+}
}
this->unit_support_points[renumber[k++]] = p;
};
-};
+}
#if deal_II_dimension == 1
void FE_Q_Hierarchical<1>::initialize_unit_face_support_points ()
{
// no faces in 1d, so nothing to do
-};
+}
#endif
}
this->unit_face_support_points[face_renumber[k++]] = p;
};
-};
+}
// we use same dpo_vector as FE_Q
FE_Q_Hierarchical<dim>::n_base_elements () const
{
return 1;
-};
+}
{
Assert (index==0, ExcIndexRange(index, 0, 1));
return *this;
-};
+}
{
Assert (index==0, ExcIndexRange(index, 0, 1));
return 1;
-};
+}
FE_Q_Hierarchical<dim>::get_degree () const
{
return degree;
-};
+}
delete base_fe_values_datas[i];
base_fe_values_datas[i] = 0;
};
-};
+}
Assert(base_no<base_fe_datas.size(),
ExcIndexRange(base_no,0,base_fe_datas.size()));
return *base_fe_datas[base_no];
-};
+}
Assert(base_no<base_fe_datas.size(),
ExcIndexRange(base_no,0,base_fe_datas.size()));
base_fe_datas[base_no]=ptr;
-};
+}
ExcIndexRange(base_no,0,base_fe_values_datas.size()));
Assert(base_fe_values_datas[base_no]!=0, ExcInternalError());
return *base_fe_values_datas[base_no];
-};
+}
Assert(base_no<base_fe_values_datas.size(),
ExcIndexRange(base_no,0,base_fe_values_datas.size()));
base_fe_values_datas[base_no]=ptr;
-};
+}
// sub-objects
for (unsigned int i=0; i<base_fe_datas.size(); ++i)
base_fe_datas[i]->clear_first_cell ();
-};
+}
/* ---------------------------------- FESystem ------------------- */
base_elements[0] = ElementPair(fe.clone(), n_elements);
base_elements[0].first->subscribe ();
initialize ();
-};
+}
base_elements[1] = ElementPair(fe2.clone(), n2);
base_elements[1].first->subscribe ();
initialize ();
-};
+}
base_elements[2] = ElementPair(fe3.clone(), n3);
base_elements[2].first->subscribe ();
initialize ();
-};
+}
delete base_elements[i].first;
base_elements[i].first = 0;
}
-};
+}
{
compute_fill(mapping, cell, invalid_face_number, invalid_face_number,
quadrature, mapping_data, fe_data, data);
-};
+}
{
compute_fill (mapping, cell, face_no, invalid_face_number,
quadrature, mapping_data, fe_data, data);
-};
+}
this->system_to_component_table[total_index] = non_primitive_index;
}
}
-};
+}
ExcInternalError());
Assert (total_index == this->face_system_to_base_table.size(),
ExcInternalError());
-};
+}
= (base_element(n_index.first.first).constraints()(m_index.second,
n_index.second));
};
-};
+}
// on cell and face
initialize_unit_support_points ();
initialize_unit_face_support_points ();
-};
+}
if (dim>2) dpo.push_back(fe_data.dofs_per_hex * N);
return FiniteElementData<dim> (dpo, fe_data.n_components() * N);
-};
+}
initialize_unit_face_support_points ()
{
// no faces no work
-};
+}
#endif
return FiniteElementData<dim> (dpo,
fe1.n_components() * N1 +
fe2.n_components() * N2);
-};
+}
fe1.n_components() * N1 +
fe2.n_components() * N2 +
fe3.n_components() * N3);
-};
+}
multiplicities.push_back (n_elements);
return compute_restriction_is_additive_flags (fe_list, multiplicities);
-};
+}
multiplicities.push_back (N2);
return compute_restriction_is_additive_flags (fe_list, multiplicities);
-};
+}
multiplicities.push_back (N3);
return compute_restriction_is_additive_flags (fe_list, multiplicities);
-};
+}
Assert (total_index == n_shape_functions, ExcInternalError());
return retval;
-};
+}
multiplicities.push_back (N1);
return compute_nonzero_components (fe_list, multiplicities);
-};
+}
multiplicities.push_back (N2);
return compute_nonzero_components (fe_list, multiplicities);
-};
+}
multiplicities.push_back (N3);
return compute_nonzero_components (fe_list, multiplicities);
-};
+}
Assert (total_index == n_shape_functions, ExcInternalError());
return retval;
-};
+}
Assert (index < base_elements.size(),
ExcIndexRange(index, 0, base_elements.size()));
return *base_elements[index].first;
-};
+}
FESystem<dim>::n_base_elements () const
{
return base_elements.size();
-};
+}
Assert (index < base_elements.size(),
ExcIndexRange(index, 0, base_elements.size()));
return base_elements[index].second;
-};
+}
// provide this information
return (base_element(this->system_to_base_index(index).first.first)
.unit_support_point(this->system_to_base_index(index).second));
-};
+}
// provide this information
return (base_element(this->face_system_to_base_index(index).first.first)
.unit_face_support_point(this->face_system_to_base_index(index).second));
-};
+}
for (unsigned int i=0; i<base_elements.size(); ++i)
mem += MemoryConsumption::memory_consumption (*base_elements[i].first);
return mem;
-};
+}
default:
Assert (false, ExcNotImplemented());
};
-};
+}
}
}
}
-};
+}
for (unsigned int shape_func=0; shape_func<dofs_per_cell; ++shape_func)
values[point] += (dof_values(shape_func) *
this->shape_value(shape_func, point));
-};
+}
for (unsigned int c=0; c<n_components; ++c)
values[point](c) += (dof_values(shape_func) *
shape_value_component(shape_func, point, c));
-};
+}
{
Assert (this->update_flags & update_q_points, ExcAccessToUninitializedField());
return this->quadrature_points;
-};
+}
tmp *= dof_values(shape_func);
gradients[point] += tmp;
};
-};
+}
tmp *= dof_values(shape_func);
gradients[point][c] += tmp;
};
-};
+}
tmp *= dof_values(shape_func);
second_derivatives[point] += tmp;
};
-};
+}
tmp *= dof_values(shape_func);
second_derivs[point][c] += tmp;
};
-};
+}
Assert (i<this->quadrature_points.size(), ExcIndexRange(i, 0, this->quadrature_points.size()));
return this->quadrature_points[i];
-};
+}
Assert (i<this->JxW_values.size(), ExcIndexRange(i, 0, this->JxW_values.size()));
return this->JxW_values[i];
-};
+}
MemoryConsumption::memory_consumption (fe_data) +
MemoryConsumption::memory_consumption (*fe_data) +
MemoryConsumption::memory_consumption (this->shape_function_to_row_table));
-};
+}
| mapping->update_each (flags);
return flags;
-};
+}
quadrature (q)
{
initialize (update_flags);
-};
+}
{
Assert (DEAL_II_COMPAT_MAPPING, ExcCompatibility("mapping"));
initialize (update_flags);
-};
+}
// set up objects within this class
FEValuesData<dim>::initialize (this->n_quadrature_points, *this->fe, flags);
-};
+}
{
return (FEValuesBase<dim>::memory_consumption () +
MemoryConsumption::memory_consumption (quadrature));
-};
+}
/*------------------------------- FEFaceValuesBase --------------------------*/
mapping,
fe),
quadrature(quadrature)
-{};
+{}
Assert (this->update_flags & update_normal_vectors,
typename FEValuesBase<dim>::ExcAccessToUninitializedField());
return this->normal_vectors;
-};
+}
FEFaceValuesBase<dim>::get_boundary_forms () const
{
Assert (this->update_flags & update_boundary_forms,
- FEValuesBase<dim>::ExcAccessToUninitializedField());
+ typename FEValuesBase<dim>::ExcAccessToUninitializedField());
return this->boundary_forms;
-};
+}
return (FEValuesBase<dim>::memory_consumption () +
MemoryConsumption::memory_consumption (quadrature) +
MemoryConsumption::memory_consumption (present_face));
-};
+}
/*------------------------------- FEFaceValues -------------------------------*/
fe, quadrature)
{
initialize (update_flags);
-};
+}
{
Assert (DEAL_II_COMPAT_MAPPING, ExcCompatibility("mapping"));
initialize (update_flags);
-};
+}
// set up objects within this class
FEValuesData<dim>::initialize(this->n_quadrature_points, *this->fe, flags);
-};
+}
this->fe_data->clear_first_cell ();
this->mapping_data->clear_first_cell ();
-};
+}
/*------------------------------- FESubFaceValues -------------------------------*/
{
Assert (DEAL_II_COMPAT_MAPPING, ExcCompatibility("mapping"));
initialize (update_flags);
-};
+}
// set up objects within this class
FEValuesData<dim>::initialize(this->n_quadrature_points, *this->fe, flags);
-};
+}
this->fe_data->clear_first_cell ();
this->mapping_data->clear_first_cell ();
-};
+}
/*------------------------------- Explicit Instantiations -------------*/
MappingQ<dim> (3)
{
Assert (dim > 1, ExcImpossibleInDim(dim));
-};
+}
#if deal_II_dimension == 1
{
const unsigned int dim = 1;
Assert (dim > 1, ExcImpossibleInDim(dim));
-};
+}
#endif
a.insert (a.end(), line_points.begin(), line_points.end());
};
};
-};
+}
#endif
std::vector<Point<dim> > &) const
{
Assert (false, ExcNotImplemented());
-};
+}
{
const unsigned int dim = 1;
Assert (dim > 2, ExcImpossibleInDim(dim));
-};
+}
#endif
{
const unsigned int dim = 2;
Assert (dim > 2, ExcImpossibleInDim(dim));
-};
+}
#endif
std::vector<Point<dim> > &) const
{
Assert (false, ExcNotImplemented());
-};
+}
MemoryConsumption::memory_consumption (quadrature_points) +
MemoryConsumption::memory_consumption (unit_tangentials) +
MemoryConsumption::memory_consumption (aux));
-};
+}
MemoryConsumption::memory_consumption (unit_normals) +
MemoryConsumption::memory_consumption (use_mapping_q1_on_current_cell) +
MemoryConsumption::memory_consumption (mapping_q1_data));
-};
+}
a.insert (a.end(), line_points.begin(), line_points.end());
}
}
-};
+}
MappingQ<dim>::get_degree() const
{
return degree;
-};
+}
// explicit instantiation
MemoryConsumption::memory_consumption (cell_of_current_support_points) +
MemoryConsumption::memory_consumption (is_mapping_q1_data) +
MemoryConsumption::memory_consumption (n_shape_functions));
-};
+}
template <int dim>
MappingQ1<dim>::MappingQ1 ()
-{};
+{}
{3,2},
{0,3}};
return subcells[face][subface];
-};
+}
{3, 2, 6, 7},
{0, 4, 7, 3}};
return subcells[face][subface];
-};
+}
GridGenerator::colorize_hyper_rectangle (Triangulation<1> &)
{
// nothing to do in 1d
-};
+}
#else
default:
Assert(false, ExcNotImplemented());
};
-};
+}
#endif
const bool)
{
Assert (false, ExcNotImplemented());
-};
+}
const double)
{
Assert (false, ExcNotImplemented());
-};
+}
const double)
{
Assert (false, ExcNotImplemented());
-};
+}
const double)
{
Assert (false, ExcNotImplemented());
-};
+}
const unsigned int)
{
Assert (false, ExcNotImplemented());
-};
+}
#endif
++cell;
cell->face(3)->set_boundary_indicator(2);
}
-};
+}
tria.create_triangulation (std::vector<Point<dim> >(&vertices[0], &vertices[8]),
cells,
SubCellData()); // no boundary information
-};
+}
tria.create_triangulation (std::vector<Point<2> >(&vertices[0], &vertices[8]),
cells,
SubCellData()); // no boundary information
-};
+}
};
tria.create_triangulation (vertices, cells, SubCellData());
-};
+}
tria.create_triangulation (std::vector<Point<2> >(&vertices[0], &vertices[8]),
cells,
SubCellData()); // no boundary information
-};
+}
};
tria.create_triangulation (vertices, cells, SubCellData());
-};
+}
const bool)
{
Assert (false, ExcNotImplemented());
-};
+}
tria.create_triangulation (std::vector<Point<dim> >(&vertices[0], &vertices[26]),
cells,
SubCellData()); // no boundary information
-};
+}
cells,
SubCellData()); // no boundary information
*/
-};
+}
cell->face(1)->set_boundary_indicator(2);
++cell;
}
-};
+}
const unsigned int )
{
Assert (false, ExcNotImplemented());
-};
+}
#endif
template <int dim>
GridIn<dim>::GridIn () :
- tria(0) {};
+ tria(0) {}
template <int dim>
void GridIn<dim>::attach_triangulation (Triangulation<dim> &t)
{
tria = &t;
-};
+}
template <int dim>
// ... and cells
GridReordering<dim>::reorder_cells (cells);
tria->create_triangulation (vertices, cells, subcelldata);
-};
+}
// ...and cells
GridReordering<dim>::reorder_cells (cells);
tria->create_triangulation (vertices, cells, subcelldata);
-};
+}
// else: go on with next line
};
-};
+}
// put back first character of
// first non-comment line
in.putback (c);
-};
+}
if (vertex_used[v] == true)
tmp.push_back (vertices[v]);
swap (vertices, tmp);
-};
+}
std::ostream &/*out*/)
{
Assert (false, ExcNotImplemented());
-};
+}
#if deal_II_dimension == 2
<< min_y << ':' << max_y << "] "
<< min_y << std::endl
<< "pause -1" << std::endl;
-};
+}
#endif
<< vertices[cells[cell].vertices[7]]
<< std::endl << std::endl << std::endl;
};
-};
+}
#endif
write_diameter (write_diameter),
write_measure (write_measure),
write_all_faces (write_all_faces)
- {};
+ {}
const bool write_faces) :
write_preamble (write_preamble),
write_faces (write_faces)
- {};
+ {}
const unsigned int n_boundary_face_points) :
write_cell_numbers (write_cell_numbers),
n_boundary_face_points(n_boundary_face_points)
- {};
+ {}
line_width (line_width),
color_lines_on_user_flag(color_lines_on_user_flag),
n_boundary_face_points(n_boundary_face_points)
- {};
+ {}
EpsFlagsBase(size_type, size, line_width,
color_lines_on_user_flag,
n_boundary_face_points)
- {};
+ {}
write_cell_numbers (write_cell_numbers),
write_cell_number_level (write_cell_number_level),
write_vertex_numbers (write_vertex_numbers)
- {};
+ {}
n_boundary_face_points),
azimut_angle (azimut_angle),
turn_angle (turn_angle)
- {};
-}; // end namespace GridOutFlags
+ {}
+} // end namespace GridOutFlags
void GridOut::set_flags (const GridOutFlags::DX &flags)
{
dx_flags = flags;
-};
+}
void GridOut::set_flags (const GridOutFlags::Ucd &flags)
{
ucd_flags = flags;
-};
+}
void GridOut::set_flags (const GridOutFlags::Gnuplot &flags)
{
gnuplot_flags = flags;
-};
+}
void GridOut::set_flags (const GridOutFlags::Eps<1> &flags)
{
eps_flags_1 = flags;
-};
+}
void GridOut::set_flags (const GridOutFlags::Eps<2> &flags)
{
eps_flags_2 = flags;
-};
+}
void GridOut::set_flags (const GridOutFlags::Eps<3> &flags)
{
eps_flags_3 = flags;
-};
+}
Assert (false, ExcNotImplemented());
return "";
};
-};
+}
AssertThrow (false, ExcInvalidState ());
// return something weird
return OutputFormat(-1);
-};
+}
std::string GridOut::get_output_format_names ()
{
return "dx|gnuplot|eps|ucd";
-};
+}
sizeof(eps_flags_1) +
sizeof(eps_flags_2) +
sizeof(eps_flags_3));
-};
+}
write_ucd_faces (tria, cell_index, out);
AssertThrow (out, ExcIO());
-};
+}
unsigned int GridOut::n_boundary_faces (const Triangulation<1> &) const
{
return 0;
-};
+}
#endif
n_faces++;
return n_faces;
-};
+}
std::ostream &) const
{
return;
-};
+}
#endif
++index;
};
-};
+}
#if deal_II_dimension==1
AssertThrow (out, ExcIO());
-};
+}
#endif
out << "showpage" << std::endl;
AssertThrow (out, ExcIO());
-};
+}
#endif
};
Assert (false, ExcInternalError());
-};
+}
for (unsigned int index=0; index<n_cells; ++cell, ++index)
if (std::fabs(criteria(index)) >= new_threshold)
cell->set_refine_flag();
-};
+}
if (std::fabs(criteria(index)) <= threshold)
if (!cell->refine_flag_set())
cell->set_coarsen_flag();
-};
+}
coarsen (tria, criteria, *(tmp.begin() + tmp.size() - coarsen_cells));
};
};
-};
+}
if (bottom_threshold > *std::min_element(criteria.begin(), criteria.end()))
coarsen (tria, criteria, bottom_threshold);
-};
+}
}
}
refine(tria,criteria,criteria(tmp[minArg]));
-};
+}
// explicit instantiations
template void GridRefinement
{
for (unsigned int i=0; i<GeometryInfo<dim>::faces_per_cell; ++i)
neighbors[i] = invalid_neighbor;
-};
+}
{
for (unsigned int i=0; i<GeometryInfo<dim>::faces_per_cell; ++i)
neighbors[i] = invalid_neighbor;
-};
+}
template <int dim>
if (neighbors[i] != invalid_neighbor)
++n;
return n;
-};
+}
GridReordering<dim>::Cell::insert_faces (std::map<Face,FaceData> &/*global_faces*/)
{
Assert (false, ExcNotImplemented());
-};
+}
#if deal_II_dimension == 2
faces[2][face]->second.adjacent_cells[1] = cell_no;
};
};
-};
+}
#endif
faces[rot][face] = new_faces_ptr
[cell_orientation_faces[rot][face].second]
[cell_orientation_faces[rot][face].first];
-};
+}
#endif
else
neighbors[face] = faces[0][face]->second.adjacent_cells[0];
};
-};
+}
else
if (track_back_to_cell == FaceData::invalid_adjacent_cell)
track_back_to_cell = cell_no-1;
-};
+}
// no conflicts found
return true;
-};
+}
ExcInternalError());
++faces[rot][face]->second.use_count;
};
-};
+}
ExcInternalError());
--faces[rot][face]->second.use_count;
};
-};
+}
// if all indices are equal:
return false;
-};
+}
if (vertices[v] != face.vertices[v])
return false;
return true;
-};
+}
use_count (0)
{
adjacent_cells[0] = adjacent_cells[1] = invalid_adjacent_cell;
-};
+}
// as a goto.
goto top_of_function;
};
-};
+}
// backtracking
// cout << "Unsuccessfully tried to rotate neighbors of cell " << cell_no << endl;
return false;
-};
+}
};
// cout << "Done!" << endl;
-};
+}
i->second.adjacent_cells[k] = new_cell_numbers[i->second.adjacent_cells[k]];
return new_cell_numbers;
-};
+}
// of
for (typename std::map<Face,FaceData>::iterator i=faces.begin(); i!=faces.end(); ++i)
Assert (i->second.use_count == 0, ExcInternalError());
-};
+}
{
// there should not be much to do
// in 1d...
-};
+}
#endif
};
return std::sqrt(max_distance_sqr);
-};
+}
#else
while (!rightmost->at_boundary(1)) rightmost = rightmost->neighbor(1);
return std::sqrt((leftmost->vertex(0) - rightmost->vertex(1)).square());
-};
+}
#endif
private:
const double factor;
};
-};
+}
template <int dim>
Triangulation<dim> &triangulation)
{
transform (ShiftPoint<dim>(shift_vector), triangulation);
-};
+}
#if deal_II_dimension == 2
Triangulation<2> &triangulation)
{
transform (Rotate2d(angle), triangulation);
-};
+}
#endif
{
Assert (scaling_factor>0, ExcScalingFactorNotPositive (scaling_factor));
transform (ScalePoint<dim>(scaling_factor), triangulation);
-};
+}
// of this object, there is a
// specialization of this function
return grid.get_tria().n_levels();
-};
+}
// specialization for grid==tria
// if GridClass==Triangulation, then
// we can ask directly.
return grid.n_levels();
-};
+}
template <template <int> class GridClass, int dim>
// are indeed related:
Assert (dst_cell == destination_grid.end(0),
ExcIncompatibleGrids ());
-};
+}
// else (no cell is refined or
// dst_cell is refined): no pointers
// to be set
-};
+}
for (unsigned int c=0; c<GeometryInfo<dim>::children_per_cell; ++c)
set_entries_to_cell (src_cell->child(c),
dst_cell);
-};
+}
template <template <int> class GridClass, int dim>
ExcInvalidKey (source_cell));
return mapping[source_cell->level()][source_cell->index()];
-};
+}
mapping.clear ();
source_grid = 0;
destination_grid = 0;
-};
+}
InterGridMap<GridClass,dim>::get_source_grid () const
{
return *source_grid;
-};
+}
InterGridMap<GridClass,dim>::get_destination_grid () const
{
return *destination_grid;
-};
+}
return (MemoryConsumption::memory_consumption (mapping) +
MemoryConsumption::memory_consumption (source_grid) +
MemoryConsumption::memory_consumption (destination_grid));
-};
+}
PersistentTriangulation<dim>::
PersistentTriangulation (const Triangulation<dim> &coarse_grid) :
coarse_grid (&coarse_grid)
-{};
+{}
template <int dim>
coarsen_flags (old_tria.coarsen_flags)
{
Assert (old_tria.n_levels() == 0, ExcTriaNotEmpty ());
-};
+}
template <int dim>
PersistentTriangulation<dim>::~PersistentTriangulation ()
-{};
+{}
template <int dim>
// then refine triangulation
Triangulation<dim>::execute_coarsening_and_refinement ();
-};
+}
template <int dim>
// refinement sweeps
for (unsigned int i=0; i<refine_flags.size()+1; ++i)
restore(i);
-};
+}
template <int dim>
Triangulation<dim>::execute_coarsening_and_refinement ();
};
-};
+}
coarse_grid = &old_grid;
refine_flags.clear ();
coarsen_flags.clear ();
-};
+}
template <int dim>
const SubCellData &)
{
Assert (false, ExcFunctionNotUseful());
-};
+}
template <int dim>
MemoryConsumption::memory_consumption (coarse_grid) +
MemoryConsumption::memory_consumption (refine_flags) +
MemoryConsumption::memory_consumption (coarsen_flags));
-};
+}
// explicit instantiations
CellData<1>::rotate (const unsigned int)
{
Assert (false, ExcNotPossible());
-};
+}
vertices[2] = vertices[3];
vertices[3] = x;
};
-};
+}
// order
for (unsigned int i=0; i<GeometryInfo<3>::vertices_per_cell; ++i)
vertices[i] = old_vertices[rotations[times][i]];
-};
+}
return (boundary_quads.size() == 0);
};
return true;
-};
+}
total_cells*(2*dimension) - neighbors.size(),
std::make_pair(-1,-1));
};
-};
+}
ExcMemoryInexact (refine_flags.size(), neighbors.size()));
Assert (2*true_dimension*coarsen_flags.size() == neighbors.size(),
ExcMemoryInexact (coarsen_flags.size(), neighbors.size()));
-};
+}
return (MemoryConsumption::memory_consumption (refine_flags) +
MemoryConsumption::memory_consumption (coarsen_flags) +
MemoryConsumption::memory_consumption (neighbors));
-};
+}
lines.user_pointers.insert (lines.user_pointers.end(),
new_size-lines.user_pointers.size(), 0);
};
-};
+}
ExcMemoryInexact (lines.lines.size(), lines.user_pointers.size()));
TriangulationLevel<0>::monitor_memory (true_dimension);
-};
+}
MemoryConsumption::memory_consumption (lines.user_flags) +
MemoryConsumption::memory_consumption (lines.material_id) +
MemoryConsumption::memory_consumption (lines.user_pointers));
-};
+}
quads.user_pointers.insert (quads.user_pointers.end(),
new_size-quads.user_pointers.size(), 0);
};
-};
+}
ExcMemoryInexact (quads.quads.size(), quads.user_pointers.size()));
TriangulationLevel<1>::monitor_memory (true_dimension);
-};
+}
MemoryConsumption::memory_consumption (quads.user_flags) +
MemoryConsumption::memory_consumption (quads.material_id) +
MemoryConsumption::memory_consumption (quads.user_pointers));
-};
+}
hexes.user_pointers.insert (hexes.user_pointers.end(),
new_size-hexes.user_pointers.size(), 0);
};
-};
+}
ExcMemoryInexact (hexes.hexes.size(), hexes.user_pointers.size()));
TriangulationLevel<2>::monitor_memory (true_dimension);
-};
+}
MemoryConsumption::memory_consumption (hexes.user_flags) +
MemoryConsumption::memory_consumption (hexes.material_id) +
MemoryConsumption::memory_consumption (hexes.user_pointers));
-};
+}
n_active_lines (0)
// all other fields are
// default constructed
-{};
+{}
MemoryConsumption::memory_consumption (n_lines_level) +
MemoryConsumption::memory_consumption (n_active_lines) +
MemoryConsumption::memory_consumption (n_active_lines_level));
-};
+}
TriaNumberCache<2>::TriaNumberCache () :
n_active_quads (0)
// all other fields are
// default constructed
-{};
+{}
MemoryConsumption::memory_consumption (n_quads_level) +
MemoryConsumption::memory_consumption (n_active_quads) +
MemoryConsumption::memory_consumption (n_active_quads_level));
-};
+}
n_active_hexes (0)
// all other fields are
// default constructed
-{};
+{}
MemoryConsumption::memory_consumption (n_hexes_level) +
MemoryConsumption::memory_consumption (n_active_hexes) +
MemoryConsumption::memory_consumption (n_active_hexes_level));
-};
+}
namespace
{
const StraightBoundary<deal_II_dimension> dummy_straight_boundary;
-};
+}
template <int dim>
boundary[i] = straight_boundary;
boundary[i]->subscribe();
}
-};
+}
template <int dim>
// is an error!
{
Assert (false, ExcInternalError());
-};
+}
template <int dim>
for (unsigned int i=0;i<255;++i)
boundary[i]->unsubscribe ();
-};
+}
template <int dim>
};
number_cache = TriaNumberCache<dim>();
-};
+}
template <int dim>
boundary[number]->unsubscribe ();
boundary[number] = &boundary_object;
boundary_object.subscribe();
-};
+}
template <int dim>
Assert(number<255, ExcIndexRange(number,0,255));
return *(boundary[number]);
-};
+}
/*--------- Put the next functions a bit out-or-order to avoid use before
TriaDimensionInfo<1>::cell_iterator
Triangulation<1>::begin (const unsigned int level) const {
return begin_line (level);
-};
+}
template <>
TriaDimensionInfo<1>::raw_cell_iterator
Triangulation<1>::end () const {
return end_line ();
-};
+}
#endif
TriaDimensionInfo<2>::cell_iterator
Triangulation<2>::begin (const unsigned int level) const {
return begin_quad (level);
-};
+}
template <>
TriaDimensionInfo<2>::raw_cell_iterator
Triangulation<2>::end () const {
return end_quad ();
-};
+}
#endif
TriaDimensionInfo<3>::cell_iterator
Triangulation<3>::begin (const unsigned int level) const {
return begin_hex (level);
-};
+}
template <>
TriaDimensionInfo<3>::raw_cell_iterator
Triangulation<3>::end () const {
return end_hex ();
-};
+}
#endif
// note that we need not copy the
// subscriptor!
-};
+}
#if deal_II_dimension == 1
// re-compute numbers of lines, etc
update_number_cache ();
-};
+}
#endif
// re-compute numbers of lines, etc
update_number_cache ();
-};
+}
#endif
// re-compute numbers of lines, etc
update_number_cache ();
-};
+}
#endif
// finally move the vertex
vertices[vertex] += shift_vector;
};
-};
+}
#endif
= (cell->face(face)->vertex(0) +
cell->face(face)->vertex(1)) / 2;
}
-};
+}
cell->clear_coarsen_flag();
cell->set_refine_flag ();
};
-};
+}
set_all_refine_flags();
execute_coarsening_and_refinement ();
};
-};
+}
endc = end();
for (; cell!=endc; ++cell, ++i)
*i = cell->refine_flag_set();
-};
+}
save_refine_flags (v);
write_bool_vector (mn_tria_refine_flags_begin, v, mn_tria_refine_flags_end,
out);
-};
+}
read_bool_vector (mn_tria_refine_flags_begin, v, mn_tria_refine_flags_end,
in);
load_refine_flags (v);
-};
+}
cell->set_refine_flag();
else
cell->clear_refine_flag();
-};
+}
endc = end();
for (; cell!=endc; ++cell, ++i)
*i = cell->coarsen_flag_set();
-};
+}
save_coarsen_flags (v);
write_bool_vector (mn_tria_coarsen_flags_begin, v, mn_tria_coarsen_flags_end,
out);
-};
+}
read_bool_vector (mn_tria_coarsen_flags_begin, v, mn_tria_coarsen_flags_end,
in);
load_coarsen_flags (v);
-};
+}
cell->set_coarsen_flag();
else
cell->clear_coarsen_flag();
-};
+}
#if deal_II_dimension == 1
endc = end();
for (; cell!=endc; ++cell)
cell->clear_user_pointer ();
-};
+}
endc = end();
for (; cell!=endc; ++cell)
cell->clear_user_flag ();
-};
+}
#endif
endc = end();
for (; cell!=endc; ++cell)
cell->clear_user_pointer ();
-};
+}
endc = end();
for (; cell!=endc; ++cell)
cell->clear_user_flag ();
-};
+}
#endif
endc = end();
for (; cell!=endc; ++cell)
cell->clear_user_pointer ();
-};
+}
endc = end();
for (; cell!=endc; ++cell)
cell->clear_user_flag ();
-};
+}
#endif
if (dim >= 4)
Assert (false, ExcNotImplemented());
-};
+}
if (dim >= 4)
Assert (false, ExcNotImplemented());
-};
+}
if (dim >= 4)
Assert (false, ExcNotImplemented());
-};
+}
if (dim >= 4)
Assert (false, ExcNotImplemented());
-};
+}
endl = end_line();
for (; line!=endl; ++line, ++i)
*i = line->user_flag_set();
-};
+}
save_user_flags_line (v);
write_bool_vector (mn_tria_line_user_flags_begin, v, mn_tria_line_user_flags_end,
out);
-};
+}
read_bool_vector (mn_tria_line_user_flags_begin, v, mn_tria_line_user_flags_end,
in);
load_user_flags_line (v);
-};
+}
line->set_user_flag();
else
line->clear_user_flag();
-};
+}
#if deal_II_dimension == 1
void Triangulation<1>::save_user_flags_quad (std::ostream &) const
{
Assert (false, ExcFunctionNotUseful());
-};
+}
void Triangulation<1>::save_user_flags_quad (std::vector<bool> &) const
{
Assert (false, ExcFunctionNotUseful());
-};
+}
void Triangulation<1>::load_user_flags_quad (std::istream &)
{
Assert (false, ExcFunctionNotUseful());
-};
+}
void Triangulation<1>::load_user_flags_quad (const std::vector<bool> &)
{
Assert (false, ExcFunctionNotUseful());
-};
+}
void Triangulation<1>::save_user_flags_hex (std::ostream &) const
{
Assert (false, ExcFunctionNotUseful());
-};
+}
void Triangulation<1>::save_user_flags_hex (std::vector<bool> &) const
{
Assert (false, ExcFunctionNotUseful());
-};
+}
void Triangulation<1>::load_user_flags_hex (std::istream &)
{
Assert (false, ExcFunctionNotUseful());
-};
+}
void Triangulation<1>::load_user_flags_hex (const std::vector<bool> &)
{
Assert (false, ExcFunctionNotUseful());
-};
+}
#endif
endq = end_quad();
for (; quad!=endq; ++quad, ++i)
*i = quad->user_flag_set();
-};
+}
save_user_flags_quad (v);
write_bool_vector (mn_tria_quad_user_flags_begin, v, mn_tria_quad_user_flags_end,
out);
-};
+}
read_bool_vector (mn_tria_quad_user_flags_begin, v, mn_tria_quad_user_flags_end,
in);
load_user_flags_quad (v);
-};
+}
quad->set_user_flag();
else
quad->clear_user_flag();
-};
+}
#if deal_II_dimension == 2
void Triangulation<2>::save_user_flags_hex (std::ostream &) const
{
Assert (false, ExcFunctionNotUseful());
-};
+}
void Triangulation<2>::save_user_flags_hex (std::vector<bool> &) const
{
Assert (false, ExcFunctionNotUseful());
-};
+}
void Triangulation<2>::load_user_flags_hex (std::istream &)
{
Assert (false, ExcFunctionNotUseful());
-};
+}
void Triangulation<2>::load_user_flags_hex (const std::vector<bool> &)
{
Assert (false, ExcFunctionNotUseful());
-};
+}
#endif
endh = end_hex();
for (; hex!=endh; ++hex, ++i)
*i = hex->user_flag_set();
-};
+}
save_user_flags_hex (v);
write_bool_vector (mn_tria_hex_user_flags_begin, v, mn_tria_hex_user_flags_end,
out);
-};
+}
read_bool_vector (mn_tria_hex_user_flags_begin, v, mn_tria_hex_user_flags_end,
in);
load_user_flags_hex (v);
-};
+}
hex->set_user_flag();
else
hex->clear_user_flag();
-};
+}
if (dim >= 4)
Assert (false, ExcNotImplemented());
-};
+}
if (dim >= 4)
Assert (false, ExcNotImplemented());
-};
+}
endl = end_line();
for (; line!=endl; ++line, ++i)
*i = line->user_pointer();
-};
+}
std::vector<void *>::const_iterator i = v.begin();
for (; line!=endl; ++line, ++i)
line->set_user_pointer(*i);
-};
+}
#if deal_II_dimension == 1
void Triangulation<1>::save_user_pointers_quad (std::vector<void *> &) const
{
Assert (false, ExcFunctionNotUseful());
-};
+}
void Triangulation<1>::load_user_pointers_quad (const std::vector<void *> &)
{
Assert (false, ExcFunctionNotUseful());
-};
+}
void Triangulation<1>::save_user_pointers_hex (std::vector<void *> &) const
{
Assert (false, ExcFunctionNotUseful());
-};
+}
void Triangulation<1>::load_user_pointers_hex (const std::vector<void *> &)
{
Assert (false, ExcFunctionNotUseful());
-};
+}
#endif
endq = end_quad();
for (; quad!=endq; ++quad, ++i)
*i = quad->user_pointer();
-};
+}
std::vector<void *>::const_iterator i = v.begin();
for (; quad!=endq; ++quad, ++i)
quad->set_user_pointer(*i);
-};
+}
#if deal_II_dimension == 2
void Triangulation<2>::save_user_pointers_hex (std::vector<void *> &) const
{
Assert (false, ExcFunctionNotUseful());
-};
+}
void Triangulation<2>::load_user_pointers_hex (const std::vector<void *> &)
{
Assert (false, ExcFunctionNotUseful());
-};
+}
#endif
endh = end_hex();
for (; hex!=endh; ++hex, ++i)
*i = hex->user_pointer();
-};
+}
std::vector<void *>::const_iterator i = v.begin();
for (; hex!=endh; ++hex, ++i)
hex->set_user_pointer(*i);
-};
+}
Triangulation<1>::begin_raw (const unsigned int level) const
{
return begin_raw_line (level);
-};
+}
Triangulation<1>::begin_active (const unsigned int level) const
{
return begin_active_line (level);
-};
+}
Triangulation<1>::last_raw () const
{
return last_raw_line ();
-};
+}
Triangulation<1>::last_raw (const unsigned int level) const
{
return last_raw_line (level);
-};
+}
Triangulation<1>::last () const
{
return last_line ();
-};
+}
Triangulation<1>::last (const unsigned int level) const
{
return last_line (level);
-};
+}
Triangulation<1>::last_active () const
{
return last_active_line ();
-};
+}
Triangulation<1>::last_active (const unsigned int level) const
{
return last_active_line (level);
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
#endif
Triangulation<2>::begin_raw (const unsigned int level) const
{
return begin_raw_quad (level);
-};
+}
Triangulation<2>::begin_active (const unsigned int level) const
{
return begin_active_quad (level);
-};
+}
Triangulation<2>::last_raw () const
{
return last_raw_quad ();
-};
+}
Triangulation<2>::last_raw (const unsigned int level) const
{
return last_raw_quad (level);
-};
+}
Triangulation<2>::last () const
{
return last_quad ();
-};
+}
Triangulation<2>::last (const unsigned int level) const
{
return last_quad (level);
-};
+}
Triangulation<2>::last_active () const
{
return last_active_quad ();
-};
+}
Triangulation<2>::last_active (const unsigned int level) const
{
return last_active_quad (level);
-};
+}
Triangulation<2>::begin_raw_face (const unsigned int level) const
{
return begin_raw_line (level);
-};
+}
Triangulation<2>::begin_face (const unsigned int level) const
{
return begin_line (level);
-};
+}
Triangulation<2>::begin_active_face (const unsigned int level) const
{
return begin_active_line (level);
-};
+}
Triangulation<2>::end_face () const
{
return end_line ();
-};
+}
Triangulation<2>::last_raw_face () const
{
return last_raw_line ();
-};
+}
Triangulation<2>::last_raw_face (const unsigned int level) const
{
return last_raw_line (level);
-};
+}
Triangulation<2>::last_face () const
{
return last_line ();
-};
+}
Triangulation<2>::last_face (const unsigned int level) const
{
return last_line (level);
-};
+}
Triangulation<2>::last_active_face () const
{
return last_active_line ();
-};
+}
Triangulation<2>::last_active_face (const unsigned int level) const
{
return last_active_line (level);
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
{
Assert (false, ExcFunctionNotUseful());
return 0;
-};
+}
#endif
Triangulation<3>::begin_raw (const unsigned int level) const
{
return begin_raw_hex (level);
-};
+}
Triangulation<3>::begin_active (const unsigned int level) const
{
return begin_active_hex (level);
-};
+}
Triangulation<3>::last_raw () const
{
return last_raw_hex ();
-};
+}
Triangulation<3>::last_raw (const unsigned int level) const
{
return last_raw_hex (level);
-};
+}
Triangulation<3>::last () const
{
return last_hex ();
-};
+}
Triangulation<3>::last (const unsigned int level) const
{
return last_hex (level);
-};
+}
Triangulation<3>::last_active () const
{
return last_active_hex ();
-};
+}
Triangulation<3>::last_active (const unsigned int level) const
{
return last_active_hex (level);
-};
+}
Triangulation<3>::begin_raw_face (const unsigned int level) const
{
return begin_raw_quad (level);
-};
+}
Triangulation<3>::begin_face (const unsigned int level) const
{
return begin_quad (level);
-};
+}
Triangulation<3>::begin_active_face (const unsigned int level) const
{
return begin_active_quad (level);
-};
+}
Triangulation<3>::end_face () const
{
return end_quad ();
-};
+}
Triangulation<3>::last_raw_face () const
{
return last_raw_quad ();
-};
+}
Triangulation<3>::last_raw_face (const unsigned int level) const
{
return last_raw_quad (level);
-};
+}
Triangulation<3>::last_face () const
{
return last_quad ();
-};
+}
Triangulation<3>::last_face (const unsigned int level) const
{
return last_quad (level);
-};
+}
Triangulation<3>::last_active_face () const
{
return last_active_quad ();
-};
+}
Triangulation<3>::last_active_face (const unsigned int level) const
{
return last_active_quad (level);
-};
+}
#endif
return raw_line_iterator (const_cast<Triangulation<dim>*>(this),
level,
0);
-};
+}
return raw_quad_iterator (const_cast<Triangulation<dim>*>(this),
level,
0);
-};
+}
return raw_hex_iterator (const_cast<Triangulation<dim>*>(this),
level,
0);
-};
+}
if ((++ri).state() != IteratorState::valid)
return ri;
return ri;
-};
+}
if ((++ri).state() != IteratorState::valid)
return ri;
return ri;
-};
+}
if ((++ri).state() != IteratorState::valid)
return ri;
return ri;
-};
+}
if ((++i).state() != IteratorState::valid)
return i;
return i;
-};
+}
if ((++i).state() != IteratorState::valid)
return i;
return i;
-};
+}
if ((++i).state() != IteratorState::valid)
return i;
return i;
-};
+}
return raw_line_iterator (const_cast<Triangulation<dim>*>(this),
-1,
-1);
-};
+}
return raw_quad_iterator (const_cast<Triangulation<dim>*>(this),
-1,
-1);
-};
+}
return raw_hex_iterator (const_cast<Triangulation<dim>*>(this),
-1,
-1);
-};
+}
return raw_line_iterator (const_cast<Triangulation<dim>*>(this),
level,
levels[level]->lines.lines.size()-1);
-};
+}
template <int dim>
return raw_quad_iterator (const_cast<Triangulation<dim>*>(this),
level,
levels[level]->quads.quads.size()-1);
-};
+}
template <int dim>
return raw_hex_iterator (const_cast<Triangulation<dim>*>(this),
level,
levels[level]->hexes.hexes.size()-1);
-};
+}
template <int dim>
typename TriaDimensionInfo<dim>::raw_line_iterator
Triangulation<dim>::last_raw_line () const {
return last_raw_line (levels.size()-1);
-};
+}
template <int dim>
typename TriaDimensionInfo<dim>::raw_quad_iterator
Triangulation<dim>::last_raw_quad () const {
return last_raw_quad (levels.size()-1);
-};
+}
template <int dim>
typename TriaDimensionInfo<dim>::raw_hex_iterator
Triangulation<dim>::last_raw_hex () const {
return last_raw_hex (levels.size()-1);
-};
+}
template <int dim>
if (ri->used()==true)
return ri;
return ri;
-};
+}
template <int dim>
if (ri->used()==true)
return ri;
return ri;
-};
+}
template <int dim>
if (ri->used()==true)
return ri;
return ri;
-};
+}
template <int dim>
typename TriaDimensionInfo<dim>::line_iterator
Triangulation<dim>::last_line () const {
return last_line (levels.size()-1);
-};
+}
template <int dim>
typename TriaDimensionInfo<dim>::quad_iterator
Triangulation<dim>::last_quad () const {
return last_quad (levels.size()-1);
-};
+}
template <int dim>
typename TriaDimensionInfo<dim>::hex_iterator
Triangulation<dim>::last_hex () const {
return last_hex (levels.size()-1);
-};
+}
template <int dim>
if (i->has_children()==false)
return i;
return i;
-};
+}
template <int dim>
if (i->has_children()==false)
return i;
return i;
-};
+}
template <int dim>
if (i->has_children()==false)
return i;
return i;
-};
+}
template <int dim>
typename TriaDimensionInfo<dim>::active_line_iterator
Triangulation<dim>::last_active_line () const {
return last_active_line (levels.size()-1);
-};
+}
template <int dim>
typename TriaDimensionInfo<dim>::active_quad_iterator
Triangulation<dim>::last_active_quad () const {
return last_active_quad (levels.size()-1);
-};
+}
template <int dim>
typename TriaDimensionInfo<dim>::active_hex_iterator
Triangulation<dim>::last_active_hex () const {
return last_active_hex (levels.size()-1);
-};
+}
template <int dim>
return (level == levels.size()-1 ?
end() :
begin_raw (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
cell_iterator(end()) :
begin (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
active_cell_iterator(end()) :
begin_active (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
end_face() :
begin_raw_face (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
face_iterator(end_face()) :
begin_face (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
active_face_iterator(end_face()) :
begin_active_face (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
end_line() :
begin_raw_line (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
line_iterator(end_line()) :
begin_line (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
active_line_iterator(end_line()) :
begin_active_line (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
end_quad() :
begin_raw_quad (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
quad_iterator(end_quad()) :
begin_quad (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
active_quad_iterator(end_quad()) :
begin_active_quad (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
end_hex() :
begin_raw_hex (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
hex_iterator(end_hex()) :
begin_hex (level+1));
-};
+}
template <int dim>
return (level == levels.size()-1 ?
active_hex_iterator(end_hex()) :
begin_active_hex (level+1));
-};
+}
template <int dim>
for (unsigned int l=0; l<levels.size(); ++l)
n += n_cells (l);
return n;
-};
+}
template <int dim>
for (unsigned int l=0; l<levels.size(); ++l)
n += n_active_cells (l);
return n;
-};
+}
#if deal_II_dimension == 1
template <>
unsigned int Triangulation<1>::n_active_cells (const unsigned int level) const {
return n_active_lines (level);
-};
+}
template <>
unsigned int Triangulation<1>::n_cells (const unsigned int level) const {
return n_lines (level);
-};
+}
#endif
template <>
unsigned int Triangulation<2>::n_cells (const unsigned int level) const {
return n_quads (level);
-};
+}
template <>
unsigned int Triangulation<2>::n_active_cells (const unsigned int level) const {
return n_active_quads (level);
-};
+}
#endif
template <>
unsigned int Triangulation<3>::n_cells (const unsigned int level) const {
return n_hexs (level);
-};
+}
template <>
unsigned int Triangulation<3>::n_active_cells (const unsigned int level) const {
return n_active_hexs (level);
-};
+}
#endif
template <int dim>
unsigned int Triangulation<dim>::n_lines () const {
return number_cache.n_lines;
-};
+}
template <int dim>
ExcIndexRange (level, 0, number_cache.n_lines_level.size()));
return number_cache.n_lines_level[level];
-};
+}
template <int dim>
unsigned int Triangulation<dim>::n_active_lines () const {
return number_cache.n_active_lines;
-};
+}
template <int dim>
ExcIndexRange (level, 0, number_cache.n_lines_level.size()));
return number_cache.n_active_lines_level[level];
-};
+}
#if deal_II_dimension == 1
unsigned int Triangulation<1>::n_quads () const
{
return 0;
-};
+}
template <>
unsigned int Triangulation<1>::n_quads (const unsigned int) const
{
return 0;
-};
+}
template <>
unsigned int Triangulation<1>::n_active_quads (const unsigned int) const
{
return 0;
-};
+}
template <>
unsigned int Triangulation<1>::n_active_quads () const
{
return 0;
-};
+}
#endif
template <int dim>
unsigned int Triangulation<dim>::n_quads () const {
return number_cache.n_quads;
-};
+}
template <int dim>
ExcIndexRange (level, 0, number_cache.n_quads_level.size()));
return number_cache.n_quads_level[level];
-};
+}
template <int dim>
unsigned int Triangulation<dim>::n_active_quads () const {
return number_cache.n_active_quads;
-};
+}
template <int dim>
ExcIndexRange (level, 0, number_cache.n_quads_level.size()));
return number_cache.n_active_quads_level[level];
-};
+}
#if deal_II_dimension < 3
unsigned int Triangulation<dim>::n_hexs () const
{
return 0;
-};
+}
unsigned int Triangulation<dim>::n_hexs (const unsigned int) const
{
return 0;
-};
+}
unsigned int Triangulation<dim>::n_active_hexs () const
{
return 0;
-};
+}
unsigned int Triangulation<dim>::n_active_hexs (const unsigned int) const
{
return 0;
-};
+}
#else
unsigned int Triangulation<dim>::n_hexs () const
{
return number_cache.n_hexes;
-};
+}
ExcIndexRange (level, 0, number_cache.n_hexes_level.size()));
return number_cache.n_hexes_level[level];
-};
+}
unsigned int Triangulation<dim>::n_active_hexs () const
{
return number_cache.n_active_hexes;
-};
+}
ExcIndexRange (level, 0, number_cache.n_hexes_level.size()));
return number_cache.n_active_hexes_level[level];
-};
+}
#endif
Assert (false, ExcInternalError());
// just to make the compiler happy:
return 0;
-};
+}
Triangulation<dim>::n_vertices () const
{
return vertices.size();
-};
+}
Triangulation<dim>::get_vertices () const
{
return vertices;
-};
+}
{
return std::count_if (vertices_used.begin(), vertices_used.end(),
std::bind2nd (std::equal_to<bool>(), true));
-};
+}
Triangulation<dim>::get_used_vertices () const
{
return vertices_used;
-};
+}
#if deal_II_dimension == 1
unsigned int Triangulation<1>::max_adjacent_cells () const
{
return 2;
-};
+}
#endif
return std::max (GeometryInfo<dim>::vertices_per_cell,
static_cast<unsigned int>(*std::max_element (usage_count.begin(),
usage_count.end())));
-};
+}
execute_coarsening();
execute_refinement();
-};
+}
#if deal_II_dimension == 1
while (cell != endc)
Assert (!(cell++)->refine_flag_set(), ExcInternalError ());
#endif
-};
+}
#endif
while (cell != endc)
Assert (!(cell++)->refine_flag_set(), ExcInternalError ());
#endif
-};
+}
#endif
while (cell != endc)
Assert (!(cell++)->refine_flag_set(), ExcInternalError ());
#endif
-};
+}
#endif
for (cell=begin(); cell!=endc; ++cell)
Assert (cell->user_flag_set() == false, ExcInternalError());
#endif
-};
+}
template <int dim>
void Triangulation<dim>::prepare_refinement_dim_dependent ()
-{};
+{}
#if deal_II_dimension == 3
};
}
while (mesh_changed == true);
-};
+}
#endif
cell->child(c)->set_coarsen_flag();
};
};
-};
+}
template <int dim>
// the present state
return ((flags_before[0] != flags_before_loop[0]) ||
(flags_before[1] != flags_before_loop[1]));
-};
+}
#if deal_II_dimension == 1
// delete pointer to children
cell->set_children (-1);
cell->clear_user_flag();
-};
+}
#endif
// delete pointer to children
cell->set_children (-1);
cell->clear_user_flag();
-};
+}
#endif
line->clear_children();
};
-};
+}
#endif
delete[] flags;
AssertThrow (out, ExcIO());
-};
+}
template <int dim>
delete[] flags;
AssertThrow (in, ExcIO());
-};
+}
mem += MemoryConsumption::memory_consumption (number_cache);
return mem;
-};
+}
// update total number of lines
number_cache.n_active_lines += number_cache.n_active_lines_level[level];
};
-};
+}
#if deal_II_dimension == 1
void Triangulation<1>::update_number_cache_quads ()
{
Assert (false, ExcInternalError());
-};
+}
#endif
// update total number of quads
number_cache.n_active_quads += number_cache.n_active_quads_level[level];
};
-};
+}
#endif
void Triangulation<1>::update_number_cache_hexes ()
{
Assert (false, ExcInternalError());
-};
+}
#endif
void Triangulation<2>::update_number_cache_hexes ()
{
Assert (false, ExcInternalError());
-};
+}
#endif
// update total number of hexes
number_cache.n_active_hexes += number_cache.n_active_hexes_level[level];
};
-};
+}
#endif
default:
Assert (false, ExcInternalError());
};
-};
+}
// explicit instantiations
void TriaObjectAccessor<1, dim>::set (const Line &line) const
{
this->tria->levels[this->present_level]->lines.lines[this->present_index] = line;
-};
+}
{
Assert (i<2, ExcIndexRange(i,0,2));
return this->tria->levels[this->present_level]->lines.lines[this->present_index].vertex (i);
-};
+}
TriaObjectAccessor<1, dim>::vertex (const unsigned int i) const
{
return const_cast<Point<dim> &> (this->tria->vertices[vertex_index(i)]);
-};
+}
Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
this->tria->levels[this->present_level]->lines.used[this->present_index] = true;
-};
+}
Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
this->tria->levels[this->present_level]->lines.used[this->present_index] = false;
-};
+}
if (has_children())
for (unsigned int c=0; c<2; ++c)
child(c)->recursively_set_user_flag ();
-};
+}
if (has_children())
for (unsigned int c=0; c<2; ++c)
child(c)->recursively_clear_user_flag ();
-};
+}
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->lines.user_pointers[this->present_index] = p;
-};
+}
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->lines.user_pointers[this->present_index] = 0;
-};
+}
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
return this->tria->levels[this->present_level]->lines.user_pointers[this->present_index];
-};
+}
typename TriaAccessor<dim>::ExcCantSetChildren(index));
this->tria->levels[this->present_level]->lines.children[this->present_index] = index;
-};
+}
void TriaObjectAccessor<1, dim>::clear_children () const
{
set_children (-1);
-};
+}
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
return this->tria->levels[this->present_level]->lines.material_id[this->present_index];
-};
+}
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->lines.material_id[this->present_index] = boundary_ind;
-};
+}
// error checking is done
// in boundary_indicator()
return (boundary_indicator() != 255);
-};
+}
double TriaObjectAccessor<1, dim>::diameter () const
{
return std::sqrt((vertex(1)-vertex(0)).square());
-};
+}
Point<dim> TriaObjectAccessor<1, dim>::center () const
{
return (vertex(1)+vertex(0))/2.;
-};
+}
Point<dim> TriaObjectAccessor<1, dim>::barycenter () const
{
return (vertex(1)+vertex(0))/2.;
-};
+}
double TriaObjectAccessor<1, dim>::measure () const
{
return std::sqrt((vertex(1)-vertex(0)).square());
-};
+}
sum += child(c)->number_of_children();
return sum;
};
-};
+}
/*------------------------ Functions: QuadAccessor ---------------------------*/
void TriaObjectAccessor<2, dim>::set (const Quad &quad) const
{
this->tria->levels[this->present_level]->quads.quads[this->present_index] = quad;
-};
+}
const int corner_convention[4] = { 0,0,1,1 };
return line(corner)->vertex_index(corner_convention[corner]);
-};
+}
TriaObjectAccessor<2, dim>::vertex (const unsigned int i) const
{
return const_cast<Point<dim> &> (this->tria->vertices[vertex_index(i)]);
-};
+}
Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
this->tria->levels[this->present_level]->quads.used[this->present_index] = true;
-};
+}
Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
this->tria->levels[this->present_level]->quads.used[this->present_index] = false;
-};
+}
if (has_children())
for (unsigned int c=0; c<4; ++c)
child(c)->recursively_set_user_flag ();
-};
+}
if (has_children())
for (unsigned int c=0; c<4; ++c)
child(c)->recursively_clear_user_flag ();
-};
+}
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->quads.user_pointers[this->present_index] = p;
-};
+}
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->quads.user_pointers[this->present_index] = 0;
-};
+}
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
return this->tria->levels[this->present_level]->quads.user_pointers[this->present_index];
-};
+}
typename TriaAccessor<dim>::ExcCantSetChildren(index));
this->tria->levels[this->present_level]->quads.children[this->present_index] = index;
-};
+}
void TriaObjectAccessor<2, dim>::clear_children () const
{
set_children (-1);
-};
+}
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
return this->tria->levels[this->present_level]->quads.material_id[this->present_index];
-};
+}
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->quads.material_id[this->present_index] = boundary_ind;
-};
+}
// error checking is done
// in boundary_indicator()
return (boundary_indicator() != 255);
-};
+}
{
return std::sqrt(std::max((vertex(2)-vertex(0)).square(),
(vertex(3)-vertex(1)).square()));
-};
+}
Point<dim> TriaObjectAccessor<2, dim>::center () const
{
return (vertex(0)+vertex(1)+vertex(2)+vertex(3))/4.;
-};
+}
#if deal_II_dimension == 2
+t42*y[2]-t44*y[1]+t38*y[0]-x[1]*t50+x[0]*t52
-x[3]*t54+x[2]*t56+x[3]*t50-x[2]*t52+x[1]*t54-x[0]*t56;
return Point<2> (t25*t35/3.0, t62*t35/3.0);
-};
+}
return (-x[0]*y[3]/2.0-x[1]*y[0]/2.0+x[2]*y[3]/2.0+x[3]*y[0]/2.0+
x[0]*y[1]/2.0-x[3]*y[2]/2.0+x[1]*y[2]/2.0-x[2]*y[1]/2.0);
-};
+}
#endif
Assert (false, ExcNotImplemented());
return Point<3> ();
-};
+}
// function above.
Assert (false, ExcNotImplemented());
return 0;
-};
+}
#endif
sum += child(c)->number_of_children();
return sum;
};
-};
+}
/*------------------------ Functions: TriaObjectAccessor ---------------------------*/
void TriaObjectAccessor<3, dim>::set (const Hexahedron &hex) const
{
this->tria->levels[this->present_level]->hexes.hexes[this->present_index] = hex;
-};
+}
return quad(0)->vertex_index(corner);
else
return quad(1)->vertex_index(corner-4);
-};
+}
TriaObjectAccessor<3, dim>::vertex (const unsigned int i) const
{
return const_cast<Point<dim> &> (this->tria->vertices[vertex_index(i)]);
-};
+}
Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
this->tria->levels[this->present_level]->hexes.used[this->present_index] = true;
-};
+}
Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
this->tria->levels[this->present_level]->hexes.used[this->present_index] = false;
-};
+}
if (has_children())
for (unsigned int c=0; c<8; ++c)
child(c)->recursively_set_user_flag ();
-};
+}
if (has_children())
for (unsigned int c=0; c<8; ++c)
child(c)->recursively_clear_user_flag ();
-};
+}
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->hexes.user_pointers[this->present_index] = p;
-};
+}
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->hexes.user_pointers[this->present_index] = 0;
-};
+}
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
return this->tria->levels[this->present_level]->hexes.user_pointers[this->present_index];
-};
+}
typename TriaAccessor<dim>::ExcCantSetChildren(index));
this->tria->levels[this->present_level]->hexes.children[this->present_index] = index;
-};
+}
void TriaObjectAccessor<3, dim>::clear_children () const
{
set_children (-1);
-};
+}
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
return this->tria->levels[this->present_level]->hexes.material_id[this->present_index];
-};
+}
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->hexes.material_id[this->present_index] = boundary_ind;
-};
+}
// error checking is done
// in boundary_indicator()
return (boundary_indicator() != 255);
-};
+}
(vertex(7)-vertex(1)).square()),
std::max((vertex(4)-vertex(2)).square(),
(vertex(5)-vertex(3)).square()) ));
-};
+}
{
return (vertex(0)+vertex(1)+vertex(2)+vertex(3)+
vertex(4)+vertex(5)+vertex(6)+vertex(7))/8.;
-};
+}
#if deal_II_dimension == 3
const double unknown2 = s1*s2;
return Point<3> (unknown0, unknown1, unknown2);
-};
+}
*x[4]*y[1]/12.0-z[5]*x[4]*y[6]/12.0-x[6]*y[7]*z[3]/12.0-x[4]*y[3]*z[7]/12.0+x
[4]*y[7]*z[3]/12.0-x[1]*y[5]*z[6]/12.0-y[6]*x[7]*z[4]/12.0-y[1]*x[2]*z[6]/12.0-
y[2]*x[3]*z[6]/12.0+s2+s1+x[2]*y[0]*z[3]/12.0);
-};
+}
#endif
sum += child(c)->number_of_children();
return sum;
};
-};
+}
/*------------------------ Functions: CellAccessor<1> -----------------------*/
bool CellAccessor<1>::at_boundary () const
{
return at_boundary(0) || at_boundary(1);
-};
+}
Assert (this->used(), TriaAccessor<1>::ExcCellNotUsed());
return this->tria->levels[this->present_level]
->lines.material_id[this->present_index];
-};
+}
Assert (this->used(), TriaAccessor<1>::ExcCellNotUsed());
this->tria->levels[this->present_level]->lines.material_id[this->present_index]
= mat_id;
-};
+}
template <>
bool CellAccessor<2>::at_boundary () const
{
return at_boundary(0) || at_boundary(1) || at_boundary(2) || at_boundary(3);
-};
+}
{
Assert (this->used(), TriaAccessor<2>::ExcCellNotUsed());
return this->tria->levels[this->present_level]->quads.material_id[this->present_index];
-};
+}
Assert (this->used(), TriaAccessor<2>::ExcCellNotUsed());
this->tria->levels[this->present_level]->quads.material_id[this->present_index]
= mat_id;
-};
+}
return (at_boundary(0) || at_boundary(1) ||
at_boundary(2) || at_boundary(3) ||
at_boundary(4) || at_boundary(5));
-};
+}
{
Assert (this->used(), TriaAccessor<3>::ExcCellNotUsed());
return this->tria->levels[this->present_level]->hexes.material_id[this->present_index];
-};
+}
Assert (this->used(), TriaAccessor<3>::ExcCellNotUsed());
this->tria->levels[this->present_level]->hexes.material_id[this->present_index]
= mat_id;
-};
+}
template <>
{
Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
return this->tria->levels[this->present_level]->subdomain_ids[this->present_index];
-};
+}
Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
this->tria->levels[this->present_level]->subdomain_ids[this->present_index]
= new_subdomain_id;
-};
+}
neighbors[this->present_index*GeometryInfo<dim>::faces_per_cell+i].second
= -1;
};
-};
+}
Assert (false, ExcInternalError());
return static_cast<unsigned int>(-1);
};
-};
+}
Assert (false, ExcInternalError());
return std::make_pair (static_cast<unsigned int>(-1),
static_cast<unsigned int>(-1));
-};
+}
ExcIndexRange (i,0,GeometryInfo<dim>::faces_per_cell));
return (neighbor_index(i) == -1);
-};
+}
bool CellAccessor<1>::has_boundary_lines () const
{
return at_boundary();
-};
+}
#else
return true;
return false;
-};
+}
#endif
template <int dim>
Boundary<dim>::~Boundary ()
-{};
+{}
{
Assert (false, ExcPureVirtualFunctionCalled());
return Point<dim>();
-};
+}
std::vector<Point<dim> > &) const
{
Assert (false, ExcPureVirtualFunctionCalled());
-};
+}
std::vector<Point<dim> > &) const
{
Assert (false, ExcPureVirtualFunctionCalled());
-};
+}
FaceVertexNormals &) const
{
Assert (false, ExcPureVirtualFunctionCalled());
-};
+}
template <int dim>
StraightBoundary<dim>::StraightBoundary ()
-{};
+{}
StraightBoundary<dim>::get_new_point_on_line (const typename Triangulation<dim>::line_iterator &line) const
{
return (line->vertex(0) + line->vertex(1)) / 2;
-};
+}
#if deal_II_dimension < 3
{
Assert (false, typename Boundary<dim>::ExcFunctionNotUseful(dim));
return Point<dim>();
-};
+}
#else
quad->line(1)->child(0)->vertex(1) +
quad->line(2)->child(0)->vertex(1) +
quad->line(3)->child(0)->vertex(1)) / 8;
-};
+}
#endif
for (unsigned int i=0; i<n; ++i, x+=dx)
points[i] = (1-x)*vertices[0] + x*vertices[1];
-};
+}
#endif
Boundary<1>::FaceVertexNormals &) const
{
Assert (false, Boundary<1>::ExcFunctionNotUseful(1));
-};
+}
#endif
// compute normals from tangent
face_vertex_normals[vertex] = Point<dim>(tangent[1],
-tangent[0]);
-};
+}
#endif
cross_product (face_vertex_normals[vertex],
tangents[0], tangents[1]);
};
-};
+}
#endif
template <int dim>
CylinderBoundary<dim>::CylinderBoundary (const double radius) :
radius(radius)
-{};
+{}
middle(i) *= f;
}
return middle;
-};
+}
#if deal_II_dimension >=3
middle(i) *= f;
}
return middle;
-};
+}
#endif
CylinderBoundary<dim>::
get_new_point_on_quad (const typename Triangulation<dim>::quad_iterator &) const
{
- Assert(false, Boundary<dim>::ExcFunctionNotUseful(dim));
+ Assert (false, typename Boundary<dim>::ExcFunctionNotUseful(dim));
return Point<dim>();
}
const typename Triangulation<dim>::quad_iterator &,
std::vector<Point<dim> > &) const
{
- Assert(false, Boundary<dim>::ExcFunctionNotUseful(dim));
+ Assert (false, typename Boundary<dim>::ExcFunctionNotUseful(dim));
}
Boundary<1>::FaceVertexNormals &) const
{
Assert (false, Boundary<1>::ExcFunctionNotUseful(1));
-};
+}
#endif
face_vertex_normals[vertex] = face->vertex(vertex);
face_vertex_normals[vertex][0] = 0.;
}
-};
+}
CylinderBoundary<dim>::get_radius () const
{
return radius;
-};
+}
//======================================================================//
HyperBallBoundary<dim>::HyperBallBoundary (const Point<dim> p,
const double radius) :
center(p), radius(radius), compute_radius_automatically(false)
-{};
+{}
middle += center;
return middle;
-};
+}
{
Assert (false, ExcInternalError());
return Point<1>();
-};
+}
#endif
middle += center;
return middle;
-};
+}
#if deal_II_dimension == 1
const typename Triangulation<dim>::quad_iterator &,
std::vector<Point<dim> > &) const
{
- Assert(false, Boundary<dim>::ExcFunctionNotUseful(dim));
+ Assert(false, typename Boundary<dim>::ExcFunctionNotUseful(dim));
}
Boundary<1>::FaceVertexNormals &) const
{
Assert (false, Boundary<1>::ExcFunctionNotUseful(1));
-};
+}
#endif
{
for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_face; ++vertex)
face_vertex_normals[vertex] = face->vertex(vertex)-center;
-};
+}
HyperBallBoundary<dim>::get_center () const
{
return center;
-};
+}
{
Assert(!compute_radius_automatically, ExcRadiusNotSet());
return radius;
-};
+}
/* ---------------------------------------------------------------------- */
HalfHyperBallBoundary<dim>::HalfHyperBallBoundary (const Point<dim> center,
const double radius) :
HyperBallBoundary<dim> (center, radius)
-{};
+{}
return line_center;
else
return HyperBallBoundary<dim>::get_new_point_on_line (line);
-};
+}
{
Assert (false, ExcInternalError());
return Point<1>();
-};
+}
#endif
return quad_center;
else
return HyperBallBoundary<dim>::get_new_point_on_quad (quad);
-};
+}
return StraightBoundary<dim>::get_intermediate_points_on_line (line, points);
else
return HyperBallBoundary<dim>::get_intermediate_points_on_line (line, points);
-};
+}
StraightBoundary<dim>::get_intermediate_points_on_quad (quad, points);
else
HyperBallBoundary<dim>::get_intermediate_points_on_quad (quad, points);
-};
+}
std::vector<Point<1> > &) const
{
Assert (false, ExcInternalError());
-};
+}
#endif
Boundary<1>::FaceVertexNormals &) const
{
Assert (false, Boundary<1>::ExcFunctionNotUseful(1));
-};
+}
#endif
StraightBoundary<dim>::get_normals_at_vertices (face, face_vertex_normals);
else
HyperBallBoundary<dim>::get_normals_at_vertices (face, face_vertex_normals);
-};
+}
/* ---------------------------------------------------------------------- */
HyperBallBoundary<dim>(center, 0.)
{
this->compute_radius_automatically=true;
-};
+}
/* ---------------------------------------------------------------------- */
template <int dim>
HalfHyperShellBoundary<dim>::HalfHyperShellBoundary (const Point<dim> ¢er) :
HyperShellBoundary<dim> (center)
-{};
+{}
// inner part of the shell. proceed
// as in the base class
return HyperShellBoundary<dim>::get_new_point_on_line (line);
-};
+}
{
Assert (false, ExcInternalError());
return Point<1>();
-};
+}
#endif
// inner part of the shell. proceed
// as in the base class
return HyperShellBoundary<dim>::get_new_point_on_quad (quad);
-};
+}
return StraightBoundary<dim>::get_intermediate_points_on_line (line, points);
else
return HyperShellBoundary<dim>::get_intermediate_points_on_line (line, points);
-};
+}
StraightBoundary<dim>::get_intermediate_points_on_quad (quad, points);
else
HyperShellBoundary<dim>::get_intermediate_points_on_quad (quad, points);
-};
+}
std::vector<Point<1> > &) const
{
Assert (false, ExcInternalError());
-};
+}
#endif
Boundary<1>::FaceVertexNormals &) const
{
Assert (false, Boundary<1>::ExcFunctionNotUseful(1));
-};
+}
#endif
StraightBoundary<dim>::get_normals_at_vertices (face, face_vertex_normals);
else
HyperShellBoundary<dim>::get_normals_at_vertices (face, face_vertex_normals);
-};
+}
template <class VECTOR>
MGTransfer<VECTOR>::~MGTransfer()
-{};
+{}
template <class VECTOR>
MGMatrixBase<VECTOR>::~MGMatrixBase()
-{};
+{}
template <class VECTOR>
MGCoarseGrid<VECTOR>::~MGCoarseGrid()
-{};
+{}
// Explicit instantiations
const AccessorData *local_data) :
MGDoFAccessor<dim> (local_data),
MGDoFObjectAccessor_Inheritance<1,dim>::BaseClass(tria,level,index,local_data)
-{};
+{}
template <int dim>
unsigned int MGDoFObjectAccessor<1, dim>::mg_dof_index (const unsigned int i) const
{
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (i<this->dof_handler->get_fe().dofs_per_line,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_line));
return this->mg_dof_handler->mg_levels[this->present_level]
->line_dofs[this->present_index*this->dof_handler->get_fe().dofs_per_line+i];
-};
+}
template <int dim>
void MGDoFObjectAccessor<1, dim>::set_mg_dof_index (const unsigned int i,
const unsigned int index) const
{
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (i<this->dof_handler->get_fe().dofs_per_line,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_line));
this->mg_dof_handler->mg_levels[this->present_level]
->line_dofs[this->present_index*this->dof_handler->get_fe().dofs_per_line+i] = index;
-};
+}
template <int dim>
unsigned int MGDoFObjectAccessor<1, dim>::mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i) const
{
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (vertex<2, ExcIndexRange (i,0,2));
Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_vertex));
return (this->mg_dof_handler->mg_vertex_dofs[this->vertex_index(vertex)]
.get_index (this->present_level, i, this->dof_handler->get_fe().dofs_per_vertex));
-};
+}
template <int dim>
const unsigned int i,
const unsigned int index) const
{
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (vertex<2, ExcIndexRange (i,0,2));
Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_vertex));
this->mg_dof_handler->mg_vertex_dofs[this->vertex_index(vertex)]
.set_index (this->present_level, i, this->dof_handler->get_fe().dofs_per_vertex, index);
-};
+}
template <int dim>
void
MGDoFObjectAccessor<1, dim>::get_mg_dof_indices (std::vector<unsigned int> &dof_indices) const
{
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (dof_indices.size() == (2*this->dof_handler->get_fe().dofs_per_vertex +
this->dof_handler->get_fe().dofs_per_line),
- DoFAccessor<dim>::ExcVectorDoesNotMatch());
+ typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
dofs_per_line = this->dof_handler->get_fe().dofs_per_line;
Assert (next == dof_indices.end(),
ExcInternalError());
-};
+}
template <int dim>
Assert (next_dof_value == dof_values.end(),
ExcInternalError());
-};
+}
template <int dim>
Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
#endif
return q;
-};
+}
template <int dim>
{
DoFObjectAccessor<1, dim>::copy_from (a);
this->set_mg_dof_handler (a.mg_dof_handler);
-};
+}
/* ------------------------ MGDoFQuadAccessor --------------------------- */
const AccessorData *local_data) :
MGDoFAccessor<dim> (local_data),
MGDoFObjectAccessor_Inheritance<2,dim>::BaseClass(tria,level,index,local_data)
-{};
+{}
template <int dim>
unsigned int MGDoFObjectAccessor<2, dim>::mg_dof_index (const unsigned int i) const
{
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (i<this->dof_handler->get_fe().dofs_per_quad,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_quad));
return this->mg_dof_handler->mg_levels[this->present_level]
->quad_dofs[this->present_index*this->dof_handler->get_fe().dofs_per_quad+i];
-};
+}
template <int dim>
void MGDoFObjectAccessor<2, dim>::set_mg_dof_index (const unsigned int i,
const unsigned int index) const
{
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (i<this->dof_handler->get_fe().dofs_per_quad,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_quad));
this->mg_dof_handler->mg_levels[this->present_level]
->quad_dofs[this->present_index*this->dof_handler->get_fe().dofs_per_quad+i] = index;
-};
+}
template <int dim>
unsigned int MGDoFObjectAccessor<2, dim>::mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i) const
{
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (vertex<4, ExcIndexRange (i,0,4));
Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_vertex));
return (this->mg_dof_handler->mg_vertex_dofs[this->vertex_index(vertex)]
.get_index (this->present_level, i, this->dof_handler->get_fe().dofs_per_vertex));
-};
+}
template <int dim>
const unsigned int i,
const unsigned int index) const
{
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (vertex<4, ExcIndexRange (i,0,4));
Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_vertex));
this->mg_dof_handler->mg_vertex_dofs[this->vertex_index(vertex)]
.set_index (this->present_level, i, this->dof_handler->get_fe().dofs_per_vertex, index);
-};
+}
template <int dim>
void
MGDoFObjectAccessor<2, dim>::get_mg_dof_indices (std::vector<unsigned int> &dof_indices) const
{
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (dof_indices.size() == (4*this->dof_handler->get_fe().dofs_per_vertex +
4*this->dof_handler->get_fe().dofs_per_line +
this->dof_handler->get_fe().dofs_per_quad),
Assert (next == dof_indices.end(),
ExcInternalError());
-};
+}
template <int dim>
Assert (next_dof_value == dof_values.end(),
ExcInternalError());
-};
+}
template <int dim>
this->line_index (i),
this->mg_dof_handler
);
-};
+}
template <int dim>
Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
#endif
return q;
-};
+}
template <int dim>
{
DoFObjectAccessor<2, dim>::copy_from (a);
this->set_mg_dof_handler (a.mg_dof_handler);
-};
+}
/* ------------------------ MGDoFHexAccessor --------------------------- */
const AccessorData *local_data) :
MGDoFAccessor<dim> (local_data),
MGDoFObjectAccessor_Inheritance<3,dim>::BaseClass(tria,level,index,local_data)
-{};
+{}
template <int dim>
unsigned int MGDoFObjectAccessor<3, dim>::mg_dof_index (const unsigned int i) const
{
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (i<this->dof_handler->get_fe().dofs_per_hex,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_hex));
return this->mg_dof_handler->mg_levels[this->present_level]
->hex_dofs[this->present_index*this->dof_handler->get_fe().dofs_per_hex+i];
-};
+}
template <int dim>
void MGDoFObjectAccessor<3, dim>::set_mg_dof_index (const unsigned int i,
const unsigned int index) const
{
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (i<this->dof_handler->get_fe().dofs_per_hex,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_hex));
this->mg_dof_handler->mg_levels[this->present_level]
->hex_dofs[this->present_index*this->dof_handler->get_fe().dofs_per_hex+i] = index;
-};
+}
template <int dim>
unsigned int MGDoFObjectAccessor<3, dim>::mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i) const
{
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (vertex<8, ExcIndexRange (i,0,8));
Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_vertex));
return (this->mg_dof_handler->mg_vertex_dofs[this->vertex_index(vertex)]
.get_index (this->present_level, i, this->dof_handler->get_fe().dofs_per_vertex));
-};
+}
template <int dim>
const unsigned int i,
const unsigned int index) const
{
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (vertex<4, ExcIndexRange (i,0,4));
Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, this->dof_handler->get_fe().dofs_per_vertex));
this->mg_dof_handler->mg_vertex_dofs[this->vertex_index(vertex)]
.set_index (this->present_level, i, this->dof_handler->get_fe().dofs_per_vertex, index);
-};
+}
template <int dim>
void
MGDoFObjectAccessor<3, dim>::get_mg_dof_indices (std::vector<unsigned int> &dof_indices) const
{
- Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0,
+ typename DoFAccessor<dim>::ExcInvalidObject());
Assert (dof_indices.size() == (8*this->dof_handler->get_fe().dofs_per_vertex +
12*this->dof_handler->get_fe().dofs_per_line +
6*this->dof_handler->get_fe().dofs_per_quad +
Assert (next == dof_indices.end(),
ExcInternalError());
-};
+}
template <int dim>
Assert (next_dof_value == dof_values.end(),
ExcInternalError());
-};
+}
template <int dim>
this->line_index (i),
this->mg_dof_handler
);
-};
+}
template <int dim>
this->quad_index (i),
this->mg_dof_handler
);
-};
+}
template <int dim>
Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
#endif
return q;
-};
+}
template <int dim>
MGDoFObjectAccessor<3, dim>::copy_from (const MGDoFObjectAccessor<3, dim> &a) {
DoFObjectAccessor<3, dim>::copy_from (a);
this->set_mg_dof_handler (a.mg_dof_handler);
-};
+}
/*------------------------- Functions: MGDoFCellAccessor -----------------------*/
Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsNeighbor());
#endif
return q;
-};
+}
template <int dim>
Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
#endif
return q;
-};
+}
#if deal_II_dimension == 1
{
Assert (false, ExcNotUsefulForThisDimension());
return face_iterator();
-};
+}
#endif
MGDoFCellAccessor<2>::face (const unsigned int i) const
{
return this->line(i);
-};
+}
#endif
MGDoFCellAccessor<3>::face (const unsigned int i) const
{
return this->quad(i);
-};
+}
#endif
coarsest_level (1<<30),
finest_level (0),
indices (0)
-{};
+{}
template <int dim>
for (unsigned int i=0; i<n_levels*dofs_per_vertex; ++i)
indices[i] = DoFHandler<dim>::invalid_dof_index;
-};
+}
template <int dim>
MGDoFHandler<dim>::MGVertexDoFs::~MGVertexDoFs () {
delete[] indices;
-};
+}
template <int dim>
inline
unsigned int MGDoFHandler<dim>::MGVertexDoFs::get_coarsest_level () const {
return coarsest_level;
-};
+}
template <int dim>
inline
unsigned int MGDoFHandler<dim>::MGVertexDoFs::get_finest_level () const {
return finest_level;
-};
+}
/* ------------------------ MGDoFHandler ------------------------------------- */
template <int dim>
MGDoFHandler<dim>::MGDoFHandler (const Triangulation<dim> &tria) :
DoFHandler<dim> (tria)
-{};
+{}
template <int dim>
MGDoFHandler<dim>::~MGDoFHandler ()
{
clear ();
-};
+}
#if deal_II_dimension == 1
MGDoFHandler<1>::raw_cell_iterator
MGDoFHandler<1>::begin_raw (const unsigned int level) const {
return begin_raw_line (level);
-};
+}
template <>
MGDoFHandler<1>::cell_iterator
MGDoFHandler<1>::begin (const unsigned int level) const {
return begin_line (level);
-};
+}
template <>
MGDoFHandler<1>::active_cell_iterator
MGDoFHandler<1>::begin_active (const unsigned int level) const {
return begin_active_line (level);
-};
+}
template <>
MGDoFHandler<1>::raw_cell_iterator
MGDoFHandler<1>::end () const {
return end_line ();
-};
+}
template <>
MGDoFHandler<1>::raw_cell_iterator
MGDoFHandler<1>::last_raw () const {
return last_raw_line ();
-};
+}
template <>
MGDoFHandler<1>::raw_cell_iterator
MGDoFHandler<1>::last_raw (const unsigned int level) const {
return last_raw_line (level);
-};
+}
template <>
MGDoFHandler<1>::cell_iterator
MGDoFHandler<1>::last () const {
return last_line ();
-};
+}
template <>
MGDoFHandler<1>::cell_iterator
MGDoFHandler<1>::last (const unsigned int level) const {
return last_line (level);
-};
+}
template <>
MGDoFHandler<1>::active_cell_iterator
MGDoFHandler<1>::last_active () const {
return last_active_line ();
-};
+}
template <>
MGDoFHandler<1>::active_cell_iterator
MGDoFHandler<1>::last_active (const unsigned int level) const {
return last_active_line (level);
-};
+}
template <>
MGDoFHandler<1>::begin_raw_face (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::begin_face (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::begin_active_face (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::end_face () const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_raw_face () const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_raw_face (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_face () const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_face (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_active_face () const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_active_face (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::begin_raw_quad (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::begin_quad (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::begin_active_quad (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::end_quad () const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_raw_quad (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_quad (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_active_quad (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_raw_quad () const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_quad () const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_active_quad () const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::begin_raw_hex (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::begin_hex (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::begin_active_hex (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::end_hex () const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_raw_hex (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_hex (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_active_hex (const unsigned int) const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_raw_hex () const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_hex () const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
template <>
MGDoFHandler<1>::last_active_hex () const {
Assert (false, ExcImpossibleInDim(1));
return 0;
-};
+}
#endif
MGDoFHandler<2>::raw_cell_iterator
MGDoFHandler<2>::begin_raw (const unsigned int level) const {
return begin_raw_quad (level);
-};
+}
template <>
MGDoFHandler<2>::cell_iterator
MGDoFHandler<2>::begin (const unsigned int level) const {
return begin_quad (level);
-};
+}
template <>
MGDoFHandler<2>::active_cell_iterator
MGDoFHandler<2>::begin_active (const unsigned int level) const {
return begin_active_quad (level);
-};
+}
template <>
MGDoFHandler<2>::raw_cell_iterator
MGDoFHandler<2>::end () const {
return end_quad ();
-};
+}
template <>
MGDoFHandler<2>::raw_cell_iterator
MGDoFHandler<2>::last_raw () const {
return last_raw_quad ();
-};
+}
template <>
MGDoFHandler<2>::raw_cell_iterator
MGDoFHandler<2>::last_raw (const unsigned int level) const {
return last_raw_quad (level);
-};
+}
template <>
MGDoFHandler<2>::cell_iterator
MGDoFHandler<2>::last () const {
return last_quad ();
-};
+}
template <>
MGDoFHandler<2>::cell_iterator
MGDoFHandler<2>::last (const unsigned int level) const {
return last_quad (level);
-};
+}
template <>
MGDoFHandler<2>::active_cell_iterator
MGDoFHandler<2>::last_active () const {
return last_active_quad ();
-};
+}
template <>
MGDoFHandler<2>::active_cell_iterator
MGDoFHandler<2>::last_active (const unsigned int level) const {
return last_active_quad (level);
-};
+}
template <>
MGDoFDimensionInfo<2>::raw_face_iterator
MGDoFHandler<2>::begin_raw_face (const unsigned int level) const {
return begin_raw_line (level);
-};
+}
template <>
MGDoFDimensionInfo<2>::face_iterator
MGDoFHandler<2>::begin_face (const unsigned int level) const {
return begin_line (level);
-};
+}
template <>
MGDoFDimensionInfo<2>::active_face_iterator
MGDoFHandler<2>::begin_active_face (const unsigned int level) const {
return begin_active_line (level);
-};
+}
template <>
MGDoFDimensionInfo<2>::raw_face_iterator
MGDoFHandler<2>::end_face () const {
return end_line ();
-};
+}
template <>
MGDoFDimensionInfo<2>::raw_face_iterator
MGDoFHandler<2>::last_raw_face () const {
return last_raw_line ();
-};
+}
template <>
MGDoFDimensionInfo<2>::raw_face_iterator
MGDoFHandler<2>::last_raw_face (const unsigned int level) const {
return last_raw_line (level);
-};
+}
template <>
MGDoFDimensionInfo<2>::face_iterator
MGDoFHandler<2>::last_face () const {
return last_line ();
-};
+}
template <>
MGDoFDimensionInfo<2>::face_iterator
MGDoFHandler<2>::last_face (const unsigned int level) const {
return last_line (level);
-};
+}
template <>
MGDoFDimensionInfo<2>::active_face_iterator
MGDoFHandler<2>::last_active_face () const {
return last_active_line ();
-};
+}
template <>
MGDoFDimensionInfo<2>::active_face_iterator
MGDoFHandler<2>::last_active_face (const unsigned int level) const {
return last_active_line (level);
-};
+}
template <>
MGDoFHandler<2>::begin_raw_hex (const unsigned int) const {
Assert (false, ExcImpossibleInDim(2));
return 0;
-};
+}
template <>
MGDoFHandler<2>::begin_hex (const unsigned int) const {
Assert (false, ExcImpossibleInDim(2));
return 0;
-};
+}
template <>
MGDoFHandler<2>::begin_active_hex (const unsigned int) const {
Assert (false, ExcImpossibleInDim(2));
return 0;
-};
+}
template <>
MGDoFHandler<2>::end_hex () const {
Assert (false, ExcImpossibleInDim(2));
return 0;
-};
+}
template <>
MGDoFHandler<2>::last_raw_hex (const unsigned int) const {
Assert (false, ExcImpossibleInDim(2));
return 0;
-};
+}
template <>
MGDoFHandler<2>::last_hex (const unsigned int) const {
Assert (false, ExcImpossibleInDim(2));
return 0;
-};
+}
template <>
MGDoFHandler<2>::last_active_hex (const unsigned int) const {
Assert (false, ExcImpossibleInDim(2));
return 0;
-};
+}
template <>
MGDoFHandler<2>::last_raw_hex () const {
Assert (false, ExcImpossibleInDim(2));
return 0;
-};
+}
template <>
MGDoFHandler<2>::last_hex () const {
Assert (false, ExcImpossibleInDim(2));
return 0;
-};
+}
template <>
MGDoFHandler<2>::last_active_hex () const {
Assert (false, ExcImpossibleInDim(2));
return 0;
-};
+}
#endif
MGDoFHandler<3>::raw_cell_iterator
MGDoFHandler<3>::begin_raw (const unsigned int level) const {
return begin_raw_hex (level);
-};
+}
template <>
MGDoFHandler<3>::cell_iterator
MGDoFHandler<3>::begin (const unsigned int level) const {
return begin_hex (level);
-};
+}
template <>
MGDoFHandler<3>::active_cell_iterator
MGDoFHandler<3>::begin_active (const unsigned int level) const {
return begin_active_hex (level);
-};
+}
template <>
MGDoFHandler<3>::raw_cell_iterator
MGDoFHandler<3>::end () const {
return end_hex ();
-};
+}
template <>
MGDoFHandler<3>::raw_cell_iterator
MGDoFHandler<3>::last_raw () const {
return last_raw_hex ();
-};
+}
template <>
MGDoFHandler<3>::raw_cell_iterator
MGDoFHandler<3>::last_raw (const unsigned int level) const {
return last_raw_hex (level);
-};
+}
template <>
MGDoFHandler<3>::cell_iterator
MGDoFHandler<3>::last () const {
return last_hex ();
-};
+}
template <>
MGDoFHandler<3>::cell_iterator
MGDoFHandler<3>::last (const unsigned int level) const {
return last_hex (level);
-};
+}
template <>
MGDoFHandler<3>::active_cell_iterator
MGDoFHandler<3>::last_active () const {
return last_active_hex ();
-};
+}
template <>
MGDoFHandler<3>::active_cell_iterator
MGDoFHandler<3>::last_active (const unsigned int level) const {
return last_active_hex (level);
-};
+}
template <>
MGDoFDimensionInfo<3>::raw_face_iterator
MGDoFHandler<3>::begin_raw_face (const unsigned int level) const {
return begin_raw_quad (level);
-};
+}
template <>
MGDoFDimensionInfo<3>::face_iterator
MGDoFHandler<3>::begin_face (const unsigned int level) const {
return begin_quad (level);
-};
+}
template <>
MGDoFDimensionInfo<3>::active_face_iterator
MGDoFHandler<3>::begin_active_face (const unsigned int level) const {
return begin_active_quad (level);
-};
+}
template <>
MGDoFDimensionInfo<3>::raw_face_iterator
MGDoFHandler<3>::end_face () const {
return end_quad ();
-};
+}
template <>
MGDoFDimensionInfo<3>::raw_face_iterator
MGDoFHandler<3>::last_raw_face () const {
return last_raw_quad ();
-};
+}
template <>
MGDoFDimensionInfo<3>::raw_face_iterator
MGDoFHandler<3>::last_raw_face (const unsigned int level) const {
return last_raw_quad (level);
-};
+}
template <>
MGDoFDimensionInfo<3>::face_iterator
MGDoFHandler<3>::last_face () const {
return last_quad ();
-};
+}
template <>
MGDoFDimensionInfo<3>::face_iterator
MGDoFHandler<3>::last_face (const unsigned int level) const {
return last_quad (level);
-};
+}
template <>
MGDoFDimensionInfo<3>::active_face_iterator
MGDoFHandler<3>::last_active_face () const {
return last_active_quad ();
-};
+}
template <>
MGDoFDimensionInfo<3>::active_face_iterator
MGDoFHandler<3>::last_active_face (const unsigned int level) const {
return last_active_quad (level);
-};
+}
#endif
this->tria->begin_raw_line(level)->level(),
this->tria->begin_raw_line(level)->index(),
this);
-};
+}
template <int dim>
this->tria->begin_line(level)->level(),
this->tria->begin_line(level)->index(),
this);
-};
+}
template <int dim>
this->tria->begin_active_line(level)->level(),
this->tria->begin_active_line(level)->index(),
this);
-};
+}
template <int dim>
this->tria->begin_raw_quad(level)->level(),
this->tria->begin_raw_quad(level)->index(),
this);
-};
+}
template <int dim>
this->tria->begin_quad(level)->level(),
this->tria->begin_quad(level)->index(),
this);
-};
+}
template <int dim>
this->tria->begin_active_quad(level)->level(),
this->tria->begin_active_quad(level)->index(),
this);
-};
+}
template <int dim>
this->tria->begin_raw_hex(level)->level(),
this->tria->begin_raw_hex(level)->index(),
this);
-};
+}
template <int dim>
this->tria->begin_hex(level)->level(),
this->tria->begin_hex(level)->index(),
this);
-};
+}
template <int dim>
this->tria->begin_active_hex(level)->level(),
this->tria->begin_active_hex(level)->index(),
this);
-};
+}
template <int dim>
typename MGDoFHandler<dim>::raw_line_iterator
MGDoFHandler<dim>::end_line () const {
return raw_line_iterator (this->tria, -1, -1, this);
-};
+}
template <int dim>
typename MGDoFHandler<dim>::raw_quad_iterator
MGDoFHandler<dim>::end_quad () const {
return raw_quad_iterator (this->tria, -1, -1, this);
-};
+}
template <int dim>
typename MGDoFHandler<dim>::raw_hex_iterator
MGDoFHandler<dim>::end_hex () const {
return raw_hex_iterator (this->tria, -1, -1, this);
-};
+}
template <int dim>
return (level == mg_levels.size()-1 ?
end() :
begin_raw (level+1));
-};
+}
template <int dim>
return (level == mg_levels.size()-1 ?
cell_iterator(end()) :
begin (level+1));
-};
+}
template <int dim>
return (level == mg_levels.size()-1 ?
active_cell_iterator(end()) :
begin_active (level+1));
-};
+}
template <int dim>
return (level == mg_levels.size()-1 ?
end_face() :
begin_raw_face (level+1));
-};
+}
template <int dim>
return (level == mg_levels.size()-1 ?
face_iterator(end_face()) :
begin_face (level+1));
-};
+}
template <int dim>
return (level == mg_levels.size()-1 ?
active_face_iterator(end_face()) :
begin_active_face (level+1));
-};
+}
template <int dim>
return (level == mg_levels.size()-1 ?
end_line() :
begin_raw_line (level+1));
-};
+}
template <int dim>
return (level == mg_levels.size()-1 ?
line_iterator(end_line()) :
begin_line (level+1));
-};
+}
template <int dim>
return (level == mg_levels.size()-1 ?
active_line_iterator(end_line()) :
begin_active_line (level+1));
-};
+}
template <int dim>
return (level == mg_levels.size()-1 ?
end_quad() :
begin_raw_quad (level+1));
-};
+}
template <int dim>
return (level == mg_levels.size()-1 ?
quad_iterator(end_quad()) :
begin_quad (level+1));
-};
+}
template <int dim>
return (level == mg_levels.size()-1 ?
active_quad_iterator(end_quad()) :
begin_active_quad (level+1));
-};
+}
template <int dim>
return (level == mg_levels.size()-1 ?
end_hex() :
begin_raw_hex (level+1));
-};
+}
template <int dim>
return (level == mg_levels.size()-1 ?
hex_iterator(end_hex()) :
begin_hex (level+1));
-};
+}
template <int dim>
return (level == mg_levels.size()-1 ?
active_hex_iterator(end_hex()) :
begin_active_hex (level+1));
-};
+}
template <int dim>
this->tria->last_raw_line(level)->level(),
this->tria->last_raw_line(level)->index(),
this);
-};
+}
template <int dim>
this->tria->last_line(level)->level(),
this->tria->last_line(level)->index(),
this);
-};
+}
template <int dim>
this->tria->last_active_line(level)->level(),
this->tria->last_active_line(level)->index(),
this);
-};
+}
template <int dim>
this->tria->last_raw_quad(level)->level(),
this->tria->last_raw_quad(level)->index(),
this);
-};
+}
template <int dim>
this->tria->last_quad(level)->level(),
this->tria->last_quad(level)->index(),
this);
-};
+}
template <int dim>
this->tria->last_active_quad(level)->level(),
this->tria->last_active_quad(level)->index(),
this);
-};
+}
template <int dim>
this->tria->last_raw_hex(level)->level(),
this->tria->last_raw_hex(level)->index(),
this);
-};
+}
template <int dim>
this->tria->last_hex(level)->level(),
this->tria->last_hex(level)->index(),
this);
-};
+}
template <int dim>
this->tria->last_active_hex(level)->level(),
this->tria->last_active_hex(level)->index(),
this);
-};
+}
template <int dim>
typename MGDoFHandler<dim>::raw_line_iterator
MGDoFHandler<dim>::last_raw_line () const {
return last_raw_line (mg_levels.size()-1);
-};
+}
template <int dim>
typename MGDoFHandler<dim>::raw_quad_iterator
MGDoFHandler<dim>::last_raw_quad () const {
return last_raw_quad (mg_levels.size()-1);
-};
+}
template <int dim>
typename MGDoFHandler<dim>::raw_hex_iterator
MGDoFHandler<dim>::last_raw_hex () const {
return last_raw_hex (mg_levels.size()-1);
-};
+}
template <int dim>
typename MGDoFHandler<dim>::line_iterator
MGDoFHandler<dim>::last_line () const {
return last_line (mg_levels.size()-1);
-};
+}
template <int dim>
typename MGDoFHandler<dim>::quad_iterator
MGDoFHandler<dim>::last_quad () const {
return last_quad (mg_levels.size()-1);
-};
+}
template <int dim>
typename MGDoFHandler<dim>::hex_iterator
MGDoFHandler<dim>::last_hex () const {
return last_hex (mg_levels.size()-1);
-};
+}
template <int dim>
typename MGDoFHandler<dim>::active_line_iterator
MGDoFHandler<dim>::last_active_line () const {
return last_active_line (mg_levels.size()-1);
-};
+}
template <int dim>
typename MGDoFHandler<dim>::active_quad_iterator
MGDoFHandler<dim>::last_active_quad () const {
return last_active_quad (mg_levels.size()-1);
-};
+}
template <int dim>
typename MGDoFHandler<dim>::active_hex_iterator
MGDoFHandler<dim>::last_active_hex () const {
return last_active_hex (mg_levels.size()-1);
-};
+}
//------------------------------------------------------------------
// finally restore the user flags
const_cast<Triangulation<dim> &>(*(this->tria)).load_user_flags(user_flags);
-};
+}
#if deal_II_dimension == 1
cell->set_user_flag ();
return next_free_dof;
-};
+}
#endif
cell->set_user_flag ();
return next_free_dof;
-};
+}
#endif
cell->set_user_flag ();
return next_free_dof;
-};
+}
#endif
// let base class release its mem
// as well
DoFHandler<dim>::clear ();
-};
+}
template <int dim>
Assert (level < mg_used_dofs.size(), ExcInvalidLevel(level));
return mg_used_dofs[level];
-};
+}
#if deal_II_dimension == 1
Assert (*i != DoFHandler<1>::invalid_dof_index, ExcInternalError());
*i = new_numbers[*i];
};
-};
+}
#endif
Assert (*i != DoFHandler<2>::invalid_dof_index, ExcInternalError());
*i = new_numbers[*i];
};
-};
+}
#endif
Assert (*i != DoFHandler<3>::invalid_dof_index, ExcInternalError());
*i = new_numbers[*i];
};
-};
+}
#endif
max_level[vertex],
this->selected_fe->dofs_per_vertex);
};
-};
+}
#endif
max_level[vertex],
this->selected_fe->dofs_per_vertex);
};
-};
+}
#endif
max_level[vertex],
this->selected_fe->dofs_per_vertex);
};
-};
+}
#endif
// indices
std::vector<MGVertexDoFs> tmp;
std::swap (mg_vertex_dofs, tmp);
-};
+}
steps(steps)
{
Assert (false, ExcNotImplemented());
-};
+}
#endif
// for this level its destination
interior_boundary_dofs[level-1] = boundary_dofs;
};
-};
+}
#endif
for (std::vector<unsigned int>::const_iterator p=interior_boundary_dofs[level-1].begin();
p!=interior_boundary_dofs[level-1].end(); ++p)
u(*p) = 0;
-};
+}
//////////////////////////////////////////////////////////////////////
template <typename number>
MGTransferPrebuilt<number>::~MGTransferPrebuilt ()
-{};
+{}
template <typename number>
ExcIndexRange (to_level, 1, prolongation_matrices.size()+1));
prolongation_matrices[to_level-1].vmult (dst, src);
-};
+}
template <typename number>
ExcIndexRange (from_level, 1, prolongation_matrices.size()+1));
prolongation_matrices[from_level-1].Tvmult_add (dst, src);
-};
+}
template <typename number>
MGTransferBlock<number>::~MGTransferBlock ()
-{};
+{}
template <typename number>
prolongation_matrices[to_level-1].block(k,k).vmult (dst.block(b), src.block(b));
++k;
}
-};
+}
template <typename number>
prolongation_matrices[from_level-1].block(k,k).Tvmult_add (dst.block(b), src.block(b));
++k;
}
-};
+}
template <typename number>
MGTransferSelect<number>::~MGTransferSelect ()
-{};
+{}
template <typename number>
prolongation_matrices[to_level-1].block(selected, selected)
.vmult (dst, src);
-};
+}
template <typename number>
prolongation_matrices[from_level-1].block(selected, selected)
.Tvmult_add (dst, src);
-};
+}
// Explicit instantiations
};
};
};
-};
+}
/* ----------------------------- MGTransferBlock ------------------------ */
k += t;
}
-};
+}
template <typename number>
single_data(data),
has_block(false),
names(names)
-{};
+{}
block_data(data),
has_block(true),
names(names)
-{};
+{}
{
return (sizeof (single_data) + sizeof (block_data) +
MemoryConsumption::memory_consumption (names));
-};
+}
template <int dof_handler_dim, int patch_dim, int patch_space_dim>
DataOut_DoFData<dof_handler_dim,patch_dim,patch_space_dim>::DataOut_DoFData () :
dofs(0)
-{};
+{}
DataOut_DoFData<dof_handler_dim,patch_dim,patch_space_dim>::~DataOut_DoFData ()
{
clear ();
-};
+}
dofs = &d;
if (dofs != 0)
dofs->subscribe ();
-};
+}
dof_data.push_back (new_entry);
else
cell_data.push_back (new_entry);
-};
+}
template <int dof_handler_dim, int patch_dim, int patch_space_dim>
dofs->unsubscribe ();
dofs = 0;
};
-};
+}
};
return names;
-};
+}
DataOut_DoFData<dof_handler_dim,patch_dim,patch_space_dim>::get_patches () const
{
return patches;
-};
+}
MemoryConsumption::memory_consumption (dof_data) +
MemoryConsumption::memory_consumption (cell_data) +
MemoryConsumption::memory_consumption (patches));
-};
+}
face=next_face(face);
}
};
-};
+}
else
// just one thread
build_some_patches(thread_data[0]);
-};
+}
Assert (false, ExcInternalError());
return FaceDescriptor();
-};
+}
face.first = this->dofs->end();
face.second = 0;
return face;
-};
+}
// explicit instantiations
static T sqr (const T t)
{
return t*t;
-};
+}
fe_values.get_function_values (solution, values);
return values[0](component);
};
-};
+}
for (unsigned int i=0; i<dim; ++i)
s += d[i]*d[i];
return std::sqrt(s);
-};
+}
DerivativeApproximation::Gradient<dim>::symmetrize (Derivative &)
{
// nothing to do here
-};
+}
fe_values.get_function_grads (solution, values);
return values[0][component];
};
-};
+}
#if deal_II_dimension == 1
derivative_norm (const Derivative &d)
{
return std::fabs (d[0][0]);
-};
+}
#endif
return std::max (std::fabs (eigenvalues[0]),
std::fabs (eigenvalues[1]));
-};
+}
#endif
return std::max (std::fabs (EE[0]),
std::max (std::fabs (EE[1]),
std::fabs (EE[2])));
-};
+}
#endif
// suffice?
Assert (false, ExcNotImplemented());
return 0;
-};
+}
const double s = (d[i][j] + d[j][i]) / 2;
d[i][j] = d[j][i] = s;
};
-};
+}
solution,
component,
derivative_norm);
-};
+}
template <int dim>
solution,
component,
derivative_norm);
-};
+}
template <int dim>
solution,
component,
derivative_norm);
-};
+}
template <int dim>
solution,
component,
derivative_norm);
-};
+}
template <class DerivativeDescription, int dim>
index_intervals[i],
derivative_norm));
thread_manager.wait ();
-};
+}
*derivative_norm_on_this_cell
= DerivativeDescription::derivative_norm (derivative);
};
-};
+}
double sqr (const double x)
{
return x*x;
-};
+}
std::vector<Vector<float>*> errors (1, &error);
estimate (mapping, dof_handler, quadrature, neumann_bc, solutions, errors,
component_mask, coefficients, n_threads);
-};
+}
template <int dim>
static const MappingQ1<dim> mapping;
estimate(mapping, dof_handler, quadrature, neumann_bc, solution,
error, component_mask, coefficients, n_threads);
-};
+}
for (unsigned int s=0; s<n_solution_vectors; ++s)
(*errors[s])(cell_index) = std::sqrt((*errors[s])(cell_index));
};
-};
+}
#else // #if deal_II_dimension !=1
((t<this_thread.second) && (cell!=dof_handler.end()));
++t, ++cell);
};
-};
+}
for (unsigned int n=0; n<n_solution_vectors; ++n)
(*errors[n])(present_cell) = std::sqrt((*errors[n])(present_cell));
};
-};
+}
#endif
FEFaceValues<1> &)
{
Assert (false, ExcInternalError());
-};
+}
template <>
FESubfaceValues<1> &)
{
Assert (false, ExcInternalError());
-};
+}
#endif
Assert (face_integrals[face][0] < 0, ExcInternalError());
face_integrals[face] = face_integral;
-};
+}
};
face_integrals[face] = sum;
-};
+}
// explicit instantiations
return (((n1<n2) && (n1>0)) ||
((n1<n2) && (n2<=0)) ||
((n2<n1) && (n1>0) && (n2<=0)));
-};
+}
left_point (left_point),
right_point (right_point),
content (0)
-{};
+{}
Histogram::Interval::memory_consumption () const
{
return sizeof(*this);
-};
+}
break;
};
};
-};
+}
std::vector<Vector<number> > values_list (1,
values);
evaluate (values_list, std::vector<double>(1,0.), n_intervals, interval_spacing);
-};
+}
};
AssertThrow (out, ExcIO());
-};
+}
std::string Histogram::get_interval_spacing_names ()
{
return "linear|logarithmic";
-};
+}
return linear;
};
-};
+}
{
return (MemoryConsumption::memory_consumption (intervals) +
MemoryConsumption::memory_consumption (y_values));
-};
+}
// preset solution vector
solution(dof_number) = dof->second;
};
-};
+}
// preset solution vector
solution.block(block_index.first)(block_index.second) = dof->second;
};
-};
+}
:
first (first),
second (second)
-{};
+{}
:
first (ip.first),
second (ip.second)
-{};
+{}
.collect_args (mapping, dof, q, matrix, coefficient,
thread_ranges[thread], mutex));
thread_manager.wait ();
-};
+}
cell_matrix(i,j));
mutex.release ();
};
-};
+}
template <int dim>
rhs_vector, coefficient,
thread_ranges[thread], mutex));
thread_manager.wait ();
-};
+}
rhs_vector(dof_indices[i]) += local_rhs(i);
mutex.release ();
};
-};
+}
template <int dim>
// identity matrix on the boundary
// dofs?
Assert (false, ExcNotImplemented());
-};
+}
#endif
dof_to_boundary_mapping, coefficient,
thread_ranges[thread], mutex));
thread_manager.wait ();
-};
+}
};
mutex.release ();
};
-};
+}
template <int dim>
.collect_args (mapping, dof, q, matrix, coefficient,
thread_ranges[thread], mutex));
thread_manager.wait ();
-};
+}
rhs_vector, coefficient,
thread_ranges[thread], mutex));
thread_manager.wait ();
-};
+}
rhs_vector(dof_indices[i]) += local_rhs(i);
mutex.release ();
};
-};
+}
MemoryConsumption::memory_consumption (indices_on_cell) +
MemoryConsumption::memory_consumption (all_pointerstructs) +
MemoryConsumption::memory_consumption (dof_values_on_cell));
-};
+}
SolutionTransfer<dim, number>::Pointerstruct::memory_consumption () const
{
return sizeof(*this);
-};
+}
:
look_ahead (look_ahead),
look_back (look_back)
-{};
+{}
TimeDependent::TimeDependent (const TimeSteppingData &data_primal,
timestepping_data_primal (data_primal),
timestepping_data_dual (data_dual),
timestepping_data_postprocess (data_postprocess)
-{};
+{}
TimeDependent::~TimeDependent ()
{
while (timesteps.size() != 0)
delete_timestep (0);
-};
+}
void
timesteps.end() :
std::find(timesteps.begin(), timesteps.end(), position)),
new_timestep);
-};
+}
void
TimeDependent::add_timestep (TimeStepBase *new_timestep)
{
insert_timestep (0, new_timestep);
-};
+}
void TimeDependent::delete_timestep (const unsigned int position)
timesteps[position]->set_previous_timestep ((position!=0) ?
timesteps[position-1] :
0);
-};
+}
void
std::mem_fun(&TimeStepBase::solve_primal_problem),
timestepping_data_primal,
forward);
-};
+}
void
std::mem_fun(&TimeStepBase::solve_dual_problem),
timestepping_data_dual,
backward);
-};
+}
void
std::mem_fun(&TimeStepBase::postprocess_timestep),
timestepping_data_postprocess,
forward);
-};
+}
for (unsigned int step=0; step<timesteps.size(); ++step)
timesteps[step]->start_sweep ();
-};
+}
{
for (unsigned int step=begin; step<end; ++step)
timesteps[step]->end_sweep ();
-};
+}
mem += MemoryConsumption::memory_consumption (*timesteps[i]);
return mem;
-};
+}
sweep_no (static_cast<unsigned int>(-1)),
timestep_no (static_cast<unsigned int>(-1)),
time (time)
-{};
+{}
TimeStepBase::~TimeStepBase ()
-{};
+{}
void
TimeStepBase::wake_up (const unsigned )
-{};
+{}
void
TimeStepBase::sleep (const unsigned)
-{};
+{}
void
TimeStepBase::start_sweep ()
-{};
+{}
void
TimeStepBase::end_sweep ()
-{};
+{}
TimeStepBase::init_for_primal_problem ()
{
next_action = primal_problem;
-};
+}
TimeStepBase::init_for_dual_problem ()
{
next_action = dual_problem;
-};
+}
TimeStepBase::init_for_postprocessing ()
{
next_action = postprocess;
-};
+}
TimeStepBase::solve_dual_problem ()
{
Assert (false, ExcPureVirtualFunctionCalled());
-};
+}
TimeStepBase::postprocess_timestep ()
{
Assert (false, ExcPureVirtualFunctionCalled());
-};
+}
TimeStepBase::get_time () const
{
return time;
-};
+}
TimeStepBase::get_timestep_no () const
{
return timestep_no;
-};
+}
{
Assert (previous_timestep != 0, ExcCantComputeTimestep());
return time - previous_timestep->time;
-};
+}
{
Assert (next_timestep != 0, ExcCantComputeTimestep());
return next_timestep->time - time;
-};
+}
TimeStepBase::set_previous_timestep (const TimeStepBase *previous)
{
previous_timestep = previous;
-};
+}
TimeStepBase::set_next_timestep (const TimeStepBase *next)
{
next_timestep = next;
-};
+}
TimeStepBase::set_timestep_no (const unsigned int step_no)
{
timestep_no = step_no;
-};
+}
TimeStepBase::set_sweep_no (const unsigned int sweep)
{
sweep_no = sweep;
-};
+}
{
// only simple data types
return sizeof(*this);
-};
+}
/* ------------------------------------------------------------------------- */
refinement_flags(0)
{
Assert (false, ExcPureVirtualFunctionCalled());
-};
+}
coarse_grid (&coarse_grid),
flags (flags),
refinement_flags (refinement_flags)
-{};
+{}
Assert (tria==0, ExcInternalError());
coarse_grid = 0;
-};
+}
if (wakeup_level == flags.wakeup_level_to_build_grid)
if (flags.delete_and_rebuild_tria || !tria)
restore_grid ();
-};
+}
};
TimeStepBase::sleep (sleep_level);
-};
+}
coarsen_flags.push_back (std::vector<bool>());
tria->save_refine_flags (refine_flags.back());
tria->save_coarsen_flags (coarsen_flags.back());
-};
+}
tria->execute_coarsening_and_refinement ();
};
-};
+}
if (old_cell->has_children() && new_cell->has_children())
for (unsigned int c=0; c<GeometryInfo<dim>::children_per_cell; ++c)
::mirror_refinement_flags<dim> (new_cell->child(c), old_cell->child(c));
-};
+}
Assert (false, ExcInternalError());
return false;
-};
+}
grids_changed |= ::adapt_grid_cells<dim> (cell1, cell2);
return grids_changed;
-};
+}
// than the present one and vica versa.
::adapt_grids<dim> (*previous_tria, *tria);
};
-};
+}
void TimeStepBase_Tria<dim>::init_for_refinement ()
{
next_action = grid_refinement;
-};
+}
sizeof(flags) + sizeof(refinement_flags) +
MemoryConsumption::memory_consumption (refine_flags) +
MemoryConsumption::memory_consumption (coarsen_flags));
-};
+}
sleep_level_to_delete_grid (0)
{
Assert (false, ExcInternalError());
-};
+}
// ExcInvalidParameter(wakeup_level_to_build_grid));
// Assert (!delete_and_rebuild_tria || (sleep_level_to_delete_grid>=1),
// ExcInvalidParameter(sleep_level_to_delete_grid));
-};
+}
template <int dim>
Assert (cell_number_corridor_top>=0, ExcInvalidValue (cell_number_corridor_top));
Assert (cell_number_corridor_bottom>=0, ExcInvalidValue (cell_number_corridor_bottom));
Assert (cell_number_corridor_bottom<=1, ExcInvalidValue (cell_number_corridor_bottom));
-};
+}
template <int dim>
Assert ((coarsening_threshold < refinement_threshold) ||
((coarsening_threshold == 0) && (refinement_threshold == 0)),
ExcInvalidValue (coarsening_threshold));
-};
+}
// explicit instantiations
template class Flags<deal_II_dimension>;
template class RefinementFlags<deal_II_dimension>;
template class RefinementData<deal_II_dimension>;
-};
+}
for (unsigned int i=0; i<n; ++i)
if (p_select[i])
v(i) -= s;
-};
+}
inline double sqr_point (const Tensor<1,dim> &p)
{
return p * p;
-};
+}
// zero boundary values into the
// project_boundary_values function?
Assert (false, ExcNotImplemented());
-};
+}
#endif
// distribute solution
constraints.distribute (vec);
-};
+}
template <int dim>
rhs_vector(dofs[i]) += cell_vector(i);
}
}
-};
+}
template <int dim>
rhs_vector(dofs[i]) += cell_vector(i);
}
}
-};
+}
#else
const std::set<unsigned char> &)
{
Assert (false, ExcImpossibleInDim(1));
-};
+}
#endif
if (component_mask[fe.face_system_to_component_index(i).first])
boundary_values[outermost_cell->vertex_dof_index(direction,i)]
= function_values(fe.face_system_to_component_index(i).first);
-};
+}
i!=function_map.end(); ++i)
interpolate_boundary_values (mapping, dof, i->first, *i->second,
boundary_values, component_mask);
-};
+}
#endif
function_map[boundary_component] = &boundary_function;
interpolate_boundary_values (mapping, dof, function_map, boundary_values,
component_mask);
-};
+}
// to interpolation
interpolate_boundary_values (mapping, dof, boundary_functions,
boundary_values, std::vector<bool>());
-};
+}
#endif
// is the number on the boundary and
// thus in the solution vector
boundary_values[i] = boundary_projection(dof_to_boundary_mapping[i]);
-};
+}
template <int dim>
};
return (mean/area);
-};
+}
template <int dim, class InVector>
{
for (unsigned int i=0; i<=n_blocks; ++i)
start_indices[i] = 0;
-};
+}
start_indices(n.size()+1)
{
reinit (n);
-};
+}
{
const std::vector<unsigned int> v(n_blocks, n_elements_per_block);
reinit (v);
-};
+}
start_indices[0] = 0;
for (unsigned int i=1; i<=n_blocks; ++i)
start_indices[i] = start_indices[i-1] + n[i-1];
-};
+}
--block;
return std::make_pair<unsigned int>(block, i-start_indices[block]);
-};
+}
inline
ExcIndexRange (index, 0, start_indices[block+1]-start_indices[block]));
return start_indices[block]+index;
-};
+}
inline
BlockIndices::total_size () const
{
return start_indices[n_blocks];
-};
+}
{
Assert (block < n_blocks, ExcIndexRange(block, 0, n_blocks));
return start_indices[block+1]-start_indices[block];
-};
+}
start_indices = b.start_indices;
n_blocks = b.n_blocks;
return *this;
-};
+}
return false;
return true;
-};
+}
for (unsigned int i=0; i<=n_blocks; ++i)
std::swap (start_indices[i], b.start_indices[i]);
-};
+}
{
return (sizeof(*this) +
start_indices.size() * sizeof(start_indices[0]));
-};
+}
void swap (BlockIndices &u, BlockIndices &v)
{
u.swap (v);
-};
+}
BlockSparseMatrix<number>::n_block_cols () const
{
return columns;
-};
+}
BlockSparseMatrix<number>::n_block_rows () const
{
return rows;
-};
+}
template <typename number>
Assert (column<columns, ExcIndexRange (column, 0, columns));
return *sub_objects[row][column];
-};
+}
Assert (column<columns, ExcIndexRange (column, 0, columns));
return *sub_objects[row][column];
-};
+}
BlockSparseMatrix<number>::m () const
{
return sparsity_pattern->n_rows();
-};
+}
BlockSparseMatrix<number>::n () const
{
return sparsity_pattern->n_cols();
-};
+}
block(row_index.first,col_index.first).set (row_index.second,
col_index.second,
value);
-};
+}
block(row_index.first,col_index.first).add (row_index.second,
col_index.second,
value);
-};
+}
col_index = sparsity_pattern->column_indices.global_to_local (j);
return block(row_index.first,col_index.first) (row_index.second,
col_index.second);
-};
+}
col_index = sparsity_pattern->column_indices.global_to_local (j);
return block(row_index.first,col_index.first).el (row_index.second,
col_index.second);
-};
+}
block(r,c).copy_from (source.block(r,c));
return *this;
-};
+}
for (unsigned int r=0; r<rows; ++r)
for (unsigned int c=0; c<columns; ++c)
block(r,c).add_scaled (factor, matrix.block(r,c));
-};
+}
block(row,col).vmult_add (dst.block(row),
src.block(col));
};
-};
+}
block(row,col).vmult_add (dst.block(row),
src.block(col));
};
-};
+}
block(row,col).Tvmult_add (dst.block(col),
src.block(row));
};
-};
+}
block(row,col).Tvmult_add (dst.block(col),
src.block(row));
};
-};
+}
norm_sqr += block(row,col).matrix_scalar_product (v.block(row),
v.block(col));
return norm_sqr;
-};
+}
result += block(row,col).matrix_scalar_product (u.block(row),
v.block(col));
return result;
-};
+}
for (unsigned int row=0; row<rows; ++row)
res += dst.block(row).norm_sqr ();
return std::sqrt(res);
-};
+}
block(i,i).precondition_Jacobi (dst.block(i),
src.block(i),
omega);
-};
+}
template <typename number>
rows (0),
columns (0),
sparsity_pattern (0)
-{};
+{}
columns (0)
{
reinit (sparsity);
-};
+}
sub_objects[r][c] = 0;
delete p;
};
-};
+}
for (unsigned int c=0; c<columns; ++c)
block(r,c) = m.block(r,c);
return *this;
-};
+}
for (unsigned int r=0; r<rows; ++r)
for (unsigned int c=0; c<columns; ++c)
block(r,c).reinit ();
-};
+}
sub_objects[r][c] = new SparseMatrix<number>();
block(r,c).reinit (sparsity.block(r,c));
};
-};
+}
for (unsigned int r=0; r<rows; ++r)
for (unsigned int c=0; c<columns; ++c)
block(r,c).clear ();
-};
+}
if (block(r,c).empty () == false)
return false;
return true;
-};
+}
BlockSparseMatrix<number>::n_nonzero_elements () const
{
return sparsity_pattern->n_nonzero_elements ();
-};
+}
for (unsigned int j=0; j<columns; ++j)
count += sub_objects[i][j]->n_actually_nonzero_elements ();
return count;
-};
+}
BlockSparseMatrix<number>::get_sparsity_pattern () const
{
return *sparsity_pattern;
-};
+}
template <typename number>
for (unsigned int c=0; c<columns; ++c)
mem += MemoryConsumption::memory_consumption(*sub_objects[r][c]);
return mem;
-};
+}
Assert (row<rows, ExcIndexRange(row,0,rows));
Assert (column<columns, ExcIndexRange(column,0,columns));
return *sub_objects[row][column];
-};
+}
Assert (row<rows, ExcIndexRange(row,0,rows));
Assert (column<columns, ExcIndexRange(column,0,columns));
return *sub_objects[row][column];
-};
+}
BlockSparsityPatternBase<SparsityPatternBase>::get_row_indices () const
{
return row_indices;
-};
+}
BlockSparsityPatternBase<SparsityPatternBase>::get_column_indices () const
{
return column_indices;
-};
+}
col_index = column_indices.global_to_local (j);
sub_objects[row_index.first][col_index.first]->add (row_index.second,
col_index.second);
-};
+}
col_index = column_indices.global_to_local (j);
return sub_objects[row_index.first][col_index.first]->exists (row_index.second,
col_index.second);
-};
+}
friend class InverseConstnessIterator;
#endif
};
-};
+}
start = end;
};
Assert (start == end, ExcIteratorRangeDoesNotMatchVectorSize());
-};
+}
{
scale (factor);
return *this;
-};
+}
return *this;
}
-};
+}
/**
BlockVector<Number> &v)
{
u.swap (v);
-};
+}
for (unsigned int i=0; i<num_blocks; ++i)
::swap (components[i], v.components[i]);
::swap (block_indices, v.block_indices);
-};
+}
BlockVector<Number>::begin()
{
return iterator(*this, 0U);
-};
+}
BlockVector<Number>::begin() const
{
return const_iterator(*this, 0U);
-};
+}
template <typename Number>
BlockVector<Number>::end()
{
return iterator(*this, size());
-};
+}
BlockVector<Number>::end() const
{
return const_iterator(*this, size());
-};
+}
sum += components[i].norm_sqr();
}
return sum;
-};
+}
mem += MemoryConsumption::memory_consumption (components[i]);
mem += MemoryConsumption::memory_consumption (block_indices);
return mem;
-};
+}
--global_index;
}
-};
+}
#endif
CompressedSparsityPattern::n_rows () const
{
return rows;
-};
+}
inline
CompressedSparsityPattern::n_cols () const
{
return cols;
-};
+}
#endif
const IndexValuePair &i2) const
{
return (i1.first < i2.first);
-};
+}
constraints.begin()+old_size,
constraints.end(),
PairComparison());
-};
+}
FilteredMatrix<Matrix,Vector>::get_referenced_matrix () const
{
return *matrix;
-};
+}
unsigned int FilteredMatrix<Matrix,Vector>::m () const
{
return matrix->m();
-};
+}
unsigned int FilteredMatrix<Matrix,Vector>::n () const
{
return matrix->n();
-};
+}
template <class Matrix, class Vector>
FilteredMatrix<Matrix,Vector>::
FilteredMatrix ()
-{};
+{}
constraints (fm.constraints)
{
set_referenced_matrix (*fm.matrix);
-};
+}
FilteredMatrix (const Matrix &m)
{
set_referenced_matrix (m);
-};
+}
set_referenced_matrix (*fm.matrix);
constraints = fm.constraints;
return *this;
-};
+}
{
matrix = &m;
allocate_tmp_vector ();
-};
+}
// swap vectors to release memory
std::vector<IndexValuePair> empty;
constraints.swap (empty);
-};
+}
// each other
for (i=constraints.begin(); i!=e; ++i)
v(i->first) = i->second;
-};
+}
const const_index_value_iterator e = constraints.end();
for (; i!=e; ++i)
v(i->first) = 0;
-};
+}
const const_index_value_iterator e = constraints.end();
for (; i!=e; ++i)
out(i->first) = in(i->first);
-};
+}
tmp_mutex.release ();
// finally do post-filtering
post_filter (src, dst);
-};
+}
Assert (res2>=0, ExcInternalError());
return std::sqrt (res2);
-};
+}
tmp_mutex.release ();
// finally do post-filtering
post_filter (src, dst);
-};
+}
const value_type ret = matrix->matrix_norm_square (tmp_vector);
tmp_mutex.release ();
return ret;
-};
+}
const const_index_value_iterator e = constraints.end();
for (; i!=e; ++i)
dst(i->first) = src(i->first);
-};
+}
return (MemoryConsumption::memory_consumption (matrix) +
MemoryConsumption::memory_consumption (constraints) +
MemoryConsumption::memory_consumption (tmp_vector));
-};
+}
FullMatrix<number>::m() const
{
return this->n_rows();
-};
+}
FullMatrix<number>::n() const
{
return this->n_cols();
-};
+}
template <typename number>
return false;
return true;
-};
+}
*p++ *= factor;
return *this;
-};
+}
};
};
};
-};
+}
};
return sum;
-};
+}
template <typename number>
};
return sum;
-};
+}
const number t = (this->el(i,j) + this->el(j,i)) / 2;
this->el(i,j) = this->el(j,i) = t;
};
-};
+}
template <typename number>
max = sum;
}
return max;
-};
+}
template <typename number>
max = sum;
}
return max;
-};
+}
template <typename number>
M.data()));
return result;
-};
+}
template <typename number>
default:
return 0;
};
-};
+}
template <typename number>
*this = M;
gauss_jordan();
};
-};
+}
template <typename number>
for (unsigned int i=0; i<n; ++i, ++dst_ptr, ++src_ptr)
*dst_ptr = om * *src_ptr / this->el(i,i);
-};
+}
// reset output format
out.flags (old_flags);
out.precision(old_precision);
-};
+}
{
return sizeof(*this) - sizeof (Table<2,number>)
+ Table<2,number>::memory_consumption();
-};
+}
#endif
const unsigned int j)
{
return matrix.el(i,j);
-};
+}
const unsigned int j)
{
return matrix.el(i,j);
-};
+}
const unsigned int j)
{
return matrix(i,j);
-};
+}
average += get_element (matrix, row, col);
average /= n_elements;
return average;
-};
+}
// finally set the name
this->name = name;
-};
+}
A(0),
store_diagonals(false),
same_diagonal(false)
-{};
+{}
template <class MATRIX, typename inverse_type>
for (unsigned int i=0; i<var_diagonal.size(); ++i)
mem += MemoryConsumption::memory_consumption(var_diagonal[i]);
return mem;
-};
+}
Solver<Vector>::control() const
{
return cntrl;
-};
+}
template<class Vector>
Solver<Vector>::Solver(SolverControl &cn, VectorMemory<Vector> &mem)
: cntrl(cn),
memory(mem)
-{};
+{}
#endif
throw SolverControl::NoConvergence (this->control().last_step(),
this->control().last_value());
// otherwise exit as normal
-};
+}
#endif
const unsigned int /*row*/) const
{
return strengthen_diagonal;
-};
+}
const Vector<somenumber> &src) const
{
vmult (dst, src);
-};
+}
#endif // __deal2__sparse_ilu_h
template <typename number>
SparseILU<number>::SparseILU ()
-{};
+{}
template <typename number>
SparseILU<number>::SparseILU (const SparsityPattern &sparsity) :
SparseLUDecomposition<number> (sparsity)
-{};
+{}
// because the for-loop doesn't do
// it...
this->diag_element(this->m()-1) = 1./this->diag_element(this->m()-1);
-};
+}
// was stored inverted
dst(row) *= this->diag_element(row);
};
-};
+}
SparseILU<number>::memory_consumption () const
{
return SparseLUDecomposition<number>::memory_consumption ();
-};
+}
{
Assert (cols != 0, ExcMatrixNotInitialized());
return cols->rows;
-};
+}
template <typename number>
{
Assert (cols != 0, ExcMatrixNotInitialized());
return cols->cols;
-};
+}
template <typename number>
if (index != SparsityPattern::invalid_entry)
val[index] = value;
-};
+}
if (value != 0.)
val[index] += value;
-};
+}
Assert (cols->operator()(i,j) != SparsityPattern::invalid_entry,
ExcInvalidIndex(i,j));
return val[cols->operator()(i,j)];
-};
+}
return val[index];
else
return 0;
-};
+}
// row of a square matrix is the main
// diagonal
return val[cols->rowstart[i]];
-};
+}
// row of a square matrix is the main
// diagonal
return val[cols->rowstart[i]];
-};
+}
ExcIndexRange(index,0,cols->row_length(row)));
return val[cols->rowstart[row]+index];
-};
+}
ExcIndexRange (j, 0, cols->n_nonzero_elements()));
return val[j];
-};
+}
ExcIndexRange (j, 0, cols->n_nonzero_elements()));
return val[j];
-};
+}
// write entries
set (row, j->first, j->second);
};
-};
+}
//----------------------------------------------------------------------//
cols(0),
val(0),
max_len(0)
-{};
+{}
Assert (m.cols==0, ExcInvalidConstructorCall());
Assert (m.val==0, ExcInvalidConstructorCall());
Assert (m.max_len==0, ExcInvalidConstructorCall());
-};
+}
Assert (m.max_len==0, ExcInvalidConstructorCall());
return *this;
-};
+}
max_len(0)
{
reinit();
-};
+}
if (val != 0)
delete[] val;
-};
+}
{
cols = &sparsity;
reinit ();
-};
+}
if (val) delete[] val;
val = 0;
max_len = 0;
-};
+}
return true;
else
return cols->empty();
-};
+}
{
Assert (cols != 0, ExcMatrixNotInitialized());
return cols->n_nonzero_elements ();
-};
+}
Assert (cols != 0, ExcMatrixNotInitialized());
return std::count_if(&val[0], &val[n_nonzero_elements ()],
std::bind2nd(std::not_equal_to<double>(), 0));
-};
+}
++colnum_ptr;
};
};
-};
+}
&val[0]);
return *this;
-};
+}
for (unsigned int col=0; col<matrix.n(); ++col)
if (matrix(row,col) != 0)
set (row, col, matrix(row,col));
-};
+}
while (val_ptr != end_ptr)
*val_ptr++ += factor * *matrix_ptr++;
-};
+}
template <typename number>
*dst_ptr++ = s;
};
};
-};
+}
template <typename number>
s += *val_ptr++ * src(*colnum_ptr++);
*dst_ptr++ = s;
};
-};
+}
template <typename number>
s += *val_ptr++ * src(*colnum_ptr++);
*dst_ptr++ += s;
};
-};
+}
template <typename number>
return sum;
};
-};
+}
sum += s* v(row);
};
*partial_sum = sum;
-};
+}
return sum;
};
-};
+}
sum += s* u(row);
};
*partial_sum = sum;
-};
+}
column_sums(cols->colnums[j]) += std::fabs(val[j]);
return column_sums.linfty_norm();
-};
+}
template <typename number>
max = sum;
}
return max;
-};
+}
template <typename number>
};
*partial_norm = norm;
-};
+}
// in each row, i.e. at index
// rowstart[i]
*dst_ptr = om * *src_ptr / val[*rowstart_ptr];
-};
+}
dst = src;
SOR(dst,om);
-};
+}
template <typename number>
dst = src;
TSOR(dst,om);
-};
+}
template <typename number>
{
Assert (cols != 0, ExcMatrixNotInitialized());
return *cols;
-};
+}
out << "(" << i << "," << cols->colnums[j] << ") " << val[j] << std::endl;
AssertThrow (out, ExcIO());
-};
+}
template <typename number>
// reset output format
out.precision(old_precision);
out.flags (old_flags);
-};
+}
out << ']';
AssertThrow (out, ExcIO());
-};
+}
- reinterpret_cast<char*>(&val[0]));
in >> c;
AssertThrow (c == ']', ExcIO());
-};
+}
SparseMatrix<number>::memory_consumption () const
{
return sizeof(*this) + max_len*sizeof(number);
-};
+}
#endif
diag(0),
inv_diag(0),
inner_sums(0)
-{};
+{}
diag(0),
inv_diag(0),
inner_sums(0)
-{};
+{}
inv_diag[row] = 1.0/diag[row];
Assert(diag[row]>0, ExcInternal());
}
-};
+}
rowsum += this->global_entry (col-column_numbers);
return rowsum;
-};
+}
dst(row) *= inv_diag[row];
};
-};
+}
MemoryConsumption::memory_consumption(diag) +
MemoryConsumption::memory_consumption(inv_diag) +
MemoryConsumption::memory_consumption(inner_sums));
-};
+}
thread_manager.wait ();
};
-};
+}
template <typename number>
for (unsigned int row=begin; row<end; ++row)
if (selected[row] == true)
compute_inverse (row, local_indices);
-};
+}
// Compute inverse
inverses[row]->gauss_jordan();
-};
+}
template<typename number>
// then pass on to the function
// that actually does the work
apply_preconditioner (dst, src);
-};
+}
if (conserve_mem == true)
inverses[row] = 0;
};
-};
+}
mem += MemoryConsumption::memory_consumption (*inverses[i]);
return mem;
-};
+}
std::vector<bool>(M.m(), false))
{
compute_dof_masks (M, selected, blocking_strategy);
-};
+}
template <typename number>
default:
Assert (false, ExcInternalError());
};
-};
+}
for (unsigned int i=0; i<dof_masks.size(); ++i)
mem += MemoryConsumption::memory_consumption (dof_masks[i]);
return mem;
-};
+}
SparsityPattern::n_rows () const
{
return rows;
-};
+}
inline
SparsityPattern::n_cols () const
{
return cols;
-};
+}
inline
SparsityPattern::is_compressed () const
{
return compressed;
-};
+}
inline
SparsityPattern::get_rowstart_indices () const
{
return rowstart;
-};
+}
inline
SparsityPattern::get_column_numbers () const
{
return colnums;
-};
+}
inline
Assert ((rowstart!=0) && (colnums!=0), ExcEmptyObject());
Assert (compressed, ExcNotCompressed());
return rowstart[rows]-rowstart[0];
-};
+}
SparsityPattern::get_column_index_from_iterator (const unsigned int i)
{
return i;
-};
+}
get_column_index_from_iterator (const std::pair<unsigned int, value> &i)
{
return i.first;
-};
+}
SparsityPattern::get_column_index_from_iterator (const std::pair<const unsigned int, value> &i)
{
return i.first;
-};
+}
// everything. this also sorts the
// entries within each row
compress ();
-};
+}
#endif
SwappableVector<number>::SwappableVector ()
:
data_is_preloaded (false)
-{};
+{}
data_is_preloaded (false)
{
Assert (v.filename == "", ExcInvalidCopyOperation());
-};
+}
if (filename != "")
kill_file ();
-};
+}
lock.release ();
return *this;
-};
+}
this->reinit (0);
lock.release ();
-};
+}
// branch of the if-clause
lock.release ();
};
-};
+}
.collect_args(this, true));
// note that reload_vector also
// releases the lock
-};
+}
data_is_preloaded = true;
lock.release ();
};
-};
+}
};
lock.release ();
-};
+}
SwappableVector<number>::get_filename () const
{
return filename;
-};
+}
sizeof(lock) +
MemoryConsumption::memory_consumption (data_is_preloaded) +
Vector<number>::memory_consumption ());
-};
+}
// over to it in a second
reinit (std::distance (first, last), true);
std::copy (first, last, begin());
-};
+}
Vector<Number>::begin ()
{
return &val[0];
-};
+}
Vector<Number>::begin () const
{
return &val[0];
-};
+}
Vector<Number>::end ()
{
return &val[dim];
-};
+}
Vector<Number>::end () const
{
return &val[dim];
-};
+}
{
scale (factor);
return *this;
-};
+}
void swap (Vector<Number> &u, Vector<Number> &v)
{
u.swap (v);
-};
+}
static inline Number sqr (const Number x)
{
return x*x;
-};
+}
void Vector<Number>::reinit (const Vector<Number2>& v, const bool fast)
{
reinit (v.size(), fast);
-};
+}
std::swap (dim, v.dim);
std::swap (maxdim, v.maxdim);
std::swap (val, v.val);
-};
+}
if (*p++ != 0.0)
return false;
return true;
-};
+}
template <typename Number>
sum0 += ::sqr(*ptr++);
return sum0+sum1+sum2+sum3;
-};
+}
template <typename Number>
sum0 += *ptr++;
return (sum0+sum1+sum2+sum3)/size();
-};
+}
template <typename Number>
sum0 += std::fabs(*ptr++);
return sum0+sum1+sum2+sum3;
-};
+}
template <typename Number>
Number Vector<Number>::l2_norm () const
{
return std::sqrt(norm_sqr());
-};
+}
template <typename Number>
return std::pow(sum0+sum1+sum2+sum3,
static_cast<Number>(1./p));
-};
+}
template <typename Number>
return std::max (std::max(max0, max1),
std::max(max2, max3));
-};
+}
template <typename Number>
b_ptr = b.begin();
while (i_ptr!=i_end)
*i_ptr++ = *a_ptr++ / *b_ptr++;
-};
+}
out << std::endl;
AssertThrow (out, ExcIO());
-};
+}
out.write (&outro, 1);
AssertThrow (out, ExcIO());
-};
+}
Vector<Number>::memory_consumption () const
{
return sizeof(*this) + (maxdim * sizeof(Number));
-};
+}
#endif
:
rows (0),
columns (0)
-{};
+{}
columns (0)
{
reinit (r,c);
-};
+}
rows = 0;
columns=0;
-};
+}
{
// clear all memory
reinit (0,0);
-};
+}
for (unsigned int i=0; i<rows; ++i)
for (unsigned int j=0; j<columns; ++j)
sub_objects[i][j] = new SparsityPatternBase;
-};
+}
collect_sizes ();
return *this;
-};
+}
// finally initialize the row
// indices with this array
column_indices.reinit (col_sizes);
-};
+}
for (unsigned int i=0; i<rows; ++i)
for (unsigned int j=0; j<columns; ++j)
sub_objects[i][j]->compress ();
-};
+}
if (sub_objects[i][j]->empty () == false)
return false;
return true;
-};
+}
max_entries = this_row;
};
return max_entries;
-};
+}
for (unsigned int r=0; r<rows; ++r)
count += sub_objects[r][0]->n_rows();
return count;
-};
+}
for (unsigned int c=0; c<columns; ++c)
count += sub_objects[0][c]->n_cols();
return count;
-};
+}
for (unsigned int j=0; j<columns; ++j)
count += sub_objects[i][j]->n_nonzero_elements ();
return count;
-};
+}
BlockSparsityPattern::BlockSparsityPattern ()
-{};
+{}
:
BlockSparsityPatternBase<SparsityPattern>(n_rows,
n_columns)
-{};
+{}
if (sub_objects[i][j]->is_compressed () == false)
return false;
return true;
-};
+}
mem += MemoryConsumption::memory_consumption (*sub_objects[r][c]);
return mem;
-};
+}
// and finally enquire their new
// sizes
collect_sizes();
-};
+}
CompressedBlockSparsityPattern::CompressedBlockSparsityPattern ()
-{};
+{}
:
BlockSparsityPatternBase<CompressedSparsityPattern>(n_rows,
n_columns)
-{};
+{}
template class Iterator<float,false>;
template class Iterator<float,true>;
-};
+}
CompressedSparsityPattern::CompressedSparsityPattern () :
rows(0),
cols(0)
-{};
+{}
{
Assert (s.rows == 0, ExcInvalidConstructorCall());
Assert (s.cols == 0, ExcInvalidConstructorCall());
-};
+}
cols(0)
{
reinit (m,n);
-};
+}
cols(0)
{
reinit (n,n);
-};
+}
Assert (cols == 0, ExcInvalidConstructorCall());
return *this;
-};
+}
void
CompressedSparsityPattern::compress ()
-{};
+{}
CompressedSparsityPattern::empty () const
{
return ((rows==0) && (cols==0));
-};
+}
m = std::max (m, static_cast<unsigned int>(column_indices[i].size()));
return m;
-};
+}
// assures uniqueness and
// sortedness of the column indices
column_indices[i].insert (j);
-};
+}
bool
// this is not the diagonal
if (row != *i)
add (*i, row);
-};
+}
CompressedSparsityPattern::row_length (const unsigned int row) const
{
return column_indices[row].size();
-};
+}
std::set<unsigned int>::const_iterator p = column_indices[row].begin();
std::advance (p, index);
return *p;
-};
+}
b = std::abs(static_cast<signed int>(row-*i));
return b;
-};
+}
for (unsigned int i=0; i<rows; ++i)
n += column_indices[i].size();
return n;
-};
+}
(*matrix)(row,index)));
};
};
-};
+}
// presently not implemented, but
// should be fairly simple to do
Assert (false, ExcNotImplemented());
-};
+}
tmp_mutex.acquire ();
tmp_vector.reinit (matrix->n(), true);
tmp_mutex.release ();
-};
+}
tmp_mutex.acquire ();
tmp_vector.reinit (matrix->n(), true);
tmp_mutex.release ();
-};
+}
tmp_mutex.acquire ();
tmp_vector.reinit (block_sizes, true);
tmp_mutex.release ();
-};
+}
tmp_mutex.acquire ();
tmp_vector.reinit (block_sizes, true);
tmp_mutex.release ();
-};
+}
template class FilteredMatrix<SparseMatrix<double>,Vector<double> >;
show_absolute_values (show_absolute_values),
block_size (block_size),
discontinuous (discontinuous)
-{};
+{}
MatrixOut::~MatrixOut ()
-{};
+{}
MatrixOut::get_patches () const
{
return patches;
-};
+}
MatrixOut::get_dataset_names () const
{
return std::vector<std::string>(1,name);
-};
+}
:
last_step (last_step),
last_residual (last_residual)
-{};
+{}
const char *
m_log_history(m_log_history),
m_log_frequency(1),
m_log_result(m_log_result)
-{};
+{}
SolverControl::~SolverControl()
-{};
+{}
:
SolverControl (n, tol, m_log_history, m_log_result),
reduce(red)
-{};
+{}
ReductionControl::~ReductionControl()
-{};
+{}
double
ReductionControl::initial_value() const {
return initial_val;
-};
+}
SolverControl::State
}
else
return SolverControl::check(step, check_value);
-};
+}
AssertThrow (false, ExcMessage("You can only use the HSL functions after putting "
"the respective files in the right place, "
"re-configuring the library and re-building it!"));
- };
+ }
extern "C"
AssertThrow (false, ExcMessage("You can only use the HSL functions after putting "
"the respective files in the right place, "
"re-configuring the library and re-building it!"));
- };
+ }
extern "C"
AssertThrow (false, ExcMessage("You can only use the HSL functions after putting "
"the respective files in the right place, "
"re-configuring the library and re-building it!"));
- };
+ }
extern "C" void ma27x1_ (unsigned int *)
AssertThrow (false, ExcMessage("You can only use the HSL functions after putting "
"the respective files in the right place, "
"re-configuring the library and re-building it!"));
- };
+ }
extern "C" void ma27x2_ (unsigned int *)
AssertThrow (false, ExcMessage("You can only use the HSL functions after putting "
"the respective files in the right place, "
"re-configuring the library and re-building it!"));
- };
+ }
extern "C" void ma27x3_ (const unsigned int *)
AssertThrow (false, ExcMessage("You can only use the HSL functions after putting "
"the respective files in the right place, "
"re-configuring the library and re-building it!"));
- };
+ }
}
-};
+}
#endif // ifndef HAVE_HSL_MA27
AssertThrow (false, ExcMessage("You can only use the HSL functions after putting "
"the respective files in the right place, "
"re-configuring the library and re-building it!"));
- };
+ }
extern "C"
AssertThrow (false, ExcMessage("You can only use the HSL functions after putting "
"the respective files in the right place, "
"re-configuring the library and re-building it!"));
- };
+ }
extern "C"
AssertThrow (false, ExcMessage("You can only use the HSL functions after putting "
"the respective files in the right place, "
"re-configuring the library and re-building it!"));
- };
+ }
extern "C"
AssertThrow (false, ExcMessage("You can only use the HSL functions after putting "
"the respective files in the right place, "
"re-configuring the library and re-building it!"));
- };
+ }
}
-};
+}
#endif // ifndef HAVE_HSL_MA47
list_access_lock.acquire ();
communication_log.push_back (record);
list_access_lock.release ();
- };
+ }
/**
std::cerr << "++++++++++++++++++++++++++++++" << std::endl;
list_access_lock.release ();
- };
+ }
/**
if (i->child_pid == child_pid)
communication_log.erase (i);
list_access_lock.release ();
- };
-};
+ }
+}
<< std::endl;
CommunicationsLog::list_communication (child);
std::abort ();
- };
+ }
/**
<< std::endl;
CommunicationsLog::list_communication (child);
std::abort ();
- };
-};
+ }
+}
initialize_called (false),
factorize_called (false),
sparsity_pattern (0)
-{};
+{}
delete detached_mode_data;
detached_mode_data = 0;
};
-};
+}
{
Assert (initialize_called == false, ExcInitializeAlreadyCalled());
detached_mode = true;
-};
+}
SparseDirectMA27::detached_mode_set () const
{
return detached_mode;
-};
+}
// note that we have already been
// in this function
initialize_called = true;
-};
+}
// note that we have been here
// already
factorize_called = true;
-};
+}
call_ma27cd (&n_rows, &A[0], &LA,
&IW[0], &LIW, &MAXFRT,
&rhs_and_solution(0), &IW1[0], &NSTEPS);
-};
+}
initialize (matrix.get_sparsity_pattern());
factorize (matrix);
solve (rhs_and_solution);
-};
+}
MemoryConsumption::memory_consumption (IW) +
MemoryConsumption::memory_consumption (IKEEP) +
MemoryConsumption::memory_consumption (IW1));
-};
+}
return non_static_synchronisation_lock;
else
return static_synchronisation_lock;
-};
+}
++global_index;
};
Assert (global_index == n_nonzero_elements, ExcInternalError());
-};
+}
detached_mode_data->mutex.release ();
};
-};
+}
detached_mode_data->mutex.release ();
};
-};
+}
detached_mode_data->put (RHS, *N, "RHS");
detached_mode_data->get (RHS, *N, "RHS");
};
-};
+}
detached_mode_data->get (NRLNEC, 1, "NRLNEC");
detached_mode_data->mutex.release ();
};
-};
+}
detached_mode_data->get (NIRNEC, 1, "NIRNEC");
detached_mode_data->mutex.release ();
};
-};
+}
detached_mode_data->put (LP, 1, "LP");
detached_mode_data->mutex.release ();
};
-};
+}
initialize_called (false),
factorize_called (false),
matrix (0)
-{};
+{}
// note that we have already been
// in this function
initialize_called = true;
-};
+}
// note that we have been here
// already
factorize_called = true;
-};
+}
call_ma47cd (&n_rows, &A[0], &LA,
&IW[0], &LIW,
&rhs_and_solution(0), &IW1[0], &ICNTL[0]);
-};
+}
initialize (matrix);
factorize (matrix);
solve (rhs_and_solution);
-};
+}
MemoryConsumption::memory_consumption (IW) +
MemoryConsumption::memory_consumption (KEEP) +
MemoryConsumption::memory_consumption (IW1));
-};
+}
SparseDirectMA47::get_synchronisation_lock () const
{
return synchronisation_lock;
-};
+}
++global_index;
};
Assert (global_index == n_nonzero_elements, ExcInternalError());
-};
+}
unsigned int *ICNTL) // length 7
{
HSL::MA47::ma47id_ (CNTL, ICNTL);
-};
+}
row_numbers, column_numbers,
IW, LIW, KEEP,
ICNTL, &RINFO[0], INFO);
-};
+}
A, LA,
IW, LIW, KEEP, CNTL, ICNTL,
IW1, &RINFO[0], INFO);
-};
+}
HSL::MA47::ma47cd_(n_rows, A, LA,
IW, LIW, &W[0],
rhs_and_solution, IW1, ICNTL);
-};
+}
colnums(0)
{
reinit (0,0,0);
-};
+}
Assert (s.cols == 0, ExcInvalidConstructorCall());
reinit (0,0,0);
-};
+}
colnums(0)
{
reinit (m,n,max_per_row);
-};
+}
colnums(0)
{
reinit (m, n, row_lengths);
-};
+}
colnums(0)
{
reinit (n,n,max_per_row);
-};
+}
colnums(0)
{
reinit (m, m, row_lengths);
-};
+}
Assert (next_free_slot <= &colnums[rowstart[row+1]],
ExcNotEnoughSpace (0,rowstart[row+1]-rowstart[row]));
};
-};
+}
Assert (cols == 0, ExcInvalidConstructorCall());
return *this;
-};
+}
// other @p{reinit} function
const std::vector<unsigned int> row_lengths (m, max_per_row);
reinit (m, n, row_lengths);
-};
+}
max_vec_len = nonzero_elements;
compressed = true;
-};
+}
copy_from (csp.n_rows(), csp.n_cols(),
csp.column_indices.begin(),
csp.column_indices.end());
-};
+}
template <typename number>
// finally compress
compress ();
-};
+}
return true;
};
return false;
-};
+}
m = std::max (m, rowstart[i]-rowstart[i-1]);
return m;
-};
+}
// wrong: there was not enough space
// in this line
Assert (false, ExcNotEnoughSpace(i, rowstart[i+1]-rowstart[i]));
-};
+}
bool
// so return the respective pair
return std::make_pair (row,col);
-};
+}
if (colnums[k] != row)
add (colnums[k], row);
};
-};
+}
// the entries of this line
break;
return b;
-};
+}
out << ']';
AssertThrow (out, ExcIO());
-};
+}
- reinterpret_cast<char*>(&colnums[0]));
in >> c;
AssertThrow (c == ']', ExcIO());
-};
+}
return (sizeof(*this) +
max_dim * sizeof(unsigned int) +
max_vec_len * sizeof(unsigned int));
-};
+}