--- /dev/null
+//---------------------------------------------------------------------------
+// $Id: std_cxx0x_tuple.h 16094 2008-05-14 19:18:25Z bangerth $
+// Version: $Name$
+//
+// Copyright (C) 2009 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.
+//
+//---------------------------------------------------------------------------
+#ifndef __deal2__std_cxx0x_array_h
+#define __deal2__std_cxx0x_array_h
+
+
+#include <base/config.h>
+#include <boost/array.hpp>
+
+
+DEAL_II_NAMESPACE_OPEN
+
+namespace std_cxx0x
+{
+ using boost::array;
+}
+
+
+DEAL_II_NAMESPACE_CLOSE
+
+#endif
namespace std_cxx0x
{
using boost::tuple;
+ using boost::get;
+
namespace tuples
{
using namespace boost::tuples;
#define __deal2__fe_collection_h
#include <base/config.h>
-#include <boost/shared_ptr.hpp>
+#include <base/std_cxx0x/shared_ptr.h>
#include <fe/fe.h>
DEAL_II_NAMESPACE_OPEN
* Array of pointers to the finite
* elements stored by this collection.
*/
- std::vector<boost::shared_ptr<const FiniteElement<dim,spacedim> > > finite_elements;
+ std::vector<std_cxx0x::shared_ptr<const FiniteElement<dim,spacedim> > > finite_elements;
};
#include <fe/fe_values.h>
#include <map>
-#include <boost/shared_ptr.hpp>
+#include <base/std_cxx0x/shared_ptr.h>
DEAL_II_NAMESPACE_OPEN
* as needed in
* select_fe_values().
*/
- Table<3,boost::shared_ptr<FEValues> > fe_values_table;
+ Table<3,std_cxx0x::shared_ptr<FEValues> > fe_values_table;
/**
* Set of indices pointing at
#include <fe/fe.h>
#include <vector>
-#include <boost/shared_ptr.hpp>
+#include <base/std_cxx0x/shared_ptr.h>
DEAL_II_NAMESPACE_OPEN
* pointers to the different Mapping
* objects.
*/
- std::vector<boost::shared_ptr<const Mapping<dim,spacedim> > > mappings;
+ std::vector<std_cxx0x::shared_ptr<const Mapping<dim,spacedim> > > mappings;
};
#include <fe/fe.h>
#include <vector>
-#include <boost/shared_ptr.hpp>
+#include <base/std_cxx0x/shared_ptr.h>
DEAL_II_NAMESPACE_OPEN
* pointers to the different quadrature
* objects.
*/
- std::vector<boost::shared_ptr<const Quadrature<dim> > > quadratures;
+ std::vector<std_cxx0x::shared_ptr<const Quadrature<dim> > > quadratures;
};
QCollection<dim>::QCollection (const Quadrature<dim> &quadrature)
{
quadratures
- .push_back (boost::shared_ptr<const Quadrature<dim> >(new Quadrature<dim>(quadrature)));
+ .push_back (std_cxx0x::shared_ptr<const Quadrature<dim> >(new Quadrature<dim>(quadrature)));
}
QCollection<dim>::push_back (const Quadrature<dim> &new_quadrature)
{
quadratures
- .push_back (boost::shared_ptr<const Quadrature<dim> >(new Quadrature<dim>(new_quadrature)));
+ .push_back (std_cxx0x::shared_ptr<const Quadrature<dim> >(new Quadrature<dim>(new_quadrature)));
}
} // namespace hp
#include <base/subscriptor.h>
#include <vector>
-#include <boost/shared_ptr.hpp>
+#include <base/std_cxx0x/shared_ptr.h>
DEAL_II_NAMESPACE_OPEN
/**
* Array of the objects to be held.
*/
- std::vector<boost::shared_ptr<Object> > objects;
+ std::vector<std_cxx0x::shared_ptr<Object> > objects;
};
/*@}*/
minlevel = new_minlevel;
for (unsigned int i=0; i<new_maxlevel-new_minlevel+1; ++i)
- objects.push_back(boost::shared_ptr<Object> (new Object));
+ objects.push_back(std_cxx0x::shared_ptr<Object> (new Object));
}
MGLevelObject<Object> &
MGLevelObject<Object>::operator = (const double d)
{
- typename std::vector<boost::shared_ptr<Object> >::iterator v;
+ typename std::vector<std_cxx0x::shared_ptr<Object> >::iterator v;
for (v = objects.begin(); v != objects.end(); ++v)
**v=d;
return *this;
void
MGLevelObject<Object>::clear ()
{
- typename std::vector<boost::shared_ptr<Object> >::iterator v;
+ typename std::vector<std_cxx0x::shared_ptr<Object> >::iterator v;
for (v = objects.begin(); v != objects.end(); ++v)
(*v)->clear();
}
MGLevelObject<Object>::memory_consumption () const
{
unsigned int result = sizeof(*this);
- typedef typename std::vector<boost::shared_ptr<Object> >::const_iterator Iter;
+ typedef typename std::vector<std_cxx0x::shared_ptr<Object> >::const_iterator Iter;
const Iter end = objects.end();
for (Iter o=objects.begin(); o!=end; ++o)
result += (*o)->memory_consumption();
#include <dofs/dof_handler.h>
-#include <boost/shared_ptr.hpp>
+#include <base/std_cxx0x/shared_ptr.h>
DEAL_II_NAMESPACE_OPEN
* Sparsity patterns for transfer
* matrices.
*/
- std::vector<boost::shared_ptr<SparsityPattern> > prolongation_sparsities;
+ std::vector<std_cxx0x::shared_ptr<SparsityPattern> > prolongation_sparsities;
/**
* The actual prolongation matrix.
* while row indices belong to the
* child cell, i.e. the fine level.
*/
- std::vector<boost::shared_ptr<SparseMatrix<double> > > prolongation_matrices;
+ std::vector<std_cxx0x::shared_ptr<SparseMatrix<double> > > prolongation_matrices;
/**
* Mapping for the
unsigned int result = sizeof(*this);
result += sizeof(unsigned int) * sizes.size();
#ifdef DEAL_PREFER_MATRIX_EZ
- std::vector<boost::shared_ptr<SparseMatrixEZ<double> > >::const_iterator m;
- const std::vector<boost::shared_ptr<SparseMatrixEZ<double> > >::const_iterator end = prolongation_matrices.end();
+ std::vector<std_cxx0x::shared_ptr<SparseMatrixEZ<double> > >::const_iterator m;
+ const std::vector<std_cxx0x::shared_ptr<SparseMatrixEZ<double> > >::const_iterator end = prolongation_matrices.end();
for (m = prolongation_matrices.begin(); m != end ; ++m)
result += *m->memory_consumption();
#else
#include <dofs/dof_handler.h>
-#include <boost/shared_ptr.hpp>
+#include <base/std_cxx0x/shared_ptr.h>
DEAL_II_NAMESPACE_OPEN
DeclException0(ExcMatricesNotBuilt);
private:
- std::vector<boost::shared_ptr<BlockSparsityPattern> > prolongation_sparsities;
+ std::vector<std_cxx0x::shared_ptr<BlockSparsityPattern> > prolongation_sparsities;
protected:
* while row indices belong to the
* child cell, i.e. the fine level.
*/
- std::vector<boost::shared_ptr<BlockSparseMatrix<double> > > prolongation_matrices;
+ std::vector<std_cxx0x::shared_ptr<BlockSparseMatrix<double> > > prolongation_matrices;
/**
* Mapping for the
#include <dofs/dof_handler.h>
-#include <boost/shared_ptr.hpp>
+#include <base/std_cxx0x/shared_ptr.h>
DEAL_II_NAMESPACE_OPEN
DeclException0(ExcMatricesNotBuilt);
private:
- std::vector<boost::shared_ptr<BlockSparsityPattern> > prolongation_sparsities;
+ std::vector<std_cxx0x::shared_ptr<BlockSparsityPattern> > prolongation_sparsities;
protected:
* while row indices belong to the
* child cell, i.e. the fine level.
*/
- std::vector<boost::shared_ptr<BlockSparseMatrix<double> > > prolongation_matrices;
+ std::vector<std_cxx0x::shared_ptr<BlockSparseMatrix<double> > > prolongation_matrices;
/**
* Unused now, but intended to
#include <numerics/data_postprocessor.h>
#include <numerics/data_component_interpretation.h>
-#include <boost/shared_ptr.hpp>
+#include <base/std_cxx0x/shared_ptr.h>
DEAL_II_NAMESPACE_OPEN
* List of data elements with vectors of
* values for each degree of freedom.
*/
- std::vector<boost::shared_ptr<DataEntryBase> > dof_data;
+ std::vector<std_cxx0x::shared_ptr<DataEntryBase> > dof_data;
/**
* List of data elements with vectors of
* values for each cell.
*/
- std::vector<boost::shared_ptr<DataEntryBase> > cell_data;
+ std::vector<std_cxx0x::shared_ptr<DataEntryBase> > cell_data;
/**
* This is a list of patches that is
* extensive documentation.
*/
virtual
- std::vector<boost::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std_cxx0x::tuple<unsigned int, unsigned int, std::string> >
get_vector_data_ranges () const;
/**
*/
template <int dim, int spacedim>
static
- void create_boundary_mass_matrix_1 (boost::tuple<const Mapping<dim,spacedim> &,
+ void create_boundary_mass_matrix_1 (std_cxx0x::tuple<const Mapping<dim,spacedim> &,
const DoFHandler<dim,spacedim> &,
const Quadrature<dim-1> & > commons,
SparseMatrix<double> &matrix,
*/
template <int dim, int spacedim>
static
- void create_boundary_mass_matrix_1 (boost::tuple<const hp::MappingCollection<dim,spacedim> &,
+ void create_boundary_mass_matrix_1 (std_cxx0x::tuple<const hp::MappingCollection<dim,spacedim> &,
const hp::DoFHandler<dim,spacedim>&,
const hp::QCollection<dim-1> & > commons,
SparseMatrix<double> &matrix,
ensure_existence_of_master_dof_mask (const FiniteElement<dim,spacedim> &fe1,
const FiniteElement<dim,spacedim> &fe2,
const FullMatrix<double> &face_interpolation_matrix,
- boost::shared_ptr<std::vector<bool> > &master_dof_mask)
+ std_cxx0x::shared_ptr<std::vector<bool> > &master_dof_mask)
{
if (master_dof_mask == 0)
{
- master_dof_mask = boost::shared_ptr<std::vector<bool> >
+ master_dof_mask = std_cxx0x::shared_ptr<std::vector<bool> >
(new std::vector<bool> (fe1.dofs_per_face));
select_master_dofs_for_face_restriction (fe1,
fe2,
void
ensure_existence_of_face_matrix (const FiniteElement<dim,spacedim> &fe1,
const FiniteElement<dim,spacedim> &fe2,
- boost::shared_ptr<FullMatrix<double> > &matrix)
+ std_cxx0x::shared_ptr<FullMatrix<double> > &matrix)
{
if (matrix == 0)
{
- matrix = boost::shared_ptr<FullMatrix<double> >
+ matrix = std_cxx0x::shared_ptr<FullMatrix<double> >
(new FullMatrix<double> (fe2.dofs_per_face,
fe1.dofs_per_face));
fe1.get_face_interpolation_matrix (fe2,
ensure_existence_of_subface_matrix (const FiniteElement<dim,spacedim> &fe1,
const FiniteElement<dim,spacedim> &fe2,
const unsigned int subface,
- boost::shared_ptr<FullMatrix<double> > &matrix)
+ std_cxx0x::shared_ptr<FullMatrix<double> > &matrix)
{
if (matrix == 0)
{
- matrix = boost::shared_ptr<FullMatrix<double> >
+ matrix = std_cxx0x::shared_ptr<FullMatrix<double> >
(new FullMatrix<double> (fe2.dofs_per_face,
fe1.dofs_per_face));
fe1.get_subface_interpolation_matrix (fe2,
void
ensure_existence_of_split_face_matrix (const FullMatrix<double> &face_interpolation_matrix,
const std::vector<bool> &master_dof_mask,
- boost::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > > &split_matrix)
+ std_cxx0x::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > > &split_matrix)
{
Assert (master_dof_mask.size() == face_interpolation_matrix.m(),
ExcInternalError());
if (split_matrix == 0)
{
split_matrix
- = boost::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > >
+ = std_cxx0x::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > >
(new std::pair<FullMatrix<double>,FullMatrix<double> >());
const unsigned int n_master_dofs = face_interpolation_matrix.n();
// only once, namely the first
// time they are needed, and
// then just reuse them
- Table<2,boost::shared_ptr<FullMatrix<double> > >
+ Table<2,std_cxx0x::shared_ptr<FullMatrix<double> > >
face_interpolation_matrices (n_finite_elements (dof_handler),
n_finite_elements (dof_handler));
- Table<3,boost::shared_ptr<FullMatrix<double> > >
+ Table<3,std_cxx0x::shared_ptr<FullMatrix<double> > >
subface_interpolation_matrices (n_finite_elements (dof_handler),
n_finite_elements (dof_handler),
GeometryInfo<dim>::max_children_per_face);
// are derived from the face
// interpolation matrix as
// described in the @ref hp_paper "hp paper"
- Table<2,boost::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > > >
+ Table<2,std_cxx0x::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > > >
split_face_interpolation_matrices (n_finite_elements (dof_handler),
n_finite_elements (dof_handler));
// which of the degrees of freedom on
// the coarse side of a refined face
// will act as master dofs.
- Table<2,boost::shared_ptr<std::vector<bool> > >
+ Table<2,std_cxx0x::shared_ptr<std::vector<bool> > >
master_dof_masks (n_finite_elements (dof_handler),
n_finite_elements (dof_handler));
#include <dofs/dof_tools.h>
#include <hp/dof_handler.h>
-#include <boost/shared_ptr.hpp>
+#include <base/std_cxx0x/shared_ptr.h>
DEAL_II_NAMESPACE_OPEN
// apparent memory leaks to
// programs like valgrind
typedef
- boost::shared_ptr<const FETools::FEFactoryBase<deal_II_dimension> >
+ std_cxx0x::shared_ptr<const FETools::FEFactoryBase<deal_II_dimension> >
FEFactoryPointer;
// a function that returns the
// issues here
static
std::map<std::string,
- boost::shared_ptr<const FETools::FEFactoryBase<deal_II_dimension> > >
+ std_cxx0x::shared_ptr<const FETools::FEFactoryBase<deal_II_dimension> > >
fe_name_map
= get_default_fe_names ();
}
// that memory is released again
std::map<const FiniteElement<dim,spacedim> *,
std::map<const FiniteElement<dim,spacedim> *,
- boost::shared_ptr<FullMatrix<double> > > >
+ std_cxx0x::shared_ptr<FullMatrix<double> > > >
interpolation_matrices;
typename DH1<dim,spacedim>::active_cell_iterator cell1 = dof1.begin_active(),
// there
if (interpolation_matrices[&cell1->get_fe()][&cell2->get_fe()] == 0)
{
- boost::shared_ptr<FullMatrix<double> >
+ std_cxx0x::shared_ptr<FullMatrix<double> >
interpolation_matrix (new FullMatrix<double> (dofs_per_cell2,
dofs_per_cell1));
interpolation_matrices[&cell1->get_fe()][&cell2->get_fe()]
// dof1 to the back_interpolation
// matrices
std::map<const FiniteElement<dim> *,
- boost::shared_ptr<FullMatrix<double> > > interpolation_matrices;
+ std_cxx0x::shared_ptr<FullMatrix<double> > > interpolation_matrices;
for (; cell!=endc; ++cell)
{
if (interpolation_matrices[&cell->get_fe()] != 0)
{
interpolation_matrices[&cell->get_fe()] =
- boost::shared_ptr<FullMatrix<double> >
+ std_cxx0x::shared_ptr<FullMatrix<double> >
(new FullMatrix<double>(dofs_per_cell1, dofs_per_cell1));
get_back_interpolation_matrix(dof1.get_fe(), fe2,
*interpolation_matrices[&cell->get_fe()]);
#include <iostream>
#include <functional>
-#include <boost/array.hpp>
+#include <base/std_cxx0x/array.h>
DEAL_II_NAMESPACE_OPEN
// this file
std::map<internal::Triangulation::TriaObject<2>,
std::pair<typename Triangulation<dim,spacedim>::quad_iterator,
- boost::array<bool,GeometryInfo<dim>::lines_per_face> >,
+ std_cxx0x::array<bool,GeometryInfo<dim>::lines_per_face> >,
QuadComparator>
needed_quads;
for (unsigned int cell=0; cell<cells.size(); ++cell)
std::pair<int,int> line_list[GeometryInfo<dim>::lines_per_cell],
inverse_line_list[GeometryInfo<dim>::lines_per_cell];
unsigned int face_line_list[GeometryInfo<dim>::lines_per_face];
- boost::array<bool,GeometryInfo<dim>::lines_per_face> orientation;
+ std_cxx0x::array<bool,GeometryInfo<dim>::lines_per_face> orientation;
for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
{
quad = triangulation.begin_raw_quad();
typename std::map<internal::Triangulation::TriaObject<2>,
std::pair<typename Triangulation<dim,spacedim>::quad_iterator,
- boost::array<bool,GeometryInfo<dim>::lines_per_face> >,
+ std_cxx0x::array<bool,GeometryInfo<dim>::lines_per_face> >,
QuadComparator>
::iterator q;
for (q = needed_quads.begin(); quad!=triangulation.end_quad(); ++quad, ++q)
void
ensure_existence_of_dof_identities (const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2,
- boost::shared_ptr<DoFIdentities> &identities)
+ std_cxx0x::shared_ptr<DoFIdentities> &identities)
{
// see if we need to fill this
// entry, or whether it already
case 0:
{
identities =
- boost::shared_ptr<DoFIdentities>
+ std_cxx0x::shared_ptr<DoFIdentities>
(new DoFIdentities(fe1.hp_vertex_dof_identities(fe2)));
break;
}
case 1:
{
identities =
- boost::shared_ptr<DoFIdentities>
+ std_cxx0x::shared_ptr<DoFIdentities>
(new DoFIdentities(fe1.hp_line_dof_identities(fe2)));
break;
}
case 2:
{
identities =
- boost::shared_ptr<DoFIdentities>
+ std_cxx0x::shared_ptr<DoFIdentities>
(new DoFIdentities(fe1.hp_quad_dof_identities(fe2)));
break;
}
// vertices at all, I can't think
// of a finite element that would
// make that necessary...
- Table<2,boost::shared_ptr<internal::hp::DoFIdentities> >
+ Table<2,std_cxx0x::shared_ptr<internal::hp::DoFIdentities> >
vertex_dof_identities (get_fe().size(),
get_fe().size());
// and then only deal with those that are
// not identical of which we can handle
// at most 2
- Table<2,boost::shared_ptr<internal::hp::DoFIdentities> >
+ Table<2,std_cxx0x::shared_ptr<internal::hp::DoFIdentities> >
line_dof_identities (finite_elements->size(),
finite_elements->size());
// for quads only in 4d and
// higher, so this isn't a
// particularly frequent case
- Table<2,boost::shared_ptr<internal::hp::DoFIdentities> >
+ Table<2,std_cxx0x::shared_ptr<internal::hp::DoFIdentities> >
quad_dof_identities (finite_elements->size(),
finite_elements->size());
"same number of vector components!"));
finite_elements
- .push_back (boost::shared_ptr<const FiniteElement<dim,spacedim> >(new_fe.clone()));
+ .push_back (std_cxx0x::shared_ptr<const FiniteElement<dim,spacedim> >(new_fe.clone()));
}
if (fe_values_table(present_fe_values_index) == 0)
fe_values_table(present_fe_values_index)
=
- boost::shared_ptr<FEValues>
+ std_cxx0x::shared_ptr<FEValues>
(new FEValues ((*mapping_collection)[mapping_index],
(*fe_collection)[fe_index],
q_collection[q_index],
MappingCollection (const Mapping<dim,spacedim> &mapping)
{
mappings
- .push_back (boost::shared_ptr<const Mapping<dim,spacedim> >(mapping.clone()));
+ .push_back (std_cxx0x::shared_ptr<const Mapping<dim,spacedim> >(mapping.clone()));
}
MappingCollection<dim,spacedim>::push_back (const Mapping<dim,spacedim> &new_mapping)
{
mappings
- .push_back (boost::shared_ptr<const Mapping<dim,spacedim> >(new_mapping.clone()));
+ .push_back (std_cxx0x::shared_ptr<const Mapping<dim,spacedim> >(new_mapping.clone()));
}
//---------------------------------------------------------------------------
for (unsigned int i=0; i<n_levels-1; ++i)
{
prolongation_sparsities
- .push_back (boost::shared_ptr<BlockSparsityPattern> (new BlockSparsityPattern));
+ .push_back (std_cxx0x::shared_ptr<BlockSparsityPattern> (new BlockSparsityPattern));
prolongation_matrices
- .push_back (boost::shared_ptr<BlockSparseMatrix<double> > (new BlockSparseMatrix<double>));
+ .push_back (std_cxx0x::shared_ptr<BlockSparseMatrix<double> > (new BlockSparseMatrix<double>));
}
// two fields which will store the
for (unsigned int i=0; i<n_levels-1; ++i)
{
prolongation_sparsities
- .push_back (boost::shared_ptr<BlockSparsityPattern> (new BlockSparsityPattern));
+ .push_back (std_cxx0x::shared_ptr<BlockSparsityPattern> (new BlockSparsityPattern));
prolongation_matrices
- .push_back (boost::shared_ptr<BlockSparseMatrix<double> > (new BlockSparseMatrix<double>));
+ .push_back (std_cxx0x::shared_ptr<BlockSparseMatrix<double> > (new BlockSparseMatrix<double>));
}
// two fields which will store the
for (unsigned int i=0; i<n_levels-1; ++i)
{
prolongation_sparsities
- .push_back (boost::shared_ptr<SparsityPattern> (new SparsityPattern));
+ .push_back (std_cxx0x::shared_ptr<SparsityPattern> (new SparsityPattern));
prolongation_matrices
- .push_back (boost::shared_ptr<SparseMatrix<double> > (new SparseMatrix<double>));
+ .push_back (std_cxx0x::shared_ptr<SparseMatrix<double> > (new SparseMatrix<double>));
}
// two fields which will store the
DataEntryBase * new_entry = new DataEntry<VECTOR>(&vec, names,
data_component_interpretation);
if (actual_type == type_dof_data)
- dof_data.push_back (boost::shared_ptr<DataEntryBase>(new_entry));
+ dof_data.push_back (std_cxx0x::shared_ptr<DataEntryBase>(new_entry));
else
- cell_data.push_back (boost::shared_ptr<DataEntryBase>(new_entry));
+ cell_data.push_back (std_cxx0x::shared_ptr<DataEntryBase>(new_entry));
}
dofs->get_tria().n_active_cells()));
DataEntryBase * new_entry = new DataEntry<VECTOR>(&vec, &data_postprocessor);
- dof_data.push_back (boost::shared_ptr<DataEntryBase>(new_entry));
+ dof_data.push_back (std_cxx0x::shared_ptr<DataEntryBase>(new_entry));
}
// collect the names of dof
// and cell data
typedef
- typename std::vector<boost::shared_ptr<DataEntryBase> >::const_iterator
+ typename std::vector<std_cxx0x::shared_ptr<DataEntryBase> >::const_iterator
data_iterator;
for (data_iterator d=dof_data.begin();
template <class DH,
int patch_dim, int patch_space_dim>
-std::vector<boost::tuple<unsigned int, unsigned int, std::string> >
+std::vector<std_cxx0x::tuple<unsigned int, unsigned int, std::string> >
DataOut_DoFData<DH,patch_dim,patch_space_dim>::get_vector_data_ranges () const
{
- std::vector<boost::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std_cxx0x::tuple<unsigned int, unsigned int, std::string> >
ranges;
// collect the ranges of dof
// and cell data
typedef
- typename std::vector<boost::shared_ptr<DataEntryBase> >::const_iterator
+ typename std::vector<std_cxx0x::shared_ptr<DataEntryBase> >::const_iterator
data_iterator;
unsigned int output_component = 0;
// finally add a corresponding
// range
- boost::tuple<unsigned int, unsigned int, std::string>
+ std_cxx0x::tuple<unsigned int, unsigned int, std::string>
range (output_component,
output_component+patch_space_dim-1,
name);
// the matrix
Threads::ThreadMutex mutex;
- typedef boost::tuple<const Mapping<dim,spacedim>&,
+ typedef std_cxx0x::tuple<const Mapping<dim,spacedim>&,
const DoFHandler<dim,spacedim>&,
const Quadrature<dim-1>&> Commons;
template <>
void
MatrixCreator::
-create_boundary_mass_matrix_1<2,3> (boost::tuple<const Mapping<2,3> &,
+create_boundary_mass_matrix_1<2,3> (std_cxx0x::tuple<const Mapping<2,3> &,
const DoFHandler<2,3> &,
const Quadrature<1> & > ,
SparseMatrix<double> &,
template <int dim, int spacedim>
void
MatrixCreator::
-create_boundary_mass_matrix_1 (boost::tuple<const Mapping<dim, spacedim> &,
+create_boundary_mass_matrix_1 (std_cxx0x::tuple<const Mapping<dim, spacedim> &,
const DoFHandler<dim,spacedim> &,
const Quadrature<dim-1> & > commons,
SparseMatrix<double> &matrix,
// All assertions for this function
// are in the calling function
// before creating threads.
- const Mapping<dim,spacedim>& mapping = boost::get<0>(commons);
- const DoFHandler<dim,spacedim>& dof = boost::get<1>(commons);
- const Quadrature<dim-1>& q = boost::get<2>(commons);
+ const Mapping<dim,spacedim>& mapping = std_cxx0x::get<0>(commons);
+ const DoFHandler<dim,spacedim>& dof = std_cxx0x::get<1>(commons);
+ const Quadrature<dim-1>& q = std_cxx0x::get<2>(commons);
const FiniteElement<dim,spacedim> &fe = dof.get_fe();
const unsigned int n_components = fe.n_components();
= Threads::split_range<active_cell_iterator> (dof.begin_active(),
dof.end(), n_threads);
- typedef boost::tuple<const hp::MappingCollection<dim>&,
+ typedef std_cxx0x::tuple<const hp::MappingCollection<dim>&,
const hp::DoFHandler<dim>&,
const hp::QCollection<dim-1>&> Commons;
template <int dim, int spacedim>
void
MatrixCreator::
-create_boundary_mass_matrix_1 (boost::tuple<const hp::MappingCollection<dim,spacedim> &,
+create_boundary_mass_matrix_1 (std_cxx0x::tuple<const hp::MappingCollection<dim,spacedim> &,
const hp::DoFHandler<dim,spacedim> &,
const hp::QCollection<dim-1> &> commons,
SparseMatrix<double> &matrix,
const IteratorRange<hp::DoFHandler<dim,spacedim> > range,
Threads::ThreadMutex &mutex)
{
- const hp::MappingCollection<dim>& mapping = boost::get<0>(commons);
- const hp::DoFHandler<dim>& dof = boost::get<1>(commons);
- const hp::QCollection<dim-1>& q = boost::get<2>(commons);
+ const hp::MappingCollection<dim>& mapping = std_cxx0x::get<0>(commons);
+ const hp::DoFHandler<dim>& dof = std_cxx0x::get<1>(commons);
+ const hp::QCollection<dim-1>& q = std_cxx0x::get<2>(commons);
const hp::FECollection<dim,spacedim> &fe_collection = dof.get_fe();
const unsigned int n_components = fe_collection.n_components();
const unsigned int n_function_components = boundary_functions.begin()->second->n_components;