From 75f4976e86369eaad4676a56a2e03453f627e460 Mon Sep 17 00:00:00 2001
From: Oliver Sander <sander@igpm.rwth-aachen.de>
Date: Thu, 16 Apr 2009 13:07:38 +0000
Subject: [PATCH] The class 'Configuration' is now called 'RigidBodyMotion',
and can be parametrized by the space dimension
[[Imported from SVN: r4003]]
---
dirneucoupling.cc | 12 ++++------
rod3d.cc | 4 ++--
src/averageinterface.hh | 4 ++--
src/rigidbodymotion.hh | 16 +++++++------
src/rodassembler.cc | 46 ++++++++++++++++++------------------
src/rodassembler.hh | 20 ++++++++--------
src/roddifference.hh | 4 ++--
src/rodlocalstiffness.hh | 22 +++++++++---------
src/rodsolver.cc | 2 +-
src/rodsolver.hh | 8 +++----
src/rodwriter.hh | 4 ++--
test/fdcheck.hh | 50 +++++++++++++++++++++-------------------
12 files changed, 97 insertions(+), 95 deletions(-)
diff --git a/dirneucoupling.cc b/dirneucoupling.cc
index aab88cb2..3c7f63ce 100644
--- a/dirneucoupling.cc
+++ b/dirneucoupling.cc
@@ -29,7 +29,7 @@
#include "src/quaternion.hh"
#include "src/rodassembler.hh"
-#include "src/configuration.hh"
+#include "src/rigidbodymotion.hh"
#include "src/averageinterface.hh"
#include "src/rodsolver.hh"
#include "src/roddifference.hh"
@@ -45,7 +45,7 @@ using std::vector;
// Some types that I need
//typedef BCRSMatrix<FieldMatrix<double, dim, dim> > OperatorType;
//typedef BlockVector<FieldVector<double, dim> > VectorType;
-typedef vector<Configuration> RodSolutionType;
+typedef vector<RigidBodyMotion<dim> > RodSolutionType;
typedef BlockVector<FieldVector<double, 6> > RodDifferenceType;
@@ -89,8 +89,6 @@ int main (int argc, char *argv[]) try
// Some types that I need
typedef BCRSMatrix<FieldMatrix<double, dim, dim> > MatrixType;
typedef BlockVector<FieldVector<double, dim> > VectorType;
- typedef std::vector<Configuration> RodSolutionType;
- typedef BlockVector<FieldVector<double, 6> > RodDifferenceType;
// parse data file
ConfigParser parameterSet;
@@ -357,8 +355,8 @@ int main (int argc, char *argv[]) try
// /////////////////////////////////////////////////////
// Init interface value
- Configuration referenceInterface = rodX[0];
- Configuration lambda = referenceInterface;
+ RigidBodyMotion<3> referenceInterface = rodX[0];
+ RigidBodyMotion<3> lambda = referenceInterface;
FieldVector<double,3> lambdaForce(0);
FieldVector<double,3> lambdaTorque(0);
@@ -432,7 +430,7 @@ int main (int argc, char *argv[]) try
// Extract new interface position and orientation
// ///////////////////////////////////////////////////////////
- Configuration averageInterface;
+ RigidBodyMotion<3> averageInterface;
computeAverageInterface(interfaceBoundary[toplevel], x3d, averageInterface);
//averageInterface.r[0] = averageInterface.r[1] = 0;
diff --git a/rod3d.cc b/rod3d.cc
index b5eaa1aa..ab0205bf 100644
--- a/rod3d.cc
+++ b/rod3d.cc
@@ -11,7 +11,7 @@
#include <dune-solvers/solvers/iterativesolver.hh>
#include <dune-solvers/norms/energynorm.hh>
-#include "src/configuration.hh"
+#include "src/rigidbodymotion.hh"
#include "src/roddifference.hh"
#include "src/rodwriter.hh"
#include "src/rotation.hh"
@@ -36,7 +36,7 @@ double computeEnergyNormSquared(const BlockVector<FieldVector<double,6> >& x,
int main (int argc, char *argv[]) try
{
- typedef std::vector<Configuration> SolutionType;
+ typedef std::vector<RigidBodyMotion<3> > SolutionType;
// parse data file
ConfigParser parameterSet;
diff --git a/src/averageinterface.hh b/src/averageinterface.hh
index 25442149..1ee094f0 100644
--- a/src/averageinterface.hh
+++ b/src/averageinterface.hh
@@ -409,7 +409,7 @@ template <class GridType>
void computeAveragePressure(const Dune::FieldVector<double,GridType::dimension>& resultantForce,
const Dune::FieldVector<double,GridType::dimension>& resultantTorque,
const BoundaryPatch<GridType>& interface,
- const Configuration& crossSection,
+ const RigidBodyMotion<3>& crossSection,
Dune::BlockVector<Dune::FieldVector<double, GridType::dimension> >& pressure)
{
const GridType& grid = interface.getGrid();
@@ -640,7 +640,7 @@ void computeAveragePressure(const Dune::FieldVector<double,GridType::dimension>&
template <class GridType>
void computeAverageInterface(const BoundaryPatch<GridType>& interface,
const Dune::BlockVector<Dune::FieldVector<double,GridType::dimension> > deformation,
- Configuration& average)
+ RigidBodyMotion<3>& average)
{
using namespace Dune;
diff --git a/src/rigidbodymotion.hh b/src/rigidbodymotion.hh
index 2f7081ce..04ea26e9 100644
--- a/src/rigidbodymotion.hh
+++ b/src/rigidbodymotion.hh
@@ -1,22 +1,24 @@
-#ifndef CONFIGURATION_HH
-#define CONFIGURATION_HH
+#ifndef RIGID_BODY_MOTION_HH
+#define RIGID_BODY_MOTION_HH
#include <dune/common/fvector.hh>
#include "rotation.hh"
-/** \brief Configuration of a nonlinear rod in 3d */
-struct Configuration
+/** \brief A rigid-body motion in, R^d, i.e., a member of SE(d) */
+template <int dim, class ctype=double>
+struct RigidBodyMotion
{
// Translational part
- Dune::FieldVector<double,3> r;
+ Dune::FieldVector<ctype, dim> r;
// Rotational part
- Rotation<3,double> q;
+ Rotation<dim,ctype> q;
};
//! Send configuration to output stream
-std::ostream& operator<< (std::ostream& s, const Configuration& c)
+template <int dim, class ctype>
+std::ostream& operator<< (std::ostream& s, const RigidBodyMotion<dim,ctype>& c)
{
s << "(" << c.r << ") (" << c.q << ")";
return s;
diff --git a/src/rodassembler.cc b/src/rodassembler.cc
index 80ca3ea5..ff1f4dde 100644
--- a/src/rodassembler.cc
+++ b/src/rodassembler.cc
@@ -48,7 +48,7 @@ getNeighborsPerVertex(Dune::MatrixIndexSet& nb) const
template <class GridType>
void RodAssembler<GridType>::
-assembleMatrix(const std::vector<Configuration>& sol,
+assembleMatrix(const std::vector<RigidBodyMotion<3> >& sol,
Dune::BCRSMatrix<MatrixBlock>& matrix) const
{
using namespace Dune;
@@ -74,7 +74,7 @@ assembleMatrix(const std::vector<Configuration>& sol,
mat.setSize(numOfBaseFct, numOfBaseFct);
// Extract local solution
- std::vector<Configuration> localSolution(numOfBaseFct);
+ std::vector<RigidBodyMotion<3> > localSolution(numOfBaseFct);
for (int i=0; i<numOfBaseFct; i++)
localSolution[i] = sol[indexSet.template subIndex<gridDim>(*it,i)];
@@ -102,7 +102,7 @@ assembleMatrix(const std::vector<Configuration>& sol,
template <class GridType>
void RodAssembler<GridType>::
-assembleMatrixFD(const std::vector<Configuration>& sol,
+assembleMatrixFD(const std::vector<RigidBodyMotion<3> >& sol,
Dune::BCRSMatrix<MatrixBlock>& matrix) const
{
using namespace Dune;
@@ -114,13 +114,13 @@ assembleMatrixFD(const std::vector<Configuration>& sol,
// ///////////////////////////////////////////////////////////
// Compute gradient by finite-difference approximation
// ///////////////////////////////////////////////////////////
- std::vector<Configuration> forwardSolution = sol;
- std::vector<Configuration> backwardSolution = sol;
+ std::vector<RigidBodyMotion<3> > forwardSolution = sol;
+ std::vector<RigidBodyMotion<3> > backwardSolution = sol;
- std::vector<Configuration> forwardForwardSolution = sol;
- std::vector<Configuration> forwardBackwardSolution = sol;
- std::vector<Configuration> backwardForwardSolution = sol;
- std::vector<Configuration> backwardBackwardSolution = sol;
+ std::vector<RigidBodyMotion<3> > forwardForwardSolution = sol;
+ std::vector<RigidBodyMotion<3> > forwardBackwardSolution = sol;
+ std::vector<RigidBodyMotion<3> > backwardForwardSolution = sol;
+ std::vector<RigidBodyMotion<3> > backwardBackwardSolution = sol;
// ////////////////////////////////////////////////////
// Create local assembler
@@ -144,8 +144,8 @@ assembleMatrixFD(const std::vector<Configuration>& sol,
for (; eIt!=eEndIt; ++eIt)
elements[indexSet.index(*eIt)] = eIt;
- Dune::array<Configuration,2> localReferenceConfiguration;
- Dune::array<Configuration,2> localSolution;
+ Dune::array<RigidBodyMotion<3>,2> localReferenceConfiguration;
+ Dune::array<RigidBodyMotion<3>,2> localSolution;
// ///////////////////////////////////////////////////////////////
// Loop over all blocks of the outer matrix
@@ -353,7 +353,7 @@ assembleMatrixFD(const std::vector<Configuration>& sol,
template <class GridType>
void RodAssembler<GridType>::
-assembleGradient(const std::vector<Configuration>& sol,
+assembleGradient(const std::vector<RigidBodyMotion<3> >& sol,
Dune::BlockVector<Dune::FieldVector<double, blocksize> >& grad) const
{
using namespace Dune;
@@ -385,13 +385,13 @@ assembleGradient(const std::vector<Configuration>& sol,
const int nDofs = 2;
// Extract local solution
- array<Configuration,nDofs> localSolution;
+ array<RigidBodyMotion<3>,nDofs> localSolution;
for (int i=0; i<nDofs; i++)
localSolution[i] = sol[indexSet.subIndex(*it,i,gridDim)];
// Extract local reference configuration
- array<Configuration,nDofs> localReferenceConfiguration;
+ array<RigidBodyMotion<3>,nDofs> localReferenceConfiguration;
for (int i=0; i<nDofs; i++)
localReferenceConfiguration[i] = referenceConfiguration_[indexSet.subIndex(*it,i,gridDim)];
@@ -412,7 +412,7 @@ assembleGradient(const std::vector<Configuration>& sol,
template <class GridType>
double RodAssembler<GridType>::
-computeEnergy(const std::vector<Configuration>& sol) const
+computeEnergy(const std::vector<RigidBodyMotion<3> >& sol) const
{
using namespace Dune;
@@ -431,8 +431,8 @@ computeEnergy(const std::vector<Configuration>& sol) const
Dune::array<double,3> A = {A_[0], A_[1], A_[2]};
RodLocalStiffness<typename GridType::LeafGridView,double> localStiffness(K, A);
- Dune::array<Configuration,2> localReferenceConfiguration;
- Dune::array<Configuration,2> localSolution;
+ Dune::array<RigidBodyMotion<3>,2> localReferenceConfiguration;
+ Dune::array<RigidBodyMotion<3>,2> localSolution;
ElementLeafIterator it = grid_->template leafbegin<0>();
ElementLeafIterator endIt = grid_->template leafend<0>();
@@ -458,7 +458,7 @@ computeEnergy(const std::vector<Configuration>& sol) const
template <class GridType>
void RodAssembler<GridType>::
-getStrain(const std::vector<Configuration>& sol,
+getStrain(const std::vector<RigidBodyMotion<3> >& sol,
Dune::BlockVector<Dune::FieldVector<double, blocksize> >& strain) const
{
using namespace Dune;
@@ -493,7 +493,7 @@ getStrain(const std::vector<Configuration>& sol,
= Dune::LagrangeShapeFunctions<double, double, gridDim>::general(it->type(), elementOrder);
int numOfBaseFct = baseSet.size();
- array<Configuration,2> localSolution;
+ array<RigidBodyMotion<3>,2> localSolution;
for (int i=0; i<numOfBaseFct; i++)
localSolution[i] = sol[indexSet.subIndex(*it,i,gridDim)];
@@ -530,7 +530,7 @@ getStrain(const std::vector<Configuration>& sol,
template <class GridType>
void RodAssembler<GridType>::
-getStress(const std::vector<Configuration>& sol,
+getStress(const std::vector<RigidBodyMotion<3> >& sol,
Dune::BlockVector<Dune::FieldVector<double, blocksize> >& stress) const
{
// Get the strain
@@ -552,7 +552,7 @@ getStress(const std::vector<Configuration>& sol,
template <class GridType>
Dune::FieldVector<double,3> RodAssembler<GridType>::
getResultantForce(const BoundaryPatch<GridType>& boundary,
- const std::vector<Configuration>& sol,
+ const std::vector<RigidBodyMotion<3> >& sol,
Dune::FieldVector<double,3>& canonicalTorque) const
{
using namespace Dune;
@@ -598,9 +598,9 @@ getResultantForce(const BoundaryPatch<GridType>& boundary,
double pos = nIt->intersectionSelfLocal().corner(0);
- Dune::array<Configuration,2> localSolution = {sol[indexSet.template subIndex<1>(*eIt,0)],
+ Dune::array<RigidBodyMotion<3>,2> localSolution = {sol[indexSet.template subIndex<1>(*eIt,0)],
sol[indexSet.template subIndex<1>(*eIt,1)]};
- Dune::array<Configuration,2> localRefConf = {referenceConfiguration_[indexSet.template subIndex<1>(*eIt,0)],
+ Dune::array<RigidBodyMotion<3>,2> localRefConf = {referenceConfiguration_[indexSet.template subIndex<1>(*eIt,0)],
referenceConfiguration_[indexSet.template subIndex<1>(*eIt,1)]};
FieldVector<double, blocksize> strain = localStiffness.getStrain(localSolution, *eIt, pos);
diff --git a/src/rodassembler.hh b/src/rodassembler.hh
index 06a68c99..a466fc18 100644
--- a/src/rodassembler.hh
+++ b/src/rodassembler.hh
@@ -8,7 +8,7 @@
#include <dune/disc/operators/localstiffness.hh>
#include <dune/ag-common/boundarypatch.hh>
-#include "configuration.hh"
+#include "rigidbodymotion.hh"
/** \brief The FEM operator for an extensible, shearable rod
@@ -41,10 +41,10 @@
Dune::array<double,3> A_;
/** \brief The stress-free configuration */
- std::vector<Configuration> referenceConfiguration_;
+ std::vector<RigidBodyMotion<3> > referenceConfiguration_;
/** \todo Only for the fd approximations */
- static void infinitesimalVariation(Configuration& c, double eps, int i)
+ static void infinitesimalVariation(RigidBodyMotion<3>& c, double eps, int i)
{
if (i<3)
c.r[i] += eps;
@@ -118,33 +118,33 @@
/** \brief Assemble the tangent stiffness matrix
*/
- void assembleMatrix(const std::vector<Configuration>& sol,
+ void assembleMatrix(const std::vector<RigidBodyMotion<3> >& sol,
Dune::BCRSMatrix<MatrixBlock>& matrix) const;
/** \brief Assemble the tangent stiffness matrix using a finite difference approximation
*/
- void assembleMatrixFD(const std::vector<Configuration>& sol,
+ void assembleMatrixFD(const std::vector<RigidBodyMotion<3> >& sol,
Dune::BCRSMatrix<MatrixBlock>& matrix) const;
- void assembleGradient(const std::vector<Configuration>& sol,
+ void assembleGradient(const std::vector<RigidBodyMotion<3> >& sol,
Dune::BlockVector<Dune::FieldVector<double, blocksize> >& grad) const;
/** \brief Compute the energy of a deformation state */
- double computeEnergy(const std::vector<Configuration>& sol) const;
+ double computeEnergy(const std::vector<RigidBodyMotion<3> >& sol) const;
void getNeighborsPerVertex(Dune::MatrixIndexSet& nb) const;
- void getStrain(const std::vector<Configuration>& sol,
+ void getStrain(const std::vector<RigidBodyMotion<3> >& sol,
Dune::BlockVector<Dune::FieldVector<double, blocksize> >& strain) const;
- void getStress(const std::vector<Configuration>& sol,
+ void getStress(const std::vector<RigidBodyMotion<3> >& sol,
Dune::BlockVector<Dune::FieldVector<double, blocksize> >& stress) const;
/** \brief Return resultant force across boundary in canonical coordinates
\note Linear run-time in the size of the grid */
Dune::FieldVector<double,3> getResultantForce(const BoundaryPatch<GridType>& boundary,
- const std::vector<Configuration>& sol,
+ const std::vector<RigidBodyMotion<3> >& sol,
Dune::FieldVector<double,3>& canonicalTorque) const;
protected:
diff --git a/src/roddifference.hh b/src/roddifference.hh
index 5cd16ebd..0bb03b61 100644
--- a/src/roddifference.hh
+++ b/src/roddifference.hh
@@ -1,8 +1,8 @@
#ifndef ROD_DIFFERENCE_HH
#define ROD_DIFFERENCE_HH
-Dune::BlockVector<Dune::FieldVector<double,6> > computeRodDifference(const std::vector<Configuration>& a,
- const std::vector<Configuration>& b)
+Dune::BlockVector<Dune::FieldVector<double,6> > computeRodDifference(const std::vector<RigidBodyMotion<3> >& a,
+ const std::vector<RigidBodyMotion<3> >& b)
{
if (a.size() != b.size())
DUNE_THROW(Dune::Exception, "a and b have to have the same length!");
diff --git a/src/rodlocalstiffness.hh b/src/rodlocalstiffness.hh
index 9bf885ca..d70df8cc 100644
--- a/src/rodlocalstiffness.hh
+++ b/src/rodlocalstiffness.hh
@@ -8,7 +8,7 @@
#include <dune/disc/operators/localstiffness.hh>
#include <dune/ag-common/boundarypatch.hh>
-#include "configuration.hh"
+#include "rigidbodymotion.hh"
template<class GridView, class RT>
class RodLocalStiffness
@@ -94,8 +94,8 @@ public:
RT energy (const Entity& e,
- const Dune::array<Configuration,2>& localSolution,
- const Dune::array<Configuration,2>& localReferenceConfiguration,
+ const Dune::array<RigidBodyMotion<3>,2>& localSolution,
+ const Dune::array<RigidBodyMotion<3>,2>& localReferenceConfiguration,
int k=1);
static void interpolationDerivative(const Rotation<3,RT>& q0, const Rotation<3,RT>& q1, double s,
@@ -104,14 +104,14 @@ public:
static void interpolationVelocityDerivative(const Rotation<3,RT>& q0, const Rotation<3,RT>& q1, double s,
double intervalLength, Dune::array<Quaternion<double>,6>& grad);
- Dune::FieldVector<double, 6> getStrain(const Dune::array<Configuration,2>& localSolution,
+ Dune::FieldVector<double, 6> getStrain(const Dune::array<RigidBodyMotion<3>,2>& localSolution,
const Entity& element,
const Dune::FieldVector<double,1>& pos) const;
/** \brief Assemble the element gradient of the energy functional */
void assembleGradient(const Entity& element,
- const Dune::array<Configuration,2>& solution,
- const Dune::array<Configuration,2>& referenceConfiguration,
+ const Dune::array<RigidBodyMotion<3>,2>& solution,
+ const Dune::array<RigidBodyMotion<3>,2>& referenceConfiguration,
Dune::array<Dune::FieldVector<double,6>, 2>& gradient) const;
template <class T>
@@ -131,8 +131,8 @@ public:
template <class GridType, class RT>
RT RodLocalStiffness<GridType, RT>::
energy(const Entity& element,
- const Dune::array<Configuration,2>& localSolution,
- const Dune::array<Configuration,2>& localReferenceConfiguration,
+ const Dune::array<RigidBodyMotion<3>,2>& localSolution,
+ const Dune::array<RigidBodyMotion<3>,2>& localReferenceConfiguration,
int k)
{
RT energy = 0;
@@ -404,7 +404,7 @@ interpolationVelocityDerivative(const Rotation<3,RT>& q0, const Rotation<3,RT>&
template <class GridType, class RT>
Dune::FieldVector<double, 6> RodLocalStiffness<GridType, RT>::
-getStrain(const Dune::array<Configuration,2>& localSolution,
+getStrain(const Dune::array<RigidBodyMotion<3>,2>& localSolution,
const Entity& element,
const Dune::FieldVector<double,1>& pos) const
{
@@ -480,8 +480,8 @@ getStrain(const Dune::array<Configuration,2>& localSolution,
template <class GridType, class RT>
void RodLocalStiffness<GridType, RT>::
assembleGradient(const Entity& element,
- const Dune::array<Configuration,2>& solution,
- const Dune::array<Configuration,2>& referenceConfiguration,
+ const Dune::array<RigidBodyMotion<3>,2>& solution,
+ const Dune::array<RigidBodyMotion<3>,2>& referenceConfiguration,
Dune::array<Dune::FieldVector<double,6>, 2>& gradient) const
{
using namespace Dune;
diff --git a/src/rodsolver.cc b/src/rodsolver.cc
index 48eaea69..cd940206 100644
--- a/src/rodsolver.cc
+++ b/src/rodsolver.cc
@@ -15,7 +15,7 @@
#include <dune-solvers/norms/energynorm.hh>
#include <dune-solvers/norms/h1seminorm.hh>
-#include "configuration.hh"
+#include "rigidbodymotion.hh"
#include "quaternion.hh"
#include "maxnormtrustregion.hh"
diff --git a/src/rodsolver.hh b/src/rodsolver.hh
index 6af9804b..2fe4c45c 100644
--- a/src/rodsolver.hh
+++ b/src/rodsolver.hh
@@ -14,11 +14,11 @@
#include "rodassembler.hh"
-#include "configuration.hh"
+#include "rigidbodymotion.hh"
/** \brief Riemannian trust-region solver for 3d Cosserat rod problems */
template <class GridType>
-class RodSolver : public IterativeSolver<std::vector<Configuration>, Dune::BitSetVector<6> >
+class RodSolver : public IterativeSolver<std::vector<RigidBodyMotion<3> >, Dune::BitSetVector<6> >
{
const static int blocksize = 6;
@@ -28,12 +28,12 @@ class RodSolver : public IterativeSolver<std::vector<Configuration>, Dune::BitSe
// Some types that I need
typedef Dune::BCRSMatrix<Dune::FieldMatrix<field_type, blocksize, blocksize> > MatrixType;
typedef Dune::BlockVector<Dune::FieldVector<field_type, blocksize> > CorrectionType;
- typedef std::vector<Configuration> SolutionType;
+ typedef std::vector<RigidBodyMotion<3> > SolutionType;
public:
RodSolver()
- : IterativeSolver<std::vector<Configuration>, Dune::BitSetVector<6> >(0,100,NumProc::FULL),
+ : IterativeSolver<std::vector<RigidBodyMotion<3> >, Dune::BitSetVector<6> >(0,100,NumProc::FULL),
hessianMatrix_(NULL), h1SemiNorm_(NULL)
{}
diff --git a/src/rodwriter.hh b/src/rodwriter.hh
index 33772e83..97b49e8d 100644
--- a/src/rodwriter.hh
+++ b/src/rodwriter.hh
@@ -5,7 +5,7 @@
#include <dune/common/exceptions.hh>
-#include "configuration.hh"
+#include "rigidbodymotion.hh"
/** \brief Write a planar rod
*/
@@ -89,7 +89,7 @@ void writeRod(const Dune::BlockVector<Dune::FieldVector<double,3> >& rod,
/** \brief Write a spatial rod
*/
-void writeRod(const std::vector<Configuration>& rod,
+void writeRod(const std::vector<RigidBodyMotion<3> >& rod,
const std::string& filename)
{
int nPoints = rod.size();
diff --git a/test/fdcheck.hh b/test/fdcheck.hh
index c6ecb58a..f9b3f81d 100644
--- a/test/fdcheck.hh
+++ b/test/fdcheck.hh
@@ -1,9 +1,11 @@
#ifndef ASSEMBLER_FINITE_DIFFERENCE_CHECK
#define ASSEMBLER_FINITE_DIFFERENCE_CHECK
+#include "src/rigidbodymotion.hh"
+
#define ABORT_ON_ERROR
-void infinitesimalVariation(Configuration& c, double eps, int i)
+void infinitesimalVariation(RigidBodyMotion<3>& c, double eps, int i)
{
if (i<3)
c.r[i] += eps;
@@ -14,7 +16,7 @@ void infinitesimalVariation(Configuration& c, double eps, int i)
}
template <class GridType>
-void strainFD(const std::vector<Configuration>& x,
+void strainFD(const std::vector<RigidBodyMotion<3> >& x,
double pos,
Dune::array<Dune::FieldMatrix<double,2,6>, 6>& fdStrainDerivatives,
const RodAssembler<GridType>& assembler)
@@ -27,8 +29,8 @@ void strainFD(const std::vector<Configuration>& x,
// ///////////////////////////////////////////////////////////
// Compute gradient by finite-difference approximation
// ///////////////////////////////////////////////////////////
- std::vector<Configuration> forwardSolution = x;
- std::vector<Configuration> backwardSolution = x;
+ std::vector<RigidBodyMotion<3> > forwardSolution = x;
+ std::vector<RigidBodyMotion<3> > backwardSolution = x;
for (size_t i=0; i<x.size(); i++) {
@@ -59,7 +61,7 @@ void strainFD(const std::vector<Configuration>& x,
template <class GridType>
-void strain2ndOrderFD(const std::vector<Configuration>& x,
+void strain2ndOrderFD(const std::vector<RigidBodyMotion<3> >& x,
double pos,
Dune::array<Dune::Matrix<Dune::FieldMatrix<double,6,6> >, 3>& translationDer,
Dune::array<Dune::Matrix<Dune::FieldMatrix<double,3,3> >, 3>& rotationDer,
@@ -83,13 +85,13 @@ void strain2ndOrderFD(const std::vector<Configuration>& x,
// ///////////////////////////////////////////////////////////
// Compute gradient by finite-difference approximation
// ///////////////////////////////////////////////////////////
- std::vector<Configuration> forwardSolution = x;
- std::vector<Configuration> backwardSolution = x;
+ std::vector<RigidBodyMotion<3> > forwardSolution = x;
+ std::vector<RigidBodyMotion<3> > backwardSolution = x;
- std::vector<Configuration> forwardForwardSolution = x;
- std::vector<Configuration> forwardBackwardSolution = x;
- std::vector<Configuration> backwardForwardSolution = x;
- std::vector<Configuration> backwardBackwardSolution = x;
+ std::vector<RigidBodyMotion<3> > forwardForwardSolution = x;
+ std::vector<RigidBodyMotion<3> > forwardBackwardSolution = x;
+ std::vector<RigidBodyMotion<3> > backwardForwardSolution = x;
+ std::vector<RigidBodyMotion<3> > backwardBackwardSolution = x;
for (int i=0; i<2; i++) {
@@ -168,7 +170,7 @@ void strain2ndOrderFD(const std::vector<Configuration>& x,
template <class GridType>
-void strain2ndOrderFD2(const std::vector<Configuration>& x,
+void strain2ndOrderFD2(const std::vector<RigidBodyMotion<3> >& x,
double pos,
Dune::FieldVector<double,1> shapeGrad[2],
Dune::FieldVector<double,1> shapeFunction[2],
@@ -192,8 +194,8 @@ void strain2ndOrderFD2(const std::vector<Configuration>& x,
// ///////////////////////////////////////////////////////////
// Compute gradient by finite-difference approximation
// ///////////////////////////////////////////////////////////
- std::vector<Configuration> forwardSolution = x;
- std::vector<Configuration> backwardSolution = x;
+ std::vector<RigidBodyMotion<3> > forwardSolution = x;
+ std::vector<RigidBodyMotion<3> > backwardSolution = x;
for (int k=0; k<2; k++) {
@@ -301,7 +303,7 @@ void expHessianFD()
template <class GridType>
-void gradientFDCheck(const std::vector<Configuration>& x,
+void gradientFDCheck(const std::vector<RigidBodyMotion<3> >& x,
const Dune::BlockVector<Dune::FieldVector<double,6> >& gradient,
const RodAssembler<GridType>& assembler)
{
@@ -315,8 +317,8 @@ void gradientFDCheck(const std::vector<Configuration>& x,
// Compute gradient by finite-difference approximation
// ///////////////////////////////////////////////////////////
- std::vector<Configuration> forwardSolution = x;
- std::vector<Configuration> backwardSolution = x;
+ std::vector<RigidBodyMotion<3> > forwardSolution = x;
+ std::vector<RigidBodyMotion<3> > backwardSolution = x;
for (size_t i=0; i<x.size(); i++) {
@@ -359,7 +361,7 @@ void gradientFDCheck(const std::vector<Configuration>& x,
template <class GridType>
-void hessianFDCheck(const std::vector<Configuration>& x,
+void hessianFDCheck(const std::vector<RigidBodyMotion<3> >& x,
const Dune::BCRSMatrix<Dune::FieldMatrix<double,6,6> >& hessian,
const RodAssembler<GridType>& assembler)
{
@@ -373,13 +375,13 @@ void hessianFDCheck(const std::vector<Configuration>& x,
// ///////////////////////////////////////////////////////////
// Compute gradient by finite-difference approximation
// ///////////////////////////////////////////////////////////
- std::vector<Configuration> forwardSolution = x;
- std::vector<Configuration> backwardSolution = x;
+ std::vector<RigidBodyMotion<3> > forwardSolution = x;
+ std::vector<RigidBodyMotion<3> > backwardSolution = x;
- std::vector<Configuration> forwardForwardSolution = x;
- std::vector<Configuration> forwardBackwardSolution = x;
- std::vector<Configuration> backwardForwardSolution = x;
- std::vector<Configuration> backwardBackwardSolution = x;
+ std::vector<RigidBodyMotion<3> > forwardForwardSolution = x;
+ std::vector<RigidBodyMotion<3> > forwardBackwardSolution = x;
+ std::vector<RigidBodyMotion<3> > backwardForwardSolution = x;
+ std::vector<RigidBodyMotion<3> > backwardBackwardSolution = x;
// ///////////////////////////////////////////////////////////////
--
GitLab