SimiLie
Loading...
Searching...
No Matches
sil::exterior Namespace Reference

Classes

class  BilinearSpatialOperatorStorage
 Cache a bilinear spatial map without freezing either operand. More...
 
struct  BilinearStencil
 Homogeneous bilinear coefficients, ordered output, first point/component, second point/component (second component varies fastest). More...
 
struct  Boundary
 
class  Chain
 Chain class. More...
 
struct  Coboundary
 
struct  Coboundary< CochainType >
 
struct  Coboundary< TagToAddToCochain, CochainTag >
 
class  Cochain
 Cochain class. More...
 
class  Cochain< tensor::Tensor< T, Domain, Layout, Memory >, ElementType, ChainLayout >
 
class  CochainIterator
 
struct  Codifferential
 
struct  Codifferential< MetricIndex, TagToRemoveFromCochain, CochainTag, TensorType, MetricType, PositionType >
 
struct  Codifferential< TagToRemoveFromCochain, CochainTag >
 Pointwise codifferential with independently supplied Hodge operators. More...
 
struct  ContinuousHodgeStar
 
class  Cosimplex
 Cosimplex class. More...
 
class  CovariantDerivative
 
struct  DiscreteHodgeStar
 Compose reconstruction, continuous Hodge star and reduction policies. More...
 
struct  DualHodgeCochain
 Lazy dual cochain obtained by applying the Hodge star to a primal one-cochain. More...
 
struct  DualSimplexVolume
 
struct  FillReconstructionOperatorMem
 
struct  FillReductionOperatorMem
 
class  Form
 Differential-form coefficients, pointwise or sampled over a spatial domain. More...
 
class  Form< double >
 
struct  GaussLegendreQuadrature
 Tensor product Gauss-Legendre rule on [0,1]^Dimension, with one, two or three points per axis (exact through degree 2*Order-1 per coordinate). More...
 
struct  IdentityTransport
 Parallel transport from the second vertex's fibre to the first one's. More...
 
struct  IndexForCodifferentialOfCoboundaryInLaplacian
 
struct  InteriorProduct
 
class  Laplacian
 Hodge Laplacian assembled from independently selected Hodge-star policies. More...
 
class  LeviCivitaContinuousHodgeStar
 Continuous Hodge star for an identity metric and the positive coordinate orientation. More...
 
class  LocalChain
 
class  LocalChainIterator
 
class  OperatorActingOnCochainInPlaceOfForm
 
class  OperatorActingOnFormInPlaceOfCochain
 
struct  Reconstruction
 
struct  Reduction
 
class  Simplex
 Simplex class. More...
 
struct  SimplexVolume
 
class  StagedOperator
 Freeze an operator's geometric coefficients using its selected storage policy. More...
 
struct  Stencil
 
struct  StencilIndex
 
struct  TransposedCoboundary
 
struct  TransposedCoboundary< TagToAddToCochain, CochainTag >
 
struct  VertexFormBilinearComposition
 Periodic vertex reconstruction, bilinear form operator, and projection. More...
 
struct  VertexFormProjection
 Project a nodally sampled differential form onto primal cochains. More...
 
class  VertexFormProjectionField
 
struct  VertexFormReconstruction
 Reconstruct a primal cochain as a differential form at a mesh vertex. More...
 
class  VertexFormReconstructionField
 
struct  VertexQuadrature
 Tensor product trapezoidal rule on the reference cube [0,1]^Dimension. More...
 
class  VertexReconstructedDerivative
 Reconstruct derivatives of nodal, flat-bundle-valued zero-cochains at the vertices of one cubical cell. More...
 
class  WeightedLeviCivitaDiscreteHodgeStar
 Discrete Hodge star for an identity metric and coordinate-aligned orthogonal cells. More...
 

Concepts

concept  CochainType
 
concept  CoboundaryConcept
 
concept  DiscreteHodgeStarConcept
 
concept  ContinuousHodgeStarConcept
 
concept  ExteriorFieldType
 
concept  OperatorInputType
 
concept  OperatorOutputType
 
concept  LocalOperatorConcept
 
concept  StagedOperatorConcept
 
concept  StagingStorageConcept
 
concept  LinearStagedOperatorConcept
 
concept  LinearStagingStorageConcept
 
concept  BilinearStagingStorageConcept
 
concept  BilinearStagedOperatorConcept
 
concept  StageableOperatorConcept
 
concept  LinearStageableOperatorConcept
 
concept  BilinearStageableOperatorConcept
 
concept  FormType
 
concept  TensorFormType
 

Typedefs

template<class T >
using boundary_t = typename detail::BoundaryType<T>::type
 
template<misc::Specialization< Cochain > CochainType>
using coboundary_t = typename detail::CoboundaryType<CochainType>::type
 
template<class TagToAddToCochain , class CochainTag >
using coboundary_index_t = typename detail::CoboundaryIndex<TagToAddToCochain, CochainTag>::type
 
template<tensor::TensorNatIndex TagToAddToCochain, tensor::TensorIndex CochainTag, CochainType TensorType>
using coboundary_tensor_t
 
template<misc::Specialization< Cochain > CochainType>
using codifferential_t = typename detail::CodifferentialType<CochainType>::type
 
template<class TagToRemoveFromCochain , class CochainTag >
using codifferential_index_t
 
template<tensor::TensorNatIndex TagToRemoveFromCochain, tensor::TensorIndex CochainTag, CochainType TensorType>
using codifferential_tensor_t
 
template<misc::Specialization< ddc::TypeSeq > Indices1, misc::Specialization< ddc::TypeSeq > Indices2>
using hodge_star_domain_t
 
template<std::size_t EndId, class T >
using codifferential_hodge_output_indices_t
 
template<misc::Specialization< ddc::TypeSeq > Indices>
using reduction_index_t = typename detail::ReductionTargetIndex<Indices>::type
 
template<misc::Specialization< ddc::TypeSeq > Indices>
using reduction_domain_t
 
template<misc::Specialization< ddc::TypeSeq > Indices>
using reconstruction_domain_t
 
template<std::size_t K, class Dom >
using simplex_for_domain_t = detail::SimplexForDomain<K, Dom>::type
 
template<class Operator , class Index , class First , class Second , class Target , class Domain , class Memory , class Exec = typename Memory::execution_space>
using BilinearLocalOperatorStorage
 
template<class Index , class Source , class Target , std::size_t Radius>
using LinearStencil = Stencil<Index, Source, Target, Radius>
 

Enumerations

enum class  CellComplex {
  Primal ,
  CircumcentricDual ,
  BarycentricDual
}
 

Functions

template<misc::Specialization< Kokkos::View > AllocationType, class SimplexType >
KOKKOS_FUNCTION Chain< boundary_t< SimplexType >, typename AllocationType::array_layout, typename AllocationType::memory_space > boundary (AllocationType allocation, SimplexType const &simplex)
 
template<class MemorySpace = Kokkos::HostSpace, class SimplexType >
KOKKOS_FUNCTION LocalChain< boundary_t< SimplexType >, Kokkos::LayoutRight, MemorySpace > boundary (SimplexType const &simplex)
 
template<misc::Specialization< Kokkos::View > AllocationType, class SimplexType >
KOKKOS_FUNCTION Chain< boundary_t< SimplexType >, typename AllocationType::array_layout, typename AllocationType::memory_space > boundary (AllocationType allocation, Chain< SimplexType, typename AllocationType::array_layout, typename AllocationType::memory_space > const &chain)
 
template<class Head , class... Tail>
 Chain (Head, Tail...) -> Chain< typename Head::value_type, typename Head::array_layout, typename Head::memory_space >
 
template<misc::Specialization< Chain > ChainType>
std::ostream & operator<< (std::ostream &out, ChainType const &chain)
 
template<misc::Specialization< Cochain > CochainType>
KOKKOS_FUNCTION coboundary_t< CochainType > coboundary (CochainType const &cochain)
 
template<tensor::TensorNatIndex TagToAddToCochain, tensor::TensorIndex CochainTag, CochainType TensorType, class ExecSpace , class ExtrapolationRules = tensor::ClampExtrapolationRule>
coboundary_tensor_t< TagToAddToCochain, CochainTag, TensorType > coboundary (ExecSpace const &exec_space, coboundary_tensor_t< TagToAddToCochain, CochainTag, TensorType > const &coboundary_tensor, TensorType const &tensor, ExtrapolationRules const &extrapolation={})
 Apply the exterior derivative with a callable cochain sampling rule.
 
template<tensor::TensorNatIndex TagToAddToCochain, tensor::TensorIndex CochainTag, CochainType TensorType, class ExecSpace , class ExtrapolationRules = tensor::ZeroExtrapolationRule>
coboundary_tensor_t< TagToAddToCochain, CochainTag, TensorType > transposed_coboundary (ExecSpace const &exec_space, coboundary_tensor_t< TagToAddToCochain, CochainTag, TensorType > const &coboundary_tensor, TensorType const &tensor, ExtrapolationRules const &extrapolation={})
 
template<tensor::TensorNatIndex TagToAddToCochain, tensor::TensorIndex CochainTag, CochainType TensorType, class ExecSpace , class ExtrapolationRules = tensor::ClampExtrapolationRule>
coboundary_tensor_t< TagToAddToCochain, CochainTag, TensorType > deriv (ExecSpace const &exec_space, coboundary_tensor_t< TagToAddToCochain, CochainTag, TensorType > const &coboundary_tensor, TensorType const &tensor, ExtrapolationRules const &extrapolation={})
 
template<misc::Specialization< tensor::Tensor > Tensor>
 Cochain (Tensor const &) -> Cochain< Tensor >
 
template<class ChainType , misc::Specialization< tensor::Tensor > TensorType>
 Cochain (ChainType, TensorType) -> Cochain< ChainType, typename TensorType::value_type, ddc::detail::mdspan_to_kokkos_layout_t< typename TensorType::layout_type > >
 
template<misc::Specialization< Cochain > CochainType>
std::ostream & operator<< (std::ostream &out, CochainType const &cochain)
 
template<tensor::TensorIndex MetricIndex, tensor::TensorNatIndex TagToRemoveFromCochain, tensor::TensorIndex CochainTag, class ExecSpace , CochainType TensorType, misc::Specialization< tensor::Tensor > MetricType, misc::Specialization< tensor::Tensor > PositionType, class Rules = tensor::ZeroExtrapolationRule>
StagedOperator< Codifferential< MetricIndex, TagToRemoveFromCochain, CochainTag, TensorType, MetricType, PositionType >, typename Codifferential< MetricIndex, TagToRemoveFromCochain, CochainTag, TensorType, MetricType, PositionType >::staged_storage_type::template rebind< ExecSpace > > make_staged_codifferential (ExecSpace const &exec_space, TensorType const &tensor, MetricType const &metric, PositionType const &position, Rules const &rules={})
 Cache Codifferential::value() at every input node.
 
template<tensor::TensorIndex MetricIndex, tensor::TensorNatIndex TagToRemoveFromCochain, tensor::TensorIndex CochainTag, CochainType DualTensorType, CochainType TensorType, misc::Specialization< tensor::Tensor > HodgeStarType, misc::Specialization< tensor::Tensor > DualHodgeStarType, class ExecSpace , class DualExtrapolationRule = tensor::ZeroExtrapolationRule>
requires ( misc::NotSpecialization<DualExtrapolationRule, tensor::Tensor> && !ExteriorFieldType<DualExtrapolationRule>)
codifferential_tensor_t< TagToRemoveFromCochain, CochainTag, TensorType > codifferential (ExecSpace const &exec_space, codifferential_tensor_t< TagToRemoveFromCochain, CochainTag, TensorType > const &codifferential_tensor, TensorType const &tensor, HodgeStarType const &hodge_star, DualHodgeStarType const &dual_hodge_star, DualTensorType const &dual_tensor_buffer, DualExtrapolationRule const &dual_extrapolation={})
 
template<tensor::TensorIndex MetricIndex, tensor::TensorNatIndex TagToRemoveFromCochain, tensor::TensorIndex CochainTag, CochainType TensorType, misc::Specialization< tensor::Tensor > MetricType, misc::Specialization< tensor::Tensor > PositionType, class ExecSpace , class DualExtrapolationRule = tensor::ZeroExtrapolationRule>
requires ( misc::NotSpecialization<DualExtrapolationRule, tensor::Tensor> && !ExteriorFieldType<DualExtrapolationRule>)
codifferential_tensor_t< TagToRemoveFromCochain, CochainTag, TensorType > codifferential (ExecSpace const &exec_space, codifferential_tensor_t< TagToRemoveFromCochain, CochainTag, TensorType > const &codifferential_tensor, TensorType const &tensor, MetricType const &metric, PositionType const &position, DualExtrapolationRule const &dual_extrapolation={})
 
template<misc::Specialization< ddc::TypeSeq > Indices1, misc::Specialization< ddc::TypeSeq > Indices2, CellComplex Complex = CellComplex::Primal, misc::Specialization< tensor::Tensor > HodgeStarType, misc::Specialization< tensor::Tensor > MetricType, misc::Specialization< tensor::Tensor > PositionType, class ExecSpace >
HodgeStarType fill_discrete_hodge_star (ExecSpace const &exec_space, HodgeStarType const &hodge_star, MetricType const &metric, PositionType const &position)
 
template<misc::Specialization< ddc::TypeSeq > Indices1, misc::Specialization< ddc::TypeSeq > Indices2, misc::Specialization< tensor::Tensor > HodgeStarType, misc::Specialization< tensor::Tensor > MetricType, class ExecSpace >
HodgeStarType fill_continuous_hodge_star (ExecSpace const &exec_space, HodgeStarType const &hodge_star, MetricType const &metric)
 
template<class Direction , class Cochain , class Position , class Geometry , class Flux >
auto make_dual_hodge_cochain (Cochain cochain, Position const &position, Geometry const &geometry_rule, Flux const &flux_rule, double diffusivity=1.0)
 Normalize single policies locally, as for the staged differential operators.
 
template<misc::Specialization< Cosimplex > CosimplexType>
std::ostream & operator<< (std::ostream &out, CosimplexType const &cosimplex)
 
template<class Coefficients >
 Form (Coefficients const &) -> Form< Coefficients >
 
template<tensor::TensorIndex Index, CochainType CochainTensor, class SimplexType >
KOKKOS_FUNCTION double integrate (CochainTensor const &cochain, SimplexType const &simplex)
 Evaluate an already reduced k-cochain on one oriented k-cell.
 
template<tensor::TensorIndex Index, class ExecSpace , CochainType CochainTensor, class ChainType >
double integrate (ExecSpace const &exec, CochainTensor const &cochain, ChainType const &chain)
 Pair a reduced k-cochain with an oriented k-chain: <c, C> = sum s_i c_i.
 
template<misc::Specialization< ddc::TypeSeq > Indices, FormType Form, class Position , class SimplexType >
KOKKOS_FUNCTION double integrate (Form const &form, Position const &position, SimplexType const &simplex)
 Reduce a physical differential form, then evaluate it on an oriented cell.
 
template<misc::Specialization< ddc::TypeSeq > Indices, class ExecSpace , FormType Form, class Position , class ChainType >
double integrate (ExecSpace const &exec, Form const &form, Position const &position, ChainType const &chain)
 Reduce a physical form and pair it with a chain without storing a cochain.
 
template<tensor::TensorIndex MetricIndex, tensor::TensorNatIndex Index, tensor::TensorIndex Cochain, template< CellComplex, class, class, class, class, class > class Hodge = DiscreteHodgeStar, class Exec , CochainType Tensor, class Metric , class Position >
Laplacian< MetricIndex, Index, Cochain, Tensor, Metric, Position, Exec, Hodge > make_laplacian (Exec const &exec, Tensor const &output, Tensor const &input, Metric const &metric, Position const &position)
 
template<tensor::TensorIndex MetricIndex, tensor::TensorNatIndex LaplacianDummyIndex, tensor::TensorIndex CochainTag, CochainType TensorType, misc::Specialization< tensor::Tensor > DerivativeHodgeStarType, misc::Specialization< tensor::Tensor > DualDerivativeHodgeStarType, CochainType DerivativeDualTensorBufferType, class ExecSpace , class PrimalExtrapolationRule = tensor::ClampExtrapolationRule, class DualExtrapolationRule = tensor::ZeroExtrapolationRule>
requires (detail::ZeroRankLaplacianCochain<LaplacianDummyIndex, CochainTag>)
TensorType laplacian (ExecSpace const &exec_space, TensorType const &laplacian_tensor, TensorType const &tensor, DerivativeHodgeStarType const &hodge_star, DualDerivativeHodgeStarType const &dual_hodge_star, DerivativeDualTensorBufferType const &dual_tensor_buffer, PrimalExtrapolationRule const &primal_extrapolation={}, DualExtrapolationRule const &dual_extrapolation={})
 
template<tensor::TensorIndex MetricIndex, tensor::TensorNatIndex LaplacianDummyIndex, tensor::TensorIndex CochainTag, CochainType TensorType, misc::Specialization< tensor::Tensor > DerivativeHodgeStarType, misc::Specialization< tensor::Tensor > DualDerivativeHodgeStarType, CochainType DerivativeDualTensorBufferType, misc::Specialization< tensor::Tensor > HodgeStarType, misc::Specialization< tensor::Tensor > DualHodgeStarType, CochainType DualTensorBufferType, CochainType CodifferentialTensorBufferType, CochainType CoboundaryOfCodifferentialBufferType, class ExecSpace , class PrimalExtrapolationRule = tensor::ClampExtrapolationRule, class DualExtrapolationRule = tensor::ZeroExtrapolationRule>
requires (detail::IntermediateRankLaplacianCochain<LaplacianDummyIndex, CochainTag>)
TensorType laplacian (ExecSpace const &exec_space, TensorType const &laplacian_tensor, TensorType const &tensor, DerivativeHodgeStarType const &derivative_hodge_star, DualDerivativeHodgeStarType const &dual_derivative_hodge_star, DerivativeDualTensorBufferType const &derivative_dual_tensor_buffer, HodgeStarType const &hodge_star, DualHodgeStarType const &dual_hodge_star, DualTensorBufferType const &dual_tensor_buffer, CodifferentialTensorBufferType const &codifferential_tensor_buffer, CoboundaryOfCodifferentialBufferType const &coboundary_of_codifferential_buffer, PrimalExtrapolationRule const &primal_extrapolation={}, DualExtrapolationRule const &dual_extrapolation={})
 
template<tensor::TensorIndex MetricIndex, tensor::TensorNatIndex LaplacianDummyIndex, tensor::TensorIndex CochainTag, CochainType TensorType, misc::Specialization< tensor::Tensor > HodgeStarType, misc::Specialization< tensor::Tensor > DualHodgeStarType, CochainType DualTensorBufferType, CochainType CodifferentialTensorBufferType, class ExecSpace , class PrimalExtrapolationRule = tensor::ClampExtrapolationRule, class DualExtrapolationRule = tensor::ZeroExtrapolationRule>
requires (detail::TopRankLaplacianCochain<LaplacianDummyIndex, CochainTag>)
TensorType laplacian (ExecSpace const &exec_space, TensorType const &laplacian_tensor, TensorType const &tensor, HodgeStarType const &hodge_star, DualHodgeStarType const &dual_hodge_star, DualTensorBufferType const &dual_tensor_buffer, CodifferentialTensorBufferType const &codifferential_tensor_buffer, PrimalExtrapolationRule const &primal_extrapolation={}, DualExtrapolationRule const &dual_extrapolation={})
 
template<std::size_t K, misc::Specialization< ddc::DiscreteDomain > Dom, class MemorySpace = Kokkos::HostSpace, misc::Specialization< ddc::DiscreteElement > Elem>
KOKKOS_FUNCTION constexpr auto tangent_basis (Elem elem)
 
template<std::size_t K, misc::Specialization< ddc::DiscreteDomain > Dom, class ExecSpace >
requires (misc::NotSpecialization<ExecSpace, ddc::DiscreteElement>)
KOKKOS_FUNCTION constexpr auto tangent_basis (ExecSpace const &exec_space)
 
template<misc::Specialization< Kokkos::View > AllocationType, class SimplexType , class... T>
 LocalChain (AllocationType, SimplexType, T...) -> LocalChain< std::remove_cvref_t< SimplexType >, typename AllocationType::array_layout, typename AllocationType::memory_space >
 
template<class Rule , class Evaluator , class Measure >
KOKKOS_FUNCTION double quadrature (Rule const &rule, Evaluator const &evaluator, Measure const &measure)
 Integrate a scalar evaluator with an independent reference-cell rule.
 
template<class Rule , class Measure , class TrialResponse , class Pairing , class Accumulate >
KOKKOS_FUNCTION void assemble_bilinear_form (Rule const &rule, std::size_t trial_count, std::size_t test_count, Measure const &measure, TrialResponse const &response, Pairing const &pairing, Accumulate const &accumulate)
 Assemble a local bilinear form from independently evaluated trial responses and test functions.
 
template<misc::Specialization< ddc::TypeSeq > Indices, misc::Specialization< tensor::Tensor > ReductionTensorType, misc::Specialization< tensor::Tensor > PositionType, class ExecSpace , CellComplex Complex = CellComplex::Primal>
ReductionTensorType fill_reduction_operator (ExecSpace const &exec_space, ReductionTensorType const &reduction_tensor, PositionType const &position)
 
template<misc::Specialization< ddc::TypeSeq > Indices, misc::Specialization< tensor::Tensor > ReconstructionTensorType, misc::Specialization< tensor::Tensor > PositionType, class ExecSpace , CellComplex Complex = CellComplex::Primal>
ReconstructionTensorType fill_reconstruction_operator (ExecSpace const &exec_space, ReconstructionTensorType const &reconstruction_tensor, PositionType const &position)
 
template<class... Tag, class... T>
 Simplex (ddc::DiscreteElement< Tag... >, ddc::DiscreteVector< T... >) -> Simplex< sizeof...(T), Tag... >
 
template<class... Tag, class... T>
 Simplex (ddc::DiscreteElement< Tag... >, ddc::DiscreteVector< T... >, bool) -> Simplex< sizeof...(T), Tag... >
 
template<std::size_t K, class... Tag>
std::ostream & operator<< (std::ostream &out, Simplex< K, Tag... > const &simplex)
 
template<class Index , class Source , class Target , std::size_t Radius>
KOKKOS_FUNCTION constexpr StencilIndex< Index::size()> stencil_reindex (std::size_t flat)
 Decode the standard ordering: output component, spatial point, input component.
 
template<class Index , class Source , class Target , std::size_t Radius>
KOKKOS_FUNCTION constexpr std::size_t stencil_flatten (StencilIndex< Index::size()> index)
 

Variables

template<TensorFormType T>
constexpr std::size_t form_degree_v = detail::FormDegree<typename T::indices_domain_t>::value
 

Class Documentation

◆ sil::exterior::Coboundary

struct sil::exterior::Coboundary
template<class... Args>
struct sil::exterior::Coboundary< Args >

Definition at line 148 of file coboundary.hpp.

Collaboration diagram for sil::exterior::Coboundary< Args >:
Collaboration graph

◆ sil::exterior::Codifferential

struct sil::exterior::Codifferential
template<class... Args>
struct sil::exterior::Codifferential< Args >

Definition at line 121 of file codifferential.hpp.

Collaboration diagram for sil::exterior::Codifferential< Args >:
Collaboration graph

◆ sil::exterior::Stencil

struct sil::exterior::Stencil
template<class Index, class Source, class Target, std::size_t Radius>
struct sil::exterior::Stencil< Index, Source, Target, Radius >

Definition at line 26 of file stencil.hpp.

Collaboration diagram for sil::exterior::Stencil< Index, Source, Target, Radius >:
Collaboration graph
Class Members
size > weights {}
array< double, mem_size()> offset {}
array< double, mem_size() *mem_size()> constant_response {}
bool complete = true

◆ sil::exterior::StencilIndex

struct sil::exterior::StencilIndex
template<std::size_t Dimensions>
struct sil::exterior::StencilIndex< Dimensions >

Definition at line 15 of file stencil_indices.hpp.

Collaboration diagram for sil::exterior::StencilIndex< Dimensions >:
Collaboration graph
Class Members
size_t output_component
array< int, Dimensions > spatial_offset
size_t input_component

◆ sil::exterior::TransposedCoboundary

struct sil::exterior::TransposedCoboundary
template<class... Args>
struct sil::exterior::TransposedCoboundary< Args >

Definition at line 151 of file coboundary.hpp.

Collaboration diagram for sil::exterior::TransposedCoboundary< Args >:
Collaboration graph

◆ sil::exterior::VertexFormBilinearComposition

struct sil::exterior::VertexFormBilinearComposition
template<class Operator, class First, class Second, class Target, class Domain, class Memory, class InverseMetric>
struct sil::exterior::VertexFormBilinearComposition< Operator, First, Second, Target, Domain, Memory, InverseMetric >

Periodic vertex reconstruction, bilinear form operator, and projection.

Coefficients come from the canonical vertex transfers. Application keeps their factorization and evaluates the supplied form operator locally. Geometry and metric must remain unchanged; output must not alias an input.

Important
This operator and documentation is fully AI-generated.

Definition at line 161 of file staged_vertex_form_composition.hpp.

Collaboration diagram for sil::exterior::VertexFormBilinearComposition< Operator, First, Second, Target, Domain, Memory, InverseMetric >:
Collaboration graph
Class Members
typedef Storage staged_storage_type Storage

Typedef Documentation

◆ boundary_t

template<class T >
using sil::exterior::boundary_t = typename detail::BoundaryType<T>::type

Definition at line 39 of file boundary.hpp.

◆ coboundary_t

template<misc::Specialization< Cochain > CochainType>
using sil::exterior::coboundary_t = typename detail::CoboundaryType<CochainType>::type

Definition at line 60 of file coboundary.hpp.

◆ coboundary_index_t

template<class TagToAddToCochain , class CochainTag >
using sil::exterior::coboundary_index_t = typename detail::CoboundaryIndex<TagToAddToCochain, CochainTag>::type

Definition at line 90 of file coboundary.hpp.

◆ coboundary_tensor_t

template<tensor::TensorNatIndex TagToAddToCochain, tensor::TensorIndex CochainTag, CochainType TensorType>
using sil::exterior::coboundary_tensor_t
Initial value:
typename detail::CoboundaryTensorType<TagToAddToCochain, CochainTag, TensorType>::type

Definition at line 116 of file coboundary.hpp.

◆ codifferential_t

template<misc::Specialization< Cochain > CochainType>
using sil::exterior::codifferential_t = typename detail::CodifferentialType<CochainType>::type

Definition at line 55 of file codifferential.hpp.

◆ codifferential_index_t

template<class TagToRemoveFromCochain , class CochainTag >
using sil::exterior::codifferential_index_t
Initial value:
typename detail::CodifferentialIndex<TagToRemoveFromCochain, CochainTag>::type

Definition at line 89 of file codifferential.hpp.

◆ codifferential_tensor_t

template<tensor::TensorNatIndex TagToRemoveFromCochain, tensor::TensorIndex CochainTag, CochainType TensorType>
using sil::exterior::codifferential_tensor_t
Initial value:
typename detail::
CodifferentialTensorType<TagToRemoveFromCochain, CochainTag, TensorType>::type

Definition at line 116 of file codifferential.hpp.

◆ hodge_star_domain_t

template<misc::Specialization< ddc::TypeSeq > Indices1, misc::Specialization< ddc::TypeSeq > Indices2>
using sil::exterior::hodge_star_domain_t
Initial value:
ddc::detail::convert_type_seq_to_discrete_domain_t<ddc::type_seq_merge_t<
ddc::TypeSeq<misc::convert_type_seq_to_t<tensor::TensorFullIndex, Indices1>>,
std::conditional_t<
(ddc::type_seq_size_v<Indices2> == 0),
ddc::TypeSeq<>,
ddc::TypeSeq<misc::convert_type_seq_to_t<
tensor::TensorAntisymmetricIndex,
Indices2>>>>>

Definition at line 32 of file continuous_hodge_star.hpp.

◆ codifferential_hodge_output_indices_t

template<std::size_t EndId, class T >
using sil::exterior::codifferential_hodge_output_indices_t
Initial value:
typename detail::CodifferentialHodgeOutputIndexSeq<EndId, T>::type

Definition at line 487 of file continuous_hodge_star.hpp.

◆ reduction_index_t

template<misc::Specialization< ddc::TypeSeq > Indices>
using sil::exterior::reduction_index_t = typename detail::ReductionTargetIndex<Indices>::type

Definition at line 352 of file reduction_and_reconstruction.hpp.

◆ reduction_domain_t

template<misc::Specialization< ddc::TypeSeq > Indices>
using sil::exterior::reduction_domain_t
Initial value:
ddc::detail::convert_type_seq_to_discrete_domain_t<ddc::type_seq_merge_t<
ddc::TypeSeq<misc::convert_type_seq_to_t<
tensor::TensorFullIndex,
tensor::primes<tensor::upper_t<Indices>>>>,
ddc::TypeSeq<reduction_index_t<Indices>>>>

Definition at line 355 of file reduction_and_reconstruction.hpp.

◆ reconstruction_domain_t

template<misc::Specialization< ddc::TypeSeq > Indices>
using sil::exterior::reconstruction_domain_t
Initial value:
ddc::detail::convert_type_seq_to_discrete_domain_t<ddc::type_seq_merge_t<
ddc::TypeSeq<reduction_index_t<Indices>>,
ddc::TypeSeq<reduction_index_t<tensor::primes<Indices>>>>>

Definition at line 362 of file reduction_and_reconstruction.hpp.

◆ simplex_for_domain_t

template<std::size_t K, class Dom >
using sil::exterior::simplex_for_domain_t = detail::SimplexForDomain<K, Dom>::type

Definition at line 238 of file simplex.hpp.

◆ BilinearLocalOperatorStorage

template<class Operator , class Index , class First , class Second , class Target , class Domain , class Memory , class Exec = typename Memory::execution_space>
using sil::exterior::BilinearLocalOperatorStorage
Initial value:
BilinearSpatialOperatorStorage<
Operator,
Index,
First,
Second,
Target,
0,
0,
Domain,
Memory,
Exec>

Definition at line 228 of file bilinear_operator_storage.hpp.

◆ LinearStencil

template<class Index , class Source , class Target , std::size_t Radius>
using sil::exterior::LinearStencil = Stencil<Index, Source, Target, Radius>

Definition at line 39 of file stencil.hpp.

Enumeration Type Documentation

◆ CellComplex

enum class sil::exterior::CellComplex
strong
Enumerator
Primal 
CircumcentricDual 
BarycentricDual 

Definition at line 21 of file volume.hpp.

Function Documentation

◆ boundary() [1/3]

template<misc::Specialization< Kokkos::View > AllocationType, class SimplexType >
KOKKOS_FUNCTION Chain< boundary_t< SimplexType >, typename AllocationType::array_layout, typename AllocationType::memory_space > sil::exterior::boundary ( AllocationType allocation,
SimplexType const & simplex )

Definition at line 170 of file boundary.hpp.

◆ boundary() [2/3]

template<class MemorySpace = Kokkos::HostSpace, class SimplexType >
KOKKOS_FUNCTION LocalChain< boundary_t< SimplexType >, Kokkos::LayoutRight, MemorySpace > sil::exterior::boundary ( SimplexType const & simplex)

Definition at line 176 of file boundary.hpp.

◆ boundary() [3/3]

template<misc::Specialization< Kokkos::View > AllocationType, class SimplexType >
KOKKOS_FUNCTION Chain< boundary_t< SimplexType >, typename AllocationType::array_layout, typename AllocationType::memory_space > sil::exterior::boundary ( AllocationType allocation,
Chain< SimplexType, typename AllocationType::array_layout, typename AllocationType::memory_space > const & chain )

Definition at line 197 of file boundary.hpp.

◆ Chain()

template<class Head , class... Tail>
sil::exterior::Chain ( Head ,
Tail...  ) -> Chain< typename Head::value_type, typename Head::array_layout, typename Head::memory_space >

◆ operator<<() [1/4]

template<misc::Specialization< Chain > ChainType>
std::ostream & sil::exterior::operator<< ( std::ostream & out,
ChainType const & chain )

Definition at line 304 of file chain.hpp.

◆ coboundary() [1/2]

template<misc::Specialization< Cochain > CochainType>
KOKKOS_FUNCTION coboundary_t< CochainType > sil::exterior::coboundary ( CochainType const & cochain)

Definition at line 508 of file coboundary.hpp.

◆ coboundary() [2/2]

template<tensor::TensorNatIndex TagToAddToCochain, tensor::TensorIndex CochainTag, CochainType TensorType, class ExecSpace , class ExtrapolationRules = tensor::ClampExtrapolationRule>
coboundary_tensor_t< TagToAddToCochain, CochainTag, TensorType > sil::exterior::coboundary ( ExecSpace const & exec_space,
coboundary_tensor_t< TagToAddToCochain, CochainTag, TensorType > const & coboundary_tensor,
TensorType const & tensor,
ExtrapolationRules const & extrapolation = {} )

Apply the exterior derivative with a callable cochain sampling rule.

A single rule is automatically broadcast to both sides of every non-index dimension; an ExtrapolationRules policy retains its per-boundary selection. Exterior rules are invoked as rule(tensor, sampled_element) and return a pointwise Tensor containing every stored component, while interior samples retain their stored values. Rules must be copyable and callable in ExecSpace. The output domain selects where to evaluate d; the input domain selects which samples require extrapolation. The same contract applies to deriv(), transposed_coboundary(), and the primal and dual stages of laplacian(); codifferential() accepts a rule for its dual Hodge field.

Important
This documentation is fully AI-generated.

Definition at line 532 of file coboundary.hpp.

◆ transposed_coboundary()

template<tensor::TensorNatIndex TagToAddToCochain, tensor::TensorIndex CochainTag, CochainType TensorType, class ExecSpace , class ExtrapolationRules = tensor::ZeroExtrapolationRule>
coboundary_tensor_t< TagToAddToCochain, CochainTag, TensorType > sil::exterior::transposed_coboundary ( ExecSpace const & exec_space,
coboundary_tensor_t< TagToAddToCochain, CochainTag, TensorType > const & coboundary_tensor,
TensorType const & tensor,
ExtrapolationRules const & extrapolation = {} )

Definition at line 586 of file coboundary.hpp.

◆ deriv()

template<tensor::TensorNatIndex TagToAddToCochain, tensor::TensorIndex CochainTag, CochainType TensorType, class ExecSpace , class ExtrapolationRules = tensor::ClampExtrapolationRule>
coboundary_tensor_t< TagToAddToCochain, CochainTag, TensorType > sil::exterior::deriv ( ExecSpace const & exec_space,
coboundary_tensor_t< TagToAddToCochain, CochainTag, TensorType > const & coboundary_tensor,
TensorType const & tensor,
ExtrapolationRules const & extrapolation = {} )

Definition at line 640 of file coboundary.hpp.

◆ Cochain() [1/2]

template<misc::Specialization< tensor::Tensor > Tensor>
sil::exterior::Cochain ( Tensor const & ) -> Cochain< Tensor >

◆ Cochain() [2/2]

template<class ChainType , misc::Specialization< tensor::Tensor > TensorType>
sil::exterior::Cochain ( ChainType ,
TensorType  ) -> Cochain< ChainType, typename TensorType::value_type, ddc::detail::mdspan_to_kokkos_layout_t< typename TensorType::layout_type > >

◆ operator<<() [2/4]

template<misc::Specialization< Cochain > CochainType>
std::ostream & sil::exterior::operator<< ( std::ostream & out,
CochainType const & cochain )

Definition at line 408 of file cochain.hpp.

◆ make_staged_codifferential()

template<tensor::TensorIndex MetricIndex, tensor::TensorNatIndex TagToRemoveFromCochain, tensor::TensorIndex CochainTag, class ExecSpace , CochainType TensorType, misc::Specialization< tensor::Tensor > MetricType, misc::Specialization< tensor::Tensor > PositionType, class Rules = tensor::ZeroExtrapolationRule>
StagedOperator< Codifferential< MetricIndex, TagToRemoveFromCochain, CochainTag, TensorType, MetricType, PositionType >, typename Codifferential< MetricIndex, TagToRemoveFromCochain, CochainTag, TensorType, MetricType, PositionType >::staged_storage_type::template rebind< ExecSpace > > sil::exterior::make_staged_codifferential ( ExecSpace const & exec_space,
TensorType const & tensor,
MetricType const & metric,
PositionType const & position,
Rules const & rules = {} )

Cache Codifferential::value() at every input node.

Important
This operator and documentation is fully AI-generated. A fixed stencil stores all component couplings and affine boundary terms. Its Manhattan radius is one (seven spatial points in three dimensions). Closures that sample outside this support are rejected during construction. Geometry and the dual closure are fixed at construction. Application only contracts the stored stencil with the current cochain values.

Definition at line 591 of file codifferential.hpp.

◆ codifferential() [1/2]

template<tensor::TensorIndex MetricIndex, tensor::TensorNatIndex TagToRemoveFromCochain, tensor::TensorIndex CochainTag, CochainType DualTensorType, CochainType TensorType, misc::Specialization< tensor::Tensor > HodgeStarType, misc::Specialization< tensor::Tensor > DualHodgeStarType, class ExecSpace , class DualExtrapolationRule = tensor::ZeroExtrapolationRule>
requires ( misc::NotSpecialization<DualExtrapolationRule, tensor::Tensor> && !ExteriorFieldType<DualExtrapolationRule>)
codifferential_tensor_t< TagToRemoveFromCochain, CochainTag, TensorType > sil::exterior::codifferential ( ExecSpace const & exec_space,
codifferential_tensor_t< TagToRemoveFromCochain, CochainTag, TensorType > const & codifferential_tensor,
TensorType const & tensor,
HodgeStarType const & hodge_star,
DualHodgeStarType const & dual_hodge_star,
DualTensorType const & dual_tensor_buffer,
DualExtrapolationRule const & dual_extrapolation = {} )

Definition at line 629 of file codifferential.hpp.

◆ codifferential() [2/2]

template<tensor::TensorIndex MetricIndex, tensor::TensorNatIndex TagToRemoveFromCochain, tensor::TensorIndex CochainTag, CochainType TensorType, misc::Specialization< tensor::Tensor > MetricType, misc::Specialization< tensor::Tensor > PositionType, class ExecSpace , class DualExtrapolationRule = tensor::ZeroExtrapolationRule>
requires ( misc::NotSpecialization<DualExtrapolationRule, tensor::Tensor> && !ExteriorFieldType<DualExtrapolationRule>)
codifferential_tensor_t< TagToRemoveFromCochain, CochainTag, TensorType > sil::exterior::codifferential ( ExecSpace const & exec_space,
codifferential_tensor_t< TagToRemoveFromCochain, CochainTag, TensorType > const & codifferential_tensor,
TensorType const & tensor,
MetricType const & metric,
PositionType const & position,
DualExtrapolationRule const & dual_extrapolation = {} )

Definition at line 703 of file codifferential.hpp.

◆ fill_discrete_hodge_star()

template<misc::Specialization< ddc::TypeSeq > Indices1, misc::Specialization< ddc::TypeSeq > Indices2, CellComplex Complex = CellComplex::Primal, misc::Specialization< tensor::Tensor > HodgeStarType, misc::Specialization< tensor::Tensor > MetricType, misc::Specialization< tensor::Tensor > PositionType, class ExecSpace >
HodgeStarType sil::exterior::fill_discrete_hodge_star ( ExecSpace const & exec_space,
HodgeStarType const & hodge_star,
MetricType const & metric,
PositionType const & position )

Definition at line 370 of file continuous_hodge_star.hpp.

◆ fill_continuous_hodge_star()

template<misc::Specialization< ddc::TypeSeq > Indices1, misc::Specialization< ddc::TypeSeq > Indices2, misc::Specialization< tensor::Tensor > HodgeStarType, misc::Specialization< tensor::Tensor > MetricType, class ExecSpace >
HodgeStarType sil::exterior::fill_continuous_hodge_star ( ExecSpace const & exec_space,
HodgeStarType const & hodge_star,
MetricType const & metric )

Definition at line 419 of file continuous_hodge_star.hpp.

◆ make_dual_hodge_cochain()

template<class Direction , class Cochain , class Position , class Geometry , class Flux >
auto sil::exterior::make_dual_hodge_cochain ( Cochain cochain,
Position const & position,
Geometry const & geometry_rule,
Flux const & flux_rule,
double diffusivity = 1.0 )

Normalize single policies locally, as for the staged differential operators.

Important
This operator and documentation is fully AI-generated.

Definition at line 959 of file continuous_hodge_star.hpp.

◆ operator<<() [3/4]

template<misc::Specialization< Cosimplex > CosimplexType>
std::ostream & sil::exterior::operator<< ( std::ostream & out,
CosimplexType const & cosimplex )

Definition at line 114 of file cosimplex.hpp.

◆ Form()

template<class Coefficients >
sil::exterior::Form ( Coefficients const & ) -> Form< Coefficients >

◆ integrate() [1/4]

template<tensor::TensorIndex Index, CochainType CochainTensor, class SimplexType >
KOKKOS_FUNCTION double sil::exterior::integrate ( CochainTensor const & cochain,
SimplexType const & simplex )

Evaluate an already reduced k-cochain on one oriented k-cell.

Important
This operator and documentation is fully AI-generated.

The tensor stores integrals on positively oriented cells, not physical components. The cell's active logical directions select its coefficient; its orientation supplies the sign. Logical axes must follow the same order in the cell and the cochain index. No metric or cell measure is applied here.

Definition at line 51 of file integration.hpp.

◆ integrate() [2/4]

template<tensor::TensorIndex Index, class ExecSpace , CochainType CochainTensor, class ChainType >
double sil::exterior::integrate ( ExecSpace const & exec,
CochainTensor const & cochain,
ChainType const & chain )

Pair a reduced k-cochain with an oriented k-chain: <c, C> = sum s_i c_i.

Important
This operator and documentation is fully AI-generated.

This is DEC integration. In particular, integrating df over C equals integrating f over the boundary of C. An empty chain integrates to zero. The execution space must be able to access both the chain and the tensor.

Definition at line 67 of file integration.hpp.

◆ integrate() [3/4]

template<misc::Specialization< ddc::TypeSeq > Indices, FormType Form, class Position , class SimplexType >
KOKKOS_FUNCTION double sil::exterior::integrate ( Form const & form,
Position const & position,
SimplexType const & simplex )

Reduce a physical differential form, then evaluate it on an oriented cell.

Important
This operator and documentation is fully AI-generated.

Reduction owns the geometric pullback and its sampling convention. This overload adds no quadrature rule. Use the cochain overload when reduction has already been performed, to avoid applying cell measures twice.

Definition at line 96 of file integration.hpp.

◆ integrate() [4/4]

template<misc::Specialization< ddc::TypeSeq > Indices, class ExecSpace , FormType Form, class Position , class ChainType >
double sil::exterior::integrate ( ExecSpace const & exec,
Form const & form,
Position const & position,
ChainType const & chain )

Reduce a physical form and pair it with a chain without storing a cochain.

Important
This operator and documentation is fully AI-generated.

Definition at line 143 of file integration.hpp.

◆ make_laplacian()

template<tensor::TensorIndex MetricIndex, tensor::TensorNatIndex Index, tensor::TensorIndex Cochain, template< CellComplex, class, class, class, class, class > class Hodge = DiscreteHodgeStar, class Exec , CochainType Tensor, class Metric , class Position >
Laplacian< MetricIndex, Index, Cochain, Tensor, Metric, Position, Exec, Hodge > sil::exterior::make_laplacian ( Exec const & exec,
Tensor const & output,
Tensor const & input,
Metric const & metric,
Position const & position )

Definition at line 855 of file exterior/laplacian/laplacian.hpp.

◆ laplacian() [1/3]

template<tensor::TensorIndex MetricIndex, tensor::TensorNatIndex LaplacianDummyIndex, tensor::TensorIndex CochainTag, CochainType TensorType, misc::Specialization< tensor::Tensor > DerivativeHodgeStarType, misc::Specialization< tensor::Tensor > DualDerivativeHodgeStarType, CochainType DerivativeDualTensorBufferType, class ExecSpace , class PrimalExtrapolationRule = tensor::ClampExtrapolationRule, class DualExtrapolationRule = tensor::ZeroExtrapolationRule>
requires (detail::ZeroRankLaplacianCochain<LaplacianDummyIndex, CochainTag>)
TensorType sil::exterior::laplacian ( ExecSpace const & exec_space,
TensorType const & laplacian_tensor,
TensorType const & tensor,
DerivativeHodgeStarType const & hodge_star,
DualDerivativeHodgeStarType const & dual_hodge_star,
DerivativeDualTensorBufferType const & dual_tensor_buffer,
PrimalExtrapolationRule const & primal_extrapolation = {},
DualExtrapolationRule const & dual_extrapolation = {} )

Definition at line 1033 of file exterior/laplacian/laplacian.hpp.

◆ laplacian() [2/3]

template<tensor::TensorIndex MetricIndex, tensor::TensorNatIndex LaplacianDummyIndex, tensor::TensorIndex CochainTag, CochainType TensorType, misc::Specialization< tensor::Tensor > DerivativeHodgeStarType, misc::Specialization< tensor::Tensor > DualDerivativeHodgeStarType, CochainType DerivativeDualTensorBufferType, misc::Specialization< tensor::Tensor > HodgeStarType, misc::Specialization< tensor::Tensor > DualHodgeStarType, CochainType DualTensorBufferType, CochainType CodifferentialTensorBufferType, CochainType CoboundaryOfCodifferentialBufferType, class ExecSpace , class PrimalExtrapolationRule = tensor::ClampExtrapolationRule, class DualExtrapolationRule = tensor::ZeroExtrapolationRule>
requires (detail::IntermediateRankLaplacianCochain<LaplacianDummyIndex, CochainTag>)
TensorType sil::exterior::laplacian ( ExecSpace const & exec_space,
TensorType const & laplacian_tensor,
TensorType const & tensor,
DerivativeHodgeStarType const & derivative_hodge_star,
DualDerivativeHodgeStarType const & dual_derivative_hodge_star,
DerivativeDualTensorBufferType const & derivative_dual_tensor_buffer,
HodgeStarType const & hodge_star,
DualHodgeStarType const & dual_hodge_star,
DualTensorBufferType const & dual_tensor_buffer,
CodifferentialTensorBufferType const & codifferential_tensor_buffer,
CoboundaryOfCodifferentialBufferType const & coboundary_of_codifferential_buffer,
PrimalExtrapolationRule const & primal_extrapolation = {},
DualExtrapolationRule const & dual_extrapolation = {} )

Definition at line 1077 of file exterior/laplacian/laplacian.hpp.

◆ laplacian() [3/3]

template<tensor::TensorIndex MetricIndex, tensor::TensorNatIndex LaplacianDummyIndex, tensor::TensorIndex CochainTag, CochainType TensorType, misc::Specialization< tensor::Tensor > HodgeStarType, misc::Specialization< tensor::Tensor > DualHodgeStarType, CochainType DualTensorBufferType, CochainType CodifferentialTensorBufferType, class ExecSpace , class PrimalExtrapolationRule = tensor::ClampExtrapolationRule, class DualExtrapolationRule = tensor::ZeroExtrapolationRule>
requires (detail::TopRankLaplacianCochain<LaplacianDummyIndex, CochainTag>)
TensorType sil::exterior::laplacian ( ExecSpace const & exec_space,
TensorType const & laplacian_tensor,
TensorType const & tensor,
HodgeStarType const & hodge_star,
DualHodgeStarType const & dual_hodge_star,
DualTensorBufferType const & dual_tensor_buffer,
CodifferentialTensorBufferType const & codifferential_tensor_buffer,
PrimalExtrapolationRule const & primal_extrapolation = {},
DualExtrapolationRule const & dual_extrapolation = {} )

Definition at line 1153 of file exterior/laplacian/laplacian.hpp.

◆ tangent_basis() [1/2]

template<std::size_t K, misc::Specialization< ddc::DiscreteDomain > Dom, class MemorySpace = Kokkos::HostSpace, misc::Specialization< ddc::DiscreteElement > Elem>
KOKKOS_FUNCTION constexpr auto sil::exterior::tangent_basis ( Elem elem)
constexpr

Definition at line 444 of file local_chain.hpp.

◆ tangent_basis() [2/2]

template<std::size_t K, misc::Specialization< ddc::DiscreteDomain > Dom, class ExecSpace >
requires (misc::NotSpecialization<ExecSpace, ddc::DiscreteElement>)
KOKKOS_FUNCTION constexpr auto sil::exterior::tangent_basis ( ExecSpace const & exec_space)
constexpr

Definition at line 451 of file local_chain.hpp.

◆ LocalChain()

template<misc::Specialization< Kokkos::View > AllocationType, class SimplexType , class... T>
sil::exterior::LocalChain ( AllocationType ,
SimplexType ,
T...  ) -> LocalChain< std::remove_cvref_t< SimplexType >, typename AllocationType::array_layout, typename AllocationType::memory_space >

◆ quadrature()

template<class Rule , class Evaluator , class Measure >
KOKKOS_FUNCTION double sil::exterior::quadrature ( Rule const & rule,
Evaluator const & evaluator,
Measure const & measure )
nodiscard

Integrate a scalar evaluator with an independent reference-cell rule.

Important
This operator and documentation is fully AI-generated. evaluator(point, sample) supplies the reconstructed integrand, while measure(point, sample) supplies the physical volume Jacobian. Neither is inferred from the other. The sample number allows cached reconstructions; evaluators at arbitrary points can ignore it.

Definition at line 93 of file quadrature.hpp.

◆ assemble_bilinear_form()

template<class Rule , class Measure , class TrialResponse , class Pairing , class Accumulate >
KOKKOS_FUNCTION void sil::exterior::assemble_bilinear_form ( Rule const & rule,
std::size_t trial_count,
std::size_t test_count,
Measure const & measure,
TrialResponse const & response,
Pairing const & pairing,
Accumulate const & accumulate )

Assemble a local bilinear form from independently evaluated trial responses and test functions.

The callback decides how local entries are accumulated.

Important
This operator and documentation is fully AI-generated.

Definition at line 110 of file quadrature.hpp.

◆ fill_reduction_operator()

template<misc::Specialization< ddc::TypeSeq > Indices, misc::Specialization< tensor::Tensor > ReductionTensorType, misc::Specialization< tensor::Tensor > PositionType, class ExecSpace , CellComplex Complex = CellComplex::Primal>
ReductionTensorType sil::exterior::fill_reduction_operator ( ExecSpace const & exec_space,
ReductionTensorType const & reduction_tensor,
PositionType const & position )

Definition at line 917 of file reduction_and_reconstruction.hpp.

◆ fill_reconstruction_operator()

template<misc::Specialization< ddc::TypeSeq > Indices, misc::Specialization< tensor::Tensor > ReconstructionTensorType, misc::Specialization< tensor::Tensor > PositionType, class ExecSpace , CellComplex Complex = CellComplex::Primal>
ReconstructionTensorType sil::exterior::fill_reconstruction_operator ( ExecSpace const & exec_space,
ReconstructionTensorType const & reconstruction_tensor,
PositionType const & position )

Definition at line 1265 of file reduction_and_reconstruction.hpp.

◆ Simplex() [1/2]

template<class... Tag, class... T>
sil::exterior::Simplex ( ddc::DiscreteElement< Tag... > ,
ddc::DiscreteVector< T... >  ) -> Simplex< sizeof...(T), Tag... >

◆ Simplex() [2/2]

template<class... Tag, class... T>
sil::exterior::Simplex ( ddc::DiscreteElement< Tag... > ,
ddc::DiscreteVector< T... > ,
bool  ) -> Simplex< sizeof...(T), Tag... >

◆ operator<<() [4/4]

template<std::size_t K, class... Tag>
std::ostream & sil::exterior::operator<< ( std::ostream & out,
Simplex< K, Tag... > const & simplex )

Definition at line 241 of file simplex.hpp.

◆ stencil_reindex()

template<class Index , class Source , class Target , std::size_t Radius>
KOKKOS_FUNCTION constexpr StencilIndex< Index::size()> sil::exterior::stencil_reindex ( std::size_t flat)
constexpr

Decode the standard ordering: output component, spatial point, input component.

The input component varies fastest. The spatial ordering is StencilShape::offset.

Important
This documentation is fully AI-generated.

Definition at line 72 of file stencil_indices.hpp.

◆ stencil_flatten()

template<class Index , class Source , class Target , std::size_t Radius>
KOKKOS_FUNCTION constexpr std::size_t sil::exterior::stencil_flatten ( StencilIndex< Index::size()> index)
constexpr

Definition at line 81 of file stencil_indices.hpp.

Variable Documentation

◆ form_degree_v

template<TensorFormType T>
std::size_t sil::exterior::form_degree_v = detail::FormDegree<typename T::indices_domain_t>::value
inlineconstexpr

Definition at line 186 of file form.hpp.