def define_elements(self, elems):
from ipkiss.plugins.photonics.routing.connect import RouteConnectorRounded
r1, r2 = self.get_waveguide_routes()
elems += RouteConnectorRounded(route=r1)
elems += RouteConnectorRounded(route=r2)
return elems
def define_connectors_splitter_transforms(self):
T = -Translation(self.splitter.in_ports[0].position)
#T = -Translation((0.0,0.0))
splitter_transforms = [T]
P = self.splitter.out_ports.y_sorted().transform_copy(T)
connectors = [[RouteConnectorRounded(RouteToEastAtY(input_port = P[0], y_position = -0.5*self.y_spacing)),
RouteConnectorRounded(RouteToEastAtY(input_port = P[1], y_position = 0.5*self.y_spacing))]]
return (connectors, splitter_transforms)
def define_patches_connectors_splitter_transforms(self):
N = 2**self.branch_level
L = self.splitter.out_ports.size_info(
).east - self.splitter.in_ports.size_info().west
T = [Translation(-self.splitter.in_ports[0].position)]
splitter_transforms = []
splitter_transforms += T
connectors = []
patches = []
for i in range(self.branch_level):
C = []
P = []
T2 = []
Y = 0.5 * self.y_spacing * 2**(self.branch_level - i)
for t in T:
P_out = self.splitter.out_ports.y_sorted().transform_copy(t)
P_in = self.splitter.in_ports.transform_copy(t)
c1 = RouteConnectorRounded(
RouteToEastAtY(input_port=P_out[0],
y_position=P_in[0].y - 0.5 * Y))
c2 = RouteConnectorRounded(
RouteToEastAtY(input_port=P_out[1],
y_position=P_in[0].y + 0.5 * Y))
C += [c1, c2]
# patch sharp angle between connectors
c1i = c1.in_ports[0]
c2i = c2.in_ports[0]
c1o = c1.out_ports[0]
c2o = c2.out_ports[0]
xl = min(c1i.position.x,
c2i.position.x) + 0.5 * c1.shape.start_straight
yl = 0.5 * (c1i.position.y + c2i.position.y)
xr = max(c1o.position.x,
c2o.position.x) - 0.5 * c1.shape.end_straight
wp = abs(c2o.position.y - c1o.position.y) + 0.5 * (
c1o.wg_definition.wg_width + c2o.wg_definition.wg_width
) + c1o.wg_definition.trench_width + c2o.wg_definition.trench_width
## patches necessary??? probably depends on the splitter you take
#P += [Line(layer=PPLayer(self.splitter.wg_definition.process, TECH.PURPOSE.LF_AREA),begin_coord=(xl,yl),end_coord=(xr,yl),line_width=wp)]
if i < self.branch_level - 1:
T2 += [
Translation(
coord2_match_position(self.splitter.in_ports[0],
c1.out_ports[0])),
Translation(
coord2_match_position(self.splitter.in_ports[0],
c2.out_ports[0]))
]
connectors += [C]
patches += [P]
splitter_transforms += T2
T = T2
return (patches, connectors, splitter_transforms)
def define_elements(self, elems):
t1, t2 = self.get_transformations()
# Single References (SREF) place a copy of the layout at a given position with
# transformation. This is a reference copy, so the layout data is not duplicated.
elems += SRef(reference=self.ring1, transformation=t1)
elems += SRef(reference=self.ring2, transformation=t2)
# add the routes
from ipkiss.plugins.photonics.routing.connect import RouteConnectorRounded
for r in self.get_routes():
elems += RouteConnectorRounded(route=r)
return elems
def define_elements(self, elems):
from ipkiss.plugins.photonics.routing.connect import RouteConnectorRounded
for r in self.get_routes():
elems += RouteConnectorRounded(route=r)
#calculate additional transformation to put the structure in place.
structure_transform = vector_match_transform(
self.structure.ports[self.port_labels[0]].transform_copy(
self.structure_transformation),
self.get_routes()[0].ports[-1])
elems += SRef(reference=self.structure,
transformation=self.structure_transformation +
structure_transform)
return elems
def define_elements(self, elems):
# go over ports
for i in range(len(self.struct_west_ports)):
ip = self.struct_west_ports[i]
# position tapers
t_pos = (ip.position[0] - self.connect_length, self.__y_west__[i])
T = WgElTaperLinear(start_position=t_pos,
end_position=(t_pos[0] - self.taper_length,
t_pos[1]),
start_wg_def=ip.wg_definition,
end_wg_def=self.wg_definition)
elems += T
# draw straight waveguides
elems += self.wg_definition(
shape=[T.west_ports[0].position, (0.0, t_pos[1])])
# generic connector between structure port and taper port
R = RouteToWestAtY(input_port=ip,
y_position=T.east_ports[0].y,
bend_radius=self.bend_radius,
min_straight=self.minimum_straight,
rounding_algorithm=self.rounding_algorithm)
R.end_straight += R.out_ports[0].x - T.east_ports[0].x
elems += RouteConnectorRounded(R)
#blocking trenches
elems += Line(
PPLayer(self.wg_definition.process, TECH.PURPOSE.DF.TRENCH),
(self.block_trench_position,
0.5 * self.wg_definition.wg_width +
self.wg_definition.trench_width),
(self.block_trench_position, 0.5 * self.y_spacing),
self.block_trench_width)
elems += Line(
PPLayer(self.wg_definition.process, TECH.PURPOSE.DF.TRENCH),
(self.block_trench_position,
-0.5 * self.wg_definition.wg_width -
self.wg_definition.trench_width),
(self.block_trench_position, -0.5 * self.y_spacing),
self.block_trench_width)
for i in range(len(self.struct.east_ports)):
op = self.struct_east_ports[i]
# position tapers
t_pos = (op.position[0] + self.connect_length, self.__y_east__[i])
T = WgElTaperLinear(start_position=t_pos,
end_position=(t_pos[0] + self.taper_length,
t_pos[1]),
start_wg_def=op.wg_definition,
end_wg_def=self.wg_definition)
elems += T
# draw straight waveguides
elems += self.wg_definition(
shape=[T.east_ports[0].position, (self.width, t_pos[1])])
# generic connector between structure port and taper port
R = RouteToEastAtY(input_port=ip,
y_position=T.west_ports[0].y,
bend_radius=self.bend_radius,
min_straight=self.minimum_straight,
rounding_algorithm=self.rounding_algorithm)
R.end_straight += -R.out_ports[0].x + T.west_ports[0].x
elems += RouteConnectorRounded(R)
return elems
def define_elements(self, elems):
from ipkiss.plugins.photonics.routing.connect import RouteConnectorRounded
elems += RouteConnectorRounded(route=self.get_route())
return elems
