crystalbuilder 0.5.4__py2.py3-none-any.whl

crystalbuilder/utils.py

@@ -0,0 +1,22 @@
+from crystalbuilder import convert
+from crystalbuilder import lattice
+from crystalbuilder import vectors
+from crystalbuilder import bilbao
+import numpy as np
+
+def MonkhorstPack(size):
+    """
+    This is a direct copy of the Monkhorst-Pack k-space sampling method in ase (https://iopscience.iop.org/article/10.1088/1361-648X/aa680e)
+    
+    This way there's no need to import ase. 
+
+    Parameters
+    ----------
+    size : ndarray
+        number of points (kx, ky, kz) to sample reciprocal space. This should only be used in MPB, as it performs the necessary multiplication by the reciprocal lattice vectors 
+
+    """
+    if np.less_equal(size, 0).any():
+        raise ValueError(f'Illegal size: {list(size)}')
+    kpts = np.indices(size).transpose((1, 2, 3, 0)).reshape((-1, 3))
+    return (kpts + 0.5) / size - 0.5

crystalbuilder/vectors.py

@@ -0,0 +1,279 @@
+import numpy as np
+from matplotlib import pyplot as plt
+
+debug = 'off'
+
+rounder = 50 #sets decimal rounding
+#Needs Done
+
+
+def flatten(list):
+    flat_list = [item for sublist in list for item in sublist]
+    return flat_list
+
+def angle_check(theta, unit):
+    if unit == 'degrees' or 'deg' or 'd' or 'degree':
+        radthet = np.radians(theta)
+    elif unit == 'radians' or 'rad' or 'r' or 'radian':    
+        radthet = theta
+    else:
+        print("Error: Units must be 'degrees' or 'radians'")
+    return radthet
+
+def shift(point, shift_vector):
+    """
+    TO DO
+
+    shift point by the shift vector
+    """
+    point_arr = np.asarray(point)
+    shiftvec = np.asarray(shift_vector)
+    shiftedpoint = point_arr.reshape(3,) + shiftvec.reshape(3,)
+    return shiftedpoint
+
+def get_shift_vector(point, newpoint):
+    point_arr = np.asarray(point)
+    newpoint = np.asarray(newpoint)
+    shiftvec = newpoint.reshape(3,) - point_arr.reshape(3,)
+    return shiftvec
+
+def shift_angle(point, theta, distance, unit='degrees'):
+    """
+    Shifts in x-y plane a distance at angle theta
+    """
+    point_arr = np.asarray(point)
+    shiftvec = rotate([[distance, 0, 0]], theta, axis=2, unit=unit)
+    print(shiftvec.T)
+    print(point_arr)
+    shiftedpoint = point_arr.reshape(3,) + shiftvec.reshape(3,)
+    return shiftedpoint
+
+def rotate(point, theta, relative_point=(0,0,0), axis=2, unit='degrees', toarray=True):
+    """
+    rotates counterclockwise a point or list of points about relative_point by theta in
+    This does a 2D rotation only, so string a few together to rotate in more than one axis
+
+    Parameters:
+        point (list of array_like)
+        theta (float)
+        relative_point (array_like)
+        axis (0,1,2)
+        unit (str): 'degrees' or 'radians'
+
+    Returns:
+        List of coordinate lists (3-list)
+
+    """
+
+    radthet = angle_check(theta, unit)
+
+
+    coordinatelist = []
+    
+
+    for coord in point:
+
+        if axis==2:
+            newcoord = rotatez(coord, radthet, relative_point)
+            
+        elif axis ==1:
+            newcoord = rotatey(coord, radthet, relative_point)
+            
+        elif axis ==0:
+            newcoord = rotatex(coord, radthet, relative_point)
+            
+        else:
+            print("Error: Check Axis Direction")
+        
+        newcoord = newcoord.reshape(3,).tolist()
+        coordinatelist.append(newcoord)
+        if toarray==False: 
+            new_coordinates=coordinatelist
+        else:
+            new_coordinates=np.asarray(coordinatelist)
+        
+        if debug == 'on':
+            print('coordinates=\n', new_coordinates)
+            print('type= ', type(new_coordinates))
+            print('data type= ', type(new_coordinates[0][0]))
+
+
+    return new_coordinates
+
+def rotatex(point, theta, relative_point):
+    """
+    rotates counterclockwise a point in x by theta radians about relative_point
+    """
+    x = point[0]
+    y = point[1]
+    z = point[2]
+
+    relx = relative_point[0]
+    rely = relative_point[1]
+    relz = relative_point[2]
+
+    tmat = np.array([
+                    [1,0,0,0],
+                    [0, 1, 0, 0],
+                    [0,0,1,0],
+                    [relx, rely, relz,1]])
+    
+    tnmat = np.array([
+                    [1,0,0,0],
+                    [0,1,0,0],
+                    [0,0,1,0],
+                    [-relx, -rely, -relz, 1]])
+
+    rxmat = np.array([
+                    [1, 0, 0, 0],
+                    [0, np.cos(theta), -np.sin(theta), 0], 
+                    [0, np.sin(theta), np.cos(theta), 0],
+                    [0,0,0,1]
+                    ]).round(rounder)
+    if debug=='on':
+        print("rxmat", '= ', rxmat)
+
+    rt1mat = np.matmul(rxmat,tnmat)
+    if debug=='on':
+        print("rt1mat", '= ', rt1mat)
+
+    rt2mat = np.matmul(tmat,rt1mat)
+    if debug=='on':
+        print("rt2mat", '= ', rt2mat)
+    
+    rotation = np.matmul(rt2mat, np.array([[x],[y],[z],[1]]))
+    return rotation[:3]
+
+def rotatey(point, theta, relative_point):
+    """
+    rotates counterclockwise a point in y by theta radians about relative_point
+    """
+    x = point[0]
+    y = point[1]
+    z = point[2]
+
+    relx = relative_point[0]
+    rely = relative_point[1]
+    relz = relative_point[2]
+
+    tmat = np.array([
+                    [1,0,0,0],
+                    [0, 1, 0, 0],
+                    [0,0,1,0],
+                    [relx, rely, relz,1]])
+    
+    tnmat = np.array([
+                    [1,0,0,0],
+                    [0,1,0,0],
+                    [0,0,1,0],
+                    [-relx, -rely, -relz, 1]])
+
+    rymat = np.array([
+                    [np.cos(theta), 0, np.sin(theta), 0],
+                    [0, 1, 0, 0], 
+                    [-np.sin(theta), 0, np.cos(theta), 0],
+                    [0,0,0,1]
+                    ]).round(rounder)
+    if debug=='on':
+        print("rymat", '= ', rymat)
+
+    rt1mat = np.matmul(rymat,tnmat)
+    if debug=='on':
+        print("rt1mat", '= ', rt1mat)
+
+    rt2mat = np.matmul(tmat,rt1mat)
+    if debug=='on':
+        print("rt2mat", '= ', rt2mat)
+    
+    rotation = np.matmul(rt2mat, np.array([[x],[y],[z],[1]]))
+    return rotation[:3]
+
+def rotatez(point, theta, relative_point):
+    """
+    rotates counterclockwise a point in z by theta radians about relative_point
+    """
+    x = point[0]
+    y = point[1]
+    z = point[2]
+
+    relx = relative_point[0]
+    rely = relative_point[1]
+    relz = relative_point[2]
+
+    tmat = np.array([
+                    [1,0,0,relx],
+                    [0,1,0,rely],
+                    [0,0,1,relz],
+                    [0,0,0,1]])
+    
+    
+    tnmat = np.array([
+                    [1,0,0,-relx],
+                    [0,1,0,-rely],
+                    [0,0,1,-relz],
+                    [0,0,0,1]])
+
+    rzmat = np.array([
+                    [np.cos(theta), -np.sin(theta),0 , 0],
+                    [np.sin(theta), np.cos(theta), 0, 0], 
+                    [0, 0, 1, 0],
+                    [0,0,0,1]
+                    ]).round(rounder)
+    if debug=='on':
+        print("translation matrix = \n", tmat)
+        print("negative translation matrix = \n", tnmat)
+        print("rzmat", '=\n', rzmat)
+        
+
+    rt1mat = np.matmul(rzmat,tnmat)
+    if debug=='on':
+        print("rt1mat", '=\n', rt1mat)
+
+    rt2mat = np.matmul(tmat,rt1mat)
+    if debug=='on':
+        print("rt2mat", '=\n', rt2mat)
+    
+    rotation = np.matmul(rt2mat, np.array([[x],[y],[z],[1]]))
+    return rotation[:3]
+
+def basis_change(basis1, basis2, point_in_basis1):
+    """
+    makes column vectors from basis1 and basis2, then determines the change-of-basis matrix. Applies this to specified point and returns the coordinate in the other basis.
+
+    Both bases need to be defined in cartesian basis, but the output will be in terms of basis2
+
+
+    Parameters
+    ----------
+    basis1: basis in 3x3 list or array, or 'cartesian'
+    basis2: basis in 3x3 list or array, or 'cartesian'
+    point_in_basis1: 3-list point specified in units of basis 1
+
+    """
+    cartbasis = [[1,0,0], [0,1,0], [0,0,1]]
+    try: 
+        if basis1 == 'cartesian': basis1=cartbasis
+    except ValueError:
+        pass
+    
+    try: 
+        if basis2 == 'cartesian': basis2=cartbasis
+    except ValueError:
+        pass
+    
+    
+    bas1_arr = np.transpose(np.asarray(basis1))
+    bas2_arr = np.transpose(np.asarray(basis2))
+    point_arr = np.asarray(point_in_basis1).reshape(3,1)
+
+    newpoint = np.matmul(bas1_arr, point_arr)
+    outpoint = np.matmul(bas2_arr, newpoint)
+    return outpoint.reshape(3,)
+
+def cart_to_pol(point):
+    x = point[0]
+    y = point[1]
+    z = point[2]
+    r = np.sqrt((x**2 + y**2))
+    theta = np.arctan2(y, x)+np.pi
+    return [r, theta, z]

crystalbuilder/viewer.py

@@ -0,0 +1,82 @@
+import vedo
+import crystalbuilder
+import crystalbuilder.geometry as geo
+
+vedo.settings.default_backend='vtk'
+
+
+
+def add_to_visualizer(structures, plot, **kwargs):
+    for object in structures:       
+        if isinstance(object, geo.Cylinder):
+            plot += visualize_cylinder(object, **kwargs)
+        elif isinstance(object, geo.Sphere):
+            plot += visualize_sphere(object, **kwargs)
+        elif isinstance(object, geo.SuperCell):
+            plot += visualize_supercell(object, **kwargs)
+
+
+def visualize(structures, plotter_style=9, **kwargs):
+    """
+    
+    Parameters
+    -----------
+    structures : list of geo
+
+    """
+    
+    plot = vedo.Plotter(axes=plotter_style)
+
+    add_to_visualizer(structures, plot)
+    
+    # for object in structures:
+    #     if isinstance(object, geo.Structure):
+    #         if isinstance(object, geo.Cylinder):
+    #             obj  = visualize_cylinder(object, **kwargs)
+    #             plot += obj
+    #         elif isinstance(object, geo.SuperCell):
+    #             obj  = visualize_supercell(object, **kwargs)
+    #             plot += obj
+    #         elif isinstance(object, geo.Sphere):
+    #             obj = visualize_sphere(object, **kwargs)
+    #             plot += obj
+    #     elif isinstance(object, list):
+    #         for n in object:
+                
+            
+    return plot
+
+def visualize_cylinder(cylinder, **kwargs):
+    center = cylinder.center
+    radius = cylinder.radius
+    height = cylinder.height
+    axis = cylinder.axis
+    name = str(cylinder.center)
+    obj = vedo.Cylinder(pos=center, r=radius, height=height, axis=axis, **kwargs).legend(name)
+    obj.name = name
+    return obj
+
+def visualize_sphere(sphere, **kwargs):
+    center = sphere.center
+    radius = sphere.radius
+    name = str(sphere.center)
+    obj = vedo.Sphere(pos=center, r=radius, **kwargs).legend(name)
+    obj.name = name
+    return obj
+
+def visualize_supercell(SuperCell, **kwargs):
+    objects = []
+    for structure in SuperCell:
+        if isinstance(structure, geo.Cylinder):
+            objects.append(visualize_cylinder(structure, **kwargs))
+        elif isinstance(structure, geo.Sphere):
+            objects.append(visualize_sphere(structure, **kwargs))
+    return objects
+
+
+
+
+if __name__ == "__main__":
+    cylinder1 = geo.Cylinder(center=(0,0,0), radius=1, height=3, axis=2)
+    cylinder2 = geo.Cylinder(center=(5,5,0), radius=2, height=6, axis=1)
+    visualize([cylinder1, cylinder2])

crystalbuilder-0.5.4.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: crystalbuilder
+Version: 0.5.4
+Summary: A package for building 3D photonic crystals
+Author: Brandon Hacha
+License-File: LICENSE
+Requires-Dist: beautifulsoup4
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: vedo
+Provides-Extra: full
+Requires-Dist: tidy3d; extra == 'full'

crystalbuilder-0.5.4.dist-info/RECORD

@@ -0,0 +1,14 @@
+crystalbuilder/__init__.py,sha256=_Jc_rgu9WcSSuOs_uZw2NIFojARRBSU_EA59DY9vCzw,1368
+crystalbuilder/bilbao.py,sha256=660d06o8I3NAqTSLHrOK7kTf-Lnr1rKhp2smw_giafA,10994
+crystalbuilder/convert.py,sha256=2f8EcLg0SAyObjcdhL6m-j1N8qBLy_XIo-3MugLGYnM,12691
+crystalbuilder/geometry.py,sha256=CPioM1OTVQUutJoX_XpVa3kYOXhJ9B3N4Vbmfjs5M1c,24647
+crystalbuilder/lattice.py,sha256=1y8U9iJKbYIqTeX4qVR2k8E2lAjsbyx1zUz4ATswU7A,33555
+crystalbuilder/utils.py,sha256=INkhGf8Jat_YH1K3TghL6mw5cS__CVILQgdo7u9g_SY,818
+crystalbuilder/vectors.py,sha256=uf5StYewaQsY9R1hrtZtzg-5MkeN0DR7VPen2Tux_TU,7686
+crystalbuilder/viewer.py,sha256=r37owd9kPre32D2zvIQUqImgySbR0CiuMFfdRfuDYVY,2474
+crystalbuilder/conversions/lumc.py,sha256=WFJbt8Dgy5myWlIzdciHNMpmpeEV3TvmqB6SSvFZ3nw,1327
+crystalbuilder/conversions/t3d.py,sha256=9QzRImME7muk7kG43Nnu7XUpjJi9um0zwWllKbBQM-s,6627
+crystalbuilder-0.5.4.dist-info/METADATA,sha256=e1N8-PHxYERJpcdlnFEoNDFJdRmRyBm_96gdC2bNl40,312
+crystalbuilder-0.5.4.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+crystalbuilder-0.5.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+crystalbuilder-0.5.4.dist-info/RECORD,,

crystalbuilder-0.5.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any