-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
-
+//---------------------------- dof_accessor.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- dof_accessor.cc ---------------------------
#include <dofs/dof_accessor.h>
#include <vector>
-
-
-
/*------------------------- Functions: DoFLineAccessor -----------------------*/
-
template <int dim>
void DoFObjectAccessor<1, dim>::set_dof_index (const unsigned int i,
const unsigned int index) const
};
-
-
template <int dim>
void DoFObjectAccessor<1, dim>::set_vertex_dof_index (const unsigned int vertex,
const unsigned int i,
};
-
template <int dim>
void DoFObjectAccessor<1, dim>::
distribute_local_to_global (const Vector<double> &local_source,
};
-
template <int dim>
void DoFObjectAccessor<1, dim>::
distribute_local_to_global (const FullMatrix<double> &local_source,
};
-
template <int dim>
template <typename number>
void
};
-
template <int dim>
template <typename number>
void
};
-
-
/*------------------------- Functions: DoFQuadAccessor -----------------------*/
};
-
template <int dim>
void
DoFObjectAccessor<2, dim>::set_vertex_dof_index (const unsigned int vertex,
};
-
template <int dim>
void DoFObjectAccessor<2, dim>::
distribute_local_to_global (const Vector<double> &local_source,
};
-
template <int dim>
void DoFObjectAccessor<2, dim>::
distribute_local_to_global (const FullMatrix<double> &local_source,
};
-
template <int dim>
template <typename number>
void
};
-
template <int dim>
template <typename number>
void
};
-
-
-
-
/*------------------------- Functions: DoFHexAccessor -----------------------*/
};
-
template <int dim>
void DoFObjectAccessor<3, dim>::set_vertex_dof_index (const unsigned int vertex,
const unsigned int i,
};
-
template <int dim>
void DoFObjectAccessor<3, dim>::
distribute_local_to_global (const Vector<double> &local_source,
};
-
template <int dim>
void DoFObjectAccessor<3, dim>::
distribute_local_to_global (const FullMatrix<double> &local_source,
};
-
template <int dim>
template <typename number>
void
};
-
template <int dim>
template <typename number>
void
};
-
-
-
/*------------------------- Functions: DoFCellAccessor -----------------------*/
-
#if deal_II_dimension == 1
template <>
#endif
-
#if deal_II_dimension == 2
template <>
#endif
-
#if deal_II_dimension == 3
template <>
#endif
-
-
template <int dim>
template <typename number>
void
};
-
template <int dim>
template <typename number>
void
};
-
-
-
-
-
// explicit instantiations
Vector<float> &) const;
-
#if deal_II_dimension == 1
template class DoFObjectAccessor<1, 1>;
#endif
#endif
-
#if deal_II_dimension == 3
template class DoFObjectAccessor<1, 3>;
template class DoFObjectAccessor<2, 3>;
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
-
+//---------------------------- dof_constraints.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- dof_constraints.cc ---------------------------
#include <dofs/dof_constraints.h>
#include <numeric>
-
inline
bool
ConstraintMatrix::ConstraintLine::operator < (const ConstraintLine &a) const
};
-
-
ConstraintMatrix::ConstraintMatrix () :
lines(), sorted(false) {};
-
void ConstraintMatrix::add_line (const unsigned int line) {
Assert (sorted==false, ExcMatrixIsClosed());
lines.push_back (ConstraintLine());
lines.back().line = line;
};
-
void ConstraintMatrix::add_entry (const unsigned int line,
};
-
-
void ConstraintMatrix::close () {
Assert (sorted==false, ExcMatrixIsClosed());
sorted = true;
};
-
void ConstraintMatrix::clear () {
lines = vector<ConstraintLine>();
};
-
void ConstraintMatrix::condense (const SparsityPattern &uncondensed,
SparsityPattern &condensed) const {
Assert (sorted == true, ExcMatrixNotClosed());
Assert (uncondensed.n_rows() == uncondensed.n_cols(),
ExcMatrixNotSquare());
-
- // store for each line of the matrix
+
+// store for each line of the matrix
// its new line number
// after compression. If the shift is
// -1, this line will be condensed away
else
new_line.push_back (row-shift);
-
- next_constraint = lines.begin();
+
+next_constraint = lines.begin();
// note: in this loop we need not check
// whether #next_constraint# is a valid
// iterator, since #next_constraint# is
};
-
void ConstraintMatrix::condense (SparsityPattern &sparsity) const {
Assert (sorted == true, ExcMatrixNotClosed());
Assert (sparsity.is_compressed() == false, ExcMatrixIsClosed());
};
-
unsigned int ConstraintMatrix::n_constraints () const
{
return lines.size();
};
-
bool ConstraintMatrix::is_constrained (const unsigned int index) const
{
if (sorted == true)
};
-
void ConstraintMatrix::print (ostream &out) const {
for (unsigned int i=0; i!=lines.size(); ++i)
for (unsigned int j=0; j!=lines[i].entries.size(); ++j)
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998, 1999 */
+//---------------------------- dof_handler.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- dof_handler.cc ---------------------------
#include <dofs/dof_handler.h>
#include <algorithm>
-
template <int dim>
DoFHandler<dim>::DoFHandler (Triangulation<dim> &tria) :
tria(&tria),
{};
-
template <int dim>
DoFHandler<dim>::~DoFHandler ()
{};
-
-
-
-
#if deal_II_dimension == 1
template <>
};
-
template <>
DoFHandler<1>::cell_iterator
DoFHandler<1>::begin (const unsigned int level) const {
};
-
template <>
DoFHandler<1>::active_cell_iterator
DoFHandler<1>::begin_active (const unsigned int level) const {
};
-
template <>
DoFHandler<1>::raw_cell_iterator
DoFHandler<1>::end () const {
};
-
template <>
DoFHandler<1>::raw_cell_iterator
DoFHandler<1>::last_raw () const {
};
-
template <>
DoFHandler<1>::raw_cell_iterator
DoFHandler<1>::last_raw (const unsigned int level) const {
};
-
template <>
DoFHandler<1>::cell_iterator
DoFHandler<1>::last () const {
};
-
template <>
DoFHandler<1>::cell_iterator
DoFHandler<1>::last (const unsigned int level) const {
};
-
template <>
DoFHandler<1>::active_cell_iterator
DoFHandler<1>::last_active () const {
};
-
template <>
DoFHandler<1>::active_cell_iterator
DoFHandler<1>::last_active (const unsigned int level) const {
};
-
template <>
DoFDimensionInfo<1>::raw_face_iterator
DoFHandler<1>::begin_raw_face (const unsigned int) const {
};
-
template <>
DoFDimensionInfo<1>::face_iterator
DoFHandler<1>::begin_face (const unsigned int) const {
};
-
template <>
DoFDimensionInfo<1>::active_face_iterator
DoFHandler<1>::begin_active_face (const unsigned int) const {
};
-
template <>
DoFDimensionInfo<1>::raw_face_iterator
DoFHandler<1>::end_face () const {
};
-
template <>
DoFDimensionInfo<1>::raw_face_iterator
DoFHandler<1>::last_raw_face () const {
};
-
template <>
DoFDimensionInfo<1>::raw_face_iterator
DoFHandler<1>::last_raw_face (const unsigned int) const {
};
-
template <>
DoFDimensionInfo<1>::face_iterator
DoFHandler<1>::last_face () const {
};
-
template <>
DoFDimensionInfo<1>::face_iterator
DoFHandler<1>::last_face (const unsigned int) const {
};
-
template <>
DoFDimensionInfo<1>::active_face_iterator
DoFHandler<1>::last_active_face () const {
};
-
template <>
DoFDimensionInfo<1>::active_face_iterator
DoFHandler<1>::last_active_face (const unsigned int) const {
};
-
-
template <>
DoFHandler<1>::raw_quad_iterator
DoFHandler<1>::begin_raw_quad (const unsigned int) const {
};
-
template <>
DoFHandler<1>::quad_iterator
DoFHandler<1>::begin_quad (const unsigned int) const {
};
-
template <>
DoFHandler<1>::active_quad_iterator
DoFHandler<1>::begin_active_quad (const unsigned int) const {
};
-
template <>
DoFHandler<1>::raw_quad_iterator
DoFHandler<1>::end_quad () const {
};
-
template <>
DoFHandler<1>::raw_quad_iterator
DoFHandler<1>::last_raw_quad (const unsigned int) const {
};
-
template <>
DoFHandler<1>::active_quad_iterator
DoFHandler<1>::last_active_quad (const unsigned int) const {
};
-
template <>
DoFHandler<1>::raw_quad_iterator
DoFHandler<1>::last_raw_quad () const {
};
-
template <>
DoFHandler<1>::quad_iterator
DoFHandler<1>::last_quad () const {
};
-
template <>
DoFHandler<1>::active_quad_iterator
DoFHandler<1>::last_active_quad () const {
};
-
template <>
DoFHandler<1>::raw_hex_iterator
DoFHandler<1>::begin_raw_hex (const unsigned int) const {
};
-
template <>
DoFHandler<1>::hex_iterator
DoFHandler<1>::begin_hex (const unsigned int) const {
};
-
template <>
DoFHandler<1>::active_hex_iterator
DoFHandler<1>::begin_active_hex (const unsigned int) const {
};
-
template <>
DoFHandler<1>::raw_hex_iterator
DoFHandler<1>::end_hex () const {
};
-
template <>
DoFHandler<1>::raw_hex_iterator
DoFHandler<1>::last_raw_hex (const unsigned int) const {
};
-
template <>
DoFHandler<1>::raw_hex_iterator
DoFHandler<1>::last_raw_hex () const {
};
-
template <>
DoFHandler<1>::hex_iterator
DoFHandler<1>::last_hex (const unsigned int) const {
};
-
template <>
DoFHandler<1>::hex_iterator
DoFHandler<1>::last_hex () const {
};
-
template <>
DoFHandler<1>::active_hex_iterator
DoFHandler<1>::last_active_hex (const unsigned int) const {
};
-
template <>
DoFHandler<1>::active_hex_iterator
DoFHandler<1>::last_active_hex () const {
};
-
template <>
DoFHandler<2>::cell_iterator
DoFHandler<2>::begin (const unsigned int level) const {
};
-
template <>
DoFHandler<2>::active_cell_iterator
DoFHandler<2>::begin_active (const unsigned int level) const {
};
-
template <>
DoFHandler<2>::raw_cell_iterator
DoFHandler<2>::end () const {
};
-
template <>
DoFHandler<2>::raw_cell_iterator
DoFHandler<2>::last_raw () const {
};
-
template <>
DoFHandler<2>::raw_cell_iterator
DoFHandler<2>::last_raw (const unsigned int level) const {
};
-
template <>
DoFHandler<2>::cell_iterator
DoFHandler<2>::last () const {
};
-
template <>
DoFHandler<2>::cell_iterator
DoFHandler<2>::last (const unsigned int level) const {
};
-
template <>
DoFHandler<2>::active_cell_iterator
DoFHandler<2>::last_active () const {
};
-
template <>
DoFHandler<2>::active_cell_iterator
DoFHandler<2>::last_active (const unsigned int level) const {
};
-
template <>
DoFDimensionInfo<2>::face_iterator
DoFHandler<2>::begin_face (const unsigned int level) const {
};
-
template <>
DoFDimensionInfo<2>::active_face_iterator
DoFHandler<2>::begin_active_face (const unsigned int level) const {
};
-
template <>
DoFDimensionInfo<2>::raw_face_iterator
DoFHandler<2>::end_face () const {
};
-
template <>
DoFDimensionInfo<2>::raw_face_iterator
DoFHandler<2>::last_raw_face () const {
};
-
template <>
DoFDimensionInfo<2>::raw_face_iterator
DoFHandler<2>::last_raw_face (const unsigned int level) const {
};
-
template <>
DoFDimensionInfo<2>::face_iterator
DoFHandler<2>::last_face () const {
};
-
template <>
DoFDimensionInfo<2>::face_iterator
DoFHandler<2>::last_face (const unsigned int level) const {
};
-
template <>
DoFDimensionInfo<2>::active_face_iterator
DoFHandler<2>::last_active_face () const {
};
-
template <>
DoFDimensionInfo<2>::active_face_iterator
DoFHandler<2>::last_active_face (const unsigned int level) const {
};
-
template <>
DoFHandler<2>::raw_hex_iterator
DoFHandler<2>::begin_raw_hex (const unsigned int) const {
};
-
template <>
DoFHandler<2>::hex_iterator
DoFHandler<2>::begin_hex (const unsigned int) const {
};
-
template <>
DoFHandler<2>::active_hex_iterator
DoFHandler<2>::begin_active_hex (const unsigned int) const {
};
-
template <>
DoFHandler<2>::raw_hex_iterator
DoFHandler<2>::end_hex () const {
};
-
template <>
DoFHandler<2>::raw_hex_iterator
DoFHandler<2>::last_raw_hex (const unsigned int) const {
};
-
template <>
DoFHandler<2>::raw_hex_iterator
DoFHandler<2>::last_raw_hex () const {
};
-
template <>
DoFHandler<2>::hex_iterator
DoFHandler<2>::last_hex (const unsigned int) const {
};
-
template <>
DoFHandler<2>::hex_iterator
DoFHandler<2>::last_hex () const {
};
-
template <>
DoFHandler<2>::active_hex_iterator
DoFHandler<2>::last_active_hex (const unsigned int) const {
};
-
template <>
DoFHandler<2>::active_hex_iterator
DoFHandler<2>::last_active_hex () const {
#endif
-
-
-
#if deal_II_dimension == 3
template <>
};
-
template <>
DoFHandler<3>::cell_iterator
DoFHandler<3>::begin (const unsigned int level) const {
};
-
template <>
DoFHandler<3>::active_cell_iterator
DoFHandler<3>::begin_active (const unsigned int level) const {
};
-
template <>
DoFHandler<3>::raw_cell_iterator
DoFHandler<3>::end () const {
};
-
template <>
DoFHandler<3>::raw_cell_iterator
DoFHandler<3>::last_raw () const {
};
-
template <>
DoFHandler<3>::raw_cell_iterator
DoFHandler<3>::last_raw (const unsigned int level) const {
};
-
template <>
DoFHandler<3>::cell_iterator
DoFHandler<3>::last () const {
};
-
template <>
DoFHandler<3>::cell_iterator
DoFHandler<3>::last (const unsigned int level) const {
};
-
template <>
DoFHandler<3>::active_cell_iterator
DoFHandler<3>::last_active () const {
};
-
template <>
DoFHandler<3>::active_cell_iterator
DoFHandler<3>::last_active (const unsigned int level) const {
};
-
-
-
-
-
template <>
DoFHandler<3>::raw_face_iterator
DoFHandler<3>::begin_raw_face (const unsigned int level) const {
};
-
template <>
DoFHandler<3>::face_iterator
DoFHandler<3>::begin_face (const unsigned int level) const {
};
-
template <>
DoFHandler<3>::active_face_iterator
DoFHandler<3>::begin_active_face (const unsigned int level) const {
};
-
template <>
DoFHandler<3>::raw_face_iterator
DoFHandler<3>::end_face () const {
};
-
template <>
DoFHandler<3>::raw_face_iterator
DoFHandler<3>::last_raw_face () const {
};
-
template <>
DoFHandler<3>::raw_face_iterator
DoFHandler<3>::last_raw_face (const unsigned int level) const {
};
-
template <>
DoFHandler<3>::face_iterator
DoFHandler<3>::last_face () const {
};
-
template <>
DoFHandler<3>::face_iterator
DoFHandler<3>::last_face (const unsigned int level) const {
};
-
template <>
DoFHandler<3>::active_face_iterator
DoFHandler<3>::last_active_face () const {
};
-
template <>
DoFHandler<3>::active_face_iterator
DoFHandler<3>::last_active_face (const unsigned int level) const {
#endif
-
template <int dim>
typename DoFHandler<dim>::raw_line_iterator
DoFHandler<dim>::begin_raw_line (const unsigned int level) const {
};
-
template <int dim>
typename DoFHandler<dim>::line_iterator
DoFHandler<dim>::begin_line (const unsigned int level) const {
};
-
template <int dim>
typename DoFHandler<dim>::active_line_iterator
DoFHandler<dim>::begin_active_line (const unsigned int level) const {
};
-
template <int dim>
typename DoFHandler<dim>::raw_quad_iterator
DoFHandler<dim>::begin_raw_quad (const unsigned int level) const {
};
-
template <int dim>
typename DoFHandler<dim>::quad_iterator
DoFHandler<dim>::begin_quad (const unsigned int level) const {
};
-
template <int dim>
typename DoFHandler<dim>::active_quad_iterator
DoFHandler<dim>::begin_active_quad (const unsigned int level) const {
};
-
-
template <int dim>
typename DoFHandler<dim>::raw_hex_iterator
DoFHandler<dim>::begin_raw_hex (const unsigned int level) const {
};
-
template <int dim>
typename DoFHandler<dim>::hex_iterator
DoFHandler<dim>::begin_hex (const unsigned int level) const {
};
-
template <int dim>
typename DoFHandler<dim>::active_hex_iterator
DoFHandler<dim>::begin_active_hex (const unsigned int level) const {
};
-
template <int dim>
typename DoFHandler<dim>::raw_line_iterator
DoFHandler<dim>::end_line () const {
};
-
template <int dim>
typename DoFHandler<dim>::raw_quad_iterator
DoFHandler<dim>::end_quad () const {
};
-
template <int dim>
typename DoFHandler<dim>::raw_hex_iterator
DoFHandler<dim>::end_hex () const {
};
-
template <int dim>
typename DoFDimensionInfo<dim>::raw_cell_iterator
DoFHandler<dim>::end_raw (const unsigned int level) const {
};
-
template <int dim>
typename DoFDimensionInfo<dim>::cell_iterator
DoFHandler<dim>::end (const unsigned int level) const {
};
-
template <int dim>
typename DoFDimensionInfo<dim>::active_cell_iterator
DoFHandler<dim>::end_active (const unsigned int level) const {
};
-
template <int dim>
typename DoFDimensionInfo<dim>::raw_face_iterator
DoFHandler<dim>::end_raw_face (const unsigned int level) const {
};
-
template <int dim>
typename DoFDimensionInfo<dim>::face_iterator
DoFHandler<dim>::end_face (const unsigned int level) const {
};
-
template <int dim>
typename DoFDimensionInfo<dim>::active_face_iterator
DoFHandler<dim>::end_active_face (const unsigned int level) const {
};
-
template <int dim>
typename DoFDimensionInfo<dim>::raw_line_iterator
DoFHandler<dim>::end_raw_line (const unsigned int level) const {
};
-
template <int dim>
typename DoFDimensionInfo<dim>::line_iterator
DoFHandler<dim>::end_line (const unsigned int level) const {
};
-
template <int dim>
typename DoFDimensionInfo<dim>::active_line_iterator
DoFHandler<dim>::end_active_line (const unsigned int level) const {
};
-
-
template <int dim>
typename DoFDimensionInfo<dim>::raw_quad_iterator
DoFHandler<dim>::end_raw_quad (const unsigned int level) const {
};
-
template <int dim>
typename DoFDimensionInfo<dim>::quad_iterator
DoFHandler<dim>::end_quad (const unsigned int level) const {
};
-
template <int dim>
typename DoFDimensionInfo<dim>::active_quad_iterator
DoFHandler<dim>::end_active_quad (const unsigned int level) const {
};
-
template <int dim>
typename DoFDimensionInfo<dim>::raw_hex_iterator
DoFHandler<dim>::end_raw_hex (const unsigned int level) const {
};
-
template <int dim>
typename DoFDimensionInfo<dim>::hex_iterator
DoFHandler<dim>::end_hex (const unsigned int level) const {
};
-
template <int dim>
typename DoFDimensionInfo<dim>::active_hex_iterator
DoFHandler<dim>::end_active_hex (const unsigned int level) const {
};
-
template <int dim>
typename DoFHandler<dim>::raw_line_iterator
DoFHandler<dim>::last_raw_line (const unsigned int level) const {
};
-
template <int dim>
typename DoFHandler<dim>::line_iterator
DoFHandler<dim>::last_line (const unsigned int level) const {
};
-
template <int dim>
typename DoFHandler<dim>::active_line_iterator
DoFHandler<dim>::last_active_line (const unsigned int level) const {
};
-
template <int dim>
typename DoFHandler<dim>::raw_quad_iterator
DoFHandler<dim>::last_raw_quad (const unsigned int level) const {
};
-
-
template <int dim>
typename DoFHandler<dim>::quad_iterator
DoFHandler<dim>::last_quad (const unsigned int level) const {
};
-
-
template <int dim>
typename DoFHandler<dim>::active_quad_iterator
DoFHandler<dim>::last_active_quad (const unsigned int level) const {
};
-
template <int dim>
typename DoFHandler<dim>::raw_hex_iterator
DoFHandler<dim>::last_raw_hex (const unsigned int level) const {
};
-
-
template <int dim>
typename DoFHandler<dim>::hex_iterator
DoFHandler<dim>::last_hex (const unsigned int level) const {
};
-
-
template <int dim>
typename DoFHandler<dim>::active_hex_iterator
DoFHandler<dim>::last_active_hex (const unsigned int level) const {
};
-
template <int dim>
typename DoFHandler<dim>::raw_line_iterator
DoFHandler<dim>::last_raw_line () const {
};
-
template <int dim>
typename DoFHandler<dim>::raw_quad_iterator
DoFHandler<dim>::last_raw_quad () const {
};
-
template <int dim>
typename DoFHandler<dim>::raw_hex_iterator
DoFHandler<dim>::last_raw_hex () const {
};
-
template <int dim>
typename DoFHandler<dim>::line_iterator
DoFHandler<dim>::last_line () const {
};
-
template <int dim>
typename DoFHandler<dim>::quad_iterator
DoFHandler<dim>::last_quad () const {
};
-
template <int dim>
typename DoFHandler<dim>::hex_iterator
DoFHandler<dim>::last_hex () const {
};
-
template <int dim>
typename DoFHandler<dim>::active_line_iterator
DoFHandler<dim>::last_active_line () const {
};
-
template <int dim>
typename DoFHandler<dim>::active_quad_iterator
DoFHandler<dim>::last_active_quad () const {
};
-
template <int dim>
typename DoFHandler<dim>::active_hex_iterator
DoFHandler<dim>::last_active_hex () const {
};
-
-
-
-
//------------------------------------------------------------------
-
-
-
-
-
#if deal_II_dimension == 1
template <>
};
-
template <>
unsigned int DoFHandler<1>::n_boundary_dofs (const FunctionMap &) const {
Assert (selected_fe != 0, ExcNoFESelected());
#endif
-
-
-
template <int dim>
unsigned int DoFHandler<dim>::n_boundary_dofs () const {
Assert (selected_fe != 0, ExcNoFESelected());
};
-
template <int dim>
unsigned int DoFHandler<dim>::n_boundary_dofs (const FunctionMap &boundary_indicators) const {
Assert (selected_fe != 0, ExcNoFESelected());
};
-
template <int dim>
const Triangulation<dim> & DoFHandler<dim>::get_tria () const {
return *tria;
};
-
template <int dim>
void DoFHandler<dim>::distribute_dofs (const FiniteElement<dim> &ff,
const unsigned int offset)
};
-
template <int dim>
void DoFHandler<dim>::clear () {
// release lock to old fe
};
-
-
#if deal_II_dimension == 1
template <>
for (unsigned int d=0; d<selected_fe->dofs_per_line; ++d)
line->set_dof_index (d, next_free_dof++);
};
-
- // dofs of quad
+
+// dofs of quad
if (selected_fe->dofs_per_quad > 0)
for (unsigned int d=0; d<selected_fe->dofs_per_quad; ++d)
cell->set_dof_index (d, next_free_dof++);
-
- // note that this cell has been processed
+
+// note that this cell has been processed
cell->set_user_flag ();
return next_free_dof;
#endif
-
#if deal_II_dimension == 3
template <>
};
- // dofs of hex
+// dofs of hex
if (selected_fe->dofs_per_hex > 0)
for (unsigned int d=0; d<selected_fe->dofs_per_hex; ++d)
cell->set_dof_index (d, next_free_dof++);
-
- // note that this cell has been processed
+
+// note that this cell has been processed
cell->set_user_flag ();
return next_free_dof;
#endif
-
#if deal_II_dimension == 1
template <>
#endif
-
-
#if deal_II_dimension == 1
template <>
};
-
template <>
unsigned int DoFHandler<1>::max_couplings_between_boundary_dofs () const {
Assert (selected_fe != 0, ExcNoFESelected());
#endif
-
#if deal_II_dimension == 2
template <>
};
-
template <>
unsigned int DoFHandler<2>::max_couplings_between_boundary_dofs () const {
Assert (selected_fe != 0, ExcNoFESelected());
9*4*7*3*selected_fe->dofs_per_quad +
27*selected_fe->dofs_per_hex);
-
- Assert (false, ExcNotImplemented());
+
+Assert (false, ExcNotImplemented());
return 0;
};
-
template <>
unsigned int DoFHandler<3>::max_couplings_between_boundary_dofs () const {
Assert (selected_fe != 0, ExcNoFESelected());
};
-
#endif
-
-
-
#if deal_II_dimension == 1
template <>
};
-
template <>
void DoFHandler<1>::map_dof_to_boundary_indices (const FunctionMap &,
vector<unsigned int> &) const {
#endif
-
template <int dim>
void DoFHandler<dim>::map_dof_to_boundary_indices (vector<unsigned int> &mapping) const
{
};
-
template <int dim>
void DoFHandler<dim>::map_dof_to_boundary_indices (const FunctionMap &boundary_indicators,
vector<unsigned int> &mapping) const
};
-
#if deal_II_dimension == 1
template <>
};
-
/*-------------- Explicit Instantiations -------------------------------*/
template class DoFHandler<deal_II_dimension>;
-/* $Id$ */
+//---------------------------- dof_renumbering.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- dof_renumbering.cc ---------------------------
+
#include <lac/sparsity_pattern.h>
#include <dofs/dof_accessor.h>
#include <algorithm>
-
template <int dim>
void DoFRenumbering::Cuthill_McKee (DoFHandler<dim> &dof_handler,
const bool reversed_numbering,
// initialize the first dof
last_round_dofs.push_back (starting_point);
};
-
- // store next free dof index
+
+// store next free dof index
unsigned int next_free_number = 0;
// enumerate the first round dofs
if (all_dofs_renumbered)
// end loop if possible
continue;
-
- // store for each coordination
+
+// store for each coordination
// number the dofs with these
// coordination number
multimap<unsigned int, int> dofs_by_coordination;
};
-
-
template <int dim>
void DoFRenumbering::Cuthill_McKee (MGDoFHandler<dim> &dof_handler,
const unsigned int level,
// initialize the first dof
last_round_dofs.push_back (starting_point);
};
-
- // store next free dof index
+
+// store next free dof index
unsigned int next_free_number = 0;
// enumerate the first round dofs
if (all_dofs_renumbered)
// end loop if possible
continue;
-
- // store for each coordination
+
+// store for each coordination
// number the dofs with these
// coordination number
multimap<unsigned int, int> dofs_by_coordination;
};
-
template <int dim>
void DoFRenumbering::component_wise (DoFHandler<dim> &dof_handler,
const vector<unsigned int> &component_order_arg)
dof_handler.renumber_dofs (new_indices);
};
-
-
-
-
// explicit instantiations
template
-// $Id$
+//---------------------------- dof_tools.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- dof_tools.cc ---------------------------
#include <grid/tria.h>
dof_mask[i][j] = mask
[dof.get_fe().system_to_component_index(i).first]
[dof.get_fe().system_to_component_index(j).first];
-
-
- vector<unsigned int> dofs_on_this_cell(dofs_per_cell);
+
+
+vector<unsigned int> dofs_on_this_cell(dofs_per_cell);
DoFHandler<dim>::active_cell_iterator cell = dof.begin_active(),
endc = dof.end();
for (; cell!=endc; ++cell)
};
-
template <>
void
DoFTools::make_boundary_sparsity_pattern (const DoFHandler<1>&,
#endif
-
template <int dim>
void
DoFTools::make_boundary_sparsity_pattern (const DoFHandler<dim>& dof,
};
-
template <int dim>
void DoFTools::make_boundary_sparsity_pattern (const DoFHandler<dim>& dof,
const DoFHandler<dim>::FunctionMap &boundary_indicators,
};
-
-
//TODO: Check this function for potential of optimization. (G)
template<int dim>
}
-
#if deal_II_dimension == 1
template <>
#endif
-
#if deal_II_dimension == 2
template <>
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
if (cell->face(face)->has_children())
cell->face(face)->set_user_flag();
-
-
-
- // loop over all lines; only on lines
+
+// loop over all lines; only on lines
// there can be constraints.
for (line = dof_handler.begin_line(); line != endl; ++line)
// if dofs on this line are subject
#endif
-
#if deal_II_dimension == 3
template <>
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
if (cell->face(face)->has_children())
cell->face(face)->set_user_flag();
-
-
- // loop over all faces; only on faces
+
+
+// loop over all faces; only on faces
// there can be constraints.
for (face=dof_handler.begin_face(); face != endf; ++face)
// if dofs on this line are subject
#endif
-
-
template <int dim, typename Number>
void DoFTools::distribute_cell_to_dof_vector (const DoFHandler<dim> &dof_handler,
const Vector<Number> &cell_data,
};
-
template<int dim>
void
DoFTools::extract_dofs(const DoFHandler<dim> &dof,
}
-
template<int dim>
void
DoFTools::extract_level_dofs(const unsigned int level,
}
-
// explicit instantiations
#if deal_II_dimension > 1
template void
Vector<double> &dof_data) const;
-
template void DoFTools::extract_dofs(const DoFHandler<deal_II_dimension>& dof,
const vector<bool>& local_select,
vector<bool>& selected_dofs);
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+//---------------------------- fe.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- fe.cc ---------------------------
#include <fe/fe.h>
#include <grid/tria_boundary.h>
-
/*------------------------------- FiniteElementData ----------------------*/
template <int dim>
};
-
-
template <int dim>
FiniteElementData<dim>::FiniteElementData (const unsigned int dofs_per_vertex,
const unsigned int dofs_per_line,
};
-
template <int dim>
FiniteElementData<dim>::FiniteElementData (const unsigned int dofs_per_vertex,
const unsigned int dofs_per_line,
};
-
template <int dim>
FiniteElementData<dim>::FiniteElementData (const unsigned int dofs_per_vertex,
const unsigned int dofs_per_line,
};
-
template <int dim>
FiniteElementData<dim>::~FiniteElementData ()
{};
-
-
template<int dim>
bool FiniteElementData<dim>::operator== (const FiniteElementData<dim> &f) const
{
};
-
/*------------------------------- FiniteElementBase ----------------------*/
-
template <int dim>
FiniteElementBase<dim>::FiniteElementBase (const FiniteElementData<dim> &fe_data,
const vector<bool> &restriction_is_additive_flags) :
};
-
template <int dim>
const FullMatrix<double> &
FiniteElementBase<dim>::restrict (const unsigned int child) const
};
-
template <int dim>
const FullMatrix<double> &
FiniteElementBase<dim>::prolongate (const unsigned int child) const
};
-
template <int dim>
const FullMatrix<double> &
FiniteElementBase<dim>::constraints () const
};
-
template <int dim>
bool FiniteElementBase<dim>::operator == (const FiniteElementBase<dim> &f) const
{
};
-
/*------------------------------- FiniteElement ----------------------*/
ExcWrongFieldDimension(support_points.size(), dofs_per_cell));
- // local mesh width
+// local mesh width
const double h=(cell->vertex(1)(0) - cell->vertex(0)(0));
for (unsigned int i=0; i<q_points.size(); ++i)
};
-
template <>
void FiniteElement<1>::fill_fe_face_values (const DoFHandler<1>::cell_iterator &,
const unsigned int ,
};
-
template <>
void FiniteElement<1>::get_unit_support_points (vector<Point<1> > &support_points) const {
Assert (support_points.size() == dofs_per_cell,
};
-
template <>
void FiniteElement<1>::get_support_points (const DoFHandler<1>::cell_iterator &cell,
vector<Point<1> > &support_points) const {
#endif
-
template <int dim>
void FiniteElement<dim>::fill_fe_values (const DoFHandler<dim>::cell_iterator &,
const vector<Point<dim> > &,
};
-
template <int dim>
void FiniteElement<dim>::fill_fe_face_values (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
};
-
-
template <int dim>
void FiniteElement<dim>::fill_fe_subface_values (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
};
-
template <int dim>
void
FiniteElement<dim>::get_unit_support_points (vector<Point<dim> > &) const
};
-
template <int dim>
void
FiniteElement<dim>::get_support_points (const DoFHandler<dim>::cell_iterator &,
template class FiniteElement<deal_II_dimension>;
-
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+//---------------------------- fe_lib.criss_cross.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- fe_lib.criss_cross.cc ---------------------------
#include <fe/fe_lib.criss_cross.h>
#include <cmath>
-
/*-----------------------------------2d------------------------------------
Maple script to automate some of the error-prone computations on
this strange sort of element.
od:
od:
-
- # these are the basis functions differentiated with respect to
+
+# these are the basis functions differentiated with respect to
# xi and eta. we need them for the computation of the jacobi
# matrix, since we can't just differentiate a function.
phi_xi[0] := proc(x,y) if(y<1-x) then -1; else 0; fi; end:
end:
- # Now for the mass matrix: we divide the entire cell into four
+# Now for the mass matrix: we divide the entire cell into four
# sectors:
#
# *-------*
-----------------------------------------------------------------------------*/
-
-
-
-
-
#if deal_II_dimension == 1
};
-
template <>
double FECrissCross<1>::shape_value (const unsigned int, const Point<1> &) const {
Assert (false, ExcNotUseful());
};
-
template <>
Tensor<1,1> FECrissCross<1>::shape_grad (const unsigned int, const Point<1> &) const {
Assert (false, ExcNotUseful());
};
-
template <>
Tensor<2,1> FECrissCross<1>::shape_grad_grad (const unsigned int, const Point<1> &) const {
Assert (false, ExcNotUseful());
};
-
template <>
void FECrissCross<1>::get_unit_support_points (vector<Point<1> >&) const {
Assert (false, ExcNotUseful());
};
-
template <>
void FECrissCross<1>::get_support_points (const DoFHandler<1>::cell_iterator &,
vector<Point<1> > &) const {
};
-
template <>
void FECrissCross<1>::get_face_support_points (const DoFHandler<1>::face_iterator &,
vector<Point<1> > &) const {
};
-
template <>
void FECrissCross<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &,
FullMatrix<double> &) const {
};
-
template <>
double FECrissCross<1>::shape_value_transform (const unsigned int,
const Point<1> &) const {
};
-
template <>
Tensor<1,1> FECrissCross<1>::shape_grad_transform (const unsigned int,
const Point<1> &) const {
};
-
template <>
void FECrissCross<1>::get_face_jacobians (const DoFHandler<1>::face_iterator &,
const vector<Point<0> > &,
};
-
template <>
void FECrissCross<1>::get_subface_jacobians (const DoFHandler<1>::face_iterator &,
const unsigned int,
};
-
template <>
void FECrissCross<1>::get_normal_vectors (const DoFHandler<1>::cell_iterator &,
const unsigned int,
};
-
template <>
void FECrissCross<1>::get_normal_vectors (const DoFHandler<1>::cell_iterator &,
const unsigned int,
};
-
template <>
void FECrissCross<1>::fill_fe_values (const DoFHandler<1>::cell_iterator &,
const vector<Point<1> > &,
#endif
-
-
-
-
#if deal_II_dimension == 2
};
-
-
template <>
inline
double FECrissCross<2>::shape_value (const unsigned int i,
};
-
template <>
inline
Tensor<1,2> FECrissCross<2>::shape_grad (const unsigned int i, const Point<2> &p) const
};
-
template <>
void FECrissCross<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
Assert(unit_points.size()==dofs_per_cell,
};
-
template <>
void FECrissCross<2>::get_support_points (const DoFHandler<2>::cell_iterator &cell,
vector<Point<2> > &support_points) const {
};
-
template <>
void FECrissCross<2>::get_face_support_points (const DoFHandler<2>::face_iterator &face,
vector<Point<2> > &support_points) const {
};
-
template <>
void FECrissCross<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cell,
FullMatrix<double> &mass_matrix) const {
};
-
template <>
inline
double FECrissCross<2>::shape_value_transform (const unsigned int i,
};
-
template <>
Tensor<1,2> FECrissCross<2>::shape_grad_transform (const unsigned int i,
const Point<2> &p) const {
};
-
template <>
void FECrissCross<2>::get_face_jacobians (const DoFHandler<2>::face_iterator &face,
const vector<Point<1> > &unit_points,
};
-
template <>
void FECrissCross<2>::get_subface_jacobians (const DoFHandler<2>::face_iterator &face,
const unsigned int,
};
-
template <>
void FECrissCross<2>::get_normal_vectors (const DoFHandler<2>::cell_iterator &cell,
const unsigned int face_no,
};
-
template <>
void FECrissCross<2>::get_normal_vectors (const DoFHandler<2>::cell_iterator &cell,
const unsigned int face_no,
};
-
template <int dim>
void FECrissCross<dim>::fill_fe_values (const DoFHandler<dim>::cell_iterator &cell,
const vector<Point<dim> > &unit_points,
Assert (support_points.size() == dofs_per_cell,
ExcWrongFieldDimension(support_points.size(), dofs_per_cell));
-
- unsigned int n_points=unit_points.size();
+
+unsigned int n_points=unit_points.size();
// we need the support points in any
// way, wanted or not by the user
for (unsigned int l=0; l<n_points; ++l)
q_points[l] += support_points[j] * shape_values_transform(j, l);
};
-
+
/* jacobi matrices: compute d(x)/d(xi) and invert this
Let M(l) be the inverse of J at the quadrature point l, then
};
- if (compute_jacobians_grad)
+if (compute_jacobians_grad)
switch (dim)
{
case 1:
#endif
-
#if deal_II_dimension == 3
// provide dummy implementations of the functions above. the reason is
};
-
template <>
double
FECrissCross<3>::shape_value (const unsigned int,
};
-
template <>
Tensor<1,3>
FECrissCross<3>::shape_grad (const unsigned int,
};
-
template <>
Tensor<2,3>
FECrissCross<3>::shape_grad_grad (const unsigned int,
};
-
template <>
void
FECrissCross<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
};
-
template <>
void FECrissCross<3>::get_unit_support_points (vector<Point<3> > &) const
{
};
-
template <>
void FECrissCross<3>::get_support_points (const DoFHandler<3>::cell_iterator &,
vector<Point<3> > &) const
};
-
template <>
void FECrissCross<3>::get_face_support_points (const DoFHandler<3>::face_iterator &,
vector<Point<3> > &) const
};
-
-
template <>
void FECrissCross<3>::get_face_jacobians (const DoFHandler<3>::face_iterator &,
const vector<Point<2> > &,
};
-
template <>
void FECrissCross<3>::get_subface_jacobians (const DoFHandler<3>::face_iterator &,
const unsigned int,
};
-
template <>
void FECrissCross<3>::get_normal_vectors (const DoFHandler<3>::cell_iterator &,
const unsigned int,
};
-
template <>
void FECrissCross<3>::fill_fe_values (const DoFHandler<3>::cell_iterator &,
const vector<Point<3> > &,
};
-
template <>
double FECrissCross<3>::shape_value_transform (const unsigned int,
const Point<3> &) const
};
-
template <>
Tensor<1,3> FECrissCross<3>::shape_grad_transform (const unsigned int,
const Point<3> &) const
#endif // deal_II_dimension == 3
-
-
/*--------------------------- QCrissCross* ------------------------------------*/
#endif
-
#if deal_II_dimension == 2
template <>
#endif
-
// explicit instantiations
template class FECrissCross<deal_II_dimension>;
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+//---------------------------- fe_lib.cubic.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- fe_lib.cubic.cc ---------------------------
#include <fe/fe_lib.lagrange.h>
#include <algorithm>
-
-
// declare explicit specializations before use:
template <> void FEQ3<deal_II_dimension>::initialize_matrices ();
-
-
#if deal_II_dimension == 1
template <>
};
-
template <>
FEQ3<1>::FEQ3 (const int) :
FEQ1Mapping<1> (0, 4, 0, 0, 1,
};
-
template <>
void FEQ3<1>::initialize_matrices () {
};
-
template <>
double
FEQ3<1>::shape_value (const unsigned int i,
};
-
template <>
Tensor<1,1>
FEQ3<1>::shape_grad (const unsigned int i,
};
-
template <>
Tensor<2,1>
FEQ3<1>::shape_grad_grad (const unsigned int i,
};
-
template <>
void FEQ3<1>::get_unit_support_points (vector<Point<1> > &unit_points) const {
FiniteElement<1>::get_unit_support_points (unit_points);
};
-
template <>
void FEQ3<1>::get_support_points (const DoFHandler<1>::cell_iterator &cell,
vector<Point<1> > &support_points) const {
};
-
template <>
void FEQ3<1>::get_face_support_points (const DoFHandler<1>::face_iterator &,
vector<Point<1> > &) const {
};
-
template <>
void FEQ3<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
#endif
-
-
#if deal_II_dimension == 2
template <>
};
-
template <>
FEQ3<2>::FEQ3 (const int) :
FEQ1Mapping<2> (0, 0, 16, 0, 1,
};
-
template <>
void FEQ3<2>::initialize_matrices () {
prolongation[0](0,0) = 1.0;
};
-
template <>
double
FEQ3<2>::shape_value (const unsigned int i,
};
-
template <>
Tensor<1,2>
FEQ3<2>::shape_grad (const unsigned int i,
};
-
template <>
Tensor<2,2>
FEQ3<2>::shape_grad_grad (const unsigned int i,
};
-
template <>
void FEQ3<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
};
-
template <>
void FEQ3<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
Assert (unit_points.size() == dofs_per_cell,
};
-
template <>
void FEQ3<2>::get_support_points (const DoFHandler<2>::cell_iterator &cell,
vector<Point<2> > &support_points) const {
};
-
template <>
void FEQ3<2>::get_face_support_points (const DoFHandler<2>::face_iterator &face,
vector<Point<2> > &support_points) const {
};
-
#endif
-
-
#if deal_II_dimension == 3
// ignore the following, since it doesn't compile properly. it simply
};
-
template <>
FEQ3<3>::FEQ3 (const int) :
FEQ1Mapping<3> (0, 0, 0, 64, 1,
};
-
template <>
void FEQ3<3>::initialize_matrices ()
{
prolongation[7](63,62) = 225.0/256.0;
- restriction[0](0,0) = 1.0;
+restriction[0](0,0) = 1.0;
restriction[0](8,9) = 1.0;
restriction[0](14,15) = 1.0;
restriction[0](24,25) = 1.0;
};
-
template <>
double
FEQ3<3>::shape_value (const unsigned int i,
};
-
template <>
Tensor<1,3>
FEQ3<3>::shape_grad (const unsigned int i,
};
-
template <>
Tensor<2,3>
FEQ3<3>::shape_grad_grad (const unsigned int i,
};
-
template <>
void
FEQ3<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
};
-
template <>
void FEQ3<3>::get_unit_support_points (vector<Point<3> > &unit_points) const
{
};
-
template <>
void FEQ3<3>::get_support_points (const typename DoFHandler<3>::cell_iterator &cell,
vector<Point<3> > &support_points) const
};
-
template <>
void FEQ3<3>::get_face_support_points (const typename DoFHandler<3>::face_iterator &face,
vector<Point<3> > &support_points) const
};
-
#else // 0
// provide dummy implementations of the functions above. for the
};
-
template <>
FEQ3<3>::FEQ3 (const int) :
FEQ1Mapping<3> (0, 0, 0, 64, 1,
};
-
template <>
void FEQ3<3>::initialize_matrices ()
{
};
-
template <>
double
FEQ3<3>::shape_value (const unsigned int,
};
-
template <>
Tensor<1,3>
FEQ3<3>::shape_grad (const unsigned int,
};
-
template <>
Tensor<2,3>
FEQ3<3>::shape_grad_grad (const unsigned int,
};
-
template <>
void
FEQ3<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
};
-
template <>
void FEQ3<3>::get_unit_support_points (vector<Point<3> > &) const
{
};
-
template <>
void FEQ3<3>::get_support_points (const DoFHandler<3>::cell_iterator &,
vector<Point<3> > &) const
};
-
template <>
void FEQ3<3>::get_face_support_points (const DoFHandler<3>::face_iterator &,
vector<Point<3> > &) const
};
-
#endif // 0
#endif // deal_II_dimension == 3
-/* $Id$ */
-/* Ralf Hartmann, University of Heidelberg, Dez 98 */
+//---------------------------- fe_lib.dg.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- fe_lib.dg.cc ---------------------------
-#include<fe/fe_lib.dg.h>
+#include<fe/fe_lib.dg.h>
template<int dim>
FEQ4<dim>(1) {};
-
template <int dim>
void
FEDG_Q1<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
};
-
-
// explicit instantiations
template class FEDG_Q1<deal_II_dimension>;
template class FEDG_Q2<deal_II_dimension>;
-/* Ralf Hartmann, University of Heidelberg, Dez 98 */
+//---------------------------- fe_lib.dg.constant.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- fe_lib.dg.constant.cc ---------------------------
#include <fe/fe_lib.dg.h>
#include <algorithm>
-
-
-
template <int dim>
FEDG_Q0<dim>::FEDG_Q0 () :
FEQ1Mapping<dim> (0,
};
-
#if deal_II_dimension == 1
};
-
template <int dim>
inline
Tensor<1,dim>
};
-
template <int dim>
inline
Tensor<2,dim>
};
-
template <int dim>
void FEDG_Q0<dim>::get_local_mass_matrix (const DoFHandler<dim>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
};
-
template <int dim>
void
FEDG_Q0<dim>::get_unit_support_points (vector<Point<dim> > &unit_points) const {
for (unsigned int d=0; d<dim; ++d)
unit_points[0](d) = 0.5;
};
-
+
template <int dim>
void
};
-
// explicit instantiations
template class FEDG_Q0<deal_II_dimension>;
-
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+//---------------------------- fe_lib.linear.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- fe_lib.linear.cc ---------------------------
#include <fe/fe_lib.lagrange.h>
#include <algorithm>
-
-
// declare explicit specializations before use:
template <> void FEQ1<deal_II_dimension>::initialize_matrices ();
-
-
#if deal_II_dimension == 1
template <>
};
-
-
template <>
void FEQ1<1>::initialize_matrices () {
// for restriction and prolongation matrices:
};
-
template <>
double
FEQ1<1>::shape_value(const unsigned int i,
}
-
template <>
inline
Tensor<1,1>
};
-
template <>
inline
Tensor<2,1>
};
-
template <>
void FEQ1<1>::get_unit_support_points (vector<Point<1> > &support_points) const {
FiniteElement<1>::get_unit_support_points (support_points);
};
-
template <>
void FEQ1<1>::get_support_points (const DoFHandler<1>::cell_iterator &cell,
vector<Point<1> > &support_points) const {
};
-
template <>
void FEQ1<1>::get_face_support_points (const DoFHandler<1>::face_iterator &,
vector<Point<1> > &) const {
};
-
template <>
void FEQ1<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
#endif
-
-
#if deal_II_dimension == 2
template <>
};
-
template <>
FEQ1<2>::FEQ1 (const int) :
FEQ1Mapping<2> (0, 0, 4, 0, 1,
};
-
template <>
void FEQ1<2>::initialize_matrices () {
restriction[0](0,0) = 1.0;
};
-
-
template <>
inline
double
};
-
template <>
inline
Tensor<1,2>
};
-
template <>
inline
Tensor<2,2>
};
-
template <>
void FEQ1<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
};
-
template <>
void FEQ1<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
Assert (unit_points.size() == dofs_per_cell,
unit_points[2] = Point<2> (1,1);
unit_points[3] = Point<2> (0,1);
};
-
+
#endif
};
-
template <>
FEQ1<3>::FEQ1 (const int) :
FEQ1Mapping<3> (0, 0, 0, 8, 1,
};
-
template <>
void FEQ1<3>::initialize_matrices () {
restriction[0](0,0) = 1.0;
};
-
-
template <>
inline
double
};
-
template <>
inline
Tensor<1,3>
};
-
template <>
inline
Tensor<2,3>
};
-
template <>
void FEQ1<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
FullMatrix<double> &local_mass_matrix) const {
};
-
template <>
void FEQ1<3>::get_unit_support_points (vector<Point<3> > &unit_points) const {
Assert (unit_points.size() == dofs_per_cell,
unit_points[6] = Point<3> (1,1,1);
unit_points[7] = Point<3> (0,1,1);
};
-
-#endif
+#endif
template <int dim>
};
-
template <int dim>
void
FEQ1<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &face,
};
-
-
// explicit instantiations
template class FEQ1<deal_II_dimension>;
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+//---------------------------- fe_lib.quadratic.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- fe_lib.quadratic.cc ---------------------------
#include <fe/fe_lib.lagrange.h>
#include <algorithm>
-
// declare explicit specializations before use:
template <> void FEQ2<deal_II_dimension>::initialize_matrices ();
-
#if deal_II_dimension == 1
template <>
};
-
template <>
FEQ2<1>::FEQ2 (const int) :
FEQ1Mapping<1> (0, 3, 0, 0, 1,
};
-
template <>
void FEQ2<1>::initialize_matrices () {
/*
od;
-
- # to get the restriction (interpolation) matrices, evaluate
+# to get the restriction (interpolation) matrices, evaluate
# the basis functions on the child cells at the global
# interpolation points
};
-
template <>
double
FEQ2<1>::shape_value(const unsigned int i,
};
-
template <>
Tensor<1,1>
FEQ2<1>::shape_grad(const unsigned int i,
};
-
template <>
Tensor<2,1>
FEQ2<1>::shape_grad_grad (const unsigned int i,
};
-
template <>
void FEQ2<1>::get_unit_support_points (vector<Point<1> > &unit_points) const {
FiniteElement<1>::get_unit_support_points (unit_points);
};
-
template <>
void FEQ2<1>::get_support_points (const DoFHandler<1>::cell_iterator &cell,
vector<Point<1> > &support_points) const {
};
-
template <>
void FEQ2<1>::get_face_support_points (const DoFHandler<1>::face_iterator &,
vector<Point<1> > &) const {
};
-
template <>
void FEQ2<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
};
-
template <>
FEQ2<2>::FEQ2 (const int) :
FEQ1Mapping<2> (0, 0, 9, 0, 1,
};
-
template <>
void FEQ2<2>::initialize_matrices () {
/*
};
-
template <>
double
FEQ2<2>::shape_value (const unsigned int i,
};
-
template <>
Tensor<1,2>
FEQ2<2>::shape_grad (const unsigned int i,
};
-
template <>
Tensor<2,2>
FEQ2<2>::shape_grad_grad (const unsigned int i,
};
-
template <>
void FEQ2<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
};
-
template <>
void FEQ2<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
Assert (unit_points.size() == dofs_per_cell,
unit_points[8] = Point<2> (0.5,0.5);
};
-
template <>
void FEQ2<2>::get_support_points (const DoFHandler<2>::cell_iterator &cell,
};
-
template <>
void FEQ2<2>::get_face_support_points (const DoFHandler<2>::face_iterator &face,
vector<Point<2> > &support_points) const {
#endif
-
#if deal_II_dimension == 3
template <>
};
-
template <>
FEQ2<3>::FEQ2 (const int) :
FEQ1Mapping<3> (0, 0, 0, 27, 1,
};
-
template <>
void FEQ2<3>::initialize_matrices () {
prolongation[0](0,0) = 1.0;
};
-
template <>
double
FEQ2<3>::shape_value (const unsigned int i,
};
-
template <>
Tensor<1,3>
FEQ2<3>::shape_grad (const unsigned int i,
};
-
template <>
Tensor<2,3>
FEQ2<3>::shape_grad_grad (const unsigned int i,
};
-
template <>
void FEQ2<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
FullMatrix<double> &local_mass_matrix) const {
};
-
template <>
void FEQ2<3>::get_unit_support_points (vector<Point<3> > &unit_points) const {
Assert (unit_points.size() == dofs_per_cell,
unit_points[26] = Point<3>(1/2, 1/2, 1/2);
};
-
template <>
void FEQ2<3>::get_support_points (const DoFHandler<3>::cell_iterator &cell,
};
-
template <>
void FEQ2<3>::get_face_support_points (const DoFHandler<3>::face_iterator &face,
vector<Point<3> > &support_points) const {
#endif
-
-
-
// explicit instantiations
template class FEQ2<deal_II_dimension>;
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+//---------------------------- fe_lib.quartic.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- fe_lib.quartic.cc ---------------------------
#include <fe/fe_lib.lagrange.h>
#include <algorithm>
-
// declare explicit specializations before use:
template <> void FEQ4<deal_II_dimension>::initialize_matrices ();
-
#if deal_II_dimension == 1
template <>
};
-
-
template <>
void FEQ4<1>::initialize_matrices () {
prolongation[0](0,0) = 1.0;
};
-
template <>
double
FEQ4<1>::shape_value(const unsigned int i,
};
-
template <>
Tensor<1,1>
FEQ4<1>::shape_grad(const unsigned int i,
};
-
template <>
Tensor<2,1>
FEQ4<1>::shape_grad_grad (const unsigned int i,
};
-
template <>
void FEQ4<1>::get_unit_support_points (vector<Point<1> > &unit_points) const {
FiniteElement<1>::get_unit_support_points (unit_points);
};
-
template <>
void FEQ4<1>::get_support_points (const DoFHandler<1>::cell_iterator &cell,
vector<Point<1> > &support_points) const {
};
-
template <>
void FEQ4<1>::get_face_support_points (const DoFHandler<1>::face_iterator &,
vector<Point<1> > &) const {
};
-
template <>
void FEQ4<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
#endif
-
-
#if deal_II_dimension == 2
template <>
};
-
template <>
FEQ4<2>::FEQ4 (const int) :
FEQ1Mapping<2> (0, 0, 25, 0, 1,
};
-
template <>
void FEQ4<2>::initialize_matrices () {
prolongation[0](0,0) = 1.0;
};
-
template <>
Tensor<1,2>
FEQ4<2>::shape_grad (const unsigned int i,
};
-
template <>
Tensor<2,2>
FEQ4<2>::shape_grad_grad (const unsigned int i,
};
-
template <>
void FEQ4<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
};
-
template <>
void FEQ4<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
Assert (unit_points.size() == dofs_per_cell,
};
-
template <>
void FEQ4<2>::get_support_points (const DoFHandler<2>::cell_iterator &cell,
vector<Point<2> > &support_points) const {
};
-
template <>
void FEQ4<2>::get_face_support_points (const DoFHandler<2>::face_iterator &face,
vector<Point<2> > &support_points) const {
};
-
#endif
-
-
#if deal_II_dimension == 3
// provide dummy implementations of the functions above. the reason is
};
-
template <>
FEQ4<3>::FEQ4 (const int) :
FEQ1Mapping<3> (0, 0, 0, 64, 1,
};
-
template <>
void FEQ4<3>::initialize_matrices ()
{
};
-
template <>
double
FEQ4<3>::shape_value (const unsigned int,
};
-
template <>
Tensor<1,3>
FEQ4<3>::shape_grad (const unsigned int,
};
-
template <>
Tensor<2,3>
FEQ4<3>::shape_grad_grad (const unsigned int,
};
-
template <>
void
FEQ4<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
};
-
template <>
void FEQ4<3>::get_unit_support_points (vector<Point<3> > &) const
{
};
-
template <>
void FEQ4<3>::get_support_points (const DoFHandler<3>::cell_iterator &,
vector<Point<3> > &) const
};
-
template <>
void FEQ4<3>::get_face_support_points (const DoFHandler<3>::face_iterator &,
vector<Point<3> > &) const
};
-
#endif // deal_II_dimension == 3
-
-
-
-
-
// explicit instantiations
template class FEQ4<deal_II_dimension>;
-/* $Id$ */
-/* Copyright W. Bangerth, G. Kanschat University of Heidelberg, 1999 */
+//---------------------------- fe_system.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- fe_system.cc ---------------------------
#include <fe/fe_system.h>
-
-
-
template <int dim>
FESystem<dim>::~FESystem ()
{
}
-
template <int dim>
void FESystem<dim>::build_interface_constraints ()
{
};
-
-
-
template <int dim>
void FESystem<dim>::initialize ()
{
};
- // now set up the interface constraints.
+// now set up the interface constraints.
// this is kind'o hairy, so don't try
// to do it dimension independent
build_interface_constraints ();
};
-
-
#if deal_II_dimension == 1
template <>
return tmp;
};
-
-
template <int dim>
double
};
-
template <int dim>
Tensor<1,dim>
FESystem<dim>::shape_grad (const unsigned int i,
};
-
template <int dim>
Tensor<2,dim>
FESystem<dim>::shape_grad_grad (const unsigned int i,
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
- pair<unsigned,unsigned> comp = system_to_component_index(i);
+pair<unsigned,unsigned> comp = system_to_component_index(i);
return base_element(component_to_base_table[comp.first])
.shape_grad_grad(comp.second, p);
};
-
template <int dim>
void FESystem<dim>::get_unit_support_points (
vector<Point<dim> > &unit_support_points) const
};
-
template <int dim>
void FESystem<dim>::get_support_points (const DoFHandler<dim>::cell_iterator &cell,
vector<Point<dim> > &support_points) const
};
-
template <int dim>
void FESystem<dim>::get_face_support_points (const DoFHandler<dim>::face_iterator & face,
vector<Point<dim> > & support_points) const
}
-
template <int dim>
void FESystem<dim>::get_local_mass_matrix (const DoFHandler<dim>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const
};
-
template <int dim>
double FESystem<dim>::shape_value_transform (const unsigned int i,
const Point<dim> &p) const
};
-
template <int dim>
void FESystem<dim>::get_face_jacobians (const DoFHandler<dim>::face_iterator &face,
const vector<Point<dim-1> > &unit_points,
};
-
template <int dim>
void FESystem<dim>::get_subface_jacobians (const DoFHandler<dim>::face_iterator &face,
const unsigned int subface_no,
};
-
-
template <int dim>
void FESystem<dim>::get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
};
-
template <int dim>
void FESystem<dim>::get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
}
}
-
// explicit instantiations
template class FESystem<deal_II_dimension>;
-
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+//---------------------------- fe_values.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- fe_values.cc ---------------------------
#include <fe/fe.h>
{};
-
-
template <int dim>
double FEValuesBase<dim>::shape_value (const unsigned int i,
const unsigned int j) const {
};
-
template <int dim>
void FEValuesBase<dim>::get_function_values (const Vector<double> &fe_function,
vector<double> &values) const
};
-
template <int dim>
const Tensor<1,dim> &
FEValuesBase<dim>::shape_grad (const unsigned int i,
};
-
template <int dim>
void FEValuesBase<dim>::get_function_grads (const Vector<double> &fe_function,
vector<Tensor<1,dim> > &gradients) const
};
-
template <int dim>
void FEValuesBase<dim>::get_function_2nd_derivatives (const Vector<double> &fe_function,
vector<Tensor<2,dim> > &second_derivatives) const
};
-
template <int dim>
const Point<dim> &
FEValuesBase<dim>::quadrature_point (const unsigned int i) const
};
-
template <int dim>
const Point<dim> &
FEValuesBase<dim>::support_point (const unsigned int i) const
};
-
template <int dim>
double FEValuesBase<dim>::JxW (const unsigned int i) const
{
};
-
-
/*------------------------------- FEValues -------------------------------*/
template <int dim>
};
-
-
-
-
-
template <int dim>
void FEValues<dim>::reinit (const typename DoFHandler<dim>::cell_iterator &cell) {
present_cell = cell;
contract (tmp2, tmp1, 1, jacobi_matrices[j], 1);
- // second part:
+// second part:
// tmp1 := (d_k J_lj) (d_l phi)
contract (tmp1, jacobi_matrices_grad[j], 2, unit_shape_gradients[i][j]);
// tmp1_kj J_ki
// add up first contribution
shape_2nd_derivatives[i][j] += tmp2;
};
-
-
- // compute Jacobi determinants in
+
+
+// compute Jacobi determinants in
// quadrature points.
// refer to the general doc for
// why we take the inverse of the
};
-
-
-
/*------------------------------- FEFaceValuesBase --------------------------*/
{};
-
template <int dim>
const Point<dim> &
FEFaceValuesBase<dim>::normal_vector (const unsigned int i) const {
};
-
-
-
-
/*------------------------------- FEFaceValues -------------------------------*/
};
-
template <int dim>
void FEFaceValues<dim>::reinit (const typename DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no) {
};
- Tensor<2,dim> tmp1, tmp2;
+Tensor<2,dim> tmp1, tmp2;
if (update_flags & update_second_derivatives)
for (unsigned int i=0; i<fe->dofs_per_cell; ++i)
for (unsigned int j=0; j<n_quadrature_points; ++j)
contract (tmp2, tmp1, 1, jacobi_matrices[j], 1);
- // second part:
+// second part:
// tmp1 := (d_k J_lj) (d_l phi)
contract (tmp1,
jacobi_matrices_grad[j], 2,
// add up first contribution
shape_2nd_derivatives[i][j] += tmp2;
};
-
-
- // compute Jacobi determinants in
+
+
+// compute Jacobi determinants in
// quadrature points.
// refer to the general doc for
// why we take the inverse of the
};
-
-
-
-
/*------------------------------- FESubFaceValues -------------------------------*/
};
-
template <int dim>
void FESubfaceValues<dim>::reinit (const typename DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
contract (tmp2, tmp1, 1, jacobi_matrices[j], 1);
- // second part:
+// second part:
// tmp1 := (d_k J_lj) (d_l phi)
contract (tmp1,
jacobi_matrices_grad[j], 2,
// add up first contribution
shape_2nd_derivatives[i][j] += tmp2;
};
-
-
- // compute Jacobi determinants in
+
+
+// compute Jacobi determinants in
// quadrature points.
// refer to the general doc for
// why we take the inverse of the
};
-
-
-
/*------------------------------- Explicit Instantiations -------------*/
template class FEValuesBase<deal_II_dimension>;
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+//---------------------------- q1_mapping.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- q1_mapping.cc ---------------------------
-// moved from file fe_linear_mapping.cc
#include <fe/q1_mapping.h>
#include <base/quadrature.h>
#include <cmath>
-
/*---------------------------- FEQ1Mapping ----------------------------------*/
-
#if deal_II_dimension == 1
template <>
};
-
template <>
inline
double
};
-
template <>
inline
Tensor<1,1>
};
-
template <>
void FEQ1Mapping<1>::get_face_jacobians (const DoFHandler<1>::face_iterator &,
const vector<Point<0> > &,
};
-
template <>
void FEQ1Mapping<1>::get_subface_jacobians (const DoFHandler<1>::face_iterator &,
const unsigned int ,
};
-
template <>
void FEQ1Mapping<1>::get_normal_vectors (const DoFHandler<1>::cell_iterator &,
const unsigned int,
};
-
template <>
void FEQ1Mapping<1>::get_normal_vectors (const DoFHandler<1>::cell_iterator &,
const unsigned int,
};
-
template <>
void FEQ1Mapping<1>::fill_fe_values (const DoFHandler<1>::cell_iterator &cell,
const vector<Point<1> > &unit_points,
};
-
#endif
-
#if deal_II_dimension == 2
template <>
};
-
template <>
inline
double
};
-
template <>
inline
Tensor<1,2>
};
-
template <>
void FEQ1Mapping<2>::get_face_jacobians (const DoFHandler<2>::face_iterator &face,
const vector<Point<1> > &unit_points,
};
-
template <>
void FEQ1Mapping<2>::get_subface_jacobians (const DoFHandler<2>::face_iterator &face,
const unsigned int ,
};
-
template <>
void FEQ1Mapping<2>::get_normal_vectors (const DoFHandler<2>::cell_iterator &cell,
const unsigned int face_no,
};
-
template <>
void FEQ1Mapping<2>::get_normal_vectors (const DoFHandler<2>::cell_iterator &cell,
const unsigned int face_no,
#endif
-
#if deal_II_dimension == 3
template <>
{};
-
template <>
inline
double
};
-
template <>
inline
Tensor<1,3>
};
-
template <>
void FEQ1Mapping<3>::get_face_jacobians (const DoFHandler<3>::face_iterator &face,
const vector<Point<2> > &unit_points,
};
-
template <>
void FEQ1Mapping<3>::get_subface_jacobians (const DoFHandler<3>::face_iterator &/*face*/,
const unsigned int ,
};
-
template <>
void FEQ1Mapping<3>::get_normal_vectors (const DoFHandler<3>::cell_iterator &cell,
const unsigned int face_no,
};
-
template <>
void FEQ1Mapping<3>::get_normal_vectors (const DoFHandler<3>::cell_iterator &/*cell*/,
const unsigned int /*face_no*/,
#endif
-
template <int dim>
void FEQ1Mapping<dim>::fill_fe_values (const DoFHandler<dim>::cell_iterator &cell,
const vector<Point<dim> > &unit_points,
Assert ((!compute_support_points) || (support_points.size() == dofs_per_cell),
ExcWrongFieldDimension(support_points.size(), dofs_per_cell));
-
- unsigned int n_points=unit_points.size();
+
+unsigned int n_points=unit_points.size();
Point<dim> vertices[GeometryInfo<dim>::vertices_per_cell];
for (unsigned int l=0; l<GeometryInfo<dim>::vertices_per_cell; ++l)
vertices[l] = cell->vertex(l);
-
- if (compute_q_points)
+
+if (compute_q_points)
{
// initialize points to zero
for (unsigned int i=0; i<n_points; ++i)
for (unsigned int l=0; l<n_points; ++l)
q_points[l] += vertices[j] * shape_values_transform(j, l);
};
-
+
/* jacobi matrices: compute d(x)/d(xi) and invert this
Let M(l) be the inverse of J at the quadrature point l, then
};
};
-
- One last note regarding whether we have to invert M or M transposed: it is
+
+One last note regarding whether we have to invert M or M transposed: it is
easy to try out, by computing the gradients of a function on a distorted
cell (just move one vertex) where the nodal values for linear elements
are one for the moved vertex and zero otherwise. Please also note that
QTrapez<2> q;
FEValues<2> fevalues(fe,q,update_gradients);
fevalues.reinit (dof.begin_active(),b);
-
-
- Vector<double> val(4);
+
+
+Vector<double> val(4);
val(2) = 1;
vector<Point<2> > grads(4);
};
-
-
/*------------------------------- Explicit Instantiations -------------*/
template class FEQ1Mapping<deal_II_dimension>;
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+//---------------------------- q1_mapping.jacobians.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- q1_mapping.jacobians.cc ---------------------------
-// moved from file fe_linear_mapping_jacobians.cc
#include <fe/q1_mapping.h>
#include <grid/tria_iterator.h>
#include <cmath>
-
/**
* This file has been singled out from q1_mapping.cc because the computation
* of the 3d matrices is so extremely large that it can't be done with
*/
-
#if deal_II_dimension == 1
template <>
};
-
template <>
void FEQ1Mapping<1>::compute_jacobian_gradients (const DoFHandler<1>::cell_iterator &,
const vector<Point<1> > &unit_points,
#endif
-
#if deal_II_dimension == 2
template <>
};
-
template <>
void FEQ1Mapping<2>::compute_jacobian_gradients (const DoFHandler<2>::cell_iterator &cell,
const vector<Point<2> > &unit_points,
#endif
-
#if deal_II_dimension == 3
template <>
};
-
template <>
void FEQ1Mapping<3>::compute_jacobian_gradients (const DoFHandler<3>::cell_iterator &cell,
const vector<Point<3> > &unit_points,
-/* $Id$ */
+//---------------------------- geometry_info.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- geometry_info.cc ---------------------------
+
#include <grid/geometry_info.h>
-/* $Id$ */
+//---------------------------- grid_generator.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- grid_generator.cc ---------------------------
#include <grid/grid_generator.h>
#include <cmath>
-
-
#if deal_II_dimension == 1
template <>
};
-
template <>
void GridGenerator::hyper_cube_slit<> (Triangulation<1> &,
const double,
};
-
template <>
void GridGenerator::hyper_L<> (Triangulation<1> &,
const double,
};
-
template <>
void GridGenerator::hyper_ball<> (Triangulation<1> &,
const Point<1> &,
};
-
template <>
void GridGenerator::hyper_shell<> (Triangulation<1> &,
const Point<1> &,
#endif
-
#if deal_II_dimension == 2
template <>
};
-
template <>
void GridGenerator::hyper_cube_slit<> (Triangulation<2> &tria,
const double left,
};
-
template <>
void GridGenerator::hyper_L<> (Triangulation<2> &tria,
const double a,
};
-
template <>
void GridGenerator::hyper_ball<> (Triangulation<2> &tria,
const Point<2> &p,
};
-
template <>
void GridGenerator::hyper_shell<> (Triangulation<2> &tria,
const Point<2> ¢er,
};
-
template <>
void GridGenerator::hyper_cube_slit<> (Triangulation<3> &,
const double,
};
-
template <>
void GridGenerator::hyper_L<> (Triangulation<3> &tria,
const double a,
};
-
template <>
void GridGenerator::hyper_ball<> (Triangulation<3> &tria,
const Point<3> &p,
};
-
template <>
void GridGenerator::hyper_shell<> (Triangulation<3> &,
const Point<3> &,
#endif
-
-
// explicit instantiations
// template void GridGenerator::hyper_cube (Triangulation<deal_II_dimension> &,
// const double,
-/* $Id$ */
+//---------------------------- grid_in.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- grid_in.cc ---------------------------
+
#include <grid/grid_in.h>
#include <grid/tria.h>
#include <map>
-
template <int dim>
GridIn<dim>::GridIn () :
tria(0) {};
-
template <int dim>
void GridIn<dim>::attach_triangulation (Triangulation<dim> &t)
{
};
-
template <int dim>
void GridIn<dim>::read_ucd (istream &in)
{
// put back first character of
// first non-comment line
in.putback (c);
-
-
- unsigned int n_vertices;
+
+
+unsigned int n_vertices;
unsigned int n_cells;
int dummy;
};
-
//explicit instantiations
template class GridIn<deal_II_dimension>;
-/* $Id$ */
+//---------------------------- grid_out.all_dimensions.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- grid_out.all_dimensions.cc ---------------------------
+
#include <grid/grid_out.h>
{};
-
GridOut::GnuplotFlags::GnuplotFlags (const bool write_cell_numbers,
const bool write_level) :
write_cell_numbers (write_cell_numbers),
{};
-
GridOut::EpsFlagsBase::EpsFlagsBase (const SizeType size_type,
const unsigned int size,
const double line_width) :
{};
-
// egcs 1.1.2 does not understand this, so I made it inlined in the
// class declaration
//
// {};
-
void GridOut::set_flags (const UcdFlags &flags)
{
ucd_flags = flags;
};
-
void GridOut::set_flags (const GnuplotFlags &flags)
{
gnuplot_flags = flags;
};
-
void GridOut::set_flags (const EpsFlags<1> &flags)
{
eps_flags_1 = flags;
};
-
void GridOut::set_flags (const EpsFlags<2> &flags)
{
eps_flags_2 = flags;
};
-
void GridOut::set_flags (const EpsFlags<3> &flags)
{
eps_flags_3 = flags;
};
-
string GridOut::default_suffix (const OutputFormat output_format)
{
switch (output_format)
return "";
};
};
-
-
GridOut::OutputFormat
};
-
string GridOut::get_output_format_names () {
return "gnuplot|eps";
};
-/* $Id$ */
+//---------------------------- grid_out.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- grid_out.cc ---------------------------
#include <base/point.h>
#include <cmath>
-
template <int dim>
void GridOut::write_ucd (const Triangulation<dim> &tria,
ostream &out)
vertices[cell->vertex_index(vertex)] = cell->vertex(vertex);
++n_vertices;
};
-
- // write preamble
+
+// write preamble
if (ucd_flags.write_preamble)
{
// block this to have local
};
-
#if deal_II_dimension == 1
template <>
#endif
-
template <int dim>
unsigned int GridOut::n_boundary_faces (const Triangulation<dim> &tria) const
{
};
-
#if deal_II_dimension == 1
template <>
#endif
-
template <int dim>
void GridOut::write_ucd_faces (const Triangulation<dim> &tria,
const unsigned int starting_index,
};
-
template <int dim>
void GridOut::write_gnuplot (const Triangulation<dim> &tria,
ostream &out)
};
-
template <int dim>
void GridOut::write_eps (const Triangulation<dim> &tria,
ostream &out)
default:
Assert (false, ExcNotImplemented());
};
-
-
- // find out minimum and maximum x and
+
+// find out minimum and maximum x and
// y coordinates to compute offsets
// and scaling factors
double x_min = tria.begin_active_line()->vertex(0)(0);
(eps_flags_base.size_type==EpsFlagsBase::width ?
x_max - x_min :
y_min - y_max));
-
-
- // now write preamble
+
+
+// now write preamble
if (true)
{
// block this to have local
};
-
-
template <int dim>
void GridOut::write (const Triangulation<dim> &tria,
ostream &out,
};
-
-
// explicit instantiations. note that write instantiates all the other
// functions as needed
template void GridOut::write (const Triangulation<deal_II_dimension> &, ostream &, OutputFormat);
-/* $Id$ */
+//---------------------------- intergrid_map.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- intergrid_map.cc ---------------------------
+
#include <grid/tria.h>
#include <dofs/dof_handler.h>
#include <grid/intergrid_map.h>
-
// helper function to aquire the number of levels within a grid
template <class GridClass>
unsigned int
};
-
-
-
template <template <int> class GridClass, int dim>
void InterGridMap<GridClass,dim>::make_mapping (const GridClass<dim> &source_grid,
const GridClass<dim> &destination_grid)
{
// first delete all contents
clear ();
-
- // then set up the containers from
+
+// then set up the containers from
// scratch and fill them with end-iterators
const unsigned int n_levels = get_n_levels(source_grid);
mapping.resize (n_levels);
};
-
template <template <int> class GridClass, int dim>
void
InterGridMap<GridClass,dim>::set_mapping (const cell_iterator &src_cell,
};
-
template <template <int> class GridClass, int dim>
void
InterGridMap<GridClass,dim>::set_entries_to_cell (const cell_iterator &src_cell,
};
-
template <template <int> class GridClass, int dim>
typename InterGridMap<GridClass,dim>::cell_iterator
InterGridMap<GridClass,dim>::operator [] (const cell_iterator &source_cell) const
};
-
template <template <int> class GridClass, int dim>
void InterGridMap<GridClass,dim>::clear ()
{
};
-
-
// explicit instantiations
template class InterGridMap<Triangulation, deal_II_dimension>;
template class InterGridMap<DoFHandler, deal_II_dimension>;
template class InterGridMap<MGDoFHandler, deal_II_dimension>;
-
+
-/* $Id$ */
+//---------------------------- persistent_tria.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- persistent_tria.cc ---------------------------
+
#include <grid/persistent_tria.h>
#include <grid/magic_numbers.h>
};
-
template <int dim>
PersistentTriangulation<dim>::~PersistentTriangulation ()
{};
-
template <int dim>
void
PersistentTriangulation<dim>::execute_coarsening_and_refinement ()
};
-
template <int dim>
void
PersistentTriangulation<dim>::restore () {
};
-
template <int dim>
void
PersistentTriangulation<dim>::copy_triangulation (const Triangulation<dim> &old_grid)
};
-
template <int dim>
void
PersistentTriangulation<dim>::write_flags(ostream &out) const
}
-
template <int dim>
void
PersistentTriangulation<dim>::read_flags(istream &in)
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1999 */
+//---------------------------- tria.all_dimensions.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- tria.all_dimensions.cc ---------------------------
#include <grid/tria.h>
*/
-
-
bool SubCellData::check_consistency (const unsigned int dim) const
{
switch (dim)
return true;
};
-
-
void TriangulationLevel<0>::reserve_space (const unsigned int total_cells,
const unsigned int dimension)
};
-
-
void TriangulationLevel<0>::monitor_memory (const unsigned int true_dimension) const
{
// Assert (refine_flags.size() == refine_flags.capacity() ||
};
-
void TriangulationLevel<1>::reserve_space (const unsigned int new_lines)
{
const unsigned int new_size = new_lines +
};
-
-
void TriangulationLevel<1>::monitor_memory (const unsigned int true_dimension) const
{
// Assert (lines.lines.size() == lines.lines.capacity() ||
};
-
void TriangulationLevel<2>::reserve_space (const unsigned int new_quads)
{
const unsigned int new_size = new_quads +
};
-
void TriangulationLevel<2>::monitor_memory (const unsigned int true_dimension) const
{
// Assert (quads.quads.size() == quads.quads.capacity() ||
};
-
void TriangulationLevel<3>::reserve_space (const unsigned int new_hexes)
{
const unsigned int new_size = new_hexes +
};
-
void TriangulationLevel<3>::monitor_memory (const unsigned int true_dimension) const
{
// Assert (hexes.hexes.size() == hexes.hexes.capacity() ||
};
-
TriaNumberCache<1>::TriaNumberCache () :
n_lines (0),
n_active_lines (0)
{};
-
-
TriaNumberCache<2>::TriaNumberCache () :
n_quads (0),
n_active_quads (0)
{};
-
-
TriaNumberCache<3>::TriaNumberCache () :
n_hexes (0),
n_active_hexes (0)
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998, 1999 */
+//---------------------------- tria.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- tria.cc ---------------------------
#include <grid/tria.h>
#include <cmath>
-
template <int dim>
const StraightBoundary<dim>& Triangulation<dim>::straight_boundary
= StraightBoundary<dim>();
-
-
template <int dim>
Triangulation<dim>::Triangulation (const MeshSmoothing smooth_grid) :
Subscriptor (),
};
-
template <int dim>
Triangulation<dim>::Triangulation (const Triangulation<dim> &)
:
};
-
template <int dim>
Triangulation<dim>::~Triangulation ()
{
};
-
template <int dim>
void Triangulation<dim>::clear ()
{
};
-
template <int dim>
const Boundary<dim> &
Triangulation<dim>::get_boundary (const unsigned int number) const
};
-
-
/*--------- Put the next functions a bit out-or-order to avoid use before
--------- explicit specialization, which is not allowed. */
};
-
template <>
TriaDimensionInfo<1>::raw_cell_iterator
Triangulation<1>::end () const {
};
-
template <>
TriaDimensionInfo<2>::raw_cell_iterator
Triangulation<2>::end () const {
#endif
-
#if deal_II_dimension == 3
template <>
};
-
template <>
TriaDimensionInfo<3>::raw_cell_iterator
Triangulation<3>::end () const {
#endif
-
-
/*-----------------------------------------------------------------*/
-
template <int dim>
void Triangulation<dim>::copy_triangulation (const Triangulation<dim> &old_tria)
{
};
-
#if deal_II_dimension == 1
template <>
};
- // some security tests
+// some security tests
unsigned int boundary_nodes = 0;
for (unsigned int i=0; i<lines_at_vertex.size(); ++i)
switch (lines_at_vertex[i].size())
AssertThrow (boundary_nodes == 2, ExcInternalError());
- // update neighborship info
+// update neighborship info
active_line_iterator line = begin_active_line ();
// for all lines
for (; line!=end(); ++line)
};
- // re-compute numbers of lines, etc
+// re-compute numbers of lines, etc
update_number_cache ();
};
#endif
-
#if deal_II_dimension == 2
template <>
// may need to change entries
vector<CellData<2> > cells(c);
-
- // make up a list of the needed lines
+
+// make up a list of the needed lines
// each line is a pair of vertices. The list
// is kept sorted and it is guaranteed
// that each line is inserted only once.
// rotation
break;
};
-
-
- for (unsigned int line=0; line<4; ++line)
+
+
+for (unsigned int line=0; line<4; ++line)
{
// assert that the line was not
// already inserted in reverse
needed_lines[line_vertices[line]] = end_line();
};
};
-
- // check the every vertex has
+
+// check the every vertex has
// at least two adjacent lines
if (true)
{
};
- // store for each line index
+// store for each line index
// the adjacent cells
map<int,vector<cell_iterator> > adjacent_cells;
ExcInternalErrorOnCell(c));
};
};
-
- for (line_iterator line=begin_line(); line!=end_line(); ++line)
+
+for (line_iterator line=begin_line(); line!=end_line(); ++line)
{
const unsigned int n_adj_cells = adjacent_cells[line->index()].size();
// assert that every line has one or
};
-
-
-
- // finally update neighborship info
+// finally update neighborship info
for (cell_iterator cell=begin(); cell!=end(); ++cell)
for (unsigned int side=0; side<4; ++side)
if (adjacent_cells[cell->line(side)->index()][0] == cell)
adjacent_cells[cell->line(side)->index()][0]);
- // re-compute numbers of lines, etc
+// re-compute numbers of lines, etc
update_number_cache ();
};
};
-
template <>
void Triangulation<3>::create_triangulation (const vector<Point<3> > &v,
const vector<CellData<3> > &c,
needed_lines[line_vertices[line]] = end_line();
};
};
-
- /////////////////////////////////
+
+/////////////////////////////////
// now for some sanity-checks:
//
// check the every vertex has
};
- ///////////////////////////////////
+///////////////////////////////////
// actually set up data structures
// for the lines
// reserve enough space
};
- ///////////////////////////////////////////
+///////////////////////////////////////////
// make up the quads of this triangulation
//
// same thing: the iterators are set
// nothing bad happens here
needed_quads[faces[quad]] = end_quad();
};
-
- /////////////////////////////////
+
+/////////////////////////////////
// enter the resulting quads into
// the arrays of the Triangulation
//
ExcInternalErrorOnCell(c));
};
};
-
- /////////////////////////////////////////
+
+/////////////////////////////////////////
// find those quads which are at the
// boundary and mark them appropriately
for (quad_iterator quad=begin_quad(); quad!=end_quad(); ++quad)
if (quad->at_boundary())
for (unsigned int l=0; l<4; ++l)
quad->line(l)->set_boundary_indicator (0);
-
- ///////////////////////////////////////
+
+///////////////////////////////////////
// now set boundary indicators
// where given
//
AssertThrow ((subcelldata.boundary_lines.size() == 0) &&
(subcelldata.boundary_quads.size() == 0),
ExcInternalError());
-
- /////////////////////////////////////////
+
+/////////////////////////////////////////
// finally update neighborship info
for (cell_iterator cell=begin(); cell!=end(); ++cell)
for (unsigned int face=0; face<6; ++face)
adjacent_cells[cell->quad(face)->index()][0]);
- // re-compute numbers of lines, etc
+// re-compute numbers of lines, etc
update_number_cache ();
};
#endif
-
-
#if deal_II_dimension == 1
template <>
};
- const unsigned int n_vertices = vertices.size();
+const unsigned int n_vertices = vertices.size();
Point<dim> shift_vector;
for (unsigned int vertex=0; vertex<n_vertices; ++vertex)
#endif
-
template <int dim>
void Triangulation<dim>::distort_random (const double factor,
const bool keep_boundary) {
};
- const unsigned int n_vertices = vertices.size();
+const unsigned int n_vertices = vertices.size();
Point<dim> shift_vector;
for (unsigned int vertex=0; vertex<n_vertices; ++vertex)
vertices[vertex] += shift_vector;
};
-
- // finally correct hanging nodes
+
+// finally correct hanging nodes
// again. The following is not
// necessary for 1D
active_cell_iterator cell = begin_active(),
};
-
-
template <int dim>
void Triangulation<dim>::set_all_refine_flags () {
active_cell_iterator cell = begin_active(),
};
-
template <int dim>
void Triangulation<dim>::refine_global (const unsigned int times) {
for (unsigned int i=0; i<times; ++i)
};
-
template <int dim>
void Triangulation<dim>::save_refine_flags (vector<bool> &v) const {
v.resize (n_active_cells(), false);
};
-
template <int dim>
void Triangulation<dim>::save_refine_flags (ostream &out) const {
vector<bool> v;
};
-
template <int dim>
void Triangulation<dim>::load_refine_flags (istream &in) {
vector<bool> v;
};
-
template <int dim>
void Triangulation<dim>::load_refine_flags (const vector<bool> &v) {
Assert (v.size() == n_active_cells(), ExcGridReadError());
};
-
template <int dim>
void Triangulation<dim>::save_coarsen_flags (vector<bool> &v) const {
v.resize (n_active_cells(), false);
};
-
template <int dim>
void Triangulation<dim>::save_coarsen_flags (ostream &out) const {
vector<bool> v;
};
-
template <int dim>
void Triangulation<dim>::load_coarsen_flags (istream &in) {
vector<bool> v;
};
-
template <int dim>
void Triangulation<dim>::load_coarsen_flags (const vector<bool> &v) {
Assert (v.size() == n_active_cells(), ExcGridReadError());
};
-
#if deal_II_dimension == 1
template <>
};
-
template <>
void Triangulation<1>::clear_user_flags () {
cell_iterator cell = begin(),
};
-
template <>
void Triangulation<2>::clear_user_flags () {
line_iterator line = begin_line(),
#endif
-
-
#if deal_II_dimension == 3
template <>
};
-
template <>
void Triangulation<3>::clear_user_flags () {
line_iterator line = begin_line(),
#endif
-
-
template <int dim>
void Triangulation<dim>::save_user_flags (ostream &out) const {
save_user_flags_line (out);
};
-
template <int dim>
void Triangulation<dim>::save_user_flags (vector<bool> &v) const {
// clear vector and append
};
-
template <int dim>
void Triangulation<dim>::load_user_flags (istream &in)
{
};
-
template <int dim>
void Triangulation<dim>::load_user_flags (const vector<bool> &v)
{
};
-
template <int dim>
void Triangulation<dim>::save_user_flags_line (vector<bool> &v) const {
v.resize (n_lines(), false);
};
-
template <int dim>
void Triangulation<dim>::save_user_flags_line (ostream &out) const {
vector<bool> v;
};
-
template <int dim>
void Triangulation<dim>::load_user_flags_line (istream &in) {
vector<bool> v;
};
-
template <int dim>
void Triangulation<dim>::load_user_flags_line (const vector<bool> &v) {
Assert (v.size() == n_lines(), ExcGridReadError());
};
-
#if deal_II_dimension == 1
template <>
};
-
template <>
void Triangulation<1>::save_user_flags_quad (vector<bool> &) const {
Assert (false, ExcFunctionNotUseful());
};
-
template <>
void Triangulation<1>::save_user_flags_hex (vector<bool> &) const {
Assert (false, ExcFunctionNotUseful());
#endif
-
-
template <int dim>
void Triangulation<dim>::save_user_flags_quad (vector<bool> &v) const {
v.resize (n_quads(), false);
};
-
template <int dim>
void Triangulation<dim>::save_user_flags_quad (ostream &out) const {
vector<bool> v;
};
-
template <int dim>
void Triangulation<dim>::load_user_flags_quad (istream &in) {
vector<bool> v;
};
-
template <int dim>
void Triangulation<dim>::load_user_flags_quad (const vector<bool> &v) {
Assert (v.size() == n_quads(), ExcGridReadError());
};
-
#if deal_II_dimension == 2
template <>
};
-
template <>
void Triangulation<2>::save_user_flags_hex (vector<bool> &) const {
Assert (false, ExcFunctionNotUseful());
#endif
-
-
template <int dim>
void Triangulation<dim>::save_user_flags_hex (vector<bool> &v) const {
v.resize (n_hexs(), false);
};
-
template <int dim>
void Triangulation<dim>::save_user_flags_hex (ostream &out) const {
vector<bool> v;
};
-
template <int dim>
void Triangulation<dim>::load_user_flags_hex (istream &in) {
vector<bool> v;
};
-
template <int dim>
void Triangulation<dim>::load_user_flags_hex (const vector<bool> &v) {
Assert (v.size() == n_hexs(), ExcGridReadError());
};
-
/*------------------------ Iterator functions ------------------------*/
};
-
template <>
TriaDimensionInfo<1>::active_cell_iterator
Triangulation<1>::begin_active (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<1>::raw_cell_iterator
Triangulation<1>::last_raw () const {
};
-
template <>
TriaDimensionInfo<1>::raw_cell_iterator
Triangulation<1>::last_raw (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<1>::cell_iterator
Triangulation<1>::last () const {
};
-
template <>
TriaDimensionInfo<1>::cell_iterator
Triangulation<1>::last (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<1>::active_cell_iterator
Triangulation<1>::last_active () const {
};
-
template <>
TriaDimensionInfo<1>::active_cell_iterator
Triangulation<1>::last_active (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<1>::raw_face_iterator
Triangulation<1>::begin_raw_face (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::face_iterator
Triangulation<1>::begin_face (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::active_face_iterator
Triangulation<1>::begin_active_face (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::raw_face_iterator
Triangulation<1>::end_face () const {
};
-
template <>
TriaDimensionInfo<1>::raw_face_iterator
Triangulation<1>::last_raw_face () const {
};
-
template <>
TriaDimensionInfo<1>::raw_face_iterator
Triangulation<1>::last_raw_face (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::face_iterator
Triangulation<1>::last_face () const {
};
-
template <>
TriaDimensionInfo<1>::face_iterator
Triangulation<1>::last_face (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::active_face_iterator
Triangulation<1>::last_active_face () const {
};
-
template <>
TriaDimensionInfo<1>::active_face_iterator
Triangulation<1>::last_active_face (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::quad_iterator
Triangulation<1>::begin_quad (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::active_quad_iterator
Triangulation<1>::begin_active_quad (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::raw_quad_iterator
Triangulation<1>::end_quad () const {
};
-
template <>
TriaDimensionInfo<1>::raw_quad_iterator
Triangulation<1>::last_raw_quad (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::raw_quad_iterator
Triangulation<1>::last_raw_quad () const {
};
-
template <>
TriaDimensionInfo<1>::quad_iterator
Triangulation<1>::last_quad (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::quad_iterator
Triangulation<1>::last_quad () const {
};
-
template <>
TriaDimensionInfo<1>::active_quad_iterator
Triangulation<1>::last_active_quad (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::active_quad_iterator
Triangulation<1>::last_active_quad () const {
};
-
template <>
TriaDimensionInfo<1>::raw_hex_iterator
Triangulation<1>::begin_raw_hex (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::hex_iterator
Triangulation<1>::begin_hex (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::active_hex_iterator
Triangulation<1>::begin_active_hex (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::raw_hex_iterator
Triangulation<1>::end_hex () const {
};
-
template <>
TriaDimensionInfo<1>::raw_hex_iterator
Triangulation<1>::last_raw_hex (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::raw_hex_iterator
Triangulation<1>::last_raw_hex () const {
};
-
template <>
TriaDimensionInfo<1>::hex_iterator
Triangulation<1>::last_hex (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::hex_iterator
Triangulation<1>::last_hex () const {
};
-
template <>
TriaDimensionInfo<1>::active_hex_iterator
Triangulation<1>::last_active_hex (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<1>::active_hex_iterator
Triangulation<1>::last_active_hex () const {
#endif
-
-
#if deal_II_dimension == 2
template <>
};
-
template <>
TriaDimensionInfo<2>::active_cell_iterator
Triangulation<2>::begin_active (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<2>::raw_cell_iterator
Triangulation<2>::last_raw () const {
};
-
template <>
TriaDimensionInfo<2>::raw_cell_iterator
Triangulation<2>::last_raw (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<2>::cell_iterator
Triangulation<2>::last () const {
};
-
template <>
TriaDimensionInfo<2>::cell_iterator
Triangulation<2>::last (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<2>::active_cell_iterator
Triangulation<2>::last_active () const {
};
-
template <>
TriaDimensionInfo<2>::active_cell_iterator
Triangulation<2>::last_active (const unsigned int level) const {
};
-
-
-
-
-
template <>
TriaDimensionInfo<2>::raw_face_iterator
Triangulation<2>::begin_raw_face (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<2>::face_iterator
Triangulation<2>::begin_face (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<2>::active_face_iterator
Triangulation<2>::begin_active_face (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<2>::raw_face_iterator
Triangulation<2>::end_face () const {
};
-
template <>
TriaDimensionInfo<2>::raw_face_iterator
Triangulation<2>::last_raw_face () const {
};
-
template <>
TriaDimensionInfo<2>::raw_face_iterator
Triangulation<2>::last_raw_face (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<2>::face_iterator
Triangulation<2>::last_face () const {
};
-
template <>
TriaDimensionInfo<2>::face_iterator
Triangulation<2>::last_face (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<2>::active_face_iterator
Triangulation<2>::last_active_face () const {
};
-
template <>
TriaDimensionInfo<2>::active_face_iterator
Triangulation<2>::last_active_face (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<2>::hex_iterator
Triangulation<2>::begin_hex (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<2>::active_hex_iterator
Triangulation<2>::begin_active_hex (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<2>::raw_hex_iterator
Triangulation<2>::end_hex () const {
};
-
template <>
TriaDimensionInfo<2>::raw_hex_iterator
Triangulation<2>::last_raw_hex (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<2>::raw_hex_iterator
Triangulation<2>::last_raw_hex () const {
};
-
template <>
TriaDimensionInfo<2>::hex_iterator
Triangulation<2>::last_hex (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<2>::hex_iterator
Triangulation<2>::last_hex () const {
};
-
template <>
TriaDimensionInfo<2>::active_hex_iterator
Triangulation<2>::last_active_hex (const unsigned int) const {
};
-
template <>
TriaDimensionInfo<2>::active_hex_iterator
Triangulation<2>::last_active_hex () const {
#endif
-
#if deal_II_dimension == 3
template <>
};
-
template <>
TriaDimensionInfo<3>::active_cell_iterator
Triangulation<3>::begin_active (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<3>::raw_cell_iterator
Triangulation<3>::last_raw () const {
};
-
template <>
TriaDimensionInfo<3>::raw_cell_iterator
Triangulation<3>::last_raw (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<3>::cell_iterator
Triangulation<3>::last () const {
};
-
template <>
TriaDimensionInfo<3>::cell_iterator
Triangulation<3>::last (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<3>::active_cell_iterator
Triangulation<3>::last_active () const {
};
-
template <>
TriaDimensionInfo<3>::active_cell_iterator
Triangulation<3>::last_active (const unsigned int level) const {
};
-
-
-
-
-
template <>
TriaDimensionInfo<3>::raw_face_iterator
Triangulation<3>::begin_raw_face (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<3>::face_iterator
Triangulation<3>::begin_face (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<3>::active_face_iterator
Triangulation<3>::begin_active_face (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<3>::raw_face_iterator
Triangulation<3>::end_face () const {
};
-
template <>
TriaDimensionInfo<3>::raw_face_iterator
Triangulation<3>::last_raw_face () const {
};
-
template <>
TriaDimensionInfo<3>::raw_face_iterator
Triangulation<3>::last_raw_face (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<3>::face_iterator
Triangulation<3>::last_face () const {
};
-
template <>
TriaDimensionInfo<3>::face_iterator
Triangulation<3>::last_face (const unsigned int level) const {
};
-
template <>
TriaDimensionInfo<3>::active_face_iterator
Triangulation<3>::last_active_face () const {
};
-
template <>
TriaDimensionInfo<3>::active_face_iterator
Triangulation<3>::last_active_face (const unsigned int level) const {
};
-
#endif
-
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_line_iterator
Triangulation<dim>::begin_raw_line (unsigned int level) const {
};
-
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_quad_iterator
Triangulation<dim>::begin_raw_quad (unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_hex_iterator
Triangulation<dim>::begin_raw_hex (unsigned int level) const {
};
-
-
template <int dim>
typename TriaDimensionInfo<dim>::line_iterator
Triangulation<dim>::begin_line (unsigned int level) const {
};
-
-
template <int dim>
typename TriaDimensionInfo<dim>::quad_iterator
Triangulation<dim>::begin_quad (unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::hex_iterator
Triangulation<dim>::begin_hex (unsigned int level) const {
};
-
-
template <int dim>
typename TriaDimensionInfo<dim>::active_line_iterator
Triangulation<dim>::begin_active_line (unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::active_quad_iterator
Triangulation<dim>::begin_active_quad (unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::active_hex_iterator
Triangulation<dim>::begin_active_hex (unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_line_iterator
Triangulation<dim>::end_line () const {
};
-
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_quad_iterator
Triangulation<dim>::end_quad () const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_hex_iterator
Triangulation<dim>::end_hex () const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_line_iterator
Triangulation<dim>::last_raw_line (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_quad_iterator
Triangulation<dim>::last_raw_quad (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_hex_iterator
Triangulation<dim>::last_raw_hex (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_line_iterator
Triangulation<dim>::last_raw_line () const {
};
-
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_quad_iterator
Triangulation<dim>::last_raw_quad () const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_hex_iterator
Triangulation<dim>::last_raw_hex () const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::line_iterator
Triangulation<dim>::last_line (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::quad_iterator
Triangulation<dim>::last_quad (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::hex_iterator
Triangulation<dim>::last_hex (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::line_iterator
Triangulation<dim>::last_line () const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::quad_iterator
Triangulation<dim>::last_quad () const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::hex_iterator
Triangulation<dim>::last_hex () const {
};
-
-
template <int dim>
typename TriaDimensionInfo<dim>::active_line_iterator
Triangulation<dim>::last_active_line (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::active_quad_iterator
Triangulation<dim>::last_active_quad (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::active_hex_iterator
Triangulation<dim>::last_active_hex (const unsigned int level) const {
};
-
-
template <int dim>
typename TriaDimensionInfo<dim>::active_line_iterator
Triangulation<dim>::last_active_line () const {
};
-
-
template <int dim>
typename TriaDimensionInfo<dim>::active_quad_iterator
Triangulation<dim>::last_active_quad () const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::active_hex_iterator
Triangulation<dim>::last_active_hex () const {
};
-
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_cell_iterator
Triangulation<dim>::end_raw (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::cell_iterator
Triangulation<dim>::end (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::active_cell_iterator
Triangulation<dim>::end_active (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_face_iterator
Triangulation<dim>::end_raw_face (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::face_iterator
Triangulation<dim>::end_face (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::active_face_iterator
Triangulation<dim>::end_active_face (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_line_iterator
Triangulation<dim>::end_raw_line (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::line_iterator
Triangulation<dim>::end_line (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::active_line_iterator
Triangulation<dim>::end_active_line (const unsigned int level) const {
};
-
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_quad_iterator
Triangulation<dim>::end_raw_quad (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::quad_iterator
Triangulation<dim>::end_quad (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::active_quad_iterator
Triangulation<dim>::end_active_quad (const unsigned int level) const {
};
-
-
-
template <int dim>
typename TriaDimensionInfo<dim>::raw_hex_iterator
Triangulation<dim>::end_raw_hex (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::hex_iterator
Triangulation<dim>::end_hex (const unsigned int level) const {
};
-
template <int dim>
typename TriaDimensionInfo<dim>::active_hex_iterator
Triangulation<dim>::end_active_hex (const unsigned int level) const {
};
-
-
-
template <int dim>
unsigned int Triangulation<dim>::n_cells () const {
unsigned int n=0;
};
-
template <int dim>
unsigned int Triangulation<dim>::n_active_cells () const {
unsigned int n=0;
};
-
#if deal_II_dimension == 1
template <>
#endif
-
#if deal_II_dimension == 2
template <>
};
-
template <>
unsigned int Triangulation<2>::n_active_cells (const unsigned int level) const {
return n_active_quads (level);
#endif
-
#if deal_II_dimension == 3
template <>
};
-
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>
unsigned int Triangulation<dim>::n_lines (const unsigned int level) const {
Assert (level < number_cache.n_lines_level.size(),
};
-
template <int dim>
unsigned int Triangulation<dim>::n_active_lines () const {
return number_cache.n_active_lines;
};
-
template <int dim>
unsigned int Triangulation<dim>::n_active_lines (const unsigned int level) const {
Assert (level < number_cache.n_lines_level.size(),
};
-
#if deal_II_dimension == 1
template <>
};
-
template <>
unsigned int Triangulation<1>::n_quads (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
};
-
template <>
unsigned int Triangulation<1>::n_active_quads (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
};
-
template <int dim>
unsigned int Triangulation<dim>::n_quads (const unsigned int level) const {
Assert (level < number_cache.n_quads_level.size(),
};
-
template <int dim>
unsigned int Triangulation<dim>::n_active_quads () const {
return number_cache.n_active_quads;
};
-
template <int dim>
unsigned int Triangulation<dim>::n_active_quads (const unsigned int level) const {
Assert (level < number_cache.n_quads_level.size(),
};
-
#if deal_II_dimension < 3
template <>
};
-
template <>
unsigned int Triangulation<1>::n_hexs (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
};
-
template <>
unsigned int Triangulation<1>::n_active_hexs () const {
Assert (false, ExcFunctionNotUseful());
};
-
template <>
unsigned int Triangulation<1>::n_active_hexs (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
};
-
template <>
unsigned int Triangulation<2>::n_hexs () const {
Assert (false, ExcFunctionNotUseful());
};
-
template <>
unsigned int Triangulation<2>::n_hexs (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
};
-
template <>
unsigned int Triangulation<2>::n_active_hexs () const {
Assert (false, ExcFunctionNotUseful());
};
-
template <>
unsigned int Triangulation<2>::n_active_hexs (const unsigned int) const {
Assert (false, ExcFunctionNotUseful());
};
-
template <int dim>
unsigned int Triangulation<dim>::n_hexs (const unsigned int level) const {
Assert (level < number_cache.n_hexes_level.size(),
};
-
template <int dim>
unsigned int Triangulation<dim>::n_active_hexs () const {
return number_cache.n_active_hexes;
};
-
template <int dim>
unsigned int Triangulation<dim>::n_active_hexs (const unsigned int level) const {
Assert (level < number_cache.n_hexes_level.size(),
};
-
-
template <int dim>
unsigned int Triangulation<dim>::n_levels () const {
if (levels.size() == 0)
};
-
template <int dim>
unsigned int
Triangulation<dim>::n_vertices () const
};
-
template <int dim>
unsigned int
Triangulation<dim>::n_used_vertices () const
};
-
#if deal_II_dimension == 1
template <>
#endif
-
template <int dim>
unsigned int Triangulation<dim>::max_adjacent_cells () const {
cell_iterator cell = begin(0),
};
-
-
-
template <int dim>
template <typename number>
void Triangulation<dim>::refine (const Vector<number> &criteria,
};
-
template <int dim>
template <typename number>
void Triangulation<dim>::coarsen (const Vector<number> &criteria,
};
-
template <int dim>
template <typename number>
void
};
-
static
inline
double sqr(double a) {
};
-
template <int dim>
template <typename number>
void
};
-
-
-
template <int dim>
void Triangulation<dim>::execute_coarsening_and_refinement () {
prepare_coarsening_and_refinement ();
};
-
-
#if deal_II_dimension == 1
template <>
break;
};
};
-
-
- // check how much space is needed
+// check how much space is needed
// on every level
// we need not check the highest
// level since either
};
- // Do REFINEMENT
+// Do REFINEMENT
// on every level; exclude highest level as
// above
};
- // re-compute number of lines
+// re-compute number of lines
update_number_cache ();
#ifdef DEBUG
#endif
-
#if deal_II_dimension == 2
template <>
};
-
- // check how much space is needed
+// check how much space is needed
// on every level
// we need not check the highest
// level since either
= count_if (levels[level+1]->quads.used.begin(),
levels[level+1]->quads.used.end(),
bind2nd (equal_to<bool>(), true));
-
-
- // reserve space for the used_cells
+
+
+// reserve space for the used_cells
// cells already existing on the next
// higher level as well as for the
// 4*flagged_cells that will be created
};
- // Do REFINEMENT
+// Do REFINEMENT
// on every level; exclude highest level as
// above
new_lines[10]->set_boundary_indicator (255);
new_lines[11]->set_boundary_indicator (255);
-
- // finally add the four new cells!
+
+// finally add the four new cells!
// search for next unused cell
// the four children have to be put
subcells[i] = next_unused_cell;
++next_unused_cell;
};
-
-
-
- cell->set_children (subcells[0]->index());
+
+
+cell->set_children (subcells[0]->index());
subcells[0]->set (Quad(new_lines[0]->index(), new_lines[8]->index(),
new_lines[10]->index(), new_lines[7]->index()));
subcells[1]->clear_user_pointer ();
- subcells[2]->set (Quad(new_lines[11]->index(), new_lines[3]->index(),
+subcells[2]->set (Quad(new_lines[11]->index(), new_lines[3]->index(),
new_lines[4]->index(), new_lines[9]->index()));
subcells[2]->set_used_flag();
subcells[2]->clear_children();
subcells[2]->clear_user_pointer ();
-
- subcells[3]->set (Quad(new_lines[10]->index(), new_lines[9]->index(),
+
+subcells[3]->set (Quad(new_lines[10]->index(), new_lines[9]->index(),
new_lines[5]->index(), new_lines[6]->index()));
subcells[3]->set_used_flag();
subcells[3]->clear_children();
#endif
-
#if deal_II_dimension == 3
template <>
};
- // first clear user flags for
+// first clear user flags for
// quads and lines; we're gonna
// use them to flag which lines
// and quads need refinement
line->clear_user_flag();
for (quad_iterator quad=begin_quad(); quad!=end_quad(); ++quad)
quad->clear_user_flag();
-
- // check how much space is needed
+// check how much space is needed
// on every level
// we need not check the highest
// level since either
needed_lines += 2;
needed_vertices += 1;
};
-
-
- // count number of used cells on
+
+
+// count number of used cells on
// the next higher level
const unsigned int used_cells
= count_if (levels[level+1]->quads.used.begin(),
levels[level+1]->quads.used.end(),
bind2nd (equal_to<bool>(), true));
-
-
- // reserve space for the used_cells
+
+
+// reserve space for the used_cells
// cells already existing on the next
// higher level as well as for the
// 8*flagged_cells that will be created
};
- ///////////////////////////////////////////
+///////////////////////////////////////////
// Before we start with the actual
// refinement, we do some sanity checks if
// in debug mode. especially, we try to
};
- ///////////////////////////////////////
+///////////////////////////////////////
// now refine marked quads
///////////////////////////////////////
for (unsigned int level=0; level!=levels.size()-1; ++level)
};
-
- // now for the quads. again, first
+// now for the quads. again, first
// collect some data about the
// indices of the lines, with
// the following numbering:
// compute average
vertices[next_unused_vertex] /= 26;
-
-
- // now that we created the right
+
+
+// now that we created the right
// point, make up the six
// lines interior to the quad
// (++ takes care of the end of
};
-
- // now for the quads. again, first
+// now for the quads. again, first
// collect some data about the
// indices of the lines, with
// the following numbering:
};
- /////////////////////////////////
+/////////////////////////////////
// create the eight new hexes
//
// again first collect some data.
hex->face(5)->child_index(2),
hex->face(5)->child_index(3)
};
-
-
- // find some space for the eight
+
+
+// find some space for the eight
// newly to be created hexes.
// note that there should
// always be eight consecutive
quad_indices[10],
quad_indices[31],
quad_indices[34]));
-
-
- for (unsigned int i=0; i<8; ++i)
+
+
+for (unsigned int i=0; i<8; ++i)
{
new_hexes[i]->set_used_flag();
new_hexes[i]->clear_user_flag();
};
- /////////////////////////////////
+/////////////////////////////////
// now the only thing still to be
// done is setting neighborship
// information.
new_hexes[7]->set_neighbor (5, neighbor_cells[5][2]);
- // now we need to set the neighbors
+// now we need to set the neighbors
// neighborship information; this
// is only necessary if the
// neighboring cell is refined,
new_hexes[child_on_face_and_subface[nb][subface]]);
};
-
-
- // note that the refinement
+
+// note that the refinement
// flag was already cleared at
// the beginning of this loop
};
};
-
#endif
-
-
template <int dim>
void Triangulation<dim>::execute_coarsening () {
// loop over all cells. Flag all cells of
cell->child(child)->clear_coarsen_flag();
};
};
-
- // now do the actual coarsening step. Since
+
+// now do the actual coarsening step. Since
// the loop goes over used cells only we need
// not worry about deleting some cells since
// the ++operator will then just hop over
};
-
-
-
template <int dim>
void Triangulation<dim>::prepare_refinement_dim_dependent ()
{};
-
#if deal_II_dimension == 3
template <>
cell->line(line)->set_user_flag();
- // now check whether there are cells with
+// now check whether there are cells with
// lines that are more than once refined
// or that will be more than once
// refined. The first thing should never
#endif
-
template <int dim>
void Triangulation<dim>::fix_coarsen_flags () {
// loop over all cells. Flag all cells of
};
};
};
-
-
template <int dim>
save_refine_flags (flags_before[1]);
- // do nothing in 1d, except setting the
+// do nothing in 1d, except setting the
// coarsening flags correctly
if (dim == 1)
{
==GeometryInfo<dim>::children_per_cell)
not_active_neighbor_will_be_coarsened=true;
}
-
-
- if ((neighbor->active() &&
+
+
+if ((neighbor->active() &&
neighbor->refine_flag_set()) ||
!not_active_neighbor_will_be_coarsened)
++count;
} // if (!cell->active())
} // for (all cells)
} // if (smooth_grid & ...)
-
- //////////////////////////////////////
+
+//////////////////////////////////////
// STEP 1:
// eliminate refined islands in the
// interior and at the boundary. since
};
-
#if deal_II_dimension == 1
template <>
};
};
-
- // delete the vertex which will not be
+
+// delete the vertex which will not be
// needed anymore. This vertex is the
// second of the second line of the
// first child
cell->child(child)->clear_user_flag();
cell->child(child)->clear_used_flag();
};
-
-
- // delete pointer to children
+
+
+// delete pointer to children
cell->set_children (-1);
cell->clear_user_flag();
};
cell->child(child)->clear_user_flag();
cell->child(child)->clear_used_flag();
};
-
-
- // delete pointer to children
+
+
+// delete pointer to children
cell->set_children (-1);
cell->clear_user_flag();
};
#endif
-
#if deal_II_dimension == 3
cell->child(child)->clear_user_flag();
cell->child(child)->clear_used_flag();
};
-
-
- // delete pointer to children
+
+
+// delete pointer to children
cell->clear_children ();
cell->clear_user_flag();
};
};
-
- // now, if the lines are not marked as
+
+// now, if the lines are not marked as
// needed, we may delete their children
// and the midpoint
map<line_iterator,bool>::iterator line_and_flag;
#endif
-
template <int dim>
void Triangulation<dim>::write_bool_vector (const unsigned int magic_number1,
const vector<bool> &v,
};
-
template <int dim>
void Triangulation<dim>::read_bool_vector (const unsigned int magic_number1,
vector<bool> &v,
};
-
-
template <int dim>
void Triangulation<dim>::update_number_cache_lines ()
{
};
-
#if deal_II_dimension == 1
template <>
};
-
-
-
// explicit instantiations
template class Triangulation<deal_II_dimension>;
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+//---------------------------- tria_accessor.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- tria_accessor.cc ---------------------------
#include <grid/tria.h>
#include <cmath>
-
-
-
-
/*------------------------ Functions: LineAccessor ---------------------------*/
template <int dim>
};
-
template <int dim>
int TriaObjectAccessor<1, dim>::vertex_index (const unsigned int i) const {
Assert (i<2, ExcIndexRange(i,0,2));
};
-
template <int dim>
Point<dim> &
TriaObjectAccessor<1, dim>::vertex (const unsigned int i) const {
};
-
template <int dim>
void TriaObjectAccessor<1, dim>::set_used_flag () const {
Assert (state() == valid, ExcDereferenceInvalidObject());
tria->levels[present_level]->lines.used[present_index] = true;
};
-
template <int dim>
};
-
template <int dim>
void TriaObjectAccessor<1, dim>::recursively_set_user_flag () const {
set_user_flag ();
};
-
template <int dim>
void TriaObjectAccessor<1, dim>::recursively_clear_user_flag () const {
clear_user_flag ();
};
-
template <int dim>
void TriaObjectAccessor<1, dim>::set_user_pointer (void *p) const {
Assert (used(), ExcCellNotUsed());
};
-
template <int dim>
void TriaObjectAccessor<1, dim>::clear_user_pointer () const {
Assert (used(), ExcCellNotUsed());
};
-
template <int dim>
void * TriaObjectAccessor<1, dim>::user_pointer () const {
Assert (used(), ExcCellNotUsed());
return tria->levels[present_level]->lines.user_pointers[present_index];
};
-
+
template <int dim>
void TriaObjectAccessor<1, dim>::set_children (const int index) const {
};
-
template <int dim>
void TriaObjectAccessor<1, dim>::clear_children () const {
set_children (-1);
};
-
template <int dim>
unsigned char TriaObjectAccessor<1, dim>::boundary_indicator () const {
Assert (dim>=2, ExcNotUsefulForThisDimension());
};
-
template <int dim>
void TriaObjectAccessor<1, dim>::set_boundary_indicator (unsigned char boundary_ind) const {
Assert (dim>=2, ExcNotUsefulForThisDimension());
};
-
template <int dim>
bool TriaObjectAccessor<1, dim>::at_boundary () const {
// error checking is done
};
-
template <int dim>
double TriaObjectAccessor<1, dim>::diameter () const {
return sqrt((vertex(1)-vertex(0)).square());
};
-
template <int dim>
Point<dim> TriaObjectAccessor<1, dim>::center () const {
return (vertex(1)+vertex(0))/2.;
};
-
template <int dim>
Point<dim> TriaObjectAccessor<1, dim>::barycenter () const {
return (vertex(1)+vertex(0))/2.;
};
-
template <int dim>
double TriaObjectAccessor<1, dim>::measure () const {
return sqrt((vertex(1)-vertex(0)).square());
};
-
template <int dim>
unsigned int TriaObjectAccessor<1, dim>::number_of_children () const {
if (!has_children())
};
-
-
/*------------------------ Functions: QuadAccessor ---------------------------*/
template <int dim>
};
-
template <int dim>
int TriaObjectAccessor<2, dim>::vertex_index (const unsigned int corner) const {
Assert (corner<4, ExcIndexRange(corner,0,4));
};
-
template <int dim>
Point<dim> &
TriaObjectAccessor<2, dim>::vertex (const unsigned int i) const {
};
-
-
template <int dim>
void
TriaObjectAccessor<2, dim>::set_used_flag () const {
Assert (state() == valid, ExcDereferenceInvalidObject());
tria->levels[present_level]->quads.used[present_index] = true;
};
-
template <int dim>
};
-
template <int dim>
void TriaObjectAccessor<2, dim>::recursively_set_user_flag () const {
set_user_flag ();
};
-
template <int dim>
void TriaObjectAccessor<2, dim>::recursively_clear_user_flag () const {
clear_user_flag ();
};
-
template <int dim>
void TriaObjectAccessor<2, dim>::set_user_pointer (void *p) const {
Assert (used(), ExcCellNotUsed());
};
-
template <int dim>
void TriaObjectAccessor<2, dim>::clear_user_pointer () const {
Assert (used(), ExcCellNotUsed());
};
-
template <int dim>
void * TriaObjectAccessor<2, dim>::user_pointer () const {
Assert (used(), ExcCellNotUsed());
};
-
template <int dim>
void TriaObjectAccessor<2, dim>::set_children (const int index) const {
Assert (used(), ExcCellNotUsed());
};
-
template <int dim>
void TriaObjectAccessor<2, dim>::clear_children () const {
set_children (-1);
};
-
template <int dim>
unsigned char TriaObjectAccessor<2, dim>::boundary_indicator () const {
Assert (dim>=3, ExcNotUsefulForThisDimension());
};
-
template <int dim>
void TriaObjectAccessor<2, dim>::set_boundary_indicator (unsigned char boundary_ind) const {
Assert (dim>=3, ExcNotUsefulForThisDimension());
};
-
template <int dim>
bool TriaObjectAccessor<2, dim>::at_boundary () const {
// error checking is done
};
-
template <int dim>
double TriaObjectAccessor<2, dim>::diameter () const {
return sqrt(max((vertex(2)-vertex(0)).square(),
};
-
template <int dim>
Point<dim> TriaObjectAccessor<2, dim>::center () const {
return (vertex(0)+vertex(1)+vertex(2)+vertex(3))/4.;
};
-
#if deal_II_dimension == 2
template <>
};
-
-
template <>
double TriaObjectAccessor<2, 2>::measure () const {
// the evaluation of the formulae
#endif
-
#if deal_II_dimension == 3
template <>
};
-
-
template <>
double TriaObjectAccessor<2, 3>::measure () const {
// the evaluation of the formulae
};
-
-
-
/*------------------------ Functions: TriaObjectAccessor ---------------------------*/
template <int dim>
};
-
template <int dim>
int TriaObjectAccessor<3, dim>::vertex_index (const unsigned int corner) const {
Assert (corner<8, ExcIndexRange(corner,0,8));
};
-
template <int dim>
Point<dim> &
TriaObjectAccessor<3, dim>::vertex (const unsigned int i) const {
};
-
template <int dim>
void TriaObjectAccessor<3, dim>::set_used_flag () const {
Assert (state() == valid, ExcDereferenceInvalidObject());
tria->levels[present_level]->hexes.used[present_index] = true;
};
-
template <int dim>
};
-
-
template <int dim>
void TriaObjectAccessor<3, dim>::recursively_set_user_flag () const {
set_user_flag ();
};
-
template <int dim>
void TriaObjectAccessor<3, dim>::recursively_clear_user_flag () const {
clear_user_flag ();
};
-
template <int dim>
void TriaObjectAccessor<3, dim>::set_user_pointer (void *p) const {
Assert (used(), ExcCellNotUsed());
};
-
template <int dim>
void TriaObjectAccessor<3, dim>::clear_user_pointer () const {
Assert (used(), ExcCellNotUsed());
};
-
template <int dim>
void * TriaObjectAccessor<3, dim>::user_pointer () const {
Assert (used(), ExcCellNotUsed());
};
-
template <int dim>
void TriaObjectAccessor<3, dim>::set_children (const int index) const {
Assert (used(), ExcCellNotUsed());
};
-
template <int dim>
void TriaObjectAccessor<3, dim>::clear_children () const {
set_children (-1);
};
-
template <int dim>
unsigned char TriaObjectAccessor<3, dim>::boundary_indicator () const {
Assert (dim<4, ExcNotUsefulForThisDimension());
};
-
template <int dim>
void TriaObjectAccessor<3, dim>::set_boundary_indicator (unsigned char boundary_ind) const {
Assert (dim<4, ExcNotUsefulForThisDimension());
};
-
template <int dim>
bool TriaObjectAccessor<3, dim>::at_boundary () const {
// error checking is done
};
-
template <int dim>
double TriaObjectAccessor<3, dim>::diameter () const {
return sqrt(max( max((vertex(6)-vertex(0)).square(),
};
-
template <int dim>
Point<dim> TriaObjectAccessor<3, dim>::center () const {
return (vertex(0)+vertex(1)+vertex(2)+vertex(3)+
};
-
#if deal_II_dimension == 3
template <>
};
-
-
template <>
double TriaObjectAccessor<3, 3>::measure () const {
/*
};
-
-
-
/*------------------------ Functions: CellAccessor<1> -----------------------*/
};
-
template <>
unsigned char CellAccessor<1>::material_id () const {
Assert (used(), ExcCellNotUsed());
};
-
template <>
void CellAccessor<1>::set_material_id (const unsigned char mat_id) const {
Assert (used(), ExcCellNotUsed());
};
-
template <>
unsigned char CellAccessor<2>::material_id () const {
Assert (used(), ExcCellNotUsed());
};
-
template <>
void CellAccessor<2>::set_material_id (const unsigned char mat_id) const {
Assert (used(), ExcCellNotUsed());
#endif
-
/*------------------------ Functions: CellAccessor<3> -----------------------*/
};
-
template <>
unsigned char CellAccessor<3>::material_id () const {
Assert (used(), ExcCellNotUsed());
};
-
template <>
void CellAccessor<3>::set_material_id (const unsigned char mat_id) const {
Assert (used(), ExcCellNotUsed());
};
-
template <int dim>
unsigned int CellAccessor<dim>::neighbor_of_neighbor (const unsigned int neighbor) const
{
};
-
template <int dim>
bool CellAccessor<dim>::at_boundary (const unsigned int i) const {
Assert (used(), ExcCellNotUsed());
};
-
-
-
// explicit instantiations
template class TriaAccessor<deal_II_dimension>;
template class TriaObjectAccessor<1, deal_II_dimension>;
#endif
-
-
-
-
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+//---------------------------- tria_boundary.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- tria_boundary.cc ---------------------------
#include <grid/tria_boundary.h>
#include <cmath>
-
template <int dim>
Boundary<dim>::~Boundary ()
{};
-
-
template <int dim>
Point<dim>
Boundary<dim>::get_new_point_on_quad (const typename Triangulation<dim>::quad_iterator &) const
};
-
template <int dim>
Point<dim>
StraightBoundary<dim>::get_new_point_on_line (const typename Triangulation<dim>::line_iterator &line) const
};
-
#if deal_II_dimension < 3
template <int dim>
#endif
-
-
// explicit instantiations
template class Boundary<deal_II_dimension>;
template class StraightBoundary<deal_II_dimension>;
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+//---------------------------- tria_boundary_lib.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- tria_boundary_lib.cc ---------------------------
+
#include <grid/tria_boundary_lib.h>
#include <grid/tria.h>
#include <cmath>
-
-
template <int dim>
HyperBallBoundary<dim>::HyperBallBoundary (const Point<dim> p,
const double radius) :
{};
-
template <int dim>
Point<dim>
HyperBallBoundary<dim>::get_new_point_on_line (const typename Triangulation<dim>::line_iterator &line) const
};
-
#if deal_II_dimension == 1
template <>
#endif
-
template <int dim>
Point<dim>
HyperBallBoundary<dim>::
};
-
template <int dim>
Point<dim>
HyperBallBoundary<dim>::get_center () const
};
-
template <int dim>
double
HyperBallBoundary<dim>::get_radius () const
};
-
-
template <int dim>
HalfHyperBallBoundary<dim>::HalfHyperBallBoundary (const Point<dim> center,
const double radius) :
{};
-
template <int dim>
Point<dim>
HalfHyperBallBoundary<dim>::
};
-
-
#if deal_II_dimension == 1
template <>
};
-
template <int dim>
HyperShellBoundary<dim>::HyperShellBoundary (const Point<dim> ¢er) :
center (center)
};
-
#if deal_II_dimension == 1
template <>
#endif
-
template <int dim>
Point<dim>
HyperShellBoundary<dim>::
};
-
-
-
// explicit instantiations
template class HyperBallBoundary<deal_II_dimension>;
template class HalfHyperBallBoundary<deal_II_dimension>;
-// $Id$
+//---------------------------- mg_base.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- mg_base.cc ---------------------------
+
#include <multigrid/mg_base.h>
#include <multigrid/mg_smoother.h>
#include <cmath>
-
//TODO: this function is only for debugging purposes and should be removed sometimes
template<class VECTOR>
static
}
-
//////////////////////////////////////////////////////////////////////
{};
-
MGBase::MGBase(const MGTransferBase &transfer,
const unsigned minlevel,
const unsigned maxlevel)
};
-
void
MGBase::vcycle(const MGSmootherBase &pre_smooth,
const MGSmootherBase &post_smooth,
};
-
void
MGBase::level_mgstep(const unsigned int level,
const MGSmootherBase &pre_smooth,
{};
-
//////////////////////////////////////////////////////////////////////
MGTransferBase::~MGTransferBase()
{};
-
-
-
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
-
+//---------------------------- mg_dof_accessor.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- mg_dof_accessor.cc ---------------------------
#include <dofs/dof_levels.h>
#include <lac/sparse_matrix.h>
-
-
-
-
/* ------------------------ MGDoFLineAccessor --------------------------- */
template <int dim>
{};
-
template <int dim>
unsigned int MGDoFObjectAccessor<1, dim>::mg_dof_index (const unsigned int i) const
{
};
-
-
-
template <int dim>
void MGDoFObjectAccessor<1, dim>::set_mg_dof_index (const unsigned int i,
const unsigned int index) const
};
-
-
template <int dim>
unsigned int MGDoFObjectAccessor<1, dim>::mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i) const
};
-
template <int dim>
void MGDoFObjectAccessor<1, dim>::set_mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i,
};
-
template <int dim>
void
MGDoFObjectAccessor<1, dim>::get_mg_dof_indices (vector<unsigned int> &dof_indices) const
};
-
template <int dim>
template <typename number>
void
};
-
template <int dim>
TriaIterator<dim,MGDoFObjectAccessor<1, dim> >
MGDoFObjectAccessor<1, dim>::child (const unsigned int i) const
};
-
template <int dim>
void
MGDoFObjectAccessor<1, dim>::copy_from (const MGDoFObjectAccessor<1, dim> &a)
};
-
-
/* ------------------------ MGDoFQuadAccessor --------------------------- */
template <int dim>
{};
-
template <int dim>
inline
unsigned int MGDoFObjectAccessor<2, dim>::mg_dof_index (const unsigned int i) const
};
-
template <int dim>
void MGDoFObjectAccessor<2, dim>::set_mg_dof_index (const unsigned int i,
const unsigned int index) const
};
-
template <int dim>
inline
unsigned int MGDoFObjectAccessor<2, dim>::mg_vertex_dof_index (const unsigned int vertex,
};
-
template <int dim>
void MGDoFObjectAccessor<2, dim>::set_mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i,
};
-
template <int dim>
void
MGDoFObjectAccessor<2, dim>::get_mg_dof_indices (vector<unsigned int> &dof_indices) const
};
-
template <int dim>
template <typename number>
void
};
-
template <int dim>
TriaIterator<dim,MGDoFObjectAccessor<1, dim> >
MGDoFObjectAccessor<2, dim>::line (const unsigned int i) const
};
-
template <int dim>
TriaIterator<dim,MGDoFObjectAccessor<2, dim> >
MGDoFObjectAccessor<2, dim>::child (const unsigned int i) const
};
-
template <int dim>
void
MGDoFObjectAccessor<2, dim>::copy_from (const MGDoFObjectAccessor<2, dim> &a)
};
-
-
/* ------------------------ MGDoFHexAccessor --------------------------- */
template <int dim>
{};
-
template <int dim>
inline
unsigned int MGDoFObjectAccessor<3, dim>::mg_dof_index (const unsigned int i) const
};
-
template <int dim>
void MGDoFObjectAccessor<3, dim>::set_mg_dof_index (const unsigned int i,
const unsigned int index) const
};
-
template <int dim>
inline
unsigned int MGDoFObjectAccessor<3, dim>::mg_vertex_dof_index (const unsigned int vertex,
};
-
template <int dim>
void MGDoFObjectAccessor<3, dim>::set_mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i,
};
-
template <int dim>
void
MGDoFObjectAccessor<3, dim>::get_mg_dof_indices (vector<unsigned int> &dof_indices) const
};
-
template <int dim>
template <typename number>
void
};
-
template <int dim>
TriaIterator<dim,MGDoFObjectAccessor<1, dim> >
MGDoFObjectAccessor<3, dim>::line (const unsigned int i) const {
};
-
template <int dim>
TriaIterator<dim,MGDoFObjectAccessor<2, dim> >
MGDoFObjectAccessor<3, dim>::quad (const unsigned int i) const {
};
-
template <int dim>
TriaIterator<dim,MGDoFObjectAccessor<3, dim> >
MGDoFObjectAccessor<3, dim>::child (const unsigned int i) const {
};
-
template <int dim>
void
MGDoFObjectAccessor<3, dim>::copy_from (const MGDoFObjectAccessor<3, dim> &a) {
};
-
-
-
/*------------------------- Functions: MGDoFCellAccessor -----------------------*/
template <int dim>
};
-
template <int dim>
TriaIterator<dim,MGDoFCellAccessor<dim> >
MGDoFCellAccessor<dim>::child (const unsigned int i) const {
};
-
#if deal_II_dimension == 1
template <>
#endif
-
#if deal_II_dimension == 2
template <>
#endif
-
-
#if deal_II_dimension == 3
template <>
#endif
-
-
-
// explicit instantiations
template
Vector<float> &dof_values) const;
-
#if deal_II_dimension >= 2
template
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+//---------------------------- mg_dof_handler.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- mg_dof_handler.cc ---------------------------
#include <dofs/dof_levels.h>
#include <algorithm>
-
/* ------------------------ MGVertexDoFs ----------------------------------- */
template <int dim>
{};
-
template <int dim>
void MGDoFHandler<dim>::MGVertexDoFs::init (const unsigned int cl,
const unsigned int fl,
};
-
template <int dim>
MGDoFHandler<dim>::MGVertexDoFs::~MGVertexDoFs () {
delete[] indices;
};
-
template <int dim>
inline
unsigned int MGDoFHandler<dim>::MGVertexDoFs::get_coarsest_level () const {
};
-
template <int dim>
inline
unsigned int MGDoFHandler<dim>::MGVertexDoFs::get_finest_level () const {
};
-
-
-
-
/* ------------------------ MGDoFHandler ------------------------------------- */
template <int dim>
{};
-
template <int dim>
MGDoFHandler<dim>::~MGDoFHandler () {};
-
-
-
-
#if deal_II_dimension == 1
template <>
};
-
template <>
MGDoFHandler<1>::cell_iterator
MGDoFHandler<1>::begin (const unsigned int level) const {
};
-
template <>
MGDoFHandler<1>::active_cell_iterator
MGDoFHandler<1>::begin_active (const unsigned int level) const {
};
-
template <>
MGDoFHandler<1>::raw_cell_iterator
MGDoFHandler<1>::end () const {
};
-
-
template <>
MGDoFHandler<1>::raw_cell_iterator
MGDoFHandler<1>::last_raw () const {
};
-
template <>
MGDoFHandler<1>::raw_cell_iterator
MGDoFHandler<1>::last_raw (const unsigned int level) const {
};
-
template <>
MGDoFHandler<1>::cell_iterator
MGDoFHandler<1>::last () const {
};
-
template <>
MGDoFHandler<1>::cell_iterator
MGDoFHandler<1>::last (const unsigned int level) const {
};
-
template <>
MGDoFHandler<1>::active_cell_iterator
MGDoFHandler<1>::last_active () const {
};
-
template <>
MGDoFHandler<1>::active_cell_iterator
MGDoFHandler<1>::last_active (const unsigned int level) const {
};
-
template <>
MGDoFDimensionInfo<1>::raw_face_iterator
MGDoFHandler<1>::begin_raw_face (const unsigned int) const {
};
-
template <>
MGDoFDimensionInfo<1>::face_iterator
MGDoFHandler<1>::begin_face (const unsigned int) const {
};
-
template <>
MGDoFDimensionInfo<1>::active_face_iterator
MGDoFHandler<1>::begin_active_face (const unsigned int) const {
};
-
template <>
MGDoFDimensionInfo<1>::raw_face_iterator
MGDoFHandler<1>::end_face () const {
};
-
template <>
MGDoFDimensionInfo<1>::raw_face_iterator
MGDoFHandler<1>::last_raw_face () const {
};
-
template <>
MGDoFDimensionInfo<1>::raw_face_iterator
MGDoFHandler<1>::last_raw_face (const unsigned int) const {
};
-
template <>
MGDoFDimensionInfo<1>::face_iterator
MGDoFHandler<1>::last_face () const {
};
-
template <>
MGDoFDimensionInfo<1>::face_iterator
MGDoFHandler<1>::last_face (const unsigned int) const {
};
-
template <>
MGDoFDimensionInfo<1>::active_face_iterator
MGDoFHandler<1>::last_active_face () const {
};
-
template <>
MGDoFDimensionInfo<1>::active_face_iterator
MGDoFHandler<1>::last_active_face (const unsigned int) const {
};
-
-
template <>
MGDoFHandler<1>::raw_quad_iterator
MGDoFHandler<1>::begin_raw_quad (const unsigned int) const {
};
-
template <>
MGDoFHandler<1>::quad_iterator
MGDoFHandler<1>::begin_quad (const unsigned int) const {
};
-
template <>
MGDoFHandler<1>::active_quad_iterator
MGDoFHandler<1>::begin_active_quad (const unsigned int) const {
};
-
template <>
MGDoFHandler<1>::raw_quad_iterator
MGDoFHandler<1>::end_quad () const {
};
-
template <>
MGDoFHandler<1>::raw_quad_iterator
MGDoFHandler<1>::last_raw_quad (const unsigned int) const {
};
-
template <>
MGDoFHandler<1>::active_quad_iterator
MGDoFHandler<1>::last_active_quad (const unsigned int) const {
};
-
template <>
MGDoFHandler<1>::raw_quad_iterator
MGDoFHandler<1>::last_raw_quad () const {
};
-
template <>
MGDoFHandler<1>::quad_iterator
MGDoFHandler<1>::last_quad () const {
};
-
template <>
MGDoFHandler<1>::active_quad_iterator
MGDoFHandler<1>::last_active_quad () const {
};
-
template <>
MGDoFHandler<1>::hex_iterator
MGDoFHandler<1>::begin_hex (const unsigned int) const {
};
-
template <>
MGDoFHandler<1>::active_hex_iterator
MGDoFHandler<1>::begin_active_hex (const unsigned int) const {
};
-
template <>
MGDoFHandler<1>::raw_hex_iterator
MGDoFHandler<1>::end_hex () const {
};
-
template <>
MGDoFHandler<1>::raw_hex_iterator
MGDoFHandler<1>::last_raw_hex (const unsigned int) const {
};
-
template <>
MGDoFHandler<1>::active_hex_iterator
MGDoFHandler<1>::last_active_hex (const unsigned int) const {
};
-
template <>
MGDoFHandler<1>::raw_hex_iterator
MGDoFHandler<1>::last_raw_hex () const {
};
-
template <>
MGDoFHandler<1>::hex_iterator
MGDoFHandler<1>::last_hex () const {
};
-
template <>
MGDoFHandler<1>::active_hex_iterator
MGDoFHandler<1>::last_active_hex () const {
#endif
-
#if deal_II_dimension == 2
template <>
};
-
template <>
MGDoFHandler<2>::cell_iterator
MGDoFHandler<2>::begin (const unsigned int level) const {
};
-
template <>
MGDoFHandler<2>::active_cell_iterator
MGDoFHandler<2>::begin_active (const unsigned int level) const {
};
-
template <>
MGDoFHandler<2>::raw_cell_iterator
MGDoFHandler<2>::end () const {
};
-
template <>
MGDoFHandler<2>::raw_cell_iterator
MGDoFHandler<2>::last_raw () const {
};
-
template <>
MGDoFHandler<2>::raw_cell_iterator
MGDoFHandler<2>::last_raw (const unsigned int level) const {
};
-
template <>
MGDoFHandler<2>::cell_iterator
MGDoFHandler<2>::last () const {
};
-
template <>
MGDoFHandler<2>::cell_iterator
MGDoFHandler<2>::last (const unsigned int level) const {
};
-
template <>
MGDoFHandler<2>::active_cell_iterator
MGDoFHandler<2>::last_active () const {
};
-
template <>
MGDoFHandler<2>::active_cell_iterator
MGDoFHandler<2>::last_active (const unsigned int level) const {
};
-
template <>
MGDoFDimensionInfo<2>::face_iterator
MGDoFHandler<2>::begin_face (const unsigned int level) const {
};
-
template <>
MGDoFDimensionInfo<2>::active_face_iterator
MGDoFHandler<2>::begin_active_face (const unsigned int level) const {
};
-
template <>
MGDoFDimensionInfo<2>::raw_face_iterator
MGDoFHandler<2>::end_face () const {
};
-
template <>
MGDoFDimensionInfo<2>::raw_face_iterator
MGDoFHandler<2>::last_raw_face () const {
};
-
template <>
MGDoFDimensionInfo<2>::raw_face_iterator
MGDoFHandler<2>::last_raw_face (const unsigned int level) const {
};
-
template <>
MGDoFDimensionInfo<2>::face_iterator
MGDoFHandler<2>::last_face () const {
};
-
template <>
MGDoFDimensionInfo<2>::face_iterator
MGDoFHandler<2>::last_face (const unsigned int level) const {
};
-
template <>
MGDoFDimensionInfo<2>::active_face_iterator
MGDoFHandler<2>::last_active_face () const {
};
-
template <>
MGDoFDimensionInfo<2>::active_face_iterator
MGDoFHandler<2>::last_active_face (const unsigned int level) const {
};
-
template <>
MGDoFHandler<2>::raw_hex_iterator
MGDoFHandler<2>::begin_raw_hex (const unsigned int) const {
};
-
template <>
MGDoFHandler<2>::hex_iterator
MGDoFHandler<2>::begin_hex (const unsigned int) const {
};
-
template <>
MGDoFHandler<2>::active_hex_iterator
MGDoFHandler<2>::begin_active_hex (const unsigned int) const {
};
-
template <>
MGDoFHandler<2>::raw_hex_iterator
MGDoFHandler<2>::end_hex () const {
};
-
template <>
MGDoFHandler<2>::raw_hex_iterator
MGDoFHandler<2>::last_raw_hex (const unsigned int) const {
};
-
template <>
MGDoFHandler<2>::active_hex_iterator
MGDoFHandler<2>::last_active_hex (const unsigned int) const {
};
-
template <>
MGDoFHandler<2>::raw_hex_iterator
MGDoFHandler<2>::last_raw_hex () const {
};
-
template <>
MGDoFHandler<2>::hex_iterator
MGDoFHandler<2>::last_hex () const {
};
-
template <>
MGDoFHandler<2>::active_hex_iterator
MGDoFHandler<2>::last_active_hex () const {
};
-
#endif
-
-
#if deal_II_dimension == 3
template <>
};
-
template <>
MGDoFHandler<3>::cell_iterator
MGDoFHandler<3>::begin (const unsigned int level) const {
};
-
template <>
MGDoFHandler<3>::active_cell_iterator
MGDoFHandler<3>::begin_active (const unsigned int level) const {
};
-
template <>
MGDoFHandler<3>::raw_cell_iterator
MGDoFHandler<3>::end () const {
};
-
template <>
MGDoFHandler<3>::raw_cell_iterator
MGDoFHandler<3>::last_raw () const {
};
-
template <>
MGDoFHandler<3>::raw_cell_iterator
MGDoFHandler<3>::last_raw (const unsigned int level) const {
};
-
template <>
MGDoFHandler<3>::cell_iterator
MGDoFHandler<3>::last () const {
};
-
template <>
MGDoFHandler<3>::cell_iterator
MGDoFHandler<3>::last (const unsigned int level) const {
};
-
template <>
MGDoFHandler<3>::active_cell_iterator
MGDoFHandler<3>::last_active () const {
};
-
template <>
MGDoFHandler<3>::active_cell_iterator
MGDoFHandler<3>::last_active (const unsigned int level) const {
};
-
template <>
MGDoFDimensionInfo<3>::face_iterator
MGDoFHandler<3>::begin_face (const unsigned int level) const {
};
-
template <>
MGDoFDimensionInfo<3>::active_face_iterator
MGDoFHandler<3>::begin_active_face (const unsigned int level) const {
};
-
template <>
MGDoFDimensionInfo<3>::raw_face_iterator
MGDoFHandler<3>::end_face () const {
};
-
template <>
MGDoFDimensionInfo<3>::raw_face_iterator
MGDoFHandler<3>::last_raw_face () const {
};
-
template <>
MGDoFDimensionInfo<3>::raw_face_iterator
MGDoFHandler<3>::last_raw_face (const unsigned int level) const {
};
-
template <>
MGDoFDimensionInfo<3>::face_iterator
MGDoFHandler<3>::last_face () const {
};
-
template <>
MGDoFDimensionInfo<3>::face_iterator
MGDoFHandler<3>::last_face (const unsigned int level) const {
};
-
template <>
MGDoFDimensionInfo<3>::active_face_iterator
MGDoFHandler<3>::last_active_face () const {
};
-
template <>
MGDoFDimensionInfo<3>::active_face_iterator
MGDoFHandler<3>::last_active_face (const unsigned int level) const {
#endif
-
-
-
template <int dim>
typename MGDoFHandler<dim>::raw_line_iterator
MGDoFHandler<dim>::begin_raw_line (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFHandler<dim>::line_iterator
MGDoFHandler<dim>::begin_line (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFHandler<dim>::active_line_iterator
MGDoFHandler<dim>::begin_active_line (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFHandler<dim>::raw_quad_iterator
MGDoFHandler<dim>::begin_raw_quad (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFHandler<dim>::quad_iterator
MGDoFHandler<dim>::begin_quad (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFHandler<dim>::active_quad_iterator
MGDoFHandler<dim>::begin_active_quad (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFHandler<dim>::raw_hex_iterator
MGDoFHandler<dim>::begin_raw_hex (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFHandler<dim>::hex_iterator
MGDoFHandler<dim>::begin_hex (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFHandler<dim>::active_hex_iterator
MGDoFHandler<dim>::begin_active_hex (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFHandler<dim>::raw_line_iterator
MGDoFHandler<dim>::end_line () const {
};
-
template <int dim>
typename MGDoFHandler<dim>::raw_quad_iterator
MGDoFHandler<dim>::end_quad () const {
};
-
template <int dim>
typename MGDoFHandler<dim>::raw_hex_iterator
MGDoFHandler<dim>::end_hex () const {
};
-
template <int dim>
typename MGDoFDimensionInfo<dim>::raw_cell_iterator
MGDoFHandler<dim>::end_raw (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFDimensionInfo<dim>::cell_iterator
MGDoFHandler<dim>::end (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFDimensionInfo<dim>::active_cell_iterator
MGDoFHandler<dim>::end_active (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFDimensionInfo<dim>::raw_face_iterator
MGDoFHandler<dim>::end_raw_face (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFDimensionInfo<dim>::face_iterator
MGDoFHandler<dim>::end_face (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFDimensionInfo<dim>::active_face_iterator
MGDoFHandler<dim>::end_active_face (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFDimensionInfo<dim>::raw_line_iterator
MGDoFHandler<dim>::end_raw_line (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFDimensionInfo<dim>::line_iterator
MGDoFHandler<dim>::end_line (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFDimensionInfo<dim>::active_line_iterator
MGDoFHandler<dim>::end_active_line (const unsigned int level) const {
};
-
-
template <int dim>
typename MGDoFDimensionInfo<dim>::raw_quad_iterator
MGDoFHandler<dim>::end_raw_quad (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFDimensionInfo<dim>::quad_iterator
MGDoFHandler<dim>::end_quad (const unsigned int level) const {
};
-
-
template <int dim>
typename MGDoFDimensionInfo<dim>::active_quad_iterator
MGDoFHandler<dim>::end_active_quad (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFDimensionInfo<dim>::raw_hex_iterator
MGDoFHandler<dim>::end_raw_hex (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFDimensionInfo<dim>::hex_iterator
MGDoFHandler<dim>::end_hex (const unsigned int level) const {
};
-
-
template <int dim>
typename MGDoFDimensionInfo<dim>::active_hex_iterator
MGDoFHandler<dim>::end_active_hex (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFHandler<dim>::raw_line_iterator
MGDoFHandler<dim>::last_raw_line (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFHandler<dim>::line_iterator
MGDoFHandler<dim>::last_line (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFHandler<dim>::active_line_iterator
MGDoFHandler<dim>::last_active_line (const unsigned int level) const {
};
-
template <int dim>
typename MGDoFHandler<dim>::raw_quad_iterator
MGDoFHandler<dim>::last_raw_quad (const unsigned int level) const {
};
-
-
template <int dim>
typename MGDoFHandler<dim>::quad_iterator
MGDoFHandler<dim>::last_quad (const unsigned int level) const {
};
-
-
template <int dim>
typename MGDoFHandler<dim>::active_quad_iterator
MGDoFHandler<dim>::last_active_quad (const unsigned int level) const {
};
-
-
template <int dim>
typename MGDoFHandler<dim>::raw_hex_iterator
MGDoFHandler<dim>::last_raw_hex (const unsigned int level) const {
};
-
-
template <int dim>
typename MGDoFHandler<dim>::hex_iterator
MGDoFHandler<dim>::last_hex (const unsigned int level) const {
};
-
-
template <int dim>
typename MGDoFHandler<dim>::active_hex_iterator
MGDoFHandler<dim>::last_active_hex (const unsigned int level) const {
};
-
-
template <int dim>
typename MGDoFHandler<dim>::raw_line_iterator
MGDoFHandler<dim>::last_raw_line () const {
};
-
template <int dim>
typename MGDoFHandler<dim>::raw_quad_iterator
MGDoFHandler<dim>::last_raw_quad () const {
};
-
template <int dim>
typename MGDoFHandler<dim>::raw_hex_iterator
MGDoFHandler<dim>::last_raw_hex () const {
};
-
template <int dim>
typename MGDoFHandler<dim>::line_iterator
MGDoFHandler<dim>::last_line () const {
};
-
template <int dim>
typename MGDoFHandler<dim>::quad_iterator
MGDoFHandler<dim>::last_quad () const {
};
-
template <int dim>
typename MGDoFHandler<dim>::hex_iterator
MGDoFHandler<dim>::last_hex () const {
};
-
template <int dim>
typename MGDoFHandler<dim>::active_line_iterator
MGDoFHandler<dim>::last_active_line () const {
};
-
-
template <int dim>
typename MGDoFHandler<dim>::active_quad_iterator
MGDoFHandler<dim>::last_active_quad () const {
};
-
template <int dim>
typename MGDoFHandler<dim>::active_hex_iterator
MGDoFHandler<dim>::last_active_hex () const {
};
-
-
-
-
//------------------------------------------------------------------
-
-
-
-
-
template <int dim>
void MGDoFHandler<dim>::distribute_dofs (const FiniteElement<dim> &fe,
unsigned int offset)
DoFHandler<dim>::distribute_dofs (fe, offset);
- // reserve space for the MG dof numbers
+// reserve space for the MG dof numbers
reserve_space ();
mg_used_dofs.resize (tria->n_levels(), 0);
};
-
#if deal_II_dimension == 1
template <>
for (unsigned int d=0; d<selected_fe->dofs_per_line; ++d)
line->set_mg_dof_index (d, next_free_dof++);
};
-
- // dofs of quad
+
+// dofs of quad
if (selected_fe->dofs_per_quad > 0)
for (unsigned int d=0; d<selected_fe->dofs_per_quad; ++d)
cell->set_mg_dof_index (d, next_free_dof++);
-
- // note that this cell has been processed
+
+// note that this cell has been processed
cell->set_user_flag ();
return next_free_dof;
#endif
-
#if deal_II_dimension == 3
template <>
for (unsigned int d=0; d<selected_fe->dofs_per_line; ++d)
quad->set_mg_dof_index (d, next_free_dof++);
};
-
- // dofs of cell
+
+// dofs of cell
if (selected_fe->dofs_per_hex > 0)
for (unsigned int d=0; d<selected_fe->dofs_per_hex; ++d)
cell->set_mg_dof_index (d, next_free_dof++);
-
- // note that this cell has been processed
+
+// note that this cell has been processed
cell->set_user_flag ();
return next_free_dof;
#endif
-
-
template <int dim>
unsigned int MGDoFHandler<dim>::n_dofs (const unsigned int level) const {
Assert (level < mg_used_dofs.size(), ExcInvalidLevel(level));
};
-
#if deal_II_dimension == 1
template <>
#endif
-
-
#if deal_II_dimension == 2
template <>
#endif
-
#if deal_II_dimension == 3
template <>
#endif
-
-
#if deal_II_dimension == 1
template <>
#endif
-
#if deal_II_dimension == 2
template <>
// this calls the destructor which
// must free the space
mg_vertex_dofs.clear ();
-
-
- ////////////////////////////
+
+
+////////////////////////////
// CONSTRUCTION
// first allocate space for the
DoFHandler<2>::invalid_dof_index);
};
-
- // now allocate space for the
+
+// now allocate space for the
// vertices. To this end, we need
// to construct as many objects as
// there are vertices and let them
max_level[vertex_index] = cell->level();
};
-
- // now allocate the needed space
+
+// now allocate the needed space
for (unsigned int vertex=0; vertex<tria->vertices.size(); ++vertex)
{
Assert (min_level[vertex] < tria->n_levels(), ExcInternalError());
#endif
-
-
#if deal_II_dimension == 3
template <>
// this calls the destructor which
// must free the space
mg_vertex_dofs.clear ();
-
-
- ////////////////////////////
+
+
+////////////////////////////
// CONSTRUCTION
// first allocate space for the
DoFHandler<3>::invalid_dof_index);
};
-
- // now allocate space for the
+
+// now allocate space for the
// vertices. To this end, we need
// to construct as many objects as
// there are vertices and let them
max_level[vertex_index] = cell->level();
};
-
- // now allocate the needed space
+
+// now allocate the needed space
for (unsigned int vertex=0; vertex<tria->vertices.size(); ++vertex)
{
Assert (min_level[vertex] < tria->n_levels(), ExcInternalError());
-/* $Id$ */
+//---------------------------- mg_dof_tools.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- mg_dof_tools.cc ---------------------------
#include <lac/sparsity_pattern.h>
face < GeometryInfo<dim>::faces_per_cell;
++face)
{
- if ( (! cell->at_boundary(face)) && (cell->neighbor_level(face) == level) )
+ if ( (! cell->at_boundary(face)) &&
+ (static_cast<unsigned int>(cell->neighbor_level(face)) == level) )
{
DoFHandler<dim>::cell_iterator neighbor = cell->neighbor(face);
neighbor->get_dof_indices (dofs_on_other_cell);
-/* $Id$ */
+//---------------------------- mg_smoother.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- mg_smoother.cc ---------------------------
#include <grid/tria.h>
#include <algorithm>
-
//////////////////////////////////////////////////////////////////////
{};
-
-
#if deal_II_dimension == 1
MGSmoother::MGSmoother (const MGDoFHandler<1> &/*mg_dof*/, unsigned int steps)
-// $Id$
+//---------------------------- multigrid.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- multigrid.cc ---------------------------
#include <grid/tria.h>
#include <lac/vector.h>
-
/* --------------------------------- MG ------------------------------------ */
template <int dim>
{};
-
template <int dim>
void
Multigrid<dim>::level_vmult (const unsigned int level,
}
-
-
-
-
/* ----------------------------- MGTransferPrebuilt ------------------------ */
-
MGTransferPrebuilt::~MGTransferPrebuilt ()
{};
-
template <int dim>
void MGTransferPrebuilt::build_matrices (const MGDoFHandler<dim> &mg_dof)
{
prolongation_matrices.clear ();
prolongation_sparsities.reserve (n_levels-1);
prolongation_matrices.reserve (n_levels-1);
-
- // two fields which will store the
+
+// two fields which will store the
// indices of the multigrid dofs
// for a cell and one of its children
vector<unsigned int> dof_indices_mother (dofs_per_cell);
prolongation_matrices[level].reinit (prolongation_sparsities[level]);
- // now actually build the matrices
+// now actually build the matrices
for (MGDoFHandler<dim>::cell_iterator cell=mg_dof.begin(level);
cell != mg_dof.end(level); ++cell)
if (cell->has_children())
};
-
void MGTransferPrebuilt::prolongate (const unsigned int to_level,
Vector<double> &dst,
const Vector<double> &src) const
};
-
void MGTransferPrebuilt::restrict_and_add (const unsigned int from_level,
Vector<double> &dst,
const Vector<double> &src) const
};
-
// explicit instatations
template class Multigrid<deal_II_dimension>;
template
template
void Multigrid<deal_II_dimension>::copy_from_mg (Vector<double>& src) const;
-
+
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+//---------------------------- assembler.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- assembler.cc ---------------------------
#include <numerics/assembler.h>
{};
-
-
template <int dim>
Assembler<dim>::Assembler (Triangulation<dim> *tria,
const int level,
};
-
template <int dim>
void Assembler<dim>::assemble (const Equation<dim> &equation) {
// re-init fe values for this cell
cell_matrix.clear ();
if (assemble_rhs)
cell_vector.clear ();
-
- // fill cell matrix and vector if required
+
+// fill cell matrix and vector if required
DoFHandler<dim>::cell_iterator this_cell (*this);
if (assemble_matrix && assemble_rhs)
equation.assemble (cell_matrix, cell_vector, fe_values, this_cell);
Assert (false, ExcNoAssemblingRequired());
- // get indices of dofs
+// get indices of dofs
vector<unsigned int> dofs (n_dofs);
get_dof_indices (dofs);
rhs_vector(dofs[j]) += cell_vector(j);
};
-
-
-
// explicit instantiations
template class Assembler<deal_II_dimension>;
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+//---------------------------- base.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- base.cc ---------------------------
#include <numerics/assembler.h>
#include <cmath>
-
template <int dim>
ProblemBase<dim>::ProblemBase () :
tria(0),
{};
-
template <int dim>
void ProblemBase<dim>::set_tria_and_dof (Triangulation<dim> *t,
DoFHandler<dim> *d)
};
-
template <int dim>
void ProblemBase<dim>::clear () {
if (tria) { delete tria; tria = 0; };
};
-
template <int dim>
ProblemBase<dim>::~ProblemBase () {};
-
template <int dim>
void ProblemBase<dim>::assemble (const Equation<dim> &equation,
const Quadrature<dim> &quadrature,
};
-
-
template <int dim>
void ProblemBase<dim>::solve ()
{
};
-
-
template <int dim>
void ProblemBase<dim>::fill_data (DataOut<dim> &out) const {
Assert ((tria!=0) && (dof_handler!=0), ExcNoTriaSelected());
};
-
template <int dim>
string ProblemBase<dim>::get_solution_name () const {
return "solution";
};
-
-
-
-
-
// explicit instantiations
template class ProblemBase<deal_II_dimension>;
-/* $Id$ */
-/* Copyright W. Bangerth, Guido Kanschat, Stefan Nauber */
-/* University of Heidelberg, 1998, 1999 */
+//---------------------------- data_io.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- data_io.cc ---------------------------
+
#include <numerics/data_io.h>
#include <dofs/dof_handler.h>
#include <cmath>
-
-
template <int dim>
DataOut_Old<dim>::DataEntry::DataEntry () :
data(0), name(""), units("") {};
-
template <int dim>
DataOut_Old<dim>::DataEntry::DataEntry (const Vector<double> *data,
const string name,
data(data), name(name), units(units) {};
-
-
template <int dim>
DataOut_Old<dim>::DataOut_Old () :
dofs(0) {};
-
template <int dim>
void DataOut_Old<dim>::attach_dof_handler (const DoFHandler<dim> &d) {
dofs = &d;
};
-
template <int dim>
void DataOut_Old<dim>::add_data_vector (const Vector<double> &vec,
const string &name,
};
-
template <int dim>
void DataOut_Old<dim>::clear_data_vectors () {
dof_data.erase (dof_data.begin(), dof_data.end());
};
-
template <int dim>
void DataOut_Old<dim>::write_ucd (ostream &out) const {
Assert (dofs != 0, ExcNoDoFHandlerSelected());
if (is_vertex_dof[i] == true)
++n_vertex_dofs;
};
-
- // write preamble
+
+// write preamble
if (true)
{
/*
};
-
#if deal_II_dimension == 1
template <>
#endif
-
template <int dim>
unsigned int DataOut_Old<dim>::n_boundary_faces () const {
typename DoFHandler<dim>::active_face_iterator face, endf;
};
-
-
#if deal_II_dimension == 1
template <>
AssertThrow (out, ExcIO());
};
-
-
-
template <int dim>
void DataOut_Old<dim>::write_gnuplot (ostream &out, unsigned int accuracy) const
};
- DoFHandler<dim>::active_cell_iterator cell;
+DoFHandler<dim>::active_cell_iterator cell;
DoFHandler<dim>::active_cell_iterator endc = dofs->end();
QTrapez<1> q_trapez;
}
out << endl;
};
-
-
- break;
+
+
+break;
default:
Assert (false, ExcNotImplemented());
}
-
template <int dim>
void DataOut_Old<dim>::write_gnuplot_draft (ostream &out) const
{
};
- DoFHandler<dim>::active_cell_iterator cell;
+DoFHandler<dim>::active_cell_iterator cell;
DoFHandler<dim>::active_cell_iterator endc = dofs->end();
unsigned int cell_index=0;
};
// again: stop drawing
out << endl << endl;
-
-
- break;
+
+
+break;
default:
Assert (false, ExcNotImplemented());
<< " <20, 20, -20> White" << endl
<< "}" << endl
<< endl;
-
-
- // write frame object
+
+
+// write frame object
out << "mesh {" << endl;
DoFHandler<2>::active_cell_iterator cell;
#endif
-
template <int dim>
void DataOut_Old<dim>::write_povray_mesh (ostream &) const {
// this is for all other dimensions that
};
-
-
#if deal_II_dimension == 2
template <>
<< "%%BoundingBox: -5 -5 305 305" << endl;
};
-
- // Make output values local by
+
+// Make output values local by
// copying them to a multiset.
// Perform the necessary turn.
const DoFHandler<2>::active_cell_iterator endc = dofs->end();
cells2.clear();
- // If we want shaded output we can
+// If we want shaded output we can
// do the shading now.
if (cell_shade_p)
{
// more, we use a trick for copying
// that is significantly faster
cells2.swap (cells);
-
- // Next we have to shift and scale
+// Next we have to shift and scale
// a bit so that everything still
// arrives in our bounding box of
// 310x310.
};
- // Now we are ready to output...
+// Now we are ready to output...
for (multiset<DataOut_Old<2>::EpsCellData>::iterator c=cells.begin();
c!=cells.end(); ++c)
{
#endif
-
-
template <int dim>
void DataOut_Old<dim>::write_eps (ostream &,
const EpsOutputData &) const{
};
-
-
template <int dim>
void DataOut_Old<dim>::write_gmv (ostream &out) const
{
<< endl;
- ///////////////////////////////
+///////////////////////////////
// first make up a list of used
// vertices along with their
// coordinates. since dofs have
out << endl;
};
-
- /////////////////////////////////////
+
+/////////////////////////////////////
// now for the cells. this is simpler
// than the above task
if (true)
};
- ///////////////////////////////////////
+///////////////////////////////////////
// data output.
out << "variable" << endl;
};
- // Cell data is the simplest since the order
+// Cell data is the simplest since the order
// already is correct
if (true)
{
AssertThrow (out, ExcIO());
};
-
-
-
template <int dim>
void DataOut_Old<dim>::write (ostream &out,
};
-
template <int dim>
string DataOut_Old<dim>::default_suffix (const OutputFormat output_format)
{
return "";
};
};
-
template <int dim>
};
-
template<int dim>
bool DataOut_Old<dim>::EpsCellData::operator < (const EpsCellData &other) const
{
};
-
template <int dim>
void DataOut_Old<dim>::EpsVertexData::turn(double azi, double ele)
{
// ( 0 0 1 )( 0 sx cx )(z) ( 0*x+ *(cx*y-sx*z)+1*(sx*y+cx*z) )
-
template <int dim>
void DataOut_Old<dim>::EpsCellData::turn(double azi, double ele)
{
};
-
void EpsOutputData::color(const float x,
const float xmax,
const float xmin,
};
-
//explicit instantiations
template class DataOut_Old<deal_II_dimension>;
-/* $Id$ */
+//---------------------------- data_out.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- data_out.cc ---------------------------
#include <base/quadrature_lib.h>
};
-
template <int dim>
void DataOut_DoFData<dim>::add_data_vector (const Vector<double> &vec,
const string &name)
}
-
-
template <int dim>
void DataOut_DoFData<dim>::clear ()
{
};
-
template <int dim>
vector<string> DataOut_DoFData<dim>::get_dataset_names () const
{
};
-
template <int dim>
const vector<typename DataOutBase::Patch<dim> > &
DataOut_DoFData<dim>::get_patches () const
}
-
-
template <int dim>
void DataOut<dim>::build_patches (const unsigned int n_subdivisions,
const unsigned int n_threads_)
#endif
- // before we start the loop:
+// before we start the loop:
// create a quadrature rule that
// actually has the points on this
// patch
};
-
template <int dim>
typename DoFHandler<dim>::cell_iterator
DataOut<dim>::first_cell ()
};
-
template <int dim>
typename DoFHandler<dim>::cell_iterator
DataOut<dim>::next_cell (const typename DoFHandler<dim>::cell_iterator &cell)
};
-
// explicit instantiations
template class DataOut_DoFData<deal_II_dimension>;
template class DataOut<deal_II_dimension>;
-
-/* $Id$ */
+//---------------------------- data_out_stack.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- data_out_stack.cc ---------------------------
+
#include <numerics/data_out_stack.h>
#include <base/quadrature_lib.h>
{};
-
template <int dim>
void DataOutStack<dim>::new_parameter_value (const double p,
const double dp)
};
-
template <int dim>
void DataOutStack<dim>::declare_data_vector (const string &name,
const VectorType vector_type)
};
-
template <int dim>
void DataOutStack<dim>::declare_data_vector (const vector<string> &names,
const VectorType vector_type)
};
-
-
template <int dim>
template <typename number>
void DataOutStack<dim>::add_data_vector (const Vector<number> &vec,
};
-
template <int dim>
void DataOutStack<dim>::build_patches (const unsigned int n_subdivisions)
{
++n_patches;
- // before we start the loop:
+// before we start the loop:
// create a quadrature rule that
// actually has the points on this
// patch, and an object that
default:
Assert (false, ExcNotImplemented());
};
-
- // now fill in the the data values.
+
+// now fill in the the data values.
// note that the required order is
// with highest coordinate running
// fastest, we need to enter each
};
-
template <int dim>
void DataOutStack<dim>::finish_parameter_value ()
{
};
-
template <int dim>
const vector<DataOutBase::Patch<dim+1> > &
DataOutStack<dim>::get_patches () const
};
-
template <int dim>
vector<string> DataOutStack<dim>::get_dataset_names () const
{
};
-
-
// explicit instantiations
template class DataOutStack<deal_II_dimension>;
template void DataOutStack<deal_II_dimension>::add_data_vector (const Vector<double> &vec,
-// $Id$
+//---------------------------- equation.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- equation.cc ---------------------------
+
#include <numerics/assembler.h>
#include <grid/tria_iterator.h>
n_eq(n_equations) {};
-
template <int dim>
void Equation<dim>::assemble (FullMatrix<double> &,
Vector<double> &,
};
-
template <int dim>
void Equation<dim>::assemble (FullMatrix<double> &,
const FEValues<dim> &,
};
-
template <int dim>
void Equation<dim>::assemble (Vector<double> &,
const FEValues<dim> &,
};
-
-
template class Equation<deal_II_dimension>;
-/* $Id$ */
+//---------------------------- error_estimator.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- error_estimator.cc ---------------------------
#include <fe/fe.h>
}
-
template <>
void KellyErrorEstimator<1>::estimate (const DoFHandler<1> &dof,
const Quadrature<0> &,
for (FunctionMap::const_iterator i=neumann_bc.begin(); i!=neumann_bc.end(); ++i)
Assert (i->second->n_components == n_components, ExcInvalidBoundaryFunction());
-
-
- const unsigned int dim=1;
+
+
+const unsigned int dim=1;
// reserve one slot for each cell and set
// it to zero
coefficient->vector_value(cell->vertex(n),
coefficient_values);
};
-
-
- for (unsigned int component=0; component<n_components; ++component)
+
+
+for (unsigned int component=0; component<n_components; ++component)
if (component_mask[component] == true)
{
// get gradient
error(cell_index) = sqrt(error(cell_index));
};
};
-
- // #if deal_II_dimension !=1
+
+// #if deal_II_dimension !=1
#else
FESubfaceValues<dim> fe_subface_values (data.dof.get_fe(),
data.quadrature,
update_gradients);
-
-
- DoFHandler<dim>::active_cell_iterator cell=data.dof.begin_active();
+
+
+DoFHandler<dim>::active_cell_iterator cell=data.dof.begin_active();
// calculate the start cell for this
// thread. the enumeration is choosen
// face: do nothing
if (data.face_integrals[cell->face(face_no)] >=0)
continue;
-
-
- // if the neighboring cell is less
+
+
+// if the neighboring cell is less
// refined than the present one, then
// do nothing since we integrate
// over the subfaces when we visit
data.face_integrals[cell->face(face_no)] = 0;
continue;
};
-
-
-
- if (cell->face(face_no)->has_children() == false)
+
+
+if (cell->face(face_no)->has_children() == false)
// if the face is a regular one, i.e.
// either on the other side there is
// nirvana (face is at boundary), or
};
-
template <int dim>
void KellyErrorEstimator<dim>::estimate (const DoFHandler<dim> &dof,
const Quadrature<dim-1> &quadrature,
for (active_cell_iterator cell=data.dof.begin_active(); cell!=data.endc; ++cell)
for (unsigned int face_no=0; face_no<GeometryInfo<dim>::faces_per_cell; ++face_no)
data.face_integrals[cell->face(face_no)]=-10e20;
-
-
- // split all cells into threads
+
+
+// split all cells into threads
// if multithreading is used
#ifdef DEAL_II_USE_MT
vector<FunData>
fun_data (data.n_threads,
FunData (data,0,&KellyErrorEstimator::estimate_some));
-
-
- // get start cells for each thread
+
+
+// get start cells for each thread
for (unsigned int l=0;l<data.n_threads;++l)
{
fun_data[l].arg2=l;
KellyErrorEstimator::estimate_some(data,0);
#endif
-
-
- // finally add up the contributions of the
+
+
+// finally add up the contributions of the
// faces for each cell
// reserve one slot for each cell and set
};
-
template <>
void KellyErrorEstimator<1>::
integrate_over_irregular_face (Data &,
#endif
-
template <int dim>
void KellyErrorEstimator<dim>::
integrate_over_regular_face (Data &data,
for (unsigned int p=0; p<data.n_q_points; ++p)
data.psi[this_thread][p][component] -= data.neighbor_psi[this_thread][p][component];
};
-
-
-
- // now psi contains the following:
+
+
+// now psi contains the following:
// - for an internal face, psi=[grad u]
// - for a neumann boundary face,
// psi=grad u
data.coefficient_values[this_thread][point](component);
};
};
-
-
- if (face->at_boundary() == true)
+
+
+if (face->at_boundary() == true)
// neumann boundary face. compute
// difference between normal
// derivative and boundary function
for (unsigned int point=0; point<data.n_q_points; ++point)
data.phi[this_thread][point][component] -= g[point](component);
};
-
-
- // now phi contains the following:
+
+
+// now phi contains the following:
// - for an internal face, phi=[a du/dn]
// - for a neumann boundary face,
// phi=a du/dn-g
};
-
-
template <int dim>
void KellyErrorEstimator<dim>::
integrate_over_irregular_face (Data &data,
// let phi be the name of the integrand
data.normal_vectors[this_thread]=fe_face_values.get_normal_vectors();
-
-
- for (unsigned int component=0; component<data.n_components; ++component)
+
+
+for (unsigned int component=0; component<data.n_components; ++component)
for (unsigned int point=0; point<data.n_q_points; ++point)
data.phi[this_thread][point][component] =
data.psi[this_thread][point][component]*
data.face_integrals[neighbor_child->face(neighbor_neighbor)] = face_integral;
};
-
- // finally loop over all subfaces to
+
+// finally loop over all subfaces to
// collect the contributions of the
// subfaces and store them with the
// mother face
};
-
-
// explicit instantiations
template class KellyErrorEstimator<deal_II_dimension>;
-/* $Id$ */
+//---------------------------- histogram.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- histogram.cc ---------------------------
+
#include <lac/vector.h>
#include <numerics/histogram.h>
#include <cmath>
-
-
-
template <typename number>
inline
bool Histogram::logarithmic_less (const number n1,
};
-
Histogram::Interval::Interval (const double left_point,
const double right_point) :
left_point (left_point),
{};
-
template <typename number>
void Histogram::evaluate (const vector<Vector<number> > &values,
const vector<double> &_y_values,
&Histogram::template logarithmic_less<number>
#endif
);
-
- for (unsigned int i=1; i<values.size(); ++i)
+
+for (unsigned int i=1; i<values.size(); ++i)
{
min_value = min (min_value,
*min_element(values[i].begin(),
// precision.
if (max_value <= min_value)
max_value = min_value+1;
-
- // now set up the intervals based on
+// now set up the intervals based on
// the min and max values
intervals.clear ();
// set up one list of intervals
intervals.push_back (intervals[0]);
- // finally fill the intervals
+// finally fill the intervals
for (unsigned int i=0; i<values.size(); ++i)
for (Vector<number>::const_iterator p=values[i].begin();
p < values[i].end(); ++p)
};
-
template <typename number>
void Histogram::evaluate (const Vector<number> &values,
const unsigned int n_intervals,
};
-
void Histogram::write_gnuplot (ostream &out) const
{
AssertThrow (out, ExcIO());
};
-
string Histogram::get_interval_spacing_names ()
{
return "linear|logarithmic";
};
-
Histogram::IntervalSpacing
Histogram::parse_interval_spacing (const string &name)
{
};
-
-
// explicit instantiations for float
template
void Histogram::evaluate (const vector<Vector<float> > &values,
-/* $Id$ */
+//---------------------------- matrices.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- matrices.cc ---------------------------
+
#include <base/function.h>
#include <dofs/dof_handler.h>
#include <cmath>
-
template <int dim>
void MatrixCreator<dim>::create_mass_matrix (const DoFHandler<dim> &dof,
const Quadrature<dim> &q,
};
-
-
template <int dim>
void MatrixCreator<dim>::create_mass_matrix (const DoFHandler<dim> &dof,
const Quadrature<dim> &q,
};
-
template <int dim>
void MatrixCreator<dim>::create_mass_matrix (const DoFHandler<dim> &dof,
SparseMatrix<double> &matrix) {
};
-
#if deal_II_dimension == 1
template <>
#endif
-
template <int dim>
void MatrixCreator<dim>::create_boundary_mass_matrix (const DoFHandler<dim> &dof,
const Quadrature<dim-1> &q,
FullMatrix<double> cell_matrix(dofs_per_cell, dofs_per_cell);
Vector<double> cell_vector(dofs_per_cell);
-
-
- UpdateFlags update_flags = UpdateFlags (update_values |
+
+
+UpdateFlags update_flags = UpdateFlags (update_values |
update_JxW_values |
update_q_points);
FEFaceValues<dim> fe_values (fe, q, update_flags);
weights[point];
};
};
-
- // now transfer cell matrix and vector
+// now transfer cell matrix and vector
// to the whole boundary matrix
//
// in the following: dof[i] holds the
};
-
template <int dim>
void MatrixCreator<dim>::create_laplace_matrix (const DoFHandler<dim> &dof,
const Quadrature<dim> &q,
};
-
-
-
-
template <int dim>
void MatrixTools<dim>::apply_boundary_values (const map<unsigned int,double> &boundary_values,
SparseMatrix<double> &matrix,
// simply return
if (boundary_values.size() == 0)
return;
-
-
- map<unsigned int,double>::const_iterator dof = boundary_values.begin(),
+
+
+map<unsigned int,double>::const_iterator dof = boundary_values.begin(),
endd = boundary_values.end();
const unsigned int n_dofs = matrix.m();
const SparsityPattern &sparsity = matrix.get_sparsity_pattern();
for (unsigned int j=sparsity_rowstart[dof_number]+1; j<last; ++j)
matrix.global_entry(j) = 0.;
-
- // set right hand side to
+
+// set right hand side to
// wanted value: if main diagonal
// entry nonzero, don't touch it
// and scale rhs accordingly. If
matrix.global_entry(global_entry) = 0.;
};
};
-
-
-
- // preset solution vector
+
+
+// preset solution vector
solution(dof_number) = dof->second;
};
};
-
-
-
-
-
-
-
-
template <int dim>
MassMatrix<dim>::MassMatrix (const Function<dim> * const rhs,
const Function<dim> * const a) :
coefficient (a) {};
-
template <int dim>
void MassMatrix<dim>::assemble (FullMatrix<double> &cell_matrix,
const FEValues<dim> &fe_values,
const FullMatrix<double> &values = fe_values.get_shape_values ();
const vector<double> &weights = fe_values.get_JxW_values ();
-
- if (coefficient != 0)
+
+if (coefficient != 0)
{
if (coefficient->n_components == 1)
// scalar coefficient given
};
-
template <int dim>
void MassMatrix<dim>::assemble (FullMatrix<double> &cell_matrix,
Vector<double> &rhs,
};
-
template <int dim>
void MassMatrix<dim>::assemble (Vector<double> &rhs,
const FEValues<dim> &fe_values,
};
-
-
-
template <int dim>
LaplaceMatrix<dim>::LaplaceMatrix (const Function<dim> * const rhs,
const Function<dim> * const a) :
};
-
template <int dim>
void LaplaceMatrix<dim>::assemble (FullMatrix<double> &cell_matrix,
const FEValues<dim> &fe_values,
};
-
template <int dim>
void LaplaceMatrix<dim>::assemble (Vector<double> &rhs,
const FEValues<dim> &fe_values,
};
-
template<int dim>
void
MatrixCreator<dim>::create_interpolation_matrix(const FiniteElement<dim> &high,
ExcDimensionMismatch(result.n(), high.dofs_per_cell));
- // Initialize FEValues at the support points
+// Initialize FEValues at the support points
// of the low element.
vector<double> phantom_weights(low.dofs_per_cell,1.);
vector<Point<dim> > support_points(low.dofs_per_cell);
}
-
-
template class MatrixCreator<deal_II_dimension>;
template class MatrixTools<deal_II_dimension>;
template class MassMatrix<deal_II_dimension>;
-/*---------------------------- solutiontransfer.cc ---------------------*/
-/* $Id$ */
-/* Ralf Hartmann, University of Heidelberg */
+//---------------------------- solution_transfer.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- solution_transfer.cc ---------------------------
+
#include <grid/tria.h>
#include <dofs/dof_handler.h>
#include <numerics/solution_transfer.h>
-
template<int dim, typename number>
SolutionTransfer<dim, number>::SolutionTransfer(const DoFHandler<dim> &dof):
dof_handler(&dof),
{}
-
template<int dim, typename number>
SolutionTransfer<dim, number>::~SolutionTransfer()
{
}
-
template<int dim, typename number>
void SolutionTransfer<dim, number>::clear ()
{
}
-
template<int dim, typename number>
void SolutionTransfer<dim, number>::prepare_for_pure_refinement()
{
}
-
template<int dim, typename number>
void
SolutionTransfer<dim, number>::refine_interpolate(const Vector<number> &in,
}
-
template<int dim, typename number>
void SolutionTransfer<dim, number>::refine_interpolate (Vector<number> &vec) const
{
}
-
template<int dim, typename number>
void
SolutionTransfer<dim, number>::
n_coarsen_fathers);
- // we need counters for
+// we need counters for
// the 'to_stay_or_refine' cells 'n_sr',
// the 'coarsen_fathers' cells 'n_cf',
// and all the cells where a
}
-
template<int dim, typename number>
void
SolutionTransfer<dim, number>::prepare_for_coarsening_and_refinement(const Vector<number> &in)
}
-
template<int dim, typename number>
void SolutionTransfer<dim, number>::
interpolate (const vector<Vector<number> > &all_in,
all_out[i].reinit (dof_handler->n_dofs());
};
-
- const unsigned int dofs_per_cell=dof_handler->get_fe().dofs_per_cell;
+
+const unsigned int dofs_per_cell=dof_handler->get_fe().dofs_per_cell;
Vector<number> local_values(dofs_per_cell);
vector<unsigned int> *indexptr;
}
-
template<int dim, typename number>
void SolutionTransfer<dim, number>::interpolate(const Vector<number> &in,
Vector<number> &out) const
}
-
-
template class SolutionTransfer<deal_II_dimension, float>;
template class SolutionTransfer<deal_II_dimension, double>;
-// $Id$
+//---------------------------- time_dependent.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- time_dependent.cc ---------------------------
#include <numerics/time_dependent.h>
{};
-
-
TimeDependent::TimeDependent (const TimeSteppingData &data_primal,
const TimeSteppingData &data_dual,
const TimeSteppingData &data_postprocess):
{};
-
-
TimeDependent::~TimeDependent ()
{
while (timesteps.size() != 0)
};
-
void
TimeDependent::insert_timestep (const TimeStepBase *position,
TimeStepBase *new_timestep)
};
-
void
TimeDependent::add_timestep (TimeStepBase *new_timestep)
{
};
-
void TimeDependent::delete_timestep (const unsigned int position)
{
Assert (position<timesteps.size(),
};
-
void
TimeDependent::solve_primal_problem ()
{
};
-
void
TimeDependent::solve_dual_problem ()
{
};
-
void
TimeDependent::postprocess ()
{
};
-
-
-
void TimeDependent::start_sweep (const unsigned int s)
{
sweep_no = s;
};
-
void TimeDependent::end_sweep (const unsigned int n_threads)
{
#ifdef DEAL_II_USE_MT
}
-
void TimeDependent::end_sweep (const unsigned int begin,
const unsigned int end)
{
for (unsigned int step=begin; step<end; ++step)
timesteps[step]->end_sweep ();
};
-
-
/* --------------------------------------------------------------------- */
-
TimeStepBase::TimeStepBase (const double time) :
previous_timestep(0),
next_timestep (0),
{};
-
TimeStepBase::~TimeStepBase ()
{};
-
void
TimeStepBase::wake_up (const unsigned )
{};
-
void
TimeStepBase::sleep (const unsigned)
{};
-
void
TimeStepBase::start_sweep ()
{};
-
void
TimeStepBase::end_sweep ()
{};
-
void
TimeStepBase::init_for_primal_problem ()
{
};
-
void
TimeStepBase::init_for_dual_problem ()
{
};
-
void
TimeStepBase::init_for_postprocessing ()
{
};
-
-
void
TimeStepBase::solve_dual_problem ()
{
};
-
void
TimeStepBase::postprocess_timestep ()
{
};
-
double
TimeStepBase::get_time () const
{
};
-
unsigned int
TimeStepBase::get_timestep_no () const
{
};
-
double
TimeStepBase::get_backward_timestep () const
{
};
-
double
TimeStepBase::get_forward_timestep () const
{
};
-
void
TimeStepBase::set_previous_timestep (const TimeStepBase *previous)
{
};
-
void
TimeStepBase::set_next_timestep (const TimeStepBase *next)
{
};
-
void
TimeStepBase::set_timestep_no (const unsigned int step_no)
{
};
-
void
TimeStepBase::set_sweep_no (const unsigned int sweep)
{
};
-
/* ------------------------------------------------------------------------- */
-
-
-
template <int dim>
TimeStepBase_Tria<dim>::TimeStepBase_Tria() :
TimeStepBase (0),
};
-
template <int dim>
TimeStepBase_Tria<dim>::TimeStepBase_Tria (const double time,
const Triangulation<dim> &coarse_grid,
};
-
template <int dim>
TimeStepBase_Tria<dim>::~TimeStepBase_Tria ()
{
};
-
template <int dim>
void
TimeStepBase_Tria<dim>::wake_up (const unsigned wakeup_level) {
};
-
template <int dim>
void
TimeStepBase_Tria<dim>::sleep (const unsigned sleep_level)
};
-
-
template <int dim>
void TimeStepBase_Tria<dim>::save_refine_flags ()
{
};
-
template <int dim>
void TimeStepBase_Tria<dim>::restore_grid () {
Assert (tria == 0, ExcGridNotDeleted());
};
-
template <int dim>
static void
mirror_refinement_flags (const Triangulation<dim>::cell_iterator &new_cell,
};
-
template <int dim>
static bool
adapt_grids (const Triangulation<dim>::cell_iterator &cell1,
return grids_changed;
};
-
- if (!cell1->has_children() && !cell2->has_children())
+
+if (!cell1->has_children() && !cell2->has_children())
// none of the two have children, so
// make sure that not one is flagged
// for refinement and the other for
return false;
};
-
-
- if (cell1->has_children() && !cell2->has_children())
+
+
+if (cell1->has_children() && !cell2->has_children())
// cell1 has children, cell2 has not
// -> cell2 needs to be refined if any
// of cell1's children is flagged
};
-
template <int dim>
static bool
adapt_grids (Triangulation<dim> &tria1,
};
-
-
-
-
template <int dim>
void TimeStepBase_Tria<dim>::refine_grid (const RefinementData refinement_data)
{
p_coarsening_threshold=0;
- // if we are to do some cell number
+// if we are to do some cell number
// correction steps, we have to find out
// which further cells (beyond
// refinement_threshold) to refine in case
coarsening_threshold);
};
-
-
- // actually flag cells the first time
+
+// actually flag cells the first time
tria->refine (criteria, refinement_threshold);
tria->coarsen (criteria, coarsening_threshold);
tria->prepare_coarsening_and_refinement ();
previous_tria->prepare_coarsening_and_refinement ();
-
-
- // now count the number of elements
+
+// now count the number of elements
// which will result on the previous
// grid after it will be refined. The
// number which will really result
cell->clear_coarsen_flag ();
};
-
- // flag cells finally
+
+// flag cells finally
tria->refine (criteria, refinement_threshold);
tria->coarsen (criteria, coarsening_threshold);
};
{
Triangulation<dim> *previous_tria
= dynamic_cast<const TimeStepBase_Tria<dim>*>(previous_timestep)->tria;
-
- // if we used the dual estimator, we
+
+// if we used the dual estimator, we
// computed the error information on
// a time slab, rather than on a level
// of its own. we then mirror the
};
-
-
template <int dim>
void TimeStepBase_Tria<dim>::init_for_refinement ()
{
};
-
-
-
template <int dim>
TimeStepBase_Tria<dim>::Flags::Flags () {
Assert (false, ExcInternalError());
};
-
template <int dim>
TimeStepBase_Tria<dim>::Flags::Flags (const bool delete_and_rebuild_tria,
const unsigned int wakeup_level_to_build_grid,
};
-
template <int dim>
TimeStepBase_Tria<dim>::RefinementFlags::CorrectionRelaxations
TimeStepBase_Tria<dim>::RefinementFlags::default_correction_relaxations
};
-
template <int dim>
TimeStepBase_Tria<dim>::RefinementData::
RefinementData (const double _refinement_threshold,
};
-
-
-
// explicit instantiations
template class TimeStepBase_Tria<deal_II_dimension>;
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+//---------------------------- vectors.all_dimensions.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- vectors.all_dimensions.cc ---------------------------
+
#include <lac/vector.h>
#include <numerics/vectors.h>
};
-
-/* $Id$ */
-/* Copyright W. Bangerth, University of Heidelberg, 1998 */
-
+//---------------------------- vectors.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- vectors.cc ---------------------------
#include <base/function.h>
#include <cmath>
-
-
inline double sqr (const double x) {
return x*x;
};
};
-
-
template <int dim>
void VectorTools::interpolate (const DoFHandler<dim> &dof,
const Function<dim> &function,
cell->get_dof_indices (dofs_on_cell);
-
- if (fe_is_system)
+if (fe_is_system)
{
// get function values at
// these points. Here: get
}
-
template <int dim> void
VectorTools::interpolate (const DoFHandler<dim> &dof_1,
const DoFHandler<dim> &dof_2,
}
-
#if deal_II_dimension == 1
template <>
#endif
-
-
template <int dim>
void VectorTools::project (const DoFHandler<dim> &dof,
const ConstraintMatrix &constraints,
boundary_values);
};
-
-
- // set up mass matrix and right hand side
+
+// set up mass matrix and right hand side
vec.reinit (dof.n_dofs());
SparsityPattern sparsity(dof.n_dofs(),
dof.n_dofs(),
};
-
template <int dim>
void VectorTools::create_right_hand_side (const DoFHandler<dim> &dof,
const Quadrature<dim> &quadrature,
};
-
-
#if deal_II_dimension == 1
template <>
#endif
-
template <int dim>
void
VectorTools::interpolate_boundary_values (const DoFHandler<dim> &dof,
}
-
template <int dim>
void
VectorTools::project_boundary_values (const DoFHandler<dim> &dof,
sparsity.compress();
else
Assert (false, ExcNotImplemented());
-
- // make mass matrix and right hand side
+
+// make mass matrix and right hand side
SparseMatrix<double> mass_matrix(sparsity);
Vector<double> rhs(sparsity.n_rows());
-
- MatrixTools<dim>::create_boundary_mass_matrix (dof, q,
+
+MatrixTools<dim>::create_boundary_mass_matrix (dof, q,
mass_matrix, boundary_functions,
rhs, dof_to_boundary_mapping);
// to consider constraints
Assert (dim<3, ExcNotImplemented());
-
- Vector<double> boundary_projection (rhs.size());
+
+Vector<double> boundary_projection (rhs.size());
SolverControl control(1000, 1e-16);
PrimitiveVectorMemory<> memory;
};
-
template <int dim>
void
VectorTools::integrate_difference (const DoFHandler<dim> &dof,
Assert (false, ExcNotImplemented());
};
-
- // append result of this cell
+
+// append result of this cell
// to the end of the vector
difference(index) = diff;
};
};
-
-
// explicit instantiations
template
void VectorTools::integrate_difference (const DoFHandler<deal_II_dimension> &,
projects / dealii-svn.git / commitdiff