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 |
| struct sil::exterior::Coboundary |
Definition at line 148 of file coboundary.hpp.

| struct sil::exterior::Codifferential |
Definition at line 121 of file codifferential.hpp.

| struct sil::exterior::Stencil |
Definition at line 26 of file stencil.hpp.

| Class Members | ||
|---|---|---|
| size > | weights {} | |
| array< double, mem_size()> | offset {} | |
| array< double, mem_size() *mem_size()> | constant_response {} | |
| bool | complete = true | |
| struct sil::exterior::StencilIndex |
Definition at line 15 of file stencil_indices.hpp.

| Class Members | ||
|---|---|---|
| size_t | output_component | |
| array< int, Dimensions > | spatial_offset | |
| size_t | input_component | |
| struct sil::exterior::TransposedCoboundary |
Definition at line 151 of file coboundary.hpp.

| struct sil::exterior::VertexFormBilinearComposition |
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.
Definition at line 161 of file staged_vertex_form_composition.hpp.

| Class Members | ||
|---|---|---|
| typedef Storage | staged_storage_type Storage | |
| using sil::exterior::boundary_t = typename detail::BoundaryType<T>::type |
Definition at line 39 of file boundary.hpp.
| using sil::exterior::coboundary_t = typename detail::CoboundaryType<CochainType>::type |
Definition at line 60 of file coboundary.hpp.
| using sil::exterior::coboundary_index_t = typename detail::CoboundaryIndex<TagToAddToCochain, CochainTag>::type |
Definition at line 90 of file coboundary.hpp.
| using sil::exterior::coboundary_tensor_t |
Definition at line 116 of file coboundary.hpp.
| using sil::exterior::codifferential_t = typename detail::CodifferentialType<CochainType>::type |
Definition at line 55 of file codifferential.hpp.
| using sil::exterior::codifferential_index_t |
Definition at line 89 of file codifferential.hpp.
| using sil::exterior::codifferential_tensor_t |
Definition at line 116 of file codifferential.hpp.
| using sil::exterior::hodge_star_domain_t |
Definition at line 32 of file continuous_hodge_star.hpp.
| using sil::exterior::codifferential_hodge_output_indices_t |
Definition at line 487 of file continuous_hodge_star.hpp.
| using sil::exterior::reduction_index_t = typename detail::ReductionTargetIndex<Indices>::type |
Definition at line 352 of file reduction_and_reconstruction.hpp.
| using sil::exterior::reduction_domain_t |
Definition at line 355 of file reduction_and_reconstruction.hpp.
| using sil::exterior::reconstruction_domain_t |
Definition at line 362 of file reduction_and_reconstruction.hpp.
| using sil::exterior::simplex_for_domain_t = detail::SimplexForDomain<K, Dom>::type |
Definition at line 238 of file simplex.hpp.
| using sil::exterior::BilinearLocalOperatorStorage |
Definition at line 228 of file bilinear_operator_storage.hpp.
| using sil::exterior::LinearStencil = Stencil<Index, Source, Target, Radius> |
Definition at line 39 of file stencil.hpp.
|
strong |
| Enumerator | |
|---|---|
| Primal | |
| CircumcentricDual | |
| BarycentricDual | |
Definition at line 21 of file volume.hpp.
| 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.
| KOKKOS_FUNCTION LocalChain< boundary_t< SimplexType >, Kokkos::LayoutRight, MemorySpace > sil::exterior::boundary | ( | SimplexType const & | simplex | ) |
Definition at line 176 of file boundary.hpp.
| 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.
| sil::exterior::Chain | ( | Head | , |
| Tail... | ) -> Chain< typename Head::value_type, typename Head::array_layout, typename Head::memory_space > |
| std::ostream & sil::exterior::operator<< | ( | std::ostream & | out, |
| ChainType const & | chain ) |
| KOKKOS_FUNCTION coboundary_t< CochainType > sil::exterior::coboundary | ( | CochainType const & | cochain | ) |
Definition at line 508 of file coboundary.hpp.
| 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.
Definition at line 532 of file coboundary.hpp.
| 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.
| 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.
| sil::exterior::Cochain | ( | Tensor const & | ) | -> Cochain< Tensor > |
| sil::exterior::Cochain | ( | ChainType | , |
| TensorType | ) -> Cochain< ChainType, typename TensorType::value_type, ddc::detail::mdspan_to_kokkos_layout_t< typename TensorType::layout_type > > |
| std::ostream & sil::exterior::operator<< | ( | std::ostream & | out, |
| CochainType const & | cochain ) |
Definition at line 408 of file cochain.hpp.
| 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.
Definition at line 591 of file codifferential.hpp.
| 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_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.
| 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.
| 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.
| 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.
Definition at line 959 of file continuous_hodge_star.hpp.
| std::ostream & sil::exterior::operator<< | ( | std::ostream & | out, |
| CosimplexType const & | cosimplex ) |
Definition at line 114 of file cosimplex.hpp.
| sil::exterior::Form | ( | Coefficients const & | ) | -> Form< Coefficients > |
| KOKKOS_FUNCTION double sil::exterior::integrate | ( | CochainTensor const & | cochain, |
| SimplexType const & | simplex ) |
Evaluate an already reduced k-cochain on one oriented k-cell.
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.
| 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.
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.
| 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.
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.
| 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.
Definition at line 143 of file integration.hpp.
| 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.
| 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.
| 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.
| 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.
|
constexpr |
Definition at line 444 of file local_chain.hpp.
|
constexpr |
Definition at line 451 of file local_chain.hpp.
| sil::exterior::LocalChain | ( | AllocationType | , |
| SimplexType | , | ||
| T... | ) -> LocalChain< std::remove_cvref_t< SimplexType >, typename AllocationType::array_layout, typename AllocationType::memory_space > |
|
nodiscard |
Integrate a scalar evaluator with an independent reference-cell rule.
Definition at line 93 of file quadrature.hpp.
| 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.
Definition at line 110 of file quadrature.hpp.
| 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.
| 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.
| sil::exterior::Simplex | ( | ddc::DiscreteElement< Tag... > | , |
| ddc::DiscreteVector< T... > | ) -> Simplex< sizeof...(T), Tag... > |
| sil::exterior::Simplex | ( | ddc::DiscreteElement< Tag... > | , |
| ddc::DiscreteVector< T... > | , | ||
| bool | ) -> Simplex< sizeof...(T), Tag... > |
| std::ostream & sil::exterior::operator<< | ( | std::ostream & | out, |
| Simplex< K, Tag... > const & | simplex ) |
Definition at line 241 of file simplex.hpp.
|
constexpr |
Decode the standard ordering: output component, spatial point, input component.
The input component varies fastest. The spatial ordering is StencilShape::offset.
Definition at line 72 of file stencil_indices.hpp.
|
constexpr |
Definition at line 81 of file stencil_indices.hpp.