def Decrypt(data, key):
transp = Permutation(data, BegPermut)
L = transp[:32]
R = transp[32:]
for i in range(15,-1,-1):
R, L = ba(L), ba(R ^ fRK(L, GetKey(key, i)))
return Permutation(L + R, EndPermut)
def colour_matrix(degrees, matrix):
"""
Greedy coloring of bit-encoded RMSD matrix.
Parameters
----------
degrees : numpy.ndarray
array containing each node degree. Clustered nodes have degree = 0.
matrix : collections.OrderedDict
dict of bitarrays.
Returns
-------
colors : numpy.ndarray
array of colors assigned to each node of the matrix.
"""
# Constants ---------------------------------------------------------------
N = degrees.size
m = len(matrix)
one = ba('1')
xcolor = 0
# Initialize containers ---------------------------------------------------
ordered_by_degrees = iter((-degrees[:m]).argsort())
colors = np.zeros(N, dtype=np.int32)
colored = ba(N)
colored.setall(0)
seen = set()
while True:
# Retrieve the max-degree node ----------------------------------------
max_node = next(ordered_by_degrees)
if max_node in seen:
continue
seen.add(max_node)
xcolor += 1
not_neighbors = ~ matrix[max_node]
not_colored = ~colored
candidates = not_neighbors & not_colored
# Nodes passing conditions (not-neighb, not-colored, not-neighb) ------
passed = [max_node]
for candidate in candidates.itersearch(one):
passed.append(candidate)
try:
candidates &= ~matrix[candidate]
except KeyError:
continue
if not candidates.any():
break
seen.update(passed)
# Deliver a color class to passed nodes -------------------------------
colors[passed] = xcolor
colored = ba()
colored.pack(colors.astype(np.bool).tobytes())
if colored.count(0) == 0:
break
return colors
def TripleDES_decrypt(file,data,key):
while( len(key) < 24 ):
key+=key
key1, key2, key3 = ba(), ba(), ba()
key1.frombytes(key[0:8])
key2.frombytes(key[8:16])
key3.frombytes(key[16:24])
data_len = len(data)
for i in range(0, data_len, 8):
block = ba()
block.frombytes(data[i:i + 8])
res=Decrypt(Decrypt(Decrypt(block, key3), key2), key1).tobytes()
if res.endswith(b"\x00"):
res=res[:res.index(b"\x00")]
file.write(res)
def calc_matrix_degrees(unclustered_bit, matrix):
"""
Calculate number of neighbors (degree) of unclustered nodes in matrix.
Parameters
----------
unclustered_bit : bitarray.bitarray
bitarray with indices of unclustered nodes turned on.
matrix : collections.OrderedDict
dict of bitarrays.
Returns
-------
degrees : numpy.ndarray
array containing each node degree. Clustered nodes have degree = 0.
"""
one = ba('1')
degrees = np.zeros(len(unclustered_bit), dtype=np.int32)
for node in unclustered_bit.itersearch(one):
try:
degrees[node] = matrix[node].count()
except KeyError:
pass
return degrees
def calc_rmsd_matrix(trajectory, args):
"""
Calculate optimal RMSD binary-encoded square matrix using MDTraj. Pairwise
similarity is saved in RAM as bits (dict of bitarrays), not floats.
Parameters
----------
trajectory : mdtraj.Trajectory
MDTraj trajectory object.
args : argparse.Namespace
user input parameters parsed by argparse (CLI).
Returns
-------
matrix : collections.OrderedDict
dict of bitarrays.
"""
trajectory.center_coordinates()
cutoff = np.full(trajectory.n_frames, args.cutoff / 10, dtype=np.float32)
matrix = OrderedDict()
to_explore = range(trajectory.n_frames)
for i in to_explore:
rmsd_ = md.rmsd(trajectory, trajectory, i, precentered=True)
vector_np = np.less_equal(rmsd_, cutoff)
bitarr = ba()
bitarr.pack(vector_np.tobytes())
bitarr.fill()
matrix.update({i: bitarr})
return matrix
def TripleDES_encrypt(file,data,key):
print(key)
while(len(key)<24):
key+=key
key1,key2,key3=ba(),ba(),ba()
key1.frombytes(key[0 :8])
key2.frombytes(key[8 :16])
key3.frombytes(key[16:24])
data_len=len(data)
if data_len%8 != 0:
data=data+b"\x00"*(8 - data_len % 8)
for i in range(0,data_len,8):
block=ba()
block.frombytes(data[i:i+8])
file.write(Encrypt(Encrypt(Encrypt(block, key1), key2), key3).tobytes())
def Sbox_permut(data): # data 48 bit; ret 32
res = ba()
for i in range(8):
b=data[6*i:6*i+6]
m=int(b[0:6:5].to01(), 2)
l=int(b[1:5].to01(), 2 )
res+= bin(S_box[i][m][l])[2:].zfill(4)
return res
def test_no_blocking_two_datasets(k_):
THRESHOLD = .6
# These values don't actually matter...
dataset0 = [ba('00'), ba('01'), ba('10'), ba('11')]
dataset1 = [ba('00'), ba('01'), ba('11'), ba('')]
datasets = [dataset0, dataset1]
def similarity_f(datasets, threshold, k=None):
assert threshold == THRESHOLD
# All we need to check for k is that it's been passed correctly
assert k == k_
dset0, dset1 = map(list, datasets)
if dset0 == dataset0 and dset1 == dataset1:
sims = [
0.9432949307428928, 0.8568189930049877, 0.8419286042520673,
0.6343698774541688, 0.6
]
rec_is0 = [1, 2, 0, 3, 0]
rec_is1 = [1, 0, 0, 3, 2]
else:
assert False, 'datasets not passed through as expected'
return array('d', sims), (array('I', rec_is0), array('I', rec_is1))
sims, (dset_is0, dset_is1), (rec_is0,
rec_is1) = find_candidate_pairs(datasets,
similarity_f,
THRESHOLD,
k=k_)
if k_ == 0:
assert list(sims) == []
assert list(dset_is0) == []
assert list(dset_is1) == []
assert list(rec_is0) == []
assert list(rec_is1) == []
elif k_ == 1:
assert list(sims) == [
0.9432949307428928, 0.8568189930049877, 0.6343698774541688
]
assert list(dset_is0) == [0, 0, 0]
assert list(dset_is1) == [1, 1, 1]
assert list(rec_is0) == [1, 2, 3]
assert list(rec_is1) == [1, 0, 3]
else:
assert list(sims) == [
0.9432949307428928, 0.8568189930049877, 0.8419286042520673,
0.6343698774541688, 0.6
]
assert list(dset_is0) == [0, 0, 0, 0, 0]
assert list(dset_is1) == [1, 1, 1, 1, 1]
assert list(rec_is0) == [1, 2, 0, 3, 0]
assert list(rec_is1) == [1, 0, 0, 3, 2]
def test_no_blocking_too_few_datasets(datasets_n, k_, blocking_f):
THRESHOLD = .6
# These values don't actually matter...
dataset0 = [ba('00'), ba('01'), ba('10'), ba('11')]
datasets = [dataset0] if datasets_n else []
def similarity_f(datasets, threshold, k=None, blocking_f=blocking_f):
assert False, 'should not be called at all'
sims, (dset_is0, dset_is1), (rec_is0,
rec_is1) = find_candidate_pairs(datasets,
similarity_f,
THRESHOLD,
k=k_)
assert list(sims) == []
assert list(dset_is0) == []
assert list(dset_is1) == []
assert list(rec_is0) == []
assert list(rec_is1) == []
def np_to_bitarray(np_array, N):
'''
DESCRIPTION
Converts a numpy array to a bitarray using the fastest way. It creates a
bitarray of N bits and sets to 1 only those indices that coincides with
the integers in the numpy array.
Arguments:
np_array (numpy.array): numpy array.
N (int): size of the desired bitarray.
Return:
bitarr (bitarray): a bitarray of N bits having as 1 only those indices
that coincides with the integers present in the numpy array.
'''
zero_arr = np.zeros(N, dtype=np.bool)
zero_arr[np_array] = 1
bitarr = ba()
bitarr.pack(zero_arr.tobytes())
return bitarr
def set_to_bitarray(set_, N):
"""
Convert from python set to bitarray.bitarray.
Parameters
----------
set_ : set
a python set.
N : int
lenght of the desired bitarray. It must be greater than the maximum
value of indices present in set.
Returns
-------
bitarr : bitarray.bitarray
bitarray of lenght N with indices present in set turned on.
"""
zero_arr = np.zeros(N, dtype=np.bool)
zero_arr[list(set_)] = 1
bitarr = ba()
bitarr.pack(zero_arr.tobytes())
return bitarr
def test_blocking_two_datasets(k_):
THRESHOLD = .6
# These values don't actually matter...
dataset0 = [ba('00'), ba('01'), ba('10'), ba('11')]
dataset1 = [ba('00'), ba('01'), ba('11'), ba('')]
datasets = [dataset0, dataset1]
def similarity_f(datasets, threshold, k=None):
assert threshold == THRESHOLD
# All we need to check for k is that it's been passed correctly
assert k == k_
dset0, dset1 = map(list, datasets)
if (dset0 == list(map(dataset0.__getitem__, [0, 1]))
and dset1 == list(map(dataset1.__getitem__, [0, 1]))):
# Block where first bits are 0
sims = [0.9432949307428928, 0.8419286042520673]
rec_is0 = [1, 0]
rec_is1 = [1, 0]
elif (dset0 == list(map(dataset0.__getitem__, [2, 3]))
and dset1 == list(map(dataset1.__getitem__, [2]))):
# Block where first bits are 1
sims = []
rec_is0 = []
rec_is1 = []
elif (dset0 == list(map(dataset0.__getitem__, [0, 2]))
and dset1 == list(map(dataset1.__getitem__, [0]))):
# Block where second bits are 0
sims = [0.8568189930049877, 0.8419286042520673]
rec_is0 = [1, 0]
rec_is1 = [0, 0]
elif (dset0 == list(map(dataset0.__getitem__, [1, 3]))
and dset1 == list(map(dataset1.__getitem__, [1, 2]))):
# Block where second bits are 1
sims = [0.9432949307428928]
rec_is0 = [0]
rec_is1 = [0]
else:
assert False, 'datasets not passed through as expected'
return array('d', sims), (array('I', rec_is0), array('I', rec_is1))
def blocking_f(dataset_index, record_index, hash_):
assert datasets[dataset_index][record_index] == hash_
if hash_:
yield 0, hash_[0]
yield 1, hash_[1]
sims, (dset_is0,
dset_is1), (rec_is0,
rec_is1) = find_candidate_pairs(datasets,
similarity_f,
THRESHOLD,
k=k_,
blocking_f=blocking_f)
if k_ == 0:
assert list(sims) == []
assert list(dset_is0) == []
assert list(dset_is1) == []
assert list(rec_is0) == []
assert list(rec_is1) == []
elif k_ == 1:
assert list(sims) == [0.9432949307428928, 0.8568189930049877]
assert list(dset_is0) == [0, 0]
assert list(dset_is1) == [1, 1]
assert list(rec_is0) == [1, 2]
assert list(rec_is1) == [1, 0]
else:
assert list(sims) == [
0.9432949307428928, 0.8568189930049877, 0.8419286042520673
]
assert list(dset_is0) == [0, 0, 0]
assert list(dset_is1) == [1, 1, 1]
assert list(rec_is0) == [1, 2, 0]
assert list(rec_is1) == [1, 0, 0]
def test_blocking_three_datasets():
THRESHOLD = .6
SIMV = .7
# These values don't actually matter...
dataset0 = [ba('00'), ba('01'), ba('10'), ba('11')]
dataset1 = [ba('00'), ba('01'), ba('11'), ba('10')]
dataset2 = [ba('11'), ba('01'), ba('00'), ba('10')]
datasets = [dataset0, dataset1, dataset2]
def similarity_f(datasets, threshold, k=None):
items = [(SIMV, i, j) for i in range(len(datasets[0]))
for j in range(len(datasets[1]))]
return (array('d',
(i[0] for i in items)), (array('I',
(i[1] for i in items)),
array('I',
(i[2] for i in items))))
def blocking_f(dataset_index, record_index, hash_):
assert datasets[dataset_index][record_index] == hash_
# Records share a block if either their first bits match or
# their second bits match.
return enumerate(hash_)
blocks = [[(i, j) for i, dset in enumerate(datasets)
for j, rec in enumerate(dset) if rec[k] == v] for k in range(2)
for v in [False, True]]
sims, (dset_is0,
dset_is1), (rec_is0,
rec_is1) = find_candidate_pairs(datasets,
similarity_f,
THRESHOLD,
blocking_f=blocking_f)
assert (len(sims) == len(dset_is0) == len(rec_is0) == len(dset_is1) ==
len(rec_is1))
assert all(s == SIMV for s in sims)
for i0, i1 in zip(zip(dset_is0, rec_is0), zip(dset_is1, rec_is1)):
assert any(i0 in block and i1 in block for block in blocks)
for block in blocks:
for i0, i1 in combinations(block, 2):
if i0[0] != i1[0]:
assert (i0, i1) in zip(zip(dset_is0, rec_is0),
zip(dset_is1, rec_is1))
def test_no_blocking_three_datasets(k_):
THRESHOLD = .6
# These values don't actually matter...
dataset0 = [ba('00'), ba('01'), ba('10'), ba('11')]
dataset1 = [ba('00'), ba('01'), ba('11'), ba('')]
dataset2 = [ba('11'), ba('01'), ba('00'), ba('10')]
datasets = [dataset0, dataset1, dataset2]
def similarity_f(datasets, threshold, k=None):
assert threshold == THRESHOLD
# All we need to check for k is that it's been passed correctly
assert k == k_
dset0, dset1 = map(list, datasets)
if dset0 == dataset0 and dset1 == dataset1:
sims = [
0.9432949307428928, 0.8568189930049877, 0.8419286042520673,
0.6343698774541688, 0.6
]
rec_is0 = [1, 2, 0, 3, 0]
rec_is1 = [1, 0, 0, 3, 2]
elif dset0 == dataset0 and dset1 == dataset2:
sims = [
0.9962946784347061, 0.900267827898046, 0.88468228054972,
0.6956392099710476
]
rec_is0 = [1, 0, 3, 2]
rec_is1 = [2, 1, 2, 3]
elif dset0 == dataset1 and dset1 == dataset2:
sims = [
0.88468228054972, 0.699430643486643, 0.6121560533778709,
0.6076471833512952
]
rec_is0 = [3, 3, 2, 0]
rec_is1 = [2, 3, 2, 3]
else:
assert False, 'datasets not passed through as expected'
return array('d', sims), (array('I', rec_is0), array('I', rec_is1))
sims, (dset_is0, dset_is1), (rec_is0,
rec_is1) = find_candidate_pairs(datasets,
similarity_f,
THRESHOLD,
k=k_)
if k_ is 0:
assert list(sims) == []
assert list(dset_is0) == []
assert list(dset_is1) == []
assert list(rec_is0) == []
assert list(rec_is1) == []
elif k_ is 1:
assert list(sims) == [
0.9962946784347061, 0.9432949307428928, 0.900267827898046,
0.88468228054972, 0.8568189930049877, 0.6956392099710476,
0.6343698774541688
]
assert list(dset_is0) == [0, 0, 0, 1, 0, 0, 0]
assert list(dset_is1) == [2, 1, 2, 2, 1, 2, 1]
assert list(rec_is0) == [1, 1, 0, 3, 2, 2, 3]
assert list(rec_is1) == [2, 1, 1, 2, 0, 3, 3]
else:
assert list(sims) == [
0.9962946784347061, 0.9432949307428928, 0.900267827898046,
0.88468228054972, 0.88468228054972, 0.8568189930049877,
0.8419286042520673, 0.699430643486643, 0.6956392099710476,
0.6343698774541688, 0.6121560533778709, 0.6076471833512952, 0.6
]
assert list(dset_is0) == [0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0]
assert list(dset_is1) == [2, 1, 2, 2, 2, 1, 1, 2, 2, 1, 2, 2, 1]
assert list(rec_is0) == [1, 1, 0, 3, 3, 2, 0, 3, 2, 3, 2, 0, 0]
assert list(rec_is1) == [2, 1, 1, 2, 2, 0, 0, 3, 3, 3, 2, 3, 2]
def initialize(self):
""" Randomly initialize population """
return np.array(
[ba(self.gene_number) for i in range(self.population_number)],
float)
mps = maxPacketSize = 100 # bytes
hs = headerSize = 40 # bytes
pds = payloadSize = mps - hs # bytes
##dataRateMode = 0 # for payload size dependency
# Constants and fixed values
#known: v - tc - fl
#fromset: nh
#unknown: pl - hl - sa - da
###<SHOULD CHOOSE RULE 2>
v = version = bits(ba('0110')) # 4 bits, value = 6
tc = trafficClass = bits(uint=0, length=8) # 8 bits, value = 0
fl = flowLabel = bits(uint=0, length=20) # 20 bits, value = 0
pl = payloadLength = bits(uint=pds,
length=16) # 16 bits, value = payload size in bytes
nh = nextHeader = bits(uint=17, length=8) # 8 bits, value = 17 = udp
hl = hopLimit = bits(uint=randrange(20, 255),
length=8) # 8 bits, value = random
sa = sourceAddress = bits(ba(128)) # 128 bits, value = random
da = destinationAddress = bits(ba(128)) # 128 bits, value = random
pd = payload = bits(ba(pds * 8)) # bits, value = random
print "v: ", v, v.length
print "tc: ", tc, tc.length
print "fl: ", fl, fl.length
print "pl: ", pl, pl.int, pl.length
def Permutation(data, table):
return ba([data[i] for i in table])
def count(rowsLeft, rowA, rowB, rowC):
if rowsLeft == 0:
return 1
# filled another row ?
if rowA.count() == width:
return count(rowsLeft - 1, rowB, rowC, EmptyRow)
# find first gap in rowA
pos = rowA.index(0)
result = 0
# shape: @@ a
# @ b
a, b = ba(rowA), ba(rowB)
if (rowsLeft >= 2 and pos < width - 1 and use(pos, a) and use(pos + 1, a)
and use(pos, b)):
result += count(rowsLeft, fba(a), fba(b), rowC)
# shape: @@ a
# @ b
a, b = ba(rowA), ba(rowB)
if (rowsLeft >= 2 and pos < width - 1 and use(pos, a) and use(pos + 1, a)
and use(pos + 1, b)):
result += count(rowsLeft, fba(a), fba(b), rowC)
# shape: @ a
# @@ b
a, b = ba(rowA), ba(rowB)
if (rowsLeft >= 2 and pos < width - 1 and use(pos, a) and use(pos, b)
and use(pos + 1, b)):
result += count(rowsLeft, fba(a), fba(b), rowC)
# shape: @ a
# @@ b
# note: this shape extends one "negative" unit to the left
a, b = ba(rowA), ba(rowB)
if (rowsLeft >= 2 and pos > 0 and use(pos, a) and use(pos - 1, b)
and use(pos, b)):
result += count(rowsLeft, fba(a), fba(b), rowC)
# shape: @ a
# @ b
# @ c
a, b, c = ba(rowA), ba(rowB), ba(rowC)
if (rowsLeft >= 3 and use(pos, a) and use(pos, b) and use(pos, c)):
result += count(rowsLeft, fba(a), fba(b), fba(c))
# shape: @@@ a
a = ba(rowA)
if (rowsLeft >= 1 and pos < width - 2 and use(pos, a) and use(pos + 1, a)
and use(pos + 2, a)):
result += count(rowsLeft, fba(a), rowB, rowC)
return result
def bitclusterize(matrix, degrees, args):
'''
DESCRIPTION
Clusters the bit matrix using bitwise operations.
Args:
matrix (list): list of bitarrays
degrees (collections.OrderedDict): dict of bitarrays lenghts.
Return:
clusters (numpy.ndarray): array of clusters ID.
leaders (list) : list of clusters´ centers ID.
'''
degrees = np.asarray([degrees[x] for x in degrees])
# Memory allocation for clusters container --------------------------------
clusters = np.empty(len(matrix), dtype='int32')
clusters.fill(-1)
# Declare all bits as available -------------------------------------------
available_bits = ba(int(len(degrees)))
available_bits.setall('1')
# Start iterative switching -----------------------------------------------
leaders = []
clust_id = 0
ncluster = -1
while True:
ncluster += 1
# Break 0: break if max number of cluster was reached -----------------
if ncluster > args.max_clust:
break
# Find the biggest cluster --------------------------------------------
leader = degrees.argmax()
# Break 1: all candidates cluster have degree 1 (can´t clusterize) ----
if degrees.sum() == np.nonzero(degrees)[0].size:
# return clusters, leaders
break
biggest_cluster = matrix[leader] & available_bits
biggest_cluster_list = np.frombuffer(biggest_cluster.unpack(),
dtype=np.bool)
# Break 2: all candidates cluster have degree < minsize ---------------
if biggest_cluster_list.sum() < args.minsize:
# return clusters, leaders
break
# Break 3: No more candidates available (empty matrix) ----------------
if degrees.sum() == 0:
# return clusters, leaders
break
degrees[biggest_cluster_list] = 0
available_bits = (available_bits ^ biggest_cluster) & available_bits
if biggest_cluster.count() <= 1:
leaders.append(-1)
# return clusters, leaders
break
else:
leaders.append(leader)
# Assign next cluster ID ------------------------------------------
clusters[biggest_cluster_list] = clust_id
clust_id += 1
# Update degrees of unclustered frames --------------------------------
for degree in available_bits.itersearch(ba('1')):
# degrees[degree] = ba.fast_hw_and(available_bits, matrix[degree])
degrees[degree] = bau.count_and(available_bits, matrix[degree])
return clusters, leaders
def main():
# >>>> Debugging <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
# import argparse
# args = argparse.Namespace()
# args.trajectory = '../trajs/aligned_tau.dcd'
# args.topology = '../trajs/aligned_tau.pdb'
# args.nclust = np.inf
# args.min_clust_size = 2
# args.first = 1000
# args.last = 6000
# args.stride = 3
# args.selection = 'all'
# args.cutoff = 4
# args.outdir = 'bitQT_outputs'
# =========================================================================
# 1. Creating binary matrix (adjacency list)
# =========================================================================
# ++++ Get adjacency matrix of trajectory as list of bitarrays ++++++++++++
args = parse_arguments()
try:
os.makedirs(args.outdir)
except FileExistsError:
raise Exception('{} directory already exists.'.format(args.outdir) +
'Please specify another location or rename it.')
trajectory = load_raw_traj(args.trajectory, valid_trajs, args.topology)
trajectory = shrink_traj_selection(trajectory, args.selection)
N1 = trajectory.n_frames
trajectory = shrink_traj_range(args.first, args.last, args.stride, trajectory)
trajectory.center_coordinates()
matrix = calc_rmsd_matrix(trajectory, args)
# ++++ Tracking clust/uNCLUSTERed bits to avoid re-computations +++++++++++
N = len(matrix[0])
m = len(matrix)
unclust_bit = ba(N)
unclust_bit.setall(1)
clustered_bit = unclust_bit.copy()
clustered_bit.setall(0)
zeros = np.zeros(N, dtype=np.int32)
# ++++ Save clusters in an array (1 .. N) +++++++++++++++++++++++++++++++++
clusters_array = np.zeros(N, dtype=np.int32)
NCLUSTER = 0
clustered = set()
nmembers = []
# ++++ Coloring ordered vertices (1 .. N) +++++++++++++++++++++++++++++++++
degrees = calc_matrix_degrees(unclust_bit, matrix)
ordered_by_degs = degrees.argsort()[::-1]
colors = colour_matrix(ordered_by_degs, matrix)
# colors[np.frombuffer(clustered_bit.unpack(), dtype=np.bool)] = 0
# =========================================================================
# 2. Main algorithm: BitQT !
# =========================================================================
while True:
NCLUSTER += 1
# ++++ Find a big clique early ++++++++++++++++++++++++++++++++++++++++
big_node = degrees.argmax()
bit_clique, big_clique = do_bit_cascade(big_node, degrees, colors,
matrix, 0)
big_clique_size = big_clique.size
# ++++ Find promising nodes +++++++++++++++++++++++++++++++++++++++++++
biggers = degrees > big_clique_size
biggers[big_clique] = False
cluster_colors = colors[big_clique]
biggers_colors = colors[biggers]
promising_colors = np.setdiff1d(biggers_colors, cluster_colors)
promising_nodes = deque()
for x in promising_colors:
promising_nodes.extend(((colors == x) & biggers).nonzero()[0])
# ++++ Explore all promising nodes ++++++++++++++++++++++++++++++++++++
cum_found = big_clique
while promising_nodes:
node = promising_nodes.popleft()
try:
bit_clique, clique = do_bit_cascade(node, degrees, colors,
matrix, big_clique_size)
CLIQUE_SIZE = len(clique)
except TypeError:
CLIQUE_SIZE = 0
# ++++ Cumulative update only if biggers candidates are found +++++
if CLIQUE_SIZE > big_clique_size:
big_node = node
big_clique = clique
big_clique_size = big_clique.size
# ++++ Repeat previous condition ++++++++++++++++++++++++++++++
cum_found = np.concatenate((cum_found, big_clique))
biggers = degrees > big_clique_size
biggers[cum_found] = False
cluster_colors = colors[big_clique]
biggers_colors = colors[biggers]
promising_colors = np.setdiff1d(biggers_colors, cluster_colors)
promising_nodes = deque()
for x in promising_colors:
promising_nodes.extend(((colors == x) & biggers).nonzero()[0])
nmembers.append(big_clique_size)
if (big_clique_size < args.min_clust_size) or (NCLUSTER == args.nclust):
break
# ++++ Save new cluster & update NCLUSTER +++++++++++++++++++++++++++++
clusters_array[big_clique] = NCLUSTER
# ++++ Update (un)clustered_bit +++++++++++++++++++++++++++++++++++++++
clustered.update(big_clique)
clustered_bit = set_to_bitarray(clustered, N)
unclust_bit = ~clustered_bit
# ++++ Hard erasing of clustered frames from matrix +++++++++++++++++++
degrees = zeros.copy()
for x in unclust_bit[:m].itersearch(ba('1')):
degrees[x] = matrix[x].count()
if bu.count_and(matrix[x], clustered_bit):
matrix[x] &= (matrix[x] ^ clustered_bit)
# =========================================================================
# 3. Output
# =========================================================================
# saving pickle for api debugging tests
outname = os.path.basename(args.topology).split('.')[0]
pickle_to_file(clusters_array, os.path.join(args.outdir,
'{}.pick'.format(outname)))
# saving VMD visualization script
to_VMD(args.outdir, args.topology, args.first, args.last, N1, args.stride,
clusters_array[:m])
# saving clustering info files
frames_stats = get_frames_stats(N1, args.first, args.last, args.stride,
clusters_array[:m], args.outdir)
cluster_stats = get_cluster_stats(clusters_array[:m], args.outdir)
print('\n\nNormal Termination of BitQT :)')
