crystalbuilder 0.5.4__py2.py3-none-any.whl

crystalbuilder/__init__.py

@@ -0,0 +1,27 @@
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("crystalbuilder")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+__all__ = ["convert", "geometry", "lattice", "vectors","bilbao", "viewer", "conversions", "conversions"]
+
+
+
+
+"""
+CrystalBuilder allows building triangle and cylinder based photonic crystal lattices for MEEP, MPB, and Tidy3D.
+
+convert.py: methods for converting CrystalBuilder objects to MEEP/MPB/Tidy3D geometries
+
+geometry.py: geometry classes. These are not actually "meshed" structures, but vertices/centers as required by the simulation program. e.g. a "triangle" object is defined by vertices in MEEP and Tidy3D so it is also defined that way in CrystalBuilder.geometry. There are additional methods in the geometry program that allow for defining with a center+size, but under the hood it still just calculates vertices.
+
+lattice.py: the lattice class contains the basis vector information, and the methods for tiling the geometry objects. kekule modulation is also here.
+
+vectors.py: methods for rotating/shifting/scaling vectors defined as numpy arrays or simple lists. This probably won't need to be called by users, but is integral for all the other packages.
+
+bilbao.py: methods for retrieving space group information from Bilbao servers
+
+viewer.py: methods for visualizing structures
+"""

crystalbuilder/bilbao.py

@@ -0,0 +1,297 @@
+
+import re
+import os
+
+location = os.path.dirname(os.path.realpath(__file__))
+resources = os.path.join(location, 'resources')
+
+import requests
+import numpy as np
+from bs4 import BeautifulSoup
+import math
+import json
+    
+
+def check_resource(filename):
+    if os.path.exists(filename):
+        with open(filename) as f:
+            kvec_dict = json.load(f)
+        return kvec_dict
+    else:
+        return False
+    
+def create_resource(filename, dictionary):
+    for key, value in dictionary.items():
+        if isinstance(value, np.ndarray):
+            dictionary[key] = value.tolist()
+    with open(filename, 'w') as f:
+        json.dump(dictionary, f, indent=3)
+        
+def get_kvectors(groupnum, dict_out=False):
+    
+    kvec_array = [] #will convert coordinates to array
+    kvec_dictionary = {} ## for converting both symbols and coordinates to formatted dictionary
+    
+    file = os.path.join(resources, f'{groupnum}-kvec.json')
+    localkdict = check_resource(file)
+    if localkdict:
+        for key, k in localkdict.items():
+            kvec_array.append(k)
+        save_file = False
+        kvec_dictionary = localkdict
+    else:
+        save_file = True
+        URL = "https://www.cryst.ehu.es/cgi-bin/cryst/programs/nph-kv-list"
+        page = requests.post(URL, data={'gnum': str(groupnum),'standard':'Optimized listing of k-vector types using ITA description'})
+        soup = BeautifulSoup(page.content, "html.parser")
+        kvec_table = soup.find_all('table')[1]
+        rows = kvec_table('tr')[2:]
+        raw_kvec_dict = {}
+        for row in rows:
+            sympoint = row.find_all('td')[0].get_text() #first cell has symbol/letter
+            coordstring = row.find_all('td')[1].get_text() #next cell has the coordinates
+            coord = coordstring.split(',') #split the kvec into components
+            raw_kvec_dict[sympoint] = coord # create dictionary from symbol and coordinate
+
+        for key, n in raw_kvec_dict.items():
+            if len(n) == 3:           #Make sure we have (kx,ky,kz)
+                point = []             ## container for the 3 coordinates
+                for index, k in enumerate(n): ## iterate through all the points
+                    k= re.split(r'\b\D\b', k) ### remove blanks, letters, and slashes from division signs.
+                    try:
+                        coordinate = float(k[0])/float(k[1])
+                    except IndexError:
+                        coordinate = float(k[0])
+                    except ValueError:
+                        try:
+                            coordinate = float(k[0])
+                        except ValueError:
+                            coordinate = 1
+                        pass
+                    pass    
+                    point.append(coordinate)
+                kxkykz = np.reshape(np.array(point),(3))
+                kvec_array.append(kxkykz)
+        
+                kvec_dictionary[key] = kxkykz
+        
+
+    kvec_array = np.reshape(np.asarray(kvec_array), (-1,3))
+
+    if save_file == True:
+        create_resource(file, kvec_dictionary)
+        
+    if dict_out == True:
+        return kvec_dictionary
+    else:
+        return kvec_array
+
+def get_genmat(groupnum):
+    """ Retrieve generator matrices 
+    
+    Parameters
+    -----------
+    groupnum : int
+        One of 230 numbered space groups in the IUCr
+    
+    Returns
+    --------
+    matrix_list : list
+        list of matrices representing general positions
+    
+    """
+
+    matrix_list = [] #will convert coordinates to array
+    gen_dictionary = {} ## for converting both symbols and coordinates to formatted dictionary
+    
+    file = os.path.join(resources, f'{groupnum}-generators.json')
+    localgendict = check_resource(file)
+    if localgendict:
+        for key, k in localgendict.items():
+            matrix = k
+            matrix_list.append(k)
+        save_file = False
+    else:
+        save_file = True
+        URL = "https://www.cryst.ehu.es/cgi-bin/cryst/programs/nph-getgen"
+        page = requests.post(URL, data={'gnum': str(
+            groupnum), 'what': 'gp', 'list': 'Standard/Default+Setting'})
+        gen_pos = BeautifulSoup(page.content, "html.parser")
+        holder = gen_pos.find_all("pre")
+
+        matrix_text = []
+        for k in holder:
+            matrix_text.append(k.get_text()) #get text from table
+
+        for f in range(0, len(matrix_text)):  
+            genpos_line = matrix_text[f].split('\n') #separate the matrix text based on newline, giving 3x4 matrix of strings
+
+            genpos_matrix = np.array([]).reshape(0,4)  #create an empty numpy array to "append" each row of the matrix to
+
+            for row_string in genpos_line:
+                row_list = list(filter(None, row_string.split(' '))) # generate a list of strings for each row.
+                row_elements = [] ## create list to store the elements as floats
+                
+                for element in row_list: #go through and convert string elements to floating point ones
+                    try:
+                        matrix_value = float(element) #try simply converting
+                    except ValueError:
+                        elem_split = element.split('/') #if the simple conversion doesn't work, it's likely because it's written as a fraction
+                        matrix_value = float(elem_split[0])/float(elem_split[1]) #calculate the float from the fraction
+
+                    
+                    row_elements.append(matrix_value)  #Put the element in a list with the others in the same row
+
+                row_elements = np.asarray(row_elements) #convert to numpy array
+                genpos_matrix = np.vstack([genpos_matrix, row_elements]) #add the below our existing row
+            
+            matrix_list.append(genpos_matrix) #After iterating through the rows of the matrix, put the matrix in the list
+
+    if save_file == True:
+        matdict = {}
+        for key, value in enumerate(matrix_list):
+            matdict[key] = value
+        
+        create_resource(file, matdict) 
+
+    return matrix_list
+
+def get_coordinates(groupnum, origin, output_array=True):
+    """ Generates positions from specified origin and generator matrices
+    
+    Parameters
+    -----------
+    groupnum : int
+        One of 230 numbered space groups in the IUCr
+
+    origin : list
+        Any point that should be used as (x,y,z) for symmetry operations from the generator matrices
+    
+    output_array : bool
+        Oututs numpy array by default (True), since the result should be an m x 3 matrix with m being the number of generator matrices. If False, the output is a list of lists.
+    
+    Returns
+    --------
+    coordinates : list, array
+        Returns an array if output_array is True (default), returns a list object otherwise.
+
+
+    
+    """
+
+    position_vector = np.array([origin[0], origin[1], origin[2]]).reshape(3,1)
+    matrix_list = get_genmat(groupnum)
+    coordinate_list = []
+    coordinate_array = np.array([]).reshape(0,3)
+    for n in matrix_list:
+        n = np.asarray(n)
+        linear_part, translation_part = np.split(n, [3,], axis=1) #Split matrix into linear part and translation part, *after* third element in row
+        #linear_part is 3x3, translation_part is 3x1
+        linear_product = np.matmul(linear_part, position_vector)  #matrix part
+        transformation = linear_product + translation_part #affine transformation
+        new_point = transformation.reshape(1,3) #make row matrix
+        if ((new_point.all() <= 1) and (new_point.all() >= 0)):
+            if output_array==True:
+                coordinate_array = np.concatenate([coordinate_array, new_point], axis=0)
+            else:
+                coordinate_list.append(new_point.tolist()) #add point to list
+        else:
+            continue
+        
+
+    if output_array == True:
+        return coordinate_array
+    else:
+        return coordinate_list
+
+class SpaceGroup():
+    """ 
+    One of 230 space groups
+
+    This class will have the properties necessary for each space group, as pulled from the Bilbao database.
+
+    Includes:
+        k-vectors with labels
+        generator matrices
+        generation of equivalent points
+    """
+
+    def __init__(
+            self,
+            group_number,
+            **kwargs
+                    ) -> None:
+        
+        """
+        Create the instance of a Space Group
+
+        Parameters
+        -----------
+        group_number : int
+            1-230, corresponding to IUCr and Bilbao server notation.
+        
+        kwargs
+        -------
+        points : list, ndarray
+            Initial coordinates that will be operated on by the symmetry operations to create the entire unit cell.
+        
+        """
+        
+        self.point_list = kwargs.get("points", None)
+        self.group_num = group_number
+        
+        self.kvec_dict = get_kvectors(self.group_num, dict_out=True)
+        self.kvec_arr = get_kvectors(self.group_num, dict_out=False)
+
+        self.generator_matrices = get_genmat(self.group_num)
+
+        self.generated_points = self.calculate_points(self.point_list)
+
+    def calculate_points(self, point_list):
+        """
+        Return a list of coordinates resulting from symmetry operations to each point in `point_list`. This is called once if the `SpaceGroup` is initialized with the `points` kwarg.
+        It can be called any number of times to directly return points from new `point_list` inputs.
+        
+        Parameter
+        ----------
+        point_list : tuple, list, ndarray
+            point(s) on which to perform symmetry operations
+            
+        Return
+        -------
+        generated_points : ndarray
+            Unique points resulting from the symmetry operations on points in point_list. This includes negative values and values greater than 1 (outside the primitive cell).
+        """
+        generated_points = np.array([]).reshape(-1,3)
+        if point_list is not None:
+            if isinstance(point_list, (list, np.ndarray)):
+                for n in point_list:
+                    newpoint = get_coordinates(self.group_num, origin=n)
+                    generated_points = np.vstack((generated_points, newpoint))
+                generated_points.reshape(-1,3)
+                generated_points = np.unique(generated_points, axis=0)
+                
+            else:
+                generated_points = get_coordinates(self.group_num, origin=point_list)
+                generated_points.reshape(-1,3)
+                generated_points = np.unique(generated_points, axis=0)
+        
+            return generated_points
+        else:
+            pass
+        
+
+if __name__ == "__main__":
+    from matplotlib import pyplot as plt
+
+
+    # crystest = SpaceGroup(227)
+    # pointlist = crystest.calculate_points([(0,0,0)])
+    # print(pointlist)
+    # print(pointlist.shape)
+    
+    # fig = plt.figure()
+    # ax = fig.add_subplot(projection='3d')
+    
+    # ax.scatter(pointlist[:, 0], pointlist[:, 1], pointlist[:,2])
+    # plt.show()

crystalbuilder/conversions/lumc.py

@@ -0,0 +1,36 @@
+import numpy as np
+from crystalbuilder import lattice as lat
+from crystalbuilder import geometry as geo
+
+try:
+    import lumpy.simobjects as so
+except ModuleNotFoundError:
+    print("Error: Lumpy and/or the Lumerical API were not found.")
+
+
+debug = 'trace'   #trace = 3, debug = 2, info = 1, none = 0
+
+def debug_msg(string, level):
+    debug_levels = {'trace':3, 'debug':2, 'info': 1, 'none':0}
+    req_deb = debug_levels[debug]
+    if level <= req_deb:
+        print(string)
+        
+def flatten(list):
+    """ Some of these methods can accidentally create nested lists, so this function can be used in try statements to correct those """
+    try:
+        flat_list = [item for sublist in list for item in sublist]
+    except:
+        flat_list = list
+    return flat_list
+
+def convert_cylinder(Cylinder, material='dielectric', index=1.5):    
+    axis = Cylinder.axis
+    lumCyl = so.Cylinder(radius=Cylinder.radius, height=Cylinder.height, center=tuple(flatten(Cylinder.center)), material=material, index=index, orientation=axis)
+    debug_msg(lumCyl.out(), 3)
+    return lumCyl
+
+def convert_prism(Prism, material='dielectric', index=1.5):
+    verts = Prism.vertices[:, 0:2]
+    lumPrism = so.Prism(vertices=verts, z_span=Prism.height, center=tuple(flatten(Prism.center)), material=material, index=index)
+    return lumPrism

crystalbuilder/conversions/t3d.py

@@ -0,0 +1,179 @@
+
+import numpy as np
+from tidy3d import Transformed, Structure, GeometryGroup, Cylinder, Medium, Simulation, PointDipole, C_0, GridSpec, GaussianPulse
+try:
+    from tidy3d import Transformed, Structure, GeometryGroup, Cylinder, Medium, Simulation, PointDipole, C_0, GridSpec, GaussianPulse
+except ModuleNotFoundError:
+    pass
+
+from crystalbuilder import geometry as geo
+debug = "off"
+
+def unpack_supercell(supercell):
+    """Turns supercell into a list of geometry objects
+
+    Parameters
+    ----------
+    supercell : gm.SuperCell()
+        A SuperCell object from geometry.py
+
+    Returns
+    -------
+    [structures]: list
+        list of the geometry objects in SuperCell
+
+    """
+
+    structures = supercell.structures
+    return structures
+
+def flatten(list):
+    """ Some of these methods can accidentally create nested lists, so this function can be used in try statements to correct those """
+    try:
+        if isinstance(list, list):
+            flat_list = [item for sublist in list for item in sublist]
+    except:
+        flat_list = list
+    return flat_list
+
+def rotate_to(orientation, v1 = [0,0,1]):
+    """
+    Create a quaternion to rotate the original vector to the specified `orientation`. By default, use a Z unit vector
+    """
+
+    orientation = np.asarray(orientation)/np.linalg.norm(orientation)
+    v1 = np.asarray(v1)/np.linalg.norm(v1)
+    eyemat = np.identity(3)
+    
+    
+    rot_axis_unnorm = np.cross(v1, orientation)
+    s_angle = np.linalg.norm(rot_axis_unnorm)
+    rot_axis = rot_axis_unnorm/s_angle
+    c_angle = np.dot(v1, orientation)
+    rotmat2 = Transformed.rotation(s_angle, (rot_axis[0], rot_axis[1], rot_axis[2]))
+
+    # print(s_angle)
+    # print(c_angle)
+
+    skew_mat = np.array(
+        ((0, -rot_axis[2], rot_axis[1]), 
+        (rot_axis[2], 0, -rot_axis[0]), 
+        (-rot_axis[1], rot_axis[0], 0))
+    )
+
+    rot_mat = eyemat + (s_angle * skew_mat) + ((1-c_angle)*(skew_mat@skew_mat))
+    #Tidy3D takes an affine transformation matrix. So we'll pad it to 4x4 with zeros and a 1 in the bottom corner
+    
+    rot_mat = np.pad(rot_mat, (0,1))
+    rot_mat[3,3] = 1
+    # rot_mat = rotmat2
+    return rot_mat
+
+def _convert_cyl(geometry_object, material):
+    """ Put the structure at the origin, do the rotation, then shift it to the correct spot."""
+    m = geometry_object
+    rot_mat = rotate_to(m.axis)
+    shift_center = flatten(m.center)
+    rot_mat[:3, -1] = shift_center
+    tdgeom = Transformed(geometry = Cylinder(radius=m.radius, axis= 2, length=m.height, center=[0,0,0]), transform=rot_mat)
+    return tdgeom
+
+def _geo_to_tidy3d(geometry_object, material, **kwargs):
+    """Converts geometry object (or supercell) to the Tidy3D equivalent. Note that Tidy3D values always include units (microns by default).
+
+    Tidy3D geometries are combined with a specified medium to create a Tidy3D structure object, which can be given a unique name. For now, the naming will be systematic. This might be changed in the future via kwargs.
+
+    The material assignment will occur after all of the geometries have been made. This means a td.GeometryGroup object will be created and made into a structure.
+     """
+
+    geom_list = []
+    try:
+        for m in geometry_object:
+            if isinstance(m, geo.SuperCell):
+                if debug=="on": print("This is running the iterable Supercell")
+                innerlist = _geo_to_tidy3d(m, material)
+                geom_list.append(innerlist)
+
+            elif isinstance(m, geo.Cylinder):
+                if debug=="on": print("This is running the iterable cylinder")
+                tdgeom = _convert_cyl(m, material)
+                geom_list.append(tdgeom)
+
+    except TypeError:
+            if isinstance(geometry_object, geo.SuperCell):
+                if debug=="on": print("This is running the single Supercell")
+                structs = unpack_supercell(geometry_object)
+                m = structs
+                newlist = _geo_to_tidy3d(m, material)
+                geom_list.append(newlist)
+
+            elif isinstance(geometry_object, geo.Cylinder):
+                m = geometry_object
+                if debug=="on": print("This is creating a single cylinder named")
+                tdgeom = _convert_cyl(m, material)
+                geom_list.append(tdgeom)
+
+    return geom_list
+
+def geo_to_tidy3d(geometry_object, material, name="Structure Group", **kwargs):
+    """Converts CrystalBuilder geometry object(s) to the corresponding Tidy3D object(s) with defined medium. 
+    
+    
+    `material` can be either a td.Medium() object or a float corresponding to the refractive index of the desired Medium.
+
+    This is a higher level wrapper of the _geo_to_tidy3d function, which I have yet to document
+
+    Parameters
+    ------------
+    geometry_object : Geometry or list of Geometry
+        an object or list of objects
+    material : td.Medium() or float
+        Tidy3D Medium or the refractive index that will be assigned to the material.
+
+
+
+    Returns
+    ------------
+    td.Structure()
+        a Tidy3D structure group with defined Medium
+
+    """
+    material_name = kwargs.get("material_name", "Dielectric Material")
+    geometry_list_raw = _geo_to_tidy3d(geometry_object, material)
+    geometry_list =geometry_list_raw
+    geometry_group = GeometryGroup(geometries = tuple(geometry_list))
+    if isinstance(material, Medium):
+        medium = material
+    else:
+        medium = Medium(permittivity = material**2, name=material_name)
+
+    return Structure(geometry=geometry_group, medium=medium, name=name)
+
+if __name__ == '__main__':
+    """testing code"""
+
+    cylinder = geo.Cylinder.from_vertices([[0,0,0], [3,0,0]], radius=.1)
+    newgeo = geo_to_tidy3d([cylinder, cylinder], material=3)
+
+    def view_structures(geometry):
+        # create source
+        lda0 = 0.75  # wavelength of interest (length scales are micrometers in Tidy3D)
+        freq0 = C_0 / lda0  # frequency of interest
+        source = PointDipole(
+            center=(-1.5, 0, 0),  # position of the dipole
+            source_time=GaussianPulse(freq0=freq0, fwidth=freq0 / 10.0),  # time profile of the source
+            polarization="Ey",  # polarization of the dipole
+    )
+
+        sim = Simulation(
+            size=(5, 5, 5),  # simulation domain size
+            grid_spec=GridSpec.auto(
+                min_steps_per_wvl=25
+            ),  # automatic nonuniform FDTD grid with 25 grids per wavelength in the material
+            structures=[geometry],
+            sources=[source],
+            run_time=3e-13,  # physical simulation time in second
+        )
+        sim.plot_3d()
+
+    view_structures(newgeo)