def test_total_time(self):
analysis = paths.ChannelAnalysis(steps=None, channels=self.channels)
analysis._results = self.toy_results
analysis.treat_multiples = 'newest'
total_time = analysis.total_time
assert_equal(total_time, {'a': 5, 'b': 4, 'c': 1})
analysis.treat_multiples = 'oldest'
total_time = analysis.total_time
assert_equal(total_time, {'a': 6, 'b': 4})
assert_equal(total_time['c'], 0)
analysis.treat_multiples = 'all'
total_time = analysis.total_time
assert_equal(total_time, {'a': 7, 'b': 6, 'c': 2})
analysis.treat_multiples = 'multiple'
total_time = analysis.total_time
assert_equal(total_time, {
'a': 4,
'b': 2,
'a,b': 2,
'b,c': 1,
'a,b,c': 1
})
def test_residence_times_with_none(self):
analysis = paths.ChannelAnalysis(steps=None, channels=self.channels)
analysis._results = self.results_with_none
residence_times = analysis.residence_times
assert_equal(residence_times,
{'a': [2, 3], 'b': [2, 1], 'None': [3]})
def test_residence_times(self):
analysis = paths.ChannelAnalysis(steps=None, channels=self.channels)
analysis._results = self.toy_results
analysis.treat_multiples = 'newest'
residence_times = analysis.residence_times
assert_equal(residence_times, {'a': [3, 2], 'b': [4], 'c': [1]})
analysis.treat_multiples = 'oldest'
residence_times = analysis.residence_times
assert_equal(residence_times, {'a': [5, 1], 'b': [4]})
analysis.treat_multiples = 'all'
residence_times = analysis.residence_times
assert_equal(residence_times, {'a': [5, 2], 'b': [6], 'c': [2]})
analysis.treat_multiples = 'multiple'
residence_times = analysis.residence_times
assert_equal(residence_times, {
'a': [3, 1],
'b': [2],
'a,b': [2],
'b,c': [1],
'a,b,c': [1]
})
def test_switching(self):
analysis = paths.ChannelAnalysis(steps=None, channels=self.channels)
analysis._results = self.toy_results
#nan = float('nan')
nan = 0 # self transitions are 0
analysis.treat_multiples = 'newest'
df = analysis.switching_matrix
expected = np.array([[nan, 1, 0], [0, nan, 1], [1, 0, nan]])
assert_array_almost_equal(df.values, expected)
analysis.treat_multiples = 'oldest'
df = analysis.switching_matrix
expected = np.array([[nan, 1], [1, nan]]) # no column for c!
assert_array_almost_equal(df.values, expected)
analysis.treat_multiples = 'multiple'
df = analysis.switching_matrix
# 'a', 'b', 'a,b', 'b,c', 'a,b,c'
expected = np.array([[nan, 0, 1, 0, 0],
[0, nan, 0, 1, 0],
[0, 1, nan, 0, 0],
[0, 0, 0, nan, 1],
[1, 0, 0, 0, nan]])
assert_array_almost_equal(df.values, expected)
def test_analyze_incr_decr(self):
steps = [
paths.MCStep(mccycle=0, active=self.incr_1),
paths.MCStep(mccycle=1, active=self.decr_1)
]
results = paths.ChannelAnalysis(steps, self.channels)
assert_equal(results._results,
{'incr': [(0,1)], 'decr': [(1,2)], None: []})
def test_switching_with_none(self):
analysis = paths.ChannelAnalysis(steps=None, channels=self.channels)
analysis._results = self.results_with_none
nan = 0 # self transitions are 0
analysis.treat_multiples = 'newest'
df = analysis.switching_matrix
# None, a, b
expected = np.array([[nan, 0, 1], [1, nan, 1], [0, 1, nan]])
assert_array_almost_equal(df.as_matrix(), expected)
def test_treat_multiples(self):
obj = paths.ChannelAnalysis(steps=None, channels=self.channels)
assert_equal(obj.treat_multiples, 'all')
obj.treat_multiples = 'oldest'
assert_equal(obj.treat_multiples, 'oldest')
obj.treat_multiples = 'newest'
assert_equal(obj.treat_multiples, 'newest')
obj.treat_multiples = 'multiple'
assert_equal(obj.treat_multiples, 'multiple')
obj.treat_multiples = 'all'
assert_equal(obj.treat_multiples, 'all')
def test_storage(self):
analyzer = paths.ChannelAnalysis(steps=None, channels=self.channels)
analyzer._results = self.toy_results
analyzer.treat_multiples = 'newest'
storage = paths.Storage(data_filename('test.nc'), 'w')
storage.tag['analyzer'] = analyzer
storage.sync()
storage.close()
new_store = paths.Storage(data_filename('test.nc'), 'r')
reloaded = storage.tag['analyzer']
assert_equal(reloaded._results, self.toy_results)
if os.path.isfile(data_filename('test.nc')):
os.remove(data_filename('test.nc'))
def test_status(self):
analysis = paths.ChannelAnalysis(steps=None, channels=self.channels)
analysis._results = self.toy_results
analysis.treat_multiples = 'newest'
assert_equal(analysis.status(4), 'b')
assert_equal(analysis.status(8), 'a')
analysis.treat_multiples = 'oldest'
assert_equal(analysis.status(4), 'a')
assert_equal(analysis.status(8), 'b')
analysis.treat_multiples = 'multiple'
assert_equal(analysis.status(4), 'a,b')
assert_equal(analysis.status(8), 'a,b,c')
analysis.treat_multiples = 'all'
assert_equal(analysis.status(4), 'a,b')
assert_equal(analysis.status(8), 'a,b,c')
def test_bad_status_number(self):
analysis = paths.ChannelAnalysis(steps=None, channels=self.channels)
analysis._results = self.toy_results
analysis.status(10)
def test_status_with_none(self):
analysis = paths.ChannelAnalysis(steps=None, channels=self.channels)
analysis._results = self.results_with_none
assert_equal(analysis.status(4), 'None')
def test_total_time_with_none(self):
analysis = paths.ChannelAnalysis(steps=None, channels=self.channels)
analysis._results = self.results_with_none
total_time = analysis.total_time
assert_equal(total_time, {'a': 5, 'b': 3, 'None': 3})
def test_bad_treat_multiples(self):
obj = paths.ChannelAnalysis(steps=None, channels=self.channels)
assert_equal(obj.treat_multiples, 'all')
obj.treat_multiples = 'bad_string'
def test_empty(self):
obj = paths.ChannelAnalysis(steps=None, channels=self.channels)
empty_results = {c: [] for c in list(self.channels.keys()) + [None]}
assert_equal(obj._results, empty_results)
