def build_triangularz(lp):
"""
Parameters
----------
lp
Returns
-------
"""
NH = lp['NH']
NV = lp['NV']
shape = lp['shape']
eta = lp['eta']
theta = lp['theta']
check = lp['check']
if lp['cutz_method'] == 'random':
xy, NL, KL, BL, LVUC, LV, UC, lattice_exten = \
generate_triangular_lattice(shape, NH, NV, eta, theta, check=check)
NL, KL, BL = \
le.cut_bonds_z_random(xy, NL, KL, BL, lp['target_z'], bulk_determination='Endpts', check=check)
elif lp['cutz_method'] == 'highest':
xy, NL, KL, BL, LVUC, LV, UC, lattice_exten = \
generate_triangular_lattice(shape, NH + 5, NV + 5, eta, theta, check=check)
NL, KL, BL = le.cut_bonds_z_highest(xy, NL, KL, BL, lp['target_z'], check=check)
# Now crop out correctly coordinated region
shapedict = {shape: [NH, NV]}
keep = blf.argcrop_lattice_to_polygon(shapedict, xy, check=check)
xy, NL, KL, BL = le.remove_pts(keep, xy, BL, NN='min')
LVUC = LVUC[keep]
else:
raise RuntimeError('Must specify cutz_method argument when Lattice topology == triangularz.')
# Remove any points with no bonds
keep = KL.any(axis=1)
xy, NL, KL, BL = le.remove_pts(keep, xy, BL, NN='min')
LVUC = LVUC[keep]
print 'len(xy) = ', len(xy)
z = le.compute_bulk_z(xy, NL, KL, BL)
print 'FOUND z = ', z
print('Defining lattice_exten...')
lattice_exten = 'triangularz_' + shape + '_zmethod' + lp['cutz_method'] + '_z' + '{0:0.03f}'.format(z)
PVxydict = {}
PVx = []
PVy = []
BBox = blf.auto_polygon(shape, lp['NH'], lp['NV'], eps=0.00)
LL = (np.max(xy[:, 0]) - np.min(xy[:, 0]), np.max(xy[:, 1]) - np.min(xy[:, 1]))
return xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten
def build_hyperuniform_annulus(lp):
"""Build an annular sample of hyperuniform centroid network structure.
Parameters
----------
lp : dict
lattice parameters dictionary. Uses lp['alph'] to determine the fraction of the system that is cut from the
center
Returns
-------
xy, NL, KL, BL, PVxydict, PVx, PVy, LVUC, BBox, LL, LV, UC, lattice_exten
"""
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_hyperuniform(
lp)
# Cut out the center and all particles more than radius away from center.
radius = min(np.max(xy[:, 0]), np.max(xy[:, 1]))
rad_inner = radius * lp['alph']
dist = np.sqrt(xy[:, 0]**2 + xy[:, 1]**2)
keep = np.logical_and(dist > rad_inner, dist < radius)
# PVxydict and PV should really not be necessary here, since the network is not periodic
if PVxydict:
print 'PVxydict = ', PVxydict
raise RuntimeError(
'Annulus function is not designed for periodic BCs -- what are you doing?'
)
else:
xy, NL, KL, BL = le.remove_pts(
keep, xy, BL, check=lp['check']) # , PVxydict=PVxydict, PV=PV)
lattice_exten += '_alph' + sf.float2pstr(lp['alph'])
return xy, NL, KL, BL, PVxydict, PVx, PVy, LVUC, BBox, LL, LV, UC, lattice_exten
def generate_cairo_tiling(lp):
"""
Parameters
----------
lp : dict
lattice parameters dict with keys: shape, NH, NV, aratio, delta, phi, check
Returns
-------
"""
print 'creating cairo tiling...'
lp_tmp = copy.deepcopy(lp)
lp_tmp['eta'] = 0.
lp_tmp['NH'] += 5
lp_tmp['NV'] += 5
xyA, NLA, KLA, BLA, LVUCA, LVA, UCA, PVxydictA, PVxA, PVyA, lattice_exten = \
generate_flattened_honeycomb_lattice(lp_tmp)
xyleft = xyA[xyA[:, 0] < np.min(xyA[:, 0]) + 1e-4]
farleft = np.argmin(xyleft[:, 1])
xyA -= xyleft[farleft]
if lp['check']:
le.display_lattice_2D(xyA, BLA)
xyB = np.dstack((xyA[:, 1], xyA[:, 0]))[0] + np.array([3., 1.])
BLB = (np.abs(BLA) + len(xyA)) * (np.minimum(np.sign(BLA[:, 0]), np.sign(BLA[:, 1]))).reshape(len(BLA), 1)
LVUC = 'none'
LV = LVA
UC = 'none'
xy = np.vstack((xyA, xyB))
BL = np.vstack((BLA, BLB))
keep = np.logical_and(np.logical_and(xy[:, 0] > 10, xy[:, 1] > 10),
np.logical_and(xy[:, 1] < np.max(xyA[:, 1]), xy[:, 0] < np.max(xyB[:, 0])))
xy, NL, KL, BL = le.remove_pts(keep, xy, BL)
# Find all crossing line segs, replace with a particle connected to each particle involved
# todo: make periodic BCs work (currently aren't realistically used)
PVxydict = copy.deepcopy(PVxydictA)
for key in PVxydictA:
PVxydict[(key[1], key[0])] = np.array([PVxydictA[key][1], PVxydictA[key][0]])
PVxB = copy.deepcopy(PVyA)
PVyB = copy.deepcopy(PVxA)
PVx = np.vstack((PVxA, PVxB))
PVy = np.vstack((PVyA, PVyB))
lattice_exten = 'cairo_' + lattice_exten[19:]
return xy, NL, KL, BL, LVUC, LV, UC, PVxydict, PVx, PVy, lattice_exten
def setup_penrose_for_periodic(lp):
"""Creating a rhombus-shaped penroserhombTri quasicrystalline lattice, with arrangement of particles such that
a periodic tiling nearly matches a true quasicrystal lattice."""
if lp['NH'] < 160 and lp['NV'] < 160:
Num_sub = int(np.ceil(np.log2(lp['NH']) + 2))
else:
Num_sub = int(np.ceil(np.log2(lp['NH']) + 3))
xy, NL, KL, BL, TRI, lattice_exten = generate_penrose_rhombic_tiling(Num_sub, check=False)
# Find a lower left sixfold particle
sixfold = np.where(np.sum(KL, axis=1) > 5)[0]
# print 'sixfold = ', sixfold
# print 'sum = ', xy[sixfold, 0] + xy[sixfold, 1]
lowerleft = np.argmin(xy[sixfold, 0] + xy[sixfold, 1])
indx = sixfold[lowerleft]
ll = (np.abs(xy[:, 0] - xy[indx, 0]) ** 2 + np.abs(xy[:, 1] - xy[indx, 1]) ** 2).argmin()
# Find a matching sixfold particle along vertical line from this location closest to NV away
vertical = np.where(np.abs(xy[:, 0] - xy[ll, 0]) < 1e-5)[0]
ul = vertical[np.argmin(np.abs(xy[vertical, 1] - xy[ll, 1] - lp['NV']))]
# Find a matching sixfold particle along sloped horizontal line from this location closest to NH away
rotll = xy - xy[ll, :]
ang = np.pi * 0.5 - 2 * np.pi * 0.2
xyrot = np.dstack((rotll[:, 0] * np.cos(ang) + rotll[:, 1] * np.sin(ang),
-rotll[:, 0] * np.sin(ang) + rotll[:, 1] * np.cos(ang)))[0]
horiz = np.where(np.abs(xyrot[:, 1]) < 1e-1)[0]
# print 'horiz = ', horiz
# plt.scatter(xy[:, 0], xy[:, 1])
# plt.scatter(xy[horiz, 0], xy[horiz, 1], c='r')
# plt.scatter(xy[ll, 0], xy[ll, 1], c='g')
# plt.show()
# plt.plot(xyrot[horiz, 0], np.abs(xyrot[horiz, 0] - lp['NH']), 'b.-')
# plt.show()
lr = horiz[np.argmin(np.abs(xyrot[horiz, 0] - lp['NH']))]
# Is there a matching particle along vertical line from this location closest to NV away from lr?
vertical = np.where(np.abs(xy[:, 0] - xy[lr, 0]) < 1e-2)[0]
ur = vertical[np.argmin(np.abs(xy[vertical, 1] - xy[lr, 1] - lp['NV']))]
if lp['check']:
print 'idx = ', ll
print 'ul = ', ul
print 'lr = ', lr
print 'ur = ', ur
le.movie_plot_2D(xy, BL, bs=0.0 * BL[:, 0], colormap='BlueBlackRed', colorz=True,
title='Output during periodic identification',
show=False) # PVx=PVx, PVy=PVy, PVxydict=PVxydict,
plt.plot([xy[ll, 0], xy[ul, 0], xy[lr, 0], xy[ur, 0]], [xy[ll, 1], xy[ul, 1], xy[lr, 1], xy[ur, 1]], 'ro')
plt.show()
vertd = xy[ul, 1] - xy[ll, 1]
horzd = xy[lr, 0] - xy[ll, 0]
horvd = xy[lr, 1] - xy[ll, 1]
midpt = np.mean(np.array([xy[ll], xy[ul], xy[ul] + np.array([horzd, horvd]), xy[lr]]), axis=0)
xy -= midpt
PV = np.array([[horzd, horvd], [0., vertd]])
polygon = 0.5 * np.array([[-PV[0, 0], (-PV[1, 1] - PV[0, 1])],
[PV[0, 0], (-PV[1, 1] + PV[0, 1])],
[PV[0, 0], (PV[1, 1] + PV[0, 1])],
[-PV[0, 0], (PV[1, 1] - PV[0, 1])]])
if lp['check']:
le.movie_plot_2D(xy, BL, bs=0.0 * BL[:, 0], colormap='BlueBlackRed', colorz=True,
title='point set before cropping', show=False)
plt.plot(polygon[:, 0], polygon[:, 1], 'r.-')
plt.show()
plt.clf()
BBox = copy.deepcopy(polygon)
eps = 1e-4
polygon += np.array([-eps, -eps])
bpath = mplpath.Path(polygon)
keep = bpath.contains_points(xy)
xy, NL, KL, BL = le.remove_pts(keep, xy, BL, NN='min', check=lp['check'])
return xy, NL, KL, BL, PV, BBox, polygon, lattice_exten
def build_lattice(lattice):
"""Build the lattice based on the values stored in the lp dictionary attribute of supplied lattice instance.
Returns
-------
lattice : lattice_class lattice instance
The instance of the lattice class, with the following attributes populated:
lattice.xy = xy
lattice.NL = NL
lattice.KL = KL
lattice.BL = BL
lattice.PVx = PVx
lattice.PVy = PVy
lattice.PVxydict = PVxydict
lattice.PV = PV
lattice.lp['BBox'] : #vertices x 2 float array
BBox is the polygon used to crop the lattice or defining the extent of the lattice; could be hexagonal, for instance.
lattice.lp['LL'] : tuple of 2 floats
LL are the linear extent in each dimension of the lattice. For ex:
( np.max(xy[:,0])-np.min(xy[:,0]), np.max(xy[:,1])-np.min(xy[:,1]) )
lattice.lp['LV'] = LV
lattice.lp['UC'] = UC
lattice.lp['lattice_exten'] : str
A string specifier for the lattice built
lattice.lp['slit_exten'] = slit_exten
"""
# Define some shortcut variables
lattice_type = lattice.lp['LatticeTop']
shape = lattice.lp['shape']
NH = lattice.lp['NH']
NV = lattice.lp['NV']
lp = lattice.lp
networkdir = lattice.lp['rootdir'] + 'networks/'
check = lattice.lp['check']
if lattice_type == 'hexagonal':
from build_hexagonal import build_hexagonal
xy, NL, KL, BL, PVxydict, PVx, PVy, PV, LL, LVUC, LV, UC, BBox, lattice_exten = build_hexagonal(
lp)
elif lattice_type == 'hexmeanfield':
from build_hexagonal import build_hexmeanfield
xy, NL, KL, BL, PVxydict, PVx, PVy, PV, LL, LVUC, LV, UC, BBox, lattice_exten = build_hexmeanfield(
lp)
elif lattice_type == 'hexmeanfield3gyro':
from build_hexagonal import build_hexmeanfield3gyro
xy, NL, KL, BL, PVxydict, PVx, PVy, PV, LL, LVUC, LV, UC, BBox, lattice_exten = build_hexmeanfield3gyro(
lp)
elif 'selregion' in lattice_type:
# amorphregion_isocent or amorphregion_kagome_isocent, for ex
# Example usage: python ./build/make_lattice.py -LT selregion_randorg_gammakick1p60_cent -spreadt 0.8 -NP 225
# python ./build/make_lattice.py -LT selregion_iscentroid -N 30
# python ./build/make_lattice.py -LT selregion_hyperuniform -N 80
from lepm.build.build_select_region import build_select_region
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_select_region(
lp)
elif lattice_type == 'frame1dhex':
from build_hexagonal import build_frame1dhex
# keep only the boundary of the lattice, eliminate the bulk
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_frame1dhex(
lp)
elif lattice_type == 'square':
import lepm.build.build_square as bs
print '\nCreating square lattice...'
xy, NL, KL, BL, lattice_exten = bs.generate_square_lattice(
shape, NH, NV, lp['eta'], lp['theta'])
print 'lattice_exten = ', lattice_exten
PVx = []
PVy = []
PVxydict = {}
LL = (NH + 1, NV + 1)
LVUC = 'none'
UC = 'none'
LV = 'none'
BBox = np.array([[-LL[0] * 0.5, -LL[1] * 0.5],
[LL[0] * 0.5,
-LL[1] * 0.5], [LL[0] * 0.5, LL[1] * 0.5],
[-LL[0] * 0.5, LL[1] * 0.5]])
elif lattice_type == 'triangular':
import lepm.build.build_triangular as bt
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = bt.build_triangular_lattice(
lp)
elif lattice_type == 'linear':
from lepm.build.build_linear_lattices import build_zigzag_lattice
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_zigzag_lattice(
lp)
lp['NV'] = 1
elif lattice_type == 'deformed_kagome':
from lepm.build.build_kagome import generate_deformed_kagome
xy, NL, KL, BL, PVxydict, PVx, PVy, PV, LL, LVUC, LV, UC, BBox, lattice_exten = generate_deformed_kagome(
lp)
elif lattice_type == 'deformed_martini':
from lepm.build.build_martini import build_deformed_martini
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_deformed_martini(
lp)
elif lattice_type == 'twisted_kagome':
from lepm.build.build_kagome import build_twisted_kagome
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_twisted_kagome(
lp)
elif lattice_type == 'hyperuniform':
from lepm.build.build_hyperuniform import build_hyperuniform
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_hyperuniform(
lp)
elif lattice_type == 'hyperuniform_annulus':
from lepm.build.build_hyperuniform import build_hyperuniform_annulus
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_hyperuniform_annulus(
lp)
lp['shape'] = 'annulus'
elif lattice_type == 'isostatic':
from lepm.build.build_jammed import build_isostatic
# Manually tune coordination of jammed packing (lets you tune through isostatic point)
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_isostatic(
lp)
elif lattice_type == 'jammed':
from lepm.build.build_jammed import build_jammed
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_jammed(
lp)
elif lattice_type == 'triangularz':
from lepm.build.build_triangular import build_triangularz
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_triangularz(
lp)
elif lattice_type == 'hucentroid':
from lepm.build.build_hucentroid import build_hucentroid
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_hucentroid(
lp)
elif lattice_type == 'hucentroid_annulus':
from lepm.build.build_hucentroid import build_hucentroid_annulus
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_hucentroid_annulus(
lp)
lp['shape'] = 'annulus'
elif lattice_type == 'huvoronoi':
from lepm.build.build_voronoized import build_huvoronoi
xy, NL, KL, BL, PVx, PVy, PVxydict, LL, BBox, lattice_exten = build_huvoronoi(
lp)
LVUC = 'none'
LV = 'none'
UC = 'none'
elif lattice_type == 'kagome_hucent':
from lepm.build.build_hucentroid import build_kagome_hucent
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_kagome_hucent(
lp)
elif lattice_type == 'kagome_hucent_annulus':
from lepm.build.build_hucentroid import build_kagome_hucent_annulus
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_kagome_hucent_annulus(
lp)
lp['shape'] = 'annulus'
elif lattice_type == 'kagome_huvor':
from lepm.build.build_voronoized import build_kagome_huvor
print('Loading hyperuniform to build lattice...')
xy, NL, KL, BL, PVx, PVy, PVxydict, LL, BBox, lattice_exten = build_kagome_huvor(
lp)
LV, LVUC, UC = 'none', 'none', 'none'
elif lattice_type == 'iscentroid':
from lepm.build.build_iscentroid import build_iscentroid
print('Loading isostatic to build lattice...')
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten = build_iscentroid(
lp)
elif lattice_type == 'kagome_isocent':
from lepm.build.build_iscentroid import build_kagome_isocent
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten = build_kagome_isocent(
lp)
elif lattice_type == 'overcoordinated1':
from lepm.build.build_overcoordinated import generate_overcoordinated1_lattice
xy, NL, KL, BL, SBL, LV, UC, LVUC, lattice_exten = generate_overcoordinated1_lattice(
NH, NV)
PVxydict = {}
PVx = []
PVy = []
if lp['check']:
le.display_lattice_2D(xy, BL)
elif lattice_type == 'circlebonds':
from lepm.build.build_linear_lattices import generate_circle_lattice
xy, NL, KL, BL, LV, UC, LVUC, lattice_exten = generate_circle_lattice(
NH)
PVxydict = {}
PVx = []
PVy = []
lp['NV'] = 1
minx = np.min(xy[:, 0])
maxx = np.max(xy[:, 0])
miny = np.min(xy[:, 1])
maxy = np.max(xy[:, 1])
BBox = np.array([[minx, miny], [minx, maxy], [maxx, maxy],
[maxx, miny]])
LL = (maxx - minx, maxy - miny)
elif lattice_type == 'dislocatedRand':
from lepm.build.build_dislocatedlattice import build_dislocated_lattice
xy, NL, KL, BL, PVx, PVy, PVxydict, LL, BBox, lattice_exten = build_dislocated_lattice(
lp)
elif lattice_type == 'dislocated':
if lp['dislocation_xy'] != 'none':
dislocX = lp['dislocation_xy'].split('/')[0]
dislocY = lp['dislocation_xy'].split('/')[1]
dislocxy_exten = '_dislocxy_' + dislocX + '_' + dislocY
pt = np.array([[float(dislocX), float(dislocY)]])
else:
pt = np.array([[0., 0.]])
dislocxy_exten = ''
if lp['Bvec'] == 'random':
Bvecs = 'W'
else:
Bvecs = lp['Bvec']
xy, NL, KL, BL, lattice_exten = generate_dislocated_hexagonal_lattice(
shape, NH, NV, pt, Bvecs=Bvecs, check=lp['check'])
lattice_exten += dislocxy_exten
PVx = []
PVy = []
PVxydict = {}
LL = (np.max(xy[:, 0]) - np.min(xy[:, 0]),
np.max(xy[:, 1]) - np.min(xy[:, 1]))
BBox = np.array([[np.min(xy[:, 0]), np.min(xy[:, 1])],
[np.max(xy[:, 0]), np.min(xy[:, 1])],
[np.max(xy[:, 0]), np.max(xy[:, 1])],
[np.min(xy[:, 0]), np.max(xy[:, 1])]])
LV = 'none'
UC = 'none'
LVUC = 'none'
elif lattice_type == 'penroserhombTri':
if lp['periodicBC']:
from lepm.build.build_quasicrystal import generate_periodic_penrose_rhombic
xy, NL, KL, BL, PVxydict, BBox, PV, lattice_exten = generate_periodic_penrose_rhombic(
lp)
LL = (PV[0, 0], PV[1, 1])
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
else:
from lepm.build.build_quasicrystal import generate_penrose_rhombic_lattice
xy, NL, KL, BL, lattice_exten, Num_sub = generate_penrose_rhombic_lattice(
shape, NH, NV, check=lp['check'])
LL = (np.max(xy[:, 0]) - np.min(xy[:, 0]),
np.max(xy[:, 1]) - np.min(xy[:, 1]))
BBox = blf.auto_polygon(shape, NH, NV, eps=0.00)
PVx = []
PVy = []
PVxydict = {}
LVUC = 'none'
LV = 'none'
UC = 'none'
elif lattice_type == 'penroserhombTricent':
from lepm.build.build_quasicrystal import generate_penrose_rhombic_centroid_lattice
xy, NL, KL, BL, PVxydict, PV, LL, BBox, lattice_exten = generate_penrose_rhombic_centroid_lattice(
lp)
# deepcopy PVxydict to generate new pointers
PVxydict = copy.deepcopy(PVxydict)
if lp['periodicBC']:
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
else:
PVx, PVy = [], []
# Rescale so that median bond length is unity
bL = le.bond_length_list(xy, BL, NL=NL, KL=KL, PVx=PVx, PVy=PVy)
scale = 1. / np.median(bL)
xy *= scale
PV *= scale
print 'PV = ', PV
BBox *= scale
LL = (LL[0] * scale, LL[1] * scale)
print 'after updating other things: PVxydict = ', PVxydict
if lp['periodicBC']:
PVx *= scale
PVy *= scale
PVxydict.update(
(key, val * scale) for key, val in PVxydict.items())
else:
PVx = []
PVy = []
LVUC = 'none'
LV = 'none'
UC = 'none'
elif lattice_type == 'kagome_penroserhombTricent':
from build.build_quasicrystal import generate_penrose_rhombic_centroid_lattice
xy, NL, KL, BL, lattice_exten = generate_penrose_rhombic_centroid_lattice(
shape, NH + 5, NV + 5, check=lp['check'])
# Decorate lattice as kagome
print('Decorating lattice as kagome...')
xy, BL, PVxydict = blf.decorate_as_kagome(xy, BL)
lattice_exten = 'kagome_' + lattice_exten
xy, NL, KL, BL = blf.mask_with_polygon(shape,
NH,
NV,
xy,
BL,
eps=0.00,
check=False)
# Rescale so that median bond length is unity
bL = le.bond_length_list(xy, BL)
xy *= 1. / np.median(bL)
minx = np.min(xy[:, 0])
miny = np.min(xy[:, 1])
maxx = np.max(xy[:, 0])
maxy = np.max(xy[:, 1])
BBox = np.array([[minx, miny], [minx, maxy], [maxx, maxy],
[maxx, miny]])
LL = (np.max(xy[:, 0]) - np.min(xy[:, 0]),
np.max(xy[:, 1]) - np.min(xy[:, 1]))
PVx = []
PVy = []
PVxydict = {}
LVUC = 'none'
LV = 'none'
UC = 'none'
elif lattice_type == 'random':
xx = np.random.uniform(low=-NH * 0.5 - 10,
high=NH * 0.5 + 10,
size=(NH + 20) * (NV + 20))
yy = np.random.uniform(low=-NV * 0.5 - 10,
high=NV * 0.5 + 10,
size=(NH + 20) * (NV + 20))
xy = np.dstack((xx, yy))[0]
Dtri = Delaunay(xy)
TRI = Dtri.vertices
BL = le.Tri2BL(TRI)
NL, KL = le.BL2NLandKL(BL, NN='min')
# Crop to polygon (instead of trimming boundaries)
# NL, KL, BL, TRI = le.delaunay_cut_unnatural_boundary(xy, NL, KL, BL, TRI, thres=lp['trimbound_thres'])
shapedict = {shape: [NH, NV]}
keep = blf.argcrop_lattice_to_polygon(shapedict, xy, check=check)
xy, NL, KL, BL = le.remove_pts(keep, xy, BL, NN='min')
lattice_exten = lattice_type + '_square_thres' + sf.float2pstr(
lp['trimbound_thres'])
polygon = blf.auto_polygon(shape, NH, NV, eps=0.00)
BBox = polygon
LL = (np.max(BBox[:, 0]) - np.min(BBox[:, 0]),
np.max(BBox[:, 1]) - np.min(BBox[:, 1]))
PVx = []
PVy = []
PVxydict = {}
LVUC = 'none'
LV = 'none'
UC = 'none'
elif lattice_type == 'randomcent':
from lepm.build.build_random import build_randomcent
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_randomcent(
lp)
elif lattice_type == 'kagome_randomcent':
from lepm.build.build_random import build_kagome_randomcent
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_kagome_randomcent(
lp)
elif lattice_type == 'randomspreadcent':
from lepm.build.build_randomspread import build_randomspreadcent
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_randomspreadcent(
lp)
elif lattice_type == 'kagome_randomspread':
from lepm.build.build_randomspread import build_kagome_randomspread
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_kagome_randomspread(
lp)
elif 'randorg_gammakick' in lattice_type and 'kaghi' not in lattice_type:
# lattice_type is like 'randorg_gamma0p20_cent' and uses Hexner pointsets
# NH is width, NV is height, NP_load is total number of points. This is different than other conventions.
from build_randorg_gamma import build_randorg_gamma_spread
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_randorg_gamma_spread(
lp)
elif 'randorg_gamma' in lattice_type and 'kaghi' not in lattice_type:
# lattice_type is like 'randorg_gamma0p20_cent' and uses Hexner pointsets
from build_randorg_gamma import build_randorg_gamma_spread_hexner
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = \
build_randorg_gamma_spread_hexner(lp)
elif 'random_organization' in lattice_type:
try:
if isinstance(lp['relax_timesteps'], str):
relax_tag = lp['relax_timesteps']
else:
relax_tag = '{0:02d}'.format(lp['relax_timesteps'])
except:
raise RuntimeError(
'lattice parameters dictionary lp needs key relax_timesteps')
points = np.loadtxt(
networkdir +
'random_organization_source/random_organization/random/' +
'random_kick_' + relax_tag + 'relax/out_d' +
'{0:02d}'.format(int(lp['conf'])) + '_xy.txt')
points -= np.mean(points, axis=0)
xytmp, trash1, trash2, trash3 = blf.mask_with_polygon(shape,
NH,
NV,
points, [],
eps=0.00)
xy, NL, KL, BL = le.delaunay_centroid_lattice_from_pts(xytmp,
polygon='auto',
check=check)
polygon = blf.auto_polygon(shape, NH, NV, eps=0.00)
if check:
le.display_lattice_2D(xy, BL)
# Rescale so that median bond length is unity
bL = le.bond_length_list(xy, BL, NL=NL, KL=KL, PVx=PVx, PVy=PVy)
xy *= 1. / np.median(bL)
polygon *= 1. / np.median(bL)
lattice_exten = lattice_type + '_relax' + relax_tag + '_' + shape + '_d' + \
'{0:02d}'.format(int(lp['loadlattice_number']))
LL = (np.max(xy[:, 0]) - np.min(xy[:, 0]),
np.max(xy[:, 1]) - np.min(xy[:, 1]))
PVxydict = {}
PVx = []
PVy = []
BBox = polygon
elif lattice_type == 'flattenedhexagonal':
from lepm.build.build_hexagonal import generate_flattened_honeycomb_lattice
xy, NL, KL, BL, LVUC, LV, UC, PVxydict, PVx, PVy, lattice_exten = \
generate_flattened_honeycomb_lattice(shape, NH, NV, lp['aratio'], lp['delta'], lp['phi'], eta=0., rot=0.,
periodicBC=False, check=check)
elif lattice_type == 'cairo':
from lepm.build.build_cairo import build_cairo
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = build_cairo(
lp)
elif lattice_type == 'kagper_hucent':
from lepm.build.build_hucentroid import build_kagper_hucent
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_kagper_hucent(
lp)
elif lattice_type == 'hex_kagframe':
from lepm.build.build_kagcentframe import build_hex_kagframe
# Use lp['alph'] to determine the beginning of the kagomized frame, surrounding hexagonal lattice
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_hex_kagframe(
lp)
elif lattice_type == 'hex_kagcframe':
from lepm.build.build_kagcentframe import build_hex_kagcframe
# Use lp['alph'] to determine the beginning of the kagomized frame, surrounding hexagonal lattice
# as circlular annulus
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_hex_kagcframe(
lp)
elif lattice_type in ['hucent_kagframe', 'hucent_kagcframe']:
from lepm.build.build_kagcentframe import build_hucent_kagframe
# Use lp['alph'] to determine the beginning of the kagomized frame, surrounding hucentroid decoration
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_hucent_kagframe(
lp)
elif lattice_type == 'kaghu_centframe':
from lepm.build.build_kagcentframe import build_kaghu_centframe
# Use lp['alph'] to determine the beginning of the centroid frame, surrounding kagomized decoration
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_kaghu_centframe(
lp)
elif lattice_type in ['isocent_kagframe', 'isocent_kagcframe']:
from lepm.build.build_kagcentframe import build_isocent_kagframe
# Use lp['alph'] to determine the beginning of the kagomized frame, surrounding hucentroid decoration
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_isocent_kagframe(
lp)
elif lattice_type == 'kagsplit_hex':
from lepm.build.build_kagome import build_kagsplit_hex
# Use lp['alph'] to determine what fraction (on the right) is kagomized
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_kagsplit_hex(
lp)
elif lattice_type == 'kagper_hex':
from lepm.build.build_kagome import build_kagper_hex
# Use lp['alph'] to determine what fraction of the radius/width (in the center) is kagomized
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_kagper_hex(
lp)
elif lattice_type == 'hex_kagperframe':
from lepm.build.build_kagcentframe import build_hex_kagperframe
# Use lp['alph'] to determine what fraction of the radius/width (in the center) is partially kagomized
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_hex_kagperframe(
lp)
elif lattice_type == 'kagome':
from lepm.build.build_kagome import build_kagome
# lets you make a square kagome
xy, NL, KL, BL, PVx, PVy, PVxydict, PV, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_kagome(
lp)
elif 'uofc' in lattice_type:
from lepm.build.build_kagcent_words import build_uofc
# ['uofc_hucent', 'uofc_kaglow_hucent', 'uofc_kaghi_hucent', 'uofc_kaglow_isocent']:
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_uofc(
lp)
elif 'chicago' in lattice_type:
from lepm.build.build_kagcent_words import build_chicago
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_chicago(
lp)
elif 'chern' in lattice_type:
from lepm.build.build_kagcent_words import build_kagcentchern
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_kagcentchern(
lp)
elif 'csmf' in lattice_type:
from lepm.build.build_kagcent_words import build_kagcentcsmf
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_kagcentcsmf(
lp)
elif 'thanks' in lattice_type:
# example:
# python ./build/make_lattice.py -LT kaghi_isocent_thanks -skip_gyroDOS -NH 300 -NV 70 -thres 5.5 -skip_polygons
from lepm.build.build_kagcent_words import build_kagcentthanks
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_kagcentthanks(
lp)
elif 'curvys' in lattice_type:
# for lattice_type in ['kaghi_isocent_curvys', 'kaglow_isocent_curvys',
# 'kaghi_hucent_curvys', 'kaglow_hucent_curvys', kaghi_randorg_gammakick1p60_cent_curvys',
# 'kaghi_randorg_gammakick0p50_cent_curvys', ... ]
# example usage:
# python ./build/make_lattice.py -LT kaghi_isocent_curvys -NH 100 -NV 70 -thres 5.5 -skip_polygons -skip_gyroDOS
from lepm.build.build_kagcent_words import build_kagcentcurvys
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_kagcentcurvys(
lp)
elif 'hexannulus' in lattice_type:
from lepm.build.build_conformal import build_hexannulus
xy, NL, KL, BL, lattice_exten, lp = build_hexannulus(lp)
LL = (np.max(xy[:, 0]) - np.min(xy[:, 0]),
np.max(xy[:, 1]) - np.min(xy[:, 1]))
PVxydict = {}
PVx = []
PVy = []
UC = np.array([0, 0])
LV = 'none'
LVUC = 'none'
minx = np.min(xy[:, 0])
miny = np.min(xy[:, 1])
maxx = np.max(xy[:, 0])
maxy = np.max(xy[:, 1])
BBox = np.array([[minx, miny], [minx, maxy], [maxx, maxy],
[maxx, miny]])
elif 'accordion' in lattice_type:
# accordionhex accordiony accordionkagy
# Example usage:
# python ./build/make_lattice.py -LT accordionkag -alph 0.9 -intparam 2 -N 6 -skip_polygons -skip_gyroDOS
# nzag controlled by lp['intparam'], and the rotation of the kagome element is controlled by lp['alph']
if lattice_type == 'accordionhex':
from lepm.build.build_hexagonal import build_accordionhex
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp, xyvx = build_accordionhex(
lp)
elif lattice_type == 'accordionkag':
from lepm.build.build_kagome import build_accordionkag
xy, NL, KL, BL, PVx, PVy, PVxydict, PV, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_accordionkag(
lp)
elif lattice_type == 'accordionkag_hucent':
from lepm.build.build_hucentroid import build_accordionkag_hucent
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = \
build_accordionkag_hucent(lp)
elif lattice_type == 'accordionkag_isocent':
from lepm.build.build_iscentroid import build_accordionkag_isocent
xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten = \
build_accordionkag_isocent(lp)
elif 'spindle' in lattice_type:
if lattice_type == 'spindle':
from lepm.build.build_spindle import build_spindle
xy, NL, KL, BL, PVxydict, PVx, PVy, PV, LL, LVUC, LV, UC, BBox, lattice_exten = build_spindle(
lp)
elif lattice_type == 'stackedrhombic':
from lepm.build.build_rhombic import build_stacked_rhombic
xy, NL, KL, BL, PVxydict, PVx, PVy, PV, LL, LVUC, LV, UC, BBox, lattice_exten = build_stacked_rhombic(
lp)
elif 'junction' in lattice_type:
# accordionhex accordiony accordionkagy
if lattice_type == 'hexjunction':
from lepm.build.build_hexagonal import build_hexjunction
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp, xyvx = build_hexjunction(
lp)
elif lattice_type == 'kagjunction':
from lepm.build.build_kagome import build_kagjunction
xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp = build_kagjunction(
lp)
###########
# For reference: this is how to change z
# le.cut_bonds_z(BL,lp['target_z'])
# ##cut N bonds for z
# N2cut = int(round((z_start-target_z)*len(BL)/z_start))
# allrows = range(len(BL))
# inds = random.sample(allrows, N2cut)
# keep = np.setdiff1d(allrows,inds)
# bnd_z = BL[keep]
# Cut slit
if lp['make_slit']:
print('Cuting notch or slit...')
L = max(xy[:, 0]) - min(xy[:, 0])
cutL = L * lp['cutLfrac']
x0 = -L * 0. + cutL * 0.5 - 1. # 0.25*L+0.5
BL, xy = blf.cut_slit(BL, xy, cutL + 1e-3, x0, y0=0.2)
slit_exten = '_cutL' + str(cutL / L) + 'L_x0_' + str(x0)
print('Rebuilding NL,KL...')
NP = len(xy)
if latticetop == 'deformed_kagome':
nn = 4
elif lattice_type == 'linear':
if NP == 1:
nn = 0
else:
nn = 2
else:
nn = 'min'
NL, KL = le.BL2NLandKL(BL, NP=NP, NN=nn)
# remake BL too
BL = le.NL2BL(NL, KL)
else:
slit_exten = ''
NP = len(xy)
if lp['check']:
print 'make_lattice: Showing lattice before saving...'
# print 'PVx = ', PVx
# print 'PVy = ', PVy
le.display_lattice_2D(xy, BL, PVxydict=PVxydict)
################
lattice.xy = xy
lattice.NL = NL
lattice.KL = KL
lattice.BL = BL
lattice.PVx = PVx
lattice.PVy = PVy
lattice.PVxydict = PVxydict
lattice.LVUC = LVUC
lattice.lp = lp
lattice.lp['BBox'] = BBox
lattice.lp['LL'] = LL
lattice.lp['LV'] = LV
lattice.lp['UC'] = UC
lattice.lp['lattice_exten'] = lattice_exten
lattice.lp['slit_exten'] = slit_exten
lattice.lp['Nparticles'] = NP
return lattice
def build_hexannulus_filled_defects(lp):
"""Build a U(1) symmetric honeycomb lattice within an annulus. The inner radius is given by alpha
At some cutoff radius, decrease the number of particles in each new row. Also, place a particle at the center.
Instead of lp['alph'] determining the inner radius cutoff as a fraction of the system size,
lp['alph'] as the cutoff radius for when to decrease the number of particles in each row.
Remove lp['Ndefects'] at each row within a radius of lp['alph'] * system_size.
Parameters
----------
lp : dict
"""
N = lp['NH']
shape = 'circle'
theta = np.linspace(0, 2. * np.pi, N + 1)
theta = theta[:-1]
# The radius, given the length of a side is:
# radius = s/(2 * sin(2 pi/ n)), where n is number of sides, s is length of each side
# We set the length of a side to be 1 (the rest length of each bond)
Rout = 1. / (2. * np.sin(np.pi / float(N)))
if lp['alph'] < 1e-5 or lp['alph'] > 1:
raise RuntimeError('lp param alph must be > 0 and less than 1')
Rinner = lp['alph'] * Rout
# Make the first row
xtmp = Rout * np.cos(theta)
ytmp = Rout * np.sin(theta)
xy = np.dstack([xtmp, ytmp])[0]
if lp['check']:
plt.plot(xy[:, 0], xy[:, 1], 'b.')
for ii in range(len(xy)):
plt.text(xy[ii, 0] + 0.2 * np.random.rand(1)[0],
xy[ii, 1] + 0.2 * np.random.rand(1)[0], str(ii))
plt.title('First row')
plt.show()
# rotate by delta(theta)/2 and shrink xy so that outer bond lengths are all equal to unity
# Here we have all bond lengths of the outer particles == 1, so that the inner radius is determined by
#
# o z1
# / |
# / |
# z2 o | |z2 - z0| = |z2 - z1| --> if z2 = r2 e^{i theta/2}, and z1 = r1 e^{i theta}, and z0 = r1,
# \ | then r2 = r1 cos[theta/2] - sqrt[s**2 - r1**2 + r1**2 cos[theta/2]**2]
# \ | or r2 = r1 cos[theta/2] + sqrt[s**2 - r1**2 + r1**2 cos[theta/2]**2]
# o z0 Choose the smaller radius (the first one).
# s is the sidelength, initially == 1
# iterate sidelength: s = R*2*sin(2pi/N)
# --> see for ex, http://www.mathopenref.com/polygonradius.html
dt = np.diff(theta)
if (dt - dt[0] < 1e-12).all():
dt = dt[0]
else:
print 'dt = ', dt
raise RuntimeError('Not all thetas are evenly spaced')
RR = Rout
ss = 1.
Rnext = RR * np.cos(dt * 0.5) - np.sqrt(ss**2 - RR**2 +
RR**2 * np.cos(dt * 0.5)**2)
rlist = [RR]
# Continue adding more rows
kk = 0
while Rnext > Rinner:
print 'Adding Rnext = ', Rnext
print 'with bond length connecting to last row = ', ss
# Add to xy
if np.mod(kk, 2) == 0:
xtmp = Rnext * np.cos(theta + dt * 0.5)
ytmp = Rnext * np.sin(theta + dt * 0.5)
else:
xtmp = Rnext * np.cos(theta)
ytmp = Rnext * np.sin(theta)
xyadd = np.dstack([xtmp, ytmp])[0]
xy = np.vstack((xy, xyadd))
rlist.append(Rnext)
if lp['check']:
plt.plot(xy[:, 0], xy[:, 1], 'b.')
for ii in range(len(xy)):
plt.text(xy[ii, 0] + 0.2 * np.random.rand(1)[0],
xy[ii, 1] + 0.2 * np.random.rand(1)[0], str(ii))
plt.title('next row')
plt.show()
RR = Rnext
ss = RR * np.sin(2. * np.pi / N)
print 'next sidelength = ', ss
Rnext = RR * np.cos(dt * 0.5) - np.sqrt(ss**2 - RR**2 +
RR**2 * np.cos(dt * 0.5)**2)
kk += 1
Rfinal = RR
# Get NV from the number of rows laid down.
NVtri = len(rlist)
lp['NV'] = NVtri - 2
print('Triangulating points...\n')
tri = Delaunay(xy)
TRItmp = tri.vertices
print('Computing bond list...\n')
BL = le.Tri2BL(TRItmp)
# bL = le.bond_length_list(xy,BL)
thres = 1.1 # cut off everything longer than a diagonal
print('thres = ' + str(thres))
print('Trimming bond list...\n')
BLtrim = le.cut_bonds(BL, xy, thres)
print('Trimmed ' + str(len(BL) - len(BLtrim)) + ' bonds.')
xy, NL, KL, BL = le.voronoi_lattice_from_pts(xy, NN=3, kill_outliers=True)
# Remove any bonds that cross the inner circle
tmpt = np.linspace(0, 2. * np.pi, 2000)
innercircle = Rinner * np.dstack((np.cos(tmpt), np.sin(tmpt)))[0]
# cycle the inner circle by one
ic_roll = np.dstack((np.roll(innercircle[:, 0],
-1), np.roll(innercircle[:, 1], -1)))[0]
ic = np.hstack((innercircle, ic_roll))
bondsegs = np.hstack((xy[BL[:, 0]], xy[BL[:, 1]]))
does_intersect = linsegs.linesegs_intersect_linesegs(bondsegs,
ic,
thres=1e-6)
keep = np.ones(len(BL[:, 0]), dtype=bool)
keep[does_intersect] = False
BL = BL[keep]
# Remove any points that ended up inside the inner radius (this should not be necessary)
inpoly = le.inds_in_polygon(xy, innercircle)
keep = np.setdiff1d(np.arange(len(xy)), inpoly)
print 'keep = ', keep
print 'len(xy) = ', len(xy)
xy, NL, KL, BL = le.remove_pts(keep, xy, BL, NN='min', check=lp['check'])
# Randomize if eta > 0 specified
eta = lp['eta']
if eta == 0:
xypts = xy
eta_exten = ''
else:
print 'Randomizing lattice by eta=', eta
jitter = eta * np.random.rand(np.shape(xy)[0], np.shape(xy)[1])
xypts = np.dstack(
(xy[:, 0] + jitter[:, 0], xy[:, 1] + jitter[:, 1]))[0]
eta_exten = '_eta{0:.3f}'.format(eta).replace('.', 'p')
# Naming
exten = '_circle_delta0p667_phi0p000_alph{0:0.2f}'.format(
lp['alph']).replace('.', 'p') + eta_exten
lattice_exten = 'hexannulus' + exten
print 'lattice_exten = ', lattice_exten
if lp['check']:
le.display_lattice_2D(xy,
BL,
NL=NL,
KL=KL,
title='output from build_hexannulus()',
close=False)
for ii in range(len(xy)):
plt.text(xy[ii, 0] + 0.2 * np.random.rand(1)[0],
xy[ii, 1] + 0.2 * np.random.rand(1)[0], str(ii))
plt.show()
# Scale up xy
BM = le.BL2BM(xy, NL, BL, KL=KL, PVx=None, PVy=None)
bL = le.BM2bL(NL, BM, BL)
scale = 1. / np.median(bL)
xy *= scale
return xy, NL, KL, BL, lattice_exten, lp
def build_kagome_randomcent(lp):
"""Build uniformly random point set, and construct voronoized network from that.
lp : dict
lattice parameters dictionary
"""
NH = lp['NH']
NV = lp['NV']
LL = (NH, NV)
if lp['periodicBC']:
xx = np.random.uniform(low=-NH * 0.5, high=NH * 0.5, size=NH * NV)
yy = np.random.uniform(low=-NV * 0.5, high=NV * 0.5, size=NH * NV)
xy = np.dstack((xx, yy))[0]
xy, NL, KL, BL, PVxydict = \
kagomecentroid_periodic_network_from_pts(xy, LL, BBox='auto', check=lp['check'])
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
# check that all points are inside BBox
shapedict = {lp['shape']: [NH, NV]}
keep = argcrop_lattice_to_polygon(shapedict, xy, check=lp['check'])
if len(np.where(keep)[0]) != len(xy):
raise RuntimeError('Some points were spuriously outside the allowed BBox.')
polygon = auto_polygon(lp['shape'], NH, NV, eps=0.00)
perstr = '_periodic'
else:
xx = np.random.uniform(low=-NH * 0.5 - 10, high=NH * 0.5 + 10, size=(NH + 20) * (NV + 20))
yy = np.random.uniform(low=-NV * 0.5 - 10, high=NV * 0.5 + 10, size=(NH + 20) * (NV + 20))
xy = np.dstack((xx, yy))[0]
xy, NL, KL, BL = kagomecentroid_lattice_from_pts(xy, polygon=None, trimbound=False, check=lp['check'])
# Crop to polygon
shapedict = {lp['shape']: [NH, NV]}
keep = argcrop_lattice_to_polygon(shapedict, xy, check=lp['check'])
xy, NL, KL, BL = le.remove_pts(keep, xy, BL, NN='min')
polygon = auto_polygon(lp['shape'], NH, NV, eps=0.00)
PVxydict = {}
PVx = []
PVy = []
perstr = ''
# If the meshfn going to overwrite a previous realization?
mfok = le.meshfn_is_used(le.build_meshfn(lp)[0])
print 'mfok = ', mfok
while mfok:
lp['conf'] += 1
mfok = le.meshfn_is_used(le.build_meshfn(lp)[0])
lattice_exten = lp['LatticeTop'] + '_' + lp['shape'] + perstr + '_r' + '{0:02d}'.format(int(lp['conf']))
# Rescale so that median bond length is unity
bL = le.bond_length_list(xy, BL, NL=NL, KL=KL, PVx=PVx, PVy=PVy)
scale = 1. / np.median(bL)
xy *= scale
polygon *= scale
LL = (LL[0] * scale, LL[1] * scale)
if lp['periodicBC']:
PVx *= scale
PVy *= scale
PVxydict.update((key, val * scale) for key, val in PVxydict.items())
LVUC = 'none'
LV = 'none'
UC = 'none'
BBox = polygon
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
return xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten
def build_isostatic(lp):
"""Build a network by manually tuning coordination of jammed packing (lets you tune through isostatic point)
Parameters
----------
lp
Returns
-------
"""
# Manually tune coordination of jammed packing (lets you tune through isostatic point)
networkdir = lp['rootdir'] + 'networks/'
print(
'Loading isostatic: get jammed point set to build lattice with new bonds...'
)
number = '{0:03d}'.format(int(lp['conf']))
if lp['source'] == 'hexner':
# Use Daniel Hexner - supplied networks
points, BL, LLv, numberstr, sizestr, lp = load_hexner_jammed(
lp, BL_load=False)
LL = (LLv, LLv)
print 'LL = ', LL
sourcestr = '_hexner'
else:
zindex = '{0:03d}'.format(int(lp['loadlattice_z']))
points = np.loadtxt(networkdir + 'isostatic_source/isostatic_homog_z' +
zindex + '_conf' + number + '_nodes.txt')
points -= np.mean(points, axis=0)
# DO initial cropping to speed up triangulation
keep1 = np.logical_and(
abs(points[:, 0]) < lp['NH'] * 0.5 + 8,
abs(points[:, 1]) < lp['NV'] * 0.5 + 8)
xy = points[keep1]
if lp['periodicBC']:
xy, NL, KL, BL, PVxydict = \
le.delaunay_rect_periodic_network_from_pts(xy, LL, target_z=lp['target_z'],
zmethod=lp['cutz_method'], check=check)
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
periodicstr = '_periodic'
else:
xy, NL, KL, BL, BM = le.delaunay_lattice_from_pts(
xy,
trimbound=False,
target_z=lp['target_z'],
zmethod=lp['cutz_method'],
check=check)
# if lp['cutz_method'] == 'random':
# NL, KL, BL = le.cut_bonds_z_random(xy, NL, KL, BL, lp['target_z'], bulk_determination='Endpts')
# elif lp['cutz_method'] == 'highest':
# NL, KL, BL = le.cut_bonds_z_highest(xy, NL, KL, BL, lp['target_z'], check=check)
# elif lp['cutz_method'] == 'none':
# pass
print('Trimming lattice to be NH x NV...')
keep = np.logical_and(
abs(xy[:, 0]) < lp['NH'] * 0.5,
abs(xy[:, 1]) < lp['NV'] * 0.5)
xy, NL, KL, BL = le.remove_pts(keep,
xy,
BL,
NN='min',
check=lp['check'])
PVxydict = {}
PVx = []
PVy = []
periodicstr = ''
le.movie_plot_2D(xy,
BL,
bs=0.0 * BL[:, 0],
PVx=PVx,
PVy=PVy,
PVxydict=PVxydict,
colormap='BlueBlackRed',
title='Output during isostatic build',
show=True)
plt.close('all')
# Calculate coordination number
z = le.compute_bulk_z(copy.deepcopy(xy), copy.deepcopy(NL),
copy.deepcopy(KL), copy.deepcopy(BL))
print 'FOUND z = ', z
lattice_exten = 'isostatic_' + lp['shape'] + periodicstr + sourcestr + '_z' + '{0:0.03f}'.format(z) + '_conf' + \
numberstr + '_zmethod' + lp['cutz_method']
BBox = np.array([[-LL[0] * 0.5, -LL[1] * 0.5], [LL[0] * 0.5, -LL[1] * 0.5],
[LL[0] * 0.5, LL[1] * 0.5], [-LL[0] * 0.5, LL[1] * 0.5]])
LV = 'none'
UC = 'none'
LVUC = 'none'
plt.close('all')
return xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp
def build_jammed(lp):
"""Use bonds from jammed packing --> already near isostatic, but can't tune above it, only below.
Parameters
----------
lp
Returns
-------
"""
# Use bonds from jammed packing --> already near isostatic, but can't tune above it, only below.
shape = lp['shape']
nh = lp['NH']
nv = lp['NV']
networkdir = dio.ensure_dir(lp['rootdir']) + 'networks/'
print('Loading isostatic file to build jammed lattice...')
# Now load
use_hexner = (lp['source'] == 'hexner')
if use_hexner:
print 'lp[periodicBC] = ', lp['periodicBC']
points, BL, LLv, numberstr, sizestr, lp = load_hexner_jammed(
lp, BL_load=True)
sourcestr = '_hexner'
else:
# Use Stephan Ulrich's lattices
if lp['periodicBC']:
RuntimeError('Not sure if Stephan Ulrich lattices are periodic!')
zindex = '{0:03d}'.format(int(lp['loadlattice_z']))
number = '{0:03d}'.format(int(lp['conf']))
points = np.loadtxt(networkdir + 'isostatic_source/isostatic_homog_z' +
zindex + '_conf' + number + '_nodes.txt')
BL = np.loadtxt(networkdir + 'isostatic_source/isostatic_homog_z' +
zindex + '_conf' + number + '_bonds.txt',
usecols=(0, 1),
dtype=int)
sourcestr = '_ulrich_homog'
print 'BL[100] = ', BL[100]
# Loaded BL uses indexing starting at 1, not 0
BL -= 1
print 'BL[100] = ', BL[100]
numberstr = number[1:]
if check:
le.display_lattice_2D(points,
np.abs(BL),
title='points and bonds loaded, before pruning')
xy = points - np.mean(points, axis=0)
NL, KL = le.BL2NLandKL(BL, NN='min')
# Remove any points with no bonds
print 'Removing points without any bonds...'
keep = KL.any(axis=1)
xy, NL, KL, BL = le.remove_pts(keep, xy, BL, NN='min')
print 'len(xy) = ', len(xy)
if check:
le.display_lattice_2D(
xy,
np.abs(BL),
title='Before tuning z (down) and before fixing PBCs')
if lp['cutz_method'] == 'random':
NL, KL, BL = le.cut_bonds_z_random(xy,
NL,
KL,
BL,
lp['target_z'],
bulk_determination='Endpts')
elif lp['cutz_method'] == 'highest':
NL, KL, BL = le.cut_bonds_z_highest(xy,
NL,
KL,
BL,
lp['target_z'],
check=check)
elif lp['cutz_method'] == 'none':
pass
if lp['periodicBC'] or lp['NP_load'] > 0:
print 'Building periodicBC PVs...'
lp['periodicBC'] = True
LL = (LLv, LLv)
polygon = 0.5 * np.array([[-LLv, -LLv], [LLv, -LLv], [LLv, LLv],
[-LLv, LLv]])
BBox = polygon
PV = np.array([[LLv, 0.0], [LLv, LLv], [LLv, -LLv], [0.0, 0.0],
[0.0, LLv], [0.0, -LLv], [-LLv, 0.0], [-LLv, LLv],
[-LLv, -LLv]])
PVxydict = le.BL2PVxydict(BL, xy, PV)
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
if lp['check']:
le.display_lattice_2D(xy,
BL,
NL=NL,
KL=KL,
PVx=PVx,
PVy=PVy,
title='Checking periodic BCs',
close=False,
colorz=False)
for ii in range(len(xy)):
plt.text(xy[ii, 0] + 0.1, xy[ii, 1], str(ii))
plt.plot(xy[:, 0], xy[:, 1], 'go')
plt.show()
else:
polygon = blf.auto_polygon(shape, nh, nv, eps=0.00)
BBox = polygon
print('Trimming lattice to be NH x NV...')
keep = np.logical_and(
abs(xy[:, 0]) < nh * 0.5,
abs(xy[:, 1]) < nv * 0.5)
print "Check that if lp['NP_load'] !=0 then len(keep) == len(xy):", len(
keep) == len(xy)
xy, NL, KL, BL = le.remove_pts(keep, xy, BL, NN='min')
LL = (nh, nv)
PVx = []
PVy = []
PVxydict = {}
z = le.compute_bulk_z(xy, NL, KL, BL)
print 'FOUND z = ', z
if lp['periodicBC']:
periodicBCstr = '_periodicBC'
else:
periodicBCstr = ''
print('Defining lattice_exten...')
lattice_exten = 'jammed_' + shape + sourcestr + periodicBCstr + '_z' + '{0:0.03f}'.format(z) + '_conf' + \
numberstr + '_zmethod' + lp['cutz_method']
LV = 'none'
UC = 'none'
LVUC = 'none'
return xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp
def calc_boundary_inner(mglat, check=False):
"""
Parameters
----------
mglat: MagneticGyroLattice instance
check: bool
Returns
-------
boundary_inner : M x 1 int array
the idices of mglat.xy that mark the boundary of mglat.xy_inner
"""
# First check if there is an outer boundary to be ignored
if len(mglat.outer_indices) == 0:
# All particles are inner particles
boundary_inner = mglat.lattice.get_boundary()
else:
# First remove the outer boundary
print 'mgfns: removing outer boundary for tmp lattice'
xytmp, NLtmp, KLtmp, BLtmp = le.remove_pts(
mglat.inner_indices,
mglat.xy,
mglat.lattice.BL,
NN='min',
check=check,
PVxydict=mglat.lattice.PVxydict,
PV=mglat.lattice.PV)
if mglat.lattice.PV is not None:
PVxydict_tmp = le.BL2PVxydict(BLtmp, xytmp, mglat.lattice.PV)
PVxtmp, PVytmp = le.PVxydict2PVxPVy(PVxydict_tmp,
NLtmp,
KLtmp,
check=check)
if mglat.lp['periodic_strip']:
# Special case: if the entire strip is a boundary, then get
boundary = le.extract_1d_boundaries(xytmp,
NLtmp,
KLtmp,
BLtmp,
PVxtmp,
PVytmp,
check=check)
elif mglat.lp['periodicBC']:
boundary = None
raise RuntimeError(
'periodic boundary conditions and not periodic strip, yet outer_indices are nonempty'
)
elif 'annulus' in mglat.lp['LatticeTop'] or mglat.lp[
'shape'] == 'annulus':
print 'here'
outer_boundary = le.extract_boundary(xytmp,
NLtmp,
KLtmp,
BLtmp,
check=check)
inner_boundary = le.extract_inner_boundary(xytmp,
NLtmp,
KLtmp,
BLtmp,
check=check)
boundary = (outer_boundary, inner_boundary)
else:
boundary = le.extract_boundary(xytmp,
NLtmp,
KLtmp,
BLtmp,
check=check)
# Now determine which particles are the same as xytmp[boundary]
boundary_inner = dh.match_points(mglat.xy, xytmp[boundary])
if check:
print 'mgfns: boundary_inner = ', boundary_inner
import matplotlib.pyplot as plt
plt.plot(mglat.xy[:, 0], mglat.xy[:, 1], 'b.')
plt.plot(xytmp[boundary, 0], xytmp[boundary, 1], 'go')
plt.plot(mglat.xy[boundary_inner, 0], mglat.xy[boundary_inner, 1],
'r.')
plt.show()
return boundary_inner
def build_select_region(lp):
"""
Parameters
----------
lp
Returns
-------
"""
lpnew = copy.deepcopy(lp)
lpnew['LatticeTop'] = lp['LatticeTop'].split('selregion_')[-1]
lpnew['check'] = False
print 'lpnew[LatticeTop] = ', lpnew['LatticeTop']
lattice = lattice_class.Lattice(lpnew)
print '\nBuilding lattice...'
lattice.build()
# xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten = build_kagome_isocent(lp)
xy = lattice.xy
NL = lattice.NL
KL = lattice.KL
BL = lattice.BL
PVx = lattice.PVx
PVy = lattice.PVy
PVxydict = lattice.PVxydict
try:
LVUC = lattice.lp['LVUC']
LV = lattice.lp['LV']
UC = lattice.lp['UC']
except:
LVUC = 'none'
LV = 'none'
UC = 'none'
LL = lattice.lp['LL']
old_lattice_exten = lattice.lp['lattice_exten']
# Display lattice
ax = le.display_lattice_2D(xy,
BL,
NL=NL,
KL=KL,
PVxydict=PVxydict,
PVx=PVx,
PVy=PVy,
title='Choose roi polygon',
xlimv=None,
ylimv=None,
colorz=True,
ptcolor=None,
ptsize=10,
close=False,
colorpoly=False,
viewmethod=False,
labelinds=False,
colormap='BlueBlackRed',
bgcolor='#FFFFFF',
axis_off=False,
linewidth=0.0,
edgecolors=None,
check=False)
# let user draw ROI
roi = roipoly(ax=ax, roicolor='r')
print 'roi = ', roi
print 'x = ', roi.allxpoints
print 'y = ', roi.allypoints
roi = np.dstack((roi.allxpoints, roi.allypoints))[0]
inpoly = dh.inds_in_polygon(xy, roi)
print 'inpoly = ', inpoly
if lp['check']:
plt.plot(xy[inpoly, 0], xy[inpoly, 1], 'b.')
plt.show()
xy, NL, KL, BL = le.remove_pts(inpoly, xy, BL, check=lp['check'])
if lp['periodicBC']:
PV = le.PVxydict2PV(PVxydict)
PVxydict = le.BL2PVxydict(BL, xy, PV)
# If cropping the points has cut off all periodic BCs, update lp to reflect this
if len(PVxydict) == 0:
lp['periodicBC'] = False
if LVUC is not None and LVUC is not 'none':
LVUC = LVUC[inpoly]
BBox = roi
lattice_exten = 'selregion_' + old_lattice_exten + '_NP{0:06d}'.format(
len(xy))
xy -= np.mean(xy, axis=0)
if lp['check']:
ax = le.display_lattice_2D(xy,
BL,
NL=NL,
KL=KL,
PVxydict=PVxydict,
PVx=PVx,
PVy=PVy,
title='Cropped network',
xlimv=None,
ylimv=None,
colorz=True,
ptcolor=None,
ptsize=10,
close=False,
colorpoly=False,
viewmethod=False,
labelinds=False,
colormap='BlueBlackRed',
bgcolor='#FFFFFF',
axis_off=False,
linewidth=0.0,
edgecolors=None,
check=False)
return xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten, lp
def build_hyperuniform(lp):
"""Build a network from a triangulated hyperuniform pointset
Parameters
----------
lp
Returns
-------
"""
networkdir = dio.prepdir(lp['rootdir']) + 'networks/'
NH = lp['NH']
NV = lp['NV']
shape = lp['shape']
if lp['NP_load'] == 0:
points = np.loadtxt(networkdir +
'hyperuniform_source/hyperuniform_N400/out_d' +
str(int(lp['conf'])) + '_xy.txt')
points -= np.mean(points, axis=0) + lp['origin']
# make lattice larger than final cut
keep = np.logical_and(
abs(points[:, 0]) < NH * 1.5 + 8,
abs(points[:, 1]) < NV * 1.5 + 8)
xy = points[keep]
xytri, NL, KL, BL, BM = le.delaunay_lattice_from_pts(
xy, trimbound=False, target_z=lp['target_z'])
# Crop lattice down to size
polygon = blf.auto_polygon(shape, NH, NV, eps=0.00)
BBox = polygon
print('Trimming lattice to be NH x NV...')
keep = np.logical_and(
abs(xy[:, 0]) < NH * 0.5,
abs(xy[:, 1]) < NV * 0.5)
print "Check that if lp['NP_load'] !=0 then len(keep) == len(xy):", len(
keep) == len(xy)
xy, NL, KL, BL = le.remove_pts(keep, xytri, BL, NN='min')
# make string from origin values
print 'lp[origin] = ', lp['origin']
print 'type(lp[origin]) = ', type(lp['origin'])
if (np.abs(lp['origin']) < 1e-7).all():
originstr = ''
else:
originstr = '_originX' + '{0:0.2f}'.format(lp['origin'][0]).replace('.', 'p') + \
'Y' + '{0:0.2f}'.format(lp['origin'][1]).replace('.', 'p')
periodicstr = ''
LL = (NH, NV)
BBox = 0.5 * np.array([[-LL[0], -LL[1]], [LL[0], -LL[1]],
[LL[0], LL[1]], [-LL[0], LL[1]]],
dtype=float)
PVx = []
PVy = []
PVxydict = {}
else:
# Unlike in the jammed case, we can't load a periodic bond list! We must make it.
lp['periodicBC'] = True
sizestr = '{0:03d}'.format(lp['NP_load'])
points = np.loadtxt(networkdir + 'hyperuniform_source/hyperuniform_N' + sizestr + '/out_d' + \
str(int(lp['conf'])) + '_xy.txt')
points -= np.mean(points, axis=0)
# Ensuring that origin param is centered (since using entire lattice)
lp['origin'] = np.array([0.0, 0.0])
LL = (lp['NP_load'], lp['NP_load'])
polygon = 0.5 * np.array([[-LL[0], -LL[1]], [LL[0], -LL[1]],
[LL[0], LL[1]], [-LL[0], LL[1]]])
BBox = polygon
xy, NL, KL, BL, PVxydict = le.delaunay_rect_periodic_network_from_pts(
points,
LL,
BBox='auto',
check=lp['check'],
zmethod=lp['cutz_method'],
target_z=lp['target_z'])
print 'Building periodicBC PVs...'
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
originstr = ''
periodicstr = '_periodic'
if lp['check']:
le.display_lattice_2D(xy,
BL,
NL=NL,
KL=KL,
PVx=PVx,
PVy=PVy,
title='Checking periodic BCs',
close=False,
colorz=False)
for ii in range(len(xy)):
plt.text(xy[ii, 0] + 0.1, xy[ii, 1], str(ii))
plt.plot(xy[:, 0], xy[:, 1], 'go')
plt.show()
lattice_exten = 'hyperuniform_' + shape + periodicstr + '_d' + '{0:02d}'.format(int(lp['conf'])) + \
'_z{0:0.3f}'.format(lp['target_z']) + originstr
LV = 'none'
UC = 'none'
LVUC = 'none'
return xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten
