swh:1:snp:f521c49ab17ef7db6ec70b2430e1ed203f50383f
Tip revision: f4767ab1bc99c3406d6b9e818856136532a59b03 authored by Jörg Buchwald on 19 April 2021, 14:58:05 UTC
[MPL] Zero initialization for constant dvalue.
[MPL] Zero initialization for constant dvalue.
Tip revision: f4767ab
ExtrapolatableElementCollection.h
/**
* \file
* \copyright
* Copyright (c) 2012-2021, OpenGeoSys Community (http://www.opengeosys.org)
* Distributed under a Modified BSD License.
* See accompanying file LICENSE.txt or
* http://www.opengeosys.org/project/license
*
*/
#pragma once
#include <functional>
#include <vector>
#include "MathLib/LinAlg/GlobalMatrixVectorTypes.h"
#include "ExtrapolatableElement.h"
namespace NumLib
{
class LocalToGlobalIndexMap;
/*! Adaptor to get information needed by an Extrapolator from an "arbitrary"
* collection of elements (e.g., local assemblers).
*
* This is an interface class; suitable implementations have to be provided for
* concrete collections of extrapolatable elements.
*/
class ExtrapolatableElementCollection
{
public:
//! Returns the shape matrix of the element with the given \c id at the
//! given \c integration_point.
virtual Eigen::Map<const Eigen::RowVectorXd> getShapeMatrix(
std::size_t const id, unsigned const integration_point) const = 0;
/*! Returns integration point values of some property of a specific element.
*
* \param id ID of the element of which the property is queried.
* \param t The time used in the evaluation if time dependent quantities.
* \param x The current solutions of a ProcessLib::Process;
* more generally any nodal GlobalVector pointers for each process.
* \param dof_table The processes d.o.f. table used to get each element's
* local d.o.f. from \c x.
* \param cache Can be used to compute a property on-the-fly.
*
* \remark
* \parblock
* Since this method returns a reference, integration point values can not
* be computed locally and just returned.
*
* Instead, the vector \c cache can be used to store some derived quantities
* that should be used as integration point values. They can be written to
* the \c cache and a reference to the \c cache can then be returned by the
* implementation of this method. Ordinary integration point values can be
* returned directly (if they are stored in the local assembler), and the
* \c cache can be left untouched.
*
* For usage examples see the processes already implemented or the unit test
* in TestExtrapolation.cpp
* \endparblock
*/
virtual std::vector<double> const& getIntegrationPointValues(
std::size_t const id, const double t,
std::vector<GlobalVector*> const& x,
std::vector<NumLib::LocalToGlobalIndexMap const*> const& dof_table,
std::vector<double>& cache) const = 0;
//! Returns the number of elements whose properties shall be extrapolated.
virtual std::size_t size() const = 0;
virtual ~ExtrapolatableElementCollection() = default;
};
template <typename LocalAssemblerCollection>
class ExtrapolatableLocalAssemblerCollection
: public ExtrapolatableElementCollection
{
public:
//! LocalAssemblerCollection contains many LocalAssembler's.
using LocalAssembler =
typename std::decay_t<decltype(*std::declval<LocalAssemblerCollection>()
[static_cast<std::size_t>(0)])>;
static_assert(std::is_base_of<ExtrapolatableElement, LocalAssembler>::value,
"Local assemblers used for extrapolation must be derived "
"from ExtrapolatableElement.");
/*! A method providing integration point values of some property.
*
* The method must return reference to a vector containing the integration
* point values.
*
* For further information about the \c cache parameter see
* ExtrapolatableElementCollection::getIntegrationPointValues().
*/
using IntegrationPointValuesMethod =
std::function<std::vector<double> const&(
LocalAssembler const& loc_asm, const double t,
std::vector<GlobalVector*> const& x,
std::vector<NumLib::LocalToGlobalIndexMap const*> const& dof_table,
std::vector<double>& cache)>;
/*! Constructs a new instance.
*
* \param local_assemblers a collection of local assemblers whose
* integration point values shall be extrapolated.
* \param integration_point_values_method a LocalAssembler method returning
* integration point values of some property for that local assembler.
*/
ExtrapolatableLocalAssemblerCollection(
LocalAssemblerCollection const& local_assemblers,
IntegrationPointValuesMethod const& integration_point_values_method)
: _local_assemblers(local_assemblers),
_integration_point_values_method{integration_point_values_method}
{
}
Eigen::Map<const Eigen::RowVectorXd> getShapeMatrix(
std::size_t const id, unsigned const integration_point) const override
{
ExtrapolatableElement const& loc_asm = *_local_assemblers[id];
return loc_asm.getShapeMatrix(integration_point);
}
std::vector<double> const& getIntegrationPointValues(
std::size_t const id, const double t,
std::vector<GlobalVector*> const& x,
std::vector<NumLib::LocalToGlobalIndexMap const*> const& dof_table,
std::vector<double>& cache) const override
{
auto const& loc_asm = *_local_assemblers[id];
return _integration_point_values_method(loc_asm, t, x, dof_table,
cache);
}
std::size_t size() const override { return _local_assemblers.size(); }
private:
LocalAssemblerCollection const& _local_assemblers;
IntegrationPointValuesMethod const _integration_point_values_method;
};
//! Creates an ExtrapolatableLocalAssemblerCollection, which can be used to
//! provide information to an Extrapolator.
template <typename LocalAssemblerCollection,
typename IntegrationPointValuesMethod>
ExtrapolatableLocalAssemblerCollection<LocalAssemblerCollection>
makeExtrapolatable(LocalAssemblerCollection const& local_assemblers,
IntegrationPointValuesMethod integration_point_values_method)
{
return ExtrapolatableLocalAssemblerCollection<LocalAssemblerCollection>{
local_assemblers, integration_point_values_method};
}
} // namespace NumLib