def init_primitives(self):
R_index = 0
L_index = 0
origin = DPoint(0,0)
prev_primitive_end = origin
prev_primitive_end_angle = 0
for i, symbol in enumerate(self._shape_string):
if( symbol == 'R' ):
if( self._turn_angles[R_index] > 0 ):
turn_radius = self._turn_radiuses[R_index]
else:
turn_radius =-self._turn_radiuses[R_index]
cpw_arc = CPW_arc(self._cpw_parameters[i], prev_primitive_end,
turn_radius, self._turn_angles[R_index],
trans_in = DCplxTrans(1, prev_primitive_end_angle*180/pi, False, 0, 0))
self.primitives["arc_"+str(R_index)] = cpw_arc
R_index += 1
elif symbol == 'L':
# Turns are reducing segments' lengths so as if there were no roundings at all
# next 'R' segment if exists
if( i+1 < self._N_elements
and self._shape_string[i+1] == 'R'
and abs(self._turn_angles[R_index]) < pi ):
coeff = abs(tan(self._turn_angles[R_index]/2))
self._segment_lengths[L_index] -= self._turn_radiuses[R_index]*coeff
# previous 'R' segment if exists
if( i-1 > 0
and self._shape_string[i-1] == 'R'
and abs(self._turn_angles[R_index-1]) < pi ):
coeff = abs(tan(self._turn_angles[R_index-1]/2))
self._segment_lengths[L_index] -= self._turn_radiuses[R_index-1]*coeff
#if( self._segment_lengths[L_index] < 0 ):
# print(self._segment_lengths[L_index])
# print("CPW_RL_Path warning: segment length is less than zero")
# print("L_index = {}".format(L_index))
cpw = CPW(self._cpw_parameters[i].width, self._cpw_parameters[i].gap,
prev_primitive_end, prev_primitive_end + DPoint(self._segment_lengths[L_index], 0),
trans_in=DCplxTrans(1, prev_primitive_end_angle*180/pi, False, 0, 0))
self.primitives["cpw_"+str(L_index)] = cpw
L_index += 1
primitive = list(self.primitives.values())[i]
prev_primitive_end = primitive.end
prev_primitive_end_angle = primitive.alpha_end
self.connections = [origin, list(self.primitives.values())[-1].end]
self.angle_connections = [0, list(self.primitives.values())[-1].alpha_end]
def _init_primitives_trans(self):
self.init_primitives() # must be implemented in every subclass
dr_origin = DSimplePolygon([DPoint(0, 0)])
if (self.DCplxTrans_init is not None):
# constructor trans displacement
dCplxTrans_temp = DCplxTrans(1, 0, False,
self.DCplxTrans_init.disp)
for element in self.primitives.values():
element.make_trans(dCplxTrans_temp)
dr_origin.transform(dCplxTrans_temp)
self._update_connections(dCplxTrans_temp)
self._update_alpha(dCplxTrans_temp)
# rest of the constructor trans functions
dCplxTrans_temp = self.DCplxTrans_init.dup()
dCplxTrans_temp.disp = DPoint(0, 0)
for element in self.primitives.values():
element.make_trans(dCplxTrans_temp)
dr_origin.transform(dCplxTrans_temp)
self._update_connections(dCplxTrans_temp)
self._update_alpha(dCplxTrans_temp)
dCplxTrans_temp = DCplxTrans(1, 0, False, self.origin)
for element in self.primitives.values():
element.make_trans(dCplxTrans_temp) # move to the origin
self._update_connections(dCplxTrans_temp)
self._update_alpha(dCplxTrans_temp)
self.origin += dr_origin.point(0)
# FOLLOWING CYCLE GIVES WRONG INFO ABOUT FILLED AND ERASED AREAS
for element in self.primitives.values():
self.metal_region += element.metal_region
self.empty_region += element.empty_region
def init_primitives(self): origin = DPoint(0, 0) transition_end = origin + DPoint(self.transition_length, 0) alpha = self.z0_cpw.angle_connections[1] self.transition_cpw2cpw = CPW2CPW( self.z0_cpw, self.z1_params, origin, transition_end, trans_in=DCplxTrans(1, degrees(alpha), False, 0, 0) ) self.primitives["transition_cpw2cpw"] = self.transition_cpw2cpw z1_cpw_end = self.transition_cpw2cpw.end + DPoint(self.z1_length, 0) self.z1_cpw = CPW(cpw_params=self.z1_params, start=self.transition_cpw2cpw.end, end=z1_cpw_end, trans_in=DCplxTrans(1, degrees(alpha), False, 0, 0)) self.primitives["z1_cpw"] = self.z1_cpw # open-ended self.z1_cpw_open_end = CPW( 0, gap=self.z1_params.b / 2, start=self.z1_cpw.end, end=self.z1_cpw.end + DPoint(self.z1_params.b / 2, 0), trans_in=DCplxTrans(1, degrees(alpha), False, 0, 0) ) self.primitives["z1_cpw_open_end"] = self.z1_cpw_open_end self.connections = [self.transition_cpw2cpw.start, self.z1_cpw.end]
def init_primitives(self):
R_index = 0
L_index = 0
origin = DPoint(0, 0)
# placing the first element
symbol_0 = self.RL_str[0]
if (symbol_0 == 'R'):
self.primitives["arc_0"] = CPW_arc(self.Z_list[0], origin,
self.R_list[0],
self.delta_alpha_list[0])
R_index += 1
elif (symbol_0 == 'L'):
self.primitives["cpw_0"] = CPW(
self.Z_list[0].width, self.Z_list[0].gap, self.start,
self.start + DPoint(self.L_list[0], 0))
L_index += 1
for i, symbol in enumerate(self.RL_str):
if (i == 0):
continue
prev_primitive = list(self.primitives.values())[i - 1]
if (symbol == 'R'):
if (self.delta_alpha_list[R_index] > 0):
sgn = 1
else:
sgn = -1
R = self.R_list[R_index] * sgn
delta_alpha = self.delta_alpha_list[R_index]
cpw_arc = CPW_arc(self.Z_list[i],
prev_primitive.end,
R,
delta_alpha,
trans_in=DCplxTrans(
1, prev_primitive.alpha_end * 180 / pi,
False, 0, 0))
self.primitives["arc_" + str(R_index)] = cpw_arc
R_index += 1
elif (symbol == 'L'):
cpw = CPW(self.Z_list[i].width,
self.Z_list[i].gap,
prev_primitive.end,
prev_primitive.end + DPoint(self.L_list[L_index], 0),
trans_in=DCplxTrans(
1, prev_primitive.alpha_end * 180 / pi, False, 0,
0))
self.primitives["cpw_" + str(L_index)] = cpw
L_index += 1
def __init__(self, origin, trans_in=None, inverse=False):
## MUST BE IMPLEMENTED ##
self.connections = [] # DPoint list with possible connection points
self.connection_edges = [
] # indexes of edges that are intended to connect to other polygons
# indexes in "self.connection_edges" where Sonnet ports
# should be placed
self.sonnet_port_connections = []
self.angle_connections = [] # list with angle of connecting elements
## MUST BE IMLPEMENTED END ##
self.connection_ptrs = [
] # pointers to connected structures represented by their class instances
self.origin = origin
self.inverse = inverse
# TODO: after Region.insert() and/or? metal_region + other_region
# there is width problem that initial region has dimensions
# Region().bbox() = ((-1,-1,1,1)) or something like that
# Hence, if you wish to take Region.bbox() of the resulting region
# You will get incorrect value due to initial region having
# something "blank" at the creation moment. This may be solved
# by either shrinking resulting region to shapes it contains,
# or by refusing of usage of empty `Region()`s
self.metal_region = Region()
self.empty_region = Region()
self.metal_regions = OrderedDict()
self.empty_regions = OrderedDict()
self.metal_regions["default"] = self.metal_region
self.empty_regions["default"] = self.empty_region
self.metal_region.merged_semantics = True
self.empty_region.merged_semantics = True
self.DCplxTrans_init = None
self.ICplxTrans_init = None
if (trans_in is not None):
# TODO: update with Klayouts new rules.
# if( isinstance( trans_in, ICplxTrans ) ): <==== FORBIDDEN
if (isinstance(trans_in, DCplxTrans)):
self.DCplxTrans_init = trans_in
self.ICplxTrans_init = ICplxTrans().from_dtrans(trans_in)
elif (isinstance(trans_in, CplxTrans)):
self.DCplxTrans_init = DCplxTrans().from_itrans(trans_in)
self.ICplxTrans_init = ICplxTrans().from_trans(trans_in)
elif (isinstance(trans_in, DTrans)):
self.DCplxTrans_init = DCplxTrans(trans_in, 1)
self.ICplxTrans_init = ICplxTrans(
Trans().from_dtrans(trans_in), 1)
elif (isinstance(trans_in, Trans)):
self.DCplxTrans_init = DCplxTrans(
DTrans().from_itrans(trans_in), 1)
self.ICplxTrans_init = ICplxTrans(trans_in, 1)
elif (isinstance(trans_in, ICplxTrans)):
# not tested 14.08.2021
self.DCplxTrans_init = DCplxTrans(trans_in)
self.ICplxTrans_init = trans_in
self._geometry_parameters = OrderedDict()
self._init_regions_trans()
def init_regions(self):
self.connections = [DPoint(0, 0), self.dr]
self.start = DPoint(0, 0)
self.end = self.start + self.dr
alpha = atan2(self.dr.y, self.dr.x)
self.angle_connections = [alpha, alpha]
alpha_trans = ICplxTrans().from_dtrans(
DCplxTrans(1, alpha * 180 / pi, False, self.start))
metal_poly = DSimplePolygon([
DPoint(0, -self.width / 2),
DPoint(self.dr.abs(), -self.width / 2),
DPoint(self.dr.abs(), self.width / 2),
DPoint(0, self.width / 2)
])
self.connection_edges = [3, 1]
self.metal_region.insert(pya.SimplePolygon().from_dpoly(metal_poly))
if (self.gap != 0):
self.empty_region.insert(
pya.Box(
Point().from_dpoint(DPoint(0, self.width / 2)),
Point().from_dpoint(
DPoint(self.dr.abs(), self.width / 2 + self.gap))))
self.empty_region.insert(
pya.Box(
Point().from_dpoint(DPoint(0, -self.width / 2 - self.gap)),
Point().from_dpoint(DPoint(self.dr.abs(),
-self.width / 2))))
self.metal_region.transform(alpha_trans)
self.empty_region.transform(alpha_trans)
def init_primitives(self):
origin = DPoint(0, 0)
# square box that clears out the area of the mark
self.primitives["empty_box"] = Rectangle(DPoint(
-self.leaf_outer, -self.leaf_outer),
2 * self.leaf_outer,
2 * self.leaf_outer,
inverse=True)
self.primitives["cross"] = Cross(
DPoint(-self.cross_out_a / 2, -self.cross_out_a / 2),
self.cross_in_a, self.cross_out_a)
Z = CPWParameters(self.leaf_outer - self.leaf_inner, 0)
for i in range(self.leafs_N):
start_angle = i * (self.leaf_angle +
self.empty_leaf_angle) - self.leaf_angle / 2
trans = DCplxTrans(1, start_angle + 90, False, 0, -self.avg_r)
self.primitives["leaf_" + str(i)] = CPW_arc(Z,
origin,
self.avg_r,
self.leaf_angle * pi /
180,
trans_in=trans)
Z_empty = CPWParameters(0, self.empty_rings_width / 2)
for i in range(1, self.empty_rings_N + 1):
r = self.leaf_inner + (self.leaf_outer - self.leaf_inner) / (
self.empty_rings_N + 1) * i
self.primitives["empty_ring_" + str(i)] = CPW_arc(
Z_empty, DVector(0, -r), r, 2 * pi)
def __init__(self,
Z0,
start,
L_coupling,
L1,
r,
L2,
N,
gnd_width,
trans_in=None):
self.Z0 = Z0
self.gnd_width = gnd_width
self.L_coupling = L_coupling
self.L1 = L1
self.r = r
self.L2 = L2
self.N = N
self.primitives_gnd = {}
super(EMResonator_TL2Qbit_worm, self).__init__(start, trans_in)
self.init_primitives_gnd_trans()
self.gnd_reg = Region()
for elem in self.primitives_gnd.values():
self.gnd_reg = self.gnd_reg + elem.metal_region
for i in range(self.N):
for elem in self.primitives["coil" +
str(i + 1)].primitives_gnd.values():
elem.make_trans(self.DCplxTrans_init)
elem.make_trans(DCplxTrans(1, 0, False, self.origin))
self.gnd_reg = self.gnd_reg + elem.metal_region
self.start = self.connections[0]
self.end = self.connections[-1]
self.dr = self.end - self.start
self.alpha_start = self.angle_connections[0]
self.alpha_end = self.angle_connections[1]
def init_regions(self):
self.connections = [DPoint(0, 0), DPoint(self.dr.abs(), 0)]
self.angle_connections = [0, 0]
alpha = atan2(self.dr.y, self.dr.x)
self.angle_connections = [alpha, alpha]
alpha_trans = DCplxTrans(1, alpha * 180 / pi, False, 0, 0)
m_poly = DSimplePolygon([
DPoint(0, -self.Z0.width / 2),
DPoint(self.dr.abs(), -self.Z1.width / 2),
DPoint(self.dr.abs(), self.Z1.width / 2),
DPoint(0, self.Z0.width / 2)
])
e_poly1 = DSimplePolygon([
DPoint(0, -self.Z0.b / 2),
DPoint(self.dr.abs(), -self.Z1.b / 2),
DPoint(self.dr.abs(), -self.Z1.width / 2),
DPoint(0, -self.Z0.width / 2)
])
e_poly2 = DSimplePolygon([
DPoint(0, self.Z0.b / 2),
DPoint(self.dr.abs(), self.Z1.b / 2),
DPoint(self.dr.abs(), self.Z1.width / 2),
DPoint(0, self.Z0.width / 2)
])
m_poly.transform(alpha_trans)
e_poly1.transform(alpha_trans)
e_poly2.transform(alpha_trans)
self.metal_region.insert(SimplePolygon.from_dpoly(m_poly))
self.empty_region.insert(SimplePolygon.from_dpoly(e_poly1))
self.empty_region.insert(SimplePolygon.from_dpoly(e_poly2))
def init_regions(self):
self.metal_regions["photo"] = Region()
self.empty_regions["photo"] = Region()
self.connections = [DPoint(0, 0), self.dr]
self.start = DPoint(0, 0)
self.end = self.start + self.dr
alpha = atan2(self.dr.y, self.dr.x)
self.angle_connections = [alpha, alpha]
alpha_trans = ICplxTrans().from_dtrans(
DCplxTrans(1, alpha * 180 / pi, False, self.start))
self.metal_regions['photo'].insert(
pya.Box(Point().from_dpoint(DPoint(0, -self.width / 2)),
Point().from_dpoint(DPoint(self.dr.abs(),
self.width / 2))))
self.empty_regions['photo'].insert(
pya.Box(
Point().from_dpoint(DPoint(0, self.width / 2)),
Point().from_dpoint(
DPoint(self.dr.abs(), self.width / 2 + self.gap))))
self.empty_regions['photo'].insert(
pya.Box(
Point().from_dpoint(DPoint(0, -self.width / 2 - self.gap)),
Point().from_dpoint(DPoint(self.dr.abs(), -self.width / 2))))
self.metal_regions['photo'].transform(alpha_trans)
self.empty_regions['photo'].transform(alpha_trans)
self.metal_region = self.metal_regions['photo']
self.empty_region = self.empty_regions['photo']
def init_regions(self):
self.metal_regions["photo"] = Region()
self.empty_regions["photo"] = Region()
self.metal_regions["bridges"] = Region()
self.empty_regions["bridges"] = Region()
self.metal_regions["bridge_patches"] = Region()
self.empty_regions["bridge_patches"] = Region()
self.connections = [DPoint(0, 0), self.dr]
self.start = DPoint(0, 0)
self.end = self.start + self.dr
alpha = atan2(self.dr.y, self.dr.x)
self.angle_connections = [alpha, alpha]
alpha_trans = ICplxTrans().from_dtrans(
DCplxTrans(1, alpha * 180 / pi, False, self.start))
self.metal_regions["photo"].insert(
pya.Box(Point().from_dpoint(DPoint(0, -self.width / 2)),
Point().from_dpoint(DPoint(self.dr.abs(),
self.width / 2))))
self.empty_regions["photo"].insert(
pya.Box(
Point().from_dpoint(DPoint(0, self.width / 2)),
Point().from_dpoint(
DPoint(self.dr.abs(), self.width / 2 + self.gap))))
self.empty_regions["photo"].insert(
pya.Box(
Point().from_dpoint(DPoint(0, -self.width / 2 - self.gap)),
Point().from_dpoint(DPoint(self.dr.abs(), -self.width / 2))))
self.metal_regions["photo"].transform(alpha_trans)
self.empty_regions["photo"].transform(alpha_trans)
if self.dr.x == 0:
N_bridges = int((self.dr.y - self._bridge_interval) //
self._bridge_interval + 1)
for i in range(N_bridges):
ab = Airbridge(self.start + DPoint(
0,
(self._bridge_interval / 2 + i * self._bridge_interval) *
sign(self.dr.y)),
trans_in=DTrans.R90)
self.metal_regions["bridges"] += ab.metal_regions["bridges"]
self.metal_regions["bridges"] += ab.metal_regions[
"bridge_patches"]
elif self.dr.y == 0:
N_bridges = int((self.dr.x - self._bridge_interval) //
self._bridge_interval + 1)
print("N_bridges", N_bridges)
for i in range(N_bridges):
bridge_pos = self.start + DPoint(
(self._bridge_interval / 2 + i * self._bridge_interval) *
sign(self.dr.x), 0)
ab = Airbridge(bridge_pos, trans_in=None)
self.metal_regions["bridges"] += ab.metal_regions["bridges"]
self.metal_regions["bridge_patches"] += ab.metal_regions[
"bridge_patches"]
def _init_regions_trans( self ):
self.init_regions() # must be implemented in every subclass
dr_origin = DSimplePolygon( [DPoint(0,0)] )
if( self.DCplxTrans_init is not None ):
# constructor trans displacement
dCplxTrans_temp = DCplxTrans( 1,0,False, self.DCplxTrans_init.disp )
self.make_trans( dCplxTrans_temp )
dr_origin.transform( dCplxTrans_temp )
# rest of the constructor trans functions
dCplxTrans_temp = self.DCplxTrans_init.dup()
dCplxTrans_temp.disp = DPoint(0,0)
self.make_trans( dCplxTrans_temp )
dr_origin.transform( dCplxTrans_temp )
# translation to the old origin (self.connections are alredy contain proper values)
self.make_trans( DCplxTrans( 1,0,False, self.origin ) ) # move to the origin
self.origin += dr_origin.point( 0 )
def init_primitives( self ):
self.arc1 = CPW_arc( self.Z0, DPoint(0,0), self.R1, pi/4 )
self.cop1 = CPW( self.Z0.width, self.Z0.gap, self.arc1.end, self.arc1.end + DPoint( sin(pi/4), sin(pi/4) )*self.L1 )
self.arc2 = CPW_arc( self.Z0, self.cop1.end, self.R2, pi/4, trans_in=DCplxTrans( 1,45,False,0,0 ) )
self.cop2 = CPW( self.Z0.width, self.Z0.gap, self.arc2.end, self.arc2.end + DPoint( 0,self.L2 ) )
self.connections = [self.arc1.start,self.cop2.end]
self.angle_connections = [self.arc1.alpha_start, self.cop2.alpha_end]
self.primitives = {"arc1":self.arc1, "cop1":self.cop1, "arc2":self.arc2, "cop2":self.cop2}
def init_primitives_gnd_trans( self ):
dr_origin = DSimplePolygon( [DPoint(0,0)] )
if( self.DCplxTrans_init is not None ):
# constructor trans displacement
dCplxTrans_temp = DCplxTrans( 1,0,False, self.DCplxTrans_init.disp )
for element in self.primitives_gnd.values():
element.make_trans( dCplxTrans_temp )
dr_origin.transform( dCplxTrans_temp )
# rest of the constructor trans functions
dCplxTrans_temp = self.DCplxTrans_init.dup()
dCplxTrans_temp.disp = DPoint(0,0)
for element in self.primitives_gnd.values():
element.make_trans( dCplxTrans_temp )
dr_origin.transform( dCplxTrans_temp )
dCplxTrans_temp = DCplxTrans( 1,0,False, self.origin )
for element in self.primitives_gnd.values():
element.make_trans( dCplxTrans_temp ) # move to the origin
def init_primitives(self):
origin = DPoint(0, 0)
self.c_wave = CWave(origin,
self.r_out,
self.dr,
self.n_semiwaves,
self.s,
self.alpha,
self.r_curve,
n_pts=self.n_pts_cwave)
self.primitives["c_wave"] = self.c_wave
Z1_start = origin + DPoint(0, self.r_in + self.gap1 + self.width1 / 2)
Z1_end = Z1_start + DPoint(0, -self.gap1 - self.width1 / 2 + self.dr)
self.cpw1 = CPW(self.Z1.width, self.Z1.gap, Z1_start, Z1_end)
self.primitives["cpw1"] = self.cpw1
Z2_start = origin - DPoint(0, self.r_in + self.gap2 + self.width2 / 2)
Z2_end = Z2_start - DPoint(0, -self.gap2 - self.width2 / 2 + self.dr)
self.cpw2 = CPW(self.Z2.width, self.Z2.gap, Z2_start, Z2_end)
self.primitives["cpw2"] = self.cpw2
self.c_wave_2_cpw_adapter = CWave2CPW(self.c_wave,
self.params[7:15],
n_pts=self.n_pts_arcs)
self.primitives["c_wave_2_cpw_adapter"] = self.c_wave_2_cpw_adapter
p_squid = None
squid_trans_in = None
if (self.c_wave.n_segments % 2 == 1):
squid_trans_in = DCplxTrans(1, self.c_wave.alpha * 180 / pi, False,
0, 0)
p_squid = origin
else:
squid_trans_in = None
second_parity = self.c_wave.n_segments / 2
y_shift = self.c_wave.L0 * sin(
self.c_wave.alpha) - self.c_wave.r_curve * (
1 / cos(self.c_wave.alpha) - 1)
if (second_parity % 2 == 0):
p_squid = origin + DPoint(0, y_shift)
else:
p_squid = origin + DPoint(0, -y_shift)
self.squid = Squid(p_squid, self.squid_params, trans_in=squid_trans_in)
self.primitives["qubit"] = self.squid
self.connections = [Z1_end, Z2_end]
self.angle_connections = [pi / 2, 3 / 2 * pi]
def init_regions(self):
self.metal_regions["photo"] = Region()
self.empty_regions["photo"] = Region()
self.metal_regions["bridges"] = Region()
self.empty_regions["bridges"] = Region()
self.metal_regions["bridge_patches"] = Region()
self.empty_regions["bridge_patches"] = Region()
self.connections = [DPoint(0, 0), self.dr, DPoint(0, self.R)]
self.angle_connections = [self.alpha_start, self.alpha_end]
self.start = DPoint(0, 0)
self.end = self.dr
self.center = DPoint(0, self.R)
n_inner = 10
n_outer = 10
metal_arc = self._get_solid_arc(self.center, self.R, self.width,
self.alpha_start - pi / 2,
self.alpha_end - pi / 2, n_inner,
n_outer)
empty_arc1 = self._get_solid_arc(self.center,
self.R - (self.width + self.gap) / 2,
self.gap, self.alpha_start - pi / 2,
self.alpha_end - pi / 2, n_inner,
n_outer)
empty_arc2 = self._get_solid_arc(self.center,
self.R + (self.width + self.gap) / 2,
self.gap, self.alpha_start - pi / 2,
self.alpha_end - pi / 2, n_inner,
n_outer)
self.metal_regions["photo"].insert(
SimplePolygon().from_dpoly(metal_arc))
self.empty_regions["photo"].insert(
SimplePolygon().from_dpoly(empty_arc1))
self.empty_regions["photo"].insert(
SimplePolygon().from_dpoly(empty_arc2))
bridge_pos = self.center + DPoint(sin(self.delta_alpha / 2),
-cos(self.delta_alpha / 2)) * self.R
ab = Airbridge(bridge_pos,
trans_in=DCplxTrans(1, self.delta_alpha / 2 * 180 / pi,
False, 0, 0))
self.metal_regions["bridges"] += ab.metal_regions["bridges"]
self.metal_regions["bridge_patches"] += ab.metal_regions[
"bridge_patches"]
def __init__(self, origin, trans_in=None):
## MUST BE IMPLEMENTED ##
self.connections = [] # DPoint list with possible connection points
self.angle_connections = [] #list with angle of connecting elements
self.connection_ptrs = [] # pointers to connected structures represented by their class instances
## MUST BE IMLPEMENTED END ##
self.origin = origin
self.metal_region = Region()
self.empty_region = Region()
self.metal_regions = {}
self.empty_regions = {}
self.metal_regions["default"] = self.metal_region
self.empty_regions["default"] = self.empty_region
self.metal_region.merged_semantics = False
self.empty_region.merged_semantics = False
self.DCplxTrans_init = None
self.ICplxTrans_init = None
if( trans_in is not None ):
# if( isinstance( trans_in, ICplxTrans ) ): <==== FORBIDDEN
if( isinstance( trans_in, DCplxTrans ) ):
self.DCplxTrans_init = trans_in
self.ICplxTrans_init = ICplxTrans().from_dtrans( trans_in )
elif( isinstance( trans_in, CplxTrans ) ):
self.DCplxTrans_init = DCplxTrans().from_itrans( trans_in )
self.ICplxTrans_init = ICplxTrans().from_trans( trans_in )
elif( isinstance( trans_in, DTrans ) ):
self.DCplxTrans_init = DCplxTrans( trans_in, 1 )
self.ICplxTrans_init = ICplxTrans( Trans().from_dtrans( trans_in ), 1 )
elif( isinstance( trans_in, Trans ) ):
self.DCplxTrans_init = DCplxTrans( DTrans().from_itrans( trans_in ), 1 )
self.ICplxTrans_init = ICplxTrans( trans_in, 1 )
self._init_regions_trans()
def init_primitives(self):
center = DPoint(0, 0)
self.empty_circle = Circle(center, self.ring1_outer_r + self.ring1_thickness, inverse=True)
self.primitives["empty_circle"] = self.empty_circle
# outer ring
self.ring1 = Ring(center, self.ring1_outer_r, self.ring1_thickness)
self.primitives["ring1"] = self.ring1
# inner ring
self.ring2 = Ring(center, self.ring2_outer_r, self.ring2_thickness)
self.primitives["ring2"] = self.ring2
## four aim lines ##
center_shift = self.aim_lines_width/3
line_length = self.ring1_outer_r - self.ring1_thickness/2 - center_shift
# left horizontal line
p1 = center + DPoint(-center_shift, 0)
p2 = p1 + DPoint(-line_length, 0)
self.left_aim_line = CPW(self.aim_lines_width, 0, p1, p2)
self.primitives["left_aim_line"] = self.left_aim_line
# bottom vertical line
p1 = center + DPoint(0, -center_shift)
p2 = p1 + DPoint(0, -line_length)
self.bottom_aim_line = CPW(self.aim_lines_width, 0, p1, p2)
self.primitives["bottom_aim_line"] = self.bottom_aim_line
# right horizontal line
p1 = center + DPoint(center_shift, 0)
p2 = p1 + DPoint(line_length, 0)
self.right_aim_line = CPW(self.aim_lines_width, 0, p1, p2)
self.primitives["right_aim_line"] = self.right_aim_line
# top vertical line
p1 = center + DPoint(0, center_shift)
p2 = p1 + DPoint(0, line_length)
self.top_aim_line = CPW(self.aim_lines_width, 0, p1, p2)
self.primitives["top_aim_line"] = self.top_aim_line
# center romb for better aiming
self.center_romb = Rectangle(
center,
self.aim_lines_width, self.aim_lines_width,
trans_in=DCplxTrans(1, 45, False, -self.aim_lines_width/2, -self.aim_lines_width/2),
inverse=True
)
self.primitives["center_romb"] = self.center_romb
self.connections = [center]
def init_primitives(self):
self.connections = [DPoint(0, 0), self.dr]
self.angle_connections = [0, 0]
self.coplanar1 = CPW(self.width, self.gap, DPoint(0, 0),
DPoint(0, 0) + DPoint(self.L1, 0), self.gndWidth)
self.arc1 = CPWArc(self.coplanar1, self.coplanar1.end, self.R1,
self.gamma, self.gndWidth, Trans(Trans.M0))
self.coplanar2 = CPW(
self.width, self.gap, self.arc1.end, self.arc1.end +
DPoint(cos(self.gamma), -sin(self.gamma)) * self.L2, self.gndWidth)
self.arc2 = CPWArc(self.coplanar1, self.coplanar2.end, self.R2,
self.gamma, self.gndWidth,
DCplxTrans(1, -self.gamma * 180 / pi, False, 0, 0))
self.coplanar3 = CPW(self.width, self.gap, self.arc2.end,
self.arc2.end + DPoint(L3, 0), self.gndWidth)
self.arc3 = CPWArc(self.coplanar1, self.coplanar3.end, self.R2,
self.gamma, self.gndWidth)
self.coplanar4 = CPW(
self.width, self.gap, self.arc3.end,
self.arc3.end + DPoint(cos(self.gamma), sin(self.gamma)) * self.L2,
self.gndWidth)
self.arc4 = CPWArc(self.coplanar1, self.coplanar4.end, self.R1,
self.gamma, self.gndWidth,
DCplxTrans(1, self.gamma * 180 / pi, True, 0, 0))
self.coplanar5 = CPW(self.width, self.gap, self.arc4.end,
self.arc4.end + DPoint(self.L1, 0), self.gndWidth)
self.primitives = {
"coplanar1": self.coplanar1,
"arc1": self.arc1,
"coplanar2": self.coplanar2,
"arc2": self.arc2,
"coplanar3": self.coplanar3,
"arc3": self.arc3,
"coplanar4": self.coplanar4,
"arc4": self.arc4,
"coplanar5": self.coplanar5
}
def __init__(self, origin, trans_in=None, inverse=False):
## MUST BE IMPLEMENTED ##
self.connections = [] # DPoint list with possible connection points
self.connection_edges = [
] # indexes of edges that are intended to connect to other polygons
# indexes in "self.connection_edges" where Sonnet ports
# should be placed
self.sonnet_port_connections = []
self.angle_connections = [] # list with angle of connecting elements
## MUST BE IMLPEMENTED END ##
self.connection_ptrs = [
] # pointers to connected structures represented by their class instances
self.origin = origin
self.inverse = inverse
self.metal_region = Region()
self.empty_region = Region()
self.metal_regions = OrderedDict()
self.empty_regions = OrderedDict()
self.metal_regions["default"] = self.metal_region
self.empty_regions["default"] = self.empty_region
self.metal_region.merged_semantics = True
self.empty_region.merged_semantics = True
self.DCplxTrans_init = None
self.ICplxTrans_init = None
if (trans_in is not None):
# if( isinstance( trans_in, ICplxTrans ) ): <==== FORBIDDEN
if (isinstance(trans_in, DCplxTrans)):
self.DCplxTrans_init = trans_in
self.ICplxTrans_init = ICplxTrans().from_dtrans(trans_in)
elif (isinstance(trans_in, CplxTrans)):
self.DCplxTrans_init = DCplxTrans().from_itrans(trans_in)
self.ICplxTrans_init = ICplxTrans().from_trans(trans_in)
elif (isinstance(trans_in, DTrans)):
self.DCplxTrans_init = DCplxTrans(trans_in, 1)
self.ICplxTrans_init = ICplxTrans(
Trans().from_dtrans(trans_in), 1)
elif (isinstance(trans_in, Trans)):
self.DCplxTrans_init = DCplxTrans(
DTrans().from_itrans(trans_in), 1)
self.ICplxTrans_init = ICplxTrans(trans_in, 1)
self._geometry_parameters = OrderedDict()
self._init_regions_trans()
def __init__(self, origin, params, trans_in=None):
self.params = params
self.a = params[0]
self.b = params[1]
self.jos1_b = params[2]
self.jos1_a = params[3]
self.f1 = params[4]
self.d1 = params[5]
self.jos2_b = params[6]
self.jos2_a = params[7]
self.f2 = params[8]
self.d2 = params[9]
self.w = params[10]
self.B1_width = params[11]
self.B1_height = params[12]
self.B2_height = params[13]
self.B5_height = params[14]
self.B6_width = params[15]
self.B6_height = params[16]
self.B7_width = params[17]
self.B7_height = params[18]
self.dCap = params[19]
self.gap = params[20]
# calculated parameters
self.B2_width = (self.gap - self.dCap - self.B6_width / 2 -
4 * self.w - self.jos1_a - self.jos2_a) / 2
self.B5_width = self.B2_width
self.B3_width = self.a + self.jos1_a / 2 - self.jos2_a / 2 - self.w
self.B4_width = self.a + self.jos2_a / 2 - self.jos1_a / 2 - self.w
self._alpha_1 = 0.5
self._length1 = (self.b + 2 * self.w + self.jos1_b)
self._alpha_2 = 0.5
self._length2 = (self.b + 2 * self.w - 2 * self.f2 - self.jos2_b
) #length
self.p0 = DPoint(0, 0)
self.p1 = self.p0 + DPoint(self.dCap, 0)
self.p2 = self.p1 + DPoint(self.B1_width,
(self.B1_height - self.B2_height) / 2)
self.p3 = self.p2 + DPoint(self.B2_width, self.B2_height)
self.p4 = self.p3 + DPoint(self.w, -self.w)
self.p5 = self.p4 + DPoint(self.B3_width, self.w)
self.p6 = self.p5 - DPoint(0, self.f2 + self._length2 * self._alpha_2)
self.p7 = self.p6 + DPoint(2 * self.w + self.jos2_a, -self.jos2_b)
self.p8 = self.p7 - DPoint(
0, self.f2 + (1 - self._alpha_2) * self._length2)
self.p9 = self.p8 - DPoint(self.B4_width + self.w, 0)
self.p10 = self.p8 + DPoint(self.B5_width,
(self.B5_height - self.B6_height) / 2)
self.p11 = self.p10 + DPoint(self.B6_width,
(self.B6_height - self.B7_height) / 2)
self.B1 = pya.DBox(self.p1,
self.p1 + DPoint(self.B1_width, self.B1_height))
self.B2 = pya.DBox(self.p2, self.p3)
self.B3 = pya.DBox(self.p4, self.p5)
self.B4 = pya.DBox(self.p9, self.p9 + DPoint(self.B4_width, self.w))
self.B5 = pya.DBox(self.p8,
self.p8 + DPoint(self.B5_width, self.B5_height))
self.B6 = pya.DBox(self.p10,
self.p10 + DPoint(self.B6_width, self.B6_height))
self.B7 = pya.DBox(self.p11,
self.p11 + DPoint(self.B7_width, self.B7_height))
self.poly_1 = self._make_polygon(self._length1 * self._alpha_1, self.w,
self.d1, self.f1, self.jos1_b)
self.poly_1.transform(DCplxTrans(1.0, 270, False, self.p3))
self.poly_2 = self._make_polygon(self._length1 * (1 - self._alpha_1),
self.w, self.d1, self.f1, self.jos1_b)
self.poly_2.transform(DCplxTrans(1.0, 90, False, self.p9))
self.poly_3 = self._make_polygon(self._length2 * self._alpha_2, self.w,
self.d2, self.f2, self.jos2_b)
self.poly_3.transform(DCplxTrans(1.0, 270, False, self.p5))
self.poly_4 = self._make_polygon(2 * self.jos2_b + self.f2, self.w,
self.d2, self.f2, self.jos2_b)
self.poly_4.transform(DCplxTrans(1.0, 90, False, self.p7))
self.poly_5 = self._make_polygon(2 * self.jos2_b + self.f2, self.w,
self.d2, self.f2, self.jos2_b)
self.poly_5.transform(DCplxTrans(1.0, 270, False, self.p6))
self.poly_6 = self._make_polygon((1 - self._alpha_2) * self._length2,
self.w, self.d2, self.f2, self.jos2_b)
self.poly_6.transform(DCplxTrans(1.0, 90, False, self.p8))
super().__init__(origin, trans_in)
def __init__(self, origin, params, trans_in=None):
self.params = params
self.a = params[0]
self.b = params[1]
self.jos1_b = params[2]
self.jos1_a = params[3]
self.f1 = params[4]
self.d1 = params[5]
self.jos2_b = params[6]
self.jos2_a = params[7]
self.f2 = params[8]
self.d2 = params[9]
self.w = params[10]
self.dCap = params[11]
self.gap = params[12]
self.square_a = params[13]
self.dSquares = params[14]
self.alum_over = params[15]
self.B1_width = params[16]
# calculated parameters
self.B2_width = self.a + self.jos1_a / 2 - self.jos2_a / 2 - self.w
self.qbit_width = 2 * self.w + self.B2_width
self.B3_width = self.a + self.jos2_a / 2 - self.jos1_a / 2 - self.w
self.B1_height = (self.dSquares - 2 * self.w - self.b) / 2
self._alpha_1 = 0.5
self._length1 = (self.b + 2 * self.w + self.jos1_b)
self._alpha_2 = 0.5
self._length2 = (self.b + 2 * self.w - 2 * self.f2 - self.jos2_b
) #length
self.p0 = DPoint(0, 0)
self.p1 = self.p0 - DPoint(0, self.dCap + self.square_a)
self.p2 = self.p1 + DPoint(self.square_a / 2 - self.qbit_width / 2,
-(self.dCap + self.B1_height))
self.p3 = self.p2 + DPoint(self.qbit_width - self.w, 0)
self.p4 = self.p2 + DPoint(self.w, -self.w)
self.p5 = self.p3 - DPoint(0, self.f2 + self._length2 * self._alpha_2)
self.p6 = self.p5 + DPoint(2 * self.w + self.jos2_a, -self.jos2_b)
self.p7 = self.p6 - DPoint(
0, self.f2 + (1 - self._alpha_2) * self._length2)
self.p8 = self.p7 - DPoint(self.w + self.B3_width, 0)
self.p9 = self.p7 - DPoint(
self.w + (self.qbit_width + self.B3_width) / 2, self.B1_height)
self.p10 = self.p1 - DPoint(
0, self.square_a + self.b + 2 * self.B1_height + 2 * self.w)
self.SQ1 = pya.DBox(self.p1,
self.p1 + DPoint(self.square_a, self.square_a))
self._B1p1 = self.p2 + DPoint(self.qbit_width / 2 - self.B1_width / 2,
0)
self.B1 = pya.DBox(
self._B1p1, self._B1p1 +
DPoint(self.B1_width, self.B1_height + self.alum_over))
self.B2 = pya.DBox(self.p4, self.p3)
self.B3 = pya.DBox(self.p8, self.p8 + DPoint(self.B3_width, self.w))
self._B4p1 = self.p9 + DPoint(self.qbit_width / 2 - self.B1_width / 2,
-self.alum_over)
self.B4 = pya.DBox(
self._B4p1, self._B4p1 +
DPoint(self.B1_width, self.B1_height + self.alum_over))
self.SQ2 = pya.DBox(self.p10,
self.p10 + DPoint(self.square_a, self.square_a))
self.poly_1 = self._make_polygon(self._length1 * self._alpha_1, self.w,
self.d1, self.f1, self.jos1_b)
self.poly_1.transform(DCplxTrans(1.0, 270, False, self.p2))
self.poly_2 = self._make_polygon(self._length1 * (1 - self._alpha_1),
self.w, self.d1, self.f1, self.jos1_b)
self.poly_2.transform(DCplxTrans(1.0, 90, False, self.p8))
self.poly_3 = self._make_polygon(self._length2 * self._alpha_2, self.w,
self.d2, self.f2, self.jos2_b)
self.poly_3.transform(DCplxTrans(1.0, 270, False, self.p3))
self.poly_4 = self._make_polygon(2 * self.jos2_b + self.f2, self.w,
self.d2, self.f2, self.jos2_b)
self.poly_4.transform(DCplxTrans(1.0, 90, False, self.p6))
self.poly_5 = self._make_polygon(2 * self.jos2_b + self.f2, self.w,
self.d2, self.f2, self.jos2_b)
self.poly_5.transform(DCplxTrans(1.0, 270, False, self.p5))
self.poly_6 = self._make_polygon((1 - self._alpha_2) * self._length2,
self.w, self.d2, self.f2, self.jos2_b)
self.poly_6.transform(DCplxTrans(1.0, 90, False, self.p7))
super().__init__(origin, trans_in)
def __init__(self, origin, params, trans_in=None):
self.params = params
self.a = params[0]
self.b = params[1]
self.jos1_b = params[2]
self.jos1_a = params[3]
self.f1 = params[4]
self.d1 = params[5]
self.jos2_b = params[6]
self.jos2_a = params[7]
self.f2 = params[8]
self.d2 = params[9]
self.w = params[10]
self.dCap = params[11]
self.gap = params[12]
self.square_a = params[13]
self.dSquares = params[14]
self.alum_over = params[15]
self.B1_width = params[16]
# calculated parameters
self.B2_width = self.a + self.jos1_a / 2 - self.jos2_a / 2 - self.w
self.qbit_width = 2 * self.w + self.B2_width
self.B3_width = self.b - self.jos2_a / 2 - self.jos1_a / 2 - 2 * self.w
self.B1_height = (self.dSquares - 2 * self.w - self.b) / 2
self._alpha_1 = 0.5
self._length1 = (self.b + 2 * self.w + self.jos1_b)
self._alpha_2 = 0.5
self._length2 = (self.b + 2 * self.w - 2 * self.f2 - self.jos2_b
) #length
self._length_right = (self.b + 2 * self.w - 2 * self.jos2_b) / 3
self.p0 = DPoint(0, 0)
self.p1 = self.p0 - DPoint(0, self.dCap + self.square_a)
self.p2 = self.p1 + DPoint(self.square_a / 2 - self.qbit_width / 2,
-(self.dCap + self.B1_height))
self.p3 = self.p2 + DPoint(self.qbit_width - self.w, 0)
self.p4 = self.p2 + DPoint(self.w, -self.w)
self.p5 = self.p3 + DPoint(2 * self.w + self.jos2_a,
-(2 * self._length_right + 2 * self.jos2_b))
self.p6 = self.p3 - DPoint(0, self.b + 2 * self.w)
self.p7 = self.p6 - DPoint(self.B3_width, 0)
self.p8 = self.p7 - DPoint(self.w, self.B1_height)
self.p9 = self.p1 - DPoint(
0, self.square_a + self.b + 2 * self.B1_height + 2 * self.w)
self.SQ1 = pya.DBox(self.p1,
self.p1 + DPoint(self.square_a, self.square_a))
self._B1p1 = self.p2 + DPoint(
(self.B2_width + 2 * self.w) / 2 - self.B1_width / 2, 0)
self.B1 = pya.DBox(
self._B1p1, self._B1p1 +
DPoint(self.B1_width, self.B1_height + self.alum_over))
self.B2 = pya.DBox(self.p4, self.p3)
self.B3 = pya.DBox(self.p7, self.p7 + DPoint(self.B3_width, self.w))
self._B4p1 = self.p8 + DPoint(
(self.B3_width + 2 * self.w) / 2 - self.B1_width / 2,
-self.alum_over)
self.B4 = pya.DBox(
self._B4p1, self._B4p1 +
DPoint(self.B1_width, self.B1_height + self.alum_over))
self.SQ2 = pya.DBox(self.p9,
self.p9 + DPoint(self.square_a, self.square_a))
self.poly_1 = self._make_polygon(self._length1 * self._alpha_1, self.w,
self.d1, self.f1, self.jos1_b)
self.poly_1.transform(DCplxTrans(1.0, 270, False, self.p2))
self.poly_2 = self._make_polygon(self._length1 * (1 - self._alpha_1),
self.w, self.d1, self.f1, self.jos1_b)
self.poly_2.transform(DCplxTrans(1.0, 90, False, self.p7))
self.poly_3 = self._make_polygon(self._length_right + self.jos2_b,
self.w, self.d2, self.f2, self.jos2_b)
self.poly_3.transform(DCplxTrans(1.0, 270, False, self.p3))
self.poly_4 = self._make_polygon(
self._length_right + self.jos2_b - self.f2, self.w, self.d2,
self.f2, self.jos2_b)
self.poly_4.transform(
DCplxTrans(
1.0, 270, True, self.p5 +
DPoint(0, self._length_right + self.jos2_b - self.f2)))
_poly_tmp = self._make_polygon(
self._length_right + self.jos2_b - self.f2, self.w, self.d2,
self.f2, self.jos2_b)
_poly_tmp.transform(
DCplxTrans(1.0, 90, False,
self.p5 + DPoint(0, self.jos2_b + self.f2)))
_reg_tmp4 = Region()
_reg_tmp4.insert(SimplePolygon().from_dpoly(self.poly_4))
_reg_tmp = Region()
_reg_tmp.insert(SimplePolygon().from_dpoly(_poly_tmp))
self._reg_tmp_to_metal = (_reg_tmp + _reg_tmp4).merged()
self.poly_5 = self._make_polygon(self._length_right + self.jos2_b,
self.w, self.d2, self.f2, self.jos2_b)
self.poly_5.transform(DCplxTrans(1.0, 90, True, self.p6))
super().__init__(origin, trans_in)
worm = EMResonator_TL2Qbit_worm(Z_res, point, L_coupling[i], L1[i], r,
L2, N)
worm.place(cell, layer_photo)
resonators.append(worm)
dy_qbit = (worm.cop_tail.dr.abs() - square_a) / 2
qbit_params = [
a[i], b[i], jos1_b, jos1_a, f1, d1, jos2_b, jos2_a, f2, d2, w,
dCap, gap, square_a, dSquares, alum_over, B1_width
]
dy_qbit = (worm.cop_tail.dr.abs() - square_a) / 2
qbit_start = worm.end + DPoint(B1_width / 2, 0)
qbit = QBit_Flux_Сshunted_3JJ(
worm.end + DPoint(qbit_coupling_gap + Z_res.width / 2, dy_qbit),
qbit_params, DCplxTrans(1, 90, False, 0, 0))
qbit_bbox = pya.DBox().from_ibox(qbit.metal_regions["photo"].bbox())
p1 = qbit.origin + DPoint(-qbit_coupling_gap, qbit.square_a / 2)
p2 = p1 + DPoint(qbit_bbox.width() + qbit_coupling_gap + qbit_gnd_gap,
0)
empty = CPW(0, (square_a + 2 * qbit_gnd_gap) / 2, p1, p2)
empty.place(cell, layer_photo)
empties.append(empty)
qbit.place(cell, layer_photo, layer_el)
qbits.append(qbit)
# place top array of resonators with qBits
N_top = N_bottom - 1
delta = 1e6
step_top = step_bot
def init_primitives(self):
R_index = 0
L_index = 0
origin = DPoint(0, 0)
prev_primitive_end = origin
prev_primitive_end_angle = 0
for i, symbol in enumerate(self._shape_string):
if symbol == 'R':
turn_radius = self._turn_radiuses[R_index] \
if self._turn_angles[R_index] > 0 \
else -self._turn_radiuses[R_index]
if self._bridged:
cpw_arc = BridgedCPWArc(self._cpw_parameters[i],
prev_primitive_end,
turn_radius,
self._turn_angles[R_index],
200e3,
trans_in=DCplxTrans(
1, prev_primitive_end_angle *
180 / pi, False, 0, 0))
else:
cpw_arc = CPW_arc(self._cpw_parameters[i],
prev_primitive_end,
turn_radius,
self._turn_angles[R_index],
trans_in=DCplxTrans(
1,
prev_primitive_end_angle * 180 / pi,
False, 0, 0))
self.primitives["arc_" + str(R_index)] = cpw_arc
R_index += 1
elif symbol == 'L':
# Turns are reducing segments' lengths so as if there were no roundings at all
if i + 1 < self._N_elements \
and self._shape_string[i + 1] == 'R' \
and abs(self._turn_angles[R_index]) < pi:
coeff = abs(tan(self._turn_angles[R_index] / 2))
self._segment_lengths[
L_index] -= self._turn_radiuses[R_index] * coeff
if i - 1 > 0 \
and self._shape_string[i - 1] == 'R' \
and abs(self._turn_angles[R_index - 1]) < pi:
coeff = abs(tan(self._turn_angles[R_index - 1] / 2))
self._segment_lengths[L_index] -= self._turn_radiuses[
R_index - 1] * coeff
if self._bridged:
cpw = BridgedCPW(self._cpw_parameters[i].width,
self._cpw_parameters[i].gap,
200e3,
prev_primitive_end,
prev_primitive_end +
DPoint(self._segment_lengths[L_index], 0),
trans_in=DCplxTrans(
1,
prev_primitive_end_angle * 180 / pi,
False, 0, 0))
else:
cpw = CPW(self._cpw_parameters[i].width,
self._cpw_parameters[i].gap,
prev_primitive_end,
prev_primitive_end +
DPoint(self._segment_lengths[L_index], 0),
trans_in=DCplxTrans(
1, prev_primitive_end_angle * 180 / pi,
False, 0, 0))
self.primitives["cpw_" + str(L_index)] = cpw
L_index += 1
primitive = list(self.primitives.values())[i]
prev_primitive_end = primitive.end
prev_primitive_end_angle = primitive.alpha_end
self.connections = [
list(self.primitives.values())[0].start,
list(self.primitives.values())[-1].end
]
self.angle_connections = [
list(self.primitives.values())[0].alpha_start,
list(self.primitives.values())[-1].alpha_end
]
class Element_Base():
def __init__(self, origin, trans_in=None):
## MUST BE IMPLEMENTED ##
self.connections = [] # DPoint list with possible connection points
self.angle_connections = [] #list with angle of connecting elements
self.connection_ptrs = [] # pointers to connected structures represented by their class instances
## MUST BE IMLPEMENTED END ##
self.origin = origin
self.metal_region = Region()
self.empty_region = Region()
self.metal_regions = {}
self.empty_regions = {}
self.metal_regions["default"] = self.metal_region
self.empty_regions["default"] = self.empty_region
self.metal_region.merged_semantics = False
self.empty_region.merged_semantics = False
self.DCplxTrans_init = None
self.ICplxTrans_init = None
if( trans_in is not None ):
# if( isinstance( trans_in, ICplxTrans ) ): <==== FORBIDDEN
if( isinstance( trans_in, DCplxTrans ) ):
self.DCplxTrans_init = trans_in
self.ICplxTrans_init = ICplxTrans().from_dtrans( trans_in )
elif( isinstance( trans_in, CplxTrans ) ):
self.DCplxTrans_init = DCplxTrans().from_itrans( trans_in )
self.ICplxTrans_init = ICplxTrans().from_trans( trans_in )
elif( isinstance( trans_in, DTrans ) ):
self.DCplxTrans_init = DCplxTrans( trans_in, 1 )
self.ICplxTrans_init = ICplxTrans( Trans().from_dtrans( trans_in ), 1 )
elif( isinstance( trans_in, Trans ) ):
self.DCplxTrans_init = DCplxTrans( DTrans().from_itrans( trans_in ), 1 )
self.ICplxTrans_init = ICplxTrans( trans_in, 1 )
self._init_regions_trans()
def init_regions( self ):
raise NotImplementedError
# first it makes trans_init displacement
# then the rest of the trans_init
# then displacement of the current state to the origin
# after all, origin should be updated
def _init_regions_trans( self ):
self.init_regions() # must be implemented in every subclass
dr_origin = DSimplePolygon( [DPoint(0,0)] )
if( self.DCplxTrans_init is not None ):
# constructor trans displacement
dCplxTrans_temp = DCplxTrans( 1,0,False, self.DCplxTrans_init.disp )
self.make_trans( dCplxTrans_temp )
dr_origin.transform( dCplxTrans_temp )
# rest of the constructor trans functions
dCplxTrans_temp = self.DCplxTrans_init.dup()
dCplxTrans_temp.disp = DPoint(0,0)
self.make_trans( dCplxTrans_temp )
dr_origin.transform( dCplxTrans_temp )
# translation to the old origin (self.connections are alredy contain proper values)
self.make_trans( DCplxTrans( 1,0,False, self.origin ) ) # move to the origin
self.origin += dr_origin.point( 0 )
def make_trans( self, dCplxTrans ):
if( dCplxTrans is not None ):
iCplxTrans = ICplxTrans().from_dtrans( dCplxTrans )
for metal_region, empty_region in zip(self.metal_regions.values(), self.empty_regions.values()):
metal_region.transform( iCplxTrans )
empty_region.transform( iCplxTrans )
self._update_connections( dCplxTrans )
self._update_alpha( dCplxTrans )
def _update_connections( self, dCplxTrans ):
if( dCplxTrans is not None ):
# the problem is, if k construct polygon with multiple points
# their order in poly_temp.each_point() doesn't coinside with the
# order of the list that was passed to the polygon constructor
# so, when k perform transformation and try to read new values through poly_temp.each_point()
# they values are rearranged
# solution is: k need to create polygon for each point personally, and the initial order presists
for i,pt in enumerate(self.connections):
poly_temp = DSimplePolygon( [pt] )
poly_temp.transform( dCplxTrans )
self.connections[i] = poly_temp.point( 0 )
def _update_alpha( self, dCplxTrans ):
if( dCplxTrans is not None ):
dCplxTrans_temp = dCplxTrans.dup()
dCplxTrans_temp.disp = DPoint(0,0)
for i,alpha in enumerate(self.angle_connections):
poly_temp = DSimplePolygon( [DPoint( cos(alpha), sin(alpha) )] )
poly_temp.transform( dCplxTrans_temp )
pt = poly_temp.point( 0 )
self.angle_connections[i] = atan2( pt.y, pt.x )
def _update_origin( self, dCplxTrans ):
if( dCplxTrans is not None ):
poly_temp = DSimplePolygon( [self.origin] )
poly_temp.transform( dCplxTrans )
self.origin = poly_temp.point( 0 )
def place( self, dest, layer_i=-1, region_name=None ):
r_cell = None
if( layer_i != -1 ):
metal_region = None
empty_region = None
if( region_name == None ):
metal_region = self.metal_region
empty_region = self.empty_region
else:
metal_region = self.metal_regions[region_name]
empty_region = self.empty_regions[region_name]
r_cell = Region( dest.begin_shapes_rec( layer_i ) )
temp_i = dest.layout().layer( pya.LayerInfo(PROGRAM.LAYER1_NUM,0) )
dest.shapes( temp_i ).insert( r_cell + metal_region - empty_region )
dest.layout().clear_layer( layer_i )
dest.layout().move_layer( temp_i, layer_i )
dest.layout().delete_layer( temp_i )
if( layer_i == -1 ): # dest is interpreted as instance of Region() class
for metal_region,empty_region in zip(self.metal_regions.values(),self.empty_regions.values()):
dest += metal_region
dest -= empty_region
def bridgify_CPW(cpw,
bridges_step,
cell=None,
bridge_layer1=-1,
bridge_layer2=-1):
"""
Function puts bridge patterns to fabricate bridges on coplanar waveguide
`cpw` with bridges having period of `bridges_step` along coplanar's wave
propagation direction.
Bridges are distributed over coplanar starting with its center.
Parameters
----------
cpw : Union[CPW, CPW_arc, CPW_RL_Path]
instance of coplanar class to be bridged during fabrication
bridges_step : float
distance between centers of bridges in nm
cell : pya.Cell
cell to place bridge polygons at
bridge_layer1 : int
index of the layer in the `cell` with ground touching polygons
bridge_layer2 : int
index of the layer in the `cell` with empty polygons
Returns
-------
None
"""
if isinstance(cpw, CPW):
cpw_center = cpw.start + cpw.end
alpha = atan2(cpw.dr.y, cpw.dr.x)
cpw_len = cpw.dr.abs()
cpw_dir_unit_vector = cpw.dr / cpw.dr.abs()
# bridge with some initial dimensions
tmp_bridge = Bridge1(DPoint(0, 0))
bridge_width = tmp_bridge.gnd_touch_dx + 2 * tmp_bridge.surround_gap
# number of additional bridges on either side of center
additional_bridges_n = int(
(cpw_len / 2 - bridge_width / 2) // bridges_step)
bridge_centers = []
for i in range(-additional_bridges_n, additional_bridges_n + 1):
bridge_centers.append(cpw.start +
(cpw_len / 2 + i * bridges_step) *
cpw_dir_unit_vector)
bridges = []
for center in bridge_centers:
bridges.append(
Bridge1(center,
trans_in=DCplxTrans(1, alpha / pi * 180, False, 0,
0)))
for bridge in bridges:
bridge.place(dest=cell,
layer_i=bridge_layer1,
region_name="bridges_1")
bridge.place(dest=cell,
layer_i=bridge_layer2,
region_name="bridges_2")
elif isinstance(cpw, CPW_arc):
# to be implemented
pass
elif isinstance(cpw, CPW_RL_Path):
for primitive in cpw.primitives.values():
if isinstance(primitive, CPW):
Bridge1.bridgify_CPW(primitive, bridges_step, cell,
bridge_layer1, bridge_layer2)
else:
# do nothing for other shapes
return
lv.add_missing_layers()
### DRAW SECTION START ###
origin = DPoint(0, 0)
# Chip drwaing START #
chip = pya.DBox(origin, DPoint(CHIP.dx, CHIP.dy))
cell.shapes(layer_ph).insert(pya.Box().from_dbox(chip))
# Chip drawing END #
# Path test drawing START #
RL_str = "RLRLR"
Z0 = CPW(12.2e3, 6.2e3)
Z_list = [Z0]
R_list = [0.5e6]
L_list = [0.2e6]
delta_alpha_list = [pi / 4, -pi / 4, -pi]
start = origin
path = CPW_RL_Path(start,
RL_str,
Z_list,
R_list,
L_list,
delta_alpha_list,
trans_in=DCplxTrans(1, 45, False, 0, 0))
path.place(cell, layer_ph)
# Path test drawing END #
### DRAW SECTION END ###
lv.zoom_fit()
jos1_a = 0.1e3
f1 = 0.13e3
d1 = 0.05e3
jos2_b = 0.8e3
jos2_a = 0.09e3
f2 = 0.25e3
d2 = d1
w = 0.2e3
B1_width = 7.325e3
B1_height = 2.405e3
B2_width = 0.6e3
B5_width = 0.4e3
B6_width = 2.5e3
B6_height = 10e3
B7_width = 5.051e3
B7_height = 4.076e3
dCap = 0
gap = 25e3
qbit_params = [
a, b, jos1_b, jos1_a, f1, d1, jos2_b, jos2_a, f2, d2, w, B1_width,
B1_height, B2_width, B5_width, B6_width, B6_height, B7_width,
B7_height, dCap, gap
]
qbit = QBit_Flux_3(DPoint(dCap, 0), qbit_params,
DCplxTrans(1, 0, False, 0, 0))
qbit.place(cell, layer_i)
### DRAW SECTION END ###
lv.zoom_fit()
### DRAW SECTION START ###
origin = DPoint(1e6,0)
a = 4.6e3
b = 4.6e3
jos1_b = 0.32e3
jos1_a = 0.1e3
f1 = 0.13e3
d1 = 0.05e3
jos2_b = 0.8e3
jos2_a = 0.09e3
f2 = 0.25e3
d2 = d1
w = 0.2e3
dCap = 0
dSquares = 30e3
gap = 25e3
square_a = 150e3
alum_over = 20e3
B1_width = 3e3
qbit_params = [a,b,
jos1_b,jos1_a,f1,d1,
jos2_b,jos2_a,f2,d2,
w, dCap,gap, square_a, dSquares, alum_over, B1_width]
qbit = QBit_Flux_Сshuted( DPoint(1e6,1e6), qbit_params, DCplxTrans( 1,0,False,0,0 ) )
print( qbit.origin )
qbit.place( cell, layer_photo, layer_el )
### DRAW SECTION END ###
lv.zoom_fit()
