Commit 52d5d039 authored by Praetorius, Simon's avatar Praetorius, Simon
Browse files

Merge branch 'feature/dofvector_global_evaluation' into 'develop'

Feature/dofvector global evaluation

See merge request spraetor/dune-amdis!48
parents 4fa922eb f9bee36d
...@@ -12,7 +12,7 @@ ...@@ -12,7 +12,7 @@
#include <amdis/Initfile.hpp> #include <amdis/Initfile.hpp>
#include <amdis/common/Size.hpp> #include <amdis/common/Size.hpp>
#include <amdis/common/ValueCategory.hpp> #include <amdis/common/ValueCategory.hpp>
#include <amdis/gridfunctions/DOFVectorView.hpp> #include <amdis/gridfunctions/DiscreteFunction.hpp>
#include <amdis/io/FileWriterInterface.hpp> #include <amdis/io/FileWriterInterface.hpp>
#include <amdis/utility/Filesystem.hpp> #include <amdis/utility/Filesystem.hpp>
...@@ -43,14 +43,17 @@ namespace AMDiS ...@@ -43,14 +43,17 @@ namespace AMDiS
constexpr std::size_t VTKFieldSize = Size<Range>; constexpr std::size_t VTKFieldSize = Size<Range>;
template <class GlobalBasis, class RangeType, class TreePath> template <class GB, class VT, class TP>
class FileWriter class FileWriter
: public FileWriterInterface : public FileWriterInterface
{ {
private: // typedefs and static constants using GlobalBasis = GB;
using ValueType = VT;
using TreePath = TP;
private:
using GridView = typename GlobalBasis::GridView; using GridView = typename GlobalBasis::GridView;
using Vector = DOFVectorConstView<GlobalBasis,RangeType,TreePath>; using Range = typename DiscreteFunction<GB,VT,TP>::Range;
using Range = typename Vector::Range;
/// Dimension of the mesh /// Dimension of the mesh
static constexpr int dim = GridView::dimension; static constexpr int dim = GridView::dimension;
...@@ -60,33 +63,32 @@ namespace AMDiS ...@@ -60,33 +63,32 @@ namespace AMDiS
public: public:
/// Constructor. /// Constructor.
FileWriter(std::string const& baseName, FileWriter(std::string const& name, DiscreteFunction<GB,VT,TP> const& discreteFct)
Vector const& dofvector) : FileWriterInterface(name)
: FileWriterInterface(baseName) , discreteFct_(discreteFct)
, dofvector_(dofvector)
, animation_(false) , animation_(false)
{ {
Parameters::get(baseName + "->ParaView animation", animation_); Parameters::get(name + "->ParaView animation", animation_);
int m = Parameters::get<int>(baseName + "->ParaView mode").value_or(0); int m = Parameters::get<int>(name + "->ParaView mode").value_or(0);
mode_ = (m == 0 ? Dune::VTK::ascii : Dune::VTK::appendedraw); mode_ = (m == 0 ? Dune::VTK::ascii : Dune::VTK::appendedraw);
init(baseName, ValueCategory_t<Range>{}); init(name, ValueCategory_t<Range>{});
} }
template <class ValueCat> template <class ValueCat>
void init(std::string const& baseName, ValueCat) void init(std::string const& baseName, ValueCat)
{ {
int subSampling = Parameters::get<int>(baseName + "->subsampling").value_or(0); auto subSampling = Parameters::get<int>(baseName + "->subsampling");
if (subSampling > 0) if (subSampling)
vtkWriter_ = std::make_shared<Dune::SubsamplingVTKWriter<GridView>>(gridView(), subSampling); vtkWriter_ = std::make_shared<Dune::SubsamplingVTKWriter<GridView>>(gridView(), subSampling.value());
else else
vtkWriter_ = std::make_shared<Dune::VTKWriter<GridView>>(gridView()); vtkWriter_ = std::make_shared<Dune::VTKWriter<GridView>>(gridView());
if (animation_) if (animation_)
vtkSeqWriter_ = std::make_shared<Dune::VTKSequenceWriter<GridView>>(vtkWriter_, filename_, dir_, ""); vtkSeqWriter_ = std::make_shared<Dune::VTKSequenceWriter<GridView>>(vtkWriter_, filename_, dir_, "");
vtkWriter_->addVertexData(dofvector_, Dune::VTK::FieldInfo(name_, VTKFieldType<Range>, VTKFieldSize<Range>)); vtkWriter_->addVertexData(discreteFct_, Dune::VTK::FieldInfo(name_, VTKFieldType<Range>, VTKFieldSize<Range>));
} }
void init(std::string const&, tag::unknown) {} void init(std::string const&, tag::unknown) {}
...@@ -105,11 +107,11 @@ namespace AMDiS ...@@ -105,11 +107,11 @@ namespace AMDiS
protected: protected:
GridView const& gridView() const GridView const& gridView() const
{ {
return dofvector_.basis().gridView(); return discreteFct_.basis().gridView();
} }
private: private:
Vector dofvector_; DiscreteFunction<GB,VT,TP> discreteFct_;
std::shared_ptr<Dune::VTKWriter<GridView>> vtkWriter_; std::shared_ptr<Dune::VTKWriter<GridView>> vtkWriter_;
std::shared_ptr<Dune::VTKSequenceWriter<GridView>> vtkSeqWriter_; std::shared_ptr<Dune::VTKSequenceWriter<GridView>> vtkSeqWriter_;
...@@ -122,12 +124,12 @@ namespace AMDiS ...@@ -122,12 +124,12 @@ namespace AMDiS
}; };
template <class GlobalBasis, class Range, class TreePath> template <class GlobalBasis, class ValueType, class TreePath>
std::shared_ptr<FileWriter<GlobalBasis,Range,TreePath>> std::shared_ptr<FileWriter<GlobalBasis,ValueType,TreePath>>
makeFileWriterPtr(std::string baseName, makeFileWriterPtr(std::string const& name,
DOFVectorConstView<GlobalBasis,Range,TreePath> const& dofvector) DiscreteFunction<GlobalBasis,ValueType,TreePath> const& discreteFct)
{ {
return std::make_shared<FileWriter<GlobalBasis,Range,TreePath>>(baseName, dofvector); return std::make_shared<FileWriter<GlobalBasis,ValueType,TreePath>>(name, discreteFct);
} }
} // end namespace AMDiS } // end namespace AMDiS
...@@ -32,6 +32,7 @@ ...@@ -32,6 +32,7 @@
#include <amdis/common/Utility.hpp> #include <amdis/common/Utility.hpp>
#include <amdis/GridFunctions.hpp> #include <amdis/GridFunctions.hpp>
#include <amdis/gridfunctions/DiscreteFunction.hpp>
#include <amdis/gridfunctions/DOFVectorView.hpp> #include <amdis/gridfunctions/DOFVectorView.hpp>
#include <amdis/io/FileWriterInterface.hpp> #include <amdis/io/FileWriterInterface.hpp>
...@@ -198,7 +199,7 @@ namespace AMDiS ...@@ -198,7 +199,7 @@ namespace AMDiS
auto getSolution(TreePath const& path = {}) const auto getSolution(TreePath const& path = {}) const
{ {
auto&& tp = makeTreePath(path); auto&& tp = makeTreePath(path);
return makeDOFVectorView(*solution_, tp); return makeDiscreteFunction(*solution_, tp);
} }
......
...@@ -5,8 +5,9 @@ install(FILES ...@@ -5,8 +5,9 @@ install(FILES
ConstantGridFunction.hpp ConstantGridFunction.hpp
CoordsGridFunction.hpp CoordsGridFunction.hpp
DerivativeGridFunction.hpp DerivativeGridFunction.hpp
DiscreteFunction.hpp
DiscreteFunction.inc.hpp
DOFVectorView.hpp DOFVectorView.hpp
DOFVectorView.inc.hpp
FunctorGridFunction.hpp FunctorGridFunction.hpp
GridFunctionConcepts.hpp GridFunctionConcepts.hpp
Integrate.hpp Integrate.hpp
......
#pragma once #pragma once
#include <vector>
#include <dune/common/std/optional.hh>
#include <dune/functions/common/defaultderivativetraits.hh>
#include <dune/functions/common/treedata.hh>
#include <dune/functions/functionspacebases/defaultnodetorangemap.hh>
#include <dune/functions/functionspacebases/flatvectorview.hh>
#include <dune/functions/gridfunctions/gridviewentityset.hh>
#include <dune/typetree/childextraction.hh>
#include <amdis/GridFunctions.hpp> #include <amdis/GridFunctions.hpp>
#include <amdis/utility/FiniteElementType.hpp> #include <amdis/gridfunctions/DiscreteFunction.hpp>
namespace AMDiS namespace AMDiS
{ {
/** /// A mutable view on the subspace of a DOFVector, \relates DiscreteFunction
* \addtogroup GridFunctions template <class GB, class VT, class TP>
* @{ class DOFVectorView
**/ : public DiscreteFunction<GB, VT, TP>
template <class GlobalBasisType, class RangeType, class TreePathType>
class DOFVectorConstView
{ {
public: using Self = DOFVectorView;
using GlobalBasis = GlobalBasisType; using Super = DiscreteFunction<GB, VT, TP>;
using TreePath = TreePathType;
using Tree = typename GlobalBasis::LocalView::Tree;
using SubTree = typename Dune::TypeTree::ChildForTreePath<Tree, TreePath>;
using NodeToRangeEntry = Dune::Functions::DefaultNodeToRangeMap<SubTree>;
using GridView = typename GlobalBasis::GridView;
using EntitySet = Dune::Functions::GridViewEntitySet<GridView, 0>;
using Domain = typename EntitySet::GlobalCoordinate;
using Range = RangeType_t<SubTree>;
static_assert(std::is_arithmetic<RangeType>::value, "");
// Don't know how to determine Range with non-trivial RangeType
using RawSignature = typename Dune::Functions::SignatureTraits<Range(Domain)>::RawSignature; using GlobalBasis = GB;
using DerivativeTraits = Dune::Functions::DefaultDerivativeTraits<RawSignature>; using TreePath = TP;
using DerivativeRange = typename DerivativeTraits::Range;
using LocalDomain = typename EntitySet::LocalCoordinate;
using Element = typename EntitySet::Element;
using Geometry = typename Element::Geometry;
enum { hasDerivative = false };
public: // a local view on the gradients
/// A LocalFunction representing the derivative of the DOFVector
class GradientLocalFunction
{
public: public:
using Domain = LocalDomain; /// Constructor forwards to the treePath constructor, with empty TreePath
using Range = DerivativeRange; DOFVectorView(DOFVector<GB,VT>& dofVector)
: DOFVectorView{dofVector, Dune::TypeTree::hybridTreePath()}
enum { hasDerivative = false }; {}
private:
using LocalView = typename GlobalBasis::LocalView;
template <class LeafNode>
using LocalBasisJacobian = typename LeafNode::FiniteElement::Traits::LocalBasisType::Traits::JacobianType;
template <class Node>
using NodeData = typename std::vector<LocalBasisJacobian<Node>>;
using ReferenceGradientContainer = Dune::Functions::TreeData<SubTree, NodeData, true>;
public:
GradientLocalFunction(DOFVectorConstView const& globalFunction)
: globalFunction_(&globalFunction)
, localView_(globalFunction_->basis().localView())
, subTree_(&Dune::TypeTree::child(localView_.tree(), globalFunction_->treePath()))
{
referenceGradientContainer_.init(*subTree_);
}
void bind(Element const& element)
{
localView_.bind(element);
geometry_.emplace(element.geometry());
bound_ = true;
}
void unbind()
{
localView_.unbind();
geometry_.reset();
bound_ = false;
}
/// Evaluate Gradient at bound element in local coordinates
Range operator()(Domain const& x) const;
friend int order(GradientLocalFunction const& self)
{
assert( self.bound_ );
return std::max(0, polynomialDegree(*self.subTree_)-1);
}
/// Return the bound element
Element const& localContext() const
{
assert( bound_ );
return localView_.element();
}
private:
DOFVectorConstView const* globalFunction_;
LocalView localView_;
SubTree const* subTree_;
mutable ReferenceGradientContainer referenceGradientContainer_;
Dune::Std::optional<Geometry> geometry_;
bool bound_ = false;
};
public: // a local view on the values
/// A LocalFunction, i.e., an element local view on the DOFVector
class LocalFunction
{
public:
using Domain = typename DOFVectorConstView::LocalDomain;
using Range = typename DOFVectorConstView::Range;
enum { hasDerivative = true };
private:
using LocalView = typename GlobalBasis::LocalView;
template <class LeafNode>
using LocalBasisRange = RangeType_t<LeafNode>;
// = typename LeafNode::FiniteElement::Traits::LocalBasisType::Traits::RangeType;
template <class Node>
using NodeData = typename std::vector<LocalBasisRange<Node>>;
using ShapeFunctionValueContainer = Dune::Functions::TreeData<SubTree, NodeData, true>;
public:
LocalFunction(DOFVectorConstView const& globalFunction)
: globalFunction_(&globalFunction)
, localView_(globalFunction_->basis().localView())
, subTree_(&Dune::TypeTree::child(localView_.tree(), globalFunction_->treePath()))
{
shapeFunctionValueContainer_.init(*subTree_);
}
void bind(Element const& element)
{
localView_.bind(element);
bound_ = true;
}
void unbind()
{
localView_.unbind();
bound_ = false;
}
/// Evaluate LocalFunction at bound element in local coordinates
Range operator()(Domain const& x) const;
/// \brief Create a LocalFunction representing the gradient. \relates GradientLocalFunction
friend GradientLocalFunction derivative(LocalFunction const& localFunction)
{
static_assert(isValidRange<DerivativeTraits>(),"Derivative of DOFVector not defined.");
return GradientLocalFunction{*localFunction.globalFunction_};
}
friend int order(LocalFunction const& self)
{
assert( self.bound_ );
return polynomialDegree(*self.subTree_);
}
/// Return the bound element
Element const& localContext() const
{
assert( bound_ );
return localView_.element();
}
private:
DOFVectorConstView const* globalFunction_;
LocalView localView_;
SubTree const* subTree_;
mutable ShapeFunctionValueContainer shapeFunctionValueContainer_;
bool bound_ = false;
};
public: /// Constructor. Stores a pointer to the mutable `dofvector`.
/// Constructor. Stores a pointer to the dofVector and a copy of the treePath. DOFVectorView(DOFVector<GB,VT>& dofVector, TP const& treePath)
DOFVectorConstView(DOFVector<GlobalBasis,RangeType> const& dofVector, TreePath const& treePath) : Super(dofVector, treePath)
: dofVector_(&dofVector) , mutableDofVector_(&dofVector)
, treePath_(treePath)
, entitySet_(dofVector.basis().gridView())
, nodeToRangeEntry_(Dune::Functions::makeDefaultNodeToRangeMap(dofVector.basis(), treePath))
{} {}
/// Evaluate the view on this DOFVector in global coordinates public:
Range operator()(Domain const& x) const /// \brief Interpolation of GridFunction to DOFVector, assuming that there is no
/// reference to this DOFVector in the expression.
/**
* **Example:**
* ```
* auto v = makeDOFVectorView(prob.getSolutionVector(),0);
* v.interpolate([](auto const& x) { return x[0]; });
* ```
**/
template <class Expr>
void interpolate_noalias(Expr&& expr)
{ {
error_exit("Not implemented."); auto const& basis = this->basis();
return Range(0); auto const& treePath = this->treePath();
}
/// \brief Create a local function for this view on the DOFVector. \relates LocalFunction auto&& gridFct = makeGridFunction(std::forward<Expr>(expr), basis.gridView());
friend LocalFunction localFunction(DOFVectorConstView const& self)
{
return LocalFunction{self};
}
EntitySet const& entitySet() const Dune::Functions::interpolate(basis, treePath, coefficients(),
{ std::forward<decltype(gridFct)>(gridFct));
return entitySet_;
} }
public: /// \brief Interpolation of GridFunction to DOFVector
/// Return global basis /**
GlobalBasis const& basis() const * **Example:**
* ```
* auto v = makeDOFVectorView(prob.getSolutionVector(),0);
* v.interpolate(v + [](auto const& x) { return x[0]; });
* ```
* Allows to have a reference to the DOFVector in the expression, e.g. as
* \ref DiscreteFunction or \ref gradientAtQP() of a DiscreteFunction.
**/
template <class Expr>
void interpolate(Expr&& expr)
{ {
return dofVector_->basis(); // create temporary copy of data
} DOFVector<GB,VT> tmp(coefficients());
Self tmpView{tmp, this->treePath()};
tmpView.interpolate_noalias(std::forward<Expr>(expr));
/// Return treePath associated with this view // move data from temporary vector into stored DOFVector
TreePath const& treePath() const coefficients().vector() = std::move(tmp.vector());
{
return treePath_;
} }
/// Return const coefficient vector /// \brief Interpolation of GridFunction to DOFVector, alias to \ref interpolate()
DOFVector<GlobalBasis,RangeType> const& coefficients() const template <class Expr>
DOFVectorView& operator<<(Expr&& expr)
{ {
return *dofVector_; interpolate(expr);
return *this;
} }
protected: /// \brief interpolate `(*this) + expr` to DOFVector
DOFVector<GlobalBasis,RangeType> const* dofVector_;
TreePath const treePath_;
EntitySet entitySet_;
NodeToRangeEntry nodeToRangeEntry_;
};
// A mutable version of DOFVectorView
template <class GlobalBasisType, class RangeType, class TreePathType>
class DOFVectorMutableView
: public DOFVectorConstView<GlobalBasisType, RangeType, TreePathType>
{
using Super = DOFVectorConstView<GlobalBasisType, RangeType, TreePathType>;
using GlobalBasis = GlobalBasisType;
using TreePath = TreePathType;
public:
/// Constructor. Stores a pointer to the mutable `dofvector`.
DOFVectorMutableView(DOFVector<GlobalBasis,RangeType>& dofVector, TreePath const& treePath)
: Super(dofVector, treePath)
, mutableDofVector_(&dofVector)
{}
public:
/// Interpolation of GridFunction to DOFVector
template <class Expr> template <class Expr>
DOFVectorMutableView& interpolate(Expr&& expr) DOFVectorView& operator+=(Expr&& expr)
{ {
auto const& basis = Super::basis(); interpolate((*this) + expr);
auto const& treePath = Super::treePath();
auto&& gridFct = makeGridFunction(std::forward<Expr>(expr), basis.gridView());
DOFVector<GlobalBasis,RangeType> tmp(*mutableDofVector_);
Dune::Functions::interpolate(basis, treePath, tmp, std::forward<decltype(gridFct)>(gridFct));
// move data from temporary vector into stored DOFVector
mutableDofVector_->vector() = std::move(tmp.vector());
return *this; return *this;
} }
/// \brief interpolate `(*this) - expr` to DOFVector
template <class Expr> template <class Expr>
DOFVectorMutableView& operator<<(Expr&& expr) DOFVectorView& operator-=(Expr&& expr)
{ {
return interpolate(expr); interpolate((*this) - expr);
return *this;
} }
/// Return the mutable DOFVector /// Return the mutable DOFVector
DOFVector<GlobalBasis,RangeType>& coefficients() { return *mutableDofVector_; } DOFVector<GB,VT>& coefficients() { return *mutableDofVector_; }
/// Return the const DOFVector /// Return the const DOFVector
using Super::coefficients; using Super::coefficients;
protected: protected:
DOFVector<GlobalBasis,RangeType>* mutableDofVector_; DOFVector<GB,VT>* mutableDofVector_;
}; };
/** @} **/
#ifndef DOXYGEN
// A Generator for a const \ref DOFVectorView.
template <class GlobalBasis, class RangeType, class TreePath>
auto makeDOFVectorView(DOFVector<GlobalBasis, RangeType> const& dofVector, TreePath const& treePath)
{
return DOFVectorConstView<GlobalBasis, RangeType, TreePath>{dofVector, treePath};
}
// A Generator for a mutable \ref DOFVectorView.
template <class GlobalBasis, class RangeType, class TreePath>
auto makeDOFVectorView(DOFVector<GlobalBasis, RangeType>& dofVector, TreePath const& treePath)
{
return DOFVectorMutableView<GlobalBasis, RangeType, TreePath>{dofVector, treePath};
}
#if DUNE_HAVE_CXX_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
// Deduction guide for DOFVectorView class
template <class GlobalBasis, class ValueType>