def define_ports(self, ports):
ports += [
OpticalPort(position=(0.0, 0.0),
wg_definition=self.wg_definition,
angle=180.0),
OpticalPort(position=(self.wg_length, 0.0),
wg_definition=self.wg_definition,
angle=0.0)
]
return ports
def define_ports(self, prts):
prts += [
OpticalPort(position=(0.0, 0.0),
angle=-180.0,
wg_definition=self.wg_definition),
OpticalPort(position=(self.length, 0.0),
angle=0.0,
wg_definition=self.wg_definition)
]
return prts
def define_ports(self, ports):
# should reflect number of in and outputs in center structure
ports += [
OpticalPort(position=(0.0, ypos),
wg_definition=self.wg_definition,
angle=180.0) for ypos in self.__y_west__
]
ports += [
OpticalPort(position=(self.width, ypos),
wg_definition=self.wg_definition,
angle=180.0) for ypos in self.__y_east__
]
return ports
def define_ports(self, ports):
ports += [
OpticalPort(position=self.p_tr,
wg_definition=self.wg_definitions[0],
angle=45.0 - self.dev_angle),
OpticalPort(position=self.p_br,
wg_definition=self.wg_definitions[0],
angle=315.0 + self.dev_angle),
OpticalPort(position=self.p_l,
wg_definition=self.wg_definitions[1],
angle=180.0)
]
return ports
def define_taper(self) :
tech = get_technology()
if hasattr(tech.PROCESS,'RFC'): # FIXME: dirty modular import
hasraised = True
else:
hasraised = False
# Case: same waveguide definitions ...
if type(self.end_wg_def)==type(self.start_port.wg_definition) :
taper = WgElPortTaperLinear(start_port=self.start_port, end_wg_def=self.end_wg_def, straight_extension=self.straight_extension)
# Case: special tapering structures ...
elif (hasraised and type(self.start_port.wg_definition) == RaisedWGFCWgElDefinition) and (type(self.end_wg_def) == WGFCWgElDefinition) :
taper = RaisedWGFCToWGFCPortTaper(start_port=self.start_port,
end_wg_def=self.end_wg_def,
straight_extension=self.straight_extension)
elif (hasraised and type(self.start_port.wg_definition) == WGFCWgElDefinition) and (type(self.end_wg_def) == RaisedWGFCWgElDefinition) :
#we manually create a new port in the opposite direction and flip the straight_extensions, so that we can use the same class 'RaisedWGFCToWGFCPortTaper'
new_port = OpticalPort(position=(0.0,0.0), wg_definition=self.end_wg_def, angle=self.start_port.angle+180.0)
taper = RaisedWGFCToWGFCPortTaper(start_port=new_port,
end_wg_def=self.start_port.wg_definition,
straight_extension=(self.straight_extension[1], self.straight_extension[0]))
taper = Translation(translation=self.start_position.move_polar_copy(self.length, self.start_port.angle_deg))(taper)
elif (hasraised and type(self.start_port.wg_definition) == RaisedFCWgElDefinition) and (type(self.end_wg_def) == WgElDefinition) :
return RaisedFCToWgElPortTaper(start_port=self.start_port, end_wg_def=self.end_wg_def, straight_extension=self.straight_extension)
elif (hasraised and type(self.start_port.wg_definition) == RaisedWgElDefinition) and (type(self.end_wg_def) == WgElDefinition) :
taper = RaisedWgElToWgElPortTaper(start_port=self.start_port,
end_wg_def=self.end_wg_def,
straight_extension=self.straight_extension)
elif hasraised and (type(self.start_port.wg_definition) == WgElDefinition) :
if type(self.end_wg_def) == RaisedFCWgElDefinition :
#we manually create a new port in the opposite direction and flip the straight_extensions, so that we can use the same class 'RaisedFCToWgElPortTaper'
new_port = OpticalPort(position=(0.0,0.0), wg_definition=self.end_wg_def, angle=self.start_port.angle+180.0)
taper = RaisedFCToWgElPortTaper(start_port=new_port,
end_wg_def=self.start_port.wg_definition,
straight_extension=(self.straight_extension[1], self.straight_extension[0]))
return Translation(translation=self.start_position.move_polar_copy(self.length, self.start_port.angle_deg))(taper)
elif type(self.end_wg_def) == RaisedWgElDefinition :
#we manually create a new port in the opposite direction and flip the straight_extensions, so that we can use the same class 'RaisedWgElToWgElPortTaper'
new_port = OpticalPort(position=(0.0,0.0), wg_definition=self.end_wg_def, angle=self.start_port.angle+180.0)
taper = RaisedWgElToWgElPortTaper(start_port=new_port,
end_wg_def=self.start_port.wg_definition,
straight_extension=(self.straight_extension[1], self.straight_extension[0]))
taper = Translation(translation=self.start_position.move_polar_copy(self.length, self.start_port.angle_deg))(taper)
else :
raise Exception("No taper could be generated between between waveguide types %s and %s." %(self.start_port.wg_definition,self.end_wg_def))
else :
raise Exception("No taper could be generated between between waveguide types %s and %s." %(self.start_port.wg_definition,self.end_wg_def))
if (self.__property_was_externally_set__("length")):
taper.length = self.length
return taper
def add_align(self,
west_east_offset=0.0,
wg_definition=TECH.WGDEF.WIRE,
adapter=None):
struct = Structure(name="Empty_align_WG",
elements=[],
ports=[
OpticalPort(position=(0.0, 0.0),
angle=0.0,
wg_definition=wg_definition),
OpticalPort(position=(0.0, 0.0),
angle=180.0,
wg_definition=wg_definition)
])
self.add(struct, offset=(west_east_offset, 0.0), adapter=adapter)
def define_ports(self, ports):
height = self.wg_definition.wg_width / 2.0 + self.gap_space + self.wg_definition_access.wg_width / 2.
pts = GratingCavity.define_ports(self, 0)
x1 = pts[0].position[0]
x2 = pts[1].position[0]
ports = [
pts[0], pts[1],
OpticalPort(position=(x1, height),
angle=-180.0,
wg_definition=self.wg_definition_access),
OpticalPort(position=(x2, height),
angle=0.0,
wg_definition=self.wg_definition_access)
]
return ports
def define_output(self):
c = self.get_control_shape()
a1 = angle_deg(c[1], c[0])
a2 = angle_deg(c[-2], c[-1])
o = OpticalPort(position=c[-1],
angle=a2,
wg_definition=self.wg_definition)
return o
def define_input(self):
c = Shape(self.shape)
a1 = angle_deg(c[1], c[0])
a2 = angle_deg(c[-2], c[-1])
i = OpticalPort(position=c[0],
angle=a1,
wg_definition=self.wg_definition)
return i
def define_ports(self, ports):
ports += [
OpticalPort(position=self.center.move_copy(
(self.length + self.straight_entrance, 0.0)),
wg_definition=self.start_wg_definition,
angle=0.0)
]
return ports
def define_ports(self, ports):
ports += [
OpticalPort(
position=(self.center[0] + self.taper_length, self.center[1]),
wg_definition=self.wg_definition,
angle=0.0)
]
return ports
def define_ports(self, prts):
from ipkiss.plugins.photonics.port.port import OpticalPort
for coord, angle, wg_def in self.ports_coordinates:
p = OpticalPort(position=(self.pitches[0] * coord[0],
self.pitches[1] * coord[1]),
angle_deg=angle,
wg_definition=wg_def)
prts += p
return prts
def define_ports(self, ports):
# assumes orthogonality """
ports += [
OpticalPort(wg_definition=self.wg_definition,
position=(-0.5 * self.length - self.straight_stub,
0.0),
angle=180),
OpticalPort(wg_definition=self.wg_definition,
position=(0.5 * self.length + self.straight_stub, 0.0),
angle=0),
OpticalPort(wg_definition=self.wg_definition,
position=(0.0, 0.5 * self.length + self.straight_stub),
angle=90),
OpticalPort(wg_definition=self.wg_definition,
position=(0.0,
-0.5 * self.length - self.straight_stub),
angle=-90)
]
return ports
def define_ports(self, prts):
wg_def = WgElDefinition(wg_width=self.wg_def_start.wg_width,
trench_width=self.wg_def_start.trench_width,
process=self.process)
prts += [
OpticalPort(position=(self.tip_length + self.tip_offset, 0.0),
angle=0.0,
wg_definition=wg_def)
]
return prts
def define_start_coords_end_coords(self):
start_coords = OpticalPortList()
end_coords = OpticalPortList()
for p in self.fibcoup.optical_ports:
start_coords += p
end_coords += OpticalPort(position=p.position.move_polar_copy(
self.taper_length, p.angle_deg),
wg_definition=self.wg_definition,
angle=p.angle_deg)
return (start_coords, end_coords)
def define_points(self, pts):
# there are quite some cases to take into account here
angle = (
self.angle_out - self.input_port.angle_deg + 180.0
) % 360.0 - 180.0 #the difference between the angles 'angle_out' and 'angle_deg' (normalized between -180 and +180), to know if the bend is to be made in negative or positive sense
bs1, bs2 = self.get_bend_size(angle)
min_dist = bs1 + self.start_straight #compute from min_straight (equals min-straight if not explicitely overruled)
P1 = self.input_port.position.move_polar_copy(
bs1, self.input_port.angle_deg
) #start point of connecting line (not necessarily used later on)
#above move_polar_copy statement to be checked : should L become min_dist ?
line = straight_line_from_point_angle(
self.line_point, self.angle_out
) #reference line going through 'line_point' with angle 'angle_out'
line2 = straight_line_from_point_angle(
self.input_port.position, self.input_port.angle_deg
) #line going through 'input_port' with angle 'angle_deg'
if line.is_parallel(line2):
# parallel or coinciding
bs1, bs2 = self.get_bend90_size()
if line == line2:
pts.append(self.input_port.position)
if (self.input_port.angle_deg - self.angle_out) % 360.0 < 0.1:
# same direction: min_straight
pts = points_add_polar(
pts, max(self.start_straight, self.end_straight),
self.angle_out)
else:
# opposite_direction: U-turn
pts = points_add_polar(pts, self.start_straight + bs1,
self.input_port.angle_deg)
pts = points_add_polar(pts, bs1 + bs2 + self.min_straight,
self.input_port.angle_deg + 90.0)
pts = points_add_polar(
pts, bs1 + bs2 +
max(self.min_straight, self.start_straight),
self.input_port.angle_deg + 180.0)
pts = points_add_polar(pts, bs1 + bs2 + self.min_straight,
self.input_port.angle_deg + 270.0)
pts = points_add_polar(pts, bs2 + self.end_straight,
self.angle_out)
else:
D = line.distance(self.input_port.position)
if (self.input_port.angle_deg - self.angle_out) % 360.0 < 0.1:
# same direction
P = RouteToParallelLine(
input_port=self.input_port,
line_point=self.line_point,
max_s_bend_angle=self.max_s_bend_angle,
bend_radius=self.bend_radius,
rounding_algorithm=self.rounding_algorithm,
min_straight=self.min_straight)
P.start_straight = self.start_straight
P.end_straight = self.end_straight
pts += P
elif D - (bs1 + bs2 +
self.min_straight) >= -0.1 / get_grids_per_unit():
# sufficient distance
pts.append(self.input_port.position)
pts = points_add_polar(pts, self.start_straight + bs1,
self.input_port.angle_deg)
pts.append(line.closest_point(pts[-1]))
pts = points_add_polar(pts, self.end_straight + bs2,
self.angle_out)
else:
# insufficient distance
pts.append(self.input_port.position)
pts = points_add_polar(pts, self.start_straight + bs1,
self.input_port.angle_deg)
A = angle_deg(line.closest_point(self.input_port.position),
self.input_port.position)
pts = points_add_polar(pts, bs1 + bs2 + self.min_straight,
A)
P2 = Coord2(pts[-1][0],
pts[-1][1]).move_polar(bs2 + self.min_straight,
self.angle_out)
P = RouteToParallelLine(
input_port=OpticalPort(
position=P2,
wg_definition=self.input_port.wg_definition,
angle=self.angle_out),
line_point=self.line_point,
max_s_bend_angle=self.max_s_bend_angle,
bend_radius=self.bend_radius,
min_straight=self.min_straight,
rounding_algorithm=self.rounding_algorithm)
P.start_straight = 0.0
P.end_straight = self.end_straight
pts += P
else:
# not parallel
bs1, bs2 = self.get_bend_size(angle)
i = line.intersection(line2)
Di = distance(i, self.input_port.position)
D = line.distance(self.input_port.position)
angle_diff = abs((angle_deg(i, self.input_port.position) -
self.input_port.angle_deg + 180.0) % 360.0 -
180.0)
if (Di - min_dist) >= 0 and angle_diff < 0.1:
if self.min_straight >= (
Di - min_dist
) or self.max_s_bend_angle < abs(angle) <= 90.0:
# simple case: just a single bend
pts.append(self.input_port.position)
pts.append(i)
pts = points_add_polar(pts, bs2 + self.end_straight,
self.angle_out)
else:
pts.append(self.input_port.position)
# extra S-bend to shorten path: difficult
# check maximum angle:
s = self.min_straight
st = self.start_straight
R = self.bend_radius
a_2 = sign(angle) * self.max_s_bend_angle
a_1 = angle - a_2
L1_1, L1_2 = self.get_bend_size(a_1)
L2_1, L2_2 = self.get_bend_size(a_2)
P1 = self.input_port.position.move_polar_copy(
st + L1_1, self.input_port.angle_deg)
line3 = straight_line_from_point_angle(
P1, self.input_port.angle_deg + a_1)
P2 = line.intersection(line3)
if distance(P2, P1) < L1_2 + L2_1 + s:
##a_2 = sign(a_2) * min(abs(a_2), self.max_s_bend_angle)
if abs(angle) >= self.max_s_bend_angle:
angle_range = [abs(angle)]
else:
angle_range = arange(
self.max_s_bend_angle, abs(angle),
-(self.max_s_bend_angle - abs(angle)) / 30.0)
for A in angle_range:
a_2 = sign(angle) * A
a_1 = angle - a_2
L1_1, L1_2 = self.get_bend_size(a_1)
L2_1, L2_2 = self.get_bend_size(a_2)
P = self.input_port.position.move_polar_copy(
st + L1_1, self.input_port.angle_deg)
line3 = straight_line_from_point_angle(
P1, self.input_port.angle_deg + a_1)
P2 = line.intersection(line3)
if distance(P2, P1) >= L1_2 + L2_1 + s:
break
pts.extend([P1, P2])
pts = points_add_polar(pts, L2_2 + self.end_straight,
self.angle_out)
else:
pts.append(self.input_port.position)
pts = points_add_polar(pts, self.start_straight + bs1,
self.input_port.angle_deg)
P2 = Coord2(pts[-1][0],
pts[-1][1]).move_polar(bs2, self.angle_out)
P = RouteToParallelLine(
input_port=OpticalPort(
position=P2,
wg_definition=self.input_port.wg_definition,
angle=self.angle_out),
line_point=self.line_point,
max_s_bend_angle=self.max_s_bend_angle,
bend_radius=self.bend_radius,
min_straight=self.min_straight,
rounding_algorithm=self.rounding_algorithm,
start_straight=self.min_straight,
end_straight=self.end_straight)
pts.extend(P)
return pts
