S-bend waveguide in MEEP

[satadrudas]

Hi, is there any proper way to construct a S-bend waveguide in MEEP ? I tried a rather brute force way and it seems to work but I am hoping that there might be a better and more tidy way.

The following is the code for the S-bend I wrote:

geometry=[]

# the following functions are to be appended to an empty geometry=[]

class center():
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z


def s_bend_parameters_extraction(block_width=1,block_height=1, waveguide_width=0.5,mid_section_waveguide_length=0):
     # this function is used for extracting the bend_radius and turn angle if the block height and width are given

    #diagonal across the quadrant and 2r*sin(theta)=block_width

    turn_angle=2*(np.pi/2 - np.arctan(block_width/(block_height-waveguide_width)))
    bend_radius=block_width/(2*np.sin(turn_angle))

    return bend_radius, turn_angle    



def s_bend(design=0,center=center(0,0,0),bend_radius=5, turn_angle=np.pi/2,mid_section_waveguide_length=0, waveguide_width=0.5, waveguide_height=0.22, waveguide_material=mp.Medium(index=3.45), cladding_material=mp.air):

    # design 0 is for top eft to bottom right, and 1 is for bottom left to top right
    
    block_height= mid_section_waveguide_length * np.sin(turn_angle) + 2*(bend_radius - bend_radius*np.cos(turn_angle)) + waveguide_width
    block_width= mid_section_waveguide_length * np.cos(turn_angle) + 2* bend_radius* np.sin(turn_angle)  


    # inner_circle_x=r*sin(theta)
    # inner_circle_y=r*cos(theta)
    # y is given, so x = r*sin(cosinv(y/r))

    # ____________
    # |          |
    # |   /      |
    # |_ /_______|
    # | /
    # |/


    #the main block
    geometry.append(mp.Block(material=waveguide_material, center=mp.Vector3(center.x,center.y,center.z), size=mp.Vector3(block_width, block_height, waveguide_height)))

    offset=waveguide_width *np.cos(turn_angle)/2

    if(design==0):

        #top left inner circle
        y=0
        inner_bend_radius=bend_radius-waveguide_width/2
        while(y+(inner_bend_radius)*np.cos(turn_angle) < inner_bend_radius):
            x = inner_bend_radius * np.sin(np.arccos((y+(inner_bend_radius)*np.cos(turn_angle)  )/inner_bend_radius))
            geometry.append(mp.Block(material=cladding_material, center=mp.Vector3(-(block_width/2)+(x)/2+center.x,y+center.y-offset,center.z), size=mp.Vector3(x,1/resolution,waveguide_height)))
            y=y+1/(2*resolution) # this multiplying by 2 removes the black strip  error

        # bottom right inner circle
        y=0
        inner_bend_radius=bend_radius-waveguide_width/2
        while(y+(inner_bend_radius)*np.cos(turn_angle) < inner_bend_radius):
            x = inner_bend_radius * np.sin(np.arccos((y+(inner_bend_radius)*np.cos(turn_angle)  )/inner_bend_radius))
            geometry.append(mp.Block(material=cladding_material, center=mp.Vector3((block_width/2)-(x)/2+center.x,-y+center.y+offset,center.z), size=mp.Vector3(x,1/resolution,waveguide_height)))
            y=y+1/(2*resolution) # this multiplying by 2 removes the black strip  error  

        # top right outer portion
        y=0
        outer_bend_radius=bend_radius+waveguide_width/2
        while(y+(outer_bend_radius)*np.cos(turn_angle) < outer_bend_radius):
            x = block_width - (outer_bend_radius * np.sin(np.arccos((y+(outer_bend_radius)*np.cos(turn_angle)  )/outer_bend_radius)))
            geometry.append(mp.Block(material=cladding_material, center=mp.Vector3((block_width/2)-(x)/2+center.x,y+center.y+offset,center.z), size=mp.Vector3(x,1/resolution,waveguide_height)))
            y=y+1/(2*resolution) # this multiplying by 2 removes the black strip  error

        # bottom left outer portion
        y=0
        outer_bend_radius=bend_radius+waveguide_width/2
        while(y+(outer_bend_radius)*np.cos(turn_angle) < outer_bend_radius):
            x = block_width - (outer_bend_radius * np.sin(np.arccos((y+(outer_bend_radius)*np.cos(turn_angle)  )/outer_bend_radius)))
            geometry.append(mp.Block(material=cladding_material, center=mp.Vector3(-(block_width/2)+(x)/2+center.x,-y+center.y-offset,center.z), size=mp.Vector3(x,1/resolution,waveguide_height)))
            y=y+1/(2*resolution) # this multiplying by 2 removes the black strip  error

        
        # adding a strip at the end for the edge dots
        
        y=-block_height/2+waveguide_width+(block_height-waveguide_width)/2
        geometry.append(mp.Block(material=cladding_material, center=mp.Vector3((block_width/2)+center.x,y+center.y,center.z), size=mp.Vector3(1/resolution,block_height-waveguide_width,waveguide_height)))

        y=block_height/2-waveguide_width-(block_height-waveguide_width)/2
        geometry.append(mp.Block(material=cladding_material, center=mp.Vector3(-(block_width/2)+center.x,y+center.y,center.z), size=mp.Vector3(1/resolution,block_height-waveguide_width,waveguide_height)))

    


    #reference waveguide
    # xx=4
    # geometry.append (mp.Block(center=mp.Vector3(-(block_width/2+xx/2)-2/resolution,block_height/2-waveguide_width/2,0),
    #                     size=mp.Vector3(xx,waveguide_width,waveguide_height),
    #                     material=Si))

    if(design==1):


        # bottom left inner circle
        y=0
        inner_bend_radius=bend_radius-waveguide_width/2
        while(y+(inner_bend_radius)*np.cos(turn_angle) < inner_bend_radius):
            x = inner_bend_radius * np.sin(np.arccos((y+(inner_bend_radius)*np.cos(turn_angle)  )/inner_bend_radius))
            geometry.append(mp.Block(material=cladding_material, center=mp.Vector3(-(block_width/2)+(x)/2+center.x,-y+center.y+offset,center.z), size=mp.Vector3(x,1/resolution,waveguide_height)))
            y=y+1/(2*resolution)   


        # top right inner circle
        y=0
        inner_bend_radius=bend_radius-waveguide_width/2
        while(y+(inner_bend_radius)*np.cos(turn_angle) < inner_bend_radius):
            x = inner_bend_radius * np.sin(np.arccos((y+(inner_bend_radius)*np.cos(turn_angle)  )/inner_bend_radius))
            geometry.append(mp.Block(material=cladding_material, center=mp.Vector3((block_width/2)-(x)/2+center.x,y+center.y-offset,center.z), size=mp.Vector3(x,1/resolution,waveguide_height)))
            y=y+1/(2*resolution)

        # top left outer portion
        y=0
        outer_bend_radius=bend_radius+waveguide_width/2
        while(y+(outer_bend_radius)*np.cos(turn_angle) < outer_bend_radius):
            x = block_width - (outer_bend_radius * np.sin(np.arccos((y+(outer_bend_radius)*np.cos(turn_angle)  )/outer_bend_radius)))
            geometry.append(mp.Block(material=cladding_material, center=mp.Vector3(-(block_width/2)+(x)/2+center.x,y+center.y+offset,center.z), size=mp.Vector3(x,1/resolution,waveguide_height)))
            y=y+1/(2*resolution) # this multiplying by 2 removes the black strip  error

        # bottom right outer portion
        y=0
        outer_bend_radius=bend_radius+waveguide_width/2
        while(y+(outer_bend_radius)*np.cos(turn_angle) < outer_bend_radius):
            x = block_width - (outer_bend_radius * np.sin(np.arccos((y+(outer_bend_radius)*np.cos(turn_angle)  )/outer_bend_radius)))
            geometry.append(mp.Block(material=cladding_material, center=mp.Vector3((block_width/2)-(x)/2+center.x,-y+center.y-offset,center.z), size=mp.Vector3(x,1/resolution,waveguide_height)))
            y=y+1/(2*resolution) # this multiplying by 2 removes the black strip  error   

        # adding a strip at the end for the edge dots
        y=block_height/2-waveguide_width-(block_height-waveguide_width)/2
        geometry.append(mp.Block(material=cladding_material, center=mp.Vector3((block_width/2)+center.x,y+center.y,center.z), size=mp.Vector3(1/resolution,block_height-waveguide_width,waveguide_height)))

        y=-block_height/2+waveguide_width+(block_height-waveguide_width)/2
        geometry.append(mp.Block(material=cladding_material, center=mp.Vector3(-(block_width/2)+center.x,y+center.y,center.z), size=mp.Vector3(1/resolution,block_height-waveguide_width,waveguide_height)))

    




    

[satadrudas]

Atleast the simulation seems to work fine:

[stevengj]

Probably better to use a Prism object.

[satadrudas]

checked the prism class just now. Yeah that would be more efficient. Thanks

[smartalecH]

I typically use something like gdspy to define the s-bend or whatever. Then I pull the vertices and represent that in meep using a prism object.

gdsfactory has a lot of this automated, actually.

[satadrudas]

thanks, will check them out.