samplemaker-sparrow 5.4.4__cp313-cp313-win_amd64.whl

samplemaker/__init__.py

@@ -0,0 +1,43 @@
+"""
+
+This is the Python version of Sample Maker, a scripting tool for designing 
+lithographic masks in the GDSII format. Package `samplemaker` comes 
+with different tools and submodules for the creation and manipulation of basic
+shapes, periodic shapes, sequences (e.g. waveguides), circuits, and complex 
+devices. 
+
+The code has been developed primarily for nanophotonics, but it can be easily
+extended to different applications in micro and nano device fabrication.
+
+Sample Maker is developed and maintained by Leonardo Midolo (Niels Bohr Institute,
+University of Copenhagen). It is based on the MATLAB(R) code developed by Leonardo Midolo 
+between 2013 and 2019. The first version of the rewritten Python code has been released in October 2021.
+
+This software has been realized with the financial support from 
+the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (Grant agreement No. 949043, NANOMEQ).
+
+.. include:: ./documentation.md
+"""
+
+from typing import (  # noqa: F401
+    cast, Any, Callable, Dict, Generator, Iterable, List, Mapping, NewType,
+    Optional, Set, Tuple, Type, TypeVar, Union,
+)
+
+__version__ = "5.4.3"
+    
+__pdoc__: Dict[str, Union[bool, str]] = {}
+__pdoc__["samplemaker.Tutorials"]=False
+__pdoc__["samplemaker.tests"]=False
+__pdoc__["samplemaker.resources"]=False
+__pdoc__["samplemaker.gdsreader"]=False
+__pdoc__["samplemaker.devices.DevicePort"]=False
+
+# The LayoutPool contains all the current layout, this class should generally not
+# be used directly, but only through the Mask class.
+LayoutPool = dict() # connects a SREF name to a particular geomgroup in the current memory
+# Additional cache pool
+_DevicePool = dict() # connects a device hash to a SREF to be instantiated
+_DeviceLocalParamPool = dict() # connects a device hash to local parameters created by the call to geom()
+_DeviceCountPool = dict() # connects a device name to a device count 
+_BoundingBoxPool = dict() # connects a SREF name to its bounding box

samplemaker/baselib/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+import samplemaker.baselib.devices
+
+print("Base library loaded")

samplemaker/baselib/devices.py

@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+"""
+Base device library.
+
+This is a collection of some simple demo devices distributed with the base
+version of `samplemaker`. It can be used as template for creating new libraries
+or to learn how to design them.
+
+Note that individual device methods are not documented but should be readable 
+and self-explanatory.
+
+The library provides the following devices:
+    
+"""
+
+import numpy as np
+import math
+from samplemaker.devices import Device, registerDevicesInModule
+import samplemaker.makers as sm
+from samplemaker.baselib.waveguides import BaseWaveguideSequencer, BaseWaveguidePort
+
+class CrossMark(Device):
+    def initialize(self):
+        self.set_name("BASELIB_CMARK")
+        self.set_description("Generic cross marker for mask alignment.")
+    
+    def parameters(self):
+        self.addparameter("length1", 20, "Length of inner cross",float)
+        self.addparameter("length2", 10, "Length of outer cross",float)
+        self.addparameter("width1", 0.5, "Width of inner cross", float)
+        self.addparameter("width2", 2, "width of outer cross", float)
+        self.addparameter("layer", 4, "Layer to use for cross", int,(0,255))
+        self.addparameter("mark_number",0,"Places a square in the corner, use 0 to remove", float, (0,4))
+        self.addparameter("square_size",10,"Size of the square in the corner", float)
+        
+    def geom(self):
+        p = self.get_params();
+        cross = sm.make_rect(0, 0, p["length1"], p["width1"],layer=1)
+        cross += sm.make_rect(0, 0, p["width1"], p["length1"],layer=1)
+        cross.boolean_union(1)
+        ocross = sm.make_rect(p["length1"]/2,0,p["length2"],p["width2"],numkey=4)
+        for i in range(4):
+            c = ocross.copy()
+            c.rotate(0, 0, 90*i)
+            cross+=c
+        if(p["mark_number"]>0):
+            rot = 90*(p["mark_number"]-1)
+            square = sm.make_rect(p["length1"]/2+p["length2"],
+                                  p["length1"]/2+p["length2"],
+                                  p["square_size"],p["square_size"],numkey=1)
+            square.rotate(0,0,rot)
+            cross+=square
+            
+        cross.set_layer(p["layer"])
+        return cross
+
+class DirectionalCoupler(Device):
+    def initialize(self):
+        self.set_name("BASELIB_DCPL")
+        self.set_description("Simple symmetric directional coupler")
+    
+    def parameters(self):
+        self.addparameter("length", 20, "Coupling length",float)
+        self.addparameter("width", 0.3, "Width of the waveguides in the coupling section",float,(0.01,1))
+        self.addparameter("gap", 0.5, "Distance between waveguides in the coupling section", float)
+        self.addparameter("input_dist", 5, "Distance between waveguides at input", float,(0.01,np.inf))
+        self.addparameter("input_len", 7, "Length of the input section from input to coupling", float, (3,np.inf))        
+        
+    def geom(self):
+        p = self.get_params();
+        # Draw the upper arm, then mirror
+        off = p["input_dist"]/2
+        clen = (p["input_len"]-1)/2
+        Ltot = p["length"]+p["input_len"]*2
+        seq = [['T',1,p["width"]],["C",-off,clen],
+                ['S',p["length"]/2]]
+        ss =  BaseWaveguideSequencer(seq)
+        dc = ss.run()
+        dc2 = dc.copy()
+        dc2.mirrorX(Ltot/2)
+        dc+=dc2
+        dc.translate(-Ltot/2, off+p["gap"]/2+p["width"]/2)
+        dc3 = dc.copy()
+        dc3.mirrorY(0)
+        dc+=dc3        
+        # Add ports
+        XP = Ltot/2
+        YP = off+p["gap"]/2+p["width"]/2
+        self.addlocalport(BaseWaveguidePort(-XP, YP, "west", ss.options["defaultWidth"], "p1"))
+        self.addlocalport(BaseWaveguidePort( XP, YP, "east", ss.options["defaultWidth"], "p2"))
+        self.addlocalport(BaseWaveguidePort(-XP,-YP, "west", ss.options["defaultWidth"], "p3"))
+        self.addlocalport(BaseWaveguidePort( XP,-YP, "east", ss.options["defaultWidth"], "p4"))
+        
+        return dc
+
+class FocusingGratingCoupler(Device):
+    def initialize(self): 
+        self.set_name("BASELIB_FGC")
+        self.set_description("Grating coupler demo.")
+    
+    def parameters(self):
+        self.addparameter('w0',0.3,'Width of the waveguide at the start', float)
+        self.addparameter('pitch',0.355,'Grating default pitch', float)
+        self.addparameter('ff',0.5,'Fill factor', float)
+        self.addparameter('theta',10,'Emission angle at central wavelength', float)
+        self.addparameter('lambda0',0.94,'Central wavelength', float)
+        self.addparameter('nr_Apo',11,'nr of the 1st arc with pitch and ff',int)
+        self.addparameter('ff_coef',0.5,'min ff_apod = ff_coef*ff', float);
+        self.addparameter('order_start',10,'Starting period', int);
+        self.addparameter('order',15,'Number of periods', int);
+        self.addparameter('diverg_angle',20,'GRT divergence angle/2, deg', float);
+        self.addparameter('pre_split',True,'Split in quads = false', bool); 
+
+    def geom(self):
+        # Grating first
+        p = self.get_params();
+        theta = math.radians(p["theta"])
+        div_angle = p["diverg_angle"]
+        q0 = p["order_start"]
+        qN = q0+p["order"]+1
+        lambda0 = p["lambda0"]
+        pitch = p["pitch"]
+        n = math.sin(theta)+lambda0/pitch # Effective refractive index
+        p0 = lambda0/math.sqrt(n*n-np.power(math.sin(theta),2));
+        ff = p["ff"]
+        nr_Apo = p["nr_Apo"]
+        ff_coef = p["ff_coef"]
+
+        g = sm.GeomGroup()        
+        for q in range(q0,qN):
+            b = q*p0
+            x0 = b*b*math.sin(theta)/(q*lambda0);
+            a = b*b*n/(q*lambda0);
+            if (q <= q0+nr_Apo-1):
+                ff_chi = ff-(1-ff_coef)*ff/(nr_Apo-2)*(q0+nr_Apo-q);
+            else:
+                ff_chi = ff
+            
+            w = ff_chi*pitch
+            g+=sm.make_arc(x0, 0, a, b, 0, w, -div_angle-5, div_angle+5,
+                           layer=3,to_poly=True,vertices=40,split=p["pre_split"])
+
+        # waveguide
+        Ltaper = 1
+        Gtaper = qN*pitch
+        Wtaper = Gtaper*math.tan(math.radians(div_angle))*2
+        
+        
+        seq = [["T",Ltaper,p["w0"]],
+                         ["CENTER",0,0],
+                         ["T",Gtaper,Wtaper],['STATE','w',2.5],['S',1]]
+        
+        ss =  BaseWaveguideSequencer(seq)
+        g += ss.run()
+
+        self.addlocalport(BaseWaveguidePort(-Ltaper, 0, "west", p["w0"], "p1"))
+
+        return g
+
+# Register all devices here in this module
+registerDevicesInModule(__name__)

samplemaker/baselib/waveguides.py

@@ -0,0 +1,320 @@
+# -*- coding: utf-8 -*-
+"""
+Base waveguide library. 
+
+
+Implements a simple waveguide sequencer and optical ports.
+This module can be used as template to develop different waveguide libraries.
+
+"""
+
+import math
+from copy import deepcopy
+import numpy as np
+from samplemaker.devices import DevicePort
+from samplemaker.shapes import GeomGroup
+import samplemaker.sequencer as smseq
+import samplemaker.makers as sm
+from samplemaker.routers import WaveguideConnect
+
+# First step in defining a waveguide library is to define a sequencer
+# and its dictionary.
+
+# Let's define some options for the BaseWaveguide sequencer
+def BaseWaveguideOptions():
+    BaseWaveguidesOptions = smseq.default_options()
+    # Let's define the default waveguide layer
+    BaseWaveguidesOptions["wgLayer"] = 1
+    # For waveguide bends, let's use a fixed resolution
+    BaseWaveguidesOptions["bendResolution"] = 30
+    # Let's define the default waveguide width
+    BaseWaveguidesOptions["defaultWidth"] = 0.3
+    return BaseWaveguidesOptions
+
+# Let's define the sequencer state class
+# We could use the default, but we would like to store
+# the current waveguide width as well using the parameter 'w'
+class BaseWaveguideState(smseq.SequencerState):
+    def __init__(self):
+        """
+        The sequencer state for BaseWaveguide library.
+        Defines 'w' as current waveguide width. 
+
+        Returns
+        -------
+        None.
+
+        """
+        super().__init__()
+        self.state["w"]=0 # The value will be set by the INIT command
+
+# Let's define the INIT command, which is always the first to execute
+def BaseWaveguideINIT(state, options):
+    smseq.__initState(state,options)
+    if(not options["__no_init__"]):
+        state['w'] = options['defaultWidth']
+    
+# The S command to go straight
+def BaseWaveguideS(args,state,options)->GeomGroup:
+    """
+    Draw straight waveguide
+
+    Parameters
+    ----------
+    args : list
+        1 argument: waveguide length.
+    state : dict
+        Current state.
+    options : dict
+        The sequencer options.
+
+    Returns
+    -------
+    samplemaker.shapes.GeomGroup
+        The waveguide geometry.
+
+    """
+    dist = args[0]
+    if(dist==0):
+        return GeomGroup()
+    
+    # Let's draw a simple rectangle
+    wg = sm.make_rect(0,0,dist,state['w'],numkey=4,layer=options["wgLayer"])
+    # Now rotate and translate according to pointer orientation
+    wg.rotate_translate(state['x'], state['y'], state['a'])
+    # Finally, update the state
+    state['x']+=dist*math.cos(math.radians(state['a']))
+    state['y']+=dist*math.sin(math.radians(state['a']))
+    state['__OL__']+=dist
+    return wg
+
+# The B command to make a circular bend
+def BaseWaveguideB(args,state,options)->GeomGroup:
+    """
+    Draw circular bend waveguide
+
+    Parameters
+    ----------
+    args : list
+        2 arguments: angle of bend (in degrees), radius of bend.
+    state : dict
+        Current state.
+    options : dict
+        The sequencer options.
+
+    Returns
+    -------
+    samplemaker.shapes.GeomGroup
+        The waveguide geometry.
+
+    """
+    angle = args[0]
+    radius = args[1]
+    if(angle==0):
+        return GeomGroup()
+    
+    wg = sm.make_arc(0, radius, radius, radius, 
+                -90, state['w'], 0, abs(angle),
+                vertices=options["bendResolution"],
+                to_poly=True,layer=options["wgLayer"])  
+    xf = radius*math.sin(math.radians(abs(angle)))
+    yf = radius*(1-math.cos(math.radians(abs(angle))))
+    if(angle<0):
+        wg.mirrorY(0)
+        yf=-yf
+    ept = sm.make_dot(xf, yf) # helps calculating the end point
+    # Now rotate and translate according to pointer orientation
+    wg.rotate_translate(state['x'], state['y'], state['a'])
+    ept.rotate_translate(state['x'], state['y'], state['a'])
+    # Finally, update the state
+    state['x']=ept.x
+    state['y']=ept.y
+    state['a']+=angle
+    state['__OL__']+=radius*2*math.pi/360*abs(angle)
+    
+    return wg
+
+def BaseWaveguideC(args, state, options)->GeomGroup:
+    """
+    Draw cosine bend waveguide. While keeping the same direciton,
+    bend the waveguide using a cosine function.
+
+    Parameters
+    ----------
+    args : list
+        2 arguments: offset (in um), radius of bend.
+    state : dict
+        Current state.
+    options : dict
+        The sequencer options.
+
+    Returns
+    -------
+    samplemaker.shapes.GeomGroup
+        The waveguide geometry.
+
+    """
+    off = args[0]
+    radius = args[1]
+    delta = 0.01 # at the very beginning and at the end go straight by delta
+    radius -= delta
+    if(radius ==0):
+        return GeomGroup()
+    N = options['bendResolution']
+    amp = math.pi*off/4/radius
+    t = np.linspace(0,2,N);
+    s = [math.asin(math.tan(math.atan(amp)*x)/amp) for x in t if x<1]
+    s+= [math.asin(math.tan(math.atan(amp)*(x-2))/amp)+math.pi for x in t if x>=1]
+    s = np.array(s)
+    xpts = s/math.pi*2*radius + state['x']
+    ypts = off*(np.cos(s+math.pi)+1)/2 + state['y']
+    xpts = np.append(xpts[0],xpts+delta)
+    xpts = np.append(xpts,xpts[-1]+delta)
+    ypts = np.append(ypts[0],ypts)
+    ypts = np.append(ypts,ypts[-1])
+    OL = np.sum(np.sqrt(np.power(np.ediff1d(xpts),2)+np.power(np.ediff1d(ypts),2)))
+    wg = sm.make_path(xpts, ypts, state['w'],to_poly=1,layer=options["wgLayer"])
+    outdot = sm.make_dot(xpts[-1],ypts[-1])
+    wg.rotate(state['x'],state['y'],state['a'])
+    outdot.rotate(state["x"],state["y"],state["a"])
+    state['x']=outdot.x
+    state['y']=outdot.y
+    state["__OL__"]+=OL
+    return wg    
+
+def BaseWaveguideT(args, state, options)->GeomGroup:
+    """
+    Draw linear taper
+
+    Parameters
+    ----------
+    args : list
+        2 arguments: length of taper (in um), final width (if <0, the defaultWidth value is used).
+    state : dict
+        Current state.
+    options : dict
+        The sequencer options.
+
+    Returns
+    -------
+    samplemaker.shapes.GeomGroup
+        The waveguide geometry.
+
+    """
+    dist = args[0]
+    wf = args[1]
+    if(dist==0):
+        return GeomGroup()
+    if(wf < 0): wf = options["defaultWidth"]
+    a = math.radians(state['a'])
+    xf = state['x']+dist*math.cos(a)
+    yf = state['y']+dist*math.sin(a)
+    wg = sm.make_tapered_path([state['x'],xf], [state['y'],yf], [state['w'],wf],
+                              layer=options["wgLayer"])
+    state['x']=xf
+    state['y']=yf
+    state['w']=wf
+    state["__OL__"]+=dist
+    return wg
+    
+def BaseWaveguideOFF(args,state,options)->GeomGroup:
+    """
+    Offset the waveguide (jumps left or right of waveguide)
+
+    Parameters
+    ----------
+    args : list
+        1 argument: offset (in um), positive means on left of waveguide direction.
+    state : dict
+        Current state.
+    options : dict
+        The sequencer options.
+
+    Returns
+    -------
+    samplemaker.shapes.GeomGroup
+        The waveguide geometry.
+
+    """
+    off = args[0]
+    a = math.radians(state['a']+90)
+    state['x']+=off*math.cos(a)
+    state['y']+=off*math.sin(a)
+    return GeomGroup()
+
+def BaseWaveguideCommands() -> dict:
+    """
+    Creates the dictionary with the command list and corresponding
+    functions.
+
+    Returns
+    -------
+    dict
+        The command list to be used by the sequencer.
+
+    """
+    command_list=smseq.default_command_list()
+    command_list["INIT"] = (0,BaseWaveguideINIT)
+    command_list["S"] = (1,BaseWaveguideS)
+    command_list["B"] = (2,BaseWaveguideB)
+    command_list["C"] = (2,BaseWaveguideC)
+    command_list["T"] = (2,BaseWaveguideT)
+    command_list["OFF"] = (1,BaseWaveguideOFF)
+    return command_list
+
+# Finally, create a custom sequencer
+class BaseWaveguideSequencer(smseq.Sequencer):
+    def __init__(self,seq):
+        """
+        Creates a custom sequencer for simple waveguides.
+
+        Parameters
+        ----------
+        seq : list
+            The sequence to be executed.
+
+        Returns
+        -------
+        None.
+
+        """
+        opts = BaseWaveguideOptions()
+        state  = BaseWaveguideState()
+        cmds = BaseWaveguideCommands()
+        super().__init__(seq,opts,state,cmds)
+
+
+# some global connector options
+BaseWaveguideConnectorOptions = {"bending_radius":3,
+                          "sequencer_options":BaseWaveguideOptions()}
+
+def BaseWaveguideConnector(port1: DevicePort,port2: DevicePort) -> GeomGroup:
+    res = WaveguideConnect(port1, port2,BaseWaveguideConnectorOptions["bending_radius"])
+    if(res[0]==True):
+        so = BaseWaveguideSequencer(res[1])
+        so.options = deepcopy(BaseWaveguideConnectorOptions["sequencer_options"])
+        g = so.run()
+        g.rotate_translate(port1.x0,port1.y0,math.degrees(port1.angle()))
+        return g
+    else:
+        return GeomGroup()
+
+# Now let's create a new DevicePort with a connector function
+class BaseWaveguidePort(DevicePort):
+    def __init__(self,x0: float, y0 : float,orient: str ="East",width: float =None,name: str =None):
+        orient = orient.lower()
+        horizontal = True
+        forward = True
+        if(orient=="west" or orient=="w"):
+            forward=False
+        if(orient=="north" or orient=="n"):
+            horizontal=False
+        if(orient=="south" or orient=="s"):
+            horizontal=False
+            forward=False
+            
+        super().__init__(x0,y0,horizontal,forward)
+        self.width = width
+        self.name=name
+        self.connector_function=BaseWaveguideConnector
+