using namespace Algorithms;
-class Explicit : public Operator<Vector<double> >
+class Explicit : public OperatorBase
{
public:
Explicit(const FullMatrix<double> &matrix);
};
-class Implicit : public Operator<Vector<double> >
+class Implicit : public OperatorBase
{
public:
Implicit(const FullMatrix<double> &matrix);
DEAL_II_NAMESPACE_OPEN
/**
- * Select data from NamedData corresponding to the attached name.
+ * Select data from AnyData corresponding to the attached name.
*
* Given a list of names to search for (provided by add()), objects of this
* class provide an index list of the selected data.
/**
- * Return the corresponding index in the NamedData object supplied to the
+ * Return the corresponding index in the AnyData object supplied to the
* last initialize(). It is an error if initialize() has not been called
* before.
*
* @author Guido Kanschat, 2006, 2010
*/
template <typename VectorType>
- class Newton : public Operator<VectorType>
+ class Newton : public OperatorBase
{
public:
/**
* Constructor, receiving the applications computing the residual and
* solving the linear problem, respectively.
*/
- Newton (Operator<VectorType> &residual, Operator<VectorType> &inverse_derivative);
+ Newton (OperatorBase &residual, OperatorBase &inverse_derivative);
/**
* Declare the parameters applicable to Newton's method.
/**
* The operator computing the residual.
*/
- SmartPointer<Operator<VectorType>, Newton<VectorType> > residual;
+ SmartPointer<OperatorBase, Newton<VectorType> > residual;
/**
* The operator applying the inverse derivative to the residual.
*/
- SmartPointer<Operator<VectorType>, Newton<VectorType> > inverse_derivative;
+ SmartPointer<OperatorBase, Newton<VectorType> > inverse_derivative;
/**
* The operator handling the output in case the debug_vectors is true.
namespace Algorithms
{
template <typename VectorType>
- Newton<VectorType>::Newton(Operator<VectorType> &residual, Operator<VectorType> &inverse_derivative)
+ Newton<VectorType>::Newton(OperatorBase &residual,
+ OperatorBase &inverse_derivative)
:
residual(&residual), inverse_derivative(&inverse_derivative),
assemble_now(false),
};
- /**
- * @deprecated This class has been replaced by OperatorBase.
- *
- * The abstract base class of all algorithms in this library. An operator is
- * an object with an operator(), which transforms a set of named vectors
- * into another set of named vectors.
- *
- * Furthermore, an operator can be notified of parameter changes by the
- * calling routine. The outer iteration can notify() the Operator of an
- * Event, which could be for instance a change of mesh, a different time
- * step size or too slow convergence of Newton's method, which would then
- * trigger reassembling of a matrix or similar things.
- *
- * <h3>Usage for nested iterations</h3>
- *
- * This is probably the most prominent use for Operator, where an outer
- * iterative method calls an inner solver and so on. Typically, the
- * innermost method in such a nested system will have to compute a residual
- * using values from all outer iterations. Since the depth and order of such
- * a nesting is hardly predictable when designing a general tool, we use
- * NamedData to access these vectors. Typically, the first vector in
- * <tt>out</tt> contains the start vector when operator()() is called, and
- * the solution when the function returns. The object <tt>in</tt> is
- * providing additional information and forwarded to the inner Operator
- * objects of the nested iteration.
- *
- * @author Guido Kanschat, 2010
- */
- template <typename VectorType>
- class Operator : public OperatorBase
- {
- public:
- Operator();
- };
-
/**
* An unary operator base class, intended to output the vectors in AnyData
* in each step of an iteration.
namespace Algorithms
{
- template <typename VectorType>
- Operator<VectorType>::Operator()
- {}
-
template <typename VectorType>
OutputOperator<VectorType>::~OutputOperator()
{}
* @date 2010
*/
template <typename VectorType>
- class ThetaTimestepping : public Operator<VectorType>
+ class ThetaTimestepping : public OperatorBase
{
public:
/**
* #op_implicit. For their meaning, see the description of those
* variables.
*/
- ThetaTimestepping (Operator<VectorType> &op_explicit,
- Operator<VectorType> &op_implicit);
+ ThetaTimestepping (OperatorBase &op_explicit,
+ OperatorBase &op_implicit);
/**
* The timestepping scheme.
* vector, $M$ the mass matrix, $F$ the operator in space and $c$ is the
* adjusted time step size $(1-\theta) \Delta t$.
*/
- SmartPointer<Operator<VectorType>, ThetaTimestepping<VectorType> > op_explicit;
+ SmartPointer<OperatorBase, ThetaTimestepping<VectorType> > op_explicit;
/**
* The operator solving the implicit part of the scheme. It will receive
* the input data, <i>M</i> the mass matrix, <i>F</i> the operator in
* space and <i>c</i> is the adjusted time step size $ \theta \Delta t$
*/
- SmartPointer<Operator<VectorType>, ThetaTimestepping<VectorType> > op_implicit;
+ SmartPointer<OperatorBase, ThetaTimestepping<VectorType> > op_implicit;
/**
* The operator writing the output in each time step
namespace Algorithms
{
template <typename VectorType>
- ThetaTimestepping<VectorType>::ThetaTimestepping (Operator<VectorType> &e, Operator<VectorType> &i)
+ ThetaTimestepping<VectorType>::ThetaTimestepping (OperatorBase &e, OperatorBase &i)
: vtheta(0.5), adaptive(false), op_explicit(&e), op_implicit(&i)
{}
for (VEC : SERIAL_VECTORS)
{
- template class Operator<VEC>;
template class OutputOperator<VEC>;
template class Newton<VEC>;
template class ThetaTimestepping<VEC>;
};
class SquareRootResidual : public
- Algorithms::Operator<Vector<double> >
+ Algorithms::OperatorBase
{
SmartPointer<SquareRoot, SquareRootResidual>
discretization;
};
class SquareRootSolver : public
- Algorithms::Operator<Vector<double> >
+ Algorithms::OperatorBase
{
SmartPointer<SquareRoot, SquareRootSolver>
solver;
class Explicit
- : public Operator<Vector<double> >
+ : public OperatorBase
{
public:
Explicit(const FullMatrix<double> &matrix);
class Implicit
- : public Operator<Vector<double> >
+ : public OperatorBase
{
public:
Implicit(const FullMatrix<double> &matrix);
projects / dealii.git / commitdiff