Commit 71d6c687 authored by Praetorius, Simon's avatar Praetorius, Simon

rebase to develop

parents d7ccc62f 28be8123
Pipeline #1813 passed with stage
in 24 minutes and 37 seconds
......@@ -28,13 +28,13 @@ PREDEFINED += HAVE_UMFPACK \
# with spaces.
INPUT += @top_srcdir@/src/amdis \
@top_srcdir@/src/amdis/assembler \
@top_srcdir@/src/amdis/common \
@top_srcdir@/src/amdis/gridfunctions \
@top_srcdir@/src/amdis/io \
@top_srcdir@/src/amdis/linearalgebra \
@top_srcdir@/src/amdis/linearalgebra/mtl \
@top_srcdir@/src/amdis/localoperators \
@top_srcdir@/src/amdis/operations \
@top_srcdir@/src/amdis/typetree \
@top_srcdir@/src/amdis/utility \
@top_srcdir@/doc
# see e.g. dune-grid for the examples of mainpage and modules
......
......@@ -52,7 +52,7 @@ int main(int argc, char** argv)
std::vector<double> errH1; errH1.reserve(numLevels);
std::vector<double> widths; widths.reserve(numLevels);
for (int i = 0; i < numLevels; ++i) {
prob.grid().globalRefine(1);
prob.grid()->globalRefine(1);
auto gridView = prob.gridView();
double h = 0;
......@@ -60,8 +60,8 @@ int main(int argc, char** argv)
h = std::max(h, e.geometry().volume());
widths.push_back(h);
prob.globalBasis().update(gridView);
prob.solutionVector().compress();
prob.globalBasis()->update(gridView);
prob.solutionVector()->compress();
prob.assemble(adaptInfo);
prob.solve(adaptInfo);
......
......@@ -6,12 +6,18 @@
namespace AMDiS
{
/**
* \addtogroup Adaption
* @{
**/
typedef enum {
NO_OPERATION = 0,
INTERPOLATE = 1
} DataTransferOperation;
/// \brief Interface for Containers allowing data transfer between grid changes.
template <class Container>
class DataTransferInterface
{
......@@ -27,8 +33,10 @@ namespace AMDiS
};
/// Implementation of \ref DataTransferInterface that does not interpolation, but
/// just resizes the containers to the dimension of the basis
/**
* \brief Implementation of \ref DataTransferInterface that does not interpolate, but
* just resizes the containers to the dimension of the basis
**/
template <class Container>
class NoDataTransfer
: public DataTransferInterface<Container>
......@@ -69,6 +77,8 @@ namespace AMDiS
}
};
/// @}
} // end namespace AMDiS
#include "DataTransfer.inc.hpp"
......@@ -205,6 +205,7 @@ namespace AMDiS
};
#ifndef DOXYGEN
template <class Tag, class PreGridFct, class PQF>
struct PreGridFunctionOperator
{
......@@ -212,6 +213,7 @@ namespace AMDiS
PreGridFct expr;
PQF quadFactory;
};
#endif
/// Store tag and expression into a \ref PreGridFunctionOperator to create a \ref GridFunctionOperator
template <class Tag, class Expr, class... QuadratureArgs>
......
......@@ -7,6 +7,12 @@
namespace AMDiS
{
/**
* \addtogroup Adaption
* @{
**/
/// \brief Interface for transfer between grid changes to be registered in a \ref GridTransferManager
class GridTransferInterface
{
public:
......@@ -17,10 +23,10 @@ namespace AMDiS
virtual bool preAdapt() = 0;
virtual bool adapt() = 0;
virtual void postAdapt() = 0;
};
/// \brief Implementation of \ref GridTransferInterface for concrete Grid type.
template <class Grid>
class GridTransfer
: public GridTransferInterface
......@@ -100,4 +106,6 @@ namespace AMDiS
unsigned long changeIndex_ = 0;
};
/// @}
} // end namespace AMDiS
......@@ -9,6 +9,11 @@
namespace AMDiS
{
/**
* \addtogroup Adaption
* @{
**/
/// Static administration class for automatic handling of DOFVectors during grid adaption
class GridTransferManager
{
......@@ -93,4 +98,6 @@ namespace AMDiS
using GridTransferCache = ConcurrentCache< Key, Data, StaticLockedPolicy, std::map<Key, Data> >;
};
/// @}
} // end namespace AMDiS
......@@ -53,20 +53,12 @@ namespace AMDiS
ProblemType& problemStat() { return *problemStat_; }
ProblemType const& problemStat() const { return *problemStat_; }
/// Returns \ref oldSolution.
SystemVector const& oldSolutionVector() const
/// Returns const-ref of \ref oldSolution.
std::shared_ptr<SystemVector const> oldSolutionVector() const
{
test_exit_dbg(oldSolution_,
test_exit_dbg(bool(oldSolution_),
"OldSolution need to be created. Call initialize with INIT_UH_OLD.");
return *oldSolution_;
}
/// Return a mutable view to a oldSolution component
template <class TreePath = RootTreePath>
auto oldSolution(TreePath path = {})
{
auto&& tp = makeTreePath(path);
return makeDOFVectorView(oldSolutionVector(), tp);
return oldSolution_;
}
/// Return a const view to a oldSolution component
......@@ -74,7 +66,7 @@ namespace AMDiS
auto oldSolution(TreePath path = {}) const
{
auto&& tp = makeTreePath(path);
return makeDOFVectorView(oldSolutionVector(), tp);
return makeDiscreteFunction(*oldSolutionVector(), tp);
}
/// Implementation of \ref ProblemTimeInterface::transferInitialSolution().
......@@ -89,7 +81,7 @@ namespace AMDiS
ProblemType* problemStat_;
/// Solution of the last timestep.
std::unique_ptr<SystemVector> oldSolution_;
std::shared_ptr<SystemVector> oldSolution_;
};
......
......@@ -45,7 +45,7 @@ void ProblemInstat<Traits>::createUhOld()
if (oldSolution_)
warning("oldSolution already created\n");
else // create oldSolution
oldSolution_.reset(new SystemVector(problemStat_->globalBasis()));
oldSolution_.reset(new SystemVector(*problemStat_->globalBasis(), INTERPOLATE));
}
......@@ -53,7 +53,7 @@ template <class Traits>
void ProblemInstat<Traits>::initTimestep(AdaptInfo&)
{
if (oldSolution_)
*oldSolution_ = problemStat_->solutionVector();
*oldSolution_ = *problemStat_->solutionVector();
}
} // end namespace AMDiS
......@@ -282,37 +282,35 @@ namespace AMDiS
/// Return a reference to the grid, \ref grid
Grid& grid() { return *grid_; }
Grid const& grid() const { return *grid_; }
std::shared_ptr<Grid> grid() { return grid_; }
std::shared_ptr<Grid const> grid() const { return grid_; }
/// Return the gridView of the leaf-level
GridView const& gridView() const { return globalBasis_->gridView(); }
GridView gridView() const { return globalBasis_->gridView(); }
/// Return the boundary manager to identify boundary segments
BoundaryManager<Grid>& boundaryManager() { return *boundaryManager_; }
BoundaryManager<Grid> const& boundaryManager() const { return *boundaryManager_; }
auto const& boundaryManagerPtr() { return boundaryManager_; }
std::shared_ptr<BoundaryManager<Grid>> boundaryManager() { return boundaryManager_; }
std::shared_ptr<BoundaryManager<Grid> const> boundaryManager() const { return boundaryManager_; }
/// Return the \ref globalBasis_
GlobalBasis& globalBasis() { return *globalBasis_; }
GlobalBasis const& globalBasis() const { return *globalBasis_; }
std::shared_ptr<GlobalBasis> globalBasis() { return globalBasis_; }
std::shared_ptr<GlobalBasis const> globalBasis() const { return globalBasis_; }
/// Return a reference to the linear solver, \ref linearSolver
LinearSolverType& solver() { return *linearSolver_; }
LinearSolverType const& solver() const { return *linearSolver_; }
std::shared_ptr<LinearSolverType> solver() { return linearSolver_; }
std::shared_ptr<LinearSolverType const> solver() const { return linearSolver_; }
/// Returns a reference to system-matrix, \ref systemMatrix_
SystemMatrix& systemMatrix() { return *systemMatrix_; }
SystemMatrix const& systemMatrix() const { return *systemMatrix_; }
std::shared_ptr<SystemMatrix> systemMatrix() { return systemMatrix_; }
std::shared_ptr<SystemMatrix const> systemMatrix() const { return systemMatrix_; }
/// Returns a reference to the solution vector, \ref solution_
SystemVector& solutionVector() { return *solution_; }
SystemVector const& solutionVector() const { return *solution_; }
std::shared_ptr<SystemVector> solutionVector() { return solution_; }
std::shared_ptr<SystemVector const> solutionVector() const { return solution_; }
/// Return a reference to the rhs system-vector, \ref rhs
SystemVector& rhsVector() { return *rhs_; }
SystemVector const& rhsVector() const { return *rhs_; }
std::shared_ptr<SystemVector> rhsVector() { return rhs_; }
std::shared_ptr<SystemVector const> rhsVector() const { return rhs_; }
/// Return a mutable view to a solution component
......
......@@ -4,6 +4,7 @@
#include <string>
#include <utility>
#include <dune/common/hybridutilities.hh>
#include <dune/common/timer.hh>
#include <dune/typetree/childextraction.hh>
......@@ -12,7 +13,6 @@
#include <amdis/Assembler.hpp>
#include <amdis/GridFunctionOperator.hpp>
#include <amdis/GridTransferManager.hpp>
#include <amdis/common/Loops.hpp>
namespace AMDiS {
......
......@@ -7,7 +7,7 @@
#include <dune/functions/functionspacebases/pqknodalbasis.hh>
#include <dune/grid/yaspgrid.hh>
#include <amdis/common/Mpl.hpp>
#include <amdis/common/Logical.hpp>
namespace AMDiS
{
......
......@@ -4,7 +4,8 @@
#include <type_traits>
#include <utility>
#include <amdis/common/Mpl.hpp>
#include <amdis/common/Index.hpp>
#include <amdis/common/StaticSize.hpp>
#include <amdis/common/TypeTraits.hpp>
namespace AMDiS
......@@ -13,14 +14,15 @@ namespace AMDiS
{
namespace Impl_
{
template <class F, class Tuple, std::size_t... I>
constexpr decltype(auto) apply_impl(F&& f, Tuple&& t, std::index_sequence<I...>)
template <class Functor, class Tuple, std::size_t... I>
constexpr decltype(auto) apply_impl(Functor&& f, Tuple&& t, std::index_sequence<I...>)
{
return f(std::get<I>(FWD(t))...);
using std::get;
return f(get<I>(FWD(t))...);
}
template <class F, std::size_t I0, std::size_t... I>
constexpr decltype(auto) apply_indices_impl(F&& f, index_t<I0>, std::index_sequence<I...>)
template <class Functor, std::size_t I0, std::size_t... I>
constexpr decltype(auto) apply_indices_impl(Functor&& f, index_t<I0>, std::index_sequence<I...>)
{
return f(index_t<I0+I>{}...);
}
......@@ -29,25 +31,25 @@ namespace AMDiS
template <class F, class Tuple>
constexpr decltype(auto) apply(F&& f, Tuple&& t)
{
return Impl_::apply_impl(FWD(f), FWD(t),
std::make_index_sequence<std::tuple_size<std::remove_reference_t<Tuple>>::value>{});
return Impl_::apply_impl(FWD(f), FWD(t),
std::make_index_sequence<Size_v<std::remove_reference_t<Tuple>>>{});
}
template <class F, class... Args>
constexpr decltype(auto) apply_variadic(F&& f, Args&&... args)
template <class Functor, class... Args>
constexpr decltype(auto) apply_variadic(Functor&& f, Args&&... args)
{
return apply(FWD(f), std::forward_as_tuple(args...));
return apply(FWD(f), std::forward_as_tuple(args...));
}
template <class F, std::size_t N>
constexpr decltype(auto) apply_indices(F&& f, index_t<N>)
template <class Functor, std::size_t N>
constexpr decltype(auto) apply_indices(Functor&& f, index_t<N>)
{
return Impl_::apply_indices_impl(FWD(f), index_t<0>{},
std::make_index_sequence<N>{});
}
template <class F, std::size_t I0, std::size_t I1>
constexpr decltype(auto) apply_indices(F&& f, index_t<I0>, index_t<I1>)
template <class Functor, std::size_t I0, std::size_t I1>
constexpr decltype(auto) apply_indices(Functor&& f, index_t<I0>, index_t<I1>)
{
return Impl_::apply_indices_impl(FWD(f), index_t<I0>{},
std::make_index_sequence<I1-I0>{});
......
......@@ -12,12 +12,15 @@ install(FILES
FieldMatVec.hpp
FieldMatVec.inc.hpp
Filesystem.hpp
ForEach.hpp
Index.hpp
Literals.hpp
Logical.hpp
Loops.hpp
Math.hpp
Mpl.hpp
MultiTypeMatrix.hpp
MultiTypeVector.hpp
Range.hpp
StaticSize.hpp
String.hpp
Tags.hpp
......
......@@ -5,7 +5,7 @@
#include <dune/functions/common/functionconcepts.hh>
#include <amdis/common/ConceptsBase.hpp>
#include <amdis/common/Mpl.hpp>
#include <amdis/common/Logical.hpp>
#include <amdis/common/TypeTraits.hpp>
namespace AMDiS
......@@ -33,6 +33,18 @@ namespace AMDiS
struct IsSimilar<Types<A0,As...>, Types<B0,Bs...>>
: and_t<IsSimilar<A0, B0>::value, IsSimilar<Types<As...>, Types<Bs...>>::value> {};
template <class... Ts>
struct IsSame;
template <class T0, class... Ts>
struct IsSame<T0, Ts...>
: std::is_same<Types<T0,Ts...>, Types<Ts...,T0>> {};
template <>
struct IsSame<> : std::true_type {};
template <class T>
struct IsReferenceWrapper
: std::false_type {};
......@@ -71,6 +83,9 @@ namespace AMDiS
} // end namespace Definition
#endif // DOXYGEN
/// Types are the same
template <class... Ts>
constexpr bool Same = Traits::IsSame<Ts...>::value;
/// Types are the same, up to decay of qualifiers
template <class A, class B>
......
#pragma once
#include <initializer_list>
#include <amdis/common/Apply.hpp>
#include <amdis/common/Index.hpp>
#include <amdis/common/Range.hpp>
namespace AMDiS
{
namespace Tools
{
namespace Impl_
{
template <class T>
void ignored_evaluation(std::initializer_list<T>&&) { /* do nothing */ }
}
template <class Tuple, class Functor>
constexpr void for_each(Tuple&& tuple, Functor&& f)
{
#if AMDIS_HAS_CXX_FOLD_EXPRESSIONS
Tools::apply([f=std::move(f)](auto&&... t) { (f(FWD(t)),...); }, tuple);
#else
Tools::apply([f=std::move(f)](auto&&... t) {
Impl_::ignored_evaluation<int>({0, (f(FWD(t)), 0)...});
}, tuple);
#endif
}
template <std::size_t I0, std::size_t I1, class Functor>
constexpr void for_range(index_t<I0> i0, index_t<I1> i1, Functor&& f)
{
Tools::for_each(range_t<I0,I1>{}, FWD(f));
}
template <std::size_t N, class Functor>
constexpr void for_range(index_t<N>, Functor&& f)
{
Tools::for_each(range_t<0,N>{}, FWD(f));
}
template <std::size_t I0, std::size_t I1, class Functor>
constexpr void for_range(Functor&& f)
{
Tools::for_each(range_t<I0,I1>{}, FWD(f));
}
} // end namespace Tools
} // end namespace AMDiS
#pragma once
// std c++ headers
#include <tuple>
#include <type_traits>
#include <utility>
namespace AMDiS
{
// introduce some shortcuts for integral constants
// ---------------------------------------------------------------------------
/// A wrapper for int type
template <int I>
using int_t = std::integral_constant<int, I>;
/// Variable template to generate int-type
template <int I>
constexpr int_t<I> int_ = {};
/// class that represents a sequence of integers
template <int... I>
using Ints = std::integer_sequence<int, I...>;
template <std::size_t I, int... J>
auto get(Ints<J...>) { return std::get<I>(std::make_tuple(int_<J>...)); }
/// A wrapper for std::size_t type
template <std::size_t I>
using index_t = std::integral_constant<std::size_t, I>;
/// Variable template to generate std::size_t-type
template <std::size_t I>
constexpr index_t<I> index_ = {};
/// class that represents a sequence of indices
template <std::size_t... I>
using Indices = std::index_sequence<I...>;
template <std::size_t I, std::size_t... J>
auto get(Indices<J...>) { return std::get<I>(std::make_tuple(index_<J>...)); }
} // end namespace AMDiS
......@@ -7,42 +7,6 @@
namespace AMDiS
{
// introduce some shortcuts for integral constants
// ---------------------------------------------------------------------------
/// A wrapper for int type
template <int I>
using int_t = std::integral_constant<int, I>;
/// Variable template to generate int-type
template <int I>
constexpr int_t<I> int_ = {};
/// class that represents a sequence of integers
template <int... I>
using Ints = std::integer_sequence<int, I...>;
template <std::size_t I, int... J>
auto get(Ints<J...>) { return std::get<I>(std::make_tuple(int_<J>...)); }
/// A wrapper for std::size_t type
template <std::size_t I>
using index_t = std::integral_constant<std::size_t, I>;
/// Variable template to generate std::size_t-type
template <std::size_t I>
constexpr index_t<I> index_ = {};
/// class that represents a sequence of indices
template <std::size_t... I>
using Indices = std::index_sequence<I...>;
template <std::size_t I, std::size_t... J>
auto get(Indices<J...>) { return std::get<I>(std::make_tuple(index_<J>...)); }
/// A wrapper for bool types
template <bool B>
using bool_t = std::integral_constant<bool, B>;
......@@ -51,47 +15,6 @@ namespace AMDiS
template <bool B>
constexpr bool_t<B> bool_ = {};
namespace Impl
{
/// A range of indices [I,J)
template <class Int, Int I, Int J>
struct range_impl
{
using type = range_impl;
/// Return the first element in the range
static constexpr auto begin() { return std::integral_constant<Int, I>{}; }
/// Returns the element after the last element in the range
static constexpr auto end() { return std::integral_constant<Int, J>{}; }
/// Returns the ith index in the range as integral constant
template <std::size_t i>
constexpr auto operator[](index_t<i>) const
{
return std::integral_constant<Int, I+Int(i)>{};
}
/// Return whether the range is empty
static constexpr bool empty() { return I >= J; }
/// Returns the size of the range
static constexpr auto size() { return std::integral_constant<Int, J-I>{}; }
};
/// Extracts the Ith element element from the range
template <std::size_t I, class Int, Int begin, Int end>
constexpr auto get(range_impl<Int, begin, end> const& r) { return r[index_<I>]; }
} // end namespace Impl
template <std::size_t I, std::size_t J>
using range_t = Impl::range_impl<std::size_t, I, J>;
template <std::size_t I, std::size_t J>
constexpr range_t<I,J> range_ = {};
// some boolean operations
// ---------------------------------------------------------------------------
......@@ -163,17 +86,6 @@ namespace AMDiS
template <class T>
struct IsEqualImpl<T> { enum { value = true }; };
template <class... Ts>
struct IsSameImpl;
template <class T0, class... Ts>
struct IsSameImpl<T0, Ts...>
: public std::is_same<std::tuple<T0,Ts...>,
std::tuple<Ts...,T0>> {};
template <>
struct IsSameImpl<> { enum { value = true }; };
} // end namespace Impl
template <class T, T... values>
......@@ -182,7 +94,4 @@ namespace AMDiS
template <class T, class... Ts>
using is_one_of = or_t<std::is_same<T, Ts>::value...>;
template <class... Ts>
using IsSame = Impl::IsSameImpl<Ts...>;
} // end namespace AMDiS
#pragma once
#include <dune/common/hybridutilities.hh>
#include <dune/common/rangeutilities.hh>
namespace AMDiS
{
using Dune::Hybrid::forEach;
} // end namespace AMDiS
......@@ -6,10 +6,11 @@
#include <dune/common/ftraits.hh>
#include <amdis/common/Concepts.hpp>
#include <amdis/common/Loops.hpp>
#include <amdis/common/ForEach.hpp>
#include <amdis/common/Index.hpp>
#include <amdis/common/Math.hpp>
#include <amdis/common/Mpl.hpp>
#include <amdis/common/MultiTypeVector.hpp>
#include <amdis/common/Range.hpp>
#include <amdis/common/StaticSize.hpp>
#include <amdis/common/TypeTraits.hpp>
#include <amdis/typetree/MultiIndex.hpp>
......@@ -71,35 +72,35 @@ namespace AMDiS
/// Assignment of real number to all tuple elements
MultiTypeMatrix& operator=(real_type value)
{
forEach(*this, [value](auto& fv) { fv = value; });
Tools::for_each(*this, [value](auto& fv) { fv = value; });
return *this;
}
// Compound assignment operator +=
MultiTypeMatrix& operator+=(MultiTypeMatrix const& that)
{
forEach(range_<0,rows>, [&that,this](auto const _i) { (*this)[_i] += that[_i]; });
Tools::for_range<0,rows>([&that,this](auto const _i) { (*this)[_i] += that[_i]; });
return *this;
}
// Compound assignment operator -=
MultiTypeMatrix& operator-=(MultiTypeMatrix const& that)
{
forEach(range_<0,rows>, [&that,this](auto const _i) { (*this)[_i] -= that[_i]; });
Tools::for_range<0,rows>([&that,this](auto const _i) { (*this)[_i] -= that[_i]; });
return *this;
}
// Scaling of all tuple elements by a constant value
MultiTypeMatrix& operator*=(real_type value)
{
forEach(*this, [value](auto& fv) { fv *= value; });
Tools::for_each(*this, [value](auto& fv) { fv *= value; });
return *this;
}
// Scaling of all tuple elements by the inverse of a constant value
MultiTypeMatrix& operator/=(real_type value)
{
forEach(*this, [value](auto& fv) { fv /= value; });
Tools::for_each(*this, [value](auto& fv) { fv /= value; });
return *this;
}
......@@ -150,4 +151,15 @@ namespace AMDiS
}
};
namespace Impl
{
template <class... Rows>
struct RowsImpl<MultiTypeMatrix<Rows...>>
: std::integral_constant<std::size_t, sizeof...(Rows) > {};
template <class Row0, class... Rows>
struct ColsImpl<MultiTypeMatrix<Row0, Rows...>>
: SizeImpl<Row0> {};
}
} // end namespace AMDiS
......@@ -7,8 +7,9 @@
#include <dune/functions/common/indexaccess.hh>
#include <amdis/common/Concepts.hpp>
#include <amdis/common/Loops.hpp>
#include <amdis/common/Mpl.hpp>
#include <amdis/common/ForEach.hpp>
#include <amdis/common/Index.hpp>