Enum MeshSieveError 

pub enum MeshSieveError {
    MissingOverlap {
        source: Box<dyn Error + Send + Sync>,
    },
    MeshError(Box<MeshSieveError>),
    InvalidPermutation(String),
    GpuMappingFailed,
    InvalidPointId,
    StackMissingPoint {
        role: &'static str,
        point: String,
    },
    UnsupportedStackOperation(&'static str),
    MissingPointInCone(String),
    UnknownPoint(String),
    CycleDetected,
    ZeroLengthSlice,
    DuplicatePoint(PointId),
    MissingAtlasPoint(PointId),
    PointNotInAtlas(PointId),
    SievedArrayPointNotInAtlas(PointId),
    SliceLengthMismatch {
        point: PointId,
        expected: usize,
        found: usize,
    },
    AtlasSliceLengthChanged {
        point: PointId,
        old: usize,
        new: usize,
    },
    SievedArraySliceLengthMismatch {
        point: PointId,
        expected: usize,
        found: usize,
    },
    DuplicateRefinementTarget {
        fine: PointId,
    },
    AtlasInsertionFailed(PointId, Box<MeshSieveError>),
    MissingSectionPoint(PointId),
    ScatterLengthMismatch {
        expected: usize,
        found: usize,
    },
    ScatterChunkMismatch {
        offset: usize,
        len: usize,
    },
    AtlasPlanStale {
        expected: u64,
        found: u64,
    },
    MissingSectionName {
        name: String,
    },
    VectorSectionMismatch {
        expected: String,
        found: Option<String>,
    },
    TaggedSectionTypeMismatch {
        expected: ScalarType,
        found: ScalarType,
    },
    MissingOwnership(PointId),
    AtlasPointLengthChanged {
        point: PointId,
        expected: usize,
        found: usize,
    },
    ReducerLengthMismatch {
        expected: usize,
        found: usize,
    },
    AtlasContiguityMismatch {
        point: PointId,
        expected: usize,
        found: usize,
    },
    SievedArrayPrimitiveConversionFailure(usize),
    DeltaLengthMismatch {
        expected: usize,
        found: usize,
    },
    ConstraintIndexOutOfBounds {
        point: PointId,
        index: usize,
        len: usize,
    },
    RefinementTopologyMismatch {
        cell: PointId,
        template: &'static str,
        expected: usize,
        found: usize,
    },
    UnsupportedRefinementCellType {
        cell: PointId,
        cell_type: CellType,
    },
    PartitionPointOverflow,
    PartitionIndexOutOfBounds(usize),
    Communication(CommError),
    MissingRecvCount {
        neighbor: usize,
    },
    SectionAccess {
        point: PointId,
        source: Box<dyn Error + Send + Sync>,
    },
    CommError {
        neighbor: usize,
        source: Box<dyn Error + Send + Sync>,
    },
    BufferSizeMismatch {
        neighbor: usize,
        expected: usize,
        got: usize,
    },
    PartCountMismatch {
        neighbor: usize,
        expected: usize,
        got: usize,
    },
    LengthsCountMismatch {
        neighbor: usize,
        expected: usize,
        got: usize,
    },
    PayloadCountMismatch {
        neighbor: usize,
        expected: usize,
        got: usize,
    },
    OverlapLinkMissing(PointId, usize),
    OverlapNonBipartite {
        src: OvlId,
        dst: OvlId,
    },
    OverlapExpectedLocal {
        found: OvlId,
    },
    OverlapExpectedPart {
        found: OvlId,
    },
    Io(Error),
    Hdf5(Error),
    InvalidGeometry(String),
    MeshIoParse(String),
    DuplicateArrow {
        src: PointId,
        dst: PointId,
    },
    ConeSizeMismatch {
        cell: PointId,
        cell_type: CellType,
        expected: usize,
        found: usize,
    },
    ClosureVertexCountMismatch {
        cell: PointId,
        cell_type: CellType,
        expected: usize,
        found: usize,
    },
    NonManifoldIncidentCells {
        point: PointId,
        dimension: u32,
        incident_cells: usize,
    },
    OverlapRankMismatch {
        expected: usize,
        found: usize,
    },
    PeriodicMappingConflict {
        slave: PointId,
        existing: PointId,
        new: PointId,
    },
    OverlapPartInBasePoints,
    OverlapLocalInCapPoints,
    OverlapDuplicateEdge {
        src: OvlId,
        dst: OvlId,
    },
    OverlapEmptyPart {
        rank: usize,
    },
    TopologyPointMissingOwnership {
        point: PointId,
    },
    OwnershipPointMissingTopology {
        point: PointId,
    },
    OwnershipGhostMismatch {
        point: PointId,
        owner: usize,
        my_rank: usize,
    },
    GhostPointMissingOverlapLink {
        point: PointId,
        owner: usize,
    },
    OverlapPointMissingTopology {
        point: PointId,
    },
    OverlapPointMissingOwnership {
        point: PointId,
    },
    OverlapInOutMirrorMissing {
        src: OvlId,
        dst: OvlId,
    },
    OverlapInOutPayloadMismatch {
        src: OvlId,
        dst: OvlId,
        out: Remote,
        inn: Remote,
    },
    OverlapInOutEdgeCountMismatch {
        out_edges: usize,
        in_edges: usize,
    },
    OverlapResolutionConflict {
        local: PointId,
        rank: usize,
        existing: Option<PointId>,
        new: PointId,
    },
}

Unified error type for mesh-sieve operations.

Variants

MissingOverlap

Error indicating that the overlap graph is missing required neighbor links.

Fields

source: Box<dyn Error + Send + Sync>

MeshError(Box<MeshSieveError>)

Generic mesh error (for internal use, e.g. error propagation)

InvalidPermutation(String)

Renumbering permutation was invalid.

GpuMappingFailed

GPU buffer mapping failed.

InvalidPointId

Attempted to construct a PointId with a zero value (invalid).

StackMissingPoint

Vertical arrow references a point missing from the base or cap sieve.

Fields

role: &'static str

point: String

UnsupportedStackOperation(&'static str)

Mutation on a read-only stack (e.g., ComposedStack) is not allowed.

MissingPointInCone(String)

A point appeared in a cone but wasn’t in the initial point set.

UnknownPoint(String)

Attempted to access a point that is not present in the CSR chart.

CycleDetected

The mesh topology contains a cycle; expected a DAG.

ZeroLengthSlice

Attempt to insert a zero-length slice, which is invalid.

DuplicatePoint(PointId)

Attempt to insert a point that’s already in the atlas.

MissingAtlasPoint(PointId)

Internal invariant broken: point in order but missing from map.

PointNotInAtlas(PointId)

Attempt to access data for a point not in the atlas.

SievedArrayPointNotInAtlas(PointId)

Attempt to access a point not in the atlas.

SliceLengthMismatch

Mismatch between expected and provided slice length for a point.

Fields

point: PointId

expected: usize

found: usize

AtlasSliceLengthChanged

👎Deprecated:

Use AtlasPointLengthChanged

Slice length changed for a point during atlas mutation.

Fields

point: PointId

👎Deprecated:

Use AtlasPointLengthChanged

old: usize

👎Deprecated:

Use AtlasPointLengthChanged

new: usize

👎Deprecated:

Use AtlasPointLengthChanged

SievedArraySliceLengthMismatch

Mismatch between expected and provided slice length for a point (SievedArray).

Fields

point: PointId

expected: usize

found: usize

DuplicateRefinementTarget

Refinement attempted to map multiple coarse points into the same fine point.

Fields

fine: PointId

AtlasInsertionFailed(PointId, Box<MeshSieveError>)

Attempt to add a point to the section failed at atlas insertion.

MissingSectionPoint(PointId)

Attempt to remove or copy data for a point that disappeared.

ScatterLengthMismatch

Bulk scatter mismatch between total lengths.

Fields

expected: usize

found: usize

ScatterChunkMismatch

One of the scatter chunks did not fit.

Fields

offset: usize

len: usize

AtlasPlanStale

Attempted to use a scatter plan built from an outdated atlas.

Fields

expected: u64

found: u64

MissingSectionName

Missing section name in a multi/mixed scatter operation.

Fields

name: String

VectorSectionMismatch

A DM vector is associated with a different section than the requested operation.

Fields

expected: String

found: Option<String>

TaggedSectionTypeMismatch

Tagged section buffer type mismatch.

Fields

expected: ScalarType

found: ScalarType

MissingOwnership(PointId)

Missing ownership metadata for a point.

AtlasPointLengthChanged

Point’s slice length changed across atlas rebuild.

Fields

point: PointId

expected: usize

found: usize

ReducerLengthMismatch

Reducer or path length mismatch when no concrete point exists.

Fields

expected: usize

found: usize

AtlasContiguityMismatch

Atlas slices are not contiguous as expected.

Fields

point: PointId

expected: usize

found: usize

SievedArrayPrimitiveConversionFailure(usize)

Failure converting count to primitive (should never happen if FromPrimitive is well-behaved).

DeltaLengthMismatch

Delta application failed because source and dest slices had different lengths.

Fields

expected: usize

found: usize

ConstraintIndexOutOfBounds

Constraint index is out of bounds for a point slice.

Fields

point: PointId

index: usize

len: usize

RefinementTopologyMismatch

Refinement template did not match the cell cone size.

Fields

cell: PointId

template: &'static str

expected: usize

found: usize

UnsupportedRefinementCellType

Unsupported cell type encountered during refinement.

Fields

cell: PointId

cell_type: CellType

PartitionPointOverflow

Partition‐point computation overflowed to zero (invalid owner).

PartitionIndexOutOfBounds(usize)

The parts slice is missing an entry for point {0}.

Communication(CommError)

Error sending or receiving data over the wire.

MissingRecvCount

Missing expected recv count for a neighbor during data exchange.

Fields

neighbor: usize

SectionAccess

Error accessing a section for a given point.

Fields

point: PointId

source: Box<dyn Error + Send + Sync>

CommError

Communication error for a specific neighbor.

Fields

neighbor: usize

source: Box<dyn Error + Send + Sync>

BufferSizeMismatch

Buffer size mismatch during data exchange.

Fields

neighbor: usize

expected: usize

got: usize

PartCountMismatch

Part count mismatch during data exchange.

Fields

neighbor: usize

expected: usize

got: usize

LengthsCountMismatch

Lengths array count mismatch during data exchange.

Fields

neighbor: usize

expected: usize

got: usize

PayloadCountMismatch

Payload element count mismatch during data exchange.

Fields

neighbor: usize

expected: usize

got: usize

OverlapLinkMissing(PointId, usize)

OverlapNonBipartite

Fields

src: OvlId

dst: OvlId

OverlapExpectedLocal

Fields

found: OvlId

OverlapExpectedPart

Fields

found: OvlId

Io(Error)

Generic I/O error for mesh readers/writers.

Hdf5(Error)

HDF5 error for mesh readers/writers.

InvalidGeometry(String)

Invalid or inverted geometry detected.

MeshIoParse(String)

Parse error while reading mesh formats.

DuplicateArrow

Duplicate arrow detected in topology.

Fields

src: PointId

dst: PointId

ConeSizeMismatch

Cell cone size did not match the expected number of vertices.

Fields

cell: PointId

cell_type: CellType

expected: usize

found: usize

ClosureVertexCountMismatch

Closure vertex count did not match the expected number of vertices.

Fields

cell: PointId

cell_type: CellType

expected: usize

found: usize

NonManifoldIncidentCells

Non-manifold entity detected by counting incident cells.

Fields

point: PointId

dimension: u32

incident_cells: usize

OverlapRankMismatch

Fields

expected: usize

found: usize

PeriodicMappingConflict

Periodic mapping for a slave point conflicted with existing entry.

Fields

slave: PointId

existing: PointId

new: PointId

OverlapPartInBasePoints

OverlapLocalInCapPoints

OverlapDuplicateEdge

Fields

src: OvlId

dst: OvlId

OverlapEmptyPart

Fields

rank: usize

TopologyPointMissingOwnership

Local topology contains a point without ownership metadata.

Fields

point: PointId

OwnershipPointMissingTopology

Ownership metadata references a point missing from the local topology.

Fields

point: PointId

OwnershipGhostMismatch

Ownership ghost flag conflicts with the owning rank.

Fields

point: PointId

owner: usize

my_rank: usize

GhostPointMissingOverlapLink

Ghost point is missing a required overlap link to its owning rank.

Fields

point: PointId

owner: usize

OverlapPointMissingTopology

Overlap references a point absent from the local topology.

Fields

point: PointId

OverlapPointMissingOwnership

Overlap references a point missing ownership metadata.

Fields

point: PointId

OverlapInOutMirrorMissing

Out edge exists but its mirrored in edge is missing.

Fields

src: OvlId

dst: OvlId

OverlapInOutPayloadMismatch

Out/in edges exist but payloads differ (rank/remote_point mismatch).

Fields

src: OvlId

dst: OvlId

out: Remote

inn: Remote

OverlapInOutEdgeCountMismatch

Counts of edges in out vs. in adjacency differ.

Fields

out_edges: usize

in_edges: usize

OverlapResolutionConflict

Fields

local: PointId

rank: usize

existing: Option<PointId>

new: PointId

Trait Implementations

impl Debug for MeshSieveError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for MeshSieveError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for MeshSieveError

impl Error for MeshSieveError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<CommError> for MeshSieveError

fn from(source: CommError) -> Self

Converts to this type from the input type.

impl From<Error> for MeshSieveError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for MeshSieveError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<MeshSieveError> for FvmAssemblyError

fn from(value: MeshSieveError) -> Self

Converts to this type from the input type.

impl PartialEq for MeshSieveError

fn eq(&self, other: &MeshSieveError) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.