class KineticsSubcommands(WESTSubcommand):
'''Base class for common options for both kinetics schemes'''
def __init__(self, parent):
super(KineticsSubcommands, self).__init__(parent)
self.progress = ProgressIndicatorComponent()
self.data_reader = WESTDataReader()
self.iter_range = IterRangeSelection()
self.output_file = None
self.assignments_file = None
self.do_compression = True
def add_args(self, parser):
self.data_reader.add_args(parser)
self.iter_range.add_args(parser)
iogroup = parser.add_argument_group('input/output options')
iogroup.add_argument(
'-a',
'--assignments',
default='assign.h5',
help='''Bin assignments and macrostate definitions are in ASSIGNMENTS
(default: %(default)s).''')
# default_kinetics_file will be picked up as a class attribute from the appropriate
# subclass
iogroup.add_argument(
'-o',
'--output',
dest='output',
default=self.default_kinetics_file,
help='''Store results in OUTPUT (default: %(default)s).''')
iogroup.add_argument(
'--no-compression',
dest='compression',
action='store_false',
help=
'''Do not store kinetics results compressed. This can increase disk
use about 100-fold, but can dramatically speed up subsequent analysis
for "w_kinavg matrix". Default: compress kinetics results.'''
)
self.progress.add_args(parser)
parser.set_defaults(compression=True)
def process_args(self, args):
self.progress.process_args(args)
self.assignments_file = h5io.WESTPAH5File(args.assignments, 'r')
self.data_reader.process_args(args)
with self.data_reader:
self.iter_range.process_args(args)
self.output_file = h5io.WESTPAH5File(args.output,
'w',
creating_program=True)
h5io.stamp_creator_data(self.output_file)
if not self.iter_range.check_data_iter_range_least(
self.assignments_file):
raise ValueError(
'assignments do not span the requested iterations')
self.do_compression = args.compression
class KineticsSubcommands(WESTSubcommand):
'''Base class for common options for both kinetics schemes'''
def __init__(self, parent):
super(KineticsSubcommands,self).__init__(parent)
self.progress = ProgressIndicatorComponent()
self.data_reader = WESTDataReader()
self.iter_range = IterRangeSelection()
self.output_file = None
self.assignments_file = None
self.do_compression = True
def add_args(self, parser):
self.data_reader.add_args(parser)
self.iter_range.add_args(parser)
iogroup = parser.add_argument_group('input/output options')
iogroup.add_argument('-a', '--assignments', default='assign.h5',
help='''Bin assignments and macrostate definitions are in ASSIGNMENTS
(default: %(default)s).''')
# default_kinetics_file will be picked up as a class attribute from the appropriate
# subclass
iogroup.add_argument('-o', '--output', dest='output', default=self.default_kinetics_file,
help='''Store results in OUTPUT (default: %(default)s).''')
iogroup.add_argument('--no-compression', dest='compression', action='store_false',
help='''Do not store kinetics results compressed. This can increase disk
use about 100-fold, but can dramatically speed up subsequent analysis
for "w_kinavg matrix". Default: compress kinetics results.''')
self.progress.add_args(parser)
parser.set_defaults(compression=True)
def process_args(self, args):
self.progress.process_args(args)
self.assignments_file = h5io.WESTPAH5File(args.assignments, 'r')
self.data_reader.process_args(args)
with self.data_reader:
self.iter_range.process_args(args)
self.output_file = h5io.WESTPAH5File(args.output, 'w', creating_program=True)
h5io.stamp_creator_data(self.output_file)
if not self.iter_range.check_data_iter_range_least(self.assignments_file):
raise ValueError('assignments do not span the requested iterations')
self.do_compression = args.compression
class KinAvgSubcommands(WESTSubcommand):
'''Common argument processing for w_kinavg subcommands'''
def __init__(self, parent):
super(KinAvgSubcommands,self).__init__(parent)
self.data_reader = WESTDataReader()
self.iter_range = IterRangeSelection()
self.progress = ProgressIndicatorComponent()
self.output_filename = None
self.kinetics_filename = None
self.assignment_filename = None
self.output_file = None
self.assignments_file = None
self.kinetics_file = None
self.evolution_mode = None
self.mcbs_alpha = None
self.mcbs_acalpha = None
self.mcbs_nsets = None
def stamp_mcbs_info(self, dataset):
dataset.attrs['mcbs_alpha'] = self.mcbs_alpha
dataset.attrs['mcbs_acalpha'] = self.mcbs_acalpha
dataset.attrs['mcbs_nsets'] = self.mcbs_nsets
def add_args(self, parser):
self.progress.add_args(parser)
self.data_reader.add_args(parser)
self.iter_range.include_args['iter_step'] = True
self.iter_range.add_args(parser)
iogroup = parser.add_argument_group('input/output options')
iogroup.add_argument('-a', '--assignments', default='assign.h5',
help='''Bin assignments and macrostate definitions are in ASSIGNMENTS
(default: %(default)s).''')
# self.default_kinetics_file will be picked up as a class attribute from the appropriate subclass
iogroup.add_argument('-k', '--kinetics', default=self.default_kinetics_file,
help='''Populations and transition rates are stored in KINETICS
(default: %(default)s).''')
iogroup.add_argument('-o', '--output', dest='output', default='kinavg.h5',
help='''Store results in OUTPUT (default: %(default)s).''')
cgroup = parser.add_argument_group('confidence interval calculation options')
cgroup.add_argument('--alpha', type=float, default=0.05,
help='''Calculate a (1-ALPHA) confidence interval'
(default: %(default)s)''')
cgroup.add_argument('--autocorrel-alpha', type=float, dest='acalpha', metavar='ACALPHA',
help='''Evaluate autocorrelation to (1-ACALPHA) significance.
Note that too small an ACALPHA will result in failure to detect autocorrelation
in a noisy flux signal. (Default: same as ALPHA.)''')
cgroup.add_argument('--nsets', type=int,
help='''Use NSETS samples for bootstrapping (default: chosen based on ALPHA)''')
cogroup = parser.add_argument_group('calculation options')
cogroup.add_argument('-e', '--evolution-mode', choices=['cumulative', 'blocked', 'none'], default='none',
help='''How to calculate time evolution of rate estimates.
``cumulative`` evaluates rates over windows starting with --start-iter and getting progressively
wider to --stop-iter by steps of --step-iter.
``blocked`` evaluates rates over windows of width --step-iter, the first of which begins at
--start-iter.
``none`` (the default) disables calculation of the time evolution of rate estimates.''')
cogroup.add_argument('--window-frac', type=float, default=1.0,
help='''Fraction of iterations to use in each window when running in ``cumulative`` mode.
The (1 - frac) fraction of iterations will be discarded from the start of each window.''')
def open_files(self):
self.output_file = h5io.WESTPAH5File(self.output_filename, 'w', creating_program=True)
h5io.stamp_creator_data(self.output_file)
self.assignments_file = h5io.WESTPAH5File(self.assignments_filename, 'r')#, driver='core', backing_store=False)
self.kinetics_file = h5io.WESTPAH5File(self.kinetics_filename, 'r')#, driver='core', backing_store=False)
if not self.iter_range.check_data_iter_range_least(self.assignments_file):
raise ValueError('assignments data do not span the requested iterations')
if not self.iter_range.check_data_iter_range_least(self.kinetics_file):
raise ValueError('kinetics data do not span the requested iterations')
def process_args(self, args):
self.progress.process_args(args)
self.data_reader.process_args(args)
with self.data_reader:
self.iter_range.process_args(args, default_iter_step=None)
if self.iter_range.iter_step is None:
#use about 10 blocks by default
self.iter_range.iter_step = max(1, (self.iter_range.iter_stop - self.iter_range.iter_start) // 10)
self.output_filename = args.output
self.assignments_filename = args.assignments
self.kinetics_filename = args.kinetics
self.mcbs_alpha = args.alpha
self.mcbs_acalpha = args.acalpha if args.acalpha else self.mcbs_alpha
self.mcbs_nsets = args.nsets if args.nsets else mclib.get_bssize(self.mcbs_alpha)
self.evolution_mode = args.evolution_mode
self.evol_window_frac = args.window_frac
if self.evol_window_frac <= 0 or self.evol_window_frac > 1:
raise ValueError('Parameter error -- fractional window defined by --window-frac must be in (0,1]')
class StateProbTool(WESTParallelTool):
prog='w_stateprobs'
description = '''\
Calculate average populations and associated errors in state populations from
weighted ensemble data. Bin assignments, including macrostate definitions,
are required. (See "w_assign --help" for more information).
-----------------------------------------------------------------------------
Output format
-----------------------------------------------------------------------------
The output file (-o/--output, usually "stateprobs.h5") contains the following
dataset:
/avg_state_pops [state]
(Structured -- see below) Population of each state across entire
range specified.
If --evolution-mode is specified, then the following additional dataset is
available:
/state_pop_evolution [window][state]
(Structured -- see below). State populations based on windows of
iterations of varying width. If --evolution-mode=cumulative, then
these windows all begin at the iteration specified with
--start-iter and grow in length by --step-iter for each successive
element. If --evolution-mode=blocked, then these windows are all of
width --step-iter (excluding the last, which may be shorter), the first
of which begins at iteration --start-iter.
The structure of these datasets is as follows:
iter_start
(Integer) Iteration at which the averaging window begins (inclusive).
iter_stop
(Integer) Iteration at which the averaging window ends (exclusive).
expected
(Floating-point) Expected (mean) value of the rate as evaluated within
this window, in units of inverse tau.
ci_lbound
(Floating-point) Lower bound of the confidence interval on the rate
within this window, in units of inverse tau.
ci_ubound
(Floating-point) Upper bound of the confidence interval on the rate
within this window, in units of inverse tau.
corr_len
(Integer) Correlation length of the rate within this window, in units
of tau.
Each of these datasets is also stamped with a number of attributes:
mcbs_alpha
(Floating-point) Alpha value of confidence intervals. (For example,
*alpha=0.05* corresponds to a 95% confidence interval.)
mcbs_nsets
(Integer) Number of bootstrap data sets used in generating confidence
intervals.
mcbs_acalpha
(Floating-point) Alpha value for determining correlation lengths.
-----------------------------------------------------------------------------
Command-line options
-----------------------------------------------------------------------------
'''
def __init__(self):
super(StateProbTool,self).__init__()
self.data_reader = WESTDataReader()
self.iter_range = IterRangeSelection()
self.progress = ProgressIndicatorComponent()
self.output_filename = None
self.kinetics_filename = None
self.output_file = None
self.assignments_file = None
self.evolution_mode = None
self.mcbs_alpha = None
self.mcbs_acalpha = None
self.mcbs_nsets = None
def stamp_mcbs_info(self, dataset):
dataset.attrs['mcbs_alpha'] = self.mcbs_alpha
dataset.attrs['mcbs_acalpha'] = self.mcbs_acalpha
dataset.attrs['mcbs_nsets'] = self.mcbs_nsets
def add_args(self, parser):
self.progress.add_args(parser)
self.data_reader.add_args(parser)
self.iter_range.include_args['iter_step'] = True
self.iter_range.add_args(parser)
iogroup = parser.add_argument_group('input/output options')
iogroup.add_argument('-a', '--assignments', default='assign.h5',
help='''Bin assignments and macrostate definitions are in ASSIGNMENTS
(default: %(default)s).''')
iogroup.add_argument('-o', '--output', dest='output', default='stateprobs.h5',
help='''Store results in OUTPUT (default: %(default)s).''')
cgroup = parser.add_argument_group('confidence interval calculation options')
cgroup.add_argument('--alpha', type=float, default=0.05,
help='''Calculate a (1-ALPHA) confidence interval'
(default: %(default)s)''')
cgroup.add_argument('--autocorrel-alpha', type=float, dest='acalpha', metavar='ACALPHA',
help='''Evaluate autocorrelation to (1-ACALPHA) significance.
Note that too small an ACALPHA will result in failure to detect autocorrelation
in a noisy flux signal. (Default: same as ALPHA.)''')
cgroup.add_argument('--nsets', type=int,
help='''Use NSETS samples for bootstrapping (default: chosen based on ALPHA)''')
cogroup = parser.add_argument_group('calculation options')
cogroup.add_argument('-e', '--evolution-mode', choices=['cumulative', 'blocked', 'none'], default='none',
help='''How to calculate time evolution of rate estimates.
``cumulative`` evaluates rates over windows starting with --start-iter and getting progressively
wider to --stop-iter by steps of --step-iter.
``blocked`` evaluates rates over windows of width --step-iter, the first of which begins at
--start-iter.
``none`` (the default) disables calculation of the time evolution of rate estimates.''')
def open_files(self):
self.output_file = h5io.WESTPAH5File(self.output_filename, 'w', creating_program=True)
h5io.stamp_creator_data(self.output_file)
self.assignments_file = h5io.WESTPAH5File(self.assignments_filename, 'r')#, driver='core', backing_store=False)
if not self.iter_range.check_data_iter_range_least(self.assignments_file):
raise ValueError('assignments data do not span the requested iterations')
def process_args(self, args):
self.progress.process_args(args)
self.data_reader.process_args(args)
with self.data_reader:
self.iter_range.process_args(args, default_iter_step=None)
if self.iter_range.iter_step is None:
#use about 10 blocks by default
self.iter_range.iter_step = max(1, (self.iter_range.iter_stop - self.iter_range.iter_start) // 10)
self.output_filename = args.output
self.assignments_filename = args.assignments
self.mcbs_alpha = args.alpha
self.mcbs_acalpha = args.acalpha if args.acalpha else self.mcbs_alpha
self.mcbs_nsets = args.nsets if args.nsets else mclib.get_bssize(self.mcbs_alpha)
self.evolution_mode = args.evolution_mode
def calc_state_pops(self):
start_iter, stop_iter = self.iter_range.iter_start, self.iter_range.iter_stop
nstates = self.nstates
state_map = self.state_map
iter_count = stop_iter-start_iter
pi = self.progress.indicator
pi.new_operation('Calculating state populations')
pops = h5io.IterBlockedDataset(self.assignments_file['labeled_populations'])
iter_state_pops = numpy.empty((nstates+1,), weight_dtype)
all_state_pops = numpy.empty((iter_count,nstates+1), weight_dtype)
avg_state_pops = numpy.zeros((nstates+1,), weight_dtype)
pops.cache_data(max_size='available')
try:
for iiter,n_iter in enumerate(xrange(start_iter,stop_iter)):
iter_state_pops.fill(0)
labeled_pops = pops.iter_entry(n_iter)
accumulate_state_populations_from_labeled(labeled_pops, state_map, iter_state_pops, check_state_map=False)
all_state_pops[iiter] = iter_state_pops
avg_state_pops += iter_state_pops
del labeled_pops
pi.progress += 1
finally:
pops.drop_cache()
self.output_file.create_dataset('state_pops', data=all_state_pops, compression=9, shuffle=True)
h5io.stamp_iter_range(self.output_file['state_pops'], start_iter, stop_iter)
self.all_state_pops = all_state_pops
avg_state_pops = numpy.zeros((nstates+1,), ci_dtype)
pi.new_operation('Calculating overall average populations and CIs', nstates)
# futures = []
# for istate in xrange(nstates):
# futures.append(self.work_manager.submit(_eval_block,kwargs=dict(iblock=None,istate=istate,
# start=start_iter,stop=stop_iter,
# state_pops=all_state_pops[:,istate],
# mcbs_alpha=self.mcbs_alpha, mcbs_nsets=self.mcbs_nsets,
# mcbs_acalpha = self.mcbs_acalpha)))
# for future in self.work_manager.as_completed(futures):
def taskgen():
for istate in xrange(nstates):
yield (_eval_block, (), dict(iblock=None,istate=istate,
start=start_iter,stop=stop_iter,
state_pops=all_state_pops[:,istate],
mcbs_alpha=self.mcbs_alpha, mcbs_nsets=self.mcbs_nsets,
mcbs_acalpha = self.mcbs_acalpha))
for future in self.work_manager.submit_as_completed(taskgen(), self.max_queue_len):
(_iblock,istate,ci_res) = future.get_result(discard=True)
avg_state_pops[istate] = ci_res
pi.progress += 1
self.output_file['avg_state_pops'] = avg_state_pops
self.stamp_mcbs_info(self.output_file['avg_state_pops'])
pi.clear()
maxlabellen = max(map(len,self.state_labels))
print('average state populations:')
for istate in xrange(nstates):
print('{:{maxlabellen}s}: mean={:21.15e} CI=({:21.15e}, {:21.15e})'
.format(self.state_labels[istate],
avg_state_pops['expected'][istate],
avg_state_pops['ci_lbound'][istate],
avg_state_pops['ci_ubound'][istate],
maxlabellen=maxlabellen))
def calc_evolution(self):
nstates = self.nstates
start_iter, stop_iter, step_iter = self.iter_range.iter_start, self.iter_range.iter_stop, self.iter_range.iter_step
start_pts = range(start_iter, stop_iter, step_iter)
pop_evol = numpy.zeros((len(start_pts), nstates), dtype=ci_dtype)
pi = self.progress.indicator
pi.new_operation('Calculating population evolution', len(start_pts)*nstates)
# futures = []
# for iblock, start in enumerate(start_pts):
# if self.evolution_mode == 'cumulative':
# block_start = start_iter
# else: # self.evolution_mode == 'blocked'
# block_start = start
# stop = min(start+step_iter, stop_iter)
#
# for istate in xrange(nstates):
# future = self.work_manager.submit(_eval_block,kwargs=dict(iblock=iblock,istate=istate,
# start=block_start,stop=stop,
# state_pops=self.all_state_pops[block_start-start_iter:stop-start_iter,istate],
# mcbs_alpha=self.mcbs_alpha, mcbs_nsets=self.mcbs_nsets,
# mcbs_acalpha = self.mcbs_acalpha))
# futures.append(future)
def taskgen():
for iblock, start in enumerate(start_pts):
if self.evolution_mode == 'cumulative':
block_start = start_iter
else: # self.evolution_mode == 'blocked'
block_start = start
stop = min(start+step_iter, stop_iter)
for istate in xrange(nstates):
yield (_eval_block,(),dict(iblock=iblock,istate=istate,
start=block_start,stop=stop,
state_pops=self.all_state_pops[block_start-start_iter:stop-start_iter,istate],
mcbs_alpha=self.mcbs_alpha, mcbs_nsets=self.mcbs_nsets,
mcbs_acalpha = self.mcbs_acalpha))
#for future in self.work_manager.as_completed(futures):
for future in self.work_manager.submit_as_completed(taskgen(), self.max_queue_len):
(iblock,istate,ci_res) = future.get_result(discard=True)
pop_evol[iblock,istate] = ci_res
pi.progress += 1
self.output_file.create_dataset('state_pop_evolution', data=pop_evol, shuffle=True, compression=9)
pi.clear()
def go(self):
pi = self.progress.indicator
with pi:
pi.new_operation('Initializing')
self.open_files()
nstates = self.nstates = self.assignments_file.attrs['nstates']
state_labels = self.state_labels = self.assignments_file['state_labels'][...]
state_map = self.state_map = self.assignments_file['state_map'][...]
if (state_map > nstates).any():
raise ValueError('invalid state mapping')
# copy metadata to output
self.output_file.attrs['nstates'] = nstates
self.output_file['state_labels'] = state_labels
# calculate overall averages
self.calc_state_pops()
# calculate evolution, if requested
if self.evolution_mode != 'none' and self.iter_range.iter_step:
self.calc_evolution()
class StateProbTool(WESTParallelTool):
prog = 'w_stateprobs'
description = '''\
Calculate average populations and associated errors in state populations from
weighted ensemble data. Bin assignments, including macrostate definitions,
are required. (See "w_assign --help" for more information).
-----------------------------------------------------------------------------
Output format
-----------------------------------------------------------------------------
The output file (-o/--output, usually "stateprobs.h5") contains the following
dataset:
/avg_state_pops [state]
(Structured -- see below) Population of each state across entire
range specified.
If --evolution-mode is specified, then the following additional dataset is
available:
/state_pop_evolution [window][state]
(Structured -- see below). State populations based on windows of
iterations of varying width. If --evolution-mode=cumulative, then
these windows all begin at the iteration specified with
--start-iter and grow in length by --step-iter for each successive
element. If --evolution-mode=blocked, then these windows are all of
width --step-iter (excluding the last, which may be shorter), the first
of which begins at iteration --start-iter.
The structure of these datasets is as follows:
iter_start
(Integer) Iteration at which the averaging window begins (inclusive).
iter_stop
(Integer) Iteration at which the averaging window ends (exclusive).
expected
(Floating-point) Expected (mean) value of the rate as evaluated within
this window, in units of inverse tau.
ci_lbound
(Floating-point) Lower bound of the confidence interval on the rate
within this window, in units of inverse tau.
ci_ubound
(Floating-point) Upper bound of the confidence interval on the rate
within this window, in units of inverse tau.
corr_len
(Integer) Correlation length of the rate within this window, in units
of tau.
Each of these datasets is also stamped with a number of attributes:
mcbs_alpha
(Floating-point) Alpha value of confidence intervals. (For example,
*alpha=0.05* corresponds to a 95% confidence interval.)
mcbs_nsets
(Integer) Number of bootstrap data sets used in generating confidence
intervals.
mcbs_acalpha
(Floating-point) Alpha value for determining correlation lengths.
-----------------------------------------------------------------------------
Command-line options
-----------------------------------------------------------------------------
'''
def __init__(self):
super(StateProbTool, self).__init__()
self.data_reader = WESTDataReader()
self.iter_range = IterRangeSelection()
self.progress = ProgressIndicatorComponent()
self.output_filename = None
self.kinetics_filename = None
self.output_file = None
self.assignments_file = None
self.evolution_mode = None
self.mcbs_alpha = None
self.mcbs_acalpha = None
self.mcbs_nsets = None
def stamp_mcbs_info(self, dataset):
dataset.attrs['mcbs_alpha'] = self.mcbs_alpha
dataset.attrs['mcbs_acalpha'] = self.mcbs_acalpha
dataset.attrs['mcbs_nsets'] = self.mcbs_nsets
def add_args(self, parser):
self.progress.add_args(parser)
self.data_reader.add_args(parser)
self.iter_range.include_args['iter_step'] = True
self.iter_range.add_args(parser)
iogroup = parser.add_argument_group('input/output options')
iogroup.add_argument(
'-a',
'--assignments',
default='assign.h5',
help='''Bin assignments and macrostate definitions are in ASSIGNMENTS
(default: %(default)s).''')
iogroup.add_argument(
'-o',
'--output',
dest='output',
default='stateprobs.h5',
help='''Store results in OUTPUT (default: %(default)s).''')
cgroup = parser.add_argument_group(
'confidence interval calculation options')
cgroup.add_argument('--alpha',
type=float,
default=0.05,
help='''Calculate a (1-ALPHA) confidence interval'
(default: %(default)s)''')
cgroup.add_argument(
'--autocorrel-alpha',
type=float,
dest='acalpha',
metavar='ACALPHA',
help='''Evaluate autocorrelation to (1-ACALPHA) significance.
Note that too small an ACALPHA will result in failure to detect autocorrelation
in a noisy flux signal. (Default: same as ALPHA.)'''
)
cgroup.add_argument(
'--nsets',
type=int,
help=
'''Use NSETS samples for bootstrapping (default: chosen based on ALPHA)'''
)
cogroup = parser.add_argument_group('calculation options')
cogroup.add_argument(
'-e',
'--evolution-mode',
choices=['cumulative', 'blocked', 'none'],
default='none',
help='''How to calculate time evolution of rate estimates.
``cumulative`` evaluates rates over windows starting with --start-iter and getting progressively
wider to --stop-iter by steps of --step-iter.
``blocked`` evaluates rates over windows of width --step-iter, the first of which begins at
--start-iter.
``none`` (the default) disables calculation of the time evolution of rate estimates.'''
)
def open_files(self):
self.output_file = h5io.WESTPAH5File(self.output_filename,
'w',
creating_program=True)
h5io.stamp_creator_data(self.output_file)
self.assignments_file = h5io.WESTPAH5File(
self.assignments_filename,
'r') #, driver='core', backing_store=False)
if not self.iter_range.check_data_iter_range_least(
self.assignments_file):
raise ValueError(
'assignments data do not span the requested iterations')
def process_args(self, args):
self.progress.process_args(args)
self.data_reader.process_args(args)
with self.data_reader:
self.iter_range.process_args(args, default_iter_step=None)
if self.iter_range.iter_step is None:
#use about 10 blocks by default
self.iter_range.iter_step = max(
1,
(self.iter_range.iter_stop - self.iter_range.iter_start) // 10)
self.output_filename = args.output
self.assignments_filename = args.assignments
self.mcbs_alpha = args.alpha
self.mcbs_acalpha = args.acalpha if args.acalpha else self.mcbs_alpha
self.mcbs_nsets = args.nsets if args.nsets else mclib.get_bssize(
self.mcbs_alpha)
self.evolution_mode = args.evolution_mode
def calc_state_pops(self):
start_iter, stop_iter = self.iter_range.iter_start, self.iter_range.iter_stop
nstates = self.nstates
state_map = self.state_map
iter_count = stop_iter - start_iter
pi = self.progress.indicator
pi.new_operation('Calculating state populations')
pops = h5io.IterBlockedDataset(
self.assignments_file['labeled_populations'])
iter_state_pops = numpy.empty((nstates + 1, ), weight_dtype)
all_state_pops = numpy.empty((iter_count, nstates + 1), weight_dtype)
avg_state_pops = numpy.zeros((nstates + 1, ), weight_dtype)
pops.cache_data(max_size='available')
try:
for iiter, n_iter in enumerate(xrange(start_iter, stop_iter)):
iter_state_pops.fill(0)
labeled_pops = pops.iter_entry(n_iter)
accumulate_state_populations_from_labeled(
labeled_pops,
state_map,
iter_state_pops,
check_state_map=False)
all_state_pops[iiter] = iter_state_pops
avg_state_pops += iter_state_pops
del labeled_pops
pi.progress += 1
finally:
pops.drop_cache()
self.output_file.create_dataset('state_pops',
data=all_state_pops,
compression=9,
shuffle=True)
h5io.stamp_iter_range(self.output_file['state_pops'], start_iter,
stop_iter)
self.all_state_pops = all_state_pops
avg_state_pops = numpy.zeros((nstates + 1, ), ci_dtype)
pi.new_operation('Calculating overall average populations and CIs',
nstates)
# futures = []
# for istate in xrange(nstates):
# futures.append(self.work_manager.submit(_eval_block,kwargs=dict(iblock=None,istate=istate,
# start=start_iter,stop=stop_iter,
# state_pops=all_state_pops[:,istate],
# mcbs_alpha=self.mcbs_alpha, mcbs_nsets=self.mcbs_nsets,
# mcbs_acalpha = self.mcbs_acalpha)))
# for future in self.work_manager.as_completed(futures):
def taskgen():
for istate in xrange(nstates):
yield (_eval_block, (),
dict(iblock=None,
istate=istate,
start=start_iter,
stop=stop_iter,
state_pops=all_state_pops[:, istate],
mcbs_alpha=self.mcbs_alpha,
mcbs_nsets=self.mcbs_nsets,
mcbs_acalpha=self.mcbs_acalpha))
for future in self.work_manager.submit_as_completed(
taskgen(), self.max_queue_len):
(_iblock, istate, ci_res) = future.get_result(discard=True)
avg_state_pops[istate] = ci_res
pi.progress += 1
self.output_file['avg_state_pops'] = avg_state_pops
self.stamp_mcbs_info(self.output_file['avg_state_pops'])
pi.clear()
maxlabellen = max(map(len, self.state_labels))
print('average state populations:')
for istate in xrange(nstates):
print(
'{:{maxlabellen}s}: mean={:21.15e} CI=({:21.15e}, {:21.15e})'.
format(self.state_labels[istate],
avg_state_pops['expected'][istate],
avg_state_pops['ci_lbound'][istate],
avg_state_pops['ci_ubound'][istate],
maxlabellen=maxlabellen))
def calc_evolution(self):
nstates = self.nstates
start_iter, stop_iter, step_iter = self.iter_range.iter_start, self.iter_range.iter_stop, self.iter_range.iter_step
start_pts = range(start_iter, stop_iter, step_iter)
pop_evol = numpy.zeros((len(start_pts), nstates), dtype=ci_dtype)
pi = self.progress.indicator
pi.new_operation('Calculating population evolution',
len(start_pts) * nstates)
# futures = []
# for iblock, start in enumerate(start_pts):
# if self.evolution_mode == 'cumulative':
# block_start = start_iter
# else: # self.evolution_mode == 'blocked'
# block_start = start
# stop = min(start+step_iter, stop_iter)
#
# for istate in xrange(nstates):
# future = self.work_manager.submit(_eval_block,kwargs=dict(iblock=iblock,istate=istate,
# start=block_start,stop=stop,
# state_pops=self.all_state_pops[block_start-start_iter:stop-start_iter,istate],
# mcbs_alpha=self.mcbs_alpha, mcbs_nsets=self.mcbs_nsets,
# mcbs_acalpha = self.mcbs_acalpha))
# futures.append(future)
def taskgen():
for iblock, start in enumerate(start_pts):
if self.evolution_mode == 'cumulative':
block_start = start_iter
else: # self.evolution_mode == 'blocked'
block_start = start
stop = min(start + step_iter, stop_iter)
for istate in xrange(nstates):
yield (_eval_block, (),
dict(
iblock=iblock,
istate=istate,
start=block_start,
stop=stop,
state_pops=self.all_state_pops[block_start -
start_iter:stop -
start_iter,
istate],
mcbs_alpha=self.mcbs_alpha,
mcbs_nsets=self.mcbs_nsets,
mcbs_acalpha=self.mcbs_acalpha))
#for future in self.work_manager.as_completed(futures):
for future in self.work_manager.submit_as_completed(
taskgen(), self.max_queue_len):
(iblock, istate, ci_res) = future.get_result(discard=True)
pop_evol[iblock, istate] = ci_res
pi.progress += 1
self.output_file.create_dataset('state_pop_evolution',
data=pop_evol,
shuffle=True,
compression=9)
pi.clear()
def go(self):
pi = self.progress.indicator
with pi:
pi.new_operation('Initializing')
self.open_files()
nstates = self.nstates = self.assignments_file.attrs['nstates']
state_labels = self.state_labels = self.assignments_file[
'state_labels'][...]
state_map = self.state_map = self.assignments_file['state_map'][
...]
if (state_map > nstates).any():
raise ValueError('invalid state mapping')
# copy metadata to output
self.output_file.attrs['nstates'] = nstates
self.output_file['state_labels'] = state_labels
# calculate overall averages
self.calc_state_pops()
# calculate evolution, if requested
if self.evolution_mode != 'none' and self.iter_range.iter_step:
self.calc_evolution()
class WPostAnalysisReweightTool(WESTTool):
prog ='w_postanalysis_reweight'
description = '''\
Calculate average rates from weighted ensemble data using the postanalysis
reweighting scheme. Bin assignments (usually "assignments.h5") and pre-calculated
iteration flux matrices (usually "flux_matrices.h5") data files must have been
previously generated using w_postanalysis_matrix.py (see "w_assign --help" and
"w_kinetics --help" for information on generating these files).
-----------------------------------------------------------------------------
Output format
-----------------------------------------------------------------------------
The output file (-o/--output, usually "kinrw.h5") contains the following
dataset:
/state_prob_evolution [window,state]
The reweighted state populations based on windows
/color_prob_evolution [window,state]
The reweighted populations last assigned to each state based on windows
/bin_prob_evolution [window, bin]
The reweighted populations of each bin based on windows. Bins contain
one color each, so to recover the original un-colored spatial bins,
one must sum over all states.
/conditional_flux_evolution [window,state,state]
(Structured -- see below). State-to-state fluxes based on windows of
varying width
The structure of the final dataset is as follows:
iter_start
(Integer) Iteration at which the averaging window begins (inclusive).
iter_stop
(Integer) Iteration at which the averaging window ends (exclusive).
expected
(Floating-point) Expected (mean) value of the rate as evaluated within
this window, in units of inverse tau.
-----------------------------------------------------------------------------
Command-line options
-----------------------------------------------------------------------------
'''
def __init__(self):
super(WPostAnalysisReweightTool, self).__init__()
self.data_reader = WESTDataReader()
self.iter_range = IterRangeSelection()
self.progress = ProgressIndicatorComponent()
self.output_filename = None
self.kinetics_filename = None
self.assignment_filename = None
self.output_file = None
self.assignments_file = None
self.kinetics_file = None
self.evolution_mode = None
def add_args(self, parser):
self.progress.add_args(parser)
self.data_reader.add_args(parser)
self.iter_range.include_args['iter_step'] = True
self.iter_range.add_args(parser)
iogroup = parser.add_argument_group('input/output options')
iogroup.add_argument('-a', '--assignments', default='assign.h5',
help='''Bin assignments and macrostate definitions are in ASSIGNMENTS
(default: %(default)s).''')
iogroup.add_argument('-k', '--kinetics', default='flux_matrices.h5',
help='''Per-iteration flux matrices calculated by w_postanalysis_matrix
(default: %(default)s).''')
iogroup.add_argument('-o', '--output', dest='output', default='kinrw.h5',
help='''Store results in OUTPUT (default: %(default)s).''')
cogroup = parser.add_argument_group('calculation options')
cogroup.add_argument('-e', '--evolution-mode', choices=['cumulative', 'blocked'], default='cumulative',
help='''How to calculate time evolution of rate estimates.
``cumulative`` evaluates rates over windows starting with --start-iter and getting progressively
wider to --stop-iter by steps of --step-iter.
``blocked`` evaluates rates over windows of width --step-iter, the first of which begins at
--start-iter.''')
cogroup.add_argument('--window-frac', type=float, default=1.0,
help='''Fraction of iterations to use in each window when running in ``cumulative`` mode.
The (1 - frac) fraction of iterations will be discarded from the start of each window.''')
cogroup.add_argument('--obs-threshold', type=int, default=1,
help='''The minimum number of observed transitions between two states i and j necessary to include
fluxes in the reweighting estimate''')
def open_files(self):
self.output_file = h5io.WESTPAH5File(self.output_filename, 'w', creating_program=True)
h5io.stamp_creator_data(self.output_file)
self.assignments_file = h5io.WESTPAH5File(self.assignments_filename, 'r')#, driver='core', backing_store=False)
self.kinetics_file = h5io.WESTPAH5File(self.kinetics_filename, 'r')#, driver='core', backing_store=False)
if not self.iter_range.check_data_iter_range_least(self.assignments_file):
raise ValueError('assignments data do not span the requested iterations')
if not self.iter_range.check_data_iter_range_least(self.kinetics_file):
raise ValueError('kinetics data do not span the requested iterations')
def process_args(self, args):
self.progress.process_args(args)
self.data_reader.process_args(args)
with self.data_reader:
self.iter_range.process_args(args, default_iter_step=None)
if self.iter_range.iter_step is None:
#use about 10 blocks by default
self.iter_range.iter_step = max(1, (self.iter_range.iter_stop - self.iter_range.iter_start) // 10)
self.output_filename = args.output
self.assignments_filename = args.assignments
self.kinetics_filename = args.kinetics
self.evolution_mode = args.evolution_mode
self.evol_window_frac = args.window_frac
if self.evol_window_frac <= 0 or self.evol_window_frac > 1:
raise ValueError('Parameter error -- fractional window defined by --window-frac must be in (0,1]')
self.obs_threshold = args.obs_threshold
def go(self):
pi = self.progress.indicator
with pi:
pi.new_operation('Initializing')
self.open_files()
nstates = self.assignments_file.attrs['nstates']
nbins = self.assignments_file.attrs['nbins']
state_labels = self.assignments_file['state_labels'][...]
state_map = self.assignments_file['state_map'][...]
nfbins = self.kinetics_file.attrs['nrows']
npts = self.kinetics_file.attrs['npts']
assert nstates == len(state_labels)
assert nfbins == nbins * nstates
start_iter, stop_iter, step_iter = self.iter_range.iter_start, self.iter_range.iter_stop, self.iter_range.iter_step
start_pts = range(start_iter, stop_iter, step_iter)
flux_evol = np.zeros((len(start_pts), nstates, nstates), dtype=ci_dtype)
color_prob_evol = np.zeros((len(start_pts), nstates))
state_prob_evol = np.zeros((len(start_pts), nstates))
bin_prob_evol = np.zeros((len(start_pts), nfbins))
pi.new_operation('Calculating flux evolution', len(start_pts))
if self.evolution_mode == 'cumulative' and self.evol_window_frac == 1.0:
print('Using fast streaming accumulation')
total_fluxes = np.zeros((nfbins, nfbins), weight_dtype)
total_obs = np.zeros((nfbins, nfbins), np.int64)
for iblock, start in enumerate(start_pts):
pi.progress += 1
stop = min(start + step_iter, stop_iter)
params = dict(start=start, stop=stop, nstates=nstates, nbins=nbins,
state_labels=state_labels, state_map=state_map, nfbins=nfbins,
total_fluxes=total_fluxes, total_obs=total_obs,
h5file=self.kinetics_file, obs_threshold=self.obs_threshold)
rw_state_flux, rw_color_probs, rw_state_probs, rw_bin_probs, rw_bin_flux = reweight(**params)
for k in xrange(nstates):
for j in xrange(nstates):
# Normalize such that we report the flux per tau (tau being the weighted ensemble iteration)
# npts always includes a 0th time point
flux_evol[iblock]['expected'][k,j] = rw_state_flux[k,j] * (npts - 1)
flux_evol[iblock]['iter_start'][k,j] = start
flux_evol[iblock]['iter_stop'][k,j] = stop
color_prob_evol[iblock] = rw_color_probs
state_prob_evol[iblock] = rw_state_probs[:-1]
bin_prob_evol[iblock] = rw_bin_probs
else:
for iblock, start in enumerate(start_pts):
pi.progress += 1
stop = min(start + step_iter, stop_iter)
if self.evolution_mode == 'cumulative':
windowsize = max(1, int(self.evol_window_frac * (stop - start_iter)))
block_start = max(start_iter, stop - windowsize)
else: # self.evolution_mode == 'blocked'
block_start = start
params = dict(start=block_start, stop=stop, nstates=nstates, nbins=nbins,
state_labels=state_labels, state_map=state_map, nfbins=nfbins,
total_fluxes=None, total_obs=None,
h5file=self.kinetics_file)
rw_state_flux, rw_color_probs, rw_state_probs, rw_bin_probs, rw_bin_flux = reweight(**params)
for k in xrange(nstates):
for j in xrange(nstates):
# Normalize such that we report the flux per tau (tau being the weighted ensemble iteration)
# npts always includes a 0th time point
flux_evol[iblock]['expected'][k,j] = rw_state_flux[k,j] * (npts - 1)
flux_evol[iblock]['iter_start'][k,j] = start
flux_evol[iblock]['iter_stop'][k,j] = stop
color_prob_evol[iblock] = rw_color_probs
state_prob_evol[iblock] = rw_state_probs[:-1]
bin_prob_evol[iblock] = rw_bin_probs
ds_flux_evol = self.output_file.create_dataset('conditional_flux_evolution', data=flux_evol, shuffle=True, compression=9)
ds_state_prob_evol = self.output_file.create_dataset('state_prob_evolution', data=state_prob_evol, compression=9)
ds_color_prob_evol = self.output_file.create_dataset('color_prob_evolution', data=color_prob_evol, compression=9)
ds_bin_prob_evol = self.output_file.create_dataset('bin_prob_evolution', data=bin_prob_evol, compression=9)
ds_state_labels = self.output_file.create_dataset('state_labels', data=state_labels)
class WPostAnalysisReweightTool(WESTTool):
prog = 'w_postanalysis_reweight'
description = '''\
Calculate average rates from weighted ensemble data using the postanalysis
reweighting scheme. Bin assignments (usually "assignments.h5") and pre-calculated
iteration flux matrices (usually "flux_matrices.h5") data files must have been
previously generated using w_postanalysis_matrix.py (see "w_assign --help" and
"w_kinetics --help" for information on generating these files).
-----------------------------------------------------------------------------
Output format
-----------------------------------------------------------------------------
The output file (-o/--output, usually "kinrw.h5") contains the following
dataset:
/state_prob_evolution [window,state]
The reweighted state populations based on windows
/color_prob_evolution [window,state]
The reweighted populations last assigned to each state based on windows
/bin_prob_evolution [window, bin]
The reweighted populations of each bin based on windows. Bins contain
one color each, so to recover the original un-colored spatial bins,
one must sum over all states.
/conditional_flux_evolution [window,state,state]
(Structured -- see below). State-to-state fluxes based on windows of
varying width
The structure of the final dataset is as follows:
iter_start
(Integer) Iteration at which the averaging window begins (inclusive).
iter_stop
(Integer) Iteration at which the averaging window ends (exclusive).
expected
(Floating-point) Expected (mean) value of the rate as evaluated within
this window, in units of inverse tau.
-----------------------------------------------------------------------------
Command-line options
-----------------------------------------------------------------------------
'''
def __init__(self):
super(WPostAnalysisReweightTool, self).__init__()
self.data_reader = WESTDataReader()
self.iter_range = IterRangeSelection()
self.progress = ProgressIndicatorComponent()
self.output_filename = None
self.kinetics_filename = None
self.assignment_filename = None
self.output_file = None
self.assignments_file = None
self.kinetics_file = None
self.evolution_mode = None
def add_args(self, parser):
self.progress.add_args(parser)
self.data_reader.add_args(parser)
self.iter_range.include_args['iter_step'] = True
self.iter_range.add_args(parser)
iogroup = parser.add_argument_group('input/output options')
iogroup.add_argument(
'-a',
'--assignments',
default='assign.h5',
help='''Bin assignments and macrostate definitions are in ASSIGNMENTS
(default: %(default)s).''')
iogroup.add_argument(
'-k',
'--kinetics',
default='flux_matrices.h5',
help=
'''Per-iteration flux matrices calculated by w_postanalysis_matrix
(default: %(default)s).''')
iogroup.add_argument(
'-o',
'--output',
dest='output',
default='kinrw.h5',
help='''Store results in OUTPUT (default: %(default)s).''')
cogroup = parser.add_argument_group('calculation options')
cogroup.add_argument(
'-e',
'--evolution-mode',
choices=['cumulative', 'blocked'],
default='cumulative',
help='''How to calculate time evolution of rate estimates.
``cumulative`` evaluates rates over windows starting with --start-iter and getting progressively
wider to --stop-iter by steps of --step-iter.
``blocked`` evaluates rates over windows of width --step-iter, the first of which begins at
--start-iter.''')
cogroup.add_argument(
'--window-frac',
type=float,
default=1.0,
help=
'''Fraction of iterations to use in each window when running in ``cumulative`` mode.
The (1 - frac) fraction of iterations will be discarded from the start of each window.'''
)
cogroup.add_argument(
'--obs-threshold',
type=int,
default=1,
help=
'''The minimum number of observed transitions between two states i and j necessary to include
fluxes in the reweighting estimate''')
def open_files(self):
self.output_file = h5io.WESTPAH5File(self.output_filename,
'w',
creating_program=True)
h5io.stamp_creator_data(self.output_file)
self.assignments_file = h5io.WESTPAH5File(
self.assignments_filename,
'r') #, driver='core', backing_store=False)
self.kinetics_file = h5io.WESTPAH5File(
self.kinetics_filename,
'r') #, driver='core', backing_store=False)
if not self.iter_range.check_data_iter_range_least(
self.assignments_file):
raise ValueError(
'assignments data do not span the requested iterations')
if not self.iter_range.check_data_iter_range_least(self.kinetics_file):
raise ValueError(
'kinetics data do not span the requested iterations')
def process_args(self, args):
self.progress.process_args(args)
self.data_reader.process_args(args)
with self.data_reader:
self.iter_range.process_args(args, default_iter_step=None)
if self.iter_range.iter_step is None:
#use about 10 blocks by default
self.iter_range.iter_step = max(
1,
(self.iter_range.iter_stop - self.iter_range.iter_start) // 10)
self.output_filename = args.output
self.assignments_filename = args.assignments
self.kinetics_filename = args.kinetics
self.evolution_mode = args.evolution_mode
self.evol_window_frac = args.window_frac
if self.evol_window_frac <= 0 or self.evol_window_frac > 1:
raise ValueError(
'Parameter error -- fractional window defined by --window-frac must be in (0,1]'
)
self.obs_threshold = args.obs_threshold
def go(self):
pi = self.progress.indicator
with pi:
pi.new_operation('Initializing')
self.open_files()
nstates = self.assignments_file.attrs['nstates']
nbins = self.assignments_file.attrs['nbins']
state_labels = self.assignments_file['state_labels'][...]
state_map = self.assignments_file['state_map'][...]
nfbins = self.kinetics_file.attrs['nrows']
npts = self.kinetics_file.attrs['npts']
assert nstates == len(state_labels)
assert nfbins == nbins * nstates
start_iter, stop_iter, step_iter = self.iter_range.iter_start, self.iter_range.iter_stop, self.iter_range.iter_step
start_pts = range(start_iter, stop_iter, step_iter)
flux_evol = np.zeros((len(start_pts), nstates, nstates),
dtype=ci_dtype)
color_prob_evol = np.zeros((len(start_pts), nstates))
state_prob_evol = np.zeros((len(start_pts), nstates))
bin_prob_evol = np.zeros((len(start_pts), nfbins))
pi.new_operation('Calculating flux evolution', len(start_pts))
if self.evolution_mode == 'cumulative' and self.evol_window_frac == 1.0:
print('Using fast streaming accumulation')
total_fluxes = np.zeros((nfbins, nfbins), weight_dtype)
total_obs = np.zeros((nfbins, nfbins), np.int64)
for iblock, start in enumerate(start_pts):
pi.progress += 1
stop = min(start + step_iter, stop_iter)
params = dict(start=start,
stop=stop,
nstates=nstates,
nbins=nbins,
state_labels=state_labels,
state_map=state_map,
nfbins=nfbins,
total_fluxes=total_fluxes,
total_obs=total_obs,
h5file=self.kinetics_file,
obs_threshold=self.obs_threshold)
rw_state_flux, rw_color_probs, rw_state_probs, rw_bin_probs, rw_bin_flux = reweight(
**params)
for k in xrange(nstates):
for j in xrange(nstates):
# Normalize such that we report the flux per tau (tau being the weighted ensemble iteration)
# npts always includes a 0th time point
flux_evol[iblock]['expected'][
k, j] = rw_state_flux[k, j] * (npts - 1)
flux_evol[iblock]['iter_start'][k, j] = start
flux_evol[iblock]['iter_stop'][k, j] = stop
color_prob_evol[iblock] = rw_color_probs
state_prob_evol[iblock] = rw_state_probs[:-1]
bin_prob_evol[iblock] = rw_bin_probs
else:
for iblock, start in enumerate(start_pts):
pi.progress += 1
stop = min(start + step_iter, stop_iter)
if self.evolution_mode == 'cumulative':
windowsize = max(
1,
int(self.evol_window_frac * (stop - start_iter)))
block_start = max(start_iter, stop - windowsize)
else: # self.evolution_mode == 'blocked'
block_start = start
params = dict(start=block_start,
stop=stop,
nstates=nstates,
nbins=nbins,
state_labels=state_labels,
state_map=state_map,
nfbins=nfbins,
total_fluxes=None,
total_obs=None,
h5file=self.kinetics_file)
rw_state_flux, rw_color_probs, rw_state_probs, rw_bin_probs, rw_bin_flux = reweight(
**params)
for k in xrange(nstates):
for j in xrange(nstates):
# Normalize such that we report the flux per tau (tau being the weighted ensemble iteration)
# npts always includes a 0th time point
flux_evol[iblock]['expected'][
k, j] = rw_state_flux[k, j] * (npts - 1)
flux_evol[iblock]['iter_start'][k, j] = start
flux_evol[iblock]['iter_stop'][k, j] = stop
color_prob_evol[iblock] = rw_color_probs
state_prob_evol[iblock] = rw_state_probs[:-1]
bin_prob_evol[iblock] = rw_bin_probs
ds_flux_evol = self.output_file.create_dataset(
'conditional_flux_evolution',
data=flux_evol,
shuffle=True,
compression=9)
ds_state_prob_evol = self.output_file.create_dataset(
'state_prob_evolution', data=state_prob_evol, compression=9)
ds_color_prob_evol = self.output_file.create_dataset(
'color_prob_evolution', data=color_prob_evol, compression=9)
ds_bin_prob_evol = self.output_file.create_dataset(
'bin_prob_evolution', data=bin_prob_evol, compression=9)
ds_state_labels = self.output_file.create_dataset(
'state_labels', data=state_labels)
class KinAvgSubcommands(WESTSubcommand):
'''Common argument processing for w_kinavg subcommands'''
def __init__(self, parent):
super(KinAvgSubcommands, self).__init__(parent)
self.data_reader = WESTDataReader()
self.iter_range = IterRangeSelection()
self.progress = ProgressIndicatorComponent()
self.output_filename = None
self.kinetics_filename = None
self.assignment_filename = None
self.output_file = None
self.assignments_file = None
self.kinetics_file = None
self.evolution_mode = None
self.mcbs_alpha = None
self.mcbs_acalpha = None
self.mcbs_nsets = None
def stamp_mcbs_info(self, dataset):
dataset.attrs['mcbs_alpha'] = self.mcbs_alpha
dataset.attrs['mcbs_acalpha'] = self.mcbs_acalpha
dataset.attrs['mcbs_nsets'] = self.mcbs_nsets
def add_args(self, parser):
self.progress.add_args(parser)
self.data_reader.add_args(parser)
self.iter_range.include_args['iter_step'] = True
self.iter_range.add_args(parser)
iogroup = parser.add_argument_group('input/output options')
iogroup.add_argument(
'-a',
'--assignments',
default='assign.h5',
help='''Bin assignments and macrostate definitions are in ASSIGNMENTS
(default: %(default)s).''')
# self.default_kinetics_file will be picked up as a class attribute from the appropriate subclass
iogroup.add_argument(
'-k',
'--kinetics',
default=self.default_kinetics_file,
help='''Populations and transition rates are stored in KINETICS
(default: %(default)s).''')
iogroup.add_argument(
'-o',
'--output',
dest='output',
default='kinavg.h5',
help='''Store results in OUTPUT (default: %(default)s).''')
cgroup = parser.add_argument_group(
'confidence interval calculation options')
cgroup.add_argument('--alpha',
type=float,
default=0.05,
help='''Calculate a (1-ALPHA) confidence interval'
(default: %(default)s)''')
cgroup.add_argument(
'--autocorrel-alpha',
type=float,
dest='acalpha',
metavar='ACALPHA',
help='''Evaluate autocorrelation to (1-ACALPHA) significance.
Note that too small an ACALPHA will result in failure to detect autocorrelation
in a noisy flux signal. (Default: same as ALPHA.)'''
)
cgroup.add_argument(
'--nsets',
type=int,
help=
'''Use NSETS samples for bootstrapping (default: chosen based on ALPHA)'''
)
cogroup = parser.add_argument_group('calculation options')
cogroup.add_argument(
'-e',
'--evolution-mode',
choices=['cumulative', 'blocked', 'none'],
default='none',
help='''How to calculate time evolution of rate estimates.
``cumulative`` evaluates rates over windows starting with --start-iter and getting progressively
wider to --stop-iter by steps of --step-iter.
``blocked`` evaluates rates over windows of width --step-iter, the first of which begins at
--start-iter.
``none`` (the default) disables calculation of the time evolution of rate estimates.'''
)
cogroup.add_argument(
'--window-frac',
type=float,
default=1.0,
help=
'''Fraction of iterations to use in each window when running in ``cumulative`` mode.
The (1 - frac) fraction of iterations will be discarded from the start of each window.'''
)
def open_files(self):
self.output_file = h5io.WESTPAH5File(self.output_filename,
'w',
creating_program=True)
h5io.stamp_creator_data(self.output_file)
self.assignments_file = h5io.WESTPAH5File(
self.assignments_filename,
'r') #, driver='core', backing_store=False)
self.kinetics_file = h5io.WESTPAH5File(
self.kinetics_filename,
'r') #, driver='core', backing_store=False)
if not self.iter_range.check_data_iter_range_least(
self.assignments_file):
raise ValueError(
'assignments data do not span the requested iterations')
if not self.iter_range.check_data_iter_range_least(self.kinetics_file):
raise ValueError(
'kinetics data do not span the requested iterations')
def process_args(self, args):
self.progress.process_args(args)
self.data_reader.process_args(args)
with self.data_reader:
self.iter_range.process_args(args, default_iter_step=None)
if self.iter_range.iter_step is None:
#use about 10 blocks by default
self.iter_range.iter_step = max(
1,
(self.iter_range.iter_stop - self.iter_range.iter_start) // 10)
self.output_filename = args.output
self.assignments_filename = args.assignments
self.kinetics_filename = args.kinetics
self.mcbs_alpha = args.alpha
self.mcbs_acalpha = args.acalpha if args.acalpha else self.mcbs_alpha
self.mcbs_nsets = args.nsets if args.nsets else mclib.get_bssize(
self.mcbs_alpha)
self.evolution_mode = args.evolution_mode
self.evol_window_frac = args.window_frac
if self.evol_window_frac <= 0 or self.evol_window_frac > 1:
raise ValueError(
'Parameter error -- fractional window defined by --window-frac must be in (0,1]'
)
