Skip to main content
Docs

Search guides and API endpoints, for example “Idempotency-Key” or “submit job”.

    Tools · Fluids & Thermodynamics

    Mechanism Target Validator

    Benchmark a kinetic mechanism against measured ignition delays and flame speeds, and rank the reactions behind each miss.

    Updated October 18, 2026

    On this page

    Prices, workflows, and method papersOpen in the app

    A kinetic mechanism is only as good as its agreement with experiment. Mechanism Target Validator runs one mechanism against a battery of combustion targets with Cantera: 0-D autoignition delay and 1-D laminar flame speed. It compares each prediction with your measured value and ranks the reactions each target is most sensitive to. Mechanism Reduction checks a reduced mechanism against its parent; this tool checks any mechanism against measurements. It runs on CPU.

    How it works

    1. Ignition delay. Each ignition condition runs in a constant-volume or constant-pressure ideal-gas reactor. By default the ignition delay is the time of the steepest temperature rise (max dT/dt); ignition_criterion: max_dOHdt uses the steepest rise in OH instead. A condition that never ignites fails the job and names the condition.
    2. Flame speed. Each flame condition solves a freely propagating premixed flame at the unburned-gas state. The mechanism needs transport data for these.
    3. Comparison. Where you give a reference value, the error is 100·|predicted − measured| / measured. A target passes when the error is within your tolerance, or within the measurement's uncertainty when that is larger. The summary reports the mean and worst error and the RMS of log₁₀ ignition delay.
    4. Sensitivities. Optionally, every reaction is ranked by d ln(target) / d ln(k). Ignition sensitivities screen all reactions, then re-check the strongest by perturbing each rate constant by ±5 %. Flame-speed sensitivities use Cantera's adjoint method and are available for a couple of flames per run.
    5. Error attribution. With reference data and sensitivities, the job flags reactions that could close a miss on their own with a rate change inside a factor you choose (default 2). This is a first-order estimate that holds for small changes, not a fitted correction.

    The conditions use exactly the same fields as Mechanism Reduction, so a reduced mechanism can be validated at the same states without edits.

    Inputs

    • The mechanism: built-in gri30 or h2o2 (mechanism_id), or your own Cantera YAML or single CHEMKIN file with thermodynamic data, uploaded or from an artifact. It can be the output of RMG Mechanism Generator, Mechanism Reduction, or Kinetic Parameter Fitter.
    • Target conditions: ignition_conditions and flame_conditions, each with temperature (K), pressure (Pa), and either an equivalence ratio with fuel and oxidizer or an explicit reactant mixture. They are numbered in order as ignition_0, ignition_1, …, then flame_0, ….
    • Reference data (optional): a CSV with condition_id, target (ignition_delay or flame_speed), value, and unit (s, ms, us, m/s, or cm/s), plus optional uncertainty_pct and source. An unknown condition_id or a unit that doesn't fit the target fails the job before anything runs. Conditions without a row are reported as predictions only.

    Outputs

    FileContents
    targets.csvPrediction, measurement, error, tolerance, and pass/fail for every condition
    sensitivity.csvRanked reactions per condition with their normalized sensitivity
    attribution.csvReactions that could explain each miss, with the rate factor each would need (when requested)
    arrhenius_grid.csv, arrhenius.pnglog₁₀ ignition delay against 1000/T, predicted and measured
    summary.jsonIgnition definition, tolerances, mechanism size, and the aggregate errors

    Not covered

    • Perfectly-stirred-reactor extinction targets.
    • Refitting rate parameters: use Kinetic Parameter Fitter on the flagged reactions.
    • Curated literature datasets: reference values come from you.

    Generate mechanisms with RMG Mechanism Generator, shrink them with Mechanism Reduction, and run single simulations in Cantera.

    Run it from the API

    Submit with Submit a job and the job_type below. Price it first with Estimate job reservation cost: submitting reserves that amount from your wallet, and the charge settles at the actual runtime.

    Mechanism Target Validator mechanism-validate

    Job type
    mechanism-validate
    Hardware
    cpu (default)
    Typical runtime
    30 min on CPU

    Payload

    Provide exactly one of: mechanism, mechanism_id.

    Payload fields
    FieldTypeDescription
    mechanismfile_object
    mechanism.namestring

    Limits: min length 1

    mechanism.filenamestring

    Limits: min length 1

    mechanism.content_b64string

    Limits: min length 1

    mechanism.contentany
    mechanism.bytesany
    mechanism_idstring

    One of: "gri30", "h2o2"

    phase_namestring

    Limits: min length 1

    ignition_conditions[]ignition_condition[]

    Limits: max items 20

    ignition_conditions.kindrequiredstring

    One of: "constant_volume", "constant_pressure"

    ignition_conditions.temperature_krequirednumber

    Limits: > 0, ≤ 5000

    ignition_conditions.pressure_parequirednumber

    Limits: > 0

    ignition_conditions.equivalence_rationumber

    Limits: > 0

    ignition_conditions.fuelcomposition
    ignition_conditions.oxidizercomposition
    ignition_conditions.reactantscomposition
    ignition_conditions.end_time_snumber

    Limits: > 0, ≤ 10

    ignition_conditions.max_stepsinteger

    Limits: ≥ 1, ≤ 1000000

    flame_conditions[]flame_condition[]

    Limits: max items 5

    flame_conditions.temperature_krequirednumber

    Limits: > 0, ≤ 5000

    flame_conditions.pressure_parequirednumber

    Limits: > 0

    flame_conditions.equivalence_rationumber

    Limits: > 0

    flame_conditions.fuelcomposition
    flame_conditions.oxidizercomposition
    flame_conditions.reactantscomposition
    flame_conditions.width_mnumber

    Limits: > 0, ≤ 1

    referencefile_object
    reference.namestring

    Limits: min length 1

    reference.filenamestring

    Limits: min length 1

    reference.content_b64string

    Limits: min length 1

    reference.contentany
    reference.bytesany
    ignition_criterionstring

    Default: "max_dTdt"One of: "max_dTdt", "max_dOHdt"

    tolerancesobject
    tolerances.ignition_delay_pctnumber

    Default: 50Limits: > 0, ≤ 1000

    tolerances.flame_speed_pctnumber

    Default: 10Limits: > 0, ≤ 100

    sensitivityboolean

    Default: false

    flame_sensitivity_conditions[]integer[]

    Limits: max items 2

    sensitivity_top_ninteger

    Default: 20Limits: ≥ 1, ≤ 100

    attributionboolean

    Default: false

    attribution_factornumber

    Default: 2Limits: > 1, ≤ 10

    File fields take {"name": "x.pdb", "content_b64": "…"} or a stored artifact, {"$artifact": {"id": "art-…", "port": "…"}}. Files are up to 25 MiB each.

    Example

    from cognichem_client import CogniChem
    
    client = CogniChem.from_env()  # reads COGNICHEM_API_KEY
    payload = {
        "mechanism_id": "gri30",
        "ignition_criterion": "max_dTdt",
        "tolerances": {"ignition_delay_pct": 50, "flame_speed_pct": 10},
        "sensitivity": True,
        "sensitivity_top_n": 10,
        "ignition_conditions": [
            {
                "kind": "constant_volume",
                "temperature_k": 1351.2,
                "pressure_pa": 933203.25,
                "equivalence_ratio": 1,
                "fuel": {"CH4": 1},
                "oxidizer": {"O2": 1, "N2": 3.76},
            },
            {
                "kind": "constant_volume",
                "temperature_k": 1718.3,
                "pressure_pa": 1019329.5,
                "equivalence_ratio": 1,
                "fuel": {"CH4": 1},
                "oxidizer": {"O2": 1, "N2": 3.76},
            },
        ],
        "flame_conditions": [
            {
                "temperature_k": 298,
                "pressure_pa": 101325,
                "equivalence_ratio": 1,
                "fuel": {"CH4": 1},
                "oxidizer": {"O2": 1, "N2": 3.76},
            },
        ],
    }
    
    estimate = client.jobs.estimate(job_type="mechanism-validate", payload=payload, resource="cpu")
    print(f"Reserves ${estimate.cost:.2f}")
    
    job = client.jobs.submit(
        job_name="my-mechanism-validate-run",
        job_type="mechanism-validate",
        payload=payload,
        resource="cpu",
    )
    status = client.jobs.wait(job.process_id)
    if status.status == "completed":
        client.jobs.result(job.process_id, save_path=".")

    Sample data from the job catalog; long values are shortened here. Each job_name must be unique among your jobs.

    Workflow inputs

    • Kinetic mechanism · optionalYAML, CHEMKIN
    • Table · optionalCSV

    Workflow outputs

    • ArchiveZIP
    • TableCSV
    • TableCSV
    • TableCSV