def callback_clone_shape(self): tab = self.notebook.currentWidget() s = self.epi.find_shape_by_file_name(tab.file_name) name = s.name + "_new" new_sim_name = dlg_get_text("Clone the shape:", name, "clone.png") new_sim_name = new_sim_name.ret if new_sim_name != None: old_name = os.path.join(get_sim_path(), tab.file_name) new_name = get_epi().new_electrical_file("shape") my_shape = shape() my_shape.load(old_name) my_shape.name = new_sim_name my_shape.x0 = my_shape.x0 - my_shape.dx my_shape.shape_electrical = get_epi().gen_new_electrical_file( "electrical") my_shape.file_name = new_name my_shape.save() get_epi().layers[self.layer_index].shapes.append(my_shape) get_epi().save() my_tab = tab_class(my_shape.file_name + ".inp") self.notebook.addTab(my_tab, my_shape.name) my_tab.changed.connect(self.callback_edit) global_object_run("gl_force_redraw")
def interlock(img, birds_eye, thresholds, lines): ''' runs the actual vision interlock; the parameters are the components that create the `certificate` :param img: image from the controller :param birds_eye: bird's eye transformation object from the controller :param thresholds: thresholds used for vision filters :param lines: proposed lane lines :return: the result of each vision interlock test ''' wb = get_wb(img, birds_eye, thresholds) plt.imshow(wb) plt.show() shape_result = shape(lines[0], lines[1], img.shape[0]) left_result = convolve(True, lines[0], wb) right_result = convolve(False, lines[1], wb) result = birds_eye.project(img, wb, lines[0], lines[1]) plt.title("Approach 1: " + ("pass" if shape_result else "fail") + "\nApproach 2L: " + (left_result if left_result else "fail") + ", Approach 2R: " + (right_result if right_result else "fail")) plt.imshow(result) plt.show() return shape_result, left_result, right_result
def produce_impl(self): # Creates the patterns # Convert parameters from [um] to [dbu] or database units d = self.specDiameter[self.diameter] / self.layout.dbu * 1000 pFlat = self.specPrimaryFlat[self.diameter] / self.layout.dbu * 1000 sFlat = self.specSecondaryFlat[self.diameter] / self.layout.dbu * 1000 aFlat = self.specSecondaryFlatAngle[self.secondaryFlatAngle] b = self.border / self.layout.dbu * 1000 dIn = self.dIn / self.layout.dbu * 1000 dOut = self.dOut / self.layout.dbu * 1000 # Create the wafer shape s = shape() region = s.siWafer(d, pFlat, sFlat, aFlat, 128) if (self.doubleFlat): regionTmp = region.dup() regionTmp.transform(pya.ICplxTrans(1, 180, False, 0, 0)) region = region & regionTmp if (self.ring): scaleIn = (d - dIn) / d scaleOut = (d + dOut) / d regionOut = region.dup() regionOut.transform(pya.ICplxTrans(scaleOut, 0, False, 0, 0)) regionIn = region.dup() regionIn.transform(pya.ICplxTrans(scaleIn, 0, False, 0, 0)) region = regionOut - regionIn if (self.invert): region = s.invert(region, b) self.cell.shapes(self.layer_layer).insert(region)
def layer_add(self): obj=self.gl_objects_get_first_selected() if obj!=None: epi=get_epi() s=epi.find_shape_by_id(obj.id[0]) if type(s)==epi_layer or type(s)==shape: layer_index=epi.find_layer_by_id(obj.id[0]) new_filename=epi.new_electrical_file("shape")+".inp" orig_filename=os.path.join(get_default_material_path(),"shape.inp") inp_copy_file(os.path.join(get_sim_path(),new_filename),os.path.join(get_sim_path(),orig_filename)) mesh=get_mesh() my_shape=shape() my_shape.load(new_filename) my_shape.dy=epi.layers[layer_index].dy my_shape.dx=mesh.get_xlen() my_shape.dz=mesh.get_zlen() my_shape.shape_electrical=epi.gen_new_electrical_file("electrical") my_shape.shape_nx=1 my_shape.shape_ny=1 my_shape.shape_nz=1 my_shape.name="New shape" my_shape.save() epi.layers[layer_index].shapes.append(my_shape) epi.save() self.force_redraw()
def cclock(self, brd): self.bloc.remove(brd) self.nbloc = shape(self.bloc) self.nbloc.shape = self.nbloc.twist_cclock(brd) self.nbloc.update_hw() if self.nbloc.can_insert(brd): self.bloc = self.nbloc else: pass self.bloc.insert(brd)
def produce_impl(self): # Creates the patterns # Convert parameters from [um] to [dbu] or database units d = self.diameter / self.layout.dbu b = self.border / self.layout.dbu # Create the cross s = shape() region = s.circle(d, self.vertices) if (self.invert): region = s.invert(region, b) self.cell.shapes(self.layer_layer).insert(region)
def produce_impl(self): # Creates the patterns # Convert parameters from [um] to [dbu] or database units w = self.width / self.layout.dbu b = self.border / self.layout.dbu # Create the cross s = shape() region = s.checkerboard(w, self.num) if (self.invert): region = s.invert(region, b) self.cell.shapes(self.layer_layer).insert(region)
def draw_light_profile(self): self.gl_objects_remove_regex("light_profile") name = inp_get_token_value(os.path.join(get_sim_path(), "light.inp"), "#light_profile") if name != "box": epi = get_epi() s = shape() s.type = name s.load_triangles() s.triangles.data = triangles_remove_below(s.triangles.data, 0.1) a = gl_base_object() a.id = ["light_profile"] a.type = "open_triangles" a.x = gl_scale.project_m2screen_x(0) a.y = gl_scale.project_m2screen_y(0) a.z = gl_scale.project_m2screen_z(0) a.dx = 1.0 a.dy = scale_get_ymul() * 1.0 a.dz = 1.0 a.r = 0.0 a.g = 1.0 a.b = 0.0 a.alpha = 1.0 my_vec = vec() my_vec.x = get_mesh().get_xlen() my_vec.y = epi.ylen() * 1.0 my_vec.z = get_mesh().get_zlen() t = triangles_mul_vec(s.triangles.data, my_vec) my_vec = vec() my_vec.x = 0.0 my_vec.y = -epi.ylen() * 3.0 my_vec.z = 0.0 t = triangles_add_vec(t, my_vec) a.triangles = scale_trianges_m2screen(t) #triangles_mul_vec(triangles_flip_in_box(s.triangles.data),my_vec) #print("bing!",gl_scale.project_m2screen_x(0)) self.gl_objects_add(a)
def main(): print(list(set([11, 22, 33, 44, 11, 22]))) defaultshape = sp.shape() if (isinstance(defaultshape, sp.shape)): print('default area is {}'.format(defaultshape.area())) squareshape = sp.square(5) if (isinstance(squareshape, sp.shape)): print('Square area is {}'.format(squareshape.area())) c1 = cn.ComplexNumber(4, 2) c2 = cn.ComplexNumber(5, 3) c3 = c1.add(c2) #print("Complex Number {}+i{}".format(c3.real, c3.complex)) print('Sum is {}'.format(c3))
def produce_impl(self): # Creates the patterns # Convert parameters from [um] to [dbu] or database units do = self.outerDiameter / self.layout.dbu di = self.innerDiameter / self.layout.dbu b = self.border / self.layout.dbu # Create the cross s = shape() region = s.ring(do, di, self.vertices, self.fracture) if (self.invert): region = s.invert(region, b) self.cell.shapes(self.layer_layer).insert(region)
def produce_impl(self): # Creates the patterns # Convert parameters from [um] to [dbu] or database units d = self.specDiameter[self.diameter] / self.layout.dbu * 1000 pFlat = self.specPrimaryFlat[self.diameter] / self.layout.dbu * 1000 sFlat = self.specSecondaryFlat[self.diameter] / self.layout.dbu * 1000 aFlat = self.specSecondaryFlatAngle[self.secondaryFlatAngle] b = self.border / self.layout.dbu * 1000 # Create the cross s = shape() region = s.siWafer(d, pFlat, sFlat, aFlat, 128) if (self.invert): region = s.invert(region, b) self.cell.shapes(self.layer_layer).insert(region)
def new_shape_file(self,layer): new_filename=self.gen_new_electrical_file("shape") mesh=get_mesh() my_shape=shape() my_shape.load(os.path.join(get_sim_path(),new_filename)+".inp") if layer!=None: my_shape.dy=layer.dy my_shape.dx=mesh.get_xlen() my_shape.dz=mesh.get_zlen() my_shape.shape_electrical=self.gen_new_electrical_file("electrical") my_shape.shape_nx=1 my_shape.shape_ny=1 my_shape.shape_nz=1 my_shape.name="New shape" my_shape.optical_material="blends/p3htpcbm" my_shape.save() return my_shape
def plot(space,sol): T = lambda x: x**2#np.sin(x) plt.figure(1) xplot = np.linspace(space.bounds[0],space.bounds[1],space.nels*10+1) plt.plot(xplot,T(xplot), linewidth = 2, color = 'blue') nw,xw,w = QuadParams.QP(space.maxord) ## set mesh parameters to spatial grid nels = space.nels order = space.order nod = space.nod xnod = space.xnod for el in range(0,nels): xL = xnod[nod[el,0]] # left endpoint on element xR = xnod[nod[el,order[el]-1]] # right endpoint on element dx = (xR-xL)/2. # Jacobian of transformation xpp = np.linspace(xL,xR,10); # set up 10 points in the true element for plotting xww =(xpp-xL)/dx-1; # xww runs in reference element ypp = 0*xpp; # initializes a zero array of len(xpp) for j in range(0,len(xpp)): psi,dpsi = shape.shape(xww[j],order[el]) uhval = 0 for k in range(0,order[el]): mynum = nod[el,k] # (nod=global numbering of nodes). mynum = node,k, of element,el uhval = uhval + sol[mynum]*psi[k] ypp[j]=uhval plt.plot(xpp,ypp,linewidth = 2, color = 'red') plt.title('Exact solution (blue) and BVP FEM solution (red)') plt.xlabel('Space') plt.grid(True) plt.show()
def Error(space,sol,T,Tp): nw,xw,w = QuadParams.QP(space.maxord) ## set mesh parameters to spatial grid nels = space.nels order = space.order nod = space.nod xnod = space.xnod l2Err = 0.0; h1Err=0.0 for el in range(0,nels): # for each element in all elements tL = xnod[nod[el,0]] # left endpoint on element tR = xnod[nod[el,order[el]-1]] # right endpoint on element dt = (tR-tL)/2. # Jacobian of transformation for l in range(0,nw): t = tL + (1 + xw[l])*dt # x runs in true element, xw runs in reference element psi,dpsi = shape.shape(xw[l],order[el]) # calculations on ref.element uval = T(t) duval = Tp(t) uhval = 0.0; duhval = 0.0 #reset uh and duh evaluations over each element for k in range(0,order[el]): mynum = nod[el,k] # (nod=global numbering of nodes). mynum = node,k, of element,el uhval = uhval + sol[mynum]*psi[k] duhval = duhval + sol[mynum]*dpsi[k]/dt #complete integration over element l2Err = l2Err + (uval-uhval)**2 *w[l]*dt h1Err = h1Err + (duval-duhval)**2 *w[l]*dt l2Err = math.sqrt(l2Err) h1Err = math.sqrt(l2Err+h1Err) return(l2Err,h1Err)
def __init__(self): self.bloc = shape(False)
def produce_impl(self): # Cross parameters cWidth = 10 cLength = 100 cGap = 0 cBorder = 10 cPos = pya.Point(0, 0) # Vernier parameters vWidth = 4 vLength = 40 vPitch = 8 vGap = 0 vPosL = pya.Point(-120000, cPos.y) vPosB = pya.Point(cPos.x, -120000) # Mask number parameters mLineWidth = 4 mPosL = pya.Point(-40000, 90000) mPosR = pya.Point(40000, 90000) # Border border = 10 # Create references to the active cell cv = pya.CellView().active() layout = cv.layout() dbu = self.layout.dbu s = shape() #Creates a cross if (self.cross == 0): #Solid Cross if (self.type == 0): #Wafer Type #Creates an inverted cross cross = s.cross((cWidth + 2 * cGap) / dbu, (cLength + 2 * cGap) / dbu) cross = s.invert(cross, cBorder / dbu) cross.transform(pya.Trans(cPos)) else: cross = s.cross(cWidth / dbu, cLength / dbu) cross.transform(pya.Trans(cPos)) else: #Dashed Cross if (self.type == 0): #Wafer Type cross = s.cross(cWidth / dbu, cLength / dbu, 1) cross = s.invert(cross, cBorder / dbu) cross.transform(pya.Trans(cPos)) else: cross = s.cross(cWidth / dbu, cLength / dbu, 2) cross.transform(pya.Trans(cPos)) if (self.type == 0): #Wafer Type #Create Vernier Left 1 vLeft = s.vernier(vWidth / dbu, vLength / dbu, vPitch / dbu) vLeft.transform(pya.Trans(vPosL)) #Create Vernier Bottom 1 vBot = s.vernier(vWidth / dbu, vLength / dbu, vPitch / dbu) vBot.transform(pya.Trans(1, False, vPosB.x, vPosB.y)) #Create Mask Number tt = pya.CplxTrans(mLineWidth, 0, False, mPosL.x, mPosL.y) mNum = s.text(self.num).transform(tt) else: #Create Vernier Left 2 vLeft = s.vernier(vWidth / dbu, vLength / dbu, vPitch / dbu + self.res / dbu) vLeft.transform( pya.Trans(2, False, vPosL.x - vLength / dbu - vGap / dbu, vPosL.y)) #Create Vernier Bottom 2 vBot = s.vernier(vWidth / dbu, vLength / dbu, vPitch / dbu + self.res / dbu) vBot.transform( pya.Trans(3, False, vPosB.x, vPosB.y - vLength / dbu - vGap / dbu)) #Create Mask Number tt = pya.CplxTrans(mLineWidth, 0, False, mPosR.x, mPosR.y) mNum = s.text(self.num).transform(tt) #Creates the Wafer Alignment Mark region = pya.Region() region.insert(cross) region.insert(vLeft) region.insert(vBot) region.insert(mNum) if (self.type == 1) and (self.mask == 0): region = s.invert(region, border / dbu) self.cell.shapes(self.layer_layer).insert(region)
def produce_impl(self): # Cross parameters cWidth = 10 cLength = 100 cGap = 0 cBorder = 10 cPos = pya.Point(0,0) # Vernier parameters vWidth = 4 vLength = 40 vPitch = 8 vGap = 0 vPosL = pya.Point(-120000,cPos.y) vPosB = pya.Point(cPos.x,-120000) # Mask number parameters mLineWidth = 4 mPos = pya.Point(140000,140000) # Border border = 10 # Create references to the active cell cv = pya.CellView().active() layout = cv.layout() dbu = self.layout.dbu # Position of the Alignment Marks posLeftMark = pya.Point(-self.pos*1000/dbu,0) posRightMark = pya.Point(self.pos*1000/dbu,0) s = shape() #Creates a cross if (self.cross == 0): #Solid Cross if (self.type == 0): #Wafer Type #Creates an inverted cross cross = s.cross((cWidth+2*cGap)/dbu, (cLength + 2*cGap)/dbu) cross = s.invert(cross, cBorder/dbu) cross.transform(pya.Trans(cPos)) else: cross = s.cross(cWidth/dbu, cLength/dbu) cross.transform(pya.Trans(cPos)) else: #Dashed Cross if (self.type == 0): #Wafer Type cross = s.cross(cWidth/dbu, cLength/dbu,1) cross = s.invert(cross, cBorder/dbu) cross.transform(pya.Trans(cPos)) else: cross = s.cross(cWidth/dbu, cLength/dbu,2) cross.transform(pya.Trans(cPos)) if (self.type == 0): #Wafer Type #Create Vernier Patterns vLeft = s.vernier(vWidth/dbu, vLength/dbu, vPitch/dbu) vLeft.transform(pya.Trans(vPosL)) vBot = vLeft.dup() vBot.transform(pya.Trans(1,0,0,0)) vRight = vLeft.dup() vRight.transform(pya.Trans(2,0,0,0)) vTop = vLeft.dup() vTop.transform(pya.Trans(3,0,0,0)) #Create Mask Number tt = pya.CplxTrans(mLineWidth, 0, False, -mPos.x, mPos.y) mNumLeft = s.text(self.num).transform(tt) mNumRight = mNumLeft.dup() mNumRight.transform(pya.Trans(2,True,0,0)) else: #Create Vernier Left 2 vLeft = s.vernier(vWidth/dbu, vLength/dbu, vPitch/dbu+self.res/dbu) vLeft.transform(pya.Trans(2, False, vPosL.x-vLength/dbu-vGap/dbu, vPosL.y)) vBot = vLeft.dup() vBot.transform(pya.Trans(1,0,0,0)) vRight = vLeft.dup() vRight.transform(pya.Trans(2,0,0,0)) vTop = vLeft.dup() vTop.transform(pya.Trans(3,0,0,0)) #Create Mask Number tt = pya.CplxTrans(mLineWidth, 0, False, -mPos.x, -mPos.y) mNumLeft = s.text(self.num).transform(tt) mNumRight = mNumLeft.dup() mNumRight.transform(pya.Trans(2,True,0,0)) #Create Shapes for Left Mark and Right Mark leftMarkCross = cross.dup() leftMarkCross.transform(pya.Trans(posLeftMark)) leftMarkVernierLeft = vLeft.dup() leftMarkVernierLeft.transform(pya.Trans(posLeftMark)) leftMarkVernierBot = vBot.dup() leftMarkVernierBot.transform(pya.Trans(posLeftMark)) leftMarkVernierRight = vRight.dup() leftMarkVernierRight.transform(pya.Trans(posLeftMark)) leftMarkVernierTop = vTop.dup() leftMarkVernierTop.transform(pya.Trans(posLeftMark)) leftMarkMNumLeft = mNumLeft.dup() leftMarkMNumLeft.transform(pya.Trans(posLeftMark)) leftMarkMNumRight = mNumRight.dup() leftMarkMNumRight.transform(pya.Trans(posLeftMark)) rightMarkCross = cross.dup() rightMarkCross.transform(pya.Trans(posRightMark)) rightMarkVernierLeft = vLeft.dup() rightMarkVernierLeft.transform(pya.Trans(posRightMark)) rightMarkVernierBot = vBot.dup() rightMarkVernierBot.transform(pya.Trans(posRightMark)) rightMarkVernierRight = vRight.dup() rightMarkVernierRight.transform(pya.Trans(posRightMark)) rightMarkVernierTop = vTop.dup() rightMarkVernierTop.transform(pya.Trans(posRightMark)) rightMarkMNumLeft = mNumLeft.dup() rightMarkMNumLeft.transform(pya.Trans(posRightMark)) rightMarkMNumRight = mNumRight.dup() rightMarkMNumRight.transform(pya.Trans(posRightMark)) #Creates the Wafer Alignment MarkCross regionLeft = pya.Region() regionLeft.insert(leftMarkCross) regionLeft.insert(leftMarkVernierLeft) regionLeft.insert(leftMarkVernierBot) regionLeft.insert(leftMarkVernierRight) regionLeft.insert(leftMarkVernierTop) regionLeft.insert(leftMarkMNumLeft) regionLeft.insert(leftMarkMNumRight) regionRight = pya.Region() regionRight.insert(rightMarkCross) regionRight.insert(rightMarkVernierLeft) regionRight.insert(rightMarkVernierBot) regionRight.insert(rightMarkVernierRight) regionRight.insert(rightMarkVernierTop) regionRight.insert(rightMarkMNumLeft) regionRight.insert(rightMarkMNumRight) if (self.type == 1) and (self.mask == 0): regionLeft = s.invert(regionLeft,border/dbu) regionRight = s.invert(regionRight,border/dbu) self.cell.shapes(self.layer_layer).insert(regionLeft) self.cell.shapes(self.layer_layer).insert(regionRight)
#Constants for certain RGB colors WHITE = (255, 255, 255) BLACK = (0, 0, 0) RED = (255, 0, 0) GREEN = (0, 255, 0) pygame.display.set_caption(("A* Shortest Pathfinder")) icon = pygame.image.load("maze.png") pygame.display.set_icon(icon) pygame.init() #List of different shape objects shapes = [ shape((29, 12), (31, 15), (31, 18), (29, 19), (25, 18), (25, 15)), shape((5, 15), (5, 19), (17, 19), (17, 15)), shape((7, 3), (10, 8), (8, 13), (4, 12), (3, 8)), shape((23, 3), (23, 11), (28, 11), (28, 3)), shape((31, 3), (33, 5), (32, 13), (29, 5)), shape((18, 3), (19, 5), (16, 8), (16, 4)), shape((11, 12), (13, 6), (15, 12)), shape((18, 13), (20, 18), (23, 16)) ] #Fixed starting and ending locations start_fixed = ((2 * scalex, 18 * scaley)) end_fixed = ((34 * scalex, 3 * scaley)) startrand = random.randint(1, 19) endrand = random.randint(1, 19)
def DFEM_BVP_1D(space,T,source,cond): ''' This function solves a two-point BVP using discontinuous Galerkin finite elements. INPUT: nw, xw, w: number of integration points, nodes, and weights nels: number of elements ord: lost of polynomial order for corresponsing elements xnod, nod, nnodes: list of node coordinates, global numbering of nodes, and total number of nodes OUTPUT: sol: is the numerical solution of the corresponding FEM coefficients A. Alberti 07/2017 ''' nw,xw,w = QuadParams.QP(space.maxord) ## set mesh parameters to spatial grid nels = space.nels order = space.order nod = space.nod xnod = space.xnod edge = space.edge xedge = space.xedge nnodes = space.nnodes ## set up matrix and rhs of linear system stiff = np.zeros((nnodes,nnodes)); rhsf = np.zeros(nnodes)#rhsf = np.zeros((nnodes,1)); # impose dirichlet boudnary conditions on solution sol = np.zeros(nnodes) sol[0] = T(space.bounds[0]) # space.bounds[0] BC sol[-1] = T(space.bounds[1]) #space.bounds[1] # BC for el in range(0,nels): # for each element... xL = xnod[nod[el,0]] # ...leftmost node xR = xnod[nod[el,order[el]-1]] # ...rightmost node dx = (xR-xL)/2. # Jacobian of transformation for nodes xEdgeL = xedge[edge[el,0]] # ...leftmost edge xEdgeR = xedge[edge[el,1]] # ...rightmost edge dxEdge = (xEdgeR-xEdgeL)/2. # Jacobian of transformation for edges # compute element stiffness matrix and load vector k = np.zeros((order[el],order[el])) # element stiffness matrix f = np.zeros(order[el]) # element load vector lmbda = 1 for l in range(0,nw): x = xL + (1 + xw[l])*dx # t runs in true element, xw runs in reference element xEdge = xEdgeL + (1 + xw[l])*dxEdge psi,dpsi = shape.shape(xw[l],order[el]) # calculations on ref.element kval = cond(x) fval = source(x) f = f + fval * psi *w[l]*dxEdge k = k + kval*np.outer(dpsi, dpsi)/dx/dx * w[l]*dx if el == 0: # first element f[0] = f[0] - T(space.bounds[0]) k[order[el]-1,order[el]-1] = k[order[el]-1,order[el]-1] - 1.0 elif el==nels-1: # last element f[1] = f[1] + T(space.bounds[1]) else: k[order[el]-1,order[el]-1] = k[order[el]-1,order[el]-1] - 1.0 # print(Cyan+'k');print(mat) # print(Cyan+'RHS');print(f) # add the computed element stiffness matrix and load vector to the global matrix and vector for idx in range(0,order[el]): rhsf[nod[el,idx]] = rhsf[nod[el,idx]] + f[idx] for idy in range(0,order[el]): stiff[nod[el,idx],nod[el,idy]] = stiff[nod[el,idx],nod[el,idy]] + k[idx][idy] if el!=nels-1: stiff[nod[el,idx]+1,nod[el,idy]] = 1.0 # # uncomment to see the global stiffness matrix and load vector # print(Cyan+'s stiffness mat');print(stiff) # print(Cyan+'RHS');print(rhsf) # sys.exit() rhsf = np.subtract(rhsf , np.dot(stiff,sol)) sol[1:-1] = np.linalg.solve(stiff[1:-1,1:-1],rhsf[1:-1]) return(sol)
def CFEM_BVP_1D(space,T,source,cond): ''' This function solves a two-point BVP using continuous Galerkin finite elements. - either first or second order FE - Numerical integration is used in computation of stiffness matrix and rhs INPUT: nw, xw, w: number of integration points, nodes, and weights nels: number of elements ord: lost of polynomial order for corresponsing elements xnod, nod, nnodes: list of node coordinates, global numbering of nodes, and total number of nodes OUTPUT: sol: is the numerical solution of the corresponding FEM coefficients A. Alberti 06/2017 Referenced from M. Peszynska MTH659 FEM Course ''' nw,xw,w = QuadParams.QP(space.maxord) ## set mesh parameters to spatial grid nels = space.nels order = space.order nod = space.nod xnod = space.xnod nnodes = space.nnodes ## set up matrix and rhs of linear system stiff = np.zeros((nnodes,nnodes)); rhsf = np.zeros(nnodes)#rhsf = np.zeros((nnodes,1)); for el in range(0,nels): # for each element in all elements xL = xnod[nod[el,0]] # left endpoint on element xR = xnod[nod[el,order[el]-1]] # right endpoint on element dx = (xR-xL)/2. # Jacobian of transformation # compute element stiffness matrix and load vector k = np.zeros((order[el],order[el])) # element stiffness matrix f = np.zeros(order[el]) # element load vector for l in range(0,nw): x = xL + (1 + xw[l])*dx # x runs in true element, xw runs in reference element # print('x -> '+str(x)) psi,dpsi = shape.shape(xw[l],order[el]) # calculations on ref.element kval = cond(x) fval = source(x) f = f + fval * psi *w[l]*dx k = k + kval*np.outer(dpsi, dpsi)/dx/dx * w[l]*dx # # uncomment to see the local (stiffness+mass) matrix and local load vector # print(k) # print(f) # sys.exit() # add the computed element stiffness matrix and load vector to the global matrix and vector for idx in range(0,order[el]): rhsf[nod[el,idx]] = rhsf[nod[el,idx]] + f[idx] for idy in range(0,order[el]): stiff[nod[el,idx],nod[el,idy]] = stiff[nod[el,idx],nod[el,idy]] + k[idx][idy] # impose Dirichlet boundary conditions eliminate known values from the system sol = np.zeros(nnodes) sol[0] = T(space.bounds[0]) #space.bounds[0] # BC sol[-1] = T(space.bounds[1]) #space.bounds[1] # BC mat = stiff # rhsf = np.subtract(rhsf , np.dot(mat,sol)) # SOLVE! (for coefficients of finite elements, still not the \emph{actual} solution) sol[1:-1] = np.linalg.solve(mat[1:-1,1:-1],rhsf[1:-1]) return(sol)
def run(d, *, squash=False): print("") print(d) print(shape(d, squash=squash))
def load(self,path): self.layers=[] f=inp() y_pos=0.0 if f.load(os.path.join(path,"epitaxy.inp"))!=False: number_of_layers=int(f.get_next_val()) f.to_sections(start="#layer_type") for s in f.sections: a=epi_layer() a.layer_type=s.layer_type a.dos_file=s.layer_dos_file if a.dos_file.startswith("dos")==True: a.layer_type="active" a.pl_file=s.layer_pl_file a.file_name=s.layer_base_shape if a.file_name!="none": a.load(os.path.join(get_sim_path(),a.file_name)) else: a.name=s.layer_name a.cal_rgb() #shape temp=s.layer_shape #value if temp=="none": a.shapes=[] else: files=temp.split(",") for sh in files: my_shape=shape() my_shape.load(sh) a.shapes.append(my_shape) #lumo a.lumo_file=s.layer_lumo #lumo a.homo_file=s.layer_homo #interface_file a.interface_file=s.layer_interface a.solve_optical_problem=s.solve_optical_problem a.solve_thermal_problem=s.solve_thermal_problem a.start=y_pos y_pos=y_pos+a.dy a.end=y_pos self.layers.append(a) self.contacts.load() self.loaded=True #self.dump_tree() changed=False for l in self.layers: if l.interface_file=="none": l.interface_file=self.gen_new_electrical_file("interface") changed=True if changed==True: self.save()
COLOR_AVG = colorAverage() end = time.time() duration = end - start DURATION_SUM += duration DURATION_AVG = DURATION_SUM / 10 find_color = rgb2colorname.color_detect(red, green, blue) co_width, co_height = color_img.shape[:2] center_x = int(co_height / 2.0) center_y = int(co_width / 2.0) font = cv2.FONT_ITALIC (text_width, text_height), baseline = cv2.getTextSize(find_color, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 1) location = (center_x - 30, center_y + int(text_height / 2)) cv2.putText(color_img, find_color, location, cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 0), 1, 8) cv2.imwrite('images/color_result2.png', color_img) img = cv2.imread("images/result.jpg") tmp = img rs_width, rs_height = img.shape[:2] shadow.grabcut(5, 10, rs_height - 10, rs_width - 5) find_shape = shape.shape() find_print = imprint.detect_text('images/result.jpg') if find_print == None: find_print = '' print(find_color + "," + find_shape + "," + find_print)
def run_tetris(): board = tetris_board() level = 1 lost = False holding_shape = None shapes_to_fall = get_next_shape([]) falling_shape = shape(shapes_to_fall.pop(0)) next_shape = shape(shapes_to_fall.pop(0)) has_swapped = False last_action_time = 0 while not lost: composite_display(board, board.score, level, falling_shape, holding_shape, next_shape) fall_time = calculate_next_frame(level) while time.time() < fall_time: # look for input action = get_next_action(fall_time - time.time()) if action != NO_INPUT: last_action_time = time.time() if action == KILL_ME: exit(0) elif action == ROTATE_RIGHT: falling_shape = board.rotate_shape_right(falling_shape) elif action == ROTATE_LEFT: falling_shape = board.rotate_shape_left(falling_shape) elif action == MOVE_RIGHT: falling_shape = board.move_shape_right(falling_shape) elif action == MOVE_LEFT: falling_shape = board.move_shape_left(falling_shape) elif action == DROP_SHAPE: falling_shape = board.drop_shape(falling_shape) elif action == MOVE_DOWN: falling_shape = board.fall_shape(falling_shape, True) elif action == SWAP: if holding_shape is None: holding_shape = falling_shape holding_shape.reset_position() shapes_to_fall = get_next_shape(shapes_to_fall) falling_shape = shape(shapes_to_fall.pop(0)) has_swapped = True if holding_shape is not None and not has_swapped: has_swapped = True tmp = falling_shape falling_shape = holding_shape holding_shape = tmp holding_shape.reset_position() if falling_shape is None: falling_shape = next_shape shapes_to_fall = get_next_shape(shapes_to_fall) next_shape = shape(shapes_to_fall.pop(0)) has_swapped = False composite_display(board, board.score, level, falling_shape, holding_shape, next_shape) if board.score / 25 > level: level += 1 falling_shape = board.fall_shape(falling_shape, not (time.time() - last_action_time) > 1) if falling_shape is None: falling_shape = next_shape shapes_to_fall = get_next_shape(shapes_to_fall) next_shape = shape(shapes_to_fall.pop(0)) has_swapped = False if board.has_intersection(falling_shape): lost = True