Parameters

Params as the Run Contract

aimmd.Params is the central contract between the scientific definition of a problem and the code that executes it. Nearly every other high-level component depends on it:

The implementation is mixin-based, but users should treat Params as one coherent object.

Required and Commonly Overridden Inputs

In practice, the most important inputs are:

states_function

Required. Maps frames to state labels such as A, R, and B.

initial_paths

Initial transition paths that seed the run.

network

Torch model used to predict the committor-like value.

descriptors_function and descriptor_transform

Optional feature pipeline before the network is evaluated.

values_function

Optional, if evaluating the network forward pass requires any special care. If not given, will default to network(descriptors).

fit

Training hook. If omitted, AIMMD uses the default trainer in aimmd.network.fit.fit().

engine and engine-specific settings

Choose between gromacs and the toy engine and provide the relevant command strings or callbacks.

State and Region Conventions

The states string defines the label ordering used throughout the code. The default is 'ARB':

  • the first label is the reactant-like metastable state,

  • the middle label is the reactive region,

  • the last label is the product-like metastable state.

This convention is used everywhere: shooting logic, free simulations, path typing, training labels, and reweighting.

Sampling Controls

Several parameters directly control how AIMMD explores path space:

chain_type

'rfps' for rejection-free path sampling or 'tps' for TPS-style acceptance.

selection_pool_size

Number of candidate paths used when selecting the next shooting point.

at_least_one_transition_in_pool

Optional heuristic that may improve sampling in early rounds by ensuring that at least one path in the selection pool is reactive.

always_select_inside_the_bins

Do not select shooting points from paths entirely outside the selection bins range.

nbins, cutoff_min, cutoff_max, marginal_bins

Define how value space is discretized for adaptive sampling and density estimation.

density_adjustment and shared_density_adjustment

Optional heuristics that may improve convergence by reweighting the density of shooting points in each bin.

When launching AIMMD, the nchains_per_worker parameter controls how many independent shooting chains are run in parallel on each worker. This can be used to improve sampling efficiency and reduce correlation between chains when selection_pool_size=1.

Multi-System (Multi-Ligand) Parameters

These fields turn one params file into a multi-system run that trains a single shared committor model across several chemical systems. They all default to the single-system behavior, so existing params files are unaffected.

multi_system

Bool, default False. Enables multi-system mode. When on, the per-system fields below become lists (one entry per system), each system runs in its own subfolder <run>/<system_id>/, and the user data functions receive a system_id keyword (passed only if their signature accepts it).

multi_system_share_network

Bool, default False. If True, one shared network is trained by a single trainer that hands fit a list of per-system PathEnsembles (pooled balanced, 1/N per system per bin); the shared network is stored at the run root. If False, each system trains its own network with its own trainer.

system_ids

List of per-system labels (e.g. ['G2', 'G4']); they name the per-system subfolders and index the list-valued fields. Defaults to ['0', '1', ...].

atom_types

Fixed, ordered list of MDAnalysis atom-type strings defining a shared one-hot graph node encoding (e.g. ['H','C','N','O','F','NA','P','S','CL','BR','I']). This is what lets one graph network consume graphs from multiple systems. None (default) keeps the legacy per-universe encoding.

trainers_share_gpu

Bool, default True. When training separate networks (share OFF), controls whether the per-system trainers bind the same GPU or distinct GPUs.

In multi-system mode topology and initial_paths accept lists (one topology file per system; one group of initial paths per system), and the per-run worker counts n/n1/n2 apply per system. See Workflow for the full multi-system workflow and the example notebook examples/notebooks/2_multi_system.ipynb.

Bias Recording (OPES / PLUMED)

For runs that apply an in-state bias during dynamics (e.g. a frozen OPES_METAD that flattens a bound well), AIMMD records the per-frame bias and recovers unbiased kinetics with the Tiwary-Parrinello correction. All of these default to off, so unbiased runs are unaffected.

record_bias

Bool, default False. When True, the per-frame bias is cached as <traj>.bias.npy and the trainer prints bias-reweighted rate estimates k = 1 / Σ(wᵢ·Lᵢ·γᵢ) with γᵢ = ⟨exp(bias)⟩ per path.

bias_function / bias_source

The callable that returns the per-frame bias in kT. With bias_source='reader' it is called bias_function(reader) (toy / position-based); with bias_source='file' it is called bias_function(fname) and reads the associated PLUMED COLVAR file. In a multi-system run a system_id keyword is forwarded when the signature accepts it; the bias itself usually enters GROMACS through the per-system gmx_mdrun string (gmx mdrun -plumed <system>/plumed.dat).

bias_reactive_threshold

Float, default 0.5. Maximum acceptable mean |bias| (in kT) inside the reactive region R (the Tiwary-Parrinello assumption). In multi-system mode this may be a single float (applied to every system) or a list, one per system_ids entry.

Important

When biasing with PLUMED, each system’s PRINT STRIDE (COLVAR output stride) must equal that system’s nstxout-compressed so that COLVAR row i lines up with trajectory frame i; a mismatch silently misaligns the cached bias.

Value-Pass Subsampling

Each training round the trainer recomputes the committor on every reactive frame of the (growing) path ensemble before binning and reweighting. With several ligands feeding one trainer this value pass can outgrow the job walltime. The optional subsample_caps bounds it by running the value pass / bin generation / reweighting / rate estimate on a fresh random subsample of the ensemble each round, while fit (network training) still sees the full ensemble.

subsample_caps

None (default) means no subsampling — behaviour is unchanged. Otherwise a dict with any of:

  • 'shot' — max PATHS kept per shot-excursion direction-type. The four direction-types sAA, sAB, sBA, sBB are capped independently, so 'shot': 100 keeps up to 4 * 100 = 400 shot paths per system.

  • 'free' — max PATHS kept per free-excursion direction-type (fAA, fAB, fBA, fBB each), so 'free': 500 keeps up to 2000 free paths per system.

  • 'in_state' — max FRAMES kept per state (the in-A and in-B paths are kept until this many frames accumulate, per state).

A missing key leaves that category uncapped. In a multi-system run this may be a single dict (broadcast to all systems) or a list of dicts/None (one per system_ids entry). Pick caps generously (e.g. shot=100, free=500): selection is uniform within each category so the reweighting stays a consistent rate estimate, and in-state-only paths carry zero reweight so dropping them never biases the rate.

Engine Integration

For engine='gromacs', the parameter object stores the command templates used to create and run simulations, including:

  • gmx_grompp,

  • gmx_mdrun,

  • gmx_eneconv,

  • gmx_mdp,

  • and topology and trajectory-format settings.

For engine='toy', the main inputs are:

  • toy_mdrun for advancing the timestep,

  • toy_slowdown to throttle the loop for testing and development.

Persistence and Reproducibility

One unusual but important design choice is that parameters are saved back to Python files rather than to a plain data format. This allows AIMMD to preserve callables such as:

  • state classifiers,

  • descriptor functions,

  • network classes,

  • and custom fit hooks.

That design is why Params includes helper code for tracking Python source and why the tests pay special attention to relative imports and reloading.

Full Parameter Reference

The list below is generated directly from the aimmd.Params field definitions, so it always matches the code. Each entry shows the field’s type, default value, and description.

states_function (Callable, required)
Map an MDAnalysis trajectory or Timestep to state labels.
This callable must accept an MDAnalysis trajectory-like object (or a Timestep,
depending on your implementation) and return an array of state identifiers
(e.g., one integer or one single-character label per frame). Used to:
- detect whether a trajectory contains transitions,
- classify frames as belonging to metastable states or the reactive region.
states (str, default 'ARB')
State label specification. A compact string defining:
- the first metastable state (e.g., 'A'),
- the reactive/intermediate region label (e.g., 'R'),
- the final metastable state (e.g., 'B').
Example: 'ARB' means transitions are defined from A to B through R.
name (str, default 'AIMMD')
System name, used when creating SLURM job names.
topology (str, default 'run.gro')
Topology/structure file used for engine setup and mass lookup.
Typically a GROMACS .gro file. Used by:
- mass assignment routines,
- (in case `engine = 'gromacs') `grompp` when constructing .tpr files.
trajectory_extension (str, default '.xtc')
Trajectory file extension written and read by the engine.
Common values:
- '.xtc' : compressed coordinates (positions only),
- '.trr' : full-precision coordinates and (optionally) velocities.
Must be consistent with the engine configuration and your analysis pipeline.
engine (str, default 'gromacs')
Simulation engine backend.
Supported values:
- 'gromacs' : external GROMACS runs,
- 'toy'     : lightweight Python integrator (see `toy_mdrun`).
gmx_mdp (str, default 'run.mdp')
GROMACS .mdp file used for production segments.
Used when running shooting trajectories and free simulations.
Must be compatible with `trajectory_extension` (e.g., if you require velocities,
use settings consistent with '.trr').
gmx_grompp (str, default '/usr/bin/false grompp -maxwarn 1')
Base `grompp` command used to build .tpr files.
You may extend this command (e.g., add `-n index.ndx`), but do NOT include flags
that AIMMD injects automatically (e.g., input coordinates, output file names,
and `-nobackup` handling).
gmx_mdrun (str, default '/usr/bin/false mdrun -v -maxh 4')
Base `mdrun` command used to run dynamics. You may tune performance flags
here (MPI/OMP/GPU), but do no include `-deffnm`, `-nobackup`, and `-noappend`,
as those are add automatically by AIMMD.
Performance note: to prevent CPU oversubscription and ensure smooth
communication between GROMACS and AIMMD, set `-ntmpi` to `(cpus_per_task - 1)`.
This reserves the final CPU core exclusively for computing CVs and orchestrating
the simulation logic.
gmx_eneconv (str, default 'printf "c\nc\n" | /usr/bin/false -nobackup eneconv -settime')
Command used to merge GROMACS energy (.edr) files after two-way shooting.
This command should merge backward/forward segment energy files into a single
time-consistent .edr file (commonly via `eneconv -settime`).
Set to an empty string to disable energy file merging/saving.
toy_mdrun (Callable, default None)
Toy-engine integrator step function.
Callable that advances the system by one step for the toy engine.
It is expected to take an MDAnalysis Timestep (or equivalent) as input
and evolve it in-place, based on the chosen law of motion.
toy_slowdown (float, default 0.01)
Artificial delay per toy integration step (seconds).
Used to slow down the toy engine to emulate wall-clock behavior or to reduce
CPU usage during debugging, while allowing AIMMD manager tasks to keep up with
the simulation speed.
network (Module, default <aimmd.network.utils.PlaceholderNetwork object at 0x735d579f9940>)
Neural network model used to estimate logit-committor-like values.
The network is evaluated on descriptors (or positions if descriptors are not
provided). The default placeholder returns a trivial output.
Important:
If you load parameters from a Python params file, the network class must be
importable or defined in that same file so it can be reconstructed.
values_function (Callable, default None)
Map descriptors to scalar values (typically logit committor).
If None, AIMMD evaluates `network(descriptors)` directly.
If provided, this callable must accept an array of descriptors and return a
1D array of values (one per frame).
descriptors_function (Callable, default None)
Compute descriptors from an MDAnalysis trajectory.
If None, AIMMD uses raw positions (potentially more expensive and higher
dimensional). If provided, the callable should return an array of descriptors
(one descriptor vector per frame).
descriptor_transform (Callable, default None)
Transform applied to descriptors immediately before network evaluation.
Typical uses:
- normalization/standardization,
- feature selection,
- dimensionality transforms.
If None, no transform is applied.
network_batch_size (int, default 4096)
Maximum number of frames evaluated by the network in a single batch.
Reduce this value if you run out of GPU/CPU memory during inference.
initial_paths (List, default [])
Initial transition paths used to seed the PathEnsemble.
Accepted elements include:
- trajectory filenames (string or list of strings, regular expressions allowed),
- MDAnalysis trajectory objects,
- `aimmd.Path` objects.
Paths are validated to contain transitions according to `states_function` and
`states`. These paths initialize an `aimmd.PathEnsemble`.
chain_type (str, default 'rfps')
Path-sampling chain type.
Supported values:
- 'tps'  : transition path sampling,
- 'rfps' : rejection-free path sampling.
selection_pool_size (int, default 10)
Number of candidate paths for shooting point selection considered
at each selection step. For standard TPS (`chain_type='tps'`), this must be 1.
For RFPS, when running with `nchains_per_worker=1`, `selection_pool_size>1`
enables pool-based selection and bin rebalancing, while improving the
homogeneity of the sampled chain. As an alternative, you can run multiple
chains per worker (`nchains_per_worker>1`)
at_least_one_transition_in_pool (bool, default False)
If True: ensure each selection pool contains at least 1 transition.
If True, detailed balance is not strictly preserved, but it can reduce
stagnation near state boundaries and improve exploration.
When `selection_pool_size=1`, this option effectively reduces to TPS-like
selection, where transitions have 100% acceptance rate in the pool, and
non-transitions are always rejected.
always_select_inside_the_bins (bool, default False)
If True: ensure you always select from paths with values in the current
selection bins. This to prevent the simulations from getting stuck close to the
state boundaries.
retry_with_state_definition_glitches (bool, default False)
If True, automatically recover from transient state-definition glitches
during shooting. Occasionally the first frame of back.xtc/forw.xtc — the
shooting point itself — is classified in a different state than expected
due to slightly different PBC handling in GROMACS vs MDAnalysis, producing
a RuntimeError like "... 0 in state A, should be in R; consider deleting
the trajectory file to allow AIMMD to recreate it". When this flag is True,
AIMMD logs a warning, deletes back* and forw* in the offending chain
directory, and reselects a new shooting point on the next iteration.
When False (default), the error is re-raised and the worker exits as
before. Only the specific "should be in" error is caught; all other errors
propagate unchanged.
nbins (int, default 10)
Number of bins used to discretize value space in the reactive region.
Bins are constructed in (logit) committor/value space and used to guide
shooting point selection. Must be >= 0. 0 disables binning.
cutoff_min (float, default 0.5)
Minimum absolute value for finite bin boundaries.
Ensures that the first/last finite boundaries are not placed too close to zero
in absolute value.
cutoff_max (float, default 20.0)
Maximum absolute value for finite bin boundaries.
Finite boundaries are clipped to lie within [-cutoff_max, +cutoff_max].
If free simulations are disabled, the finite bin range typically spans
approximately `[-cutoff_max, +cutoff_max]` (with optional +-inf bins).
terminal_bin_extension (str, default '')
Extends the first and/or last bin edges to the state interfaces (+-inf).
This forces the outermost bins to capture all configurations close to the
states, increasing exploration at the cost of reduced exploitation.
Recommended for `selection_pool_size > 1`. Values: '' (disable),
'all' (apply to both edges), or directly the state names towards which you
want the extension to happen ("A", "B", "AB", etc.).
density_adjustment (Number, default inf)
Apply a correction to the density during selection to accelerate
convergence. For each shooting chain, in each bin: multiply the density by
the number of the latest `density_adjustment` shooting points already
selected in the bin. It can be combined with `density_adjustment`.
shared_density_adjustment (bool, default False)
If True: apply a correction to the density during selection to accelerate
convergence. For each shooting chain, in each bin: multiply the density by
the number of shooting points already selected in the bin from all chains
managed by the same worker, plus with that of all the shooting points currently
being employed in a path sampling simulation. It can be combined with
`local_density_adjustment`.
lorentzian (float, default inf)
Lorentzian width controlling the target distribution in value space.
If finite, shooting points are biased toward the center of the distribution
according to a Lorentzian in logit/value space.
If `inf`, shooting points are sampled approximately uniformly between the first
and last finite bin boundaries.
free_overriding_states (str, default '')
Enable occasional shooting point selection from free simulations near states.
If non-empty, AIMMD may override the usual selection and draw shooting points
from free-simulation segments around selected states.
- If 'all': allow overriding around all states.
- If empty: disable overriding.
Warning: enabling this can slow down selection since you must reload the
free simulations every time.
free_overriding_attempts (int, default 100)
Number of frames from the free simulations considered for overriding.
Higher values increase the chance of finding a usable free-simulation shooting
point but can increase overhead.
free_overriding_bins (List, default [0, -1])
Bins where overriding is allowed, following the same logic as numpy array
indexing. For example, `free_overriding_bins = [0, 1]` will consider only the
first and last selection bin for overrding. `free_overriding_bins = None` will
consider all bins for overriding.
free_overriding_recovery_rate (float, default 0.05)
Probability of overriding within the same bin as the previous shooting point.
This is a “recovery” mechanism that can preserve local continuity, as orverriding
is intended to happen only if the new shooting point has changed selection bin
compared to the previous one. Too large values may disrupt the Markov chain
(excessive overrides).
restart_free_simulations_with_transitions (str, default '')
Restart free simulations from AIMMD-sampled transition for selected states.
If non-empty, free simulations targeting specified states are be restarted from
the last frames of randomly sampled transition paths rather than from the most
recent state crossing observed in the previous free simulation.
Accepted elements include:
- a list of states in capital letters (eg. 'AB'),
- 'all', which means that you consider *all* free simulations, regardless of
their target state.
gen_temperature (float, default 300.0)
Velocity generation temperature (Kelvin).
If > 0: generate new velocities at this temperature.
If < 0: reuse velocities from the parent trajectory (requires
`trajectory_extension == '.trr'` so velocities are available).
max_length (int, default 50000)
Maximum allowed trajectory length (frames) for a single path.
Prevents simulations from running indefinitely in long-lived intermediates.
Paths exceeding this length are typically truncated/terminated by the engine
control logic.
extra_free_frames (int, default 0)
Extra frames to continue after reaching the target state in free simulations.
If > 0, free simulations do not stop immediately upon reaching the target
state, but continue for `extra_free_frames` additional frames.
fit (Callable, default default)
Callable that fits network parameters to PathEnsemble data.
Expected signature (conceptually):
- positional: (network, pathensemble)
- optional keyword args: verbose, worker
This callable is invoked by AIMMD training logic to update `params.network`.
rescale_committor (bool, default False)
Rescale network outputs to enforce expected committor boundary behavior.
If True, AIMMD rescales the model output to better match the expected crossing
probabilities near the states (heuristically ~1/p from A and ~1/(1-p) from B,
where p is the committor), assuming sufficiently small time between frames.
Requires that `params.network` is a subclass of `aimmd.network.Rescalable`.
Experimental: recommended only when also running free simulations.
reweight_parameters (dict, default {'free_threshold': 20})
Dictionary of parameters for path reweighting and rate/free-energy estimation.
Passed to `pathensemble.reweight(...)`. Typical entries control thresholds for
including free-simulation data and regularization choices.
trajectory_update_batch_size (int, default 1000)
Number of frames registered/processed per update batch.
Controls how many frames are appended or indexed per internal update step.
During an AIMMD production run, the simulations stop if states and descriptors
computations are not catching up, and getting behind by `trajectory_update_batch_size`
or more. Reduce this when the simulation engine produces new frames much faster than
you can analyze them or if memory spikes while loading and analyzing trajectories.
network_save_interval (int, default 10)
Save network parameters every N shooting iterations.
If 10, the model is saved after every 10 accepted/attempted shooting moves
(depending on the higher-level training loop).
slurm_header (str, default '#SBATCH --mail-type=FAIL')
Default SLURM header lines inserted into generated job scripts.
Do NOT include:
- shebang (`#!/bin/bash`),
- job name,
- walltime,
- node count.
Those are set automatically by AIMMD.
Scheduling model:
- each shooting/free worker uses one SLURM task,
- trainer takes an additional task.
record_bias (bool, default False)
If True, record the instantaneous bias potential for each trajectory frame.
The bias is extracted by `bias_function` and cached as `<traj>.bias.npy` alongside
each trajectory file. Only when `record_bias=True` are bias caches computed and
Tiwary-Parrinello-corrected rate estimates printed during training.
Set to False (default) for unbiased runs; existing runs are fully unaffected.
bias_function (Callable, default None)
Callable that extracts the bias potential for each frame, in kT units (dimensionless).
Two calling conventions are supported (selected by `bias_source`):

- `bias_source = 'reader'` (default, toy/position-based):
      bias_function(trajectory_reader) -> ndarray of shape (n_frames,)
  Same convention as `states_function`. Called per-batch by `path.compute(...)`.

- `bias_source = 'file'` (PLUMED/GROMACS):
      bias_function(fname: str) -> ndarray of shape (n_frames_in_file,)
  Receives the trajectory file path; the function locates the associated PLUMED
  output (e.g. COLVAR file) and returns bias values for ALL frames in the file.
  No re-running of PLUMED is required.

In both modes, results are cached as `<traj>.bias.npy` and accessed via `path.bias`.
bias_source (str, default 'reader')
Determines the calling convention of `bias_function`. Supported values:
- 'reader' : bias_function(trajectory_reader) -> ndarray  [default; toy/position-based]
- 'file'   : bias_function(fname: str) -> ndarray         [PLUMED/GROMACS file-based]
See `bias_function` for details on each mode.
bias_reactive_threshold (float, default 0.5)
Maximum acceptable mean |bias| (in kT) in the reactive region R.
After bias computation, the training worker checks the mean absolute bias over all
frames whose state label equals the reactive-region label (e.g. 'R' in 'ARB').
If the mean exceeds this threshold, a warning is printed. This validates the
Tiwary-Parrinello assumption that the bias is negligible inside R.

In a multi-system run this may be a single float (applied to every system) or a
list of floats, one per entry of `system_ids` (each system's bias is checked
against its own threshold).
multi_system (bool, default False)
Enable multi-system (multi-ligand) mode. When False (default) AIMMD behaves
exactly as a single-system run. When True, one params file orchestrates several
chemical systems at once: per-system fields (`topology`, `initial_paths`) become
lists (one entry per system), each system runs in its own subfolder
`<run>/<system_id>/`, and the user data functions (`states_function`,
`descriptors_function`, `values_function`) receive an extra `system_id` keyword
(passed only if their signature accepts it, so existing single-system functions
keep working unchanged).
multi_system_share_network (bool, default False)
Train ONE shared committor network across all systems (only meaningful when
`multi_system=True`). When False, every system gets its own network file and its
own trainer (the trainers may share a GPU, see `trainers_share_gpu`). When True,
a single network is trained by one trainer that passes the `fit` function a LIST
of per-system PathEnsembles; the shared network is stored once at the run-folder
root and read by every system's shooting workers. Rates/kinetics are still
computed per system, in sequence.
system_ids (List, default [])
Per-system labels for a multi-system run (e.g. ['G2', 'G4']). They name the
per-system subfolders `<run>/<system_id>/` and index the per-system entries of
list-valued fields (`topology`, `initial_paths`). If left empty in multi-system
mode, defaults to ['0', '1', ...] inferred from the number of topologies.
atom_types (List, default None)
Fixed, ordered list of MDAnalysis atom-type strings defining the shared
one-hot graph node encoding (e.g. ['H','C','N','O','F','NA','P','S','CL','BR','I']).
When None (default) the graph encoding is derived per-universe from
`sorted(set(universe.atoms.types))` (legacy single-system behaviour). A fixed
table is what lets one graph network consume graphs from multiple systems: every
system encodes into the same columns and the network input width must equal
`len(atom_types)`. Forwarded to `aimmd.network.graph_utils.get_graphs_pyg`.
trainers_share_gpu (bool, default True)
When `multi_system=True` and `multi_system_share_network=False`, each system
has its own trainer. If True (default), all of a run's per-system trainers are
bound to the SAME GPU (one shared device); if False they are spread across
distinct GPUs. Ignored when a single shared network is trained (then there is
only one trainer).
subsample_caps (dict, default None)
Optional caps that bound the per-round committor *value pass* (and the bin
generation / reweighting / rate estimate that consume it) by evaluating them on a
randomly subsampled slice of the path ensemble instead of every reactive frame.
`fit` (network training) is unaffected and still sees the full ensemble.

When None (default) NO subsampling happens and behaviour is identical to before.
When a dict, the recognised keys are:

- 'shot'     : max number of PATHS kept *per shot-excursion direction-type*.
               Each of sAA, sAB, sBA, sBB is capped independently, so a value of
               100 keeps up to 4*100 = 400 shot paths per system.
- 'free'     : max number of PATHS kept *per free-excursion direction-type*.
               Each of fAA, fAB, fBA, fBB is capped independently, so a value of
               500 keeps up to 4*500 = 2000 free paths per system.
- 'in_state' : max number of FRAMES kept per state (the in-A and in-B paths are
               kept until this many frames are reached, per state, per system).

A missing key means that category is left uncapped. The subsample is drawn fresh
each round (uniformly within each category, so reweighting stays consistent;
in-state-only paths carry zero reweight so never bias the rate). In a multi-system
run this may be a single dict (applied to every system) or a list of dicts/None,
one per entry of `system_ids`. Pick caps generously (e.g. shot=100, free=500).
path (Path, default PosixPath('.'))
Base working directory for engine operations.
Engine commands (GROMACS/toy) are executed relative to this path.
Set automatically on load; typically not user-assigned.

See Also

For the Params class methods and properties, see Params.