From 58c533e4d0482b15450ee7f97a83f1152eb823e7 Mon Sep 17 00:00:00 2001
From: Oliver Sander <sander@igpm.rwth-aachen.de>
Date: Mon, 24 Oct 2011 07:51:41 +0000
Subject: [PATCH] compile again after recent interface changes
[[Imported from SVN: r7998]]
---
test/localgeodesicfefunctiontest.cc | 67 +++++++++++++++++++++--------
1 file changed, 50 insertions(+), 17 deletions(-)
diff --git a/test/localgeodesicfefunctiontest.cc b/test/localgeodesicfefunctiontest.cc
index c0fb5d8f..d4436460 100644
--- a/test/localgeodesicfefunctiontest.cc
+++ b/test/localgeodesicfefunctiontest.cc
@@ -6,6 +6,8 @@
#include <dune/common/fvector.hh>
#include <dune/grid/common/quadraturerules.hh>
+#include <dune/localfunctions/lagrange/pqkfactory.hh>
+
#include <dune/gfe/rotation.hh>
#include <dune/gfe/realtuple.hh>
#include <dune/gfe/unitvector.hh>
@@ -59,7 +61,14 @@ void testPermutationInvariance(const std::vector<TargetSpace>& corners)
{
// works only for 2d domains
assert(domainDim==2);
+
+ PQkLocalFiniteElementCache<double,double,domainDim,1> feCache;
+ typedef typename PQkLocalFiniteElementCache<double,double,domainDim,1>::FiniteElementType LocalFiniteElement;
+ GeometryType simplex;
+ simplex.makeSimplex(domainDim);
+
+ //
std::vector<TargetSpace> cornersRotated1(domainDim+1);
std::vector<TargetSpace> cornersRotated2(domainDim+1);
@@ -67,15 +76,15 @@ void testPermutationInvariance(const std::vector<TargetSpace>& corners)
cornersRotated1[1] = cornersRotated2[0] = corners[2];
cornersRotated1[2] = cornersRotated2[1] = corners[0];
- LocalGeodesicFEFunction<2,double,TargetSpace> f0(corners);
- LocalGeodesicFEFunction<2,double,TargetSpace> f1(cornersRotated1);
- LocalGeodesicFEFunction<2,double,TargetSpace> f2(cornersRotated2);
+ LocalGeodesicFEFunction<2,double,LocalFiniteElement,TargetSpace> f0(feCache.get(simplex), corners);
+ LocalGeodesicFEFunction<2,double,LocalFiniteElement,TargetSpace> f1(feCache.get(simplex), cornersRotated1);
+ LocalGeodesicFEFunction<2,double,LocalFiniteElement,TargetSpace> f2(feCache.get(simplex), cornersRotated2);
// A quadrature rule as a set of test points
int quadOrder = 3;
const Dune::QuadratureRule<double, domainDim>& quad
- = Dune::QuadratureRules<double, domainDim>::rule(GeometryType(GeometryType::simplex,domainDim), quadOrder);
+ = Dune::QuadratureRules<double, domainDim>::rule(simplex, quadOrder);
for (size_t pt=0; pt<quad.size(); pt++) {
@@ -107,8 +116,16 @@ template <int domainDim, class TargetSpace>
void testDerivative(const std::vector<TargetSpace>& corners)
{
// Make local fe function to be tested
- LocalGeodesicFEFunction<domainDim,double,TargetSpace> f(corners);
+ PQkLocalFiniteElementCache<double,double,domainDim,1> feCache;
+ typedef typename PQkLocalFiniteElementCache<double,double,domainDim,1>::FiniteElementType LocalFiniteElement;
+
+ GeometryType simplex;
+ simplex.makeSimplex(domainDim);
+
+ LocalGeodesicFEFunction<domainDim,double,LocalFiniteElement,TargetSpace> f(feCache.get(simplex), corners);
+ static const int embeddedDim = TargetSpace::EmbeddedTangentVector::dimension;
+
// A quadrature rule as a set of test points
int quadOrder = 3;
@@ -120,12 +137,12 @@ void testDerivative(const std::vector<TargetSpace>& corners)
const Dune::FieldVector<double,domainDim>& quadPos = quad[pt].position();
// evaluate actual derivative
- Dune::FieldMatrix<double, TargetSpace::EmbeddedTangentVector::size, domainDim> derivative = f.evaluateDerivative(quadPos);
+ Dune::FieldMatrix<double, embeddedDim, domainDim> derivative = f.evaluateDerivative(quadPos);
// evaluate fd approximation of derivative
- Dune::FieldMatrix<double, TargetSpace::EmbeddedTangentVector::size, domainDim> fdDerivative = f.evaluateDerivativeFD(quadPos);
+ Dune::FieldMatrix<double, embeddedDim, domainDim> fdDerivative = f.evaluateDerivativeFD(quadPos);
- Dune::FieldMatrix<double, TargetSpace::EmbeddedTangentVector::size, domainDim> diff = derivative;
+ Dune::FieldMatrix<double, embeddedDim, domainDim> diff = derivative;
diff -= fdDerivative;
if ( diff.infinity_norm() > 100*eps ) {
@@ -144,13 +161,21 @@ template <int domainDim, class TargetSpace>
void testDerivativeOfValueWRTCoefficients(const std::vector<TargetSpace>& corners)
{
// Make local fe function to be tested
- LocalGeodesicFEFunction<domainDim,double,TargetSpace> f(corners);
+ PQkLocalFiniteElementCache<double,double,domainDim,1> feCache;
+ typedef typename PQkLocalFiniteElementCache<double,double,domainDim,1>::FiniteElementType LocalFiniteElement;
+
+ GeometryType simplex;
+ simplex.makeSimplex(domainDim);
+ LocalGeodesicFEFunction<domainDim,double,LocalFiniteElement,TargetSpace> f(feCache.get(simplex), corners);
+
+ static const int embeddedDim = TargetSpace::EmbeddedTangentVector::dimension;
+
// A quadrature rule as a set of test points
int quadOrder = 3;
const Dune::QuadratureRule<double, domainDim>& quad
- = Dune::QuadratureRules<double, domainDim>::rule(GeometryType(GeometryType::simplex,domainDim), quadOrder);
+ = Dune::QuadratureRules<double, domainDim>::rule(simplex, quadOrder);
for (size_t pt=0; pt<quad.size(); pt++) {
@@ -160,15 +185,15 @@ void testDerivativeOfValueWRTCoefficients(const std::vector<TargetSpace>& corner
for (size_t i=0; i<corners.size(); i++) {
// evaluate actual derivative
- FieldMatrix<double, TargetSpace::EmbeddedTangentVector::size, TargetSpace::EmbeddedTangentVector::size> derivative;
+ FieldMatrix<double, embeddedDim, embeddedDim> derivative;
f.evaluateDerivativeOfValueWRTCoefficient(quadPos, i, derivative);
// evaluate fd approximation of derivative
- FieldMatrix<double, TargetSpace::EmbeddedTangentVector::size, TargetSpace::EmbeddedTangentVector::size> fdDerivative;
+ FieldMatrix<double, embeddedDim, embeddedDim> fdDerivative;
f.evaluateFDDerivativeOfValueWRTCoefficient(quadPos, i, fdDerivative);
if ( (derivative - fdDerivative).infinity_norm() > eps ) {
- std::cout << className(corners[0]) << ": Analytical derivative of value does not match fd approximation." << std::endl;
+ std::cout << className<TargetSpace>() << ": Analytical derivative of value does not match fd approximation." << std::endl;
std::cout << "coefficient: " << i << std::endl;
std::cout << "quad pos: " << quadPos << std::endl;
std::cout << "gfe: ";
@@ -191,13 +216,21 @@ template <int domainDim, class TargetSpace>
void testDerivativeOfGradientWRTCoefficients(const std::vector<TargetSpace>& corners)
{
// Make local fe function to be tested
- LocalGeodesicFEFunction<domainDim,double,TargetSpace> f(corners);
+ PQkLocalFiniteElementCache<double,double,domainDim,1> feCache;
+ typedef typename PQkLocalFiniteElementCache<double,double,domainDim,1>::FiniteElementType LocalFiniteElement;
+
+ GeometryType simplex;
+ simplex.makeSimplex(domainDim);
+ LocalGeodesicFEFunction<domainDim,double,LocalFiniteElement,TargetSpace> f(feCache.get(simplex),corners);
+
+ static const int embeddedDim = TargetSpace::EmbeddedTangentVector::dimension;
+
// A quadrature rule as a set of test points
int quadOrder = 3;
const Dune::QuadratureRule<double, domainDim>& quad
- = Dune::QuadratureRules<double, domainDim>::rule(GeometryType(GeometryType::simplex,domainDim), quadOrder);
+ = Dune::QuadratureRules<double, domainDim>::rule(simplex, quadOrder);
for (size_t pt=0; pt<quad.size(); pt++) {
@@ -207,11 +240,11 @@ void testDerivativeOfGradientWRTCoefficients(const std::vector<TargetSpace>& cor
for (size_t i=0; i<corners.size(); i++) {
// evaluate actual derivative
- Tensor3<double, TargetSpace::EmbeddedTangentVector::size, TargetSpace::EmbeddedTangentVector::size, domainDim> derivative;
+ Tensor3<double, embeddedDim, embeddedDim, domainDim> derivative;
f.evaluateDerivativeOfGradientWRTCoefficient(quadPos, i, derivative);
// evaluate fd approximation of derivative
- Tensor3<double, TargetSpace::EmbeddedTangentVector::size, TargetSpace::EmbeddedTangentVector::size, domainDim> fdDerivative;
+ Tensor3<double, embeddedDim, embeddedDim, domainDim> fdDerivative;
f.evaluateFDDerivativeOfGradientWRTCoefficient(quadPos, i, fdDerivative);
if ( (derivative - fdDerivative).infinity_norm() > eps ) {
--
GitLab