Skip to content
Snippets Groups Projects
Commit 6bb55ed4 authored by Dr. Felix Tobias Schindler's avatar Dr. Felix Tobias Schindler
Browse files

drop the old assembler/ dir

parent 931d0166
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 0 additions and 1703 deletions
dune/gdt/CMakeLists.txt
+ 0
− 9
View file @ 6bb55ed4
......@@ -11,14 +11,5 @@
# Tobias Leibner (2017)
# ~~~
if(DUNE_XT_WITH_PYTHON_BINDINGS)
set(dunegdt_sources
assembler/system.lib/alu_2d_simplex_conforming.cc
assembler/system.lib/yasp_1d_equidistant_offset.cc
assembler/system.lib/yasp_2d_equidistant_offset.cc
assembler/system.lib/yasp_3d_equidistant_offset.cc)
dune_library_add_sources(dunegdt SOURCES ${dunegdt_sources})
endif()
add_subdirectory(test EXCLUDE_FROM_ALL)
dune/gdt/assembler/codim0-matrix-datahandle.hh deleted 100644 → 0
+ 0
− 115
View file @ 931d0166
// This file is part of the dune-gdt project:
// https://github.com/dune-community/dune-gdt
// Copyright 2010-2018 dune-gdt developers and contributors. All rights reserved.
// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
// with "runtime exception" (http://www.dune-project.org/license.html)
// Authors:
// Rene Milk (2018)
// Tobias Leibner (2017)
#ifndef DUNE_GDT_ASSEMBLER_CODIM0MATRIXDATAHANDLE_HH
#define DUNE_GDT_ASSEMBLER_CODIM0MATRIXDATAHANDLE_HH
#include <cmath>
#include <dune/grid/common/datahandleif.hh>
namespace Dune {
namespace GDT {
// datahandle for a Dune::XT::LA::MatrixInterface matrix that can be assembled from local matrices on each entity
template <class MatrixType, class SpaceType>
class MatrixDataHandle
: public Dune::CommDataHandleIF<MatrixDataHandle<MatrixType, SpaceType>, typename MatrixType::ScalarType>
{
public:
MatrixDataHandle(MatrixType& matrix, const SpaceType& space, bool fixed_size = true)
: matrix_(matrix)
, space_(space)
, fixed_size_(fixed_size)
{
}
//! export type of data for message buffer
typedef typename MatrixType::ScalarType DataType;
//! returns true if data for this codim should be communicated
bool contains(int /*dim*/, int codim) const
{
return (codim == 0);
}
//! returns true if size per entity of given dim and codim is a constant
bool fixedsize(int /*dim*/, int /*codim*/) const
{
return fixed_size_;
}
/*! how many objects of type DataType have to be sent for a given entity
Note: Only the sender side needs to know this size.
*/
template <class EntityType>
std::enable_if_t<EntityType::codimension != 0, size_t> size(const EntityType& /*entity*/) const
{
return 0;
}
/*! how many objects of type DataType have to be sent for a given entity
Note: Only the sender side needs to know this size.
*/
template <class EntityType>
std::enable_if_t<EntityType::codimension == 0, size_t> size(const EntityType& entity) const
{
return std::pow(space_.mapper().numDofs(entity), 2);
}
//! pack data from user to message buffer
template <class MessageBuffer, class EntityType>
std::enable_if_t<EntityType::codimension != 0> gather(MessageBuffer& /*buff*/, const EntityType& /*entity*/) const
{
}
template <class MessageBuffer, class EntityType>
std::enable_if_t<EntityType::codimension == 0> gather(MessageBuffer& buff, const EntityType& entity) const
{
const auto& mapper = space_.mapper();
const auto& num_local_dofs = mapper.numDofs(entity);
for (size_t ii = 0; ii < num_local_dofs; ++ii)
for (size_t jj = 0; jj < num_local_dofs; ++jj)
buff.write(matrix_.get_entry(mapper.mapToGlobal(entity, ii), mapper.mapToGlobal(entity, jj)));
}
/*! unpack data from message buffer to user
n is the number of objects sent by the sender
*/
template <class MessageBuffer, class EntityType>
std::enable_if_t<EntityType::codimension != 0>
scatter(MessageBuffer& /*buff*/, const EntityType& /*entity*/, size_t /*n*/)
{
}
template <class MessageBuffer, class EntityType>
std::enable_if_t<EntityType::codimension == 0> scatter(MessageBuffer& buff, const EntityType& entity, size_t n)
{
const auto& mapper = space_.mapper();
const auto& num_local_dofs = mapper.numDofs(entity);
assert(num_local_dofs * num_local_dofs == n);
for (size_t ii = 0; ii < num_local_dofs; ++ii)
for (size_t jj = 0; jj < num_local_dofs; ++jj)
buff.read(matrix_.get_entry_ref(mapper.mapToGlobal(entity, ii), mapper.mapToGlobal(entity, jj)));
}
private:
MatrixType& matrix_;
const SpaceType& space_;
const bool fixed_size_;
};
} // namespace GDT
} // namespace Dune
#endif // DUNE_GDT_ASSEMBLER_CODIM0MATRIXDATAHANDLE_HH
dune/gdt/assembler/global.hh deleted 100644 → 0
+ 0
− 247
View file @ 931d0166
// This file is part of the dune-gdt project:
// https://github.com/dune-community/dune-gdt
// Copyright 2010-2018 dune-gdt developers and contributors. All rights reserved.
// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
// with "runtime exception" (http://www.dune-project.org/license.html)
// Authors:
// Felix Schindler (2012 - 2017)
// Rene Milk (2013 - 2014, 2016 - 2018)
// Tim Keil (2017)
// Tobias Leibner (2014, 2017)
#ifndef DUNE_GDT_ASSEMBLER_SYSTEM_HH
#define DUNE_GDT_ASSEMBLER_SYSTEM_HH
#include <memory>
#include <type_traits>
#include <dune/xt/common/parameter.hh>
#include <dune/xt/la/container/vector-interface.hh>
#include <dune/xt/grid/walker.hh>
#include <dune/xt/grid/type_traits.hh>
#include <dune/gdt/local/assembler/functional-assemblers.hh>
#include <dune/gdt/local/assembler/two-form-assemblers.hh>
#include <dune/gdt/local/functionals/interfaces.hh>
#include <dune/gdt/local/operators/interfaces.hh>
#include <dune/gdt/spaces/interface.hh>
#include <dune/gdt/type_traits.hh>
namespace Dune {
namespace GDT {
template <class GridView,
size_t test_range_dim = 1,
size_t test_range_dim_cols = 1,
class RangeField = double,
class TestGridView = GridView,
class AnsatzGridView = GridView,
size_t ansatz_range_dim = test_range_dim,
size_t ansatz_range_dim_cols = test_range_dim_cols>
class GlobalAssembler : public XT::Grid::Walker<GridView>
{
// no need to check the rest (is done in SpaceInterface)
static_assert(XT::Grid::is_view<GridView>::value, "");
using ThisType = GlobalAssembler<GridView,
test_range_dim,
test_range_dim_cols,
RangeField,
TestGridView,
AnsatzGridView,
ansatz_range_dim,
ansatz_range_dim_cols>;
using BaseType = XT::Grid::Walker<GridView>;
public:
using typename BaseType::GridViewType;
using typename BaseType::ElementType;
using typename BaseType::IntersectionType;
using TestSpaceType = SpaceInterface<TestGridView, test_range_dim, test_range_dim_cols, RangeField>;
using AnsatzSpaceType = SpaceInterface<AnsatzGridView, ansatz_range_dim, ansatz_range_dim_cols, RangeField>;
using ElementFilterType = XT::Grid::ElementFilter<GridViewType>;
using ApplyOnAllElements = XT::Grid::ApplyOn::AllElements<GridViewType>;
using LocalElementFunctionalType =
LocalElementFunctionalInterface<ElementType, test_range_dim, test_range_dim_cols, RangeField>;
using LocalElementTwoFormType = LocalElementTwoFormInterface<ElementType,
test_range_dim,
test_range_dim_cols,
RangeField,
RangeField,
ansatz_range_dim,
ansatz_range_dim_cols,
RangeField>;
GlobalAssembler(GridViewType grd_vw, const TestSpaceType& test_sp, const AnsatzSpaceType& ansatz_sp)
: BaseType(std::move(grd_vw))
, test_space_(test_sp)
, ansatz_space_(ansatz_sp)
{
}
template <class GV,
size_t r,
size_t rC,
class R, /* Only enable this ctor, iff */
typename = typename std::enable_if</* the type of space is TestSpaceType and */ (
std::is_same<GV, TestGridView>::value && (r == test_range_dim)
&& (rC == test_range_dim_cols)
&& std::is_same<R, RangeField>::value)
&& /* if ansatz and test space type coincide. */ std::
is_same<AnsatzSpaceType, TestSpaceType>::value>::type>
GlobalAssembler(GridViewType grd_vw, const SpaceInterface<GV, r, rC, R>& space)
: GlobalAssembler(std::move(grd_vw), space, space)
{
}
template <class GV,
size_t r,
size_t rC,
class R, /* Only enable this ctor, iff */
typename = typename std::enable_if</* the type of space is TestSpaceType, */ (
std::is_same<GV, TestGridView>::value && (r == test_range_dim)
&& (rC == test_range_dim_cols)
&& std::is_same<R, RangeField>::value)
&& /* ansatz and test space type coincide and */ std::
is_same<AnsatzSpaceType, TestSpaceType>::value
&& /* the grid view type of space and GridViewType coincide */
std::is_same<GV, GridViewType>::value>::type>
GlobalAssembler(const SpaceInterface<GV, r, rC, R>& space)
: GlobalAssembler(space.grid_view(), space, space)
{
}
GlobalAssembler(const ThisType& other) = delete;
GlobalAssembler(ThisType&& source) = default;
ThisType& operator=(const ThisType& other) = delete;
ThisType& operator=(ThisType&& source) = delete;
const TestSpaceType& test_space() const
{
return test_space_;
}
const AnsatzSpaceType& ansatz_space() const
{
return ansatz_space_;
}
using BaseType::append;
template <class V>
ThisType& append(const LocalElementFunctionalType& local_functional,
XT::LA::VectorInterface<V>& global_vector,
const XT::Common::Parameter& param = {},
const ElementFilterType& filter = ApplyOnAllElements())
{
using LocalAssemblerType = LocalElementFunctionalAssembler<typename XT::LA::VectorInterface<V>::derived_type,
GridViewType,
test_range_dim,
test_range_dim_cols,
RangeField,
TestGridView>;
this->append(new LocalAssemblerType(test_space_, local_functional, global_vector.as_imp(), param), filter);
return *this;
}
template <class M>
ThisType& append(const LocalElementTwoFormType& local_two_form,
XT::LA::MatrixInterface<M>& global_matrix,
const XT::Common::Parameter& param = {},
const ElementFilterType& filter = ApplyOnAllElements())
{
using LocalAssemblerType = LocalElementTwoFormAssembler<typename XT::LA::MatrixInterface<M>::derived_type,
GridViewType,
test_range_dim,
test_range_dim_cols,
RangeField,
TestGridView,
AnsatzGridView,
ansatz_range_dim,
ansatz_range_dim_cols>;
this->append(new LocalAssemblerType(test_space_, ansatz_space_, local_two_form, global_matrix.as_imp(), param),
filter);
return *this;
}
void assemble(const bool use_tbb = false, const bool clear_functors = true)
{
this->walk(use_tbb, clear_functors);
}
template <class Partitioning>
void assemble(Partitioning& partitioning, const bool clear_functors = true)
{
this->walk(partitioning, clear_functors);
}
protected:
const TestSpaceType& test_space_;
const AnsatzSpaceType& ansatz_space_;
}; // class GlobalAssembler
template <class GridView,
class TestGridView,
size_t t_r,
size_t t_rC,
class R,
class AnsatzGridView,
size_t a_r,
size_t a_rC>
GlobalAssembler<GridView, t_r, t_rC, R, TestGridView, AnsatzGridView, a_r, a_rC>
make_global_assembler(GridView grid_view,
const SpaceInterface<TestGridView, t_r, t_rC, R>& test_space,
const SpaceInterface<AnsatzGridView, a_r, a_rC, R>& ansatz_space,
const SpaceInterface<TestGridView, t_r, t_rC, R>& outer_test_space,
const SpaceInterface<AnsatzGridView, a_r, a_rC, R>& outer_ansatz_space)
{
return GlobalAssembler<GridView, t_r, t_rC, R, TestGridView, AnsatzGridView, a_r, a_rC>(
grid_view, test_space, ansatz_space, outer_test_space, outer_ansatz_space);
}
template <class GridView,
class TestGridView,
size_t t_r,
size_t t_rC,
class R,
class AnsatzGridView,
size_t a_r,
size_t a_rC>
GlobalAssembler<GridView, t_r, t_rC, R, TestGridView, AnsatzGridView, a_r, a_rC>
make_global_assembler(GridView grid_view,
const SpaceInterface<TestGridView, t_r, t_rC, R>& test_space,
const SpaceInterface<AnsatzGridView, a_r, a_rC, R>& ansatz_space)
{
return GlobalAssembler<GridView, t_r, t_rC, R, TestGridView, AnsatzGridView, a_r, a_rC>(
grid_view, test_space, ansatz_space);
}
template <class GridView, class SpaceGridView, size_t r, size_t rC, class R>
GlobalAssembler<GridView, r, rC, R, SpaceGridView>
make_global_assembler(GridView grid_view, const SpaceInterface<SpaceGridView, r, rC, R>& space)
{
return GlobalAssembler<GridView, r, rC, R, SpaceGridView>(grid_view, space);
}
template <class GV, size_t r, size_t rC, class R>
GlobalAssembler<GV, r, rC, R> make_global_assembler(const SpaceInterface<GV, r, rC, R>& space)
{
return GlobalAssembler<GV, r, rC, R>(space);
}
} // namespace GDT
} // namespace Dune
#endif // DUNE_GDT_ASSEMBLER_SYSTEM_HH
dune/gdt/assembler/local-accumulators.hh deleted 100644 → 0
+ 0
− 116
View file @ 931d0166
// This file is part of the dune-gdt project:
// https://github.com/dune-community/dune-gdt
// Copyright 2010-2018 dune-gdt developers and contributors. All rights reserved.
// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
// with "runtime exception" (http://www.dune-project.org/license.html)
// Authors:
// Felix Schindler (2017)
#ifndef DUNE_GDT_ASSEMBLER_LOCAL_ACCUMULATROS_HH
#define DUNE_GDT_ASSEMBLER_LOCAL_ACCUMULATROS_HH
#include <dune/xt/grid/walker/wrapper.hh>
#include <dune/gdt/local/operators/interfaces.hh>
namespace Dune {
namespace GDT {
/**
* \todo \attention Rename LocalVolumeTwoFormAccumulatorFunctor -> LocalVolumeTwoFormAccumulator once the latter is
* removed!
*/
template <class GL,
class TestFunctionType,
class AnsatzFunctionType,
class FieldType = typename TestFunctionType::RangeFieldType>
class LocalVolumeTwoFormAccumulatorFunctor : public XT::Grid::internal::Codim0ReturnObject<GL, FieldType>
{
static_assert(XT::Functions::is_localizable_function<TestFunctionType>::value, "");
static_assert(XT::Functions::is_localizable_function<AnsatzFunctionType>::value, "");
typedef LocalVolumeTwoFormAccumulatorFunctor<GL, TestFunctionType, AnsatzFunctionType, FieldType> ThisType;
typedef XT::Grid::internal::Codim0ReturnObject<GL, FieldType> BaseType;
public:
typedef LocalVolumeTwoFormInterface<typename TestFunctionType::LocalfunctionType,
typename AnsatzFunctionType::LocalfunctionType,
FieldType>
LocalVolumeTwoFormType;
typedef typename BaseType::GridLayerType GridLayerType;
typedef typename BaseType::EntityType EntityType;
LocalVolumeTwoFormAccumulatorFunctor(const GridLayerType& grid_layer,
const LocalVolumeTwoFormType& local_volume_two_form,
const TestFunctionType& test_function,
const AnsatzFunctionType& ansatz_function,
FieldType& res,
const XT::Grid::ApplyOn::WhichEntity<GridLayerType>* where)
: grid_layer_(grid_layer)
, local_volume_two_form_(local_volume_two_form)
, test_function_(test_function)
, ansatz_function_(ansatz_function)
, final_result_(res)
, where_(where)
, result_per_thread_(0.)
, finalized_(false)
{
}
void prepare() override final
{
final_result_ = 0.;
*result_per_thread_ = 0.;
}
bool apply_on(const GridLayerType& grid_layer, const EntityType& entity) const override final
{
return where_->apply_on(grid_layer, entity);
}
FieldType compute_locally(const EntityType& entity) override final
{
DynamicMatrix<FieldType> local_twoform_result(1, 1, 0.); // \todo: make mutable member, after SMP refactor
this->local_volume_two_form_.apply2(
*test_function_.local_function(entity), *ansatz_function_.local_function(entity), local_twoform_result);
return local_twoform_result[0][0];
} // ... compute_locally(...)
void apply_local(const EntityType& entity) override final
{
*result_per_thread_ += compute_locally(entity);
}
void finalize() override final
{
if (!finalized_) {
final_result_ = result_per_thread_.sum();
final_result_ = grid_layer_.comm().sum(final_result_);
finalized_ = true;
}
} // ... finalize(...)
FieldType result() const override final
{
DUNE_THROW_IF(!finalized_, XT::Common::Exceptions::you_are_using_this_wrong, "Call finalize() first!");
return final_result_;
}
private:
const GridLayerType& grid_layer_;
const LocalVolumeTwoFormType& local_volume_two_form_;
const TestFunctionType& test_function_;
const AnsatzFunctionType& ansatz_function_;
FieldType& final_result_;
const std::unique_ptr<const XT::Grid::ApplyOn::WhichEntity<GridLayerType>> where_;
Dune::XT::Common::PerThreadValue<FieldType> result_per_thread_;
bool finalized_;
}; // class LocalVolumeTwoFormAccumulatorFunctor
} // namespace GDT
} // namespace Dune
#endif // DUNE_GDT_ASSEMBLER_LOCAL_ACCUMULATROS_HH
dune/gdt/assembler/local-assemblers.hh deleted 100644 → 0
+ 0
− 670
View file @ 931d0166
This diff is collapsed.
dune/gdt/assembler/system.lib.hh deleted 100644 → 0
+ 0
− 377
View file @ 931d0166
This diff is collapsed.
dune/gdt/assembler/system.lib/alu_2d_simplex_conforming.cc deleted 100644 → 0
+ 0
− 20
View file @ 931d0166
// This file is part of the dune-gdt project:
// https://github.com/dune-community/dune-gdt
// Copyright 2010-2018 dune-gdt developers and contributors. All rights reserved.
// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
// with "runtime exception" (http://www.dune-project.org/license.html)
// Authors:
// Felix Schindler (2017)
#include <config.h>
#if HAVE_DUNE_ALUGRID
#include "../system.lib.hh"
DUNE_GDT_ASSEMBLER_SYSTEM_LIB_DD_SUBDOMAIN(template, ALU_2D_SIMPLEX_CONFORMING, cg, gdt, 1, 1, 1);
#endif // HAVE_DUNE_ALUGRID
dune/gdt/assembler/system.lib/yasp_1d_equidistant_offset.cc deleted 100644 → 0
+ 0
− 15
View file @ 931d0166
// This file is part of the dune-gdt project:
// https://github.com/dune-community/dune-gdt
// Copyright 2010-2018 dune-gdt developers and contributors. All rights reserved.
// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
// with "runtime exception" (http://www.dune-project.org/license.html)
// Authors:
// Felix Schindler (2017)
#include <config.h>
#include "../system.lib.hh"
DUNE_GDT_ASSEMBLER_SYSTEM_LIB_DD_SUBDOMAIN(template, YASP_1D_EQUIDISTANT_OFFSET, cg, gdt, 1, 1, 1);
dune/gdt/assembler/system.lib/yasp_2d_equidistant_offset.cc deleted 100644 → 0
+ 0
− 15
View file @ 931d0166
// This file is part of the dune-gdt project:
// https://github.com/dune-community/dune-gdt
// Copyright 2010-2018 dune-gdt developers and contributors. All rights reserved.
// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
// with "runtime exception" (http://www.dune-project.org/license.html)
// Authors:
// Felix Schindler (2017)
#include <config.h>
#include "../system.lib.hh"
DUNE_GDT_ASSEMBLER_SYSTEM_LIB_DD_SUBDOMAIN(template, YASP_2D_EQUIDISTANT_OFFSET, cg, gdt, 1, 1, 1);
dune/gdt/assembler/system.lib/yasp_3d_equidistant_offset.cc deleted 100644 → 0
+ 0
− 15
View file @ 931d0166
// This file is part of the dune-gdt project:
// https://github.com/dune-community/dune-gdt
// Copyright 2010-2018 dune-gdt developers and contributors. All rights reserved.
// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
// with "runtime exception" (http://www.dune-project.org/license.html)
// Authors:
// Felix Schindler (2017)
#include <config.h>
#include "../system.lib.hh"
DUNE_GDT_ASSEMBLER_SYSTEM_LIB_DD_SUBDOMAIN(template, YASP_3D_EQUIDISTANT_OFFSET, cg, gdt, 1, 1, 1);
dune/gdt/assembler/wrapper.hh deleted 100644 → 0
+ 0
− 104
View file @ 931d0166
// This file is part of the dune-gdt project:
// https://github.com/dune-community/dune-gdt
// Copyright 2010-2018 dune-gdt developers and contributors. All rights reserved.
// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
// with "runtime exception" (http://www.dune-project.org/license.html)
// Authors:
// Felix Schindler (2014 - 2017)
// Rene Milk (2014, 2016 - 2018)
// Tim Keil (2017)
// Tobias Leibner (2014, 2016 - 2017)
#ifndef DUNE_GDT_ASSEMBLER_WRAPPER_HH
#define DUNE_GDT_ASSEMBLER_WRAPPER_HH
#include <type_traits>
#include <dune/xt/la/container/interfaces.hh>
#include <dune/xt/grid/walker.hh>
#include <dune/xt/grid/walker/apply-on.hh>
#include <dune/xt/grid/walker/functors.hh>
#include <dune/xt/grid/walker/wrapper.hh>
#include <dune/xt/grid/type_traits.hh>
#include <dune/gdt/local/assembler.hh>
#include <dune/gdt/spaces/interface.hh>
#include <dune/gdt/spaces/constraints.hh>
#include <dune/gdt/type_traits.hh>
namespace Dune {
namespace GDT {
namespace internal {
// //////////////////////
// // wrap constraints //
// //////////////////////
template <class TestSpaceType, class AnsatzSpaceType, class GridLayerType, class ConstraintsType>
class ConstraintsWrapper : public XT::Grid::internal::Codim0Object<GridLayerType>
{
static_assert(AlwaysFalse<ConstraintsType>::value, "Please add a specialization for these Constraints!");
};
// given DirichletConstraints
template <class TestSpaceType, class AnsatzSpaceType, class GridLayerType>
class ConstraintsWrapper<TestSpaceType,
AnsatzSpaceType,
GridLayerType,
DirichletConstraints<XT::Grid::extract_intersection_t<GridLayerType>>>
: public XT::Grid::internal::Codim0Object<GridLayerType>
{
static_assert(is_space<TestSpaceType>::value, "TestSpaceType has to be derived from SpaceInterface!");
static_assert(is_space<AnsatzSpaceType>::value, "AnsatzSpaceType has to be derived from SpaceInterface!");
typedef XT::Grid::internal::Codim0Object<GridLayerType> BaseType;
typedef DirichletConstraints<XT::Grid::extract_intersection_t<GridLayerType>> ConstraintsType;
public:
using typename BaseType::EntityType;
ConstraintsWrapper(const XT::Common::PerThreadValue<const TestSpaceType>& test_space,
const XT::Common::PerThreadValue<const AnsatzSpaceType>& ansatz_space,
const XT::Grid::ApplyOn::WhichEntity<GridLayerType>* where,
ConstraintsType& constraints)
: test_space_(test_space)
, ansatz_space_(ansatz_space)
, where_(where)
, constraints_(constraints)
, thread_local_constraints_(constraints_.boundary_info(), constraints_.size())
{
}
bool apply_on(const GridLayerType& gv, const EntityType& entity) const override final
{
return where_->apply_on(gv, entity);
}
void apply_local(const EntityType& entity) override final
{
test_space_->local_constraints(*ansatz_space_, entity, *thread_local_constraints_);
}
void finalize() override final
{
DUNE_UNUSED std::lock_guard<std::mutex> mutex_guard(constraints_.mutex_);
constraints_.dirichlet_DoFs_.insert(thread_local_constraints_->dirichlet_DoFs_.begin(),
thread_local_constraints_->dirichlet_DoFs_.end());
}
private:
const XT::Common::PerThreadValue<const TestSpaceType>& test_space_;
const XT::Common::PerThreadValue<const AnsatzSpaceType>& ansatz_space_;
const std::unique_ptr<const XT::Grid::ApplyOn::WhichEntity<GridLayerType>> where_;
ConstraintsType& constraints_;
XT::Common::PerThreadValue<ConstraintsType> thread_local_constraints_;
}; // class ConstraintsWrapper
} // namespace internal
} // namespace GDT
} // namespace Dune
#endif // DUNE_GDT_ASSEMBLER_WRAPPER_HH
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment