Common setups

OpenPathSampling is very flexible and simplifies many different approaches to path sampling. Since it is easy to get lost under all those options, here we summarize the most common setups of networks and move schemes for transition path sampling and transition interface sampling.

Throughout the following, we assume that A, B, and C are volumes that represent states. We assume that interfacesA is a list of interfaces leaving state A, and that interfacesAB is a list of interfaces leaving state A in the expected direction of B. Similarly, we expect orderparameterA is a collective variable describing the process of leaving A, and orderparameterAB is a CV for leaving A toward B.

Transition Path Sampling

Transition networks for TPS

For all transition path sampling setups, you can use either fixed path length ensembles or flexible path length ensembles. The fixed path length ensembles are created with the FixedLengthTPSNetwork, while the flexible path length ensembles are created with the TPSNetwork. The interfaces to these classes are the same, except that any method to create a FixedLengthTPSNetwork requires an extra length parameter. The same network classes are used for both multiple state TPS and 2-state TPS.

Unidirectional two-state TPS

The standard initialization of the TPS network objects takes the parameters initial_states and final_states. If you want a TPSNetwork from state A to state B, that can be created with:

network = paths.TPSNetwork(initial_states=A, final_states=B)

This will only sample the \(A\to B\) transitions. The TPS examples for alanine dipeptide give practical illustrations of this for both fixed-length and flexible-length ensembles.

Bidirectional two-state TPS

If you want to sample both the \(A\to B\) transitions and the \(B\to A\) transitions in one TPS simulation, then you can achieve the desired sampling ensemble in several ways.

First, you could use the approach as above, but using initial_states=[A,B] and final_states=[A,B]. But there is a shortcut for this (particularly useful when there are many states) with

network = paths.TPSNetwork.from_states_all_to_all([A,B])

Both of these approaches ignore the self-transitions (\(A\to A\) and \(B\to B\)). You can also explicitly create the transitions with the TPSNetwork.from_state_pairs() method:

network = paths.TPSNetwork.from_state_pairs([(A,B), (B,A)])

Multiple-state TPS

The approaches for bidirectional 2-state TPS can be directly generalized to multiple states. By default, the multiple state ensemble ignores self-transitions (\(A\to A\)) if created with either the standard initialization or with from_states_all_to_all. If you would like to include the self-transitions (not likely), then add the parameter allow_self_transitions=True to either the standard initialization or to from_states_all_to_all.

The method from_state_pairs() will allow self-transitions if you explicitly include them. In practice, from_state_pairs() is most useful when you only want to include certain transitions. For example, if you have states A, B, and C, but only want to include the transitions \(A\to B\), \(A\to C\), and \(B\to C\), this is the method to use. You’d create the network with

network = paths.TPSNetwork.from_state_pairs([(A,B), (A,C), (B,C)])

Move schemes for TPS

Often, when using TPS (and especially when using flexible-length TPS), the entire move scheme consists of a single shooting mover. A move scheme consisting of a single one-way shooting move can be created with the OneWayShootingMoveScheme. The common way to set this up is:

scheme = paths.OneWayShootingScheme(network, selector, engine)

where network would be the (TPS) network, selector is a shooting point selector (usually an instance of UniformSelector), and engine is the desired dynamics engine.

Transition Interface Sampling

Transition networks for TIS

As with TPS, the 2-state system in TIS is just a special case of the multiple-state approach, so we use the same network classes to create 2-state systems as multiple-state systems.

Unidirectional two-state TIS

For unidirectional 2-state TIS (only studying the transition \(A\to B\), not \(B\to A\)), we use the MISTISNetwork with only one transition listed:

network = paths.MISTISNetwork([(A, interfacesAB, B)])

This will sample the transition from A to B using the InterfaceSet interfaces.

Bidirectional two-state TIS

For bidirectional 2-state TIS (simultaneously studying both the \(A\to B\) transition and the \(B\to A\) transition), you could use a MISTISNetwork as in the unidirectional case, but giving both transitions instead. However, using the MSTISNetwork is a little simpler, and gives completely equivalent results:

network = paths.MSTISNetwork([(A, interfacesA),
                              (B, interfacesB)])

Multiple-state TIS

The network for the standard multiple state TIS, where there is one set of interfaces for each state, is given by straightforward extension of the bidirectional 2-state case to more states. Illustrations of this are in the toy model MSTIS example, and in the alanine dipeptide MSTIS example.

If you wish to only focus on certain final states from a particular initial states, or if you want to use more than one interface set per initial state, then you need to use the multiple interface set variant of multiple state TIS. This is given by straightforward extension of the unidirectional case to more transitions. An illustration of this is in the toy model MISTIS example.

More details on the distinctions between the MSTIS network and the MISTIS networks are in the “Which network should I use” section.

Move schemes for TIS

Here we’ll discuss some standard and simple move schemes for TIS, which tend to be significantly more complicated than for TPS. If you want a much more complicated move scheme, it is usually good to start with one of these basic move schemes, and then to use the MoveStrategy objects to modify the scheme.

Standard TIS scheme

The default TIS scheme includes one-way shooting (uniform shooting point selection) for each TIS and multiple state ensemble, path reversal movers on those same ensembles, a minus mover for each state, and nearest-neighbor replica exchange. The probabilities of choosing each move type are designed such that, for each ensemble, path reversal and replica exchange are tried half as frequently as shooting. The minus move is tried 1/5 as frequently as shooting.

This move scheme is generated with

scheme = paths.DefaultScheme(network, engine)