11 #include <dune/common/fvector.hh> 12 #include <dune/common/fmatrix.hh> 13 #include <dune/common/shared_ptr.hh> 15 #include <dune/grid/common/grid.hh> 17 #include <amdis/AdaptInfo.hpp> 18 #include <amdis/AdaptiveGrid.hpp> 19 #include <amdis/BiLinearForm.hpp> 20 #include <amdis/CreatorInterface.hpp> 21 #include <amdis/CreatorMap.hpp> 22 #include <amdis/DirichletBC.hpp> 23 #include <amdis/DOFVector.hpp> 25 #include <amdis/Flag.hpp> 26 #include <amdis/Initfile.hpp> 27 #include <amdis/LinearAlgebra.hpp> 28 #include <amdis/LinearForm.hpp> 29 #include <amdis/Marker.hpp> 30 #include <amdis/MeshCreator.hpp> 31 #include <amdis/OperatorList.hpp> 32 #include <amdis/PeriodicBC.hpp> 33 #include <amdis/ProblemStatBase.hpp> 34 #include <amdis/ProblemStatTraits.hpp> 35 #include <amdis/StandardProblemIteration.hpp> 36 #include <amdis/common/SharedPtr.hpp> 37 #include <amdis/common/TupleUtility.hpp> 38 #include <amdis/common/TypeTraits.hpp> 39 #include <amdis/GridFunctions.hpp> 40 #include <amdis/gridfunctions/DiscreteFunction.hpp> 41 #include <amdis/io/FileWriterBase.hpp> 42 #include <amdis/typetree/Traits.hpp> 43 #include <amdis/typetree/TreePath.hpp> 48 template <
class Traits>
51 template <
class Traits>
65 using Element =
typename GridView::template Codim<0>::Entity;
66 using WorldVector =
typename Element::Geometry::GlobalCoordinate;
67 using WorldMatrix = FieldMatrix<typename WorldVector::field_type, WorldVector::dimension, WorldVector::dimension>;
70 static constexpr
int dim = Grid::dimension;
73 static constexpr
int dow = Grid::dimensionworld;
76 using LinAlgTraits =
typename Traits::LinAlgTraits;
77 using Mat =
typename LinAlgTraits::template MatrixImpl<typename Traits::CoefficientType>;
78 using Vec =
typename LinAlgTraits::template VectorImpl<typename Traits::CoefficientType>;
79 using PartitionSet =
typename LinAlgTraits::PartitionSet;
98 template <
class Gr
id_>
107 template <
class Gr
id_,
class Basis_,
class B_ = Underlying_t<Basis_>,
108 REQUIRES(Concepts::GlobalBasis<B_>)>
117 template <class Grid_, class PBF_, class GV_ = typename Underlying_t<Grid_>::LeafGridView,
118 REQUIRES(Concepts::PreBasisFactory<PBF_, GV_, MultiIndex_t<PBF_>>)>
122 adoptGlobalBasis(makeSharedPtr(GlobalBasis{grid_->leafGridView(), preBasisFactory}));
160 template <
class Operator,
class RowTreePath = RootTreePath,
class ColTreePath = RootTreePath>
163 static constexpr
bool isValidTreePath =
164 Concepts::ValidTreePath<typename GlobalBasis::LocalView::Tree, RowTreePath> &&
165 Concepts::ValidTreePath<typename GlobalBasis::LocalView::Tree, ColTreePath>;
166 static_assert(isValidTreePath,
"Invalid row and/or col treepath passed to addMatrixOperator!");
168 if constexpr (isValidTreePath)
191 template <
class Operator,
class RowTreePath = RootTreePath,
class ColTreePath = RootTreePath>
194 using I =
typename GridView::Intersection;
195 static constexpr
bool isValidTreePath =
196 Concepts::ValidTreePath<typename GlobalBasis::LocalView::Tree, RowTreePath> &&
197 Concepts::ValidTreePath<typename GlobalBasis::LocalView::Tree, ColTreePath>;
198 static_assert(isValidTreePath,
"Invalid row and/or col treepath passed to addMatrixOperator!");
200 if constexpr (isValidTreePath)
223 template <
class Operator,
class TreePath = RootTreePath>
226 static constexpr
bool isValidTreePath =
227 Concepts::ValidTreePath<typename GlobalBasis::LocalView::Tree, TreePath>;
228 static_assert(isValidTreePath,
"Invalid treepath passed to addVectorOperator!");
230 if constexpr (isValidTreePath)
251 template <
class Operator,
class TreePath = RootTreePath>
254 using I =
typename GridView::Intersection;
255 static constexpr
bool isValidTreePath =
256 Concepts::ValidTreePath<typename GlobalBasis::LocalView::Tree, TreePath>;
257 static_assert(isValidTreePath,
"Invalid treepath passed to addVectorOperator!");
259 if constexpr (isValidTreePath)
287 template <
class Predicate,
class RowTreePath,
class ColTreePath,
class Values>
289 RowTreePath row, ColTreePath col,
290 Values
const& values);
292 template <
class RowTreePath,
class ColTreePath,
class Values>
294 RowTreePath row, ColTreePath col,
295 Values
const& values);
297 template <
class Identifier,
class Values>
300 addDirichletBC(FWD(
id), RootTreePath{}, RootTreePath{}, FWD(values));
320 bool asmMatrix =
true,
321 bool asmVector =
true)
override;
332 bool createMatrixData =
true,
333 bool storeMatrixData =
false)
override;
357 std::string
const&
name()
const override {
return name_; }
360 std::shared_ptr<Grid>
grid() {
return grid_; }
361 std::shared_ptr<Grid const>
grid()
const {
return grid_; }
364 GridView
gridView()
const {
return globalBasis_->gridView(); }
368 std::shared_ptr<BoundaryManager<Grid>
const>
boundaryManager()
const {
return boundaryManager_; }
371 std::shared_ptr<GlobalBasis>
globalBasis() {
return globalBasis_; }
372 std::shared_ptr<GlobalBasis const>
globalBasis()
const {
return globalBasis_; }
375 std::shared_ptr<LinearSolver>
solver() {
return linearSolver_; }
376 std::shared_ptr<LinearSolver const>
solver()
const {
return linearSolver_; }
380 std::shared_ptr<SystemMatrix const>
systemMatrix()
const {
return systemMatrix_; }
384 std::shared_ptr<SolutionVector const>
solutionVector()
const {
return solution_; }
387 std::shared_ptr<SystemVector>
rhsVector() {
return rhs_; }
388 std::shared_ptr<SystemVector const>
rhsVector()
const {
return rhs_; }
395 assert(
bool(solution_) &&
"You have to call initialize() before.");
396 return valueOf(*solution_, ii...);
403 assert(
bool(solution_) &&
"You have to call initialize() before.");
404 return valueOf(*solution_, ii...);
411 template <
class Solver_>
421 template <
class Gr
id_>
426 createMatricesAndVectors();
436 template <
class Marker_>
440 auto it = marker_.emplace(marker->name(), marker);
441 if (marker_.size() > 1)
442 it.first->second->setMaximumMarking(
true);
448 std::size_t num = marker_.erase(name);
449 test_warning(num == 1,
"A marker with the given name '{}' does not exist.", name);
461 void createGlobalBasis();
463 void createMatricesAndVectors();
466 void createFileWriter();
468 void adoptGlobalBasis(std::shared_ptr<GlobalBasis>
globalBasis)
470 globalBasis_ = std::move(globalBasis);
474 void adoptGrid(std::shared_ptr<Grid>
const&
grid,
482 void adoptGrid(std::shared_ptr<Grid>
const& grid)
487 void adoptGrid(std::shared_ptr<typename Grid::HostGrid>
const& hostGrid)
489 auto grid = std::make_shared<Grid>(hostGrid);
495 void createGlobalBasisImpl(std::true_type);
496 void createGlobalBasisImpl(std::false_type);
498 void initGlobalBasis();
505 std::shared_ptr<Grid> grid_;
508 std::string gridName_ =
"mesh";
511 std::shared_ptr<BoundaryManager<Grid>> boundaryManager_;
514 std::shared_ptr<GlobalBasis> globalBasis_;
517 std::list<std::shared_ptr<FileWriterInterface>> filewriter_;
520 std::map<std::string, std::shared_ptr<Marker<Grid>>> marker_;
526 std::shared_ptr<LinearSolver> linearSolver_;
529 std::shared_ptr<SystemMatrix> systemMatrix_;
532 std::shared_ptr<SolutionVector> solution_;
536 std::shared_ptr<SystemVector> rhs_;
540 std::map<std::string, std::vector<double>> estimates_;
549 template <
class Gr
id,
class B,
class =
void>
550 struct DeducedProblemTraits;
552 template <
class Gr
id,
class PB>
553 struct DeducedProblemTraits<Grid,GlobalBasis<PB>,void>
558 template <
class G,
class PBF>
559 struct DeducedProblemTraits<G,PBF,
560 std::enable_if_t<Concepts::PreBasisFactory<PBF, typename G::LeafGridView, MultiIndex_t<PBF>>>>
563 using GridView =
typename Grid::LeafGridView;
564 using Basis = decltype(GlobalBasis{std::declval<GridView>(),std::declval<PBF>()});
569 template <
class Gr
id,
class Basis>
570 using DeducedProblemTraits_t =
typename DeducedProblemTraits<Grid,Basis>::type;
575 template <
class Gr
id,
class Basis>
586 #include "ProblemStat.inc.hpp" Flag oneIteration(AdaptInfo &adaptInfo, Flag toDo=FULL_ITERATION) override
Implementation of StandardProblemIteration::oneIteration.
Definition: ProblemStat.hpp:312
static constexpr int dow
Dimension of the world.
Definition: ProblemStat.hpp:73
std::string const & name() const override
Implementation of ProblemStatBase::name.
Definition: ProblemStat.hpp:357
void addPeriodicBC(BoundaryType id, WorldMatrix const &A, WorldVector const &b)
Definition: ProblemStat.inc.hpp:350
The Flag class encapsulates flags which represents simple information. Used e.g. while mesh traversal...
Definition: Flag.hpp:13
ProblemStat(std::string const &name, Grid_ &&grid)
Definition: ProblemStat.hpp:99
void addMatrixOperator(BoundaryType b, Operator const &op, RowTreePath row={}, ColTreePath col={})
Operator evaluated on the boundary of the domain with boundary index b
Definition: ProblemStat.hpp:192
void addDirichletBC(Predicate const &predicate, RowTreePath row, ColTreePath col, Values const &values)
Add boundary conditions to the system.
Definition: ProblemStat.inc.hpp:294
std::index_sequence< I... > Indices
class that represents a sequence of indices
Definition: Index.hpp:40
void addMarker(Marker_ &&m)
Store the shared_ptr and the name of the marker in the problem.
Definition: ProblemStat.hpp:437
typename Impl::AdaptiveGridImpl< HostGrid >::type AdaptiveGrid_t
Definition: AdaptiveGrid.hpp:367
void addMatrixOperator(Operator const &op, RowTreePath row={}, ColTreePath col={})
Add an operator to A.
Definition: ProblemStat.hpp:161
void estimate(AdaptInfo &) override
Implementation of ProblemStatBase::estimate.
Definition: ProblemStat.hpp:336
constexpr bool Predicate
A predicate is a function that returns a boolean.
Definition: Concepts.hpp:142
void setGrid(Grid_ &&grid)
Definition: ProblemStat.hpp:422
ProblemStat(std::string const &name)
Constructor. Takes the name of the problem that is used to access values corresponding to this proble...
Definition: ProblemStat.hpp:92
The basic container that stores a base vector and a corresponding basis.
Definition: DOFVector.hpp:27
Contains all classes needed for solving linear and non linear equation systems.
Definition: AdaptBase.hpp:6
StandardProblemIteration when derived from ProblemStat.
Definition: StandardProblemIteration.hpp:71
Definition: OperatorList.hpp:16
Base class for all markers.
Definition: Marker.hpp:28
std::shared_ptr< LinearSolver > solver()
Return a reference to the linear solver, linearSolver.
Definition: ProblemStat.hpp:375
std::shared_ptr< SolutionVector > solutionVector()
Returns a reference to the solution vector, solution_.
Definition: ProblemStat.hpp:383
Wrapper around a global basis providing default traits.
Definition: ProblemStatTraits.hpp:77
std::shared_ptr< GlobalBasis > globalBasis()
Return the globalBasis_.
Definition: ProblemStat.hpp:371
Definition: ProblemStat.hpp:52
void initialize(Flag initFlag, Self *adoptProblem=nullptr, Flag adoptFlag=INIT_NOTHING)
Initialisation of the problem.
Definition: ProblemStat.inc.hpp:23
Standard implementation of ProblemTimeInterface for a time dependent problems.
Definition: ProblemInstat.hpp:22
TreeMatrix< BCData< Mat, Sol, Rhs >::template type, typename RB::LocalView::Tree, typename CB::LocalView::Tree > BoundaryConditions
Definition: BoundaryCondition.hpp:53
void restore(Flag initFlag)
Read the grid and solution from backup files and initialize the problem.
Definition: ProblemStat.inc.hpp:108
ProblemStat(std::string const &name, Grid_ &&grid, Basis_ &&globalBasis)
Constructor taking a grid and basis. Wraps both in shared pointers.
Definition: ProblemStat.hpp:109
std::shared_ptr< Grid > grid()
Return the grid_.
Definition: ProblemStat.hpp:360
auto solution(Indices... ii) const
Return a const view to a solution component.
Definition: ProblemStat.hpp:401
std::shared_ptr< SystemMatrix > systemMatrix()
Returns a reference to system-matrix, systemMatrix_.
Definition: ProblemStat.hpp:379
static std::optional< T > get(std::string const &key)
Get parameter-values from parameter-tree.
Definition: Initfile.hpp:25
static constexpr int dim
Dimension of the grid.
Definition: ProblemStat.hpp:70
void addVectorOperator(Operator const &op, TreePath path={})
Add an operator to rhs.
Definition: ProblemStat.hpp:224
std::shared_ptr< SystemVector > rhsVector()
Return a reference to the rhs system-vector, rhs.
Definition: ProblemStat.hpp:387
Flag markElements(AdaptInfo &adaptInfo) override
Implementation of ProblemStatBase::markElements.
Definition: ProblemStat.inc.hpp:391
void removeMarker(std::string name)
Remove a marker with the given name from the problem.
Definition: ProblemStat.hpp:446
Abstract base class for linear solvers.
Definition: LinearSolverInterface.hpp:27
Flag adaptGrid(AdaptInfo &adaptInfo) override
Implementation of ProblemStatBase::refineMesh.
Definition: ProblemStat.inc.hpp:453
auto valueOf(DiscreteFunction< Coeff, GB, Path... > &df, Indices... ii)
A Generator for the childs of a mutable DiscreteFunction.
Definition: DiscreteFunction.hpp:269
ProblemStat(std::string const &name, Grid_ &&grid, PBF_ const &preBasisFactory)
Constructor taking a grid and pre-basis factory to create a global basis on the fly.
Definition: ProblemStat.hpp:119
Interface for time independent problems. Concrete problems must override all pure virtual methods...
Definition: ProblemStatBase.hpp:58
void writeFiles(AdaptInfo &adaptInfo, bool force=false)
Writes output files. If force=true write even if timestep out of write rhythm.
Definition: ProblemStat.inc.hpp:530
void solve(AdaptInfo &adaptInfo, bool createMatrixData=true, bool storeMatrixData=false) override
Implementation of ProblemStatBase::solve.
Definition: ProblemStat.inc.hpp:362
typename PreBasis::GridView GridView
The grid view that the FE space is defined on.
Definition: GlobalBasis.hpp:66
GridView gridView() const
Return the gridView of the basis.
Definition: ProblemStat.hpp:364
Flag globalRefine(int n) override
Uniform global refinement by n level.
Definition: ProblemStat.inc.hpp:438
Holds adapt parameters and infos about the problem.
Definition: AdaptInfo.hpp:25
void addVectorOperator(BoundaryType b, Operator const &op, TreePath path={})
Operator evaluated on the boundary of the domain with boundary index b
Definition: ProblemStat.hpp:252
auto solution(Indices... ii)
Return a mutable view to a solution component.
Definition: ProblemStat.hpp:393
std::shared_ptr< T > wrap_or_share(T &t)
Definition: SharedPtr.hpp:22
std::shared_ptr< BoundaryManager< Grid > > boundaryManager()
Return the boundary manager to identify boundary segments.
Definition: ProblemStat.hpp:367
void buildAfterAdapt(AdaptInfo &adaptInfo, Flag flag, bool asmMatrix=true, bool asmVector=true) override
Implementation of ProblemStatBase::buildAfterCoarse.
Definition: ProblemStat.inc.hpp:468
Definition: OperatorList.hpp:14
constexpr bool GlobalBasis
A Dune::Functions::GlobalBasis type.
Definition: Concepts.hpp:190
void assemble(AdaptInfo &adaptInfo)
Assemble the linear system by calling buildAfterAdapt with asmMatrix and asmVector set to true...
Definition: ProblemStat.hpp:325
Manage boundary ids of boundary segments in a grid.
Definition: BoundaryManager.hpp:52
std::string const & name() const
Returns name_ of the Marker.
Definition: Marker.hpp:81
Flag globalCoarsen(int n) override
Uniform global grid coarsening by up to n level.
Definition: ProblemStat.inc.hpp:407
void setSolver(Solver_ &&solver)
Set a new linear solver for the problem.
Definition: ProblemStat.hpp:412
void removeMarker(Marker< Grid > const &marker)
Remove a marker from the problem.
Definition: ProblemStat.hpp:453
void test_warning(bool condition, std::string const &str, Args &&... args)
test for condition and in case of failure print message
Definition: Output.hpp:183
Flag oneIteration(AdaptInfo &adaptInfo, Flag toDo) override
Implementation of ProblemIterationInterface::oneIteration()
Definition: StandardProblemIteration.cpp:35