def test_add(): asm = ADD_Operation().resolve() print(asm) expected = ASM(''' // MACRO=LOAD_SP @SP A=M // MACRO_END // pop y into D A=A-1 D=M // pop x into M A=A-1 // do the operation M=M+D // MACRO=DEC_SP @SP M=M-1 // MACRO_END ''') assert str(asm) == str(expected) # make sure it output valid assembly assembler = Assembler() assembler.assemble(str(asm))
def experiment01(): """ Compute the quantity of interest, it's expectation and variance """ # # FE Discretization # # Computational mesh mesh = Mesh1D(resolution=(64, )) # Element element = QuadFE(mesh.dim(), 'DQ0') dofhandler = DofHandler(mesh, element) dofhandler.distribute_dofs() # Linear Functional mesh.mark_region('integrate', lambda x: x > 0.75, entity_type='cell', strict_containment=False) phi = Basis(dofhandler) assembler = Assembler(Form(1, test=phi, flag='integrate')) assembler.assemble() L = assembler.get_vector()
def test_assemble_iiform(self): mesh = Mesh1D(resolution=(1, )) Q1 = QuadFE(1, 'DQ1') dofhandler = DofHandler(mesh, Q1) dofhandler.distribute_dofs() phi = Basis(dofhandler, 'u') k = Explicit(lambda x, y: x * y, n_variables=2, dim=1) kernel = Kernel(k) form = IIForm(kernel, test=phi, trial=phi) assembler = Assembler(form, mesh) assembler.assemble() Ku = Nodal(lambda x: 1 / 3 * x, basis=phi) #af = assembler.af[0]['bilinear'] M = assembler.get_matrix().toarray() u = Nodal(lambda x: x, basis=phi) u_vec = u.data() self.assertTrue(np.allclose(M.dot(u_vec), Ku.data()))
def test_assemble_ipform(self): # ===================================================================== # Test 7: Assemble Kernel # ===================================================================== mesh = Mesh1D(resolution=(10, )) Q1 = QuadFE(1, 'DQ1') dofhandler = DofHandler(mesh, Q1) dofhandler.distribute_dofs() phi = Basis(dofhandler, 'u') k = Explicit(lambda x, y: x * y, n_variables=2, dim=1) kernel = Kernel(k) form = IPForm(kernel, test=phi, trial=phi) assembler = Assembler(form, mesh) assembler.assemble() #af = assembler.af[0]['bilinear'] M = assembler.get_matrix().toarray() u = Nodal(lambda x: x, basis=phi) v = Nodal(lambda x: 1 - x, basis=phi) u_vec = u.data() v_vec = v.data() I = v_vec.T.dot(M.dot(u_vec)) self.assertAlmostEqual(I[0, 0], 1 / 18)
def sensitivity_sample_qoi(exp_q, dofhandler): """ Sample QoI by means of Taylor expansion J(q+dq) ~= J(q) + dJdq(q)dq """ # Basis phi = Basis(dofhandler, 'v') phi_x = Basis(dofhandler, 'vx') # Define problem exp_q_fn = Nodal(data=exp_q, basis=phi) primal = [Form(exp_q_fn, test=phi_x, trial=phi_x), Form(1, test=phi)] adjoint = [Form(exp_q_fn, test=phi_x, trial=phi_x), Form(0, test=phi)] qoi = [Form(exp_q_fn, test=phi_x)] problems = [primal, adjoint, qoi] # Define assembler assembler = Assembler(problems) # # Dirichlet conditions for primal problem # assembler.add_dirichlet('left', 0, i_problem=0) assembler.add_dirichlet('right', 1, i_problem=0) # Dirichlet conditions for adjoint problem assembler.add_dirichlet('left', 0, i_problem=1) assembler.add_dirichlet('right', -1, i_problem=1) # Assemble system assembler.assemble() # Compute solution and qoi at q (primal) u = assembler.solve(i_problem=0) # Compute solution of the adjoint problem v = assembler.solve(i_problem=1) # Evaluate J J = u.dot(assembler.get_vector(2)) # # Assemble gradient # ux_fn = Nodal(data=u, basis=phi_x) vx_fn = Nodal(data=v, basis=phi_x) k_int = Kernel(f=[exp_q_fn, ux_fn, vx_fn], F=lambda exp_q, ux, vx: exp_q * ux * vx) problem = [Form(k_int, test=phi)] assembler = Assembler(problem) assembler.assemble() dJ = -assembler.get_vector() return dJ
def sample_qoi(q, dofhandler): """ Sample total energy of output for a given sample of q's """ # # Set up weak form # # Basis phi = Basis(dofhandler, 'v') phi_x = Basis(dofhandler, 'vx') # Elliptic problem problems = [[Form(q, test=phi_x, trial=phi_x), Form(1, test=phi)], [Form(1, test=phi, trial=phi)]] # Assemble assembler = Assembler(problems, mesh) assembler.assemble() # System matrices A = assembler.af[0]['bilinear'].get_matrix() b = assembler.af[0]['linear'].get_matrix() M = assembler.af[1]['bilinear'].get_matrix() # Define linear system system = LS(phi) system.add_dirichlet_constraint('left',1) system.add_dirichlet_constraint('right',0) n_samples = q.n_samples() y_smpl = [] QoI_smpl = [] for i in range(n_samples): # Sample system if n_samples > 1: Ai = A[i] else: Ai = A system.set_matrix(Ai) system.set_rhs(b.copy()) # Solve system system.solve_system() # Record solution and qoi y = system.get_solution(as_function=False) y_smpl.append(y) QoI_smpl.append(y.T.dot(M.dot(y))) # Convert to numpy array y_smpl = np.concatenate(y_smpl,axis=1) QoI = np.concatenate(QoI_smpl, axis=1).ravel() return y_smpl, QoI
def test02_1d_dirichlet_higher_order(self): mesh = Mesh1D() for etype in ['Q2', 'Q3']: element = QuadFE(1, etype) dofhandler = DofHandler(mesh, element) dofhandler.distribute_dofs() # Basis functions ux = Basis(dofhandler, 'ux') u = Basis(dofhandler, 'u') # Exact solution ue = Nodal(f=lambda x: x * (1 - x), basis=u) # Define coefficient functions one = Constant(1) two = Constant(2) # Define forms a = Form(kernel=Kernel(one), trial=ux, test=ux) L = Form(kernel=Kernel(two), test=u) problem = [a, L] # Assemble problem assembler = Assembler(problem, mesh) assembler.assemble() A = assembler.get_matrix() b = assembler.get_vector() # Set up linear system system = LinearSystem(u, A=A, b=b) # Boundary functions bnd_left = lambda x: np.abs(x) < 1e-9 bnd_right = lambda x: np.abs(1 - x) < 1e-9 # Mark mesh mesh.mark_region('left', bnd_left, entity_type='vertex') mesh.mark_region('right', bnd_right, entity_type='vertex') # Add Dirichlet constraints to system system.add_dirichlet_constraint('left', 0) system.add_dirichlet_constraint('right', 0) # Solve system system.solve_system() system.resolve_constraints() # Compare solution with the exact solution ua = system.get_solution(as_function=True) self.assertTrue(np.allclose(ua.data(), ue.data()))
def test01_solve_2d(self): """ Solve a simple 2D problem with no hanging nodes """ mesh = QuadMesh(resolution=(5, 5)) # Mark dirichlet boundaries mesh.mark_region('left', lambda x, dummy: np.abs(x) < 1e-9, entity_type='half_edge') mesh.mark_region('right', lambda x, dummy: np.abs(x - 1) < 1e-9, entity_type='half_edge') Q1 = QuadFE(mesh.dim(), 'Q1') dQ1 = DofHandler(mesh, Q1) dQ1.distribute_dofs() phi = Basis(dQ1, 'u') phi_x = Basis(dQ1, 'ux') phi_y = Basis(dQ1, 'uy') problem = [ Form(1, test=phi_x, trial=phi_x), Form(1, test=phi_y, trial=phi_y), Form(0, test=phi) ] assembler = Assembler(problem, mesh) assembler.add_dirichlet('left', dir_fn=0) assembler.add_dirichlet('right', dir_fn=1) assembler.assemble() # Get matrix dirichlet correction and right hand side A = assembler.get_matrix().toarray() x0 = assembler.assembled_bnd() b = assembler.get_vector() ua = np.zeros((phi.n_dofs(), 1)) int_dofs = assembler.get_dofs('interior') ua[int_dofs, 0] = np.linalg.solve(A, b - x0) dir_bc = assembler.get_dirichlet() dir_vals = np.array([dir_bc[dof] for dof in dir_bc]) dir_dofs = [dof for dof in dir_bc] ua[dir_dofs] = dir_vals ue_fn = Nodal(f=lambda x: x[:, 0], basis=phi) ue = ue_fn.data() self.assertTrue(np.allclose(ue, ua)) self.assertTrue(np.allclose(x0 + A.dot(ua[int_dofs, 0]), b))
def deobfuscate(codestring): # Instructions are stored as a string, we need # to convert it to an array of the raw bytes insBytes = bytearray(codestring) oep = find_oep(insBytes) logger.info('Original code entrypoint at {}'.format(oep)) logger.info('Starting control flow analysis...') disasm = Disassembler(insBytes, oep) disasm.find_leaders() disasm.construct_basic_blocks() disasm.build_bb_edges() logger.info('Control flow analysis completed.') logger.info('Starting simplication of basic blocks...') render_graph(disasm.bb_graph, 'before.svg') simplifier = Simplifier(disasm.bb_graph) simplifier.eliminate_forwarders() render_graph(simplifier.bb_graph, 'after_forwarder.svg') simplifier.merge_basic_blocks() logger.info('Simplification of basic blocks completed.') simplified_graph = simplifier.bb_graph render_graph(simplified_graph, 'after.svg') logger.info('Beginning verification of simplified basic block graph...') if not verify_graph(simplified_graph): logger.error('Verification failed.') raise SystemExit logger.info('Verification succeeded.') logger.info('Assembling basic blocks...') asm = Assembler(simplified_graph) codestring = asm.assemble() logger.info('Successfully assembled. ') return codestring
def compile_pascal(source, dest, is_debug = False, is_interpret = False, out_stream = sys.stdout, output_tokens = False, output_bytecodes = False, lib = ['.'], in_stream = sys.stdin): ''' DID YOU KNOW that compile() is a built in function? ''' set_debug(is_debug) debug("Compiling %s into %s" % (source, dest)) scanner = Scanner(source) tokens = scanner.scan() if output_tokens: write(tokens, source + "_tokenized") debug('scanning complete') parser = Parser(tokens, source, lib = lib) bytecodes, success = parser.parse() if output_bytecodes: if is_debug: write(prettify(bytecodes), source + "_unassembled") else: write(bytecodes, source + "_unassembled") if not success: print 'Parsing error' return debug('parsing complete') assembler = Assembler(bytecodes) assembled = assembler.assemble() if is_debug: write(prettify(assembled), dest + '_debug') write(assembled, dest) debug('assembly complete.' ) if is_interpret: interp = Interpreter(out_stream, in_stream, code = assembled) interp.interpret() else: debug('run program now with `python interpreter.py %s`' % dest)
def start(self): print("Starting MRI_FID_Widget") # send 1 as signal to start MRI_FID_Widget gsocket.write(struct.pack('<I', 1)) # enable/disable GUI elements self.startButton.setEnabled(False) self.stopButton.setEnabled(True) self.applyFreqButton.setEnabled(True) self.gradOffset_x.setEnabled(True) self.gradOffset_y.setEnabled(True) self.gradOffset_z.setEnabled(True) self.gradOffset_z2.setEnabled(True) self.acquireButton.setEnabled(True) self.saveShimButton.setEnabled(True) self.loadShimButton.setEnabled(True) self.zeroShimButton.setEnabled(True) self.openFlipangletoolBtn.setEnabled(True) # setup global socket for receive data gsocket.setReadBufferSize(8 * self.size) gsocket.readyRead.connect(self.read_data) # send the sequence to the backend ass = Assembler() seq_byte_array = ass.assemble(self.seq_filename) print(len(seq_byte_array)) gsocket.write(struct.pack('<I', len(seq_byte_array))) gsocket.write(seq_byte_array) self.load_shim() self.idle = False
def start(self): print("Starting MRI_SE_Widget") # send 2 as signal to start MRI_SE_Widget gsocket.write(struct.pack('<I', 2)) # enable/disable GUI elements self.startButton.setEnabled(False) self.stopButton.setEnabled(True) self.gradOffset_x.setEnabled(True) self.gradOffset_y.setEnabled(True) self.gradOffset_z.setEnabled(True) self.gradOffset_z2.setEnabled(True) self.acquireButton.setEnabled(True) self.saveShimButton.setEnabled(True) self.loadShimButton.setEnabled(True) self.zeroShimButton.setEnabled(True) self.zoomCheckBox.setEnabled(True) self.peakWindowCheckBox.setEnabled(True) self.cycAcqBtn.setEnabled(False) self.cyclesValue.setEnabled(False) # setup global socket for receive data gsocket.readyRead.connect(self.read_data) # send the sequence to the backend ass = Assembler() seq_byte_array = ass.assemble(self.seq_filename) print(len(seq_byte_array)) gsocket.write(struct.pack('<I', len(seq_byte_array))) gsocket.write(seq_byte_array) self.load_shim() self.idle = False
def test_assemble(self): from assembler import Assembler assbl = Assembler(sequences, identifiers) assbl._find_matching_pairs = MagicMock(return_value=(map_top_bottom, map_bottom_top)) assbl._determine_order = MagicMock(return_value=order) self.assertEqual(assbl.assemble(), assembled_seq)
def sampling_error(): """ Test the sampling error by comparing the accuracy of the quantities of interest q1 = E[|y|] and q2 = E[y(0.5)] """ c = Verbose() mesh = Mesh1D(resolution=(1026,)) mesh.mark_region('left', lambda x:np.abs(x)<1e-10) mesh.mark_region('right', lambda x:np.abs(x-1)<1e-10) element = QuadFE(1,'Q1') dofhandler = DofHandler(mesh, element) dofhandler.distribute_dofs() dofhandler.set_dof_vertices() phi = Basis(dofhandler,'u') phi_x = Basis(dofhandler,'ux') ns_ref = 10000 z = get_points(n_samples=ns_ref) q = set_diffusion(dofhandler,z) problems = [[Form(q, test=phi_x, trial=phi_x), Form(1, test=phi)], [Form(1, test=phi, trial=phi)]] c.tic('assembling') assembler = Assembler(problems, mesh) assembler.assemble() c.toc() A = assembler.af[0]['bilinear'].get_matrix() b = assembler.af[0]['linear'].get_matrix() M = assembler.af[0]['bilinear'].get_matrix() system = LS(phi) system.add_dirichlet_constraint('left') system.add_dirichlet_constraint('right') c.tic('solving') for n in range(ns_ref): system.set_matrix(A[n]) system.set_rhs(b.copy()) system.solve_system() c.toc()
def touch(f): click.echo(click.format_filename(f)) fasta_parser = FASTAparser(f) parsed_sequences = fasta_parser.parse() assembler = Assembler(parsed_sequences) result = assembler.assemble() with open("result_assembled_sequence.txt", "w") as text_file: text_file.write(result)
def main(args): if len(args) != 2: print "USAGE:", args[0], "program.asm" print "\tprogram.asm is the source asm file" print "\tA hack file will be created from the source file." print "\tThe output file will use the same prefix as the source, but" print "\tthe extension will be .hack" sys.exit(1) # the source filename source_filename = args[1] # create the assembler and assemble the code try: assembler = Assembler(source_filename) assembler.assemble() except IOError: print "ERROR: Could not open source file or error writing to destination"
def send_pulse(self, inp_file): ''' Sends the pulse sequence to the server ''' # write a 3 to signal that the button has been pushed gsocket.write(struct.pack('<I', 3 << 28)) ass = Assembler() btye_array = ass.assemble(inp_file) print("Byte array = {}".format(btye_array)) print("Length of byte array = {}".format(len(btye_array))) gsocket.write(btye_array) print("Sent byte array")
def touch(fasta_file, output_file, show): click.echo(click.format_filename(fasta_file)) fasta_parser = FastaParser(fasta_file) fragments, fragment_ids = fasta_parser.parse() assembler = Assembler(fragments, fragment_ids, print_fragment_id_order=show) assembled = assembler.assemble() with open(output_file, "w") as text_file: text_file.write(assembled)
def sample_state(mesh,dQ,z,mflag,reference=False): """ Compute the sample output corresponding to a given input """ n_samples = z.shape[0] q = set_diffusion(dQ,z) phi = Basis(dQ,'u', mflag) phi_x = Basis(dQ, 'ux', mflag) if reference: problems = [[Form(q,test=phi_x,trial=phi_x), Form(1,test=phi)], [Form(1,test=phi, trial=phi)], [Form(1,test=phi_x, trial=phi_x)]] else: problems = [[Form(q,test=phi_x,trial=phi_x), Form(1,test=phi)]] assembler = Assembler(problems, mesh, subforest_flag=mflag) assembler.assemble() A = assembler.af[0]['bilinear'].get_matrix() b = assembler.af[0]['linear'].get_matrix() if reference: M = assembler.af[1]['bilinear'].get_matrix() K = assembler.af[2]['bilinear'].get_matrix() system = LS(phi) system.add_dirichlet_constraint('left') system.add_dirichlet_constraint('right') n_dofs = dQ.n_dofs(subforest_flag=mflag) y = np.empty((n_dofs,n_samples)) for n in range(n_samples): system.set_matrix(A[n]) system.set_rhs(b.copy()) system.solve_system() y[:,n] = system.get_solution(as_function=False)[:,0] y_fn = Nodal(dofhandler=dQ,subforest_flag=mflag,data=y) if reference: return y_fn, M, K else: return y_fn
def test02_variance(): """ Compute the variance of J(q) for different mesh refinement levels and compare with MC estimates. """ l_max = 8 for i_res in np.arange(2, l_max): # Computational mesh mesh = Mesh1D(resolution=(2**i_res, )) # Element element = QuadFE(mesh.dim(), 'DQ0') dofhandler = DofHandler(mesh, element) dofhandler.distribute_dofs() # Linear Functional mesh.mark_region('integrate', lambda x: x >= 0.75, entity_type='cell', strict_containment=False) phi = Basis(dofhandler) assembler = Assembler(Form(4, test=phi, flag='integrate')) assembler.assemble() L = assembler.get_vector() # Define Gaussian random field C = Covariance(dofhandler, name='gaussian', parameters={'l': 0.05}) C.compute_eig_decomp() eta = GaussianField(dofhandler.n_dofs(), K=C) eta.update_support() n_samples = 100000 J_paths = L.dot(eta.sample(n_samples=n_samples)) var_mc = np.var(J_paths) lmd, V = C.get_eig_decomp() LV = L.dot(V) var_an = LV.dot(np.diag(lmd).dot(LV.transpose())) print(var_mc, var_an)
class Streamer: #Global variables fo = open('authentication.txt') lines = [str(line.rstrip('\n')) for line in fo] consumer_key = lines[0] consumer_secret = lines[1] access_token = lines[2] access_token_secret = lines[3] fo.close() # OAuth process, using the keys and tokens auth = tweepy.OAuthHandler(consumer_key, consumer_secret) auth.set_access_token(access_token, access_token_secret) # Creation of the actual interface, using authentication api = tweepy.API(auth) def __init__(self): self.assembler = Assembler() self.wrapper = Wrapper() def priceupdate(self, base, mid, quote): timestamp = datetime.fromtimestamp(time.time()) rates = self.assembler.assemble(base, mid, quote) base_per_mid, mid_per_quote = rates[0], rates[1] last_update = self.wrapper.c.execute("SELECT * FROM Prices ORDER BY year DESC, month DESC, day DESC, hour DESC, minute DESC").fetchone() new_price = base_per_mid*mid_per_quote last_price = last_update[5]*last_update[6] delta = new_price/last_price - 1 self.wrapper.update_price_db(timestamp, base_per_mid, mid_per_quote) if delta >= 0: return '[%s CST]: The average #dogecoin price is now $%.6f, +%.1f%% growth wow (%.2f bits)' \ % (timestamp.strftime('%m-%d %H:%M'), new_price, delta*100, base_per_mid*(1000000)) else: return '[%s CST]: The average #dogecoin price is now $%.6f, %.1f%% decline (%.2f bits)' \ % (timestamp.strftime('%m-%d %H:%M'), new_price, delta*100, base_per_mid*(1000000)) #return '[%s CST]: The average #dogecoin price is now $%.6f (%.2f bits)' \ #% (timestamp.strftime('%m-%d %H:%M'), new_price, base_per_mid*(1000000)) #return '[%s CST]: The average dogecoin price is now %.2f bits ($%.6f).\n$1 = Ð%.2f\n1BTC = Ð%d' % (datetime.fromtimestamp(time.time()).strftime('%m-%d %H:%M:%S'), dogebtcprice, dogeusdprice, 1/dogeusdprice, dogebtcprice*100000) #Continuous price stream def stream(self): print 'Initiating Dogecoin Price Stream --------------------------' while True: try: tweet = self.priceupdate('DOGE', 'BTC', 'USD') self.api.update_status(tweet) print tweet print 'Tweeted successfully' except Exception, e: print str(e) time.sleep(3570)
def test01_solve_1d(self): """ Test solving 1D systems """ mesh = Mesh1D(resolution=(20, )) mesh.mark_region('left', lambda x: np.abs(x) < 1e-9) mesh.mark_region('right', lambda x: np.abs(x - 1) < 1e-9) Q1 = QuadFE(1, 'Q1') dQ1 = DofHandler(mesh, Q1) dQ1.distribute_dofs() phi = Basis(dQ1, 'u') phi_x = Basis(dQ1, 'ux') problem = [Form(1, test=phi_x, trial=phi_x), Form(0, test=phi)] assembler = Assembler(problem, mesh) assembler.add_dirichlet('left', dir_fn=0) assembler.add_dirichlet('right', dir_fn=1) assembler.assemble() # Get matrix dirichlet correction and right hand side A = assembler.get_matrix().toarray() x0 = assembler.assembled_bnd() b = assembler.get_vector() ua = np.zeros((phi.n_dofs(), 1)) int_dofs = assembler.get_dofs('interior') ua[int_dofs, 0] = np.linalg.solve(A, b - x0) dir_bc = assembler.get_dirichlet() dir_vals = np.array([dir_bc[dof] for dof in dir_bc]) dir_dofs = [dof for dof in dir_bc] ua[dir_dofs] = dir_vals ue_fn = Nodal(f=lambda x: x[:, 0], basis=phi) ue = ue_fn.data() self.assertTrue(np.allclose(ue, ua)) self.assertTrue(np.allclose(x0 + A.dot(ua[int_dofs, 0]), b))
def upload_seq(self): ''' Takes an input text file, compiles it to machine code ''' dialog = QFileDialog() # open a Dialog box to take the file fname = dialog.getOpenFileName(None, "Import Pulse Sequence", "", "Text files (*.txt)") # returns a tuple, fname[0] is filename(including path), fname[1] is file type inp_file = fname[0] print("Uploading sequence to server") try: ass = Assembler() self.upload_seq_byte_array = ass.assemble(inp_file) self.uploadSeq.setText(inp_file) except IOError as e: print("Error: required txt file doesn't exist") return print("Uploaded successfully to server")
self.pc = 2 while self.pc < end and program[self.pc] != opset.HALT: instruction = program[self.pc] self.pc += 1 if opset.nullary(instruction): self.debug("%02d %s", self.pc, opset.byte2name[instruction]) self.nullary[instruction]() elif opset.unary(instruction): argument = program[self.pc] self.pc += 1 self.debug("%02d %s %s", self.pc, opset.byte2name[instruction], argument) self.unary[instruction - opset.LIT](argument) if __name__ == "__main__": from sys import argv from assembler import Assembler from argparser import parseArgs # Grab command line arguments args = parseArgs() try: asm = Assembler(args.debug) vm = VirtualMachine(args.debug) vm.run(asm.assemble(open(args.filename))) except Exception as e: print(e) # vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4
def set_pulse(self, inp_file): ''' Sends the default pulse sequence to the server ''' ass = Assembler() self.default_seq_byte_array = ass.assemble(inp_file) gsocket.write(self.default_seq_byte_array) return
def main(): totalTime = 0.0 startTime = time.time() parser = OptionParser("usage: %prog [options] src_file [src_file...]") parser.add_option("-v", "--verbose", action="store_true", dest="verbose", default=False, help="Verbose output.") parser.add_option("-l", "--log", dest="logLevel", default=0, help="Print detailed log information.") parser.add_option("-t", "--test", action="store_true", dest="test", default=False, help="Run assembler test code.") parser.add_option("-d", "--debug", action="store_true", dest="debug", default=False, help="Turn on assembler debugging code.") parser.add_option("-s", "--syntax-only", action="store_true", dest="syntaxOnly", default=False, help="Exit after checking syntax.") (options, args) = parser.parse_args() if len(args) < 1: parser.error("At least one source file must be supplied!") sys.exit(1) sources = [] for arg in args: sources.append(arg) if not os.path.isfile(arg): parser.error("File \"%s\" does not exist" % arg) sys.exit(1) buildname = os.path.basename(os.getcwd()) firstfile = args[0] firstfilename = args[0].split('.')[0] listfile = open(firstfile + ".lst", 'w') symtabfile = open(firstfile + ".symtab", 'w') binfile = open(firstfile + ".bin", 'wb') logfile = None if options.logLevel > 0: logfile = open(firstfilename + ".log", 'w') context = Context(Architecture.AGC4_B2, listfile, binfile, options, int(options.logLevel), logfile) assembler = Assembler(context) context.assembler = assembler if options.debug: print "Build:", buildname endTime = time.time() delta = endTime - startTime totalTime += delta print "Initialisation: %3.2f seconds" % delta assembler.info("Simple AGC Assembler, v0.1", source=False) assembler.info("", source=False) startTime = time.time() for arg in args: try: assembler.assemble(arg) except: print >>sys.stderr print >>sys.stderr, "EXCEPTION:" traceback.print_exc(file=sys.stderr) print >>sys.stderr, "Context:" print >>sys.stderr, context raise if options.debug: endTime = time.time() delta = endTime - startTime totalTime += delta print "Pass 1: %3.2f seconds" % delta context.saveCurrentBank() if options.syntaxOnly == False and context.errors == 0: assembler.info("Resolving symbols...", source=False) startTime = time.time() try: assembler.resolve() except: assembler.log(1, "EXCEPTION:\n%s" % context) raise if options.debug: endTime = time.time() delta = endTime - startTime totalTime += delta for record in assembler.context.records: record.printMessages() assembler.info("Writing listing...", source=False) startTime = time.time() print >>listfile print >>listfile, "Listing" print >>listfile, "-------" for record in assembler.context.records: print >>listfile, record if options.debug: endTime = time.time() delta = endTime - startTime totalTime += delta print "Write listing: %3.2f seconds" % delta if not options.syntaxOnly: assembler.info("Writing symbol table listing...", source=False) startTime = time.time() print >>listfile print >>listfile, "Symbol Table" print >>listfile, "------------" assembler.context.symtab.printTable(listfile) if options.debug: endTime = time.time() delta = endTime - startTime totalTime += delta print "Write symbol table listing: %3.2f seconds" % delta if not options.syntaxOnly and context.errors == 0: assembler.info("Writing symbol table...", source=False) startTime = time.time() assembler.context.symtab.write(symtabfile) if options.debug: endTime = time.time() delta = endTime - startTime totalTime += delta print "Write symbol table: %3.2f seconds" % delta if context.errors == 1: msg = "1 error, " else: msg = "%d errors, " % (context.errors) if context.warnings == 1: msg += "1 warning, " else: msg += "%d warnings, " % (context.warnings) assembler.info(msg, source=False) print msg if not options.syntaxOnly: if options.test: startTime = time.time() # FIXME: Temporary hack # Check generated symbols against the symtab generated by yaYUL. assembler.info("Checking symbol table against yaYUL version...", source=False) from artemis072_symbols import ARTEMIS_SYMBOLS from memory import MemoryType nsyms = assembler.context.symtab.getNumSymbols() check_nsyms = len(ARTEMIS_SYMBOLS.keys()) assembler.info("Number of symbols: yaYUL=%d pyagc=%d" % (check_nsyms, nsyms), source=False) my_syms = [] other_syms = [] common_syms = [] for sym in assembler.context.symtab.keys(): if sym in ARTEMIS_SYMBOLS.keys(): common_syms.append(sym) else: if sym != "FIXED": my_syms.append(sym) for sym in ARTEMIS_SYMBOLS.keys(): if sym not in assembler.context.symtab.keys(): if not sym.startswith('$') and sym != "'": other_syms.append(sym) if len(my_syms) != 0 or len(other_syms) != 0: assembler.error("incorrect number of symbols, expected %d, got %d" % (check_nsyms, nsyms), source=False) if len(my_syms) > 0: assembler.error("symbols defined that should not be defined: %s" % my_syms, source=False) if len(other_syms) > 0: assembler.error("symbols not defined that should be defined: %s" % other_syms, source=False) errcount = 0 bad_syms = {} for sym in common_syms: entry = assembler.context.symtab.lookup(sym) if entry == None: assembler.error("symbol %-8s not defined" % entry, source=False) pa = entry.value aval = ARTEMIS_SYMBOLS[sym] if ',' in aval: bank = aval.split(',')[0] type = MemoryType.FIXED if bank.startswith('E'): bank = bank[1:] type = MemoryType.ERASABLE bank = int(bank, 8) offset = int(aval.split(',')[1], 8) check_pa = context.memmap.segmentedToPseudo(type, bank, offset, absolute=True) else: check_pa = int(aval, 8) if pa != check_pa: errcount += 1 bad_syms[pa] = (sym, check_pa) if errcount > 0: bad_addrs = bad_syms.keys() bad_addrs.sort() for pa in bad_addrs: sym = bad_syms[pa][0] check_pa = bad_syms[pa][1] assembler.error("symbol %-8s defined as %06o %s, expected %06o %s" % (sym, pa, context.memmap.pseudoToSegmentedString(pa), check_pa, context.memmap.pseudoToSegmentedString(check_pa)), source=False) assembler.error("%d/%d symbols incorrectly defined" % (errcount, len(common_syms)), source=False) if options.debug: endTime = time.time() delta = endTime - startTime totalTime += delta print "Symbol checking: %3.2f seconds" % delta # FIXME: End of temporary hack if not options.syntaxOnly and context.errors == 0: assembler.info("Writing binary output...", source=False) startTime = time.time() ocode = ObjectCode(context) ocode.generateBuggers() ocode.write(binfile) if options.debug: endTime = time.time() delta = endTime - startTime totalTime += delta print "Binary generation: %3.2f seconds" % delta assembler.info("Writing rope usage...", source=False) startTime = time.time() print >>listfile print >>listfile print >>listfile, "Bank Usage" print >>listfile, "----------" print >>listfile ocode.writeUsage(listfile) if options.debug: endTime = time.time() delta = endTime - startTime totalTime += delta print "Rope usage: %3.2f seconds" % delta assembler.info("Writing rope image listing...", source=False) startTime = time.time() print >>listfile print >>listfile print >>listfile, "Rope Image Listing" print >>listfile, "------------------" print >>listfile ocode.writeListing(listfile) if options.debug: endTime = time.time() delta = endTime - startTime totalTime += delta print "Rope image listing: %3.2f seconds" % delta assembler.info("Done.", source=False) listfile.close() symtabfile.close() binfile.close() if logfile: logfile.close() if options.debug: print "Total time: %3.2f seconds" % totalTime print "Done."
def main(): args = parser.parse_args() a = Assembler(args.debug) a.assemble(args.asm_path)
class Converter: #Global variables fo = open('authentication.txt') lines = [str(line.rstrip('\n')) for line in fo] consumer_key = lines[0] consumer_secret = lines[1] access_token = lines[2] access_token_secret = lines[3] fo.close() # OAuth process, using the keys and tokens auth = tweepy.OAuthHandler(consumer_key, consumer_secret) auth.set_access_token(access_token, access_token_secret) # Creation of the actual interface, using authentication api = tweepy.API(auth) #All 168 foreign currencies able to be converted via bitcoinaverage #Bypasses openexchangerates.org currency_codes = ['AED' , 'AFN' , 'ALL' , 'AMD' , 'ANG' , 'AOA' , 'ARS' , 'AUD' , 'AWG' ,\ 'AZN' , 'BAM' , 'BBD' , 'BDT' , 'BGN' , 'BHD' , 'BIF' , 'BMD' , 'BND' ,\ 'BOB' , 'BRL' , 'BSD' , 'BTC' , 'BTN' , 'BWP' , 'BYR' , 'BZD' , 'CAD' ,\ 'CDF' , 'CHF' , 'CLF' , 'CLP' , 'CNY' , 'COP' , 'CRC' , 'CUP' , 'CVE' ,\ 'CZK' , 'DJF' , 'DKK' , 'DOP' , 'DZD' , 'EEK' , 'EGP' , 'ERN' , 'ETB' ,\ 'EUR' , 'FJD' , 'FKP' , 'GBP' , 'GEL' , 'GGP' , 'GHS' , 'GIP' , 'GMD' ,\ 'GNF' , 'GTQ' , 'GYD' , 'HKD' , 'HNL' , 'HRK' , 'HTG' , 'HUF' , 'IDR' ,\ 'ILS' , 'IMP' , 'INR' , 'IQD' , 'IRR' , 'ISK' , 'JEP' , 'JMD' , 'JOD' ,\ 'JPY' , 'KES' , 'KGS' , 'KHR' , 'KMF' , 'KPW' , 'KRW' , 'KWD' , 'KYD' ,\ 'KZT' , 'LAK' , 'LBP' , 'LKR' , 'LRD' , 'LSL' , 'LTL' , 'LVL' , 'LYD' ,\ 'MAD' , 'MDL' , 'MGA' , 'MKD' , 'MMK' , 'MNT' , 'MOP' , 'MRO' , 'MTL' ,\ 'MUR' , 'MVR' , 'MWK' , 'MXN' , 'MYR' , 'MZN' , 'NAD' , 'NGN' , 'NIO' ,\ 'NOK' , 'NPR' , 'NZD' , 'OMR' , 'PAB' , 'PEN' , 'PGK' , 'PHP' , 'PKR' ,\ 'PLN' , 'PYG' , 'QAR' , 'RON' , 'RSD' , 'RUB' , 'RWF' , 'SAR' , 'SBD' ,\ 'SCR' , 'SDG' , 'SEK' , 'SGD' , 'SHP' , 'SLL' , 'SOS' , 'SRD' , 'STD' ,\ 'SVC' , 'SYP' , 'SZL' , 'THB' , 'TJS' , 'TMT' , 'TND' , 'TOP' , 'TRY' ,\ 'TTD' , 'TWD' , 'TZS' , 'UAH' , 'UGX' , 'USD' , 'UYU' , 'UZS' , 'VEF' ,\ 'VND' , 'VUV' , 'WST' , 'XAF' , 'XAG' , 'XAU' , 'XCD' , 'XDR' , 'XOF' ,\ 'XPF' , 'YER' , 'ZAR' , 'ZMK' , 'ZMW' , 'ZWL'] #Expanding to other cryptocurrencies in v1.7 cryptocurrency_codes = [] def __init__(self): self.assembler = Assembler() self.wrapper = Wrapper() def populate_db(self): for mention in self.api.mentions_timeline(): self.wrapper.update_mentions_db(mention.user.screen_name, mention.id, mention.text) #Return True if mention is a duplicate, False otherwise def no_duplicates(self, mention): command = "SELECT * FROM Mentions WHERE id = %d" % (mention.id) duplicates = self.wrapper.c.execute(command).fetchall() if len(duplicates) == 0: return True return False def insert_into_db(self, mention): self.wrapper.update_mentions_db(mention.user.screen_name, mention.id, mention.text) def convert(self, mention): if self.no_duplicates(mention): user = mention.user.screen_name #Textual trigger if '@dogepricebot convert' in mention.text.lower(): print "Found conversion request" print user+" : "+mention.text words = mention.text.lower().split(" ") command_start = words.index('@dogepricebot') amount, base, quote = float(words[command_start+2]), words[command_start+3], words[command_start+5] if base.lower() == "dogecoin" or base.lower() == "doge": rates = self.assembler.assemble(quote.upper()) rate = rates[0]*rates[1] tweet = '@%s wow such convert: %.1f #dogecoin = %.2f %s' % (user, amount, amount*rate, quote.upper()) print tweet self.api.update_status(tweet) else: rates = self.assembler.assemble(base.upper()) rate = rates[0]*rates[1] tweet = '@%s wow such convert: %.1f %s = %.2f #dogecoin' % (user, amount, base.upper(), amount/rate) print tweet self.api.update_status(tweet) self.insert_into_db(mention) else: print "duplicate" #Continuous price stream def listen(self): print 'Listening for @dogepricebot convert requests --------------------------' while True: for mention in self.api.mentions_timeline(count=10): try: self.convert(mention) except Exception, e: print "In exception" print str(e) time.sleep(300)
def reference_qoi(f, tht, basis, region, n=1000000, verbose=True): """ Parameters ---------- f : lambda function, Function of θ to be integrated. tht : GaussianField, Random field θ defined on mesh in terms of its mean and covariance basis : Basis, Basis function defining the nodal interpolant. It incorporates the mesh, the dofhandler, and the derivative. region : meshflag, Flag indicating the region of integration n : int, default=1000000 Sample size Returns ------- Q_ref : double, Reference quantity of interest err : double, Expected RMSE given by var(Q)/n. """ # # Assemble integral # batch_size = 100000 n_batches = n // batch_size + (0 if (n % batch_size) == 0 else 1) if verbose: print('Computing Reference Quantity of Interest') print('========================================') print('Sample size: ', n) print('Batch size: ', batch_size) print('Number of batches: ', n_batches) Q_smpl = np.empty(n) for k in range(n_batches): # Determine sample sizes for each batch if k < n_batches - 1: n_sample = batch_size else: # Last sample may be smaller than batch_size n_sample = n - k * batch_size if verbose: print(' - Batch Number ', k) print(' - Sample Size: ', n_sample) print(' - Sampling random field') # Sample from field tht_smpl = tht.sample(n_sample) # Define kernel tht_n = Nodal(data=tht_smpl, basis=basis) kf = Kernel(tht_n, F=f) # Define forms if k == 0: problems = [[Form(kernel=kf, flag=region)], [Form(flag=region)]] else: problems = [Form(kernel=kf, flag=region)] if verbose: print(' - Assembling.') # Compute the integral assembler = Assembler(problems, basis.mesh()) assembler.assemble() # # Compute statistic # # Get samples if k == 0: dx = assembler.get_scalar(i_problem=1) if verbose: print(' - Updating samples \n') batch_sample = assembler.get_scalar(i_problem=0, i_sample=None) Q_smpl[k * batch_size:k * batch_size + n_sample] = batch_sample / dx # Compute mean and MSE Q_ref = np.mean(Q_smpl) err = np.var(Q_smpl) / n # Return reference return Q_ref, err
def plot_heuristics(f, tht, basis, region, condition): """ Parameters ---------- f : lambda, Function of θ to be integrated. n : int, Sample size for Monte Carlo sample """ tht.update_support() # # Plot samples of the random field # n = 10000 tht_sample = tht.sample(n) tht_fn = Nodal(data=tht_sample, basis=basis) # # Compute the quantity of interest # # Define the kernel kf = Kernel(tht_fn, F=f) # Assemble over the mesh problems = [[Form(kernel=kf, flag=region)], [Form(flag=region)]] assembler = Assembler(problems, basis.mesh()) assembler.assemble() # Extract sample dx = assembler.get_scalar(i_problem=1) q_sample = assembler.get_scalar(i_sample=None) / dx # # Compute correlation coefficients of q with spatial data # plot = Plot(quickview=False) fig, ax = plt.subplots() plt_args = {'linewidth': 0.5, 'color': 'k'} ax = plot.line(tht_fn, axis=ax, i_sample=list(range(100)), plot_kwargs=plt_args) fig.savefig('ex01_sample_paths.eps') fig, ax = plt.subplots() ftht = Nodal(data=f(tht_sample), basis=basis) ax = plot.line(ftht, axis=ax, i_sample=list(range(100)), plot_kwargs=plt_args) fig.savefig('ex01_integrand.eps') fig, ax = plt.subplots(1, 1) plt.hist(q_sample, bins=50, density=True) ax.set_title(r'Histogram $Q(\theta)$') fig.savefig('ex01_histogram.eps') plt.close('all') dh = basis.dofhandler() n_dofs = dh.n_dofs() # Extract the region on which we condition cnd_dofs = dh.get_region_dofs(entity_flag=condition) I = np.eye(n_dofs) I = I[cnd_dofs, :] # Measured tht tht_msr = tht_sample[cnd_dofs, 0][:, None] n_cnd = 30 cnd_tht = tht.condition(I, tht_msr, n_samples=n_cnd) #cnd_tht_data = np.array([tht_sample[:,0] for dummy in range(n_cnd)]) #cnd_tht_data[cnd_dofs,:] = cnd_tht cnd_tht_fn = Nodal(data=f(cnd_tht), basis=basis) fig, ax = plt.subplots() ax = plot.line(cnd_tht_fn, axis=ax, i_sample=np.arange(n_cnd), plot_kwargs=plt_args) fig.tight_layout() plt.show()
def test09_1d_inverse(self): """ Compute the inverse of a matrix and apply it to a vector/matrix. """ # # Mesh # mesh = Mesh1D(resolution=(1, )) mesh.mark_region('left', lambda x: np.abs(x) < 1e-9, on_boundary=True) mesh.mark_region('right', lambda x: np.abs(1 - x) < 1e-9, on_boundary=True) # # Elements # Q3 = QuadFE(1, 'Q3') dofhandler = DofHandler(mesh, Q3) dofhandler.distribute_dofs() # # Basis # u = Basis(dofhandler, 'u') ux = Basis(dofhandler, 'ux') # # Define sampled right hand side and exact solution # xv = dofhandler.get_dof_vertices() n_points = dofhandler.n_dofs() n_samples = 6 a = np.arange(n_samples) ffn = lambda x, a: a * x ufn = lambda x, a: a / 6 * (x - x**3) + x fdata = np.zeros((n_points, n_samples)) udata = np.zeros((n_points, n_samples)) for i in range(n_samples): fdata[:, i] = ffn(xv, a[i]).ravel() udata[:, i] = ufn(xv, a[i]).ravel() # Define sampled function fn = Nodal(data=fdata, basis=u) ue = Nodal(data=udata, basis=u) # # Forms # one = Constant(1) a = Form(Kernel(one), test=ux, trial=ux) L = Form(Kernel(fn), test=u) problem = [[a], [L]] # # Assembler # assembler = Assembler(problem, mesh) assembler.assemble() A = assembler.get_matrix() b = assembler.get_vector(i_problem=1) # # Linear System # system = LinearSystem(u, A=A) # Set constraints system.add_dirichlet_constraint('left', 0) system.add_dirichlet_constraint('right', 1) system.solve_system(b) # Extract finite element solution ua = system.get_solution(as_function=True) system2 = LinearSystem(u, A=A, b=b) # Set constraints system2.add_dirichlet_constraint('left', 0) system2.add_dirichlet_constraint('right', 1) system2.solve_system() u2 = system2.get_solution(as_function=True) # Check that the solution is close self.assertTrue(np.allclose(ue.data()[:, 0], ua.data()[:, 0])) self.assertTrue(np.allclose(ue.data()[:, [0]], u2.data()))
def test08_1d_sampled_rhs(self): # # Mesh # mesh = Mesh1D(resolution=(1, )) mesh.mark_region('left', lambda x: np.abs(x) < 1e-9, on_boundary=True) mesh.mark_region('right', lambda x: np.abs(1 - x) < 1e-9, on_boundary=True) # # Elements # Q3 = QuadFE(1, 'Q3') dofhandler = DofHandler(mesh, Q3) dofhandler.distribute_dofs() # # Basis # v = Basis(dofhandler, 'u') vx = Basis(dofhandler, 'ux') # # Define sampled right hand side and exact solution # xv = dofhandler.get_dof_vertices() n_points = dofhandler.n_dofs() n_samples = 6 a = np.arange(n_samples) f = lambda x, a: a * x u = lambda x, a: a / 6 * (x - x**3) + x fdata = np.zeros((n_points, n_samples)) udata = np.zeros((n_points, n_samples)) for i in range(n_samples): fdata[:, i] = f(xv, a[i]).ravel() udata[:, i] = u(xv, a[i]).ravel() # Define sampled function fn = Nodal(data=fdata, basis=v) ue = Nodal(data=udata, basis=v) # # Forms # one = Constant(1) a = Form(Kernel(one), test=vx, trial=vx) L = Form(Kernel(fn), test=v) problem = [a, L] # # Assembler # assembler = Assembler(problem, mesh) assembler.assemble() A = assembler.get_matrix() b = assembler.get_vector() # # Linear System # system = LinearSystem(v, A=A, b=b) # Set constraints system.add_dirichlet_constraint('left', 0) system.add_dirichlet_constraint('right', 1) #system.set_constraint_relation() #system.incorporate_constraints() # Solve and resolve constraints system.solve_system() #system.resolve_constraints() # Extract finite element solution ua = system.get_solution(as_function=True) # Check that the solution is close print(ue.data()[:, [0]]) print(ua.data()) self.assertTrue(np.allclose(ue.data()[:, [0]], ua.data()))
def test05_2d_dirichlet(self): """ Two dimensional Dirichlet problem with hanging nodes """ # # Define mesh # mesh = QuadMesh(resolution=(1, 2)) mesh.cells.get_child(1).mark(1) mesh.cells.refine(refinement_flag=1) mesh.cells.refine() # # Mark left and right boundaries # bm_left = lambda x, dummy: np.abs(x) < 1e-9 bm_right = lambda x, dummy: np.abs(1 - x) < 1e-9 mesh.mark_region('left', bm_left, entity_type='half_edge') mesh.mark_region('right', bm_right, entity_type='half_edge') for etype in ['Q1', 'Q2', 'Q3']: # # Element # element = QuadFE(2, etype) dofhandler = DofHandler(mesh, element) dofhandler.distribute_dofs() # # Basis # u = Basis(dofhandler, 'u') ux = Basis(dofhandler, 'ux') uy = Basis(dofhandler, 'uy') # # Construct forms # ue = Nodal(f=lambda x: x[:, 0], basis=u) ax = Form(kernel=Kernel(Constant(1)), trial=ux, test=ux) ay = Form(kernel=Kernel(Constant(1)), trial=uy, test=uy) L = Form(kernel=Kernel(Constant(0)), test=u) problem = [ax, ay, L] # # Assemble # assembler = Assembler(problem, mesh) assembler.assemble() # # Get system matrices # A = assembler.get_matrix() b = assembler.get_vector() # # Linear System # system = LinearSystem(u, A=A, b=b) # # Constraints # # Add dirichlet conditions system.add_dirichlet_constraint('left', ue) system.add_dirichlet_constraint('right', ue) # # Solve # system.solve_system() #system.resolve_constraints() # # Check solution # ua = system.get_solution(as_function=True) self.assertTrue(np.allclose(ua.data(), ue.data()))
class data(QObject): # Init signal thats emitted when readout is processed readout_finished = pyqtSignal() t1_finished = pyqtSignal() t2_finished = pyqtSignal() uploaded = pyqtSignal(bool) def __init__(self): super(data, self).__init__() self.initVariables() # Read sequence files self.seq_fid = 'sequence/FID.txt' self.seq_se = 'sequence/SE_te.txt' self.seq_ir = 'sequence/IR_ti.txt' self.seq_sir = 'sequence/SIR_ti.txt' self.seq_2dSE = 'sequence/img/2DSE.txt' # Define Gradients self.GR_x = 0 self.GR_y = 1 self.GR_z = 2 self.GR_z2 = 3 #_______________________________________________________________________________ # Establish host connection and disconnection def conn_client(self, ip): socket.connectToHost(ip, 1001) socket.waitForConnected(1000) if socket.state() == connected: print("Connection to server esteblished.") elif socket.state() == unconnected: print("Conncection to server failed.") return False else: print("TCP socket in state : ", socket.state()) return socket.state() self.set_at(params.at) self.set_freq(params.freq) return True def disconn_client(self): try: socket.disconnectFromHost() except: pass if socket.state() == unconnected: print("Disconnected from server.") else: print("Connection to server still established.") #_______________________________________________________________________________ # Functions for initialization of variables def initVariables(self): # Flags self.ir_flag = False self.se_flag = False self.fid_flag = False # Variables self.size = 50000 # total data received (defined by the server code) self.buffer = bytearray(8 * self.size) self.data = np.frombuffer(self.buffer, np.complex64) # Variables #self.time = 20 self.freq_range = 250000 #_______________________________________________________________________________ # Functions for Setting up sequence # Function to set default FID sequence def set_FID( self ): # Function to init and set FID -- only acquire call is necessary afterwards self.assembler = Assembler() byte_array = self.assembler.assemble(self.seq_fid) socket.write(struct.pack('<I', 4 << 28)) socket.write(byte_array) while (True): # Wait until bytes written if not socket.waitForBytesWritten(): break socket.setReadBufferSize(8 * self.size) self.ir_flag = False self.se_flag = False self.fid_flag = True print("\nFID sequence uploaded.") # Function to set default FID sequence def set_2dSE( self ): # Function to init and set FID -- only acquire call is necessary afterwards self.assembler = Assembler() byte_array = self.assembler.assemble(self.seq_2dSE) socket.write(struct.pack('<I', 4 << 28)) socket.write(byte_array) while (True): # Wait until bytes written if not socket.waitForBytesWritten(): break socket.setReadBufferSize(8 * self.size) print("\n2D SE sequence uploaded.") # Function to set default SE sequence def set_SE(self, TE=10): # Function to modify SE -- call whenever acquiring a SE # Change TE in sequence and push to server params.te = TE self.change_TE(params.te) #, REC) self.assembler = Assembler() byte_array = self.assembler.assemble(self.seq_se) socket.write(struct.pack('<I', 4 << 28)) socket.write(byte_array) while (True): # Wait until bytes written if not socket.waitForBytesWritten(): break socket.setReadBufferSize(8 * self.size) self.ir_flag = False self.se_flag = True self.fid_flag = False print("\nSE sequence uploaded with TE = ", TE, " ms.") # Function to change TE in sequence def change_TE( self, TE ): # Function for changing TE value in sequence -- called inside set_SE # Open sequence and read lines f = open(self.seq_se, 'r+') lines = f.readlines() if TE < 2: TE = 2 # Modify TE time in the 8th last line lines[-10] = 'PR 3, ' + str(int(TE / 2 * 1000 - 112)) + '\t// wait&r\n' lines[-6] = 'PR 3, ' + str(int(TE / 2 * 1000 - 975)) + '\t// wait&r\n' # Close and write/save modified sequence f.close() with open(self.seq_se, "w") as out_file: for line in lines: out_file.write(line) # Function to set default IR sequence def set_IR( self, TI=15 ): #, REC=1000): # Function to modify SE -- call whenever acquiring a SE params.ti = TI self.change_IR(params.ti, self.seq_ir) #, REC) self.assembler = Assembler() byte_array = self.assembler.assemble(self.seq_ir) socket.write(struct.pack('<I', 4 << 28)) socket.write(byte_array) while (True): # Wait until bytes written if not socket.waitForBytesWritten(): break socket.setReadBufferSize(8 * self.size) self.ir_flag = True self.se_flag = False self.fid_flag = False print("\nIR sequence uploaded with TI = ", TI, " ms.") #" and REC = ", REC, " ms.") # Function to change TI in IR sequence def change_IR(self, TI, seq): f = open(seq, 'r+') # Open sequence and read lines lines = f.readlines() # Modify TI time in the 8th last line lines[-14] = 'PR 3, ' + str(int(TI * 1000 - 198)) + '\t// wait&r\n' f.close() # Close and write/save modified sequence with open(seq, "w") as out_file: for line in lines: out_file.write(line) # Function to set default SIR sequence def set_SIR(self, TI=15): params.ti = TI #self.change_SIR(params.ti, self.seq_sir) self.assembler = Assembler() byte_array = self.assembler.assemble(self.seq_sir) socket.write(struct.pack('<I', 4 << 28)) socket.write(byte_array) while (True): # Wait until bytes written if not socket.waitForBytesWritten(): break socket.setReadBufferSize(8 * self.size) print("\nSIR sequence uploaded with TI = ", TI, " ms.") #" and REC = ", REC, " ms.") # Function to change TI in SIR sequence def change_SIR(self, TI, seq): f = open(seq, 'r+') # Open sequence and read lines lines = f.readlines() # Modify TI time in the 8th last line #ines[-14] = 'PR 3, ' + str(int(TI * 1000 - 198)) + '\t// wait&r\n' #lines[-18] = 'PR 3, ' + str(int(TI * 1000 - 198)) + '\t// wait&r\n' lines[-9] = 'PR 3, ' + str(int(TI * 1000 - 198)) + '\t// wait&r\n' lines[-13] = 'PR 3, ' + str(int(TI * 1000 - 198)) + '\t// wait&r\n' f.close() # Close and write/save modified sequence with open(seq, "w") as out_file: for line in lines: out_file.write(line) # Set uploaded sequence def set_uploaded_seq(self, seq): print("Set uploaded Sequence.") self.assembler = Assembler() byte_array = self.assembler.assemble(seq) socket.write(struct.pack('<I', 4 << 28)) socket.write(byte_array) while (True): # Wait until bytes written if not socket.waitForBytesWritten(): break # Multiple function calls socket.setReadBufferSize(8 * self.size) print(byte_array) print("Sequence uploaded to server.") self.uploaded.emit(True) #_______________________________________________________________________________ # Functions to Control Console # Function to triffer acquisition and perform single readout def acquire(self, ts=20): t0 = time.time() # calculate time for acquisition socket.write(struct.pack('<I', 1 << 28)) while (True): # Wait until bytes written if not socket.waitForBytesWritten(): break while True: # Read data socket.waitForReadyRead() datasize = socket.bytesAvailable() # print(datasize) time.sleep(0.0001) if datasize == 8 * self.size: print("Readout finished : ", datasize) self.buffer[0:8 * self.size] = socket.read(8 * self.size) t1 = time.time() # calculate time for acquisition break else: continue print("Start processing readout.") self.process_readout(ts) print("Start analyzing data.") self.analytics() print('Finished acquisition in {:.3f} ms'.format((t1 - t0) * 1000.0)) # Emit signal, when data was read self.readout_finished.emit() def acquireImage(self, npe=16, ts=20): socket.write(struct.pack('<I', 6 << 28 | npe)) while (True): # Wait until bytes written if not socket.waitForBytesWritten(): break for n in range(npe): while True: # Read data socket.waitForReadyRead() datasize = socket.bytesAvailable() time.sleep(0.0001) if datasize == 8 * self.size: print("Readout finished : ", datasize) self.buffer[0:8 * self.size] = socket.read(8 * self.size) break else: continue self.process_readout(ts) self.readout_finished.emit() def acquireProjection(self, idx, ts=20): print("Acquire projection along axis: ", idx, "\n") socket.write(struct.pack('<I', 7 << 28 | idx)) while (True): # Wait until bytes written if not socket.waitForBytesWritten(): break while True: # Read data socket.waitForReadyRead() datasize = socket.bytesAvailable() # print(datasize) time.sleep(0.0001) if datasize == 8 * self.size: print("Readout finished : ", datasize) self.buffer[0:8 * self.size] = socket.read(8 * self.size) t1 = time.time() # calculate time for acquisition break else: continue print("Start processing readout.") self.process_readout(ts) self.readout_finished.emit() # Function to set frequency def set_freq(self, freq): params.freq = freq socket.write(struct.pack('<I', 2 << 28 | int(1.0e6 * freq))) print("Set frequency!") # Function to set attenuation def set_at(self, at): params.at = at socket.write(struct.pack('<I', 3 << 28 | int(abs(at) / 0.25))) print("Set attenuation!") # Function to set gradient offsets def set_gradients(self, gx=None, gy=None, gz=None, gz2=None): if not gx == None: if np.sign(gx) < 0: sign = 1 else: sign = 0 socket.write( struct.pack('<I', 5 << 28 | self.GR_x << 24 | sign << 20 | abs(gx))) if not gy == None: if np.sign(gy) < 0: sign = 1 else: sign = 0 socket.write( struct.pack('<I', 5 << 28 | self.GR_y << 24 | sign << 20 | abs(gy))) if not gz == None: if np.sign(gz) < 0: sign = 1 else: sign = 0 socket.write( struct.pack('<I', 5 << 28 | self.GR_z << 24 | sign << 20 | abs(gz))) if not gz2 == None: if np.sign(gz2) < 0: sign = 1 else: sign = 0 #socket.write(struct.pack('<I', 5 << 28 | self.GR_z2 << 24 | sign << 20 | abs(gz2))) while (True): # Wait until bytes written if not socket.waitForBytesWritten(): break #self.acquire() #_______________________________________________________________________________ # Process and analyse acquired data # Function to process the readout: extract spectrum, real, imag and magnitude data def process_readout(self, ts): # Read buffer part of interest and perform FFT # Max. data index and crop data self.data_idx = int(ts * 250) self.dclip = self.data[0:self.data_idx] * 2000.0 # +-1V -> ultiply by 2000 to obtain mV timestamp = datetime.now() self.mag = np.abs(self.data) self.pha = np.angle(self.data) # Time domain data self.mag_t = np.abs(self.dclip) self.imag_t = np.imag(self.dclip) self.real_t = np.real(self.dclip) self.mag_con = np.convolve(self.mag_t, np.ones((50, )) / 50, mode='same') self.real_con = np.convolve(self.real_t, np.ones((50, )) / 50, mode='same') self.time_axis = np.linspace(0, ts, self.data_idx) # Frequency domain data self.freqaxis = np.linspace(-self.freq_range / 2, self.freq_range / 2, self.data_idx) # 5000 points ~ 20ms self.fft = np.fft.fftshift( np.fft.fft(np.fft.fftshift(self.dclip), n=self.data_idx, norm='ortho')) # Normalization through 1/sqrt(n) self.fft_mag = abs(self.fft) params.dataTimestamp = timestamp.strftime('%m/%d/%Y, %H:%M:%S') params.data = self.dclip params.freqaxis = self.freqaxis params.fft = self.fft_mag # Ampltiude and phase plot #fig, ax = plt.subplots(2,1) #ax[0].plot(self.time_axis, self.real_t) #ax[0].plot(self.time_axis, np.convolve(self.real_t, np.ones((50,))/50, mode='same')) #ax[1].plot(self.fft) #ax[1].psd(self.dclip, Fs=250, Fc=int(1.0e6 * params.freq)) #fig.tight_layout(); plt.show() print("\tReadout processed.") # Function to calculate parameter like snr and peak values def analytics(self): # calculate output parameters # Determine peak/maximum value: self.peak_value = round(np.max(self.fft_mag), 2) self.max_index = np.argmax(self.fft_mag) # Declarations win = int(self.data_idx / 20) N = 50 p_idx = self.max_index # Full with half maximum (fwhm): # Determine candidates inside peak window by substruction of half peakValue candidates = np.abs([ x - self.peak_value / 2 for x in self.fft_mag[p_idx - win:p_idx + win] ]) # Calculate index difference by findind indices of minima, calculate fwhm in Hz thereafter fwhm_idx = np.argmin(candidates[win:]) + win - np.argmin( candidates[:win]) self.fwhm_value = fwhm_idx * (abs(np.min(self.freqaxis)) + abs( np.max(self.freqaxis))) / self.data_idx # Verification of fwhm calculation #plt.plot(candidates) #plt.show() # Signal to noise ratio (SNR): # Determine noise by substruction of moving avg from signal movAvg = np.convolve(self.fft_mag, np.ones((N, )) / N, mode='same') noise = np.subtract(self.fft_mag, movAvg) # Calculate sdt. dev. outside a window, that depends on fwhm self.snr = round( self.peak_value / np.std([*noise[:p_idx - win], *noise[p_idx + win:]]), 2) # Verification of snr calculation #plt.plot(self.freqaxis, self.fft_mag); plt.plot(self.freqaxis, movAvg); #plt.plot([*noise[:p_idx-win], *noise[p_idx+win:]]) #plt.show() # Center frequency calculation: self.center_freq = round( params.freq + ((self.max_index - self.data_idx / 2) * self.freq_range / self.data_idx) / 1.0e6, 6) print("\tData analysed.") #_______________________________________________________________________________ # T1 Measurement # Acquires one or multiple T1 values through multiple IR's def T1_measurement(self, values, freq, recovery, **kwargs): print('T1 Measurement') avgPoint = kwargs.get('avgP', 1) avgMeas = kwargs.get('avgM', 1) seq_type = kwargs.get('seqType', 1) self.idxM = 0 self.idxP = 0 self.T1 = [] self.R2 = [] self.set_freq(freq) while self.idxM < avgMeas: print("Measurement : ", self.idxM + 1, "/", avgMeas) self.measurement = [] for self.ti in values: self.peaks = [] if seq_type == 'sir': self.set_SIR(self.ti) else: self.set_IR(self.ti) while self.idxP < avgPoint: print("Datapoint : ", self.idxP + 1, "/", avgPoint) time.sleep(recovery / 1000) socket.write(struct.pack('<I', 1 << 28)) while True: # Readout data socket.waitForReadyRead() datasize = socket.bytesAvailable() print(datasize) time.sleep(0.1) if datasize == 8 * self.size: print("IR readout finished : ", datasize) self.buffer[0:8 * self.size] = socket.read( 8 * self.size) break else: continue print("Start processing IR readout.") self.process_readout() print("Start analyzing IR data.") self.analytics() self.peaks.append( np.max(self.mag_con) * np.sign(self.real_con[np.argmin(self.real_con[0:50])])) #self.peaks.append(self.peak_value*np.sign(self.real_con[np.argmin(self.real_con[0:50])])) self.readout_finished.emit() self.idxP += 1 self.measurement.append(np.mean(self.peaks)) self.idxP = 0 def func(x): return p[0] - p[1] * np.exp(-p[2] * x) try: p, cov = curve_fit(self.T1_fit, values, self.measurement) # Calculate T1 value and error self.T1.append( round(1.44 * brentq(func, values[0], values[-1]), 2)) self.R2.append( round( 1 - (np.sum( (self.measurement - self.T1_fit(values, *p))**2) / (np.sum( (self.measurement - np.mean(self.measurement)) **2))), 5)) self.x_fit = np.linspace(0, int(1.2 * values[-1]), 1000) self.y_fit = self.T1_fit(self.x_fit, *p) self.fit_params = p except: # in case no fit found self.T1.append(float('nan')) self.R2.append(float('nan')) self.x_fit = float('nan') self.y_fit = float('nan') self.fit_params = float('nan') self.t1_finished.emit() self.idxM += 1 return np.nanmean(self.T1), np.nanmean(self.R2) # Calculates fit for multiple IR's to determine t0 def T1_fit(self, x, A, B, C): return A - B * np.exp(-C * x) #_______________________________________________________________________________ # T2 Measurement # Acquires one or multiple T2 values through multiple SE's def T2_measurement(self, values, freq, recovery, **kwargs): print('T1 Measurement') avgPoint = kwargs.get('avgP', 1) avgMeas = kwargs.get('avgM', 1) self.idxM = 0 self.idxP = 0 self.T2 = [] self.R2 = [] self.measurement = [] self.set_freq(freq) while self.idxM < avgMeas: print("Measurement : ", self.idxM + 1, "/", avgMeas) self.measurement = [] for self.te in values: self.peaks = [] self.set_SE(self.te) while self.idxP < avgPoint: print("Datapoint : ", self.idxP + 1, "/", avgPoint) time.sleep(recovery / 1000) socket.write(struct.pack('<I', 1 << 28)) while True: socket.waitForReadyRead() datasize = socket.bytesAvailable() print(datasize) time.sleep(0.1) if datasize == 8 * self.size: print("IR readout finished : ", datasize) self.buffer[0:8 * self.size] = socket.read( 8 * self.size) break else: continue print("Start processing SE readout.") self.process_readout() print("Start analyzing SE data.") self.analytics() self.peaks.append(np.max(self.mag_con)) self.readout_finished.emit() self.idxP += 1 self.measurement.append(np.mean(self.peaks)) self.idxP = 0 # Calculate T2 value and error try: p, cov = curve_fit(self.T2_fit, values, self.measurement, bounds=([0, self.measurement[0], 0], [10, 50000, 0.5])) # Calculation of T2: M(T2) = 0.37*(func(0)) = 0.37(A+B), T2 = -1/C * ln((M(T2)-A)/B) self.T2.append( round( -(1 / p[2]) * np.log( ((0.37 * (p[0] + p[1])) - p[0]) / p[1]), 5)) self.R2.append( round( 1 - (np.sum( (self.measurement - self.T2_fit(values, *p))**2) / (np.sum( (self.measurement - np.mean(self.measurement)) **2))), 5)) self.x_fit = np.linspace(0, int(1.2 * values[-1]), 1000) self.y_fit = self.T2_fit(self.x_fit, *p) self.fit_params = p self.t2_finished.emit() self.idxM += 1 except: self.T2.append(float('nan')) self.R2.append(float('nan')) self.x_fit = float('nan') self.y_fit = float('nan') self.fit_params = float('nan') self.t2_finished.emit() self.idxM += 1 return np.nanmean(self.T2), np.nanmean(self.R2) # Calculates fit for multiple SE's to determine drop of Mxy def T2_fit(self, x, A, B, C): return A + B * np.exp(-C * x)
def test_assemble(self): from assembler import Assembler assbl = Assembler(sequences) assbl._find_matching_pairs = MagicMock(return_value=(top_seq_dict, bottom_seq_dict, top_ranges_dict, bottom_ranges_dict)) assbl._determine_order = MagicMock(return_value=order) self.assertEqual(assbl.assemble(), assembled_seq)
class AssemblerTest(unittest.TestCase): def setUp(self): self.assembler = Assembler() def test_instance(self): thing = object() self.assembler.instance('thing', thing) result = self.assembler.assemble('thing') self.assertEqual(thing, result) def test_factory(self): def thing_maker(): return object() self.assembler.factory('thing', thing_maker) result1 = self.assembler.assemble('thing') self.assertTrue(isinstance(result1, object)) result2 = self.assembler.assemble('thing') self.assertTrue(isinstance(result2, object)) self.assertNotEqual(result1, result2) def test_assemble_with_args(self): def thing_maker(one, two): return [one, two] self.assembler.factory('thing', thing_maker) result = self.assembler.assemble('thing', 'one', 'two') self.assertEqual(['one', 'two'], result) def test_assemble_with_kwargs(self): def thing_maker(one, two): return [one, two] self.assembler.factory('thing', thing_maker) result = self.assembler.assemble('thing', two='one', one='two') self.assertEqual(['two', 'one'], result) def test_assemble_with_args_and_kwargs(self): def thing_maker(one, two, a=None, b=None): return [one, two, (a, b)] self.assembler.factory('thing', thing_maker) result = self.assembler.assemble('thing', 'one', 'two', b='b', a='a') self.assertEqual(['one', 'two', ('a', 'b')], result) def test_assemble_with_defaults(self): def thing_maker(one='one', two='two', a='a', b='b'): return [one, two, (a, b)] self.assembler.factory('thing', thing_maker) result = self.assembler.assemble('thing') self.assertEqual(['one', 'two', ('a', 'b')], result) def test_recursive_assemble(self): def thing1_maker(thing2): return thing2 def thing2_maker(): return 'instance of thing2' self.assembler.factory('thing1', thing1_maker) self.assembler.factory('thing2', thing2_maker) result = self.assembler.assemble('thing1') self.assertEqual('instance of thing2', result) def test_class_constructors(self): class A(object): def __init__(self, b, c): self.b = b self.c = c class B(object): def __init__(self): pass class C(object): def __init__(self, d): self.d = d class D(object): def __init__(self): pass self.assembler.factory('a', A) self.assembler.factory('b', B) self.assembler.factory('c', C) self.assembler.factory('d', D) a = self.assembler.assemble('a') self.assertTrue(isinstance(a, A)) self.assertTrue(hasattr(a, 'b')) self.assertNotEqual(None, a.b) self.assertTrue(isinstance(a.b, B)) self.assertTrue(hasattr(a, 'c')) self.assertNotEqual(None, a.c) self.assertTrue(isinstance(a.c, C)) self.assertTrue(hasattr(a.c, 'd')) self.assertNotEqual(None, a.c.d) self.assertTrue(isinstance(a.c.d, D))
# a_qe = Form(kernel=Kernel(qe), trial=ux, test=ux) a_one = Form(kernel=Kernel(one), trial=ux, test=ux) L = Form(kernel=Kernel(one), test=u) # # Problems # problems = [[a_qe,L], [a_one]] # # Assembly # assembler = Assembler(problems, mesh) assembler.assemble() # ============================================================================= # Linear system for generating observations # ============================================================================= system = LinearSystem(assembler,0) f = system.get_rhs() # # Incorporate constraints # system.add_dirichlet_constraint('left',0) system.add_dirichlet_constraint('right',0) # # Compute model output
#!/usr/bin/env python import os from assembler import Assembler from optionresolver import OptionResolver from patchers import PatchManager, PatchPatcher # Get the user supplied options options = OptionResolver() # Assemble the source code assembler = Assembler(options.manifest()["projects"], options.destination(), options.extra_parameters()) assembler.assemble() # Apply any patches patchmanager = PatchManager(options.manifest()["patches"], options.destination()) patch_base = os.path.dirname(options.manifest_location()) patchmanager.add_patcher("patch_file", PatchPatcher(patch_base)) patchmanager.patch()