Guided Tour

DispatchAtlas turns a scheduling problem into public, reproducible evidence in four stages: generate a benchmark instance, solve it, analyze the runs, and explore everything through the catalog. This tour walks the whole arc at small scale with one snippet per stage; the tutorials turn each stage into a complete runnable script.

If you have not yet, run the quick start first — its smoke campaign produces the run records the analyze stage below reads.

1️⃣ Generate — a benchmark instance

A benchmark instance is one scheduling problem: tasks, the resources that run them, objectives, and constraints. The bundled smoke catalog materializes small deterministic instances from a single seed, so the same seed always yields the same problem.

from dispatchatlas.bench import smoke_benchmark_provider
 
provider = smoke_benchmark_provider(root_seed=20260527)
problem = provider.get_problem(provider.list_problem_ids()[0])
print(problem.spec.id, len(problem.spec.tasks), "tasks")

The full atlas spans classical scheduling families and a continuum of Edge–Fog–Cloud families, each carrying citation-backed metadata and a distribution-distance score. → Benchmark model

2️⃣ Solve — run a solver on it

A solver assigns tasks to resources over time and returns a schedule. The registry selects solvers that support your objective and are visible at a given evidence tier, then constructs one to run.

from dispatchatlas.core import DisclosureLabel, TerminationPolicy, derive_seed
from dispatchatlas.solve import default_solver_registry
 
registry = default_solver_registry()
candidate = registry.select(objective="makespan", disclosure_label=DisclosureLabel.CORE)[0]
solver = registry.create(candidate.solver_id)
run = solver.solve(
    problem=problem,
    stop=TerminationPolicy(max_iterations=candidate.default_stop.max_iterations),
    seed=derive_seed(20260527, "tour", 0),
)
print(run.result.feasible)

The registry holds constructive baselines, exact adapters, metaheuristics, a diversified competitor set, and a native solver family — every entry with a fail-closed citation contract. → Solver system · Algorithms

3️⃣ Analyze — turn runs into evidence

Solving many problems with many solvers produces a campaign of run records. The analysis layer loads a completed campaign and computes descriptive summaries, named non-parametric tests with effect sizes, corrected significance, and solver rankings — never a bare p-value.

from pathlib import Path
from dispatchatlas.analytica import load_campaign_dataset, summarize_dataset
 
campaign_dir = Path("experiments") / "results" / "smoke-pilot"
dataset = load_campaign_dataset(campaign_dir)
summary = summarize_dataset(dataset)
print([s.solver_id for s in summary.solver_summaries])

The same summary drives deterministic SVG and PGFPlots figures and disclosure-filtered evidence bundles. → Campaign engine · Analysis exports

4️⃣ Catalog — explore the atlas

Everything the tour produced is browsable without writing code. The interactive portal lets you search and filter the benchmark atlas by its metadata, inspect each solver's declared capabilities, preview results, and download the disclosure-filtered datasets behind every page.

• Benchmark catalog — filter and download benchmark instances by their metadata.
• Solver recommender — an explainable, metadata-only ranking of which solvers fit a problem.
• Results and platform inspection — preview evidence and the platform's own capability surface.

🧭 Where To Go Next

1. Work the tutorials for the complete runnable version of each stage.
2. Configure checkpointed, resumable runs in the reproducible campaigns workspace.
3. Read the domain contracts for the types every package shares.