placed_edges, edge_bonds = place_edges(evecs, CHARGES,
len(placed_nodes))
if RECORD_CALLBACK:
vnames = '_'.join([v.split('.')[0] for v in v_set])
if len(ea) <= 5:
enames = '_'.join([e[0:-4] for e in ea])
else:
enames = str(len(ea)) + '_edges'
prefix = template[0:-4] + '_' + vnames + '_' + enames
frames = scaling_callback_animation(callbackresults, alpha,
Bstar_inv, ncra, ncca,
num_vertices, num_edges,
TG, template, g, False)
write_scaling_callback_animation(frames, prefix)
animate_objective_minimization(callbackresults, prefix)
if PLACE_EDGES_BETWEEN_CONNECTION_POINTS:
placed_edges = adjust_edges(placed_edges, placed_nodes,
sc_unit_cell)
placed_all = placed_nodes + placed_edges
bonds_all = node_bonds + edge_bonds
if WRITE_CHECK_FILES:
write_check_cif(template, placed_nodes, placed_edges, g,
scaled_params, sc_unit_cell)
def run_template(template):
print()
print('=========================================================================================================')
print('template :',template)
print('=========================================================================================================')
print()
cat_count = 0
for net in ct2g(template):
cat_count += 1
TG, start, unit_cell, TVT, TET, TNAME, a, b, c, ang_alpha, ang_beta, ang_gamma, max_le, catenation = net
TVT = sorted(TVT, key=lambda x:x[0], reverse=True)
TET = sorted(TET, reverse=True)
node_cns = [(cncalc(node, 'nodes', ONE_ATOM_NODE_CN), node) for node in os.listdir('nodes')]
print('Number of vertices = ', len(TG.nodes()))
print('Number of edges = ', len(TG.edges()))
print()
if PRINT:
print('There are', len(TG.nodes()), 'vertices in the voltage graph:')
print()
v = 0
for node in TG.nodes():
v += 1
print(v,':',node)
node_dict = TG.node[node]
print('type : ', node_dict['type'])
print('cartesian coords : ', node_dict['ccoords'])
print('fractional coords : ', node_dict['fcoords'])
print('degree : ', node_dict['cn'][0])
print()
print('There are', len(TG.edges()), 'edges in the voltage graph:')
print()
for edge in TG.edges(data=True,keys=True):
edge_dict = edge[3]
ind = edge[2]
print(ind,':',edge[0],edge[1])
print('length : ',edge_dict['length'])
print('type : ',edge_dict['type'])
print('label : ',edge_dict['label'])
print('positive direction :',edge_dict['pd'])
print('cartesian coords : ',edge_dict['ccoords'])
print('fractional coords : ',edge_dict['fcoords'])
print()
vas = vertex_assign(TG, TVT, node_cns, unit_cell, ONE_ATOM_NODE_CN, USER_SPECIFIED_NODE_ASSIGNMENT, SYMMETRY_TOL, ALL_NODE_COMBINATIONS)
CB,CO = cycle_cocyle(TG)
for va in vas:
if len(va) == 0:
print('At least one vertex does not have a building block with the correct number of connection sites.')
print('Moving to the next template...')
print()
continue
if len(CB) != (len(TG.edges()) - len(TG.nodes()) + 1):
print('The cycle basis is incorrect.')
print('The number of cycles in the cycle basis does not equal the rank of the cycle space.')
print('Moving to the next tempate...')
continue
num_edges = len(TG.edges())
Bstar, alpha = Bstar_alpha(CB,CO,TG,num_edges)
if PRINT:
print('B* (top) and alpha (bottom) for the barycentric embedding are:')
print()
for i in Bstar:
print(i)
print()
for i in alpha:
print(i)
print()
num_vertices = len(TG.nodes())
if COMBINATORIAL_EDGE_ASSIGNMENT:
eas = list(itertools.product([e for e in os.listdir('edges')], repeat = len(TET)))
else:
edge_files = sorted([e for e in os.listdir('edges')])
eas = []
i = 0
while len(eas) < len(TET):
eas.append(edge_files[i])
i += 1
if i == len(edge_files):
i = 0
eas = [eas]
g = 0
for va in vas:
node_elems = [bbelems(i[1], 'nodes') for i in va]
metals = [[i for i in j if i in metal_elements] for j in node_elems]
metals = list(set([i for j in metals for i in j]))
v_set = [('v' + str(vname_dict[re.sub('[0-9]','',i[0])]), i[1]) for i in va]
v_set = sorted(list(set(v_set)), key=lambda x: x[0])
v_set = [v[0] + '-' + v[1] for v in v_set]
print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
print('vertex assignment : ',v_set)
print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
print()
if SINGLE_METAL_MOFS_ONLY and len(metals) != 1:
print(v_set, 'contains no metals or multiple metal elements, no cif will be written')
print()
continue
for v in va:
for n in TG.nodes(data=True):
if v[0] == n[0]:
n[1]['cifname'] = v[1]
for ea in eas:
g += 1
print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
print('edge assignment : ',ea)
print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
print()
type_assign = dict((k,[]) for k in sorted(TET, reverse=True))
for k,m in zip(TET,ea):
type_assign[k] = m
for e in TG.edges(data=True):
ty = e[2]['type']
for k in type_assign:
if ty == k or (ty[1],ty[0]) == k:
e[2]['cifname'] = type_assign[k]
ea_dict = assign_node_vecs2edges(TG, unit_cell, SYMMETRY_TOL)
all_SBU_coords = SBU_coords(TG, ea_dict, CONNECTION_SITE_BOND_LENGTH)
sc_a, sc_b, sc_c, sc_alpha, sc_beta, sc_gamma, sc_covar, Bstar_inv, max_length, callbackresults, ncra, ncca, scaling_data = scale(all_SBU_coords,a,b,c,ang_alpha,ang_beta,ang_gamma,max_le,num_vertices,Bstar,alpha,num_edges,FIX_UC,SCALING_ITERATIONS,PRE_SCALE,SCALING_CONVERGENCE_TOLERANCE,SCALING_STEP_SIZE)
print('*******************************************')
print('The scaled unit cell parameters are : ')
print('*******************************************')
print('a :', np.round(sc_a, 5))
print('b :', np.round(sc_b, 5))
print('c :', np.round(sc_c, 5))
print('alpha:', np.round(sc_alpha, 5))
print('beta :', np.round(sc_beta, 5))
print('gamma:', np.round(sc_gamma, 5))
print()
for sc, name in zip((sc_a, sc_b, sc_c), ('a', 'b', 'c')):
cflag = False
if sc < 1.0:
print('unit cell parameter', name, 'has collapsed during scaling!')
print('try re-running with', name, 'fixed, with a larger value for PRE_SCALE, or with a higher SCALING_CONVERGENCE_TOLERANCE')
print('no cif will be written')
cflag = True
if cflag:
continue
scaled_params = [sc_a,sc_b,sc_c,sc_alpha,sc_beta,sc_gamma]
sc_Alpha = np.r_[alpha[0:num_edges-num_vertices+1,:], sc_covar]
sc_omega_plus = np.dot(Bstar_inv, sc_Alpha)
ax = sc_a
ay = 0.0
az = 0.0
bx = sc_b * np.cos(sc_gamma * pi/180.0)
by = sc_b * np.sin(sc_gamma * pi/180.0)
bz = 0.0
cx = sc_c * np.cos(sc_beta * pi/180.0)
cy = (sc_c * sc_b * np.cos(sc_alpha * pi/180.0) - bx * cx) / by
cz = (sc_c ** 2.0 - cx ** 2.0 - cy ** 2.0) ** 0.5
sc_unit_cell = np.asarray([[ax,ay,az],[bx,by,bz],[cx,cy,cz]]).T
scaled_coords = omega2coords(start, TG, sc_omega_plus, (sc_a,sc_b,sc_c,sc_alpha,sc_beta,sc_gamma), num_vertices, template, g, WRITE_CHECK_FILES)
nvecs,evecs = scaled_node_and_edge_vectors(scaled_coords, sc_omega_plus, sc_unit_cell, ea_dict)
placed_nodes, node_bonds = place_nodes(nvecs, CHARGES, ORIENTATION_DEPENDENT_NODES)
placed_edges, edge_bonds = place_edges(evecs, CHARGES, len(placed_nodes))
if RECORD_CALLBACK:
vnames = '_'.join([v.split('.')[0] for v in v_set])
if len(ea) <= 5:
enames = '_'.join([e[0:-4] for e in ea])
else:
enames = str(len(ea)) + '_edges'
prefix = template[0:-4] + '_' + vnames + '_' + enames
frames = scaling_callback_animation(callbackresults, alpha, Bstar_inv, ncra, ncca, num_vertices, num_edges, TG, template, g, False)
write_scaling_callback_animation(frames, prefix)
animate_objective_minimization(callbackresults, prefix)
if PLACE_EDGES_BETWEEN_CONNECTION_POINTS:
placed_edges = adjust_edges(placed_edges, placed_nodes, sc_unit_cell)
placed_all = placed_nodes + placed_edges
bonds_all = node_bonds + edge_bonds
if WRITE_CHECK_FILES:
write_check_cif(template, placed_nodes, placed_edges, g, scaled_params, sc_unit_cell)
if SINGLE_ATOM_NODE or NODE_TO_NODE:
placed_all,bonds_all = remove_Fr(placed_all,bonds_all)
print('computing X-X bonds...')
print()
print('*******************************************')
print('Bond formation : ')
print('*******************************************')
fixed_bonds, nbcount, bond_check = bond_connected_components(placed_all, bonds_all, sc_unit_cell, max_length, BOND_TOL, TRACE_BOND_MAKING, NODE_TO_NODE, EXPANSIVE_BOND_SEARCH, ONE_ATOM_NODE_CN)
print('there were ', nbcount, ' X-X bonds formed')
if bond_check:
print('bond check passed')
bond_check_code = ''
else:
print('bond check failed, attempting distance search bonding...')
fixed_bonds, nbcount = distance_search_bond(placed_all, bonds_all, sc_unit_cell, 2.5, TRACE_BOND_MAKING)
bond_check_code = '_BOND_CHECK'
print('there were', nbcount, 'X-X bonds formed')
print()
if CHARGES:
fc_placed_all, netcharge, onetcharge, rcb = fix_charges(placed_all)
else:
fc_placed_all = placed_all
fixed_bonds = fix_bond_sym(fixed_bonds, placed_all, sc_unit_cell)
if CHARGES:
print('*******************************************')
print('Charge information : ')
print('*******************************************')
print('old net charge :', np.round(onetcharge, 5))
print('rescaling magnitude :', np.round(rcb, 5))
remove_net = choice(range(len(fc_placed_all)))
fc_placed_all[remove_net][4] -= np.round(netcharge, 4)
print('new net charge (after rescaling):', np.sum([li[4] for li in fc_placed_all]))
print()
vnames = '_'.join([v.split('.')[0] for v in v_set])
if len(ea) <= 5:
enames = []
for e in [e[0:-4] for e in ea]:
if e not in enames:
enames.append(e)
enames = '_'.join(enames)
else:
enames = str(len(ea)) + '_edges'
if catenation:
cifname = template[0:-4] + '_' + vnames + '_' + enames + bond_check_code + '_' + 'CAT' + str(cat_count) + '.cif'
else:
cifname = template[0:-4] + '_' + vnames + '_' + enames + bond_check_code + '.cif'
if WRITE_CIF:
print('writing cif...')
print()
if len(cifname) > 255:
cifname = cifname[0:241]+'_truncated.cif'
write_cif(fc_placed_all, fixed_bonds, scaled_params, sc_unit_cell, cifname, CHARGES)
if catenation and MERGE_CATENATED_NETS:
print('merging catenated cifs...')
cat_cifs = glob.glob('output_cifs/*_CAT*.cif')
for comb in itertools.combinations(cat_cifs, cat_count):
builds = [name[0:-9] for name in comb]
print(set(builds))
if len(set(builds)) == 1:
pass
else:
continue
merge_catenated_cifs(comb, CHARGES)
for cif in cat_cifs:
os.remove(cif)