State.hpp File Reference

#include "fub/PatchDataView.hpp"
#include "fub/core/tuple.hpp"
#include "fub/ext/Eigen.hpp"
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/tuple.hpp>
#include <numeric>

Go to the source code of this file.

Classes
struct	fub::NumVariables< T >
struct	fub::ScalarDepth
	This type is used to tag scalar quantities. More...
struct	fub::VectorDepth< Depth >
	This type is used to tag quantities with a depth known at compile time. More...
struct	fub::ToConcreteDepthImpl< Depth >
struct	fub::ToConcreteDepthImpl< VectorDepth<-1 > >
struct	fub::Type< T >
struct	fub::DepthsFn
struct	fub::ScalarState< Depths >
struct	fub::StateTraits< ScalarState< Depths > >
struct	fub::Conservative< Eq >
	This type has a constructor which takes an equation and might allocate any dynamically sized member variable. More...
struct	fub::StateTraits< Conservative< Eq > >
struct	fub::Primitive< Eq >
struct	fub::StateTraits< Primitive< Eq > >
struct	fub::KineticState< Eq >
struct	fub::StateTraits< KineticState< Eq > >
struct	fub::Characteristics< Eq >
struct	fub::StateTraits< Characteristics< Eq > >
struct	fub::Complete< Eq >
	This type has a constructor which takes an equation and might allocate any dynamically sized member variable. More...
struct	fub::StateTraits< Complete< Eq > >
struct	fub::BasicView< S, L, R >
struct	fub::StateTraits< BasicView< S, L, R > >
struct	fub::IsView< T >
struct	fub::IsView< BasicView< State, Layout, Rank > >
struct	fub::ViewPointer< State >
struct	fub::StateTraits< ViewPointer< State > >
struct	fub::IndexMapping< Equation >
struct	fub::StateTraits< IndexMapping< Eq > >

Namespaces
	fub
	The fub namespace.
	fub::meta
	The meta namespace.

Typedefs
template<typename Depth >
using	fub::ToConcreteDepth = typename ToConcreteDepthImpl< Depth >::type
template<typename Depths >
using	fub::ToConcreteDepths = boost::mp11::mp_transform< ToConcreteDepth, Depths >
template<typename T >
using	fub::meta::Depths = decltype(::fub::Depths(std::declval< typename T::Equation const & >(), Type< T >{}))
template<typename Depths >
using	fub::ScalarStateBase = boost::mp11::mp_transform< detail::DepthToStateValueType, Depths >
template<typename Equation >
using	fub::ConservativeBase = boost::mp11::mp_transform< detail::DepthToStateValueType, typename Equation::ConservativeDepths >
	This type alias transforms state depths into a conservative state associated with a specified equation. More...
template<typename Equation >
using	fub::CompleteBase = boost::mp11::mp_transform< detail::DepthToStateValueType, typename Equation::CompleteDepths >
template<typename State , typename Layout , int Rank>
using	fub::ViewBase = typename detail::ViewBaseImpl< State, Layout, Rank >::type
template<typename State , int Rank = State::Equation::Rank()>
using	fub::View = BasicView< State, layout_stride, Rank >
template<typename State >
using	fub::ViewPointerBase = typename detail::ViewPointerBaseImpl< State >::type
template<typename Equation >
using	fub::IndexMappingBase = boost::mp11::mp_transform< detail::DepthToIndexMappingType, typename Equation::CompleteDepths >

Functions
template<typename... Ts>
constexpr auto	fub::Zip (Ts &&... ts)
template<typename... Ts>
constexpr auto	fub::Unzip (const std::tuple< Ts... > &zipped)
template<std::size_t I, typename State >
constexpr decltype(auto)	fub::get (State &&x)
template<typename F , typename... Ts>
void	fub::ForEachVariable (F function, Ts &&... states)
template<typename State >
auto	fub::StateToTuple (const State &x)
template<typename S , typename L , int R>
	fub::BasicView (const BasicView< S, L, R > &) -> BasicView< S, L, R >
template<typename State , typename Layout , int Rank>
BasicView< const State, Layout, Rank >	fub::AsConst (const BasicView< State, Layout, Rank > &v)
template<typename Eq >
const Conservative< Eq > &	fub::AsCons (const Conservative< Eq > &x)
template<typename Eq >
Conservative< Eq > &	fub::AsCons (Conservative< Eq > &x)
template<typename Eq >
const ConservativeBase< Eq > &	fub::AsCons (const Complete< Eq > &x)
template<typename Eq >
ConservativeBase< Eq > &	fub::AsCons (Complete< Eq > &x)
template<typename State , typename L , int R>
auto	fub::AsCons (const BasicView< State, L, R > &view)
template<int N, typename State , typename Layout , int Rank>
dynamic_extents< static_cast< std::size_t >Rank)>	fub::Extents (const BasicView< State, Layout, Rank > &view)
template<int N, typename State , typename Layout , int Rank>
IndexBox< Rank >	fub::Box (const BasicView< State, Layout, Rank > &view)
template<int N, typename State , typename Layout , int Rank>
Layout::template mapping< dynamic_extents< static_cast< std::size_t >Rank)> >	fub::Mapping (const BasicView< State, Layout, Rank > &view)
template<typename F , typename... Ts>
void	fub::ForEachComponent (F function, Ts &&... states)
template<typename State , typename Layout , int Rank>
void	fub::Load (State &state, const BasicView< const State, Layout, Rank > &view, const std::array< std::ptrdiff_t, State::Equation::Rank()> &index)
template<typename State , typename Layout , int Rank>
void	fub::Load (State &state, const BasicView< State, Layout, Rank > &view, const std::array< std::ptrdiff_t, State::Equation::Rank()> &index)
template<typename Eq , typename Layout >
void	fub::Store (const BasicView< Conservative< Eq >, Layout, Eq::Rank()> &view, const Conservative< Eq > &state, const std::array< std::ptrdiff_t, Eq::Rank()> &index)
template<typename Eq , typename Layout >
void	fub::Store (const BasicView< Complete< Eq >, Layout, Eq::Rank()> &view, const Complete< Eq > &state, const std::array< std::ptrdiff_t, Eq::Rank()> &index)
template<Direction dir, typename T , typename L , int Rank, typename SliceSpecifier >
auto	fub::Slice (const BasicView< T, L, Rank > &view, SliceSpecifier slice)
template<typename State , int Rank, typename Layout >
View< State, Rank >	fub::Shrink (const BasicView< State, Layout, Rank > &view, Direction dir, std::array< std::ptrdiff_t, 2 > offsets)
template<typename Equation >
bool	fub::AnyNaN (const Complete< Equation > &state)
template<typename State >
	fub::ViewPointer (const ViewPointer< State > &) -> ViewPointer< State >
template<typename State >
ViewPointer< std::add_const_t< State > >	fub::AsConst (const ViewPointer< State > &p) noexcept
template<typename State , typename Layout , int Rank>
ViewPointer< State >	fub::Begin (const BasicView< State, Layout, Rank > &view)
template<typename State , typename Layout , int Rank>
ViewPointer< State >	fub::End (const BasicView< State, Layout, Rank > &view)
template<typename Eq >
void	fub::Load (Complete< Eq > &state, nodeduce_t< ViewPointer< const Complete< Eq >>> pointer)
template<typename Eq >
void	fub::Load (Conservative< Eq > &state, nodeduce_t< ViewPointer< const Conservative< Eq >>> pointer)
template<typename State >
void	fub::Advance (ViewPointer< State > &pointer, std::ptrdiff_t n) noexcept
template<typename Equation >
void	fub::CopyFromBuffer (Complete< Equation > &state, span< const double > buffer)
template<typename Equation >
void	fub::CopyFromBuffer (Conservative< Equation > &state, span< const double > buffer)
template<typename Equation >
void	fub::CopyToBuffer (span< double > buffer, const Conservative< Equation > &state)

Variables
constexpr struct fub::DepthsFn	fub::Depths