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_cairo(lp):
"""
Parameters
----------
lp
Returns
-------
"""
xy, NL, KL, BL, LVUC, LV, UC, PVxydict, PVx, PVy, lattice_exten = generate_cairo_tiling(lp)
BBox = blf.auto_polygon(shape, NH, 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_triangular_lattice(lp):
print('Build the lattice')
if lp['periodicBC']:
raise RuntimeError('Have not coded periodic triangular lattice yet... do that here.')
else:
shape_keep = lp['shape']
shape = {shape_keep: [lp['NH'] + 0.01, lp['NV'] + 0.01]}
xy, NL, KL, BL, LVUC, LV, UC, lattice_exten = \
generate_triangular_lattice(shape, lp['NH'] * 3, lp['NV'] * 3, lp['eta'], lp['theta'], check=lp['check'])
PVx = []
PVy = []
PVxydict = {}
BBox = blf.auto_polygon(shape_keep, 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_accordionkag_isocent(lp):
"""Create an accordion-bonded kagomized amorphous network from a loaded jammed point set.
Parameters
----------
lp
Returns
-------
"""
shape = lp['shape']
check = lp['check']
NH = lp['NH']
NV = lp['NV']
print('Loading isostatic to build kagome-decorated lattice...')
import lepm.build.build_jammed as build_jammed
use_hexner = (lp['source'] == 'hexner')
if use_hexner:
# Use Daniel Hexner's lattices
points, BL, LLv, numberstr, sizestr, lp = build_jammed.load_hexner_jammed(
lp, BL_load=False)
LL = (LLv, LLv)
else:
number = '{0:03d}'.format(int(lp['loadlattice_number']))
zindex = '{0:03d}'.format(int(lp['loadlattice_z']))
points = np.loadtxt(lp['rootdir'] + 'networks/' +
'isostatic_source/isostatic_homog_z' + zindex +
'_conf' + number + '_nodes.txt')
# LL = NH
points -= np.mean(points, axis=0)
# Separate procedure if not using entire lattice
if lp['NP_load'] == 0:
# Do initial (generous) cropping if not using entire lattice
if check:
plt.plot(points[:, 0], points[:, 1], 'b.')
plt.title('Point set before initial cutting')
plt.show()
xytmp, trash1, trash2, trash3 = blf.mask_with_polygon(shape,
NH * 1.2 + 8,
NV * 1.2 + 8,
points, [],
eps=0.)
polygon = blf.auto_polygon(shape, NH, NV, eps=0.00)
if check:
plt.plot(xytmp[:, 0], xytmp[:, 1], 'b.')
plt.title('Point set after initial cutting')
plt.show()
xy, NL, KL, BL = le.delaunay_centroid_lattice_from_pts(
xytmp, polygon=polygon, trimbound=False, check=lp['check'])
#################################################################
# nzag controlled by lp['intparam'] below
xyacc, BLacc, LVUC, UC, xyvertices, lattice_exten_add = \
blf.accordionize_network(xy, BL, lp, PVxydict=None, PVx=None, PVy=None, PV=None)
print 'BL = ', BL
# need indices of xy that correspond to xyvertices
# note that xyvertices gives the positions of the vertices, not their indices
inRx = np.in1d(xyacc[:, 0], xyvertices[:, 0])
inRy = np.in1d(xyacc[:, 1], xyvertices[:, 1])
vxind = np.where(np.logical_and(inRx, inRy))[0]
print 'vxind = ', vxind
# Note: beware, do not provide NL and KL to decorate_bondneighbors_elements() since NL,KL need
# to be recalculated
xy, BL = blf.decorate_bondneighbors_elements(xyacc,
BLacc,
vxind,
PVxydict=None,
viewmethod=False,
check=lp['check'])
NL, KL = le.BL2NLandKL(BL, NP=len(xy))
#################################################################
LL = (np.max(xy[:, 0]) - np.min(xy[:, 0]),
np.max(xy[:, 1]) - np.min(xy[:, 1]))
PVxydict = {}
PVx = []
PVy = []
periodicBCstr = ''
else:
polygon = 0.5 * np.array([[-LL[0], -LL[1]], [LL[0], -LL[1]],
[LL[0], LL[1]], [-LL[0], LL[1]]])
xy, NL, KL, BL, PVxydict = blf.kagomecentroid_periodic_network_from_pts(
points, LL, BBox='auto', check=lp['check'])
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
periodicBCstr = '_periodic'
# 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())
lattice_exten = 'accordionkag_isocent_' + shape + periodicBCstr + '_d{0:02d}'.format(int(lp['conf'])) + \
lattice_exten_add
if use_hexner:
lattice_exten = 'accordionkag_isocent_' + shape + periodicBCstr + '_hexner_size' + sizestr + '_conf' + \
numberstr + lattice_exten_add
else:
lattice_exten = 'accordionkag_isocent_' + shape + periodicBCstr + '_ulrich_homog_zindex' + zindex + \
lattice_exten_add
LV = 'none'
LVUC = 'none'
UC = 'none'
BBox = polygon
return xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten
def build_iscentroid(lp):
"""Build centroidal (honeycomb-like) network from isostatic point set generated by Daniel Hexner.
"""
NH = lp['NH']
NV = lp['NV']
# First check that if periodic, NP_load is defined as nonzero
if lp['periodicBC']:
if lp['NP_load'] == 0:
RuntimeError(
'For iscentroid lattices, if periodicBC, then must specify NP_load instead of NH, NV.'
)
use_hexner = (lp['source'] == 'hexner')
if use_hexner:
# Use Daniel Hexner's lattices
points, BL, LLv, numberstr, sizestr, lp = build_jammed.load_hexner_jammed(
lp, BL_load=False)
LL = (LLv, LLv)
else:
# Use Stephan Ulrich's lattices
if lp['periodicBC']:
RuntimeError('Not sure if Stephan Ulrich lattices are periodic!')
number = '{0:03d}'.format(int(lp['loadlattice_number']))
zindex = '{0:03d}'.format(int(lp['loadlattice_z']))
points = np.loadtxt(lp['rootdir'] + 'networks/' +
'isostatic_source/isostatic_homog_z' + zindex +
'_conf' + number + '_nodes.txt')
LL = (NH, NV)
points -= np.mean(points, axis=0)
# Do initial (generous) cropping if not using entire lattice
if lp['NP_load'] == 0:
if lp['check']:
plt.plot(points[:, 0], points[:, 1], 'b.')
plt.title('Point set before initial cutting')
plt.show()
xytmp, trash1, trash2, trash3 = \
blf.mask_with_polygon(lp['shape'], NH * 2. + 5, NV * 2. + 5, points, [], eps=0.00)
polygon = blf.auto_polygon(lp['shape'], NH, NV, eps=0.00)
if lp['check']:
plt.plot(xytmp[:, 0], xytmp[:, 1], 'b.')
plt.title('Point set after initial cutting')
plt.show()
xy, NL, KL, BL = le.delaunay_centroid_lattice_from_pts(
xytmp, polygon=polygon, trimbound=False, check=lp['check'])
LL = (np.max(xy[:, 0]) - np.min(xy[:, 0]),
np.max(xy[:, 1]) - np.min(xy[:, 1]))
PVxydict = {}
PVx = []
PVy = []
periodicBCstr = ''
else:
polygon = 0.5 * np.array([[-LL[0], -LL[1]], [LL[0], -LL[1]],
[LL[0], LL[1]], [-LL[0], LL[1]]])
xy, NL, KL, BL, PVxydict = le.delaunay_centroid_rect_periodic_network_from_pts(
points, LL, BBox='auto', check=lp['check'])
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
periodicBCstr = '_periodic'
if lp['check']:
plt.plot(xy[:, 0], xy[:, 1], 'b.')
plt.title('Point set after decoration and cropping')
plt.show()
# 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['NP_load'] != 0:
PVx *= scale
PVy *= scale
PVxydict.update((key, val * scale) for key, val in PVxydict.items())
if use_hexner:
lattice_exten = 'iscentroid_' + lp[
'shape'] + periodicBCstr + '_hexner_size' + sizestr + '_conf' + numberstr
else:
lattice_exten = 'iscentroid_' + lp[
'shape'] + periodicBCstr + '_homog_zindex' + zindex + '_conf' + number[
1:]
BBox = polygon
LV = 'none'
LVUC = 'none'
UC = 'none'
return xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, lattice_exten
def build_kagome_isocent(lp):
"""
Parameters
----------
lp
Returns
-------
"""
shape = lp['shape']
check = lp['check']
NH = lp['NH']
NV = lp['NV']
print('Loading isostatic to build kagome-decorated lattice...')
import lepm.build.build_jammed as build_jammed
use_hexner = (lp['source'] == 'hexner')
if use_hexner:
# Use Daniel Hexner's lattices
points, BL, LLv, numberstr, sizestr, lp = build_jammed.load_hexner_jammed(
lp, BL_load=False)
LL = (LLv, LLv)
else:
number = '{0:03d}'.format(int(lp['loadlattice_number']))
zindex = '{0:03d}'.format(int(lp['loadlattice_z']))
points = np.loadtxt(lp['rootdir'] + 'networks/' +
'isostatic_source/isostatic_homog_z' + zindex +
'_conf' + number + '_nodes.txt')
# LL = NH
points -= np.mean(points, axis=0)
# Separate procedure if not using entire lattice
if lp['NP_load'] == 0:
# Do initial (generous) cropping if not using entire lattice
if check:
plt.plot(points[:, 0], points[:, 1], 'b.')
plt.title('Point set before initial cutting')
plt.show()
xytmp, trash1, trash2, trash3 = blf.mask_with_polygon(shape,
NH * 1.2 + 8,
NV * 1.2 + 8,
points, [],
eps=0.)
polygon = blf.auto_polygon(shape, NH, NV, eps=0.00)
if check:
plt.plot(xytmp[:, 0], xytmp[:, 1], 'b.')
plt.title('Point set after initial cutting')
plt.show()
xy, NL, KL, BL = blf.kagomecentroid_lattice_from_pts(xytmp,
polygon=polygon,
trimbound=False,
thres=2.0,
check=lp['check'])
LL = (np.max(xy[:, 0]) - np.min(xy[:, 0]),
np.max(xy[:, 1]) - np.min(xy[:, 1]))
PVxydict = {}
PVx = []
PVy = []
periodicBCstr = ''
else:
polygon = 0.5 * np.array([[-LL[0], -LL[1]], [LL[0], -LL[1]],
[LL[0], LL[1]], [-LL[0], LL[1]]])
xy, NL, KL, BL, PVxydict = blf.kagomecentroid_periodic_network_from_pts(
points, LL, BBox='auto', check=lp['check'])
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
periodicBCstr = '_periodic'
if check:
plt.plot(xy[:, 0], xy[:, 1], 'b.')
plt.title('Point set after decoration and cropping')
plt.show()
# 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['NP_load'] != 0:
PVx *= scale
PVy *= scale
PVxydict.update((key, val * scale) for key, val in PVxydict.items())
if use_hexner:
lattice_exten = 'kagome_isocent_' + shape + periodicBCstr + '_hexner_size' + sizestr + '_conf' + numberstr
else:
lattice_exten = 'kagome_isocent_' + shape + periodicBCstr + '_ulrich_homog_zindex' + zindex +\
'_conf' + number[1:]
BBox = polygon
LV = 'none'
UC = 'none'
LVUC = 'none'
return xy, NL, KL, BL, PVx, PVy, PVxydict, LVUC, BBox, LL, LV, UC, 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_huvoronoi(lp):
if lp['NP_load'] == 0:
points = np.loadtxt(
lp['rootdir'] +
'networks/hyperuniform_source/hyperuniform_N400/out_d' +
str(int(lp['conf'])) + '_xy.txt')
points -= np.mean(points, axis=0) + lp['origin']
keep = np.logical_and(
abs(points[:, 0]) < (8 + lp['NH'] * 0.5),
abs(points[:, 1]) < (8 + lp['NV'] * 0.5))
xytmp = points[keep]
if lp['check']:
plt.plot(points[:, 0], points[:, 1], 'b.')
plt.title('Point set before initial cutting')
plt.show()
polygon = blf.auto_polygon(lp['shape'], lp['NH'], lp['NV'], eps=0.00)
xy, NL, KL, BL = le.voronoi_lattice_from_pts(xytmp,
polygon=polygon,
NN=3,
kill_outliers=True,
check=lp['check'])
if lp['check']:
le.display_lattice_2D(
xy,
BL,
NL=NL,
KL=KL,
title='Cropped centroid lattice, before dilation')
# Form output bounding box and extent measurement
LL = (np.max(xy[:, 0]) - np.min(xy[:, 0]),
np.max(xy[:, 1]) - np.min(xy[:, 1]))
PVxydict = {}
PVx = []
PVy = []
BBox = polygon
# 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 = ''
else:
lp['periodicBC'] = True
sizestr = '{0:03d}'.format(lp['NP_load'])
print 'sizestr = ', sizestr
points = np.loadtxt(lp['rootdir'] +
'networks/hyperuniform_source/hyperuniform_N' +
sizestr + '/out_d' + str(int(lp['conf'])) +
'_xy.txt')
print 'points = ', points
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.voronoi_rect_periodic_from_pts(
points, LL, BBox='auto', check=lp['check'])
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
originstr = ''
periodicstr = '_periodic'
# 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
BBox *= scale
LL = (LL[0] * scale, LL[1] * scale)
if lp['NP_load'] != 0:
PVx *= scale
PVy *= scale
PVxydict.update((key, val * scale) for key, val in PVxydict.items())
lattice_exten = 'huvoronoi_' + lp[
'shape'] + periodicstr + '_d' + '{0:02d}'.format(int(
lp['conf'])) + originstr
return xy, NL, KL, BL, PVx, PVy, PVxydict, LL, BBox, lattice_exten
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 build_kagome_huvor(lp):
"""Construct a kagomized network from hyperuniform point set and voronoize it with Wigner-Seitz
Parameters
----------
lp : dict
Lattice parameters dictionary, with keys:
rootdir, conf, origin, shape, NH, NV, check, NP_load (if periodic)
"""
if lp['NP_load'] == 0:
points = np.loadtxt(
dio.prepdir(lp['rootdir']) +
'networks/hyperuniform_source/hyperuniform_N400/out_d' +
str(int(lp['conf'])) + '_xy.txt')
points -= np.mean(points, axis=0) + lp['origin']
addpc = .05
xytmp, trash1, trash2, trash3 = \
blf.mask_with_polygon(lp['shape'], lp['NH'] + 7, lp['NV'] + 7, points, [], eps=addpc)
polygon = blf.auto_polygon(lp['shape'], lp['NH'], lp['NV'], eps=0.00)
xy, NL, KL, BL = blf.kagomevoronoi_network_from_pts(xytmp,
polygon=polygon,
kill_outliers=True,
check=lp['check'])
LL = (np.max(xy[:, 0]) - np.min(xy[:, 0]),
np.max(xy[:, 1]) - np.min(xy[:, 1]))
PVxydict, PVx, PVy = {}, [], []
BBox = polygon
if lp['check']:
le.display_lattice_2D(
xy,
BL,
NL=NL,
KL=KL,
title='Cropped centroid lattice, before dilation')
# 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')
periodicBCstr = ''
else:
# 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
lp['periodicBC'] = True
sizestr = '{0:03d}'.format(lp['NP_load'])
points = np.loadtxt(
dio.prepdir(lp['rootdir']) +
'networks/hyperuniform_source/hyperuniform_N' + sizestr +
'/out_d' + str(int(lp['conf'])) + '_xy.txt')
points -= np.mean(points, axis=0)
xy, NL, KL, BL, PVxydict = blf.kagomevoronoi_periodic_network_from_pts(
points, LL, BBox=BBox, check=lp['check'])
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
originstr = ''
periodicBCstr = '_periodic'
# 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
BBox *= 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())
lattice_exten = 'kagome_huvor_' + lp[
'shape'] + periodicBCstr + '_d{0:02d}'.format(int(
lp['conf'])) + originstr
return xy, NL, KL, BL, PVx, PVy, PVxydict, LL, BBox, lattice_exten
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
def build_accordionkag_hucent(lp):
"""Create an accordion-bonded kagomized amorphous network from a loaded hyperuniform point set.
Parameters
----------
lp
Returns
-------
"""
print('Loading hyperuniform to build lattice...')
networkdir = lp['rootdir'] + 'networks/'
shape = lp['shape']
NH = lp['NH']
NV = lp['NV']
check = lp['check']
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']
addpc = .05
xytmp, trash1, trash2, trash3 = blf.mask_with_polygon(shape,
NH + 4,
NV + 4,
points, [],
eps=addpc)
polygon = blf.auto_polygon(shape, NH, NV, eps=0.00)
xy, NL, KL, BL = le.delaunay_centroid_lattice_from_pts(
xytmp, polygon=polygon, trimbound=False) # check=check)
#################################################################
# nzag controlled by lp['intparam'] below
xyacc, BLacc, LVUC, UC, xyvertices, lattice_exten_add = \
blf.accordionize_network(xy, BL, lp, PVxydict=None, PVx=None, PVy=None, PV=None)
print 'BL = ', BL
# need indices of xy that correspond to xyvertices
# note that xyvertices gives the positions of the vertices, not their indices
inRx = np.in1d(xyacc[:, 0], xyvertices[:, 0])
inRy = np.in1d(xyacc[:, 1], xyvertices[:, 1])
vxind = np.where(np.logical_and(inRx, inRy))[0]
print 'vxind = ', vxind
# Note: beware, do not provide NL and KL to decorate_bondneighbors_elements() since NL,KL need
# to be recalculated
xy, BL = blf.decorate_bondneighbors_elements(xyacc,
BLacc,
vxind,
PVxydict=None,
viewmethod=False,
check=lp['check'])
NL, KL = le.BL2NLandKL(BL, NP=len(xy))
#################################################################
polygon = blf.auto_polygon(shape, NH, NV, eps=0.00)
if check:
le.display_lattice_2D(
xy,
BL,
NL=NL,
KL=KL,
title='Cropped centroid lattice, before dilation')
# Form output bounding box and extent measurement
LL = (np.max(xy[:, 0]) - np.min(xy[:, 0]),
np.max(xy[:, 1]) - np.min(xy[:, 1]))
PVxydict = {}
PVx = []
PVy = []
BBox = polygon
# 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')
periodicBCstr = ''
else:
# 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
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)
xy, NL, KL, BL, PVxydict = blf.kagomecentroid_periodic_network_from_pts(
points, LL, BBox=BBox, check=lp['check'])
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
originstr = ''
periodicBCstr = '_periodic'
# 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
BBox *= 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())
lattice_exten = 'accordionkag_hucent_' + shape + periodicBCstr + '_d{0:02d}'.format(int(lp['conf'])) + originstr + \
lattice_exten_add
LV = 'none'
LVUC = 'none'
UC = 'none'
return xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten
def build_kagome_hucent(lp):
print('Loading hyperuniform to build lattice...')
networkdir = lp['rootdir'] + 'networks/'
shape = lp['shape']
NH = lp['NH']
NV = lp['NV']
check = lp['check']
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']
addpc = .05
xytmp, trash1, trash2, trash3 = blf.mask_with_polygon(shape,
NH + 4,
NV + 4,
points, [],
eps=addpc)
polygon = blf.auto_polygon(shape, NH, NV, eps=0.00)
xy, NL, KL, BL = blf.kagomecentroid_lattice_from_pts(xytmp,
polygon=polygon,
trimbound=False,
check=check)
polygon = blf.auto_polygon(shape, NH, NV, eps=0.00)
if check:
le.display_lattice_2D(
xy,
BL,
NL=NL,
KL=KL,
title='Cropped centroid lattice, before dilation')
# Form output bounding box and extent measurement
LL = (np.max(xy[:, 0]) - np.min(xy[:, 0]),
np.max(xy[:, 1]) - np.min(xy[:, 1]))
PVxydict = {}
PVx = []
PVy = []
BBox = polygon
# 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')
periodicBCstr = ''
else:
# 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
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)
xy, NL, KL, BL, PVxydict = blf.kagomecentroid_periodic_network_from_pts(
points, LL, BBox=BBox, check=lp['check'])
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
originstr = ''
periodicBCstr = '_periodic'
# 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
BBox *= 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())
lattice_exten = 'kagome_hucent_' + shape + periodicBCstr + '_d{0:02d}'.format(
int(lp['conf'])) + originstr
LV = 'none'
LVUC = 'none'
UC = 'none'
return xy, NL, KL, BL, PVxydict, PVx, PVy, LL, LVUC, LV, UC, BBox, lattice_exten
def build_hucentroid(lp):
"""Load the proper hyperuniform point set, given the parameters in dict lp
Parameters
----------
lp : dict
lattice parameters dictionary
Returns
-------
xy, NL, KL, BL, PVxydict, PVx, PVy, LVUC, BBox, LL, LV, UC, lattice_exten
"""
check = lp['check']
networkdir = lp['rootdir'] + 'networks/'
print('Loading hyperuniform to build lattice...')
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']
addpc = .05
# Note: below we crop a large region so that if the network has shape==circle, we dont cut off the sides
if lp['shape'] == 'circle':
keep = np.logical_and(
abs(points[:, 0]) < (10 + lp['NH'] * (1 + addpc)),
abs(points[:, 1]) < (10 + lp['NV'] * (1 + addpc)))
else:
# it will speed things up to crop more, so do so if the shape is not a circle
keep = np.logical_and(
abs(points[:, 0]) < (5 + lp['NH'] * (1 + addpc) * 0.5),
abs(points[:, 1]) < (5 + lp['NV'] * (1 + addpc)) * 0.5)
xytmp = points[keep]
if check:
plt.plot(points[:, 0], points[:, 1], 'b.')
plt.title('Point set before initial cutting')
plt.show()
polygon = blf.auto_polygon(lp['shape'], lp['NH'], lp['NV'], eps=0.00)
xy, NL, KL, BL = le.delaunay_centroid_lattice_from_pts(xytmp,
polygon=polygon,
trimbound=False,
check=check)
if check:
le.display_lattice_2D(
xy,
BL,
NL=NL,
KL=KL,
title='Cropped centroid lattice, before dilation')
# Form output bounding box and extent measurement
LL = (np.max(xy[:, 0]) - np.min(xy[:, 0]),
np.max(xy[:, 1]) - np.min(xy[:, 1]))
PVxydict = {}
PVx = []
PVy = []
BBox = polygon
# 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 = ''
stripstr = ''
else:
if lp['periodic_strip']:
lp['periodicBC'] = True
sizestr = '{0:03d}'.format(lp['NP_load'])
print 'sizestr = ', sizestr
points = np.loadtxt(networkdir +
'hyperuniform_source/hyperuniform_N' +
sizestr + '/out_d' + str(int(lp['conf'])) +
'_xy.txt')
print 'points = ', points
points -= 0.5 * np.array([lp['NH'], lp['NV']])
# Ensuring that origin param is centered (since using entire lattice)
lp['origin'] = np.array([0.0, 0.0])
if lp['NH'] != lp['NP_load']:
raise RuntimeError(
'NP_load should be equal to NH for a periodicstrip geometry!'
)
LL = (lp['NH'], lp['NV'])
polygon = 0.5 * np.array([[-LL[0], -LL[1]], [LL[0], -LL[1]],
[LL[0], LL[1]], [-LL[0], LL[1]]])
BBox = polygon
keep = dh.inds_in_polygon(points, polygon)
points = points[keep]
xy, NL, KL, BL, PVxydict = le.delaunay_centroid_periodicstrip_from_pts(
points, LL, BBox='auto', check=check)
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
originstr = ''
periodicstr = '_periodicstrip'
stripstr = '_NH{0:06d}'.format(lp['NH']) + '_NV{0:06d}'.format(
lp['NV'])
else:
lp['periodicBC'] = True
sizestr = '{0:03d}'.format(lp['NP_load'])
print 'sizestr = ', sizestr
points = np.loadtxt(networkdir +
'hyperuniform_source/hyperuniform_N' +
sizestr + '/out_d' + str(int(lp['conf'])) +
'_xy.txt')
print 'points = ', points
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_centroid_rect_periodic_network_from_pts(
points, LL, BBox='auto', check=check)
PVx, PVy = le.PVxydict2PVxPVy(PVxydict, NL)
originstr = ''
periodicstr = '_periodic'
stripstr = ''
# 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
BBox *= scale
LL = (LL[0] * scale, LL[1] * scale)
if lp['NP_load'] != 0:
PVx *= scale
PVy *= scale
PVxydict.update((key, val * scale) for key, val in PVxydict.items())
lattice_exten = 'hucentroid_' + lp['shape'] + periodicstr + '_d' +\
'{0:02d}'.format(int(lp['conf'])) + stripstr + originstr
LVUC = 'none'
LV = 'none'
UC = 'none'
return xy, NL, KL, BL, PVxydict, PVx, PVy, LVUC, BBox, LL, LV, UC, lattice_exten