w_red

usage:

w_red [-h] [-r RCFILE] [--quiet] [--verbose] [--version] [--max-queue-length MAX_QUEUE_LENGTH]
            [--debug] [--terminal]
            [--serial | --parallel | --work-manager WORK_MANAGER] [--n-workers N_WORKERS]
            [--zmq-mode MODE] [--zmq-comm-mode COMM_MODE] [--zmq-write-host-info INFO_FILE]
            [--zmq-read-host-info INFO_FILE] [--zmq-upstream-rr-endpoint ENDPOINT]
            [--zmq-upstream-ann-endpoint ENDPOINT] [--zmq-downstream-rr-endpoint ENDPOINT]
            [--zmq-downstream-ann-endpoint ENDPOINT] [--zmq-master-heartbeat MASTER_HEARTBEAT]
            [--zmq-worker-heartbeat WORKER_HEARTBEAT] [--zmq-timeout-factor FACTOR]
            [--zmq-startup-timeout STARTUP_TIMEOUT] [--zmq-shutdown-timeout SHUTDOWN_TIMEOUT]

optional arguments:

-h, --help            show this help message and exit

general options:

-r RCFILE, --rcfile RCFILE: use RCFILE as the WEST run-time configuration file (default: west.cfg)
--quiet: emit only essential information
--verbose: emit extra information
--version: show program’s version number and exit

parallelization options:

--max-queue-length MAX_QUEUE_LENGTH
                      Maximum number of tasks that can be queued. Useful to limit RAM use for tasks that
                      have very large requests/response. Default: no limit.

parallelization options:

--serial              run in serial mode
--parallel            run in parallel mode (using processes)
--work-manager WORK_MANAGER

westpa.cli.tools.w_red module

westpa.cli.tools.w_red.H5File: alias of File

class westpa.cli.tools.w_red.WESTParallelTool(wm_env=None)

Bases: WESTTool

Base class for command-line tools parallelized with wwmgr. This automatically adds and processes wwmgr command-line arguments and creates a work manager at self.work_manager.

add_args(parser): Add arguments specific to this tool to the given argparse parser.

go(): Perform the analysis associated with this tool.

main(): A convenience function to make a parser, parse and process arguments, then run self.go() in the master process.

make_parser_and_process(prog=None, usage=None, description=None, epilog=None, args=None): A convenience function to create a parser, call add_all_args(), and then call process_all_args(). The argument namespace is returned.

process_args(args): Take argparse-processed arguments associated with this tool and deal with them appropriately (setting instance variables, etc)

westpa.cli.tools.w_red.trapezoid(y, x=None, dx=1.0, axis=-1)

Integrate along the given axis using the composite trapezoidal rule.

If x is provided, the integration happens in sequence along its elements - they are not sorted.

Integrate y (x) along each 1d slice on the given axis, compute \(\int y(x) dx\). When x is specified, this integrates along the parametric curve, computing \(\int_t y(t) dt = \int_t y(t) \left.\frac{dx}{dt}\right|_{x=x(t)} dt\).

Added in version 2.0.0.

Parameters:

y (array_like) – Input array to integrate.
x (array_like, optional) – The sample points corresponding to the y values. If x is None, the sample points are assumed to be evenly spaced dx apart. The default is None.
dx (scalar, optional) – The spacing between sample points when x is None. The default is 1.
axis (int, optional) – The axis along which to integrate.

Returns:

trapezoid – Definite integral of y = n-dimensional array as approximated along a single axis by the trapezoidal rule. If y is a 1-dimensional array, then the result is a float. If n is greater than 1, then the result is an n-1 dimensional array.

Return type:

float or ndarray

See also

sum, cumsum

Notes

Image [2] illustrates trapezoidal rule – y-axis locations of points will be taken from y array, by default x-axis distances between points will be 1.0, alternatively they can be provided with x array or with dx scalar. Return value will be equal to combined area under the red lines.

References

Examples

>>> import numpy as np

Use the trapezoidal rule on evenly spaced points:

>>> np.trapezoid([1, 2, 3])
4.0

The spacing between sample points can be selected by either the x or dx arguments:

>>> np.trapezoid([1, 2, 3], x=[4, 6, 8])
8.0
>>> np.trapezoid([1, 2, 3], dx=2)
8.0

Using a decreasing x corresponds to integrating in reverse:

>>> np.trapezoid([1, 2, 3], x=[8, 6, 4])
-8.0

More generally x is used to integrate along a parametric curve. We can estimate the integral \(\int_0^1 x^2 = 1/3\) using:

>>> x = np.linspace(0, 1, num=50)
>>> y = x**2
>>> np.trapezoid(y, x)
0.33340274885464394

Or estimate the area of a circle, noting we repeat the sample which closes the curve:

>>> theta = np.linspace(0, 2 * np.pi, num=1000, endpoint=True)
>>> np.trapezoid(np.cos(theta), x=np.sin(theta))
3.141571941375841

np.trapezoid can be applied along a specified axis to do multiple computations in one call:

>>> a = np.arange(6).reshape(2, 3)
>>> a
array([[0, 1, 2],
       [3, 4, 5]])
>>> np.trapezoid(a, axis=0)
array([1.5, 2.5, 3.5])
>>> np.trapezoid(a, axis=1)
array([2.,  8.])

class westpa.cli.tools.w_red.DurationCorrector(durations, weights, dtau, maxduration=None)

Bases: object

static from_kinetics_file(directh5, istate, fstate, dtau, n_iters=None)

property event_duration_histogram

property cumulative_event_duration_histogram

correction(iters, freqs=None)

Return the correction factor

t=theta tau=t |

|     |                 |
|       | ~                 |
|       | f(tau) dtau dt    |      * maxduration

| | |

t=0 tau=0 |

|_ _|

where: ~` ^ f(tau) is proportional to f(tau)/(theta-tau), and is normalized to

^

integrate to 1, and f(tau) is sum of the weights of walkers with duration time tau.

westpa.cli.tools.w_red.get_raw_rates(directh5, istate, fstate, n_iters=None)

westpa.cli.tools.w_red.calc_avg_rate(directh5_path, istate, fstate, **kwargs)

Return the raw or RED-corrected rate constant with the confidence interval.

Parameters:

nstiter (duration of each iteration (number of steps))
ntpr (report inteval (number of steps))

westpa.cli.tools.w_red.calc_rates(directh5_path, istate, fstate, **kwargs)

Return the raw and RED-corrected rate constants vs. iterations. This code is faster than calling calc_rate() iteratively

Parameters:

nstiter (duration of each iteration (number of steps))
ntpr (report inteval (number of steps))

class westpa.cli.tools.w_red.RateCalculator(directh5, istate, fstate, assignh5=None, **kwargs)

Bases: object

property conditional_fluxes

property populations

property tau

property dtau

property istate

property fstate

property n_iters

calc_rate(i_iter=None, red=False, **kwargs)

calc_rates(n_iters=None, **kwargs)

class westpa.cli.tools.w_red.WRed

Bases: WESTParallelTool

prog = 'w_red'

description = 'Apply the RED scheme to estimate steady-state WE fluxes from\nshorter trajectories.\n\n-----------------------------------------------------------------------------\nSource data\n-----------------------------------------------------------------------------\n\nSource data is provided as a w_ipa "scheme" which is typically defined\nin the west.cfg file. For instance, if a user wishes to estimate RED\nfluxes for a scheme named "DEFAULT" that argument would be provided\nto w_red and WRed would estimate RED fluxes based off of the data\ncontained in the assign.h5 and direct.h5 files in ANALYSIS/DEFAULT.\n\n'

go(): Perform the analysis associated with this tool.

westpa.cli.tools.w_red.entry_point()