Connections Engine

The engine module provides a connection engine for orchestrating manifold transfer discovery in CR3BP.

Engine Classes

class hiten.algorithms.connections.engine._ConnectionEngine[source]

Bases: _HitenBaseEngine[_ConnectionProblem, ConnectionResults, list]

Provide the main engine for orchestrating connection discovery between manifolds.

This class serves as the central coordinator for the connection discovery process. It takes a problem specification and orchestrates the various computational steps needed to find ballistic and impulsive transfers between manifolds.

The engine delegates the actual computational work to specialized backend algorithms while maintaining a clean interface for the higher-level connection discovery system.

Notes

The connection discovery process involves: 1. Intersecting both manifolds with the specified synodic section 2. Finding geometrically close points between intersection sets 3. Applying mutual-nearest-neighbor filtering 4. Refining matches using local segment geometry 5. Computing Delta-V requirements and classifying transfers

This engine coordinates these steps and ensures proper data flow between the different algorithmic components.

Examples

>>> engine = _ConnectionEngine()
>>> results = engine.solve(problem)
>>> print(f"Found {len(results)} connections")

See also

_ConnectionProblem

Problem specification structure processed by this engine.

_ConnectionsBackend

Backend algorithms that perform the actual computations.

ConnectionPipeline

High-level user interface that uses this engine.

Parameters:

Problem Classes

class hiten.algorithms.connections.engine._ConnectionProblem[source]

Bases: object

Define a problem specification for connection discovery between two manifolds.

This dataclass encapsulates all the parameters needed to define a connection discovery problem, including the source and target manifolds, compile-time configuration (section structure), and runtime options (search tolerances).

Parameters:
  • source (Manifold | PeriodicOrbit) – Source manifold (typically unstable manifold).

  • target (Manifold | PeriodicOrbit) – Target manifold (typically stable manifold).

  • section_axis (str) – Axis for the synodic section (e.g., “x”, “y”, “z”). From config.

  • section_offset (float) – Offset value for the synodic section. From config.

  • plane_coords (tuple of str) – Coordinate labels for the section plane projection. From config.

  • direction (int or None) – Direction for section crossings (1, -1, or None for both). From config.

  • delta_v_tol (float) – Maximum Delta-V tolerance for accepting a connection. From options.

  • ballistic_tol (float) – Threshold for classifying connections as ballistic vs impulsive. From options.

  • eps2d (float) – Radius for initial 2D pairing of points on the synodic section. From options.

  • n_workers (int or None) – Number of parallel workers for computation. From options.

Notes

This class serves as a data container that packages all the necessary information for the connection engine to process. It combines compile-time structure (config) and runtime tuning (options) into a single problem specification.

The problem specification is typically created by the high-level ConnectionPipeline class and passed to the engine for processing.

Examples

>>> problem = _ConnectionProblem(
...     source=unstable_manifold,
...     target=stable_manifold,
...     section_axis="x",
...     section_offset=0.8,
...     plane_coords=("y", "z"),
...     direction=1,
...     delta_v_tol=1e-3,
...     ballistic_tol=1e-8,
...     eps2d=1e-4,
...     n_workers=1
... )

See also

_ConnectionEngine

Engine class that processes this problem specification.

ConnectionPipeline

High-level class that creates these problem specifications.

source: Manifold
target: Manifold
section_axis: str
section_offset: float
plane_coords: tuple[str, str]
direction: int | None
delta_v_tol: float
ballistic_tol: float
eps2d: float
n_workers: int | None