// $Id$
// Version: $Name$
//
-// Copyright (C) 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/exceptions.h>
#include <base/function.h>
+DEAL_II_NAMESPACE_OPEN
/**
* This class automatically computes the gradient of a function by
};
+DEAL_II_NAMESPACE_CLOSE
#endif
#ifndef __deal2__conditional_ostream_h
#define __deal2__conditional_ostream_h
-
+#include <base/config.h>
#ifdef HAVE_STD_OSTREAM_HEADER
# include <ostream>
# include <iostream>
#endif
+DEAL_II_NAMESPACE_OPEN
+
/**
* A class that allows printing to an output stream, e.g. @p std::cout,
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// environment, contact the authors of the library.
+/**
+ * Two macro names that we put at the top and bottom of all deal.II files
+ * and that will be expanded to "namespace dealii {" and "}".
+ */
+#define DEAL_II_NAMESPACE_OPEN namespace dealii {
+#define DEAL_II_NAMESPACE_CLOSE }
+
+
/* Defined if the prototype of abort() has a no-throw exception specification.
*/
#include <base/config.h>
#include <base/table_handler.h>
+DEAL_II_NAMESPACE_OPEN
+
/**
* The ConvergenceTable class is an application to the TableHandler
};
+DEAL_II_NAMESPACE_CLOSE
+
#endif
# include <iostream>
#endif
+DEAL_II_NAMESPACE_OPEN
+
class ParameterHandler;
* the last time a stream was
* given to the read() function.
*/
- virtual const std::vector<typename ::DataOutBase::Patch<dim,spacedim> > &
+ virtual const std::vector<typename dealii::DataOutBase::Patch<dim,spacedim> > &
get_patches () const;
/**
virtual std::vector<std::string> get_dataset_names () const;
private:
- std::vector<typename ::DataOutBase::Patch<dim,spacedim> > patches;
+ std::vector<typename dealii::DataOutBase::Patch<dim,spacedim> > patches;
std::vector<std::string> dataset_names;
};
return stream;
}
+DEAL_II_NAMESPACE_CLOSE
#endif
# include <iostream>
#endif
+DEAL_II_NAMESPACE_OPEN
+
/**
* This class is the base class for all exception classes. Do not use
* @ingroup Exceptions
*/
#define DeclException0(Exception0) \
-class Exception0 : public ExceptionBase {}
+class Exception0 : public dealii::ExceptionBase {}
* one additional parameter.
*/
#define DeclException1(Exception1, type1, outsequence) \
-class Exception1 : public ExceptionBase { \
+class Exception1 : public dealii::ExceptionBase { \
public: \
Exception1 (const type1 a1) : arg1 (a1) {}; \
virtual ~Exception1 () throw () {}; \
* @ingroup Exceptions
*/
#define DeclException2(Exception2, type1, type2, outsequence) \
-class Exception2 : public ExceptionBase { \
+class Exception2 : public dealii::ExceptionBase { \
public: \
Exception2 (const type1 a1, const type2 a2) : \
arg1 (a1), arg2(a2) {}; \
* @ingroup Exceptions
*/
#define DeclException3(Exception3, type1, type2, type3, outsequence) \
-class Exception3 : public ExceptionBase { \
+class Exception3 : public dealii::ExceptionBase { \
public: \
Exception3 (const type1 a1, const type2 a2, const type3 a3) : \
arg1 (a1), arg2(a2), arg3(a3) {}; \
* @ingroup Exceptions
*/
#define DeclException4(Exception4, type1, type2, type3, type4, outsequence) \
-class Exception4 : public ExceptionBase { \
+class Exception4 : public dealii::ExceptionBase { \
public: \
Exception4 (const type1 a1, const type2 a2, \
const type3 a3, const type4 a4) : \
* @ingroup Exceptions
*/
#define DeclException5(Exception5, type1, type2, type3, type4, type5, outsequence) \
-class Exception5 : public ExceptionBase { \
+class Exception5 : public dealii::ExceptionBase { \
public: \
Exception5 (const type1 a1, const type2 a2, const type3 a3, \
const type4 a4, const type5 a5) : \
using namespace StandardExceptions;
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/subscriptor.h>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
template <int dim> class Point;
template <int rank_, int dim> class Tensor;
template <int dim> class Tensor<1,dim>;
};
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/exceptions.h>
#include <base/function.h>
+DEAL_II_NAMESPACE_OPEN
+
/**
* Derivative of a function object. The value access functions of
std::vector<Point<dim> > incr;
};
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/function.h>
#include <base/point.h>
+DEAL_II_NAMESPACE_OPEN
/**
* Namespace implementing some concrete classes derived from the
const unsigned int component = 0) const;
};
}
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
class FunctionParser;
}
+DEAL_II_NAMESPACE_OPEN
+
template <int> class Point;
template <int, int> class Tensor;
unsigned int n_vars;
};
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/config.h>
#include <base/exceptions.h>
+DEAL_II_NAMESPACE_OPEN
/**
* Support for time dependent functions.
* The library was also designed for time dependent problems. For this
}
#endif
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <base/exceptions.h>
#include <base/point.h>
+DEAL_II_NAMESPACE_OPEN
template <int dim> class GeometryInfo;
}
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <base/config.h>
#include <string>
+DEAL_II_NAMESPACE_OPEN
/**
* Identification of a program run. <tt>JobIdentifier</tt> determines the
* start time of a program run and stores it as a program
* Global object to identify the presently running program.
*/
extern JobIdentifier dealjobid;
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <stack>
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
// we only need output streams, but older compilers did not provide
// them in a separate include file
#ifdef HAVE_STD_OSTREAM_HEADER
*/
extern LogStream deallog;
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <vector>
#include <utility>
+DEAL_II_NAMESPACE_OPEN
/**
}
}
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/config.h>
#include <base/exceptions.h>
+DEAL_II_NAMESPACE_OPEN
/**
* This class provides information about the system which may be of
//---------------------------------------------------------------------------
+DEAL_II_NAMESPACE_CLOSE
// end of #ifndef __deal2__multithread_info_h
#endif
//---------------------------------------------------------------------------
#ifndef __deal2__numbers_h
#define __deal2__numbers_h
+DEAL_II_NAMESPACE_OPEN
+
/**
* Namespace for the declaration of universal constants. Since the
* availability in <tt>math.h</tt> is not always guaranteed, we put
bool is_finite (const double x);
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
#include <string>
+DEAL_II_NAMESPACE_OPEN
//TODO: Allow long input lines to be broken by appending a backslash character
//TODO: Provide an "include" command for parameter files
* @code
* #include <iostream>
* #include "../include/parameter_handler.h"
- *
+ *
+ DEAL_II_NAMESPACE_OPEN
*
* class LinEq {
* public:
};
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/config.h>
#include <base/exceptions.h>
+DEAL_II_NAMESPACE_OPEN
+
/**
* Support for searching files in a list of paths and with a list of
* suffixes.
* @code
* #include <base/path_search.h>
*
+ DEAL_II_NAMESPACE_OPEN
* PathSearch search("MESH");
* std::string full_name = search.find("grid");
* std::ifstream in(full_name.c_str());
out << std::endl;
}
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/tensor_base.h>
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
/**
* The <tt>Point</tt> class provides for a point or vector in a space with
}
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <vector>
+DEAL_II_NAMESPACE_OPEN
template <int dim> class Point;
/**
return coefficients.size() - 1;
}
}
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <vector>
+DEAL_II_NAMESPACE_OPEN
/**
* Representation of the space of polynomials of degree at most n in
}
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <vector>
+DEAL_II_NAMESPACE_OPEN
/**
* @addtogroup Polynomials
* @{
{
return my_degree;
}
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <vector>
+DEAL_II_NAMESPACE_OPEN
/**
* @addtogroup Polynomials
{
return polynomial_space.degree();
}
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <vector>
+DEAL_II_NAMESPACE_OPEN
/**
* @addtogroup Polynomials
* @{
this->compute_index(n,degrees);
}
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <vector>
+DEAL_II_NAMESPACE_OPEN
/**
* @addtogroup Polynomials
* @{
{
return my_degree;
}
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <base/quadrature.h>
+DEAL_II_NAMESPACE_OPEN
/*!@addtogroup Quadrature */
/*@{*/
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <base/subscriptor.h>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
/*!@addtogroup Quadrature */
/*@{*/
const std::vector<double> & Quadrature<0>::get_weights () const;
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <base/config.h>
#include <base/quadrature.h>
+DEAL_II_NAMESPACE_OPEN
/*!@addtogroup Quadrature */
/*@{*/
template <> QMilne<1>::QMilne ();
template <> QWeddle<1>::QWeddle ();
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <string>
+DEAL_II_NAMESPACE_OPEN
/**
* This class implements the quadrature rule passed to its constructor
create_quadrature (const std::string &s,
const unsigned int order);
};
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/config.h>
#include <base/subscriptor.h>
+DEAL_II_NAMESPACE_OPEN
/**
* Smart pointers avoid destruction of an object in use. They can be used just
t2.swap (t1);
}
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <map>
#include <string>
+DEAL_II_NAMESPACE_OPEN
/**
* Handling of subscriptions.
{}
#endif
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <base/tensor.h>
#include <base/table_indices.h>
+DEAL_II_NAMESPACE_OPEN
template <int rank, int dim> class SymmetricTensor;
}
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <cstddef>
#include <algorithm>
+DEAL_II_NAMESPACE_OPEN
// forward declaration
template <int N, typename T> class TableBase;
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <string>
#include <fstream>
+DEAL_II_NAMESPACE_OPEN
// we only need output streams, but older compilers did not provide
// them in a separate include file
#ifdef HAVE_STD_OSTREAM_HEADER
};
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <base/config.h>
#include <base/exceptions.h>
+DEAL_II_NAMESPACE_OPEN
/**
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <base/config.h>
+DEAL_II_NAMESPACE_OPEN
template <bool, typename> struct constraint_and_return_value;
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <base/config.h>
#include <base/tensor_base.h>
+DEAL_II_NAMESPACE_OPEN
template <int rank_, int dim> class Tensor;
template <int dim> class Tensor<1,dim>;
return tt;
}
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
// we only need output streams, but older compilers did not provide
// them in a separate include file
#ifdef HAVE_STD_OSTREAM_HEADER
tt[d] = t[d] / factor;
return tt;
}
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <vector>
+DEAL_II_NAMESPACE_OPEN
/**
* This class is a model for a tensor valued function. The interface
};
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <vector>
+DEAL_II_NAMESPACE_OPEN
/**
* @addtogroup Polynomials
unsigned int (&index)[3]) const;
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <boost/tuple/tuple.hpp>
#include <boost/shared_ptr.hpp>
+DEAL_II_NAMESPACE_OPEN
#if DEAL_II_USE_MT == 1
# if defined(DEAL_II_USE_MT_POSIX)
# include <pthread.h>
//---------------------------------------------------------------------------
+DEAL_II_NAMESPACE_CLOSE
// end of #ifndef __deal2__thread_management_h
#endif
//---------------------------------------------------------------------------
#include <base/config.h>
+DEAL_II_NAMESPACE_OPEN
/**
* This is a very simple class which provides information about the time
bool running;
};
+DEAL_II_NAMESPACE_CLOSE
#endif
#ifdef DEAL_II_USE_PETSC
#include <petscvec.h>
+
#else
typedef int MPI_Comm;
#endif
+DEAL_II_NAMESPACE_OPEN
+
+
/**
* A namespace for utility functions that are not particularly specific to
* finite element computing or numerical programs, but nevertheless are needed
}
}
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <base/config.h>
#include <base/exceptions.h>
+DEAL_II_NAMESPACE_OPEN
/**
* Filter a range out of any object having a random access <tt>operator[]
* (unsigned int)</tt> and a function <tt>size() const</tt>.
return v.begin()+start+length;
}
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
template <int dim>
AutoDerivativeFunction<dim>::
template class AutoDerivativeFunction<1>;
template class AutoDerivativeFunction<2>;
template class AutoDerivativeFunction<3>;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/conditional_ostream.h>
+DEAL_II_NAMESPACE_OPEN
ConditionalOStream::ConditionalOStream(std::ostream &stream,
const bool active)
{
return active_flag;
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <cmath>
#include <limits>
+DEAL_II_NAMESPACE_OPEN
namespace deal_II_numbers
{
// comparisons will be false
return ((x >= -std::numeric_limits<double>::max())
&&
+DEAL_II_NAMESPACE_CLOSE
(x <= std::numeric_limits<double>::max()));
#endif
}
}
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/convergence_table.h>
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
ConvergenceTable::ConvergenceTable()
{}
if (!col_iter->second.flag)
evaluate_convergence_rates(col_iter->first, rate_mode);
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <sstream>
+DEAL_II_NAMESPACE_OPEN
+
//TODO: Is it reasonable to have undocumented exceptions?
DeclException2 (ExcUnexpectedInput,
// first empty previous content
{
- std::vector<typename ::DataOutBase::Patch<dim,spacedim> >
+ std::vector<typename dealii::DataOutBase::Patch<dim,spacedim> >
tmp;
tmp.swap (patches);
}
{
std::pair<unsigned int, unsigned int>
dimension_info
- = ::DataOutBase::determine_intermediate_format_dimensions (in);
+ = dealii::DataOutBase::determine_intermediate_format_dimensions (in);
AssertThrow ((dimension_info.first == dim) &&
(dimension_info.second == spacedim),
ExcIncompatibleDimensions (dimension_info.first, dim,
DataOutReader<dim,spacedim>::
merge (const DataOutReader<dim,spacedim> &source)
{
- typedef typename ::DataOutBase::Patch<dim,spacedim> Patch;
+ typedef typename dealii::DataOutBase::Patch<dim,spacedim> Patch;
const std::vector<Patch> source_patches = source.get_patches ();
Assert (patches.size () != 0, ExcNoPatches ());
template <int dim, int spacedim>
-const std::vector<typename ::DataOutBase::Patch<dim,spacedim> > &
+const std::vector<typename dealii::DataOutBase::Patch<dim,spacedim> > &
DataOutReader<dim,spacedim>::get_patches () const
{
return patches;
INSTANTIATE(3,4);
+
+DEAL_II_NAMESPACE_CLOSE
# include <cxxabi.h>
#endif
+DEAL_II_NAMESPACE_OPEN
+
namespace deal_II_exceptions
{
}
+DEAL_II_NAMESPACE_CLOSE
+
+
// from the aclocal file:
// Newer versions of gcc have a very nice feature: you can set
// a verbose terminate handler, that not only aborts a program
#include <lac/vector.h>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim>
const unsigned int Function<dim>::dimension;
template class ZeroFunction<3>;
template class ConstantFunction<3>;
template class ComponentSelectFunction<3>;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim>
FunctionDerivative<dim>::FunctionDerivative (const Function<dim> &f,
const Point<dim> &dir,
template class FunctionDerivative<1>;
template class FunctionDerivative<2>;
template class FunctionDerivative<3>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
// in strict ANSI C mode, the following constants are not defined by
// default, so we do it ourselves
template class SlitSingularityFunction<2>;
template class SlitSingularityFunction<3>;
}
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
namespace Functions
template class CutOffFunctionCinfty <2>;
template class CutOffFunctionCinfty <3>;
}
+
+DEAL_II_NAMESPACE_CLOSE
#endif
+DEAL_II_NAMESPACE_OPEN
+
template <int dim>
template class FunctionParser<1>;
template class FunctionParser<2>;
template class FunctionParser<3>;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/function_time.h>
+DEAL_II_NAMESPACE_OPEN
+
FunctionTime::FunctionTime(const double initial_time)
:
{
set_time (time+delta_t);
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <base/geometry_info.h>
+DEAL_II_NAMESPACE_OPEN
template <int dim> const unsigned int GeometryInfo<dim>::children_per_cell;
template class GeometryInfo<2>;
template class GeometryInfo<3>;
template class GeometryInfo<4>;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
# include <unistd.h>
#endif
+DEAL_II_NAMESPACE_OPEN
+
+
JobIdentifier dealjobid;
{
return id;
}
+
+DEAL_II_NAMESPACE_CLOSE
}
#endif
+DEAL_II_NAMESPACE_OPEN
+
LogStream deallog;
return mem;
}
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/memory_consumption.h>
+DEAL_II_NAMESPACE_OPEN
+
namespace MemoryConsumption
{
}
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
# include <sys/sysctl.h>
#endif
+
+DEAL_II_NAMESPACE_OPEN
+
+
#if DEAL_II_USE_MT == 1
/* Detecting how many processors a given machine has is something that
// definition of the variable which is declared `extern' in the .h file
MultithreadInfo multithread_info;
+
+DEAL_II_NAMESPACE_CLOSE
# include <limits>
#endif
+DEAL_II_NAMESPACE_OPEN
+
//TODO[WB]: various functions here could be simplified by using namespace Utilities
MemoryConsumption::memory_consumption (different_values) +
sizeof (type));
}
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <cstdio>
#include <algorithm>
+DEAL_II_NAMESPACE_OPEN
+
+
std::map<std::string, std::vector<std::string> > PathSearch::path_lists;
std::map<std::string, std::vector<std::string> > PathSearch::suffix_lists;
std::string PathSearch::empty("");
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
// have a lock that guarantees that at most one thread is changing and
template class Monomial<double>;
template class Monomial<long double>;
}
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/exceptions.h>
#include <base/table.h>
+DEAL_II_NAMESPACE_OPEN
template <int dim>
template class PolynomialSpace<1>;
template class PolynomialSpace<2>;
template class PolynomialSpace<3>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <iomanip>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim>
PolynomialsABF<dim>::PolynomialsABF (const unsigned int k)
template class PolynomialsABF<2>;
template class PolynomialsABF<3>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <iostream>
#include <iomanip>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim>
PolynomialsBDM<dim>::PolynomialsBDM (const unsigned int k)
template class PolynomialsBDM<2>;
template class PolynomialsBDM<3>;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/polynomials_p.h>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim>
PolynomialsP<dim>::PolynomialsP (const unsigned int p)
template class PolynomialsP<1>;
template class PolynomialsP<2>;
template class PolynomialsP<3>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <iostream>
#include <iomanip>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim>
PolynomialsRaviartThomas<dim>::PolynomialsRaviartThomas (const unsigned int k)
template class PolynomialsRaviartThomas<2>;
template class PolynomialsRaviartThomas<3>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <cmath>
#include <iterator>
+DEAL_II_NAMESPACE_OPEN
+
namespace
{
template class QProjector<1>;
template class QProjector<2>;
template class QProjector<3>;
+
+DEAL_II_NAMESPACE_CLOSE
# include <limits>
#endif
+DEAL_II_NAMESPACE_OPEN
+
// please note: for a given dimension, we need the quadrature formulae
// for all lower dimensions as well. That is why in this file the check
template class QSimpson<3>;
template class QMilne<3>;
template class QWeddle<3>;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2005 by the deal.II authors
+// Copyright (C) 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/quadrature_selector.h>
#include <base/quadrature_lib.h>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim>
Quadrature<dim>
template class QuadratureSelector<1>;
template class QuadratureSelector<2>;
template class QuadratureSelector<3>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <string>
#include <iostream>
+DEAL_II_NAMESPACE_OPEN
+
+
namespace
{
// create a lock that might be used to control subscription to and
deallog << "No subscriber listing with multithreading" << std::endl;
#endif
}
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/symmetric_tensor.h>
+DEAL_II_NAMESPACE_OPEN
+
template <>
SymmetricTensor<4,3>
return tmp;
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <iomanip>
#include <strings.h>
+DEAL_II_NAMESPACE_OPEN
+
TableEntryBase::TableEntryBase ()
template
void TableHandler::add_value<std::string> (const std::string &,
const std::string);
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <cmath>
#include <lac/vector.h>
+DEAL_II_NAMESPACE_OPEN
+
// storage for static variables
template <int dim>
template class Tensor<4, 1>;
template class Tensor<4, 2>;
template class Tensor<4, 3>;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <cmath>
#include <lac/vector.h>
+DEAL_II_NAMESPACE_OPEN
+
//////////////////////////////////////////////////////////////////////
// TensorFunction
template class TensorFunction<2,3>;
template class TensorFunction<3,3>;
template class TensorFunction<4,3>;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/exceptions.h>
#include <base/table.h>
+DEAL_II_NAMESPACE_OPEN
+
/* ------------------- TensorProductPolynomials -------------- */
template class AnisotropicPolynomials<1>;
template class AnisotropicPolynomials<2>;
template class AnisotropicPolynomials<3>;
+
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <sys/errno.h>
+DEAL_II_NAMESPACE_OPEN
+
namespace Threads
{
#endif // (DEAL_II_USE_MT == 1) && defined(DEAL_II_USE_MT_POSIX)
} // end namespace Thread
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
}
#endif
+DEAL_II_NAMESPACE_OPEN
cumulative_time = 0.;
running = false;
}
+
+DEAL_II_NAMESPACE_CLOSE
# include <limits.h>
#endif
+DEAL_II_NAMESPACE_OPEN
+
namespace Utilities
{
}
}
+
+DEAL_II_NAMESPACE_CLOSE
#! /bin/sh
-# From configure.in Revision: 13905 .
+# From configure.in Revision: 13973 .
# Guess values for system-dependent variables and create Makefiles.
# Generated by GNU Autoconf 2.59 for deal.II 5.3.pre.
#
// In case of problems in autodetection of features of your build
// environment, contact the authors of the library.
+
+/**
+ * Two macro names that we put at the top and bottom of all deal.II files
+ * and that will be expanded to "namespace dealii {" and "}".
+ */
+#define DEAL_II_NAMESPACE_OPEN namespace dealii {
+#define DEAL_II_NAMESPACE_CLOSE }
+
])
#include <grid/tria_accessor.h>
#include <dofs/dof_handler.h>
#include <dofs/hp_dof_handler.h>
+
#include <vector>
+DEAL_II_NAMESPACE_OPEN
template <typename number> class FullMatrix;
template <typename number> class SparseMatrix;
DoFCellAccessor<hp::DoFHandler<3> >::update_cell_dof_indices_cache () const;
+DEAL_II_NAMESPACE_CLOSE
// include more templates
#include "dof_accessor.templates.h"
#include <vector>
+DEAL_II_NAMESPACE_OPEN
template <>
inline
const FiniteElement<1> &
-DoFAccessor<1,::DoFHandler<1> >::get_fe (const unsigned int fe_index) const
+DoFAccessor<1,dealii::DoFHandler<1> >::get_fe (const unsigned int fe_index) const
{
Assert (fe_index_is_active (fe_index) == true,
ExcMessage ("This function can only be called for active fe indices"));
template <>
inline
const FiniteElement<2> &
-DoFAccessor<1,::DoFHandler<2> >::get_fe (const unsigned int fe_index) const
+DoFAccessor<1,dealii::DoFHandler<2> >::get_fe (const unsigned int fe_index) const
{
Assert (fe_index_is_active (fe_index) == true,
ExcMessage ("This function can only be called for active fe indices"));
template <>
inline
const FiniteElement<3> &
-DoFAccessor<1,::DoFHandler<3> >::get_fe (const unsigned int fe_index) const
+DoFAccessor<1,dealii::DoFHandler<3> >::get_fe (const unsigned int fe_index) const
{
Assert (fe_index_is_active (fe_index) == true,
ExcMessage ("This function can only be called for active fe indices"));
template <>
inline
const FiniteElement<2> &
-DoFAccessor<2,::DoFHandler<2> >::get_fe (const unsigned int fe_index) const
+DoFAccessor<2,dealii::DoFHandler<2> >::get_fe (const unsigned int fe_index) const
{
Assert (fe_index_is_active (fe_index) == true,
ExcMessage ("This function can only be called for active fe indices"));
template <>
inline
const FiniteElement<3> &
-DoFAccessor<2,::DoFHandler<3> >::get_fe (const unsigned int fe_index) const
+DoFAccessor<2,dealii::DoFHandler<3> >::get_fe (const unsigned int fe_index) const
{
Assert (fe_index_is_active (fe_index) == true,
ExcMessage ("This function can only be called for active fe indices"));
template <>
inline
const FiniteElement<3> &
-DoFAccessor<3,::DoFHandler<3> >::get_fe (const unsigned int fe_index) const
+DoFAccessor<3,dealii::DoFHandler<3> >::get_fe (const unsigned int fe_index) const
{
Assert (fe_index_is_active (fe_index) == true,
ExcMessage ("This function can only be called for active fe indices"));
}
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <base/exceptions.h>
#include <base/subscriptor.h>
+DEAL_II_NAMESPACE_OPEN
+
template <typename> class Vector;
template <typename> class FullMatrix;
class SparsityPattern;
(constraint_line_exists[index] == true));
}
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/block_sparsity_pattern.h>
#include <lac/block_sparse_matrix.h>
+DEAL_II_NAMESPACE_OPEN
template<typename number>
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <dofs/dof_objects.h>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
template <int> class DoFHandler;
template <int> class MGDoFHandler;
* DoFAccessor::dof_index() functions or similar functions of derived classes that in turn
* access the member variables using the DoFHandler::get_dof_index() and corresponding
* setter functions. Knowledge of the actual data format is therefore encapsulated to the
- * present hierarchy of classes as well as the ::DoFHandler class.
+ * present hierarchy of classes as well as the dealii::DoFHandler class.
*
* @ingroup dofs
* @author Tobias Leicht, 2006
* resize arrays as
* necessary.
*/
- template <int> friend class ::DoFHandler;
- template <int> friend class ::MGDoFHandler;
+ template <int> friend class dealii::DoFHandler;
+ template <int> friend class dealii::MGDoFHandler;
};
/**
* resize arrays as
* necessary.
*/
- template <int> friend class ::DoFHandler;
- template <int> friend class ::MGDoFHandler;
+ template <int> friend class dealii::DoFHandler;
+ template <int> friend class dealii::MGDoFHandler;
};
}
}
+
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <map>
#include <set>
+DEAL_II_NAMESPACE_OPEN
+
namespace internal
{
namespace DoFHandler
* Alias the @p FunctionMap type
* declared elsewhere.
*/
- typedef typename ::FunctionMap<dim>::type FunctionMap;
+ typedef typename dealii::FunctionMap<dim>::type FunctionMap;
/**
* Make the dimension available
#endif // DOXYGEN
-/*---------------------------- dof_handler.h ---------------------------*/
+DEAL_II_NAMESPACE_CLOSE
+/*---------------------------- dof_handler.h ---------------------------*/
#endif
/*---------------------------- dof_handler.h ---------------------------*/
// 2. Can cell_iterator and quad_iterator in 2D be different (or hex
// in 3D)?
+DEAL_II_NAMESPACE_OPEN
+
template <int structdim, class DH> class DoFAccessor;
template <class DH> class DoFCellAccessor;
template <int celldim, class DH> class DoFObjectAccessor;
}
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif // __deal2__dof_iterator_selector_h
#include <dofs/dof_objects.h>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
template <int> class DoFHandler;
template <int> class MGDoFHandler;
* Note that vertices are separate from, and in fact have nothing to
* do with cells. The indices of degrees of freedom located on
* vertices therefore are not stored here, but rather in member
- * variables of the ::DoFHandler class.
+ * variables of the dealii::DoFHandler class.
*
* The indices of degrees of freedom located on lower dimensional
* objects, i.e. on lines for 2D and on quads and lines for 3D are
* DoFHandler::get_dof_index() and corresponding setter functions.
* Knowledge of the actual data format is therefore
* encapsulated to the present hierarchy of classes as well as the
- * ::DoFHandler class.
+ * dealii::DoFHandler class.
*
* @ingroup dofs
* @author Wolfgang Bangerth, 1998, 2006
* resize arrays as
* necessary.
*/
- template <int> friend class ::DoFHandler;
- template <int> friend class ::MGDoFHandler;
+ template <int> friend class dealii::DoFHandler;
+ template <int> friend class dealii::MGDoFHandler;
};
* resize arrays as
* necessary.
*/
- template <int> friend class ::DoFHandler;
- template <int> friend class ::MGDoFHandler;
+ template <int> friend class dealii::DoFHandler;
+ template <int> friend class dealii::MGDoFHandler;
};
* resize arrays as
* necessary.
*/
- template <int> friend class ::DoFHandler;
- template <int> friend class ::MGDoFHandler;
+ template <int> friend class dealii::DoFHandler;
+ template <int> friend class dealii::MGDoFHandler;
};
}
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/exceptions.h>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
template <int> class DoFHandler;
namespace internal
*/
template <int spacedim>
void
- set_dof_index (const ::DoFHandler<spacedim> &dof_handler,
+ set_dof_index (const dealii::DoFHandler<spacedim> &dof_handler,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int local_index,
*/
template <int spacedim>
unsigned int
- get_dof_index (const ::DoFHandler<spacedim> &dof_handler,
+ get_dof_index (const dealii::DoFHandler<spacedim> &dof_handler,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int local_index) const;
*/
template <int spacedim>
unsigned int
- n_active_fe_indices (const ::DoFHandler<spacedim> &dof_handler,
+ n_active_fe_indices (const dealii::DoFHandler<spacedim> &dof_handler,
const unsigned int index) const;
/**
*/
template <int spacedim>
bool
- fe_index_is_active (const ::DoFHandler<spacedim> &dof_handler,
+ fe_index_is_active (const dealii::DoFHandler<spacedim> &dof_handler,
const unsigned int index,
const unsigned int fe_index) const;
template <int spacedim>
inline
unsigned int
- DoFObjects<dim>::n_active_fe_indices (const ::DoFHandler<spacedim> &,
+ DoFObjects<dim>::n_active_fe_indices (const dealii::DoFHandler<spacedim> &,
const unsigned) const
{
return 1;
template <int spacedim>
inline
bool
- DoFObjects<dim>::fe_index_is_active (const ::DoFHandler<spacedim> &,
+ DoFObjects<dim>::fe_index_is_active (const dealii::DoFHandler<spacedim> &,
const unsigned int,
const unsigned int fe_index) const
{
inline
unsigned int
DoFObjects<dim>::
- get_dof_index (const ::DoFHandler<spacedim> &dof_handler,
+ get_dof_index (const dealii::DoFHandler<spacedim> &dof_handler,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int local_index) const
{
- Assert (fe_index == ::DoFHandler<spacedim>::default_fe_index,
+ Assert (fe_index == dealii::DoFHandler<spacedim>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
Assert (local_index<dof_handler.get_fe().template n_dofs_per_object<dim>(),
ExcIndexRange (local_index, 0, dof_handler.get_fe().template n_dofs_per_object<dim>()));
}
}
+
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <vector>
+DEAL_II_NAMESPACE_OPEN
/**
* Implementation of a number of renumbering algorithms for the degrees of
DeclException0 (ExcNotDGFEM);
};
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <set>
#include <map>
+DEAL_II_NAMESPACE_OPEN
+
template<int dim, class T> class Table;
class SparsityPattern;
template <typename number> class Vector;
}
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <base/config.h>
#include <map>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class Function;
typedef std::map<unsigned char, const Function<dim>*> type;
};
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <vector>
+DEAL_II_NAMESPACE_OPEN
namespace hp
{
*/
unsigned int memory_consumption () const;
- template <int> friend class ::hp::DoFHandler;
+ template <int> friend class dealii::hp::DoFHandler;
};
/**
*/
unsigned int memory_consumption () const;
- template <int> friend class ::hp::DoFHandler;
+ template <int> friend class dealii::hp::DoFHandler;
};
/**
*/
unsigned int memory_consumption () const;
- template <int> friend class ::hp::DoFHandler;
+ template <int> friend class dealii::hp::DoFHandler;
};
} // namespace hp
} // namespace internal
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <map>
#include <set>
+DEAL_II_NAMESPACE_OPEN
namespace internal
{
* The default index of the
* finite element to be used on
* a given cell. For the usual,
- * non-hp ::DoFHandler class
+ * non-hp dealii::DoFHandler class
* that only supports the same
* finite element to be used on
* all cells, the index of the
/**
* Make accessor objects friends.
*/
- template <int structdim, class DH> friend class ::DoFAccessor;
+ template <int structdim, class DH> friend class dealii::DoFAccessor;
/**
* Make accessor objects friends.
*/
- template <int dim1, class DH> friend class ::DoFObjectAccessor;
+ template <int dim1, class DH> friend class dealii::DoFObjectAccessor;
/**
* Make accessor objects friends.
*/
- template <class DH> friend class ::DoFCellAccessor;
+ template <class DH> friend class dealii::DoFCellAccessor;
/**
* Likewise for DoFLevel
const unsigned int fe_index,
const unsigned int local_index) const
{
- Assert (fe_index != ::hp::DoFHandler<dim>::default_fe_index,
+ Assert (fe_index != dealii::hp::DoFHandler<dim>::default_fe_index,
ExcMessage ("You need to specify a FE index when working "
"with hp DoFHandlers"));
Assert (finite_elements != 0,
const unsigned int local_index,
const unsigned int global_index)
{
- Assert (fe_index != ::hp::DoFHandler<dim>::default_fe_index,
+ Assert (fe_index != dealii::hp::DoFHandler<dim>::default_fe_index,
ExcMessage ("You need to specify a FE index when working "
"with hp DoFHandlers"));
Assert (finite_elements != 0,
fe_is_active_on_vertex (const unsigned int vertex_index,
const unsigned int fe_index) const
{
- Assert (fe_index != ::hp::DoFHandler<dim>::default_fe_index,
+ Assert (fe_index != dealii::hp::DoFHandler<dim>::default_fe_index,
ExcMessage ("You need to specify a FE index when working "
"with hp DoFHandlers"));
Assert (finite_elements != 0,
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
+DEAL_II_NAMESPACE_OPEN
namespace internal
{
* resize arrays as
* necessary.
*/
- template <int> friend class ::hp::DoFHandler;
+ template <int> friend class dealii::hp::DoFHandler;
};
* resize arrays as
* necessary.
*/
- template <int> friend class ::hp::DoFHandler;
+ template <int> friend class dealii::hp::DoFHandler;
};
* resize arrays as
* necessary.
*/
- template <int> friend class ::hp::DoFHandler;
+ template <int> friend class dealii::hp::DoFHandler;
};
} // namespace hp
} // namespace internal
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
+DEAL_II_NAMESPACE_OPEN
namespace internal
{
*/
template <int spacedim>
void
- set_dof_index (const ::hp::DoFHandler<spacedim> &dof_handler,
+ set_dof_index (const dealii::hp::DoFHandler<spacedim> &dof_handler,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int local_index,
*/
template <int spacedim>
unsigned int
- get_dof_index (const ::hp::DoFHandler<spacedim> &dof_handler,
+ get_dof_index (const dealii::hp::DoFHandler<spacedim> &dof_handler,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int local_index,
*/
template <int spacedim>
unsigned int
- n_active_fe_indices (const ::hp::DoFHandler<spacedim> &dof_handler,
+ n_active_fe_indices (const dealii::hp::DoFHandler<spacedim> &dof_handler,
const unsigned int obj_index) const;
/**
*/
template <int spacedim>
unsigned int
- nth_active_fe_index (const ::hp::DoFHandler<spacedim> &dof_handler,
+ nth_active_fe_index (const dealii::hp::DoFHandler<spacedim> &dof_handler,
const unsigned int obj_level,
const unsigned int obj_index,
const unsigned int n) const;
*/
template <int spacedim>
bool
- fe_index_is_active (const ::hp::DoFHandler<spacedim> &dof_handler,
+ fe_index_is_active (const dealii::hp::DoFHandler<spacedim> &dof_handler,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int obj_level) const;
* resize arrays as
* necessary.
*/
- template <int> friend class ::hp::DoFHandler;
+ template <int> friend class dealii::hp::DoFHandler;
};
inline
unsigned int
DoFObjects<dim>::
- get_dof_index (const ::hp::DoFHandler<spacedim> &dof_handler,
+ get_dof_index (const dealii::hp::DoFHandler<spacedim> &dof_handler,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int local_index,
const unsigned int obj_level) const
{
- Assert (fe_index != ::hp::DoFHandler<spacedim>::default_fe_index,
+ Assert (fe_index != dealii::hp::DoFHandler<spacedim>::default_fe_index,
ExcMessage ("You need to specify a FE index when working "
"with hp DoFHandlers"));
Assert (&dof_handler != 0,
inline
void
DoFObjects<dim>::
- set_dof_index (const ::hp::DoFHandler<spacedim> &dof_handler,
+ set_dof_index (const dealii::hp::DoFHandler<spacedim> &dof_handler,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int local_index,
const unsigned int global_index,
const unsigned int obj_level)
{
- Assert (fe_index != ::hp::DoFHandler<spacedim>::default_fe_index,
+ Assert (fe_index != dealii::hp::DoFHandler<spacedim>::default_fe_index,
ExcMessage ("You need to specify a FE index when working "
"with hp DoFHandlers"));
Assert (&dof_handler != 0,
inline
unsigned int
DoFObjects<dim>::
- n_active_fe_indices (const ::hp::DoFHandler<spacedim> &dof_handler,
+ n_active_fe_indices (const dealii::hp::DoFHandler<spacedim> &dof_handler,
const unsigned int obj_index) const
{
Assert (dim <= spacedim, ExcInternalError());
inline
unsigned int
DoFObjects<dim>::
- nth_active_fe_index (const ::hp::DoFHandler<spacedim> &dof_handler,
+ nth_active_fe_index (const dealii::hp::DoFHandler<spacedim> &dof_handler,
const unsigned int obj_level,
const unsigned int obj_index,
const unsigned int n) const
inline
bool
DoFObjects<dim>::
- fe_index_is_active (const ::hp::DoFHandler<spacedim> &dof_handler,
+ fe_index_is_active (const dealii::hp::DoFHandler<spacedim> &dof_handler,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int obj_level) const
"this DoFHandler"));
Assert (obj_index < dof_offsets.size(),
ExcIndexRange (obj_index, 0, dof_offsets.size()));
- Assert (fe_index != ::hp::DoFHandler<spacedim>::default_fe_index,
+ Assert (fe_index != dealii::hp::DoFHandler<spacedim>::default_fe_index,
ExcMessage ("You need to specify a FE index when working "
"with hp DoFHandlers"));
Assert (fe_index < dof_handler.get_fe().size(),
}
}
-#endif
-
-
+DEAL_II_NAMESPACE_CLOSE
+#endif
#include <base/config.h>
#include <fe/fe_base.h>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class FEValuesData;
template <int dim> class FEValuesBase;
template <int dim> class FEValues;
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class MappingQ;
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <string>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
template<int dim> class FESystem;
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <boost/shared_ptr.hpp>
#include <fe/fe.h>
+DEAL_II_NAMESPACE_OPEN
namespace hp
{
} // namespace hp
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <base/polynomial_space.h>
#include <fe/fe_poly.h>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class MappingQ;
/*!@addtogroup fe */
#endif
#endif // DOXYGEN
+
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/polynomials_p.h>
#include <fe/fe_poly.h>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class MappingQ;
/*@}*/
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <base/polynomial_space.h>
#include <fe/fe.h>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class PolynomialSpace;
template <int dim> class MappingQ;
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/tensor_product_polynomials.h>
#include <fe/fe_poly.h>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class MappingQ;
template <int dim> class Quadrature;
/*@}*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/geometry_info.h>
#include <fe/fe.h>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class MappingQ;
#endif
#endif // DOXYGEN
+
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <fe/fe.h>
+DEAL_II_NAMESPACE_OPEN
+
/*!@addtogroup febase */
/*@{*/
/*@}*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <fe/fe_values.h>
#include <fe/fe_poly.h>
+DEAL_II_NAMESPACE_OPEN
+
template <class POLY, int dim>
FE_Poly<POLY,dim>::FE_Poly (const POLY& poly_space,
const FiniteElementData<dim> &fe_data,
}
+DEAL_II_NAMESPACE_CLOSE
#include <lac/full_matrix.h>
#include <fe/fe.h>
+DEAL_II_NAMESPACE_OPEN
+
/*!@addtogroup febase */
/*@{*/
/*@}*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/tensor_product_polynomials.h>
#include <fe/fe_poly.h>
+DEAL_II_NAMESPACE_OPEN
+
/*!@addtogroup fe */
/*@{*/
void FE_Q<3>::initialize_constraints ();
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/tensor_product_polynomials.h>
#include <fe/fe_poly.h>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class MappingQ;
std::vector<unsigned int>
FE_Q_Hierarchical<1>::face_fe_q_hierarchical_to_hierarchic_numbering (const unsigned int);
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class MappingQ;
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
#include <utility>
+DEAL_II_NAMESPACE_OPEN
/**
* This class provides an interface to group several elements together
template <> void FESystem<1>::initialize_unit_face_support_points ();
+DEAL_II_NAMESPACE_CLOSE
/*---------------------------- fe_system.h ---------------------------*/
#endif
#include <base/geometry_info.h>
#include <vector>
-
#include <boost/shared_ptr.hpp>
+
+DEAL_II_NAMESPACE_OPEN
+
template <typename number> class FullMatrix;
template <typename number> class Vector;
template <int dim> class Quadrature;
/*@}*/
+DEAL_II_NAMESPACE_CLOSE
+
/*---------------------------- fe_tools.h ---------------------------*/
/* end of #ifndef __deal2__fe_tools_H */
#endif
#include <base/config.h>
+DEAL_II_NAMESPACE_OPEN
/*!@addtogroup feaccess */
/*@{*/
/*@}*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <algorithm>
#include <memory>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class Quadrature;
//TODO: Add access to mapping values to FEValuesBase
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <map>
#include <boost/shared_ptr.hpp>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class MappingQ1;
template <int dim> class FiniteElement;
* that is common to them. The main task of this class is to provide a
* table where for every combination of finite element, mapping, and
* quadrature object from their corresponding collection objects there
- * is a matching ::FEValues, ::FEFaceValues, or ::FESubfaceValues
+ * is a matching dealii::FEValues, dealii::FEFaceValues, or dealii::FESubfaceValues
* object. To make things more efficient, however, these FE*Values
* objects are only created once requested (lazy allocation).
*
* i.e. for usual @p hp::FEValues it is equal to the first one, while
* for face integration it is one less. The third template parameter
* indicates the type of underlying non-hp FE*Values base type,
- * i.e. it could either be ::FEValues, ::FEFaceValues, or
- * ::FESubfaceValues.
+ * i.e. it could either be dealii::FEValues, dealii::FEFaceValues, or
+ * dealii::FESubfaceValues.
*
* @ingroup hp
*
* indicated by the parameters
* to the constructor.
*/
- FEValuesBase (const ::hp::MappingCollection<dim> &mapping_collection,
- const ::hp::FECollection<dim> &fe_collection,
- const ::hp::QCollection<q_dim> &q_collection,
+ FEValuesBase (const dealii::hp::MappingCollection<dim> &mapping_collection,
+ const dealii::hp::FECollection<dim> &fe_collection,
+ const dealii::hp::QCollection<q_dim> &q_collection,
const UpdateFlags update_flags);
/**
* Constructor. Set the fields
* object for the mapping
* object.
*/
- FEValuesBase (const ::hp::FECollection<dim> &fe_collection,
- const ::hp::QCollection<q_dim> &q_collection,
+ FEValuesBase (const dealii::hp::FECollection<dim> &fe_collection,
+ const dealii::hp::QCollection<q_dim> &q_collection,
const UpdateFlags update_flags);
/**
* collection of finite
* elements to be used.
*/
- const SmartPointer<const ::hp::FECollection<dim> > fe_collection;
+ const SmartPointer<const dealii::hp::FECollection<dim> > fe_collection;
/**
* A pointer to the
* collection of mappings to
* be used.
*/
- const SmartPointer<const ::hp::MappingCollection<dim> > mapping_collection;
+ const SmartPointer<const dealii::hp::MappingCollection<dim> > mapping_collection;
/**
* Copy of the quadrature
* provided to the
* constructor.
*/
- const ::hp::QCollection<q_dim> q_collection;
+ const dealii::hp::QCollection<q_dim> q_collection;
private:
/**
* @ingroup hp
*/
template <int dim>
- class FEValues : public internal::hp::FEValuesBase<dim,dim,::FEValues<dim> >
+ class FEValues : public internal::hp::FEValuesBase<dim,dim,dealii::FEValues<dim> >
{
public:
/**
* <tt>DoFHandler::get_fe()</tt>
* function.
*/
- FEValues (const ::hp::MappingCollection<dim> &mapping_collection,
- const ::hp::FECollection<dim> &fe_collection,
- const ::hp::QCollection<dim> &q_collection,
+ FEValues (const dealii::hp::MappingCollection<dim> &mapping_collection,
+ const dealii::hp::FECollection<dim> &fe_collection,
+ const dealii::hp::QCollection<dim> &q_collection,
const UpdateFlags update_flags);
* these last three arguments.
*/
void
- reinit (const typename ::DoFHandler<dim>::cell_iterator &cell,
+ reinit (const typename dealii::DoFHandler<dim>::cell_iterator &cell,
const unsigned int q_index = deal_II_numbers::invalid_unsigned_int,
const unsigned int mapping_index = deal_II_numbers::invalid_unsigned_int,
const unsigned int fe_index = deal_II_numbers::invalid_unsigned_int);
* @ingroup hp
*/
template <int dim>
- class FEFaceValues : public internal::hp::FEValuesBase<dim,dim-1,::FEFaceValues<dim> >
+ class FEFaceValues : public internal::hp::FEValuesBase<dim,dim-1,dealii::FEFaceValues<dim> >
{
public:
/**
* these last three arguments.
*/
void
- reinit (const typename ::DoFHandler<dim>::cell_iterator &cell,
+ reinit (const typename dealii::DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int q_index = deal_II_numbers::invalid_unsigned_int,
const unsigned int mapping_index = deal_II_numbers::invalid_unsigned_int,
* @ingroup hp
*/
template <int dim>
- class FESubfaceValues : public internal::hp::FEValuesBase<dim,dim-1,::FESubfaceValues<dim> >
+ class FESubfaceValues : public internal::hp::FEValuesBase<dim,dim-1,dealii::FESubfaceValues<dim> >
{
public:
/**
* these last three arguments.
*/
void
- reinit (const typename ::DoFHandler<dim>::cell_iterator &cell,
+ reinit (const typename dealii::DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
const unsigned int q_index = deal_II_numbers::invalid_unsigned_int,
}
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class Quadrature;
template <int dim> class FEValuesData;
template <int dim> class FEValues;
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/config.h>
#include <fe/mapping_q.h>
+DEAL_II_NAMESPACE_OPEN
/*!@addtogroup mapping */
/*@{*/
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <cmath>
#include <fe/mapping.h>
+DEAL_II_NAMESPACE_OPEN
/*!@addtogroup mapping */
/*@{*/
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
#include <boost/shared_ptr.hpp>
+DEAL_II_NAMESPACE_OPEN
namespace hp
{
} // namespace hp
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/table.h>
#include <fe/mapping_q1.h>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class TensorProductPolynomials;
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
/*!@addtogroup mapping */
/*@{*/
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/smartpointer.h>
#include <fe/mapping_q1.h>
+DEAL_II_NAMESPACE_OPEN
/*!@addtogroup mapping */
/*@{*/
/*@}*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
#include <boost/shared_ptr.hpp>
+DEAL_II_NAMESPACE_OPEN
namespace hp
{
} // namespace hp
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/exceptions.h>
#include <grid/tria_iterator_base.h>
+DEAL_II_NAMESPACE_OPEN
+
+
/**
* In this namespace a number of classes is declared that may be used
* as filters in the FilteredIterator class. The filters either
}
+DEAL_II_NAMESPACE_CLOSE
+
/*------------------------- filtered_iterator.h ------------------------*/
#endif
/*------------------------- filtered_iterator.h ------------------------*/
#include <base/point.h>
#include <map>
+DEAL_II_NAMESPACE_OPEN
template <int dim> class Triangulation;
template <typename number> class Vector;
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
#include <string>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class Point;
template <int dim> class Triangulation;
template <int dim> class CellData;
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/point.h>
#include <string>
+DEAL_II_NAMESPACE_OPEN
+
class ParameterHandler;
template <int dim> class Triangulation;
template <int dim> class Mapping;
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
+DEAL_II_NAMESPACE_OPEN
// forward declarations
template <int dim> class Triangulation;
};
+DEAL_II_NAMESPACE_CLOSE
#endif //__deal2__grid_refinement_h
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <vector>
+DEAL_II_NAMESPACE_OPEN
};
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <map>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
namespace internal
} // namespace internal
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <list>
+DEAL_II_NAMESPACE_OPEN
/**
}
+DEAL_II_NAMESPACE_CLOSE
/*---------------------------- grid_tools.h ---------------------------*/
/* end of #ifndef __deal2__grid_tools_H */
#include <grid/tria_accessor.h>
#include <grid/tria_iterator.h>
+DEAL_II_NAMESPACE_OPEN
+
/**
* This class provides a map between two grids which are derived from
};
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/config.h>
+DEAL_II_NAMESPACE_OPEN
// This is a list of magic numbers used throughout the library.
// They are collected in one file to avoid double usage.
const unsigned int mn_persistent_tria_flags_end = 0xa201;
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <grid/tria.h>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
/**
* This class handles the history of a triangulation and can rebuild it after
};
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
#include <list>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class Boundary;
template <int dim> class StraightBoundary;
+
+template <int, int> class TriaObjectAccessor;
+
namespace internal
{
namespace Triangulation
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/exceptions.h>
#include <grid/tria_iterator_base.h>
+namespace std
+{
+ template<class T1, class T2>
+ struct pair;
+}
+
+DEAL_II_NAMESPACE_OPEN
template <int dim> class Point;
template <int dim, typename Accessor> class TriaRawIterator;
template <int dim, typename Accessor> class TriaIterator;
template <int dim, typename Accessor> class TriaActiveIterator;
+
+
namespace internal
{
namespace Triangulation
template <int dim> class TriaObjectAccessor<3, dim>;
-namespace std
-{
- template<class T1, class T2>
- struct pair;
-}
-
// note: the file tria_accessor.templates.h is included at the end of
// this file. this includes a lot of templates. originally, this was
// only done in debug mode, but led to cyclic reduction problems and
template <> double TriaObjectAccessor<3, 3>::measure () const;
+#endif // DOXYGEN
+
+DEAL_II_NAMESPACE_CLOSE
// include more templates in debug and optimized mode
# include "tria_accessor.templates.h"
-#endif // DOXYGEN
-
#endif
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
/*------------------------ Functions: TriaAccessor ---------------------------*/
return !this->has_children();
}
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <base/point.h>
#include <grid/tria.h>
+DEAL_II_NAMESPACE_OPEN
template <int dim> class Triangulation;
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/config.h>
#include <grid/tria_boundary.h>
+DEAL_II_NAMESPACE_OPEN
/**
* Boundary object for the hull of a cylinder. In three dimensions,
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <grid/tria_hex.h>
#include <grid/tria_objects.h>
+DEAL_II_NAMESPACE_OPEN
+
namespace internal
{
namespace Triangulation
};
}
}
+
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/config.h>
#include <base/exceptions.h>
+DEAL_II_NAMESPACE_OPEN
+
namespace internal
{
namespace Triangulation
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
# include <iostream>
#endif
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class Triangulation;
// note: in non-debug mode, i.e. with optimizations, the file
}
+DEAL_II_NAMESPACE_CLOSE
+
// if in optimized mode: include more templates
#ifndef DEBUG
/*---------------------------- tria-iterator.h ---------------------------*/
-
#endif
/*---------------------------- tria-iterator.h ---------------------------*/
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <grid/tria.h>
#include <grid/tria_iterator.h>
+DEAL_II_NAMESPACE_OPEN
+
/* Note: This file only contains template definitions and will thus
not produce an object file. It is rather thought to be included
return tmp;
}
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/config.h>
+DEAL_II_NAMESPACE_OPEN
/**
* Namespace in which an enumeration is declared that denotes the
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#define __deal2__tria_iterator_selector_h
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class CellAccessor;
template <int dim> class TriaAccessor;
template <int, int> class TriaObjectAccessor;
template <int dim, typename Accessor> class TriaIterator;
template <int dim, typename Accessor> class TriaActiveIterator;
-
namespace internal
{
namespace Triangulation
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif // __deal2__tria_iterator_selector_h
#include <base/point.h>
#include <grid/tria_objects.h>
+DEAL_II_NAMESPACE_OPEN
+
namespace internal
{
namespace Triangulation
}
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/config.h>
#include <base/exceptions.h>
+DEAL_II_NAMESPACE_OPEN
namespace internal
{
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <grid/tria_hex.h>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
namespace internal
{
namespace Triangulation
}
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/config.h>
#include <base/exceptions.h>
+DEAL_II_NAMESPACE_OPEN
namespace internal
{
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/smartpointer.h>
#include <lac/vector.h>
+DEAL_II_NAMESPACE_OPEN
/*!@addtogroup mg */
/*@{*/
/*@}*/
+DEAL_II_NAMESPACE_CLOSE
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <multigrid/mg_level_object.h>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class MGDoFHandler;
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/matrix_lib.h>
#include <multigrid/mg_base.h>
+DEAL_II_NAMESPACE_OPEN
+
/*!@addtogroup mg */
/*@{*/
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/config.h>
#include <dofs/dof_accessor.h>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class MGDoFHandler;
template <int celldim, int dim> class MGDoFObjectAccessor;
template<> MGDoFCellAccessor<3>::face_iterator
MGDoFCellAccessor<3>::face (const unsigned int i) const;
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <dofs/dof_handler.h>
#include <multigrid/mg_dof_iterator_selector.h>
+DEAL_II_NAMESPACE_OPEN
/*!@addtogroup mg */
/*@{*/
void MGDoFHandler<3>::renumber_dofs (const unsigned int level,
const std::vector<unsigned int> &new_numbers);
+DEAL_II_NAMESPACE_CLOSE
-/*---------------------------- mg_dof.h ---------------------------*/
+/*---------------------------- mg_dof.h ---------------------------*/
#endif
/*---------------------------- mg_dof.h ---------------------------*/
#include <base/config.h>
+DEAL_II_NAMESPACE_OPEN
+
template <int celldim, int dim> class MGDoFAccessor;
template <int celldim, int dim> class MGDoFObjectAccessor;
template <int dim> class MGDoFObjectAccessor<0, dim>;
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
/*---------------------------- mg_dof_iterator_selector.h ---------------------------*/
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/subscriptor.h>
#include <vector>
-
#include <boost/shared_ptr.hpp>
+DEAL_II_NAMESPACE_OPEN
+
+
/*!@addtogroup mg */
/*@{*/
return result;
}
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <multigrid/mg_base.h>
#include <multigrid/mg_level_object.h>
+DEAL_II_NAMESPACE_OPEN
+
/*!@addtogroup mg */
/*@{*/
m[level].block(row, col).Tvmult_add(dst, src);
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <multigrid/mg_level_object.h>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class MGDoFHandler;
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
#include <set>
+DEAL_II_NAMESPACE_OPEN
+
template <class Object> class MGLevelObject;
template <int dim> class MGDoFHandler;
template <typename number> class Vector;
/*@}*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <boost/shared_ptr.hpp>
+DEAL_II_NAMESPACE_OPEN
+
+
template <int dim> class MGDoFHandler;
/*
: mg_component;
}
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <algorithm>
+DEAL_II_NAMESPACE_OPEN
/* --------------------- MGTransferPrebuilt -------------- */
}
}
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
/*!@addtogroup mg */
/*@{*/
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include "iostream"
-using namespace std;
-
-
-
-
-
-
-
+DEAL_II_NAMESPACE_OPEN
template <class VECTOR>
Assert(false, ExcNotImplemented());
}
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <boost/shared_ptr.hpp>
+DEAL_II_NAMESPACE_OPEN
template <int> class FEValuesBase;
* Abbreviate the somewhat lengthy
* name for the Patch class.
*/
- typedef ::DataOutBase::Patch<patch_dim,patch_space_dim> Patch;
+ typedef dealii::DataOutBase::Patch<patch_dim,patch_space_dim> Patch;
/**
* Pointer to the dof handler object.
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <string>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
/**
};
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <string>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
/**
};
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <string>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class DoFHandler;
/**
* List of patches of all past and
* present parameter value data sets.
*/
- std::vector< ::DataOutBase::Patch<dim+1,dim+1> > patches;
+ std::vector< dealii::DataOutBase::Patch<dim+1,dim+1> > patches;
/**
* Structure holding data vectors
* the base class DataOutBase) to
* the actual output function.
*/
- virtual const std::vector< ::DataOutBase::Patch<dim+1,dim+1> > & get_patches () const;
+ virtual const std::vector< dealii::DataOutBase::Patch<dim+1,dim+1> > & get_patches () const;
/**
};
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <fe/mapping.h>
#include <utility>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class DoFHandler;
namespace hp
{
DerivativeApproximation::SecondDerivative<3>::derivative_norm (const Derivative &d);
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <iomanip>
#include <fstream>
+DEAL_II_NAMESPACE_OPEN
/**
out.write (of);
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <dofs/function_map.h>
#include <map>
+DEAL_II_NAMESPACE_OPEN
+
template <int> class DoFHandler;
template <int> class Mapping;
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
#include <string>
+DEAL_II_NAMESPACE_OPEN
+
/**
* This class provides some facilities to generate 2d and 3d histograms.
};
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/exceptions.h>
#include <base/thread_management.h>
#include <dofs/function_map.h>
+
#include <map>
+DEAL_II_NAMESPACE_OPEN
+
// forward declarations
template <int dim> class Quadrature;
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
+DEAL_II_NAMESPACE_OPEN
/**
* Transfers a discrete FE function (like a solution vector) by interpolation
};
-/*---------------------------- solutiontransfer.h ---------------------------*/
+DEAL_II_NAMESPACE_CLOSE
+
+/*---------------------------- solutiontransfer.h ---------------------------*/
#endif
/*---------------------------- solutiontransfer.h ---------------------------*/
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <vector>
#include <utility>
+DEAL_II_NAMESPACE_OPEN
+
// forward declarations
class TimeStepBase;
template <typename number> class Vector;
};
}
+DEAL_II_NAMESPACE_CLOSE
/*---------------------------- time-dependent.h ---------------------------*/
-
#endif
/*---------------------------- time-dependent.h ---------------------------*/
#include <vector>
#include <set>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim> class Point;
template <int dim> class Function;
template <int dim> class FunctionMap;
};
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <vector>
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
//TODO[RH]: Use StaticQ1Mapping where appropriate
#if deal_II_dimension == 1
void
- interpolate_zero_boundary_values (const ::DoFHandler<1> &dof_handler,
+ interpolate_zero_boundary_values (const dealii::DoFHandler<1> &dof_handler,
std::map<unsigned int,double> &boundary_values)
{
// we only need to find the
// dof indices. that's easy :-)
for (unsigned direction=0; direction<2; ++direction)
{
- ::DoFHandler<1>::cell_iterator
+ dealii::DoFHandler<1>::cell_iterator
cell = dof_handler.begin(0);
while (!cell->at_boundary(direction))
cell = cell->neighbor(direction);
template <int dim>
void
- interpolate_zero_boundary_values (const ::DoFHandler<dim> &dof_handler,
+ interpolate_zero_boundary_values (const dealii::DoFHandler<dim> &dof_handler,
std::map<unsigned int,double> &boundary_values)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
// that is actually wholly on
// the boundary, not only by
// one line or one vertex
- typename ::DoFHandler<dim>::active_face_iterator
+ typename dealii::DoFHandler<dim>::active_face_iterator
face = dof_handler.begin_active_face(),
endf = dof_handler.end_face();
std::vector<unsigned int> face_dof_indices (fe.dofs_per_face);
template <int dim, class InVector, class OutVector, class DH>
static
void
- do_integrate_difference (const ::hp::MappingCollection<dim> &mapping,
+ do_integrate_difference (const dealii::hp::MappingCollection<dim> &mapping,
const DH &dof,
const InVector &fe_function,
const Function<dim> &exact_solution,
OutVector &difference,
- const ::hp::QCollection<dim> &q,
- const ::VectorTools::NormType &norm,
+ const dealii::hp::QCollection<dim> &q,
+ const dealii::VectorTools::NormType &norm,
const Function<dim> *weight,
const double exponent_1)
{
switch (norm)
{
- case ::VectorTools::L2_norm:
- case ::VectorTools::H1_seminorm:
- case ::VectorTools::H1_norm:
+ case dealii::VectorTools::L2_norm:
+ case dealii::VectorTools::H1_seminorm:
+ case dealii::VectorTools::H1_norm:
exponent = 2.;
break;
- case ::VectorTools::L1_norm:
+ case dealii::VectorTools::L1_norm:
exponent = 1.;
break;
default:
update_JxW_values);
switch (norm)
{
- case ::VectorTools::H1_seminorm:
- case ::VectorTools::W1p_seminorm:
- case ::VectorTools::W1infty_seminorm:
+ case dealii::VectorTools::H1_seminorm:
+ case dealii::VectorTools::W1p_seminorm:
+ case dealii::VectorTools::W1infty_seminorm:
update_flags |= UpdateFlags (update_gradients);
break;
- case ::VectorTools::H1_norm:
- case ::VectorTools::W1p_norm:
- case ::VectorTools::W1infty_norm:
+ case dealii::VectorTools::H1_norm:
+ case dealii::VectorTools::W1p_norm:
+ case dealii::VectorTools::W1infty_norm:
update_flags |= UpdateFlags (update_gradients);
// no break!
default:
break;
}
- ::hp::FECollection<dim> fe_collection (dof.get_fe());
- ::hp::FEValues<dim> x_fe_values(mapping, fe_collection, q, update_flags);
+ dealii::hp::FECollection<dim> fe_collection (dof.get_fe());
+ dealii::hp::FEValues<dim> x_fe_values(mapping, fe_collection, q, update_flags);
const unsigned int max_n_q_points = q.max_n_quadrature_points ();
// initialize for this cell
x_fe_values.reinit (cell);
- const ::FEValues<dim> &fe_values = x_fe_values.get_present_fe_values ();
+ const dealii::FEValues<dim> &fe_values = x_fe_values.get_present_fe_values ();
const unsigned int n_q_points = fe_values.n_quadrature_points;
// resize all out scratch
switch (norm)
{
- case ::VectorTools::mean:
+ case dealii::VectorTools::mean:
std::fill_n (psi_scalar.begin(), n_q_points, 0.0);
// Compute values in
// quadrature points
fe_values.get_JxW_values().begin(),
0.0);
break;
- case ::VectorTools::Lp_norm:
- case ::VectorTools::L1_norm:
- case ::VectorTools::W1p_norm:
+ case dealii::VectorTools::Lp_norm:
+ case dealii::VectorTools::L1_norm:
+ case dealii::VectorTools::W1p_norm:
std::fill_n (psi_scalar.begin(), n_q_points, 0.0);
// Compute values in
// quadrature points
if (!(update_flags & update_gradients))
diff = std::pow(diff, 1./exponent);
break;
- case ::VectorTools::L2_norm:
- case ::VectorTools::H1_norm:
+ case dealii::VectorTools::L2_norm:
+ case dealii::VectorTools::H1_norm:
std::fill_n (psi_scalar.begin(), n_q_points, 0.0);
// Compute values in
// quadrature points
// Compute the root only,
// if no derivative
// values are added later
- if (norm == ::VectorTools::L2_norm)
+ if (norm == dealii::VectorTools::L2_norm)
diff=std::sqrt(diff);
break;
- case ::VectorTools::Linfty_norm:
- case ::VectorTools::W1infty_norm:
+ case dealii::VectorTools::Linfty_norm:
+ case dealii::VectorTools::W1infty_norm:
std::fill_n (psi_scalar.begin(), n_q_points, 0.0);
for (unsigned int k=0; k<n_components; ++k)
for (unsigned int q=0; q<n_q_points; ++q)
// Maximum on one cell
diff = *std::max_element (psi_scalar.begin(), psi_scalar.end());
break;
- case ::VectorTools::H1_seminorm:
- case ::VectorTools::W1p_seminorm:
- case ::VectorTools::W1infty_seminorm:
+ case dealii::VectorTools::H1_seminorm:
+ case dealii::VectorTools::W1p_seminorm:
+ case dealii::VectorTools::W1infty_seminorm:
break;
default:
Assert (false, ExcNotImplemented());
switch (norm)
{
- case ::VectorTools::W1p_seminorm:
- case ::VectorTools::W1p_norm:
+ case dealii::VectorTools::W1p_seminorm:
+ case dealii::VectorTools::W1p_norm:
std::fill_n (psi_scalar.begin(), n_q_points, 0.0);
for (unsigned int k=0; k<n_components; ++k)
for (unsigned int q=0; q<n_q_points; ++q)
0.0);
diff = std::pow(diff, 1./exponent);
break;
- case ::VectorTools::H1_seminorm:
- case ::VectorTools::H1_norm:
+ case dealii::VectorTools::H1_seminorm:
+ case dealii::VectorTools::H1_norm:
// take square of integrand
std::fill_n (psi_scalar.begin(), n_q_points, 0.0);
for (unsigned int k=0; k<n_components; ++k)
0.0);
diff = std::sqrt(diff);
break;
- case ::VectorTools::W1infty_seminorm:
- case ::VectorTools::W1infty_norm:
+ case dealii::VectorTools::W1infty_seminorm:
+ case dealii::VectorTools::W1infty_norm:
Assert(false, ExcNotImplemented());
std::fill_n (psi_scalar.begin(), n_q_points, 0.0);
for (unsigned int k=0; k<n_components; ++k)
template <int dim, class InVector, class OutVector>
void
-VectorTools::integrate_difference (const ::hp::MappingCollection<dim> &mapping,
- const ::hp::DoFHandler<dim> &dof,
+VectorTools::integrate_difference (const dealii::hp::MappingCollection<dim> &mapping,
+ const dealii::hp::DoFHandler<dim> &dof,
const InVector &fe_function,
const Function<dim> &exact_solution,
OutVector &difference,
- const ::hp::QCollection<dim> &q,
+ const dealii::hp::QCollection<dim> &q,
const NormType &norm,
const Function<dim> *weight,
const double exponent)
template <int dim, class InVector, class OutVector>
void
-VectorTools::integrate_difference (const ::hp::DoFHandler<dim> &dof,
+VectorTools::integrate_difference (const dealii::hp::DoFHandler<dim> &dof,
const InVector &fe_function,
const Function<dim> &exact_solution,
OutVector &difference,
- const ::hp::QCollection<dim> &q,
+ const dealii::hp::QCollection<dim> &q,
const NormType &norm,
const Function<dim> *weight,
const double exponent)
return compute_mean_value(mapping, dof, quadrature, v, component);
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
/*------------------------- Functions: DoFCellAccessor -----------------------*/
template class TriaIterator <deal_II_dimension,DoFCellAccessor<hp::DoFHandler<deal_II_dimension> > >;
template class TriaActiveIterator<deal_II_dimension,DoFCellAccessor<hp::DoFHandler<deal_II_dimension> > >;
+DEAL_II_NAMESPACE_CLOSE
# include <iostream>
#endif
+DEAL_II_NAMESPACE_OPEN
+
bool
ConstraintMatrix::check_zero_weight (const std::pair<unsigned int, double> &p)
MATRIX_FUNCTIONS(PETScWrappers::MPI::SparseMatrix);
MATRIX_FUNCTIONS(PETScWrappers::MPI::BlockSparseMatrix);
#endif
+
+DEAL_II_NAMESPACE_CLOSE
#include <base/memory_consumption.h>
#include <dofs/dof_faces.h>
+DEAL_II_NAMESPACE_OPEN
+
namespace internal
{
}
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <set>
#include <algorithm>
+DEAL_II_NAMESPACE_OPEN
+
//TODO[WB]: do not use a plain pointer for faces, but rather an auto_ptr or some such thing
template <int dim>
const unsigned int * dummy ()
{
- return &::DoFHandler<dim>::invalid_dof_index;
+ return &dealii::DoFHandler<dim>::invalid_dof_index;
}
template const unsigned int * dummy<deal_II_dimension> ();
/*-------------- Explicit Instantiations -------------------------------*/
template class DoFHandler<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <base/memory_consumption.h>
#include <dofs/dof_levels.h>
+DEAL_II_NAMESPACE_OPEN
namespace internal
{
}
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <base/memory_consumption.h>
#include <dofs/dof_levels.h>
+DEAL_II_NAMESPACE_OPEN
+
namespace internal
{
}
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <dofs/dof_handler.h>
#include <fe/fe.h>
+DEAL_II_NAMESPACE_OPEN
+
namespace internal
{
namespace DoFHandler
template <int spacedim>
void
DoFObjects<dim>::
- set_dof_index (const ::DoFHandler<spacedim> &dof_handler,
+ set_dof_index (const dealii::DoFHandler<spacedim> &dof_handler,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int local_index,
const unsigned int global_index)
{
- Assert (fe_index == ::DoFHandler<spacedim>::default_fe_index,
+ Assert (fe_index == dealii::DoFHandler<spacedim>::default_fe_index,
ExcMessage ("Only the default FE index is allowed for non-hp DoFHandler objects"));
Assert (local_index<dof_handler.get_fe().template n_dofs_per_object<dim>(),
ExcIndexRange (local_index, 0, dof_handler.get_fe().template n_dofs_per_object<dim>()));
template
unsigned int
DoFObjects<1>::
- get_dof_index (const ::DoFHandler<deal_II_dimension> &dof_handler,
+ get_dof_index (const dealii::DoFHandler<deal_II_dimension> &dof_handler,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int local_index) const;
template
void
DoFObjects<1>::
- set_dof_index (const ::DoFHandler<deal_II_dimension> &dof_handler,
+ set_dof_index (const dealii::DoFHandler<deal_II_dimension> &dof_handler,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int local_index,
template
unsigned int
DoFObjects<2>::
- get_dof_index (const ::DoFHandler<deal_II_dimension> &dof_handler,
+ get_dof_index (const dealii::DoFHandler<deal_II_dimension> &dof_handler,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int local_index) const;
template
void
DoFObjects<2>::
- set_dof_index (const ::DoFHandler<deal_II_dimension> &dof_handler,
+ set_dof_index (const dealii::DoFHandler<deal_II_dimension> &dof_handler,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int local_index,
template
unsigned int
DoFObjects<3>::
- get_dof_index (const ::DoFHandler<deal_II_dimension> &dof_handler,
+ get_dof_index (const dealii::DoFHandler<deal_II_dimension> &dof_handler,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int local_index) const;
template
void
DoFObjects<3>::
- set_dof_index (const ::DoFHandler<deal_II_dimension> &dof_handler,
+ set_dof_index (const dealii::DoFHandler<deal_II_dimension> &dof_handler,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int local_index,
}
}
+
+DEAL_II_NAMESPACE_CLOSE
extern "C" long int lrand48 (void);
#endif
+DEAL_II_NAMESPACE_OPEN
+
// The following two classes are defined to be used in the compute_*
const unsigned int,
const std::vector<MGDoFHandler<deal_II_dimension>::cell_iterator>&);
+DEAL_II_NAMESPACE_CLOSE
#include <algorithm>
#include <numeric>
+DEAL_II_NAMESPACE_OPEN
+
//#define WOLFGANG
};
- template <int dim> struct DoFHandlerSupportsDifferentP< ::DoFHandler<dim> >
+ template <int dim> struct DoFHandlerSupportsDifferentP< dealii::DoFHandler<dim> >
{
static const bool value = false;
};
- template <int dim> struct DoFHandlerSupportsDifferentP< ::MGDoFHandler<dim> >
+ template <int dim> struct DoFHandlerSupportsDifferentP< dealii::MGDoFHandler<dim> >
{
static const bool value = false;
};
*/
template <int dim>
unsigned int
- n_finite_elements (const ::hp::DoFHandler<dim> &dof_handler)
+ n_finite_elements (const dealii::hp::DoFHandler<dim> &dof_handler)
{
return dof_handler.get_fe().size();
}
#if deal_II_dimension == 1
static
void
- make_hp_hanging_node_constraints (const ::DoFHandler<1> &,
+ make_hp_hanging_node_constraints (const dealii::DoFHandler<1> &,
ConstraintMatrix &)
{
// nothing to do for regular
static
void
- make_oldstyle_hanging_node_constraints (const ::DoFHandler<1> &,
+ make_oldstyle_hanging_node_constraints (const dealii::DoFHandler<1> &,
ConstraintMatrix &,
- ::internal::int2type<1>)
+ dealii::internal::int2type<1>)
{
// nothing to do for regular
// dof handlers in 1d
static
void
- make_hp_hanging_node_constraints (const ::MGDoFHandler<1> &,
+ make_hp_hanging_node_constraints (const dealii::MGDoFHandler<1> &,
ConstraintMatrix &)
{
// nothing to do for regular
static
void
- make_oldstyle_hanging_node_constraints (const ::MGDoFHandler<1> &,
+ make_oldstyle_hanging_node_constraints (const dealii::MGDoFHandler<1> &,
ConstraintMatrix &,
- ::internal::int2type<1>)
+ dealii::internal::int2type<1>)
{
// nothing to do for regular
// dof handlers in 1d
static
void
- make_hp_hanging_node_constraints (const ::hp::DoFHandler<1> &/*dof_handler*/,
+ make_hp_hanging_node_constraints (const dealii::hp::DoFHandler<1> &/*dof_handler*/,
ConstraintMatrix &/*constraints*/)
{
// we may have to compute
static
void
- make_oldstyle_hanging_node_constraints (const ::hp::DoFHandler<1> &/*dof_handler*/,
+ make_oldstyle_hanging_node_constraints (const dealii::hp::DoFHandler<1> &/*dof_handler*/,
ConstraintMatrix &/*constraints*/,
- ::internal::int2type<1>)
+ dealii::internal::int2type<1>)
{
// we may have to compute
// constraints for
void
make_oldstyle_hanging_node_constraints (const DH &dof_handler,
ConstraintMatrix &constraints,
- ::internal::int2type<2>)
+ dealii::internal::int2type<2>)
{
const unsigned int dim = 2;
void
make_oldstyle_hanging_node_constraints (const DH &dof_handler,
ConstraintMatrix &constraints,
- ::internal::int2type<3>)
+ dealii::internal::int2type<3>)
{
const unsigned int dim = 3;
internal::DoFTools::
make_oldstyle_hanging_node_constraints (dof_handler,
constraints,
- ::internal::int2type<DH::dimension>());
+ dealii::internal::int2type<DH::dimension>());
}
const hp::DoFHandler<deal_II_dimension>&, const Table<2, Coupling>&,
std::vector<Table<2,Coupling> >&);
+
+DEAL_II_NAMESPACE_CLOSE
#include <base/memory_consumption.h>
#include <dofs/hp_dof_faces.h>
+DEAL_II_NAMESPACE_OPEN
namespace internal
{
}
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <algorithm>
#include <functional>
+DEAL_II_NAMESPACE_OPEN
namespace internal
{
/*-------------- Explicit Instantiations -------------------------------*/
template class DoFHandler<deal_II_dimension>;
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <base/memory_consumption.h>
#include <dofs/hp_dof_levels.h>
+DEAL_II_NAMESPACE_OPEN
namespace internal
{
}
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <base/memory_consumption.h>
#include <dofs/hp_dof_levels.h>
+DEAL_II_NAMESPACE_OPEN
namespace internal
{
}
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <dofs/hp_dof_levels.h>
#include <dofs/hp_dof_handler.h>
+DEAL_II_NAMESPACE_OPEN
//TODO: Several of the functions in this file are identical. some template trickery should make it possible to merge them
#endif
}
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <functional>
#include <numeric>
+DEAL_II_NAMESPACE_OPEN
/*------------------------------- FiniteElement ----------------------*/
/*------------------------------- Explicit Instantiations -------------*/
template class FiniteElement<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <iostream>
-using namespace std;
+
+DEAL_II_NAMESPACE_OPEN
template <int dim>
template class FE_ABF<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <base/memory_consumption.h>
#include <fe/fe_collection.h>
+DEAL_II_NAMESPACE_OPEN
namespace hp
{
template class FECollection<deal_II_dimension>;
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <base/geometry_info.h>
#include <fe/fe.h>
+DEAL_II_NAMESPACE_OPEN
template<int dim>
FiniteElementData<dim>::FiniteElementData ()
template class FiniteElementData<1>;
template class FiniteElementData<2>;
template class FiniteElementData<3>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <sstream>
+DEAL_II_NAMESPACE_OPEN
template <int dim>
FE_DGP<dim>::FE_DGP (const unsigned int degree)
template class FE_DGP<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <sstream>
+DEAL_II_NAMESPACE_OPEN
// namespace for some functions that are used in this file.
namespace
template class FE_DGPMonomial<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <sstream>
+DEAL_II_NAMESPACE_OPEN
template <int dim>
FE_DGPNonparametric<dim>::FE_DGPNonparametric (const unsigned int degree)
template class FE_DGPNonparametric<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <iostream>
#include <sstream>
+DEAL_II_NAMESPACE_OPEN
// namespace for some functions that are used in this file. they are
inline Point<1>
generate_unit_point (const unsigned int i,
const unsigned int N,
- const ::internal::int2type<1> )
+ const dealii::internal::int2type<1> )
{
Assert (i<N, ExcInternalError());
if (N==1)
inline Point<2>
generate_unit_point (const unsigned int i,
const unsigned int N,
- const ::internal::int2type<2> )
+ const dealii::internal::int2type<2> )
{
Assert (i<N, ExcInternalError());
inline Point<3>
generate_unit_point (const unsigned int i,
const unsigned int N,
- const ::internal::int2type<3> )
+ const dealii::internal::int2type<3> )
{
Assert (i<N, ExcInternalError());
if (N==1)
// cell and evaluate the
// shape functions there
const Point<dim> p = generate_unit_point (j, this->dofs_per_cell,
- ::internal::int2type<dim>());
+ dealii::internal::int2type<dim>());
for (unsigned int i=0; i<this->dofs_per_cell; ++i)
cell_interpolation(j,i)
= this->poly_space.compute_value (i, p);
template class FE_DGQ<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <sstream>
+DEAL_II_NAMESPACE_OPEN
//TODO: Remove doubled degrees
}
-
template class FE_Nedelec<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
+
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <fe/fe_nedelec.h>
+DEAL_II_NAMESPACE_OPEN
template <>
const double * const
const double * const
FE_Nedelec<1>::Matrices::constraint_matrices[] = {0};
+DEAL_II_NAMESPACE_CLOSE
#else // #if deal_II_dimension
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <fe/fe_nedelec.h>
+DEAL_II_NAMESPACE_OPEN
+
// Transfer matrices for finite elements: have one matrix for each of
// the four child cells which tells us how the degrees of freedom on
// the child cell are obtained from the degrees of freedom on the
sizeof(FE_Nedelec<2>::Matrices::constraint_matrices[0]);
+DEAL_II_NAMESPACE_CLOSE
#else // #if deal_II_dimension
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <fe/fe_nedelec.h>
+DEAL_II_NAMESPACE_OPEN
+
+
// Transfer matrices for finite elements: have one matrix for each of
// the four child cells which tells us how the degrees of freedom on
// the child cell are obtained from the degrees of freedom on the
sizeof(FE_Nedelec<3>::Matrices::constraint_matrices[0]);
+DEAL_II_NAMESPACE_CLOSE
#else // #if deal_II_dimension
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
#include <fe/fe_poly.templates.h>
+DEAL_II_NAMESPACE_OPEN
+
template class FE_Poly<TensorProductPolynomials<deal_II_dimension>, deal_II_dimension>;
template class FE_Poly<PolynomialSpace<deal_II_dimension>, deal_II_dimension>;
template class FE_Poly<PolynomialsP<deal_II_dimension>, deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <base/logstream.h>
+DEAL_II_NAMESPACE_OPEN
namespace
{
template class FE_PolyTensor<PolynomialsRaviartThomas<deal_II_dimension>,deal_II_dimension>;
template class FE_PolyTensor<PolynomialsABF<deal_II_dimension>,deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <sstream>
+DEAL_II_NAMESPACE_OPEN
//TODO: we should have a copy constructor for this class. In hp methods, we often do things like
// fe_collection.push_back(FE_Q<dim>(7))
Point<1>
generate_unit_point (const unsigned int i,
const unsigned int N,
- const ::internal::int2type<1> )
+ const dealii::internal::int2type<1> )
{
Assert (i<N, ExcInternalError());
const double h = 1./(N-1);
Point<2>
generate_unit_point (const unsigned int i,
const unsigned int N,
- const ::internal::int2type<2> )
+ const dealii::internal::int2type<2> )
{
Assert (i<N, ExcInternalError());
Assert (N>=4, ExcInternalError());
Point<3>
generate_unit_point (const unsigned int i,
const unsigned int N,
- const ::internal::int2type<3> )
+ const dealii::internal::int2type<3> )
{
Assert (i<N, ExcInternalError());
Assert (N>=8, ExcInternalError());
// shape functions there
const Point<dim>
p = FE_Q_Helper::generate_unit_point (index_map[j], this->dofs_per_cell,
- ::internal::int2type<dim>());
+ dealii::internal::int2type<dim>());
for (unsigned int i=0; i<this->dofs_per_cell; ++i)
cell_interpolation(j,i) = this->poly_space.compute_value (i, p);
// functions there
const Point<dim> p_subcell
= FE_Q_Helper::generate_unit_point (index_map[j], this->dofs_per_cell,
- ::internal::int2type<dim>());
+ dealii::internal::int2type<dim>());
const Point<dim> p_cell =
GeometryInfo<dim>::child_to_cell_coordinates (p_subcell, child);
{
const Point<dim> p_cell
= FE_Q_Helper::generate_unit_point (i, this->dofs_per_cell,
- ::internal::int2type<dim>());
+ dealii::internal::int2type<dim>());
unsigned int mother_dof = 0;
for (; mother_dof<this->dofs_per_cell; ++mother_dof)
{
template class FE_Q<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <cmath>
#include <sstream>
+DEAL_II_NAMESPACE_OPEN
namespace
{
template class FE_Q_Hierarchical<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <sstream>
#include <iostream>
+DEAL_II_NAMESPACE_OPEN
template <int dim>
FE_RaviartThomas<dim>::FE_RaviartThomas (const unsigned int deg)
template class FE_RaviartThomas<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <sstream>
+DEAL_II_NAMESPACE_OPEN
+
+
template <int dim>
FE_RaviartThomasNodal<dim>::FE_RaviartThomasNodal (const unsigned int deg)
:
template class FE_RaviartThomasNodal<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <sstream>
+DEAL_II_NAMESPACE_OPEN
/* ----------------------- FESystem::InternalData ------------------- */
// explicit instantiations
template class FESystem<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <fe/fe.h>
#include <fe/fe_tools.h>
+DEAL_II_NAMESPACE_OPEN
template <int dim>
FETools::lexicographic_to_hierarchic_numbering<3>
(const FiniteElementData<3> &fe,
std::vector<unsigned int> &l2h);
+
+DEAL_II_NAMESPACE_CLOSE
#include <boost/shared_ptr.hpp>
+DEAL_II_NAMESPACE_OPEN
+
+
// This is the map used by FETools::get_fe_from_name and
// FETools::add_fe_name. Since FEFactoryBase has a template parameter
// dim, it could not be a member variable of FETools. On the other
fe_name_map;
+
namespace
{
template <int dim>
/*---------------------------- fe_tools.cc ---------------------------*/
+
+DEAL_II_NAMESPACE_CLOSE
#include <iomanip>
+DEAL_II_NAMESPACE_OPEN
/* ---------------- FEValuesBase<dim>::CellIteratorBase --------- */
template class FESubfaceValues<deal_II_dimension>;
#endif
+DEAL_II_NAMESPACE_CLOSE
//---------------------------------------------------------------------------
#include "fe_values.instance.h"
#undef IN
#endif
+
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// Definition of vector type macros is in fe_values.cc
+DEAL_II_NAMESPACE_OPEN
template
void FEValuesBase<deal_II_dimension>::get_function_values<IN>
template
void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives<IN>
(const IN&, std::vector<std::vector<Tensor<2,deal_II_dimension> > > &, bool) const;
+
+DEAL_II_NAMESPACE_CLOSE
#include <fe/hp_fe_values.h>
#include <fe/mapping_q1.h>
+DEAL_II_NAMESPACE_OPEN
namespace internal
{
template <int dim, int q_dim, class FEValues>
FEValuesBase<dim,q_dim,FEValues>::
- FEValuesBase (const ::hp::MappingCollection<dim> &mapping_collection,
- const ::hp::FECollection<dim> &fe_collection,
- const ::hp::QCollection<q_dim> &q_collection,
+ FEValuesBase (const dealii::hp::MappingCollection<dim> &mapping_collection,
+ const dealii::hp::FECollection<dim> &fe_collection,
+ const dealii::hp::QCollection<q_dim> &q_collection,
const UpdateFlags update_flags)
:
fe_collection (&fe_collection),
template <int dim, int q_dim, class FEValues>
FEValuesBase<dim,q_dim,FEValues>::
- FEValuesBase (const ::hp::FECollection<dim> &fe_collection,
- const ::hp::QCollection<q_dim> &q_collection,
+ FEValuesBase (const dealii::hp::FECollection<dim> &fe_collection,
+ const dealii::hp::QCollection<q_dim> &q_collection,
const UpdateFlags update_flags)
:
fe_collection (&fe_collection),
- mapping_collection (&::hp::StaticMappingQ1<dim>::mapping_collection),
+ mapping_collection (&dealii::hp::StaticMappingQ1<dim>::mapping_collection),
q_collection (q_collection),
fe_values_table (fe_collection.size(),
1,
const hp::QCollection<dim> &q_collection,
const UpdateFlags update_flags)
:
- internal::hp::FEValuesBase<dim,dim,::FEValues<dim> > (mapping,
+ internal::hp::FEValuesBase<dim,dim,dealii::FEValues<dim> > (mapping,
fe_collection,
q_collection,
update_flags)
const hp::QCollection<dim> &q_collection,
const UpdateFlags update_flags)
:
- internal::hp::FEValuesBase<dim,dim,::FEValues<dim> > (fe_collection,
+ internal::hp::FEValuesBase<dim,dim,dealii::FEValues<dim> > (fe_collection,
q_collection,
update_flags)
{}
template <int dim>
void
- FEValues<dim>::reinit (const typename ::DoFHandler<dim>::cell_iterator &cell,
+ FEValues<dim>::reinit (const typename dealii::DoFHandler<dim>::cell_iterator &cell,
const unsigned int q_index,
const unsigned int mapping_index,
const unsigned int fe_index)
const hp::QCollection<dim-1> &q_collection,
const UpdateFlags update_flags)
:
- internal::hp::FEValuesBase<dim,dim-1,::FEFaceValues<dim> > (mapping,
+ internal::hp::FEValuesBase<dim,dim-1,dealii::FEFaceValues<dim> > (mapping,
fe_collection,
q_collection,
update_flags)
const hp::QCollection<dim-1> &q_collection,
const UpdateFlags update_flags)
:
- internal::hp::FEValuesBase<dim,dim-1,::FEFaceValues<dim> > (fe_collection,
+ internal::hp::FEValuesBase<dim,dim-1,dealii::FEFaceValues<dim> > (fe_collection,
q_collection,
update_flags)
{}
template <int dim>
void
- FEFaceValues<dim>::reinit (const typename ::DoFHandler<dim>::cell_iterator &cell,
+ FEFaceValues<dim>::reinit (const typename dealii::DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int q_index,
const unsigned int mapping_index,
const hp::QCollection<dim-1> &q_collection,
const UpdateFlags update_flags)
:
- internal::hp::FEValuesBase<dim,dim-1,::FESubfaceValues<dim> > (mapping,
+ internal::hp::FEValuesBase<dim,dim-1,dealii::FESubfaceValues<dim> > (mapping,
fe_collection,
q_collection,
update_flags)
const hp::QCollection<dim-1> &q_collection,
const UpdateFlags update_flags)
:
- internal::hp::FEValuesBase<dim,dim-1,::FESubfaceValues<dim> > (fe_collection,
+ internal::hp::FEValuesBase<dim,dim-1,dealii::FESubfaceValues<dim> > (fe_collection,
q_collection,
update_flags)
{}
template <int dim>
void
- FESubfaceValues<dim>::reinit (const typename ::DoFHandler<dim>::cell_iterator &cell,
+ FESubfaceValues<dim>::reinit (const typename dealii::DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
const unsigned int q_index,
namespace hp
{
template class FEValuesBase<deal_II_dimension,deal_II_dimension,
- ::FEValues<deal_II_dimension> >;
+ dealii::FEValues<deal_II_dimension> >;
#if deal_II_dimension >= 2
template class FEValuesBase<deal_II_dimension,deal_II_dimension-1,
- ::FEFaceValues<deal_II_dimension> >;
+ dealii::FEFaceValues<deal_II_dimension> >;
template class FEValuesBase<deal_II_dimension,deal_II_dimension-1,
- ::FESubfaceValues<deal_II_dimension> >;
+ dealii::FESubfaceValues<deal_II_dimension> >;
#endif
}
}
template class FESubfaceValues<deal_II_dimension>;
#endif
}
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <grid/tria.h>
#include <fe/mapping.h>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim>
Mapping<dim>::~Mapping ()
template class Mapping<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <fe/mapping_c1.h>
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
// explicit instantiations
template class MappingC1<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <algorithm>
+DEAL_II_NAMESPACE_OPEN
template <int dim>
// explicit instantiations
template class MappingCartesian<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <base/memory_consumption.h>
#include <fe/mapping_collection.h>
+DEAL_II_NAMESPACE_OPEN
+
namespace hp
{
template struct StaticMappingQ1<deal_II_dimension>;
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <numeric>
#include <memory>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim>
const bool MappingQ<dim>::use_mapping_q_on_all_cells;
// explicit instantiation
template class MappingQ<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <algorithm>
#include <memory>
+DEAL_II_NAMESPACE_OPEN
+DEAL_II_NAMESPACE_CLOSE
#include <dofs/dof_accessor.h>
#include <fe/fe.h>
+DEAL_II_NAMESPACE_OPEN
template <int dim, class EulerVectorType>
#ifdef DEAL_II_USE_PETSC
template class MappingQ1Eulerian<deal_II_dimension, PETScWrappers::Vector>;
#endif
+
+DEAL_II_NAMESPACE_CLOSE
#include <base/memory_consumption.h>
#include <fe/q_collection.h>
+DEAL_II_NAMESPACE_OPEN
namespace hp
}
+DEAL_II_NAMESPACE_CLOSE
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
+
template <int dim>
void
GridGenerator::
laplace_transformation<deal_II_dimension> (Triangulation<deal_II_dimension> &,
const std::map<unsigned int,Point<deal_II_dimension> > &);
+
+DEAL_II_NAMESPACE_CLOSE
#include <netcdfcpp.h>
#endif
+DEAL_II_NAMESPACE_OPEN
+
template <int dim>
GridIn<dim>::GridIn () :
//explicit instantiations
template class GridIn<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <grid/grid_out.h>
#include <base/parameter_handler.h>
+DEAL_II_NAMESPACE_OPEN
+
+
namespace GridOutFlags
{
DX::DX (const bool write_cells,
sizeof(eps_flags_3) +
sizeof(xfig_flags));
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <ctime>
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
#if deal_II_dimension == 1
template void GridOut::write<deal_II_dimension>
(const Triangulation<deal_II_dimension> &,
std::ostream &, const Mapping<deal_II_dimension> *) const;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <functional>
#include <fstream>
+DEAL_II_NAMESPACE_OPEN
+
namespace
if (refine_cells || coarsen_cells)
{
- ::Vector<typename Vector::value_type> tmp(criteria);
+ dealii::Vector<typename Vector::value_type> tmp(criteria);
if (refine_cells)
{
std::nth_element (tmp.begin(), tmp.begin()+refine_cells,
// error, which is what we have to sum
// up and compare with
// @p{fraction_of_error*total_error}.
- ::Vector<typename Vector::value_type> tmp(criteria);
+ dealii::Vector<typename Vector::value_type> tmp(criteria);
const double total_error = tmp.l1_norm();
// sort the largest criteria to the
std::sort (tmp.begin(), tmp.end(), std::greater<double>());
// compute thresholds
- typename ::Vector<typename Vector::value_type>::const_iterator pp=tmp.begin();
+ typename dealii::Vector<typename Vector::value_type>::const_iterator pp=tmp.begin();
for (double sum=0; (sum<top_fraction*total_error) && (pp!=(tmp.end()-1)); ++pp)
sum += *pp;
double top_threshold = ( pp != tmp.begin () ?
(*pp+*(pp-1))/2 :
*pp );
- typename ::Vector<typename Vector::value_type>::const_iterator qq=(tmp.end()-1);
+ typename dealii::Vector<typename Vector::value_type>::const_iterator qq=(tmp.end()-1);
for (double sum=0; (sum<bottom_fraction*total_error) && (qq!=tmp.begin()); --qq)
sum += *qq;
double bottom_threshold = ( qq != (tmp.end()-1) ?
refine_and_coarsen_optimize (Triangulation<deal_II_dimension> &,
const PETScWrappers::Vector &);
#endif
+
+DEAL_II_NAMESPACE_CLOSE
+
#include <iostream>
#include <fstream>
+DEAL_II_NAMESPACE_OPEN
+
#if deal_II_dimension == 1
#endif // deal_II_dimension == 3
+DEAL_II_NAMESPACE_CLOSE
+
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
// This anonymous namespace contains utility functions to extract the
// triangulation from any container such as DoFHandler, MGDoFHandler,
template
double
GridTools::maximal_cell_diameter (const Triangulation<deal_II_dimension> &triangulation);
+
+DEAL_II_NAMESPACE_CLOSE
+
#include <multigrid/mg_dof_handler.h>
#include <multigrid/mg_dof_accessor.h>
+DEAL_II_NAMESPACE_OPEN
+
+
// helper function to aquire the number of levels within a grid
template <class GridClass>
unsigned int
template class InterGridMap<hp::DoFHandler<deal_II_dimension> >;
template class InterGridMap<MGDoFHandler<deal_II_dimension> >;
+
+DEAL_II_NAMESPACE_CLOSE
+
#include <grid/magic_numbers.h>
#include <iostream>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim>
const unsigned int
// explicit instantiations
template class PersistentTriangulation<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
+
#include <numeric>
+DEAL_II_NAMESPACE_OPEN
+
bool
}
}
}
+
+DEAL_II_NAMESPACE_CLOSE
+
#include <cmath>
#include <iostream>
+DEAL_II_NAMESPACE_OPEN
+
// initialize the @p{straight_boundary} pointer of the triangulation
// class. for the reasons why it is done like this, see the
// explicit instantiations
template class Triangulation<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
+
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim>
const unsigned int TriaAccessor<dim>::objectdim;
template class TriaIterator<deal_II_dimension,TriaObjectAccessor<3, deal_II_dimension> >;
template class TriaActiveIterator<deal_II_dimension,TriaObjectAccessor<3, deal_II_dimension> >;
#endif
+
+DEAL_II_NAMESPACE_CLOSE
+
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <grid/tria_accessor.h>
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
/* -------------------------- Boundary --------------------- */
// explicit instantiations
template class Boundary<deal_II_dimension>;
template class StraightBoundary<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
+
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/tensor.h>
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim>
CylinderBoundary<dim>::CylinderBoundary (const double radius,
template class HalfHyperBallBoundary<deal_II_dimension>;
template class HyperShellBoundary<deal_II_dimension>;
template class HalfHyperShellBoundary<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
+
#include <base/memory_consumption.h>
#include <grid/tria_faces.h>
+DEAL_II_NAMESPACE_OPEN
+
namespace internal
{
}
}
+
+DEAL_II_NAMESPACE_CLOSE
+
#include <base/memory_consumption.h>
#include <grid/tria_levels.h>
+DEAL_II_NAMESPACE_OPEN
+
namespace internal
{
namespace Triangulation
}
}
+
+DEAL_II_NAMESPACE_CLOSE
+
#include <base/memory_consumption.h>
#include <grid/tria_levels.h>
+DEAL_II_NAMESPACE_OPEN
+
+
namespace internal
{
namespace Triangulation
}
}
+
+DEAL_II_NAMESPACE_CLOSE
+
#include <algorithm>
#include <functional>
+DEAL_II_NAMESPACE_OPEN
+
namespace internal
{
template class TriaObjects<Quad>;
}
}
+
+DEAL_II_NAMESPACE_CLOSE
+
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/vector.h>
#include <lac/block_vector.h>
+DEAL_II_NAMESPACE_OPEN
+
template <class VECTOR>
MGTransferBase<VECTOR>::~MGTransferBase()
template class MGCoarseGridBase<Vector<float> >;
template class MGCoarseGridBase<BlockVector<double> >;
template class MGCoarseGridBase<BlockVector<float> >;
+
+DEAL_II_NAMESPACE_CLOSE
#include <lac/full_matrix.h>
#include <lac/sparse_matrix.h>
+DEAL_II_NAMESPACE_OPEN
+
+
//TODO:[GK] Inline simple functions in 1d and 3d
/* ------------------------ MGDoFAccessor --------------------------- */
template class TriaIterator <3,MGDoFCellAccessor<3> >;
template class TriaActiveIterator<3,MGDoFCellAccessor<3> >;
#endif
+
+DEAL_II_NAMESPACE_CLOSE
#include <lac/sparse_matrix.h>
#include <base/exceptions.h>
-
#include <algorithm>
+DEAL_II_NAMESPACE_OPEN
+
+
/* ------------------------ MGVertexDoFs ----------------------------------- */
// explicit instantiations
template class MGDoFHandler<deal_II_dimension>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <algorithm>
#include <numeric>
+DEAL_II_NAMESPACE_OPEN
+
#if deal_II_dimension == 1
}
+DEAL_II_NAMESPACE_CLOSE
#undef PATTERN
+DEAL_II_NAMESPACE_OPEN
+
template void
MGTools::compute_row_length_vector(
const MGDoFHandler<deal_II_dimension>&, unsigned int,
const FunctionMap<deal_II_dimension>::type&,
std::vector<std::set<unsigned int> >&,
const std::vector<bool>&);
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <algorithm>
+DEAL_II_NAMESPACE_OPEN
+
//////////////////////////////////////////////////////////////////////
const unsigned int);
#endif
+DEAL_II_NAMESPACE_CLOSE
#include <algorithm>
#include <numeric>
+DEAL_II_NAMESPACE_OPEN
+
template <typename number>
void
template void MGTools::apply_boundary_values (
const std::set<unsigned int>&,
BlockSparseMatrix<double>&, const bool);
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// Call this file after defining PATTERN to the desired sparsity
// pattern type.
+DEAL_II_NAMESPACE_OPEN
+
+
template void
MGTools::make_sparsity_pattern<deal_II_dimension> (
#endif
+
+DEAL_II_NAMESPACE_CLOSE
#include <algorithm>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim>
const MGDoFHandler<deal_II_dimension>&,
BlockVector<double>&,
const MGLevelObject<Vector<double> >&) const;
+
+DEAL_II_NAMESPACE_CLOSE
#include <multigrid/mg_transfer.h>
#include <multigrid/mg_transfer.templates.h>
+DEAL_II_NAMESPACE_OPEN
+
+
template <typename number>
template <int dim>
const MGDoFHandler<deal_II_dimension>&,
BlockVector<double>&,
const MGLevelObject<BlockVector<double> >&) const;
+
+DEAL_II_NAMESPACE_CLOSE
#include <multigrid/mg_transfer.templates.h>
#include <multigrid/multigrid.templates.h>
+DEAL_II_NAMESPACE_OPEN
+
+
// Warning: the following function is for debugging purposes only. It
// will be compiled only, if the additional and undocumented compiler
// flag MG_DEBUG is set. Furthermore, as soon as this function is
template
void MGSmootherContinuous<BlockVector<float> >::set_zero_interior_boundary (
const unsigned int, BlockVector<float>&) const;
+
+DEAL_II_NAMESPACE_CLOSE
#include <sstream>
+DEAL_II_NAMESPACE_OPEN
template <class DH, int patch_dim, int patch_space_dim>
template <class DH,
int patch_dim, int patch_space_dim>
-const std::vector< ::DataOutBase::Patch<patch_dim, patch_space_dim> > &
+const std::vector< dealii::DataOutBase::Patch<patch_dim, patch_space_dim> > &
DataOut_DoFData<DH,patch_dim,patch_space_dim>::get_patches () const
{
return patches;
const unsigned int n_q_points = patch_points.n_quadrature_points;
- typename std::vector< ::DataOutBase::Patch<DH::dimension> >::iterator patch = this->patches.begin();
+ typename std::vector< dealii::DataOutBase::Patch<DH::dimension> >::iterator patch = this->patches.begin();
cell_iterator cell=first_cell();
// get first cell in this thread
||
((*data.cell_to_patch_index_map)[neighbor->level()][neighbor->index()]
==
- ::DataOutBase::Patch<DH::dimension>::no_neighbor))
+ dealii::DataOutBase::Patch<DH::dimension>::no_neighbor))
continue;
// now, there is a
// clear the patches array
if (true)
{
- std::vector< ::DataOutBase::Patch<DH::dimension> > dummy;
+ std::vector< dealii::DataOutBase::Patch<DH::dimension> > dummy;
this->patches.swap (dummy);
};
static_cast<unsigned int>(cell->index()));
cell_to_patch_index_map[l].resize (max_index+1,
- ::DataOutBase::Patch<DH::dimension>::no_neighbor);
+ dealii::DataOutBase::Patch<DH::dimension>::no_neighbor);
};
unsigned int n_patches = 0;
//
// then number the patches
// consecutively
- ::DataOutBase::Patch<DH::dimension> default_patch;
+ dealii::DataOutBase::Patch<DH::dimension> default_patch;
default_patch.n_subdivisions = n_subdivisions;
default_patch.data.reinit (n_datasets, n_q_points);
this->patches.insert (this->patches.end(), n_patches, default_patch);
#endif
template class DataOut<deal_II_dimension, hp::DoFHandler<deal_II_dimension> >;
+
+DEAL_II_NAMESPACE_CLOSE
#include <fe/hp_fe_values.h>
#include <fe/mapping_q1.h>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim, class DH>
const unsigned int n_q_points = patch_points.n_quadrature_points;
- typename std::vector< ::DataOutBase::Patch<DH::dimension-1,DH::dimension> >::iterator patch = this->patches.begin();
+ typename std::vector< dealii::DataOutBase::Patch<DH::dimension-1,DH::dimension> >::iterator patch = this->patches.begin();
FaceDescriptor face=first_face();
// get first face in this thread
// clear the patches array
if (true)
{
- std::vector< ::DataOutBase::Patch<DH::dimension-1,DH::dimension> > dummy;
+ std::vector< dealii::DataOutBase::Patch<DH::dimension-1,DH::dimension> > dummy;
this->patches.swap (dummy);
};
// values. note that the evaluation
// points on the face have to be
// repeated in angular direction
- ::DataOutBase::Patch<DH::dimension-1,DH::dimension> default_patch;
+ dealii::DataOutBase::Patch<DH::dimension-1,DH::dimension> default_patch;
default_patch.n_subdivisions = n_subdivisions;
default_patch.data.reinit (n_datasets, n_q_points);
this->patches.insert (this->patches.end(), n_patches, default_patch);
template class DataOutFaces<deal_II_dimension, DoFHandler<deal_II_dimension> >;
template class DataOutFaces<deal_II_dimension, hp::DoFHandler<deal_II_dimension> >;
#endif
+
+DEAL_II_NAMESPACE_CLOSE
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
+
//TODO: Update documentation
//TODO: Unify code for dimensions
unsigned int cell_number = 0;
- typename std::vector< ::DataOutBase::Patch<DH::dimension+1> >::iterator
+ typename std::vector< dealii::DataOutBase::Patch<DH::dimension+1> >::iterator
patch = this->patches.begin();
cell_iterator cell=first_cell();
// clear the patches array
if (true)
{
- std::vector< ::DataOutBase::Patch<DH::dimension+1> > dummy;
+ std::vector< dealii::DataOutBase::Patch<DH::dimension+1> > dummy;
this->patches.swap (dummy);
};
// values. note that the evaluation
// points on the cell have to be
// repeated in angular direction
- ::DataOutBase::Patch<DH::dimension+1> default_patch;
+ dealii::DataOutBase::Patch<DH::dimension+1> default_patch;
default_patch.n_subdivisions = n_subdivisions;
default_patch.data.reinit (n_datasets,
n_q_points * (n_subdivisions+1));
// explicit instantiations
template class DataOutRotation<deal_II_dimension, DoFHandler<deal_II_dimension> >;
+
+DEAL_II_NAMESPACE_CLOSE
#include <sstream>
+DEAL_II_NAMESPACE_OPEN
+
template <int dim, class DH>
unsigned int
// patch with n_q_points (in the the plane
// of the cells) times n_subdivisions+1 (in
// the time direction) points
- ::DataOutBase::Patch<dim+1,dim+1> default_patch;
+ dealii::DataOutBase::Patch<dim+1,dim+1> default_patch;
default_patch.n_subdivisions = n_subdivisions;
default_patch.data.reinit (n_datasets, n_q_points*(n_subdivisions+1));
patches.insert (patches.end(), n_patches, default_patch);
// now loop over all cells and
// actually create the patches
- typename std::vector< ::DataOutBase::Patch<dim+1,dim+1> >::iterator
+ typename std::vector< dealii::DataOutBase::Patch<dim+1,dim+1> >::iterator
patch = patches.begin() + (patches.size()-n_patches);
unsigned int cell_number = 0;
for (typename DH::active_cell_iterator cell=dof_handler->begin_active();
template <int dim, class DH>
-const std::vector< ::DataOutBase::Patch<dim+1,dim+1> > &
+const std::vector< dealii::DataOutBase::Patch<dim+1,dim+1> > &
DataOutStack<dim,DH>::get_patches () const
{
return patches;
template void DataOutStack<deal_II_dimension,hp::DoFHandler<deal_II_dimension> >::
add_data_vector<float> (const Vector<float> &vec,
const std::string &name);
+
+DEAL_II_NAMESPACE_CLOSE
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
template <typename T>
//
// if the d_11=a, d_22=b,
// d_12=d_21=c
- const double radicand = ::sqr(d[0][0] - d[1][1]) + 4*::sqr(d[0][1]);
+ const double radicand = dealii::sqr(d[0][0] - d[1][1]) +
+ 4*dealii::sqr(d[0][1]);
const double eigenvalues[2]
= { 0.5*(d[0][0] + d[1][1] + std::sqrt(radicand)),
0.5*(d[0][0] + d[1][1] - std::sqrt(radicand)) };
template
const UpdateFlags
DerivativeApproximation::ThirdDerivative<deal_II_dimension>::update_flags;
+
+DEAL_II_NAMESPACE_CLOSE
#include <cmath>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
static
for (unsigned int component=0; component<n_components; ++component)
if (component_mask[component] == true)
for (unsigned int p=0; p<n_q_points; ++p)
- face_integral[n] += ::sqr(per_thread_data.phi[n][p][component]) *
+ face_integral[n] += dealii::sqr(per_thread_data.phi[n][p][component]) *
per_thread_data.JxW_values[p];
// double check that the element
for (unsigned int component=0; component<n_components; ++component)
if (component_mask[component] == true)
for (unsigned int p=0; p<n_q_points; ++p)
- face_integral[n] += ::sqr(per_thread_data.phi[n][p][component]) *
+ face_integral[n] += dealii::sqr(per_thread_data.phi[n][p][component]) *
per_thread_data.JxW_values[p];
face_integrals[neighbor_child->face(neighbor_neighbor)] = face_integral;
INSTANTIATE(PETScWrappers::Vector,hp::DoFHandler<deal_II_dimension>);
INSTANTIATE(PETScWrappers::BlockVector,hp::DoFHandler<deal_II_dimension>);
#endif
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <algorithm>
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
template <typename number>
inline
void Histogram::evaluate<double> (const Vector<double> &values,
const unsigned int n_intervals,
const IntervalSpacing interval_spacing);
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <algorithm>
+DEAL_II_NAMESPACE_OPEN
+
//TODO:[WB] I don't think that the optimized storage of diagonals is needed (GK)
template <typename number>
BlockVector<float> &solution,
BlockVector<float> &right_hand_side,
const bool preserve_symmetry);
+
+DEAL_II_NAMESPACE_CLOSE
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
template <int dim>
inline
const Function<deal_II_dimension> &rhs,
Vector<double> &rhs_vector,
const Function<deal_II_dimension> * const coefficient);
+
+DEAL_II_NAMESPACE_CLOSE
#include <lac/vector.h>
#include <numerics/solution_transfer.h>
+DEAL_II_NAMESPACE_OPEN
template class SolutionTransfer<deal_II_dimension, double>;
/*---------------------------- solution_transfer.cc ----------------------*/
+
+DEAL_II_NAMESPACE_CLOSE
#include <algorithm>
#include <numeric>
+DEAL_II_NAMESPACE_OPEN
TimeDependent::TimeSteppingData::TimeSteppingData (const unsigned int look_ahead,
const unsigned int look_back)
{
Assert(old_cell->n_children()==new_cell->n_children(), ExcNotImplemented());
for (unsigned int c=0; c<new_cell->n_children(); ++c)
- ::mirror_refinement_flags<dim> (new_cell->child(c), old_cell->child(c));
+ dealii::mirror_refinement_flags<dim> (new_cell->child(c), old_cell->child(c));
}
}
Assert(cell2->n_children()==cell1->n_children(), ExcNotImplemented());
for (unsigned int c=0; c<cell1->n_children(); ++c)
- grids_changed |= ::adapt_grid_cells<dim> (cell1->child(c),
+ grids_changed |= dealii::adapt_grid_cells<dim> (cell1->child(c),
cell2->child(c));
return grids_changed;
};
typename Triangulation<dim>::cell_iterator(tria1.end()) :
tria1.begin(1));
for (; cell1!=endc; ++cell1, ++cell2)
- grids_changed |= ::adapt_grid_cells<dim> (cell1, cell2);
+ grids_changed |= dealii::adapt_grid_cells<dim> (cell1, cell2);
return grids_changed;
}
// (there are more coming below then
// also)
if (refinement_flags.adapt_grids)
- ::adapt_grids<dim> (*previous_tria, *tria);
+ dealii::adapt_grids<dim> (*previous_tria, *tria);
// perform flagging of cells
// needed to regularize the
// strange things may happen
if (refinement_flags.mirror_flags_to_previous_grid)
{
- ::adapt_grids<dim> (*previous_tria, *tria);
+ dealii::adapt_grids<dim> (*previous_tria, *tria);
typename Triangulation<dim>::cell_iterator old_cell, new_cell, endc;
old_cell = previous_tria->begin(0);
new_cell = tria->begin(0);
endc = tria->end(0);
for (; new_cell!=endc; ++new_cell, ++old_cell)
- ::mirror_refinement_flags<dim> (new_cell, old_cell);
+ dealii::mirror_refinement_flags<dim> (new_cell, old_cell);
};
tria->prepare_coarsening_and_refinement ();
// cells to avoid the previous grid
// to have cells refined twice more
// than the present one and vica versa.
- ::adapt_grids<dim> (*previous_tria, *tria);
+ dealii::adapt_grids<dim> (*previous_tria, *tria);
};
}
template class RefinementFlags<deal_II_dimension>;
template class RefinementData<deal_II_dimension>;
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <lac/vector.h>
#include <numerics/vectors.h>
+DEAL_II_NAMESPACE_OPEN
void
if (p_select[i])
v(i) -= s;
}
+
+DEAL_II_NAMESPACE_CLOSE
#undef VEC
+DEAL_II_NAMESPACE_OPEN
+
template
void VectorTools::create_right_hand_side<deal_II_dimension>
(const Mapping<deal_II_dimension> &,
std::map<unsigned int,double> &,
const std::vector<bool> &);
+
+DEAL_II_NAMESPACE_CLOSE
// vectors.cc defines the vector type VEC
+DEAL_II_NAMESPACE_OPEN
+
template
void VectorTools::interpolate<deal_II_dimension>
(const Mapping<deal_II_dimension>&,
const bool,
const Quadrature<deal_II_dimension-1> &,
const bool);
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <iostream>
#include <fstream>
+using namespace dealii;
+
double Adata[] =
{
4., .5, .1, 0.,
#include <iostream>
+using namespace dealii;
+
int main()
{
Triangulation<2> tr;
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/full_matrix.h>
#include <lac/vector.h>
+using namespace dealii;
double Adata[] =
{
// `sqrt' and `fabs' functions:
#include <cmath>
+using namespace dealii;
+
// @sect3{Creating the first mesh}
// In the following, first function, we
#include <fstream>
#include <cmath>
+using namespace dealii;
+
// Now, as we want to compute the
// value of pi, we have to compare to
// somewhat. These are the first few
/* $Id$ */
/* Version: $Name$ */
/* */
-/* Copyright (C) 2001, 2002, 2003, 2004 by the deal.II authors */
+/* Copyright (C) 2001, 2002, 2003, 2004, 2006 by the deal.II authors */
/* */
/* This file is subject to QPL and may not be distributed */
/* without copyright and license information. Please refer */
#include <iomanip>
#include <cmath>
+using namespace dealii;
// Then we declare a class which
// represents the solution of a
#include <iostream>
#include <fstream>
+using namespace dealii;
// @sect3{Equation data}
//
#include <list>
#include <sstream>
+using namespace dealii;
// @sect3{Evaluation of the solution}
#include <numeric>
#include <sstream>
+using namespace dealii;
+
// @sect3{Evaluating the solution}
// As mentioned in the introduction,
#include <iostream>
#include <sstream>
+using namespace dealii;
// The first thing we have here is a helper
// function that computes an even power $|v|^n$
#include <fstream>
#include <sstream>
+using namespace dealii;
// This class is based on the same
// class in step 5. Remark that we
#include <iostream>
#include <sstream>
+using namespace dealii;
// Now, here comes the declaration of the
// main class and of various other things
#include <sstream>
#include <iomanip>
+using namespace dealii;
+
// So much for the header files. As a
// matter of good practice, I have
// started to put everything that
/* $Id$ */
/* Version: $Name$ */
/* */
-/* Copyright (C) 2005 by the deal.II authors */
+/* Copyright (C) 2005, 2006 by the deal.II authors */
/* */
/* This file is subject to QPL and may not be distributed */
/* without copyright and license information. Please refer */
#include <iostream>
#include <fstream>
+using namespace dealii;
// Before we start with the actual program,
// let us declare a few global variables that
// And this is again needed for C++ output:
#include <fstream>
+using namespace dealii;
// @sect3{Mesh generation}
// offers such functionality:
#include <base/tensor_function.h>
+using namespace dealii;
// @sect3{The <code>MixedLaplaceProblem</code> class template}
// offers such functionality:
#include <base/tensor_function.h>
+using namespace dealii;
// @sect3{The ``TwoPhaseFlowProblem'' class template}
// double digit time steps.
#include <base/utilities.h>
+using namespace dealii;
+
// @sect3{The <code>WaveEquation</code> class}
// diameter.
#include <grid/grid_tools.h>
+using namespace dealii;
// @sect3{The "forward problem" class template}
#include <iostream>
#include <sstream>
+using namespace dealii;
+
// The following global variable is used to determine whether the
// problem being solved is one for which an exact solution is known,
// e.g. we are using the exact solution as the initial condition. It
#include <numeric>
#include <grid/tria_boundary.h>
+using namespace dealii;
class PointCloudSurface : public StraightBoundary<3>
{
#include <fstream>
#include <iostream>
+using namespace dealii;
// @sect3{The <code>LaplaceProblem</code> class}
// the main() function below for that):
#include <base/logstream.h>
+using namespace dealii;
// @sect3{The <code>LaplaceProblem</code> class template}
// <code>ostringstream</code>:
#include <sstream>
+using namespace dealii;
+
// @sect3{The <code>LaplaceProblem</code> class template}
// problems.
#include <numerics/error_estimator.h>
+using namespace dealii;
// @sect3{The <code>LaplaceProblem</code> class template}
#include <fstream>
#include <iostream>
+using namespace dealii;
// @sect3{Equation data}
#include <fstream>
#include <iostream>
+using namespace dealii;
// @sect3{The <code>ElasticProblem</code> class template}
# define M_PI 3.14159265358979323846
#endif
+using namespace dealii;
+
// @sect3{AdvectionProblem class declaration}
// Following we declare the main
#include <base/exceptions.h>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
/**
* Class that manages the conversion of global indices into a block
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/smartpointer.h>
#include <lac/block_vector.h>
+DEAL_II_NAMESPACE_OPEN
+
/*! @addtogroup Matrix2
*@{
*/
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <memory>
#include <sstream>
+DEAL_II_NAMESPACE_OPEN
template <typename> class BlockVector;
template <typename> class Vector;
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
/*! @addtogroup Matrix1
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif // __deal2__block_matrix_base_h
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
/*! @addtogroup Matrix1
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif // __deal2__block_sparse_matrix_h
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/memory_consumption.h>
#include <lac/block_sparse_matrix.h>
+DEAL_II_NAMESPACE_OPEN
template <typename number>
+DEAL_II_NAMESPACE_CLOSE
+
#endif // ifdef block_sparse_matrix_templates_h
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/block_indices.h>
#include <lac/sparse_matrix_ez.h>
+DEAL_II_NAMESPACE_OPEN
+
template <typename Number> class BlockVector;
/*! @addtogroup Matrix1
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif //__deal2__block_sparse_matrix_ez_h
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/memory_consumption.h>
#include <lac/block_sparse_matrix_ez.h>
+DEAL_II_NAMESPACE_OPEN
template <typename number>
+DEAL_II_NAMESPACE_CLOSE
+
#endif // ifdef block_sparse_matrix_templates_h
#include <lac/compressed_sparsity_pattern.h>
#include <lac/block_indices.h>
+DEAL_II_NAMESPACE_OPEN
+
template <typename number> class BlockSparseMatrix;
class BlockSparsityPattern;
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <cstdio>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
/*! @addtogroup Vectors
u.swap (v);
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <cmath>
#include <algorithm>
+DEAL_II_NAMESPACE_OPEN
template <typename Number>
BlockVector<Number>::BlockVector (const unsigned int n_blocks,
ExcDimensionMismatch(this->n_blocks(), v.n_blocks()));
for (unsigned int i=0; i<this->n_blocks(); ++i)
- ::swap (this->components[i], v.components[i]);
- ::swap (this->block_indices, v.block_indices);
+ dealii::swap (this->components[i], v.components[i]);
+ dealii::swap (this->block_indices, v.block_indices);
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <iterator>
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
/*! @addtogroup Vectors
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/subscriptor.h>
#include <lac/exceptions.h>
-template <typename number> class SparseMatrix;
-
#include <vector>
#include <algorithm>
+DEAL_II_NAMESPACE_OPEN
+
+template <typename number> class SparseMatrix;
+
+
/*! @addtogroup Matrix1
*@{
*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
+
/*!@addtogroup Solvers */
/*@{*/
// otherwise exit as normal
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/exceptions.h>
+DEAL_II_NAMESPACE_OPEN
+
namespace LACExceptions
{
/**
using namespace LACExceptions;
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <vector>
#include <algorithm>
+DEAL_II_NAMESPACE_OPEN
template <typename number> class Vector;
/*---------------------------- filtered_matrix.h ---------------------------*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif
/*---------------------------- filtered_matrix.h ---------------------------*/
// $Id$
// Version: $Name$
//
-// Copyright (C) 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/vector.h>
#include <lac/block_vector.h>
+DEAL_II_NAMESPACE_OPEN
+
+
template <class MATRIX, class VECTOR>
FilteredMatrix<MATRIX,VECTOR>::FilteredMatrix ()
{}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
#include <iomanip>
+DEAL_II_NAMESPACE_OPEN
+
+
// forward declarations
template<typename number> class Vector;
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <cstdio>
#include <algorithm>
+DEAL_II_NAMESPACE_OPEN
+
+
template <typename number>
FullMatrix<number>::FullMatrix (const unsigned int n)
:
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
+
// forward declarations
template<typename number> class Vector;
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/config.h>
#include <lac/exceptions.h>
+DEAL_II_NAMESPACE_OPEN
/*! @addtogroup Matrix1
*@{
/**@}*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
#include <complex>
+DEAL_II_NAMESPACE_OPEN
+
// forward declarations
template<typename number> class Vector;
template<typename number> class BlockVector;
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/config.h>
#include <base/exceptions.h>
+DEAL_II_NAMESPACE_OPEN
+
namespace LAPACKSupport
{
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// This file was automatically generated from blas.h.in
// See blastemplates in the deal.II contrib directory
//
-// Copyright (C) 2005 by the deal authors
+// Copyright (C) 2005, 2006 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
inline void
gemv (const char*, const int*, const int*, const double*, const double*, const int*, const double*, const int*, const double*, double*, const int*)
{
- LAPACKSupport::ExcMissing("dgemv");
+ dealii::LAPACKSupport::ExcMissing("dgemv");
}
#endif
inline void
gemv (const char*, const int*, const int*, const float*, const float*, const int*, const float*, const int*, const float*, float*, const int*)
{
- LAPACKSupport::ExcMissing("sgemv");
+ dealii::LAPACKSupport::ExcMissing("sgemv");
}
#endif
inline void
getrf (const int*, const int*, double*, const int*, int*, int*)
{
- LAPACKSupport::ExcMissing("dgetrf");
+ dealii::LAPACKSupport::ExcMissing("dgetrf");
}
#endif
inline void
getrf (const int*, const int*, float*, const int*, int*, int*)
{
- LAPACKSupport::ExcMissing("sgetrf");
+ dealii::LAPACKSupport::ExcMissing("sgetrf");
}
#endif
inline void
getrs (const char*, const int*, const int*, const double*, const int*, const int*, double*, const int*, int*)
{
- LAPACKSupport::ExcMissing("dgetrs");
+ dealii::LAPACKSupport::ExcMissing("dgetrs");
}
#endif
inline void
getrs (const char*, const int*, const int*, const float*, const int*, const int*, float*, const int*, int*)
{
- LAPACKSupport::ExcMissing("sgetrs");
+ dealii::LAPACKSupport::ExcMissing("sgetrs");
}
#endif
inline void
geev (const char*, const char*, const int*, double*, const int*, double*, double*, double*, const int*, double*, const int*, double*, const int*, int*)
{
- LAPACKSupport::ExcMissing("dgeev");
+ dealii::LAPACKSupport::ExcMissing("dgeev");
}
#endif
inline void
geev (const char*, const char*, const int*, float*, const int*, float*, float*, float*, const int*, float*, const int*, float*, const int*, int*)
{
- LAPACKSupport::ExcMissing("sgeev");
+ dealii::LAPACKSupport::ExcMissing("sgeev");
}
#endif
inline void
geevx (const char*, const char*, const char*, const char*, const int*, double*, const int*, double*, double*, double*, const int*, double*, const int*, int*, int*, double*, double*, double*, double*, double*, const int*, int*, int*)
{
- LAPACKSupport::ExcMissing("dgeevx");
+ dealii::LAPACKSupport::ExcMissing("dgeevx");
}
#endif
inline void
geevx (const char*, const char*, const char*, const char*, const int*, float*, const int*, float*, float*, float*, const int*, float*, const int*, int*, int*, float*, float*, float*, float*, float*, const int*, int*, int*)
{
- LAPACKSupport::ExcMissing("sgeevx");
+ dealii::LAPACKSupport::ExcMissing("sgeevx");
}
#endif
inline void
gesvd (int*, int*, const int*, const int*, double*, const int*, double*, double*, const int*, double*, const int*, double*, const int*, int*)
{
- LAPACKSupport::ExcMissing("dgesvd");
+ dealii::LAPACKSupport::ExcMissing("dgesvd");
}
#endif
inline void
gesvd (int*, int*, const int*, const int*, float*, const int*, float*, float*, const int*, float*, const int*, float*, const int*, int*)
{
- LAPACKSupport::ExcMissing("sgesvd");
+ dealii::LAPACKSupport::ExcMissing("sgesvd");
}
#endif
inline void
stev (const char*, const int*, double*, double*, double*, const int*, double*, int*)
{
- LAPACKSupport::ExcMissing("dstev");
+ dealii::LAPACKSupport::ExcMissing("dstev");
}
#endif
inline void
stev (const char*, const int*, float*, float*, float*, const int*, float*, int*)
{
- LAPACKSupport::ExcMissing("sstev");
+ dealii::LAPACKSupport::ExcMissing("sstev");
}
#endif
-
#endif
#include <base/config.h>
#include <base/exceptions.h>
+DEAL_II_NAMESPACE_OPEN
+
/**
* STL conforming iterator for constant
* and non-constant matrices.
return (other < *this);
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <lac/pointer_matrix.h>
#include <lac/solver_richardson.h>
+DEAL_II_NAMESPACE_OPEN
+
template<typename number> class Vector;
template<typename number> class BlockVector;
template<typename number> class SparseMatrix;
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/vector.h>
#include <lac/block_vector.h>
+DEAL_II_NAMESPACE_OPEN
template <typename number>
void
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <lac/sparse_matrix.h>
#include <lac/block_sparse_matrix.h>
+DEAL_II_NAMESPACE_OPEN
+
/**
* Output a matrix in graphical form using the generic format
* independent output routines of the base class. The matrix is
/**
* Abbreviate the somewhat
- * lengthy name for the ::DataOutBase::Patch
+ * lengthy name for the dealii::DataOutBase::Patch
* class.
*
- * Note that we have to indicate
- * the global scope using the
- * @p :: in front of
- * DataOutBase, since
- * otherwise the C++ rules
- * specify that this here
- * indicates the DataOutBase
- * base class of this
- * class. Since that is a private
- * base class, we cannot access
- * its members, and so access to
- * the local Patch type would
- * be forbidden.
+ * Note that we have to indicate the
+ * global scope in front of DataOutBase,
+ * since otherwise the C++ rules specify
+ * that this here indicates the
+ * DataOutBase base class of this
+ * class. Since that is a private base
+ * class, we cannot access its members,
+ * and so access to the local Patch type
+ * would be forbidden.
*/
- typedef ::DataOutBase::Patch<2,2> Patch;
+ typedef dealii::DataOutBase::Patch<2,2> Patch;
/**
* This is a list of patches that
/*---------------------------- matrix_out.h ---------------------------*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif
/*---------------------------- matrix_out.h ---------------------------*/
#ifdef DEAL_II_USE_PETSC
+DEAL_II_NAMESPACE_OPEN
+
namespace PETScWrappers
}
+DEAL_II_NAMESPACE_CLOSE
#endif // DEAL_II_USE_PETSC
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#ifdef DEAL_II_USE_PETSC
+DEAL_II_NAMESPACE_OPEN
+
namespace PETScWrappers
}
+
+DEAL_II_NAMESPACE_CLOSE
+
#endif // DEAL_II_USE_PETSC
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/config.h>
#include <lac/exceptions.h>
+#include <lac/petsc_matrix_base.h>
#ifdef DEAL_II_USE_PETSC
-#include <lac/petsc_matrix_base.h>
+DEAL_II_NAMESPACE_OPEN
+
namespace PETScWrappers
/*@}*/
}
+
+DEAL_II_NAMESPACE_CLOSE
+
#endif // DEAL_II_USE_PETSC
/*---------------------------- petsc_full_matrix.h ---------------------------*/
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <vector>
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
+
namespace PETScWrappers
{
// forward declarations
}
+DEAL_II_NAMESPACE_CLOSE
+
+
#endif // DEAL_II_USE_PETSC
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#ifdef DEAL_II_USE_PETSC
+DEAL_II_NAMESPACE_OPEN
+
namespace PETScWrappers
}
+DEAL_II_NAMESPACE_CLOSE
+
+
#endif // DEAL_II_USE_PETSC
#endif // __deal2__petsc_parallel_block_sparse_matrix_h
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#ifdef DEAL_II_USE_PETSC
+DEAL_II_NAMESPACE_OPEN
+
namespace PETScWrappers
{
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif // DEAL_II_USE_PETSC
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/config.h>
#include <lac/exceptions.h>
-#ifdef DEAL_II_USE_PETSC
-
#include <lac/petsc_matrix_base.h>
#include <lac/block_sparsity_pattern.h>
#include <vector>
+#ifdef DEAL_II_USE_PETSC
+
+DEAL_II_NAMESPACE_OPEN
+
namespace PETScWrappers
}
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif // DEAL_II_USE_PETSC
/*---------------------------- petsc_parallel_sparse_matrix.h ---------------------------*/
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/config.h>
#include <base/subscriptor.h>
#include <lac/exceptions.h>
-
#include <lac/vector.h>
+#include <lac/petsc_vector_base.h>
+
#ifdef DEAL_II_USE_PETSC
-#include <lac/petsc_vector_base.h>
+DEAL_II_NAMESPACE_OPEN
+
// forward declaration
/**@}*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif // DEAL_II_USE_PETSC
/*---------------------------- petsc_parallel_vector.h ---------------------------*/
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/config.h>
#include <lac/exceptions.h>
+
#ifdef DEAL_II_USE_PETSC
#include <petscpc.h>
+DEAL_II_NAMESPACE_OPEN
+
+
namespace PETScWrappers
{
}
+DEAL_II_NAMESPACE_CLOSE
+
+
#endif // DEAL_II_USE_PETSC
/*---------------------------- petsc_precondition.h ---------------------------*/
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/config.h>
#include <lac/exceptions.h>
#include <lac/solver_control.h>
+#include <boost/shared_ptr.hpp>
+
#ifdef DEAL_II_USE_PETSC
-#include <boost/shared_ptr.hpp>
#include <petscksp.h>
+DEAL_II_NAMESPACE_OPEN
+
namespace PETScWrappers
{
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif // DEAL_II_USE_PETSC
/*---------------------------- petsc_solver.h ---------------------------*/
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/config.h>
#include <lac/exceptions.h>
-
-#ifdef DEAL_II_USE_PETSC
-
#include <lac/petsc_matrix_base.h>
#include <lac/compressed_sparsity_pattern.h>
#include <vector>
+#ifdef DEAL_II_USE_PETSC
+
+DEAL_II_NAMESPACE_OPEN
+
+
namespace PETScWrappers
{
/**
};
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif // DEAL_II_USE_PETSC
/*---------------------------- petsc_sparse_matrix.h ---------------------------*/
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/config.h>
#include <base/subscriptor.h>
#include <lac/exceptions.h>
-
+#include <lac/petsc_vector_base.h>
+#include <lac/petsc_parallel_vector.h>
#include <lac/vector.h>
#ifdef DEAL_II_USE_PETSC
-#include <lac/petsc_vector_base.h>
-#include <lac/petsc_parallel_vector.h>
+DEAL_II_NAMESPACE_OPEN
namespace PETScWrappers
}
+DEAL_II_NAMESPACE_CLOSE
#endif // DEAL_II_USE_PETSC
#include <base/subscriptor.h>
#include <lac/exceptions.h>
+#include <vector>
+#include <utility>
+
#ifdef DEAL_II_USE_PETSC
#include <petscvec.h>
-#include <vector>
-#include <utility>
-
+DEAL_II_NAMESPACE_OPEN
// forward declaration
template <typename number> class Vector;
#endif // DOXYGEN
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif // DEAL_II_USE_PETSC
/*---------------------------- petsc_vector_base.h ---------------------------*/
#include <base/smartpointer.h>
#include <lac/vector.h>
+DEAL_II_NAMESPACE_OPEN
+
template<class VECTOR> class VectorMemory;
/*! @addtogroup Matrix2
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <lac/vector_memory.h>
#include <base/smartpointer.h>
+DEAL_II_NAMESPACE_OPEN
+
template <typename number> class Vector;
template <typename number> class SparseMatrix;
return dst.l2_norm ();
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
template <typename number> class FullMatrix;
template <typename number> class Vector;
return const_iterator(this, r+1);
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/vector.h>
#include <lac/full_matrix.h>
+DEAL_II_NAMESPACE_OPEN
+
template <class MATRIX, typename inverse_type>
PreconditionBlock<MATRIX,inverse_type>::PreconditionBlock ():
PreconditionBlockSOR<MATRIX,inverse_type>::vmult(dst, help);
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/smartpointer.h>
#include <string>
+DEAL_II_NAMESPACE_OPEN
+
template <class number> class Vector;
template <class number> class SparseMatrix;
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <lac/block_vector.h>
#include <vector>
+DEAL_II_NAMESPACE_OPEN
/*! @addtogroup Matrix2
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/config.h>
#include <base/smartpointer.h>
+DEAL_II_NAMESPACE_OPEN
+
/*! @addtogroup Matrix2
*@{
*/
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/subscriptor.h>
#include <lac/vector_memory.h>
+DEAL_II_NAMESPACE_OPEN
template <typename number> class Vector;
class SolverControl;
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <cmath>
#include <base/subscriptor.h>
+DEAL_II_NAMESPACE_OPEN
+
/*!@addtogroup Solvers */
/*@{*/
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <base/subscriptor.h>
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
/*!@addtogroup Solvers */
/*@{*/
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
class ParameterHandler;
/*!@addtogroup Solvers */
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
/*!@addtogroup Solvers */
/*@{*/
// some additional vectors, also used
// in the orthogonalization
- ::Vector<double> gamma(n_tmp_vectors),
- ci (n_tmp_vectors-1),
- si (n_tmp_vectors-1),
- h (n_tmp_vectors-1);
-
+ dealii::Vector<double>
+ gamma(n_tmp_vectors),
+ ci (n_tmp_vectors-1),
+ si (n_tmp_vectors-1),
+ h (n_tmp_vectors-1);
+
unsigned int dim = 0;
// are used as stopping criterion
VECTOR *r=0;
VECTOR *x_=0;
- ::Vector<double> *gamma_=0;
+ dealii::Vector<double> *gamma_=0;
if (!use_default_residual)
{
r=this->memory.alloc();
r->reinit(x);
x_->reinit(x);
- gamma_=new ::Vector<double> (gamma.size());
+ gamma_ = new dealii::Vector<double> (gamma.size());
}
///////////////////////////////////
{
deallog << "default_res=" << rho << std::endl;
- ::Vector<double> h_(dim);
+ dealii::Vector<double> h_(dim);
*x_=x;
*gamma_=gamma;
H1.reinit(dim+1,dim);
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <cmath>
#include <base/subscriptor.h>
+DEAL_II_NAMESPACE_OPEN
+
/*!@addtogroup Solvers */
/*@{*/
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
/*!@addtogroup Solvers */
/*@{*/
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <lac/solver_control.h>
#include <base/subscriptor.h>
+DEAL_II_NAMESPACE_OPEN
+
/*!@addtogroup Solvers */
/*@{*/
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <lac/solver_richardson.h>
#include <lac/precondition.h>
+DEAL_II_NAMESPACE_OPEN
+
/*!@addtogroup Solvers */
/*@{*/
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005, 2006 by the deal.II authors
// by the deal.II authors and Stephen "Cheffo" Kolaroff
//
// This file is subject to QPL and may not be distributed
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
/*! @addtogroup Preconditioners
*@{
*/
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif // __deal2__sparse_decomposition_h
//---------------------------------------------------------------------------
-// Copyright (C) 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005, 2006 by the deal.II authors
// by the deal.II authors and Stephen "Cheffo" Kolaroff
//
// This file is subject to QPL and may not be distributed
//
//---------------------------------------------------------------------------
+#ifndef __deal2__sparse_decomposition_templates_h
+#define __deal2__sparse_decomposition_templates_h
+
#include <base/memory_consumption.h>
#include <lac/sparse_decomposition.h>
#include <algorithm>
+DEAL_II_NAMESPACE_OPEN
template<typename number>
SparseLUDecomposition<number>::SparseLUDecomposition()
}
+DEAL_II_NAMESPACE_CLOSE
+
+#endif // __deal2__sparse_decomposition_templates_h
#include <lac/vector.h>
#include <lac/sparse_matrix.h>
+DEAL_II_NAMESPACE_OPEN
/**
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <lac/sparse_decomposition.h>
#include <lac/exceptions.h>
+DEAL_II_NAMESPACE_OPEN
+
/*! @addtogroup Preconditioners
*@{
*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif // __deal2__sparse_ilu_h
//---------------------------------------------------------------------------
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
// by the deal.II authors and Stephen "Cheffo" Kolaroff
//
// This file is subject to QPL and may not be distributed
#include <algorithm>
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
template <typename number>
SparseILU<number>::SparseILU ()
/*---------------------------- sparse_ilu.templates.h ---------------------------*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif
/*---------------------------- sparse_ilu.templates.h ---------------------------*/
#include <lac/identity_matrix.h>
#include <lac/exceptions.h>
+DEAL_II_NAMESPACE_OPEN
+
template<typename number> class Vector;
template<typename number> class FullMatrix;
/*---------------------------- sparse_matrix.h ---------------------------*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif
/*---------------------------- sparse_matrix.h ---------------------------*/
#include <base/thread_management.h>
#include <base/multithread_info.h>
+DEAL_II_NAMESPACE_OPEN
template <typename number>
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
template<typename number> class Vector;
template<typename number> class FullMatrix;
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
/*---------------------------- sparse_matrix.h ---------------------------*/
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <algorithm>
#include <cmath>
+DEAL_II_NAMESPACE_OPEN
+
//---------------------------------------------------------------------------
template <typename number>
CHECKFOR(in,']',c);
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif // __deal2__sparse_matrix_ez_templates_h
//---------------------------------------------------------------------------
-// Copyright (C) 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005, 2006 by the deal.II authors
// by the deal.II authors and Stephen "Cheffo" Kolaroff
//
// This file is subject to QPL and may not be distributed
#include <lac/sparse_matrix.h>
#include <lac/sparse_decomposition.h>
+DEAL_II_NAMESPACE_OPEN
/*! @addtogroup Preconditioners
*@{
/*@}*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif // __deal2__
//---------------------------------------------------------------------------
-// Copyright (C) 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005, 2006 by the deal.II authors
// by the deal.II authors and Stephen "Cheffo" Kolaroff
//
// This file is subject to QPL and may not be distributed
#include <lac/sparse_mic.h>
#include <lac/vector.h>
+DEAL_II_NAMESPACE_OPEN
template <typename number>
SparseMIC<number>::SparseMIC ()
+DEAL_II_NAMESPACE_CLOSE
+
#endif // __deal2__sparse_mic_templates_h
#include <vector>
#include <map>
+DEAL_II_NAMESPACE_OPEN
+
template <typename number> class FullMatrix;
template <typename number> class SparseMatrix;
template <typename number> class Vector;
};
/*@}*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <algorithm>
#include <map>
+DEAL_II_NAMESPACE_OPEN
template<typename number>
SparseVanka<number>::SparseVanka(const SparseMatrix<number> &M,
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
#include <iostream>
+DEAL_II_NAMESPACE_OPEN
class SparsityPattern;
template <typename number> class FullMatrix;
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <lac/vector.h>
#include <string>
+DEAL_II_NAMESPACE_OPEN
+
/*! @addtogroup Vectors
*@{
*/
/*@}*/
/*---------------------------- swappable_vector.h ---------------------------*/
/* end of #ifndef __deal2__swappable_vector_h */
+DEAL_II_NAMESPACE_CLOSE
+
#endif
/*---------------------------- swappable_vector.h ---------------------------*/
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/swappable_vector.h>
#include <fstream>
+DEAL_II_NAMESPACE_OPEN
template <typename number>
+DEAL_II_NAMESPACE_CLOSE
+
#endif // __deal2__swappable_vector_templates_h
#include <lac/pointer_matrix.h>
#include <boost/shared_ptr.hpp>
+DEAL_II_NAMESPACE_OPEN
+
/**
* The transpose of a given matrix. This auxiliary class swaps the
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
#include <iomanip>
+DEAL_II_NAMESPACE_OPEN
+
// forward declarations
template<typename number> class Vector;
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <cstdio>
+DEAL_II_NAMESPACE_OPEN
+
#ifdef DEAL_II_USE_PETSC
namespace PETScWrappers
/*@}*/
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <algorithm>
#include <iostream>
+DEAL_II_NAMESPACE_OPEN
/*
Note that in this file, we use std::fabs, std::sqrt, etc
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
#include <vector>
+DEAL_II_NAMESPACE_OPEN
+
+
/*!@addtogroup VMemory */
/*@{*/
*
* @author Guido Kanschat, 1998-2003
*/
-template<class VECTOR = ::Vector<double> >
+template<class VECTOR = dealii::Vector<double> >
class VectorMemory : public Subscriptor
{
public:
* vectors as needed from the global heap, i.e. performs no
* specially adapted actions for memory management.
*/
-template<class VECTOR = ::Vector<double> >
+template<class VECTOR = dealii::Vector<double> >
class PrimitiveVectorMemory : public VectorMemory<VECTOR>
{
public:
*
* @author Guido Kanschat, 1999
*/
-template<class VECTOR = ::Vector<double> >
+template<class VECTOR = dealii::Vector<double> >
class GrowingVectorMemory : public VectorMemory<VECTOR>
{
public:
#endif // DOXYGEN
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/vector.h>
#include <lac/block_vector.h>
+DEAL_II_NAMESPACE_OPEN
+
template <typename number>
BlockMatrixArray<number>::Entry::Entry (const Entry& e)
template class BlockMatrixArray<double>;
template class BlockTrianglePrecondition<float>;
template class BlockTrianglePrecondition<double>;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/block_sparse_matrix.templates.h>
+DEAL_II_NAMESPACE_OPEN
+
// explicit instantiations
template class BlockSparseMatrix<double>;
template class BlockSparseMatrix<float>;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2005 by the deal.II authors
+// Copyright (C) 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/block_sparse_matrix_ez.h>
#include <lac/block_sparse_matrix_ez.templates.h>
+DEAL_II_NAMESPACE_OPEN
+
// explicit instantiations
template class BlockSparseMatrixEZ<double>;
template class BlockSparseMatrixEZ<float>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <base/memory_consumption.h>
#include <lac/block_sparsity_pattern.h>
+DEAL_II_NAMESPACE_OPEN
+
template <class SparsityPatternBase>
BlockSparsityPatternBase<SparsityPatternBase>::BlockSparsityPatternBase ()
// to the top of this source file. The reason is a slightly buggy version
// of the Apple gcc v.3.3.
// For more information, see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=24331
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/block_vector.templates.h>
+DEAL_II_NAMESPACE_OPEN
+
// explicit instantiations
template class BlockVector<double>;
template class BlockVector<float>;
template void BlockVector<float>::reinit<float>(const BlockVector<float>&,
const bool);
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <numeric>
#include <functional>
+DEAL_II_NAMESPACE_OPEN
+
const unsigned int CompressedSparsityPattern::Line::cache_size;
return n;
}
+
+DEAL_II_NAMESPACE_CLOSE
#include <lac/filtered_matrix.templates.h>
+DEAL_II_NAMESPACE_OPEN
+
#define FILT(MM,VV) \
template <> \
void FilteredMatrix<MM , VV >::allocate_tmp_vector() \
BFILT(BlockSparseMatrix<float>, BlockVector<float>)
template class FilteredMatrix<SparseMatrix<float>,Vector<float> >;
template class FilteredMatrix<BlockSparseMatrix<float>,BlockVector<float> >;
+
+DEAL_II_NAMESPACE_CLOSE
#include <lac/full_matrix.templates.h>
#include <base/logstream.h>
+DEAL_II_NAMESPACE_OPEN
+
#define TYPEMAT double
template class FullMatrix<TYPEMAT>;
const Vector<TYPEVEC>&,
const Vector<TYPERES>&) const;
+
+DEAL_II_NAMESPACE_CLOSE
#include <lac/full_matrix.templates.h>
#include <base/logstream.h>
+DEAL_II_NAMESPACE_OPEN
+
#define TYPEMAT float
template class FullMatrix<TYPEMAT>;
template double FullMatrix<TYPEMAT>::residual<TYPEVEC,TYPERES>(
Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const Vector<TYPERES>&) const;
+
+DEAL_II_NAMESPACE_CLOSE
#include <iostream>
#include <iomanip>
+DEAL_II_NAMESPACE_OPEN
+
using namespace LAPACKSupport;
template <typename number>
template class PreconditionLU<double>;
template class PreconditionLU<float>;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/matrix_lib.templates.h>
#include <lac/sparse_matrix.h>
+DEAL_II_NAMESPACE_OPEN
+
MeanValueFilter::MeanValueFilter(unsigned int component)
:
component(component)
template class InverseMatrixRichardson<Vector<double> >;
template class InverseMatrixRichardson<BlockVector<float> >;
template class InverseMatrixRichardson<BlockVector<double> >;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/matrix_out.h>
+DEAL_II_NAMESPACE_OPEN
+
MatrixOut::Options::Options (const bool show_absolute_values,
const unsigned int block_size,
{
return std::vector<std::string>(1,name);
}
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#ifdef DEAL_II_USE_PETSC
+DEAL_II_NAMESPACE_OPEN
+
namespace PETScWrappers
{
BlockSparseMatrix::BlockSparseMatrix ()
}
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#ifdef DEAL_II_USE_PETSC
+DEAL_II_NAMESPACE_OPEN
namespace PETScWrappers
{
}
+DEAL_II_NAMESPACE_CLOSE
+
#else
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
#ifdef DEAL_II_USE_PETSC
+DEAL_II_NAMESPACE_OPEN
namespace PETScWrappers
{
}
}
+DEAL_II_NAMESPACE_CLOSE
+
#else
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#ifdef DEAL_II_USE_PETSC
+DEAL_II_NAMESPACE_OPEN
+
namespace PETScWrappers
{
namespace MPI
+DEAL_II_NAMESPACE_CLOSE
+
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#ifdef DEAL_II_USE_PETSC
+DEAL_II_NAMESPACE_OPEN
namespace PETScWrappers
{
}
+DEAL_II_NAMESPACE_CLOSE
+
#else
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#ifdef DEAL_II_USE_PETSC
+DEAL_II_NAMESPACE_OPEN
namespace PETScWrappers
{
}
+DEAL_II_NAMESPACE_CLOSE
+
#else
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004 by the deal.II authors
+// Copyright (C) 2004, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#ifdef DEAL_II_USE_PETSC
+DEAL_II_NAMESPACE_OPEN
namespace PETScWrappers
{
}
+DEAL_II_NAMESPACE_CLOSE
+
#else
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004 by the deal.II authors
+// Copyright (C) 2004, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#ifdef DEAL_II_USE_PETSC
+DEAL_II_NAMESPACE_OPEN
namespace PETScWrappers
{
}
+DEAL_II_NAMESPACE_CLOSE
+
#else
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004 by the deal.II authors
+// Copyright (C) 2004, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#endif
#include <petscversion.h>
+DEAL_II_NAMESPACE_OPEN
namespace PETScWrappers
{
}
+DEAL_II_NAMESPACE_CLOSE
+
#else
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#ifdef DEAL_II_USE_PETSC
+DEAL_II_NAMESPACE_OPEN
namespace PETScWrappers
{
}
+DEAL_II_NAMESPACE_CLOSE
+
#else
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004 by the deal.II authors
+// Copyright (C) 2004, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#ifdef DEAL_II_USE_PETSC
+DEAL_II_NAMESPACE_OPEN
namespace PETScWrappers
{
}
}
+DEAL_II_NAMESPACE_CLOSE
+
#else
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
#ifdef DEAL_II_USE_PETSC
+DEAL_II_NAMESPACE_OPEN
namespace PETScWrappers
{
}
+DEAL_II_NAMESPACE_CLOSE
+
#else
// On gcc2.95 on Alpha OSF1, the native assembler does not like empty
// files, so provide some dummy code
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/precondition_block.templates.h>
#include <lac/sparse_matrix.h>
+DEAL_II_NAMESPACE_OPEN
+
// explicit instantiations for "float" PreconditionBlock
template class PreconditionBlock<SparseMatrix<float>, float>;
Vector<float> &, const Vector<float> &) const;
template void PreconditionBlockSSOR<SparseMatrix<double>, double>::Tvmult<double> (
Vector<double> &, const Vector<double> &) const;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2005 by the deal.II authors
+// Copyright (C) 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/precondition_block.templates.h>
#include <lac/sparse_matrix_ez.h>
+DEAL_II_NAMESPACE_OPEN
+
// explicit instantiations for "float" PreconditionBlock
template class PreconditionBlock<SparseMatrixEZ<float>, float>;
Vector<float> &, const Vector<float> &) const;
template void PreconditionBlockSSOR<SparseMatrixEZ<double>, double>::Tvmult<double> (
Vector<double> &, const Vector<double> &) const;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/petsc_vector.h>
#include <lac/petsc_block_vector.h>
+DEAL_II_NAMESPACE_OPEN
+
// a few instantiations of static members. Hope that we catch all that
// are required
template class Solver<PETScWrappers::Vector>;
template class Solver<PETScWrappers::BlockVector>;
#endif
+
+DEAL_II_NAMESPACE_CLOSE
#include <cmath>
#include <sstream>
+DEAL_II_NAMESPACE_OPEN
+
/*----------------------- SolverControl ---------------------------------*/
SolverControl::parse_parameters (param);
set_reduction (param.get_double("Reduction"));
}
+
+DEAL_II_NAMESPACE_CLOSE
//---------------------------------------------------------------------------
-// Copyright (C) 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2005, 2006 by the deal.II authors
// by the deal.II authors and Stephen "Cheffo" Kolaroff
//
// This file is subject to QPL and may not be distributed
#include <lac/sparse_decomposition.templates.h>
+DEAL_II_NAMESPACE_OPEN
+
template class SparseLUDecomposition<double>;
template void SparseLUDecomposition<double>::initialize<double> (const SparseMatrix<double> &,
template void SparseLUDecomposition<float>::copy_from<double> (const SparseMatrix<double> &);
template void SparseLUDecomposition<float>::copy_from<float> (const SparseMatrix<float> &);
+
+DEAL_II_NAMESPACE_CLOSE
#endif
#include <sys/errno.h>
+DEAL_II_NAMESPACE_OPEN
+
// if we know that at least one of the HSL functions are there,
// include the respective include file. Otherwise save some CPU cycles
InstantiateUMFPACK(SparseMatrix<float>);
InstantiateUMFPACK(BlockSparseMatrix<double>);
InstantiateUMFPACK(BlockSparseMatrix<float>);
+
+DEAL_II_NAMESPACE_CLOSE
//---------------------------------------------------------------------------
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/sparse_ilu.templates.h>
+DEAL_II_NAMESPACE_OPEN
+
// explicit instantiations
template class SparseILU<double>;
const Vector<float> &) const;
template void SparseILU<float>::Tvmult<float> (Vector<float> &,
const Vector<float> &) const;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#define TYPEMAT double
+DEAL_II_NAMESPACE_OPEN
template class SparseMatrix<TYPEMAT>;
+DEAL_II_NAMESPACE_CLOSE
#define TYPE2 float
#include "sparse_matrix_matrix.in.h"
// #include <lac/sparse_matrix.2.templates>
+DEAL_II_NAMESPACE_OPEN
+
#undef TYPEMAT
vmult_add (BlockVector<double> &, const Vector<double> &) const;
template void SparseMatrix<double>::
Tvmult_add (BlockVector<double> &, const Vector<double> &) const;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#define TYPEMAT float
+DEAL_II_NAMESPACE_OPEN
template class SparseMatrix<TYPEMAT>;
+DEAL_II_NAMESPACE_CLOSE
#define TYPE2 float
#include "sparse_matrix_matrix.in.h"
// #include <lac/sparse_matrix.2.templates>
+DEAL_II_NAMESPACE_OPEN
+
#undef TYPEMAT
vmult_add (BlockVector<double> &, const Vector<double> &) const;
template void SparseMatrix<float>::
Tvmult_add (BlockVector<double> &, const Vector<double> &) const;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2005 by the deal.II authors
+// Copyright (C) 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#define TYPEMAT double
+DEAL_II_NAMESPACE_OPEN
template class SparseMatrixEZ<TYPEMAT>;
+DEAL_II_NAMESPACE_CLOSE
+
#define TYPEVEC float
#include "sparse_matrix_ez_vector.in.h"
// $Id$
// Version: $Name$
//
-// Copyright (C) 2003, 2005 by the deal.II authors
+// Copyright (C) 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#define TYPEMAT float
+DEAL_II_NAMESPACE_OPEN
template class SparseMatrixEZ<TYPEMAT>;
+DEAL_II_NAMESPACE_CLOSE
#define TYPEVEC float
#include "sparse_matrix_ez_vector.in.h"
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003 by the deal.II authors
+// Copyright (C) 2002, 2003, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// TYPEMAT and TYPEVEC are defined in sparse_matrix_ez?.cc
+DEAL_II_NAMESPACE_OPEN
+
template void SparseMatrixEZ<TYPEMAT>::vmult<TYPEVEC> (
Vector<TYPEVEC> &,
const Vector<TYPEVEC> &) const;
const Vector<TYPEVEC> &,
const TYPEMAT) const;
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// TYPEMAT and TYPE2 are defined in sparsematrix?.cc
+DEAL_II_NAMESPACE_OPEN
+
template SparseMatrix<TYPEMAT> &
SparseMatrix<TYPEMAT>::copy_from<TYPE2> (const SparseMatrix<TYPE2> &);
template void SparseMatrix<TYPEMAT>::add_scaled<TYPE2> (const TYPEMAT,
const SparseMatrix<TYPE2> &);
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// TYPEMAT and TYPEVEC are defined in sparsematrix?.cc
+DEAL_II_NAMESPACE_OPEN
+
template void SparseMatrix<TYPEMAT>::
vmult (Vector<TYPEVEC> &, const Vector<TYPEVEC> &) const;
template void SparseMatrix<TYPEMAT>::
SSOR_step<TYPEVEC> (Vector<TYPEVEC> &,
const Vector<TYPEVEC> &,
const TYPEMAT) const;
+
+DEAL_II_NAMESPACE_CLOSE
//---------------------------------------------------------------------------
-// Copyright (C) 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2005, 2006 by the deal.II authors
// by the deal.II authors and Stephen "Cheffo" Kolaroff
//
// This file is subject to QPL and may not be distributed
#include <lac/sparse_mic.templates.h>
+DEAL_II_NAMESPACE_OPEN
+
// explicit instantiations for double and float matrices
template class SparseMIC<double>;
template void SparseMIC<float>::vmult<float> (Vector<float> &,
const Vector<float> &) const;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/sparse_vanka.templates.h>
+DEAL_II_NAMESPACE_OPEN
+
// explicit instantiations
template class SparseVanka<float>;
const Vector<float> &src) const;
template void SparseBlockVanka<double>::vmult<double> (Vector<double> &dst,
const Vector<double> &src) const;
+
+DEAL_II_NAMESPACE_CLOSE
#include <numeric>
#include <functional>
+DEAL_II_NAMESPACE_OPEN
+
#ifdef DEAL_II_USE_METIS
extern "C" {
# include <metis.h>
// explicit instantiations
template void SparsityPattern::copy_from<float> (const FullMatrix<float> &, bool);
template void SparsityPattern::copy_from<double> (const FullMatrix<double> &, bool);
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/swappable_vector.templates.h>
+DEAL_II_NAMESPACE_OPEN
+
// explicit instantiations
template class SwappableVector<double>;
template class SwappableVector<float>;
+
+DEAL_II_NAMESPACE_CLOSE
#include <lac/vector.h>
#include <lac/lapack_templates.h>
+DEAL_II_NAMESPACE_OPEN
+
using namespace LAPACKSupport;
template<typename number>
template class TridiagonalMatrix<float>;
template class TridiagonalMatrix<double>;
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/vector.templates.h>
+DEAL_II_NAMESPACE_OPEN
+
// explicit instantiations
template class Vector<double>;
template void Vector<float>::equ<float>(const float, const Vector<float>&);
template void Vector<float>::scale<double>(const Vector<double>&);
template void Vector<float>::scale<float>(const Vector<float>&);
+
+DEAL_II_NAMESPACE_CLOSE
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <lac/vector.templates.h>
+DEAL_II_NAMESPACE_OPEN
+
// explicit instantiations
template class Vector<long double>;
template float Vector<float>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator *<long double> (const Vector<long double> &) const;
template void Vector<float>::reinit<long double>(const Vector<long double>&, const bool);
template void Vector<float>::equ<long double>(const float, const Vector<long double>&);
+
+DEAL_II_NAMESPACE_CLOSE