Runs a declared plan of runs on one card, or of solves of one solver, and seals the rows under one root. A plan is a list of runs, a grid over a base run, or a seeded sample over a base run; a run is a run_trajectory request without domain and card. A plan of solves names solver in place of domain and card and is a list or a grid of solve requests. The answer is small by default: the head, which holds the request, the counts and the dataset_seal, and one summary row per run; answer "states" adds each final state in decimals and "full" gives every row whole, under the same dataset_seal. A row is completed, ended, refused or unadmitted: an ended or a refused row is a run sealed up to its last landed step, and an unadmitted row is a request turned away before computing, with no seal. The seal shows the dataset was not altered after it was sealed. It does not show the engine made it: a row's request sent to run_trajectory gives the run seal to compare. The input schema says how each input is written, with a worked plan of each kind. On this open connection a dataset is returned inline and holds at most 300 runs (OPEN_MAX_DATASET_ROWS), 1000000 steps in all (OPEN_MAX_DATASET_STEPS), 10000 frames and an answer counted from the plan at 4194304 bytes (OPEN_MAX_DATASET_ANSWER_BYTES) and 42500 characters, up to about 150 summary rows; a plan of solves holds the engine's own 64 and at most 15 s of them, or one, at each solver's measured time, which describe_solver states with the count (OPEN_PLAN_SECONDS). One address holds at most 1 physics permit at a time, and long work (a solve, a plan of runs or of solves, a run of more than 10000 steps, or a verification that computes one again) runs 1 at a time. A call that finds no permit or no place is answered "Too many concurrent physics tasks." and nothing waits: the same call sent later is answered once one is free. An answer is waited for 60 seconds, and long work is stopped there.
View input schema
{
"type": "object",
"properties": {
"domain": {
"type": "string"
},
"card": {
"type": "string"
},
"plan": {
"oneOf": [
{
"type": "object",
"description": "A list of runs. Each is a run_trajectory request without domain and card.",
"properties": {
"kind": {
"const": "list"
},
"runs": {
"type": "array",
"minItems": 1,
"items": {
"type": "object"
}
}
},
"required": [
"kind",
"runs"
],
"additionalProperties": false
},
{
"type": "object",
"description": "With solver: a list of solves. Each is a solve request without solver.",
"properties": {
"kind": {
"const": "list"
},
"solves": {
"type": "array",
"minItems": 1,
"items": {
"type": "object"
}
}
},
"required": [
"kind",
"solves"
],
"additionalProperties": false
},
{
"type": "object",
"description": "A base run (with solver: a base solve request without solver) and axes of explicit values. The rows are the product of the axes, the last axis varying fastest.",
"properties": {
"kind": {
"const": "grid"
},
"base": {
"type": "object"
},
"axes": {
"type": "array",
"minItems": 1,
"items": {
"type": "object",
"properties": {
"path": {
"type": "string"
},
"values": {
"type": "array",
"minItems": 1
}
},
"required": [
"path",
"values"
],
"additionalProperties": false
}
}
},
"required": [
"kind",
"base",
"axes"
],
"additionalProperties": false
},
{
"type": "object",
"description": "A base run and draws from the counter sampler. Row n is worked out without the rows before it.",
"properties": {
"kind": {
"const": "sample"
},
"base": {
"type": "object"
},
"rows": {
"type": "integer",
"minimum": 1
},
"generator": {
"const": "splitmix64_counter_v1"
},
"seed_hex": {
"type": "string",
"pattern": "^[0-9a-f]{16}$"
},
"draws": {
"type": "array",
"minItems": 1,
"items": {
"type": "object",
"properties": {
"path": {
"type": "string"
},
"uniform": {
"type": "object",
"properties": {
"low": {
"type": "number"
},
"high": {
"type": "number"
}
},
"required": [
"low",
"high"
],
"additionalProperties": false
},
"choice": {
"type": "array",
"minItems": 1
}
},
"required": [
"path"
],
"additionalProperties": false
}
}
},
"required": [
"kind",
"base",
"rows",
"generator",
"seed_hex",
"draws"
],
"additionalProperties": false
}
],
"description": "A path names one number: initial.<field>, dt_s, or segments[0].load.<field>, with the segment's number in square brackets and [0], [1] or [2] after a 3-vector field for one of its components. steps and record_every are not paths and cannot vary: every row of a grid or a sample takes them from the base run. A value an axis or a draw sets replaces the base's value of that field, and the answer's base_replaced names each field replaced; a 3-vector the base sets whole is replaced only when the paths set all three of its components. Two paths may not set one number. Each row of a grid is held to the card's bounds alone, as each run of a list is: a value outside a bound makes that row unadmitted and the other rows run. A sample's interval or choice outside a bound refuses the plan. One worked plan of each kind, each a whole request: list: {\"domain\":\"energy\",\"card\":\"thermal\",\"plan\":{\"kind\":\"list\",\"runs\":[{\"initial\":{\"temperature_k\":293.15},\"dt_s\":1.0,\"segments\":[{\"steps\":60,\"load\":{\"heat_power_w\":5.0,\"ambient_k\":293.15}}],\"record_every\":60}]},\"store\":\"none\",\"return\":\"inline\"} grid: {\"domain\":\"energy\",\"card\":\"thermal\",\"plan\":{\"kind\":\"grid\",\"base\":{\"initial\":{},\"dt_s\":1.0,\"segments\":[{\"steps\":60,\"load\":{\"ambient_k\":293.15}}],\"record_every\":60},\"axes\":[{\"path\":\"initial.temperature_k\",\"values\":[283.15,293.15]},{\"path\":\"segments[0].load.heat_power_w\",\"values\":[0.0,5.0,10.0]}]},\"store\":\"none\",\"return\":\"inline\"} sample: {\"domain\":\"energy\",\"card\":\"thermal\",\"plan\":{\"kind\":\"sample\",\"base\":{\"initial\":{},\"dt_s\":1.0,\"segments\":[{\"steps\":60,\"load\":{\"ambient_k\":293.15}}],\"record_every\":60},\"rows\":4,\"generator\":\"splitmix64_counter_v1\",\"seed_hex\":\"0000000000000001\",\"draws\":[{\"path\":\"initial.temperature_k\",\"choice\":[283.15,293.15]},{\"path\":\"segments[0].load.heat_power_w\",\"uniform\":{\"low\":0.0,\"high\":10.0}}]},\"store\":\"none\",\"return\":\"inline\"}."
},
"store": {
"type": "string",
"enum": [
"frames",
"none"
]
},
"return": {
"type": "string",
"enum": [
"inline",
"file"
]
},
"solver": {
"type": "string",
"description": "A plan of solves: the solver, in place of domain and card. It takes no store and no return. A plan of solves is answered inline: a list, {\"kind\":\"list\",\"solves\":[{\"parameters\":{...}}]}, or a grid, {\"kind\":\"grid\",\"base\":{\"parameters\":{...}},\"axes\":[{\"path\":\"parameters.<input>\",\"values\":[...]}]}, of at most 64 solves. Each row is a solve request, solved as solve solves it and carrying the solution_seal solve gives it; a request turned away without a seal, by the rules of a request or by the solver, is an unadmitted row. The rows are sealed under one dataset_seal by the rules of a plan of runs, with solution_seal in the leaf in the place of run_seal, and completed in the counts counts the solves that converged. A summary row has row, set, outcome, reject, solution_seal and every single number of the result in decimals; answer \"full\" gives every solution whole, and is refused when it comes to more than 42500 characters. verify_dataset verifies a plan of solves by its request and dataset_seal, and validate_series compares one number of its results with measurements. Worked plan of solves: {\"solver\":\"atom_dft\",\"plan\":{\"kind\":\"list\",\"solves\":[{\"parameters\":{\"atomic_number\":10}}]}}."
},
"answer": {
"type": "string",
"enum": [
"summary",
"states",
"full"
],
"description": "Leave out, or \"summary\", for the head and one short summary row per row: the values it sets, outcome, steps landed, refusal name and seal; \"states\" adds each run's final state in decimals; \"full\" gives every row whole. With return \"file\" the answer is the head and the names of the files whatever this says. Not part of the sealed request. The head and the dataset_seal are the same in all three forms. A summary row holds row, set (the values a grid's or a sample's row sets), outcome, steps_landed, reject and run_seal; the quantities of one row are read by sending its request to run_trajectory with a readout. An ended row is a run that stopped at an end its card declares: it has a run seal, the end's reject name in reject and the sentence naming the end in reject_detail. A refused row is a run the card refused part way: it has a run seal, the refusal's name in reject and its sentence in reject_detail. An unadmitted row is a request turned away before computing: it has no run seal, and its sentence, with the refusal's name in round brackets when the sentence gives one, is its reject_detail; its summary row gives that name in reject. What a sentence that begins \"Physical Failure\" or \"Physical Violation\" means is in the description of run_trajectory. An inline answer is counted from the plan before anything runs, and one above 42500 characters is refused with what to change: a summary row counts 220 characters and the values it sets; with states, each number of the final state adds its name and 28 characters (84 for a 3-vector, 9 for a flag); a whole row counts its own request and 1900 characters, and for each number twice its name and 60 characters (150 for a 3-vector, 9 for a flag); store \"frames\" adds 128 characters for each recorded state to a full answer; the head repeats the request."
}
},
"required": [
"plan"
],
"additionalProperties": false,
"description": "A plan of runs on one card (domain, card, plan, store and return, all required) or of solves of one solver (solver and plan). Rows <= 100000, steps in total <= 100000000, stored frames <= 16777216; inline: an answer counted from the plan <= 42500 characters, which a plan reaches first, a grid on one axis at about 150 summary rows and a list sooner, its head repeating each run's request (a plan of more than 1000 rows is refused before it is counted, as too large to return inline), and frames <= 10000; solves <= 64. With return \"file\" the answer is the head and the names of the files stored, on a connection started with a directory for them."
}