const Point<spacedim> &p2,
const double w) const;
- /**
- * Return the point which shall become the new vertex surrounded by the
- * given points which make up the quadrature. We use a quadrature object,
- * which should be filled with the surrounding points together with
- * appropriate weights.
- *
- * In its default implementation it uses a pair-wise reduction of
- * the points in the quadrature formula by calling the function
- * get_intermediate_point() on the first two points, then on the
- * resulting point and the next, until all points in the quadrature
- * have been taken into account. User classes can get away by simply
- * implementing the get_intermediate_point() function. Notice that
- * by default the get_intermediate_point() function calls the
- * project_to_manifold() function with the convex combination of its
- * arguments. For simple situations you may get away by implementing
- * only the project_to_manifold() function.
- */
- virtual
- Point<spacedim>
- get_new_point (const Quadrature<spacedim> &quad) const DEAL_II_DEPRECATED;
-
/**
* Return the point which shall become the new vertex surrounded by the
* given points @p surrounding_points. @p weights contains appropriate
FlatManifold (const Tensor<1,spacedim> &periodicity = Tensor<1,spacedim>(),
const double tolerance=1e-10);
- /**
- * Let the new point be the average sum of surrounding vertices.
- *
- * This particular implementation constructs the weighted average of the
- * surrounding points, and then calls internally the function
- * project_to_manifold(). The reason why we do it this way, is to allow lazy
- * programmers to implement only the project_to_manifold() function for their
- * own Manifold classes which are small (or trivial) perturbations of a flat
- * manifold. This is the case whenever the coarse mesh is a decent
- * approximation of the manifold geometry. In this case, the middle point of
- * a cell is close to true middle point of the manifold, and a projection
- * may suffice.
- *
- * For most simple geometries, it is possible to get reasonable results by
- * deriving your own Manifold class from FlatManifold, and write a new
- * interface only for the project_to_manifold function. You will have good
- * approximations also with large deformations, as long as in the coarsest
- * mesh size you are trying to refine, the middle point is not too far from
- * the manifold mid point, i.e., as long as the coarse mesh size is small
- * enough.
- */
- virtual
- Point<spacedim>
- get_new_point(const Quadrature<spacedim> &quad) const DEAL_II_DEPRECATED;
-
/**
* Let the new point be the average sum of surrounding vertices.
*
*/
virtual ~ChartManifold ();
-
- /**
- * Refer to the general documentation of this class and the documentation of
- * the base class for more information.
- */
- virtual
- Point<spacedim>
- get_new_point(const Quadrature<spacedim> &quad) const DEAL_II_DEPRECATED;
-
/**
* Refer to the general documentation of this class and the documentation of
* the base class for more information.
get_tangent_vector (const Point<spacedim> &x1,
const Point<spacedim> &x2) const;
- /**
- * Return a point on the spherical manifold which is intermediate
- * with respect to the surrounding points.
- *
- * @deprecated Use the other function that takes points and weights separately instead.
- */
- virtual
- Point<spacedim>
- get_new_point(const dealii::Quadrature<spacedim> &quadrature) const DEAL_II_DEPRECATED;
-
/**
* Return a point on the spherical manifold which is intermediate
* with respect to the surrounding points.
const Point<spacedim> &point_on_axis,
const double tolerance = 1e-10);
- /**
- * Compute new points on the CylindricalManifold. See the documentation of
- * the base class for a detailed description of what this function does.
- */
- virtual Point<spacedim>
- get_new_point(const Quadrature<spacedim> &quad) const DEAL_II_DEPRECATED;
-
/**
* Compute new points on the CylindricalManifold. See the documentation of
* the base class for a detailed description of what this function does.
-template <int dim, int spacedim>
-Point<spacedim>
-Manifold<dim, spacedim>::
-get_new_point (const Quadrature<spacedim> &quad) const
-{
- return get_new_point(quad.get_points(),quad.get_weights());
-}
-
-
-
template <int dim, int spacedim>
Point<spacedim>
Manifold<dim, spacedim>::
-template <int dim, int spacedim>
-Point<spacedim>
-FlatManifold<dim, spacedim>::
-get_new_point (const Quadrature<spacedim> &quad) const
-{
- return get_new_point(quad.get_points(),quad.get_weights());
-}
-
-
-
template <int dim, int spacedim>
Point<spacedim>
FlatManifold<dim, spacedim>::
-template <int dim, int spacedim, int chartdim>
-Point<spacedim>
-ChartManifold<dim,spacedim,chartdim>::
-get_new_point (const Quadrature<spacedim> &quad) const
-{
- return get_new_point(quad.get_points(),quad.get_weights());
-}
-
-
-
template <int dim, int spacedim, int chartdim>
Point<spacedim>
ChartManifold<dim,spacedim,chartdim>::
return (r1-r2)*e1 + r1*gamma*tg;
}
-template <int dim, int spacedim>
-Point<spacedim>
-SphericalManifold<dim, spacedim>::
-get_new_point (const Quadrature<spacedim> &quad) const
-{
- return get_new_point(quad.get_points(),quad.get_weights());
-}
+
template <int dim, int spacedim>
Point<spacedim>
-template <int dim, int spacedim>
-Point<spacedim>
-CylindricalManifold<dim,spacedim>::
-get_new_point (const Quadrature<spacedim> &quad) const
-{
- return get_new_point(quad.get_points(),quad.get_weights());
-}
-
-
-
template <int dim, int spacedim>
Point<spacedim>
CylindricalManifold<dim,spacedim>::
// ============================================================
-// FunctionChartManifold
+// FunctionManifold
// ============================================================
template <int dim, int spacedim, int chartdim>
FunctionManifold<dim,spacedim,chartdim>::FunctionManifold
AssertDimension(pull_back_function.n_components, chartdim);
}
+
+
template <int dim, int spacedim, int chartdim>
FunctionManifold<dim,spacedim,chartdim>::FunctionManifold
(const std::string push_forward_expression,
pull_back_function = pb;
}
+
+
template <int dim, int spacedim, int chartdim>
FunctionManifold<dim,spacedim,chartdim>::~FunctionManifold()
{
}
}
+
+
template <int dim, int spacedim, int chartdim>
Point<spacedim>
FunctionManifold<dim,spacedim,chartdim>::push_forward(const Point<chartdim> &chart_point) const
}
+
template <int dim, int spacedim, int chartdim>
DerivativeForm<1,chartdim, spacedim>
FunctionManifold<dim,spacedim,chartdim>::push_forward_gradient(const Point<chartdim> &chart_point) const
}
+
template <int dim, int spacedim, int chartdim>
Point<chartdim>
FunctionManifold<dim,spacedim,chartdim>::pull_back(const Point<spacedim> &space_point) const
return Point<3>(phi, theta, w);
}
+
+
template <int dim>
Point<3>
TorusManifold<dim>::push_forward(const Point<3> &chart_point) const
}
+
template <int dim>
TorusManifold<dim>::TorusManifold (const double R, const double r)
: ChartManifold<dim,3,3> (Point<3>(2*numbers::PI, 2*numbers::PI, 0.0)),
Assert (r>0.0, ExcMessage("inner radius must be positive."));
}
+
+
template <int dim>
DerivativeForm<1,3,3>
TorusManifold<dim>::push_forward_gradient(const Point<3> &chart_point) const