crystalbuilder 0.6.0__tar.gz → 0.7.1__tar.gz

{crystalbuilder-0.6.0 → crystalbuilder-0.7.1}/.gitignore

@@ -166,8 +166,11 @@ cython_debug/
 #.idea/
 
 *.hdf5
-*.json
+
 
 
 crystalbuilder/version.py
-examples/Tidy3D/
+examples/Tidy3D/
+*.npy
+
+isolated/

{crystalbuilder-0.6.0 → crystalbuilder-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crystalbuilder
-Version: 0.6.0
+Version: 0.7.1
 Summary: A package for building 3D photonic crystals
 Author: Brandon Hacha
 License-File: LICENSE

{crystalbuilder-0.6.0 → crystalbuilder-0.7.1}/README.md

@@ -4,3 +4,8 @@ Crystalbuilder
 crystalbuilder is a package that, as its name suggests, builds photonic crystals. This is really a frankenstein of existing software, including MPB, MEEP and Vedo. MPB is used for bandstructure simulations (and MEEP is used for MPB). Vedo is just a mesh viewer/editor that is used for displaying the generated crystals.
 
 The package also uses beautifulsoup4 to read position data from the Bilbao Crystallographic Server, so that you can easily make structures corresponding to any of the 230 space groups. If you use this feature, make sure that the Bilbao server gets cited. The diamond cubic example shows how that should be done. 
+
+Crystalbuilder depends on vtk and its python version compatibility is often limited by the available wheels. Crystalbuilder currently supports Python <= 3.13
+
+Install with:
+`pip install crystalbuilder`

{crystalbuilder-0.6.0 → crystalbuilder-0.7.1}/crystalbuilder/__init__.py

@@ -5,9 +5,7 @@ try:
 except PackageNotFoundError:
     __version__ = "unknown"
 
-__all__ = ["convert", "geometry", "lattice", "vectors","bilbao", "viewer", "lumpy_convert"]
-
-
+__all__ = ["convert", "geometry", "lattice", "vectors","bilbao", "viewer", "conversions"]
 
 
 

crystalbuilder-0.7.1/crystalbuilder/bilbao.py

@@ -0,0 +1,363 @@
+
+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
+import crystalbuilder.housekeeping.types as cbt    
+
+Literal = cbt.Literal
+Iterable = cbt.Iterable
+vector_type = cbt.vector_type
+angle_unit_type = cbt.angle_unit_type
+scalar = cbt.number
+array = cbt.array
+matrix_like = cbt.matrix_like
+
+bilbao_url = "https://cryst.ehu.es/"
+
+cookie_dict = {"turnstile_passed": '1767991980'} #filler cookie. Should be set with _get_spacegroups()
+
+def _get_spacegroups(cookie, spacegroup):
+    """
+    This should not be used in a regular import scenario. This scrapes data from the Bilbao server to create offline resource files, but only works with a cookie obtained after passing a Cloudflare DDOS protection. It will fail if run without configuring that.
+    """
+    formatted_cookie = str(cookie)
+    global cookie_dict
+    cookie_dict = {"turnstile_passed": formatted_cookie}
+    
+    if spacegroup == 'all':
+        spacegroup = list(range(1, 231))
+    else:
+        pass
+
+    if isinstance(spacegroup, list):
+        for n in spacegroup:
+            groupnum = int(n)
+            get_kvectors(groupnum)
+            get_genmat(groupnum)
+    else:
+        get_kvectors(int(spacegroup))
+        get_genmat(int(spacegroup))
+
+
+def check_resource(filename:str) -> dict | Literal[False]:
+    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:str, dictionary:dict) -> None:
+    try:
+        os.mkdir(resources)
+    except FileExistsError:
+        print(f"Saving to Resources file at {resources}")
+
+    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:int, dict_out: bool=False) -> dict|array:
+    
+    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 = bilbao_url+"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'}, cookies=cookie_dict)
+        soup = BeautifulSoup(page.content, "html.parser") # type: ignore
+        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:int) -> list[array]:
+    """ 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 = bilbao_url+ "cgi-bin/cryst/programs/nph-getgen"
+        page = requests.post(URL, data={'gnum': str(
+            groupnum), 'what': 'gp', 'list': 'Standard/Default+Setting'}, cookies=cookie_dict)
+        gen_pos = BeautifulSoup(page.content, "html.parser") # type: ignore
+        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:int, origin:vector_type, output_array:bool=True, a_mag:vector_type = np.array([1,1,1])) -> list|array:
+    """ 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.
+
+
+    
+    """
+    ### We exclude transforms that return points outside of the unit cell. This can be overriden by setting bound_override to True
+    bound_override = True
+    lattice_scaling = np.asarray(a_mag)
+    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)
+        # scaled_n = (n.T*lattice_scaling).T
+        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
+        # print(linear_product)
+        # print(f"lattice: {lattice_scaling} \n translation: {translation_part.T} ")
+
+
+        transformation = linear_product + (translation_part.T * lattice_scaling).T #affine transformation
+        # print(transformation)
+        new_point = transformation.reshape(1,3) #make row matrix
+        if ((((new_point<=lattice_scaling).all()) and ((new_point>= 0).all())) or (bound_override == True)):
+            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: int,
+            **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: array|None = 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: list|array|None, a_mag: vector_type = [1,1,1], ignore_repeats:bool = True) -> array:
+        """
+        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
+
+        a_mag : list, ndarray
+            magnitude of lattice vectors in each direction
+                
+        ignore_repeats : bool (default true)
+            Ignore points that are identical to ones already calculated. There's no reason to change this unless you're trying to view all of the positions
+        
+        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:
+                    scaled_point = n * np.asarray(a_mag)
+                    newpoint = get_coordinates(self.group_num, origin=scaled_point, a_mag=a_mag)
+                    generated_points = np.vstack((generated_points, newpoint))
+                generated_points.reshape(-1,3)
+                listlen=len(generated_points)
+                if ignore_repeats == True:
+                    generated_points = np.unique(generated_points, axis=0)
+                
+            else:
+                generated_points:array = get_coordinates(self.group_num, origin=point_list)
+                generated_points.reshape(-1,3)
+                listlen=len(generated_points)
+                if ignore_repeats == True:
+                    generated_points = np.unique(generated_points, axis=0)
+                
+            print(f"Generated {listlen} points, returned {len(generated_points)}. {listlen - len(generated_points)} duplicates removed")
+            print(f"Returned {len(generated_points)} points")
+            return generated_points
+
+        else:
+            return np.array([0,0,0])
+                 
+
+if __name__ == "__main__":
+
+
+    _get_spacegroups(cookie='1770081648', spacegroup=230)
+    
+
+    # 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.invert_xaxis()
+    
+    ax.scatter(pointlist[:, 0], pointlist[:, 1], pointlist[:,2])
+    plt.show()

{crystalbuilder-0.6.0 → crystalbuilder-0.7.1}/crystalbuilder/conversions/t3d.py

@@ -4,6 +4,8 @@ try:
     from tidy3d import Transformed, Structure, GeometryGroup, Cylinder, Medium, Simulation, PointDipole, C_0, GridSpec, GaussianPulse
 except ModuleNotFoundError:
     pass
+except ImportError:
+    pass
 
 from crystalbuilder import geometry as geo
 debug = "off"

{crystalbuilder-0.6.0 → crystalbuilder-0.7.1}/crystalbuilder/convert.py

@@ -1,14 +1,16 @@
 import numpy as np
+from crystalbuilder.conversions.t3d import geo_to_tidy3d
 from crystalbuilder import lattice as lat
 from crystalbuilder import geometry as geo
-from crystalbuilder import lumpy_convert as lc
+from crystalbuilder.conversions import lumc as lc
 import platform
 if platform.system() == 'Windows':
     pass
 else:
-    import meep as mp
-
-#import tidy3d as td
+    try:
+        import meep as mp
+    except:
+        pass
 try:
     import lumpy.simobjects as so
 except ModuleNotFoundError:
@@ -58,7 +60,8 @@ def unpack_supercell(supercell):
 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]
+        if isinstance(list, list):
+            flat_list = [item for sublist in list for item in sublist]
     except:
         flat_list = list
     return flat_list
@@ -112,11 +115,14 @@ def _geo_to_meep(geometry_object, material, ismpb = False, **kwargs):
                 
                 if ismpb == True: 
                     k = vectorize(m.center)
+                    ax = vectorize(m.axis)
                     newcent = mp.cartesian_to_lattice(k, geo_lattice)
+                    newax = mp.cartesian_to_lattice(ax, geo_lattice)
                 else:
                     newcent = vectorize(m.center)
+                    newax = vectorize(m.axis)
 
-                item = mp.Cylinder(radius=m.radius, axis= m.axis, height=m.height, center=newcent, material=material)
+                item = mp.Cylinder(radius=m.radius, axis=newax, height=m.height, center=newcent, material=material)
                 geom_list.append(item)
 
             elif isinstance(m, geo.Triangle):
@@ -245,79 +251,6 @@ def geo_to_mpb(geometry_object, material, lattice):
     mpb_list = flatten(newlist)
     return mpb_list
 
-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 = td.Cylinder(radius=m.radius, axis= 2, length=m.height, center=tuple(flatten(m.center)))
-                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 = td.Cylinder(radius=m.radius, axis= 2, length=m.height, center=tuple(flatten(m.center)))
-                geom_list.append(tdgeom)
-
-
-    return geom_list
-
-def geo_to_tidy3d(geometry_object, material):
-    """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
-
-    """
-
-    geometry_list = flatten(flatten(_geo_to_tidy3d(geometry_object, material)))
-    print(geometry_list)
-    geometry_group = td.GeometryGroup(geometries = tuple(geometry_list))
-
-    if isinstance(material, td.Medium):
-        medium = material
-    else:
-        medium = td.Medium(permittivity = material**2, name="DielectricMaterial")
-    return td.Structure(geometry=geometry_group, medium=medium, name="Structure Group")
-
-
 def _geo_to_lumerical(geometry_object, material):
     """
     Converts Geometry object to list of lumerical objects
@@ -432,15 +365,20 @@ def to_mpb_lattice(geolattice):
 if __name__ == '__main__':
     """testing code"""
 
-    mat1 = mp.Medium(epsilon=4)
-    geometry_lattice = mp.Lattice(size=mp.Vector3(1, 1),
-                        basis1=mp.Vector3(np.sqrt(3) / 2, 0.5),
-                        basis2=mp.Vector3(0,0.5))
+    # mat1 = mp.Medium(epsilon=4)
+    # geometry_lattice = mp.Lattice(size=mp.Vector3(1, 1),
+    #                     basis1=mp.Vector3(np.sqrt(3) / 2, 0.5),
+    #                     basis2=mp.Vector3(0,0.5))
 
-    tri = geo.eqTriangle(1, .5)
-    print(tri.vertices.shape)
-    print(type(tri))
+    # tri = geo.eqTriangle(1, .5)
+    # print(tri.vertices.shape)
+    # print(type(tri))
     
-    newgeo = _geo_to_lumerical(tri, mat1)
+    # newgeo = _geo_to_lumerical(tri, mat1)
+
+    # print(newgeo[0].out())
 
-    print(newgeo[0].out())
+    
+    cylinder = geo.Cylinder.from_vertices([[0,0,0], [1,1,1]], radius=.2)
+    cylinder2 = geo.Cylinder(center=[1,1,0], radius=.1, height=3, axis=2)
+    newgeo = geo_to_tidy3d([cylinder, cylinder2], material=3)