def do_all_filtering(data_file, sent_filename, exclude_filename, months, years): log.info("FILTERING with months=" + " ".join(months) + " and years=" + " ".join(years)) log.info("for data file " + data_file) all_records = get_isi_all_fields(data_file) log.info("STARTING with n=" + str(len(all_records))) unique = get_unique_items(all_records) articles = get_filtered_dict(unique, lambda k, v: k == "type" and v == "Article") articles_of_months = get_filtered_dict(articles, lambda k, v: k == "data_month" and v in months) articles_of_years = get_filtered_dict(articles_of_months, lambda k, v: k == "year" and v in years) one_email_per_row = get_one_email_per_row(articles_of_years) log.info("AFTER FILTERING for months and years, ONE EMAIL PER ROW, n=" + str(len(one_email_per_row))) (first_occurrence, dupes) = email_first_occurrence(one_email_per_row, True) log.info("ELIMINATED because not first occurance, n=" + str(len(dupes))) log.info(list_of_emails(dupes)) (first_occurrence2, dupes2) = email_not_in_already_sent(first_occurrence, sent_filename) log.info("ELIMINATED because already sent, n=" + str(len(dupes2))) log.info(list_of_emails(dupes2)) (first_occurrence3, dupes3) = filter_unsubscribe_list(first_occurrence2) log.info("ELIMINATED because unsubscribe, n=" + str(len(dupes3))) log.info(list_of_emails(dupes3)) (first_occurrence4, dupes4) = filter_exclude_list(first_occurrence3, exclude_filename) log.info("ELIMINATED because on exclude list, n=" + str(len(dupes4))) log.info(list_of_emails(dupes4)) all_dupes = dupes + dupes2 + dupes3 + dupes4 keepers = first_occurrence4 log.info("KEEPING these, n=" + str(len(keepers))) log.debug(list_of_emails(keepers)) return(keepers, all_dupes)
def test_prep_email(self): test_dict = {'journal': 'Am. Nat.', 'volume_issue': '176_6', 'emails': ['*****@*****.**'], 'pretty_month': 'OCT', 'year': '2010', 'type': 'Article', 'data_month': 'OCT'} test_dict["q"] = "1" (survey_url, shortened_url) = get_survey_url(test_dict) test_dict["url"] = shortened_url email_html_body_template = open(email_template_initial, "r").read() email_body = contact_corresponding.get_email_text(email_html_body_template, test_dict) log.debug(email_body)
def genny(name, t): if t.kind == TypeKind.TYPEDEF: t = t.get_canonical() log.debug(f'name {name} type kind {t.kind}') if t.kind == TypeKind.POINTER: name = f'*{name}' yield f'print {name}'
def send_cmd(self, cmd): """发送命令取得返回值""" try: stdin, stdout, stderr = self.client.exec_command(cmd) log.debug(f'{self.user}登录{self.host}执行了{cmd}命令') print(stdout, stderr) return stdout except SSHException as e: log.debug(f'{self.user}登录{self.host}执行了{cmd}命令未成功,原因:{e}') print(e)
def get_clang_flags(args): """ Aggregate clang flags from args and Makefile if specified """ clang_flags = args.clang_flags[0].split() if args.clang_flags else [] if args.directory: makefile = args.directory / 'Makefile' log.debug(f'path to Makefile: {makefile}') assert (makefile.is_file()) clang_flags += [f'-I{args.directory.absolute()}'] clang_flags += re.findall(r'-I[^\s]+', open(makefile, 'r').read()) return clang_flags
def gen_patch(file, line, parms, array_expressions): stmts = [] stmts.append(f'b {file.split("/")[-1]}:{line}') arrays = dict(a.split(':') for a in array_expressions) log.debug(f'{len(parms)} parameters') printfs = list(gen_printfs(parms, arrays)) log.debug(printfs) stmts += printfs return stmts
def solve(self, from_pos): '''@param from_pos: a tuple (x, y) representing the path's start pos. to_area: a list of tuples (x, y) representing the path's possible end pos. @return If the path is found, return the path as a list of tuples (x,y). Otherwise, return None ''' #result = bfs_path.bfs(from_pos[0],from_pos[1], self.to_area, self.map) result = self.a_star_solver.solve(from_pos) log.debug("Path: " + str(result)) return result
def do_reminder_filtering(sent_filename, exclude_filename, months, years): (hasnt_been_sent_reminder, hasnt_been_sent_reminder) = do_reminder_filtering_part1(sent_filename, exclude_filename, months, years, "REMINDER") (first_occurrence3, dupes3) = filter_unsubscribe_list(hasnt_been_sent_reminder) log.info("ELIMINATED because unsubscribe, n=" + str(len(dupes3))) log.info(list_of_emails(dupes3)) (first_occurrence4, dupes4) = filter_exclude_list(first_occurrence3, exclude_filename) log.info("ELIMINATED because on exclude list, n=" + str(len(dupes4))) log.info(list_of_emails(dupes4)) all_dupes = hasnt_been_sent_reminder + dupes3 + dupes4 keepers = first_occurrence4 log.info("KEEPING these, n=" + str(len(keepers))) log.debug(list_of_emails(keepers)) return(keepers, all_dupes)
def __init__(self, host, password, user): self.host = host self.password = password self.user = user try: self.client = SSHClient() # 我们第一次连接时会去核实host它会去找known_host_key的这个文件,没有按如下处理 self.client.set_missing_host_key_policy(AcceptPolicy()) # 我们hostkey不在时的规定:set policy to use when connecting to servers without a known_host_key,然后我们另起炉灶 self.client.connect(hostname=host, username=user, password=password, timeout=10) log.debug(f'{user}成功登录{host}主机') except Exception as e: print(e) log.debug(f'{user}登录{host}主机失败:原因{e}') self.client = None
def do_wizard(_, args, install_sh): """ Get Pin installation from root. If Pin is not at the expected location, do the interactive wizard with install_sh. """ root = args.pin_root pin = Pin(args) if not pin.is_valid(): log.warn(f'{root} is not a valid Pin installation.') if not install_sh.is_file(): log.error(f'Could not execute {install_sh}.') exit(1) else: log.warn( f'See {install_sh} for the recommended method for installing Pin.' ) yn = input( f'Should I install it at {root}? [type y to install, anything else to quit]: ' ) if yn == 'y': cmd = f'bash {install_sh.absolute()} {root.name}' log.debug( f'Running Bash script install.sh with "{cmd}" in directory "{root}"' ) proc = subprocess.Popen(cmd.split(), cwd=root.parent, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) stdout, _ = proc.communicate() for l in stdout.decode().splitlines(): log.info(f'**[{install_sh.name}]** {l}') if proc.returncode == 0: log.info(f'Ran {install_sh} successfully.') else: log.error(f'Could not execute {install_sh}.') exit(1) else: exit(1) pin = Pin(args) if not pin.is_valid(): log.error(f'Something is wrong with the Pin environment at {root}') return pin
def parse(dirname, buggy_dirname, assertion): dirname = os.path.abspath(dirname) m = re.match( r'([^,]+),\s*(before|after)\s*line\s*([0-9]+)\s*\((.*)\),\s*(assert\(.*\);)', assertion) file_path = os.path.join(dirname, m.group(1)) buggy_file_path = os.path.join(dirname, m.group(1)) before_after = m.group(2) line_no = int(m.group(3)) expr = m.group(4).strip() assert_stmt = m.group(5) assert_args = re.match(r'assert\((.*)\);', assert_stmt).group(1) my_assert_stmt = f'if (!{assert_args}) {{*((int*)0) = 0;}} // my_assert' my_assert_stmt += '\n' log.info(f'{before_after} {file_path}:{line_no} "{my_assert_stmt}"') fromlines = open(file_path, 'r').readlines() matchto = [l.strip() for l in fromlines[line_no - 2:line_no + 2]] matches = difflib.get_close_matches(expr, matchto) log.debug(f'close matching "{expr}"') assert (len(matches) > 0) new_line_no = line_no - 2 + matchto.index(matches[0]) + 1 if new_line_no != line_no: log.warn(f'switched line number to {new_line_no}') line_no = new_line_no log.debug(f'close matched {file_path}:{line_no} "{fromlines[line_no-1]}"') if before_after == 'before': tolines = fromlines[:line_no - 1] + [my_assert_stmt ] + fromlines[line_no - 1:] elif before_after == 'after': tolines = fromlines[:line_no] + [my_assert_stmt] + fromlines[line_no:] else: log.critical(f'before_after is not valid: {before_after}') return unidiff = difflib.unified_diff(fromlines, tolines, fromfile=buggy_file_path, tofile=buggy_file_path) patch = ''.join(unidiff) return patch
def stmtgen(parameters): """ Get declaration and initializer statements for the given parameters """ decls = [] inits = [] for i, parm in enumerate(parameters): stmts = list(stmts_for_param(parm.type, parm.displayname)) parm_decls, parm_inits = zip(*stmts) log.info( f'parameter {pp(parm)}({i}) produces {len(parm_decls)} local variable declarations and {len(parm_inits)} initializer statements' ) for v, i in stmts: log.debug(f'local variable {v} has initializer(s) {i}') decls += (i for ilist in parm_decls for i in ilist) inits += (i for ilist in parm_inits for i in ilist) return decls, inits
def upload_many(client): """批量上传,在upload目录的文件将全部被上传""" filedir = os.path.dirname(os.path.abspath(__file__)) filepath = os.path.join(filedir, 'upload') f = os.walk(filepath) for i in f: u_list = i[2] base_path = i[0] try: ret = {'status': 0, 'msg': 'ok'} if client: ftp_client = client.open_sftp() for local_file in u_list: local_file_path = os.path.join(base_path, local_file) remote_file_path = 'upload/' + local_file ftp_client.put(local_file_path, remote_file_path) log.debug(f'{local_file_path}上传到远程服务器端{remote_file_path}') print('上传成功') ftp_client.close() else: ret['status'] = 1 ret['msg'] = 'error' log.debug('上传服务的连接未建立成功') except Exception as e: ret['status'] = 1 ret['msg'] = e log.debug(f'上传服务中出现错误:{e}') return ret
def find(node, selector, verbose=False): """ Return all node's descendants of a certain kind """ if verbose: log.debug(f'find: walked node {pp(node)}') found = [] if isinstance(selector, CursorKind): if node.kind == selector: found.append(node) elif callable(selector): if selector(node): found.append(node) # Recurse for children of this node for child in node.get_children(): found += find(child, selector, verbose) return found
def parse_args(): parser = argparse.ArgumentParser() parser.add_argument('filter', nargs='?', help='Filter bugs to a certain filter') parser.add_argument( '-l', '--log-level', help='Display logs at a certain level (DEBUG, INFO, ERROR)') parser.add_argument('-v', '--verbose', action='store_true', help='Display verbose logs in -lDEBUG') arguments = parser.parse_args() if arguments.log_level: log.setLevel(logging.getLevelName(arguments.log_level)) if arguments.verbose: global verbose verbose = True log.debug(f'verbose logging enabled') return arguments
def download(client, remote_file_path, local_file_path): """get file from remote server""" try: ret = {'status': 0, 'msg': 'ok'} if client: ftp_client = client.open_sftp() ftp_client.get(remote_file_path, local_file_path) log.debug(f'远程服务器端文件{remote_file_path}下载到本地{local_file_path }') print('下载成功') ftp_client.close() else: ret['status'] = 1 ret['msg'] = 'error' log.debug('下载服务的连接未建立成功') except Exception as e: ret['status'] = 1 ret['msg'] = e log.debug(f'下载服务中出现错误:{e}') return ret
def upload(client, local_file_path, remote_file_path): """put local file to remote server""" try: ret = {'status': 0, 'msg': 'ok'} if client: ftp_client = client.open_sftp() ftp_client.put(local_file_path, remote_file_path) log.debug(f'{local_file_path}上传到远程服务器端{remote_file_path}') print('上传成功') ftp_client.close() else: ret['status'] = 1 ret['msg'] = 'error' log.debug('上传文件至服务器的连接未建立成功') except Exception as e: ret['status'] = 1 ret['msg'] = e log.debug(f'上传服务中出现错误:{e}') return ret
def main(): global args args = parse_args() target = Path(args.target[0]) target_args = args.target[1:] try: dynamic_locations = args.pin.run(target, target_args) except Exception as e: log.error(e) log.error(traceback.format_exc()) return -1 log.debug(f'{len(dynamic_locations)} logs') for l in dynamic_locations: if Path(l.filepath).exists(): log.debug(f'dynamic location {l}') elif args.verbose: log.debug(f'dynamic location {l}') log.debug(f'^^^ file does not exist ^^^') dynamic_locations = [ d for d in dynamic_locations if Path(d.filepath).exists() ] static_locations = [] clang_include_paths = [f'-I{p}' for p in args.clang_include_paths] static_locations = get_static_locations(dynamic_locations, clang_include_paths) # Store only filepath and lineno and dedup all_locations = slim(dynamic_locations, args.include_column, args.include_code) if args.include_static: all_locations += slim(static_locations, args.include_column, args.include_code) if len(all_locations) == 0: log.error('No traces generated. Check if the source file was moved.') return 1 # Output trace locations to file if args.output_file: output_stream = open(args.output_file, 'w') else: output_stream = sys.stdout for l in all_locations: s = f'{l.filepath}:{l.lineno}' if args.include_column: s += f':{l.column}' if args.include_code: s += f':{l.code}' s += '\n' output_stream.write(s) if output_stream is not sys.stdout: output_stream.close() debug_info = debug_print_code(all_locations) for filepath, content in debug_info.items(): log.debug(filepath) for lineno, text in content: log.debug(f'{lineno:4} {text}') return 0
def main(): log.setLevel(logging.INFO) args = parse_args() if args.log_level: log.setLevel(args.log_level) log.debug(f'setting log level to {args.log_level}') seg_c = args.segment_file orig_dir = args.original_file log.debug(f'segment: {seg_c}, original: {orig_dir}') clang_args = args.clang_args.split() if clang_args: log.debug(f' provided clang args: {clang_args}') if args.verbose: global verbose verbose = True log.debug(f'verbose logging enabled') seg_cur = parse(seg_c, clang_args) seg_target = select_target(seg_cur, target_name=args.target) parms = list(seg_target.get_arguments()) log.debug(f'target: {pp(seg_target)}') import re target_name = re.match(r'helium_(.*)', seg_target.spelling).group(1) from pathlib import Path for orig_c in Path(orig_dir).glob('**/*.c'): orig_cur = parse(orig_c) orig_funcdecls = find(orig_cur, CursorKind.FUNCTION_DECL, verbose) orig_target = next((f.get_definition() for f in orig_funcdecls if is_the_same(f, seg_target) and f.get_definition() is not None), None) if orig_target is not None: break log.debug(f'target: {pp(orig_target)}') orig_body = find(orig_target, lambda c: c is not None and c.kind.is_statement(), verbose=verbose) first_stmt = next(iter(orig_body)) first_stmt_file, first_stmt_line = first_stmt.location.file.name, first_stmt.location.line diff = gen_patch(first_stmt_file, first_stmt_line, parms, args.array) print('\n'.join(diff))
def send_to_contact_list(fake_or_real, contact_list, subject, email_template, q, years, contact_note_append=""): ### DOESN'T HANDLE FILTERING BY YEARS YET!!! log.debug("SENDING EMAIL TO GROUPS") for journal in set([d["journal"] for d in contact_list]): log.debug("JOURNAL: " + journal) journals_records = contact_corresponding.get_filtered_dict(contact_list, lambda k, v: k == "journal" and v == journal) for month in set([d["data_month"] for d in contact_list]): log.debug("MONTH: " + month) month_records = contact_corresponding.get_filtered_dict(journals_records, lambda k, v: k == "data_month" and v == month) log.debug("n = " + str(len(month_records))) represetative_sample = month_records[0] represetative_sample["q"] = q (survey_url, shortened_url) = get_survey_url(represetative_sample) represetative_sample["url"] = shortened_url email_html_body_template = open(email_template, "r").read() email_body = contact_corresponding.get_email_text(email_html_body_template, represetative_sample) log.debug(email_body[0:200]) bcc_list = [d["single_email"] for d in month_records] log.debug("Length of bcc list:" + str(len(bcc_list))) log.debug("BCC list:") log.debug(bcc_list) if fake_or_real == "REAL": success = send_it_already(subject, email_body, bcc_list) if success: log.info("******* SENT FOR REAL ***********") else: log.info("******* FAILED TO SEND ***********") else: success = send_it_already(subject, email_body, ["*****@*****.**"]) log.info("--- just sent it to myself--------") if success: update_sent_file(sent_filename, bcc_list, "\t".join([" ".join(years), month, journal, contact_note_append]))
def close(self): """关闭连接""" self.client.close() log.debug(f'{self.user}登录的{self.host}主机断开连接')
def main(): cli = control_line.ControlLine() cli.run() cfg = config.Config() config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'ssh_login.cfg') # 登录服务器 if cli.args.shell: ips = cli.args.filename for host_ip in ips: if cfg.read_config(config_path, host_ip): dic = dict(cfg.read_config(config_path, host_ip)) user = dic['user'] password = dic['password'] host = host_ip ssh = MySSH(host=host, password=password, user=user) if ssh.client: print('登录成功') else: print('登录失败') else: print(f'配置文件中不含{host_ip}主机') log.debug(f'配置文件中不含{host_ip}主机') # 上传文件 elif cli.args.upload: if len(cli.args.filename) == 2: try: local_file = cli.args.filename[0] remote_server_file = os.path.join('download/', cli.args.filename[1]) except Exception as e: print(e) return None ssh = MySSH('192.168.23.129', '2587539619', 'root') if ssh.client: ret = upload(ssh.client, local_file, remote_server_file) print(ret) elif len(cli.args.filename) == 0: ssh = MySSH('192.168.23.129', '2587539619', 'root') if ssh.client: upload_many(ssh.client) else: print('输入参数不合规范') print(' 参数一为本地文件,参数二为远程服务器文件') log.debug('上传文件时,输入参数不合规范') # 下载文件 elif cli.args.download: if len(cli.args.filename) == 2: try: remote_server_file = cli.args.filename[0] local_file = cli.args.filename[1] except Exception as e: print(e) return None ssh = MySSH('192.168.23.129', '2587539619', 'root') if ssh.client: ret = download(ssh.client, remote_server_file, local_file) print(ret) else: log.debug('下载文件时,输入的参数不合规范') print('输入参数不合规范') print('参数一为远程服务器文件,参数二为本地文件') # 控制台交互 elif cli.args.console: ssh = MySSH('192.168.23.129', '2587539619', 'root') log.debug('root用户登录192.168.23.129主机操作控制台') while True: cmd = input('请输入shell命令,[q]-退出') if cmd == 'q': ssh.close() break log.debug(f'输入了命令{cmd}') stdout = ssh.send_cmd(cmd) print(stdout.read().decode())
def stmts_for_param(type, varname, stack=[]): """ Yields input variables for type t's fields, down to primitives """ type = type.get_canonical() decls = [] inits = [] shift_argv = 'shift_argi()' log.debug(f'variable {varname} type {type.spelling} (kind {type.kind})') if not (type.kind == TypeKind.FUNCTIONPROTO or (type.kind == TypeKind.POINTER and type.get_pointee().kind == TypeKind.FUNCTIONPROTO)): decls.append(f'{type.spelling} {varname.replace(".", "_")};') if type.kind == TypeKind.ELABORATED or type.kind == TypeKind.RECORD: td = type.get_declaration() children = list(td.get_children()) inits.append(f'// assign fields for {varname}') if any(children): for child in children: child_varname = f'{varname}.{child.spelling}' if child.kind == CursorKind.UNION_DECL: pass elif child.type.get_declaration( ).kind == CursorKind.UNION_DECL: inits.append( f'// TODO union {child_varname} = <{", ".join(c.spelling for c in child.type.get_declaration().get_children())}>;' ) elif child.type.kind == TypeKind.POINTER: if child.type.spelling in ( s.spelling for s in stack ) or child.type.get_pointee() == type: inits.append( f'// TODO recursive {child_varname} = <{type.spelling}>;' ) else: if child.type.get_pointee().kind == TypeKind.CHAR_S: inits.append(f'{child_varname} = {shift_argv};') elif child.type.spelling in (s.spelling for s in stack): pass else: valname = f'{child.spelling.replace(".", "_")}_v' yield from stmts_for_param( child.type.get_pointee(), valname, stack=stack + [child.type]) inits.append(f'{child_varname} = &{valname};') else: child_inits = zip(*stmts_for_param(child.type, f'{child_varname}', stack=stack + [child.type])) yield from (([], c) for l in child_inits for c in l) else: log.warning( f'no fields found for type {type.spelling} (kind {type.kind})') elif type.kind == TypeKind.POINTER: if type.get_pointee().kind == TypeKind.CHAR_S: inits.append(f'{varname} = {shift_argv};') elif type.get_pointee().kind == TypeKind.FUNCTIONPROTO: inits.append(f'// TODO functionptr {varname} = <{type.spelling}>;') else: valname = f'{varname}_v' yield from stmts_for_param(type.get_pointee(), valname, stack=stack + [type]) if type.get_pointee().kind != TypeKind.FUNCTIONPROTO: inits.append(f'{varname} = &{valname};') elif type.kind == TypeKind.INT or \ type.kind == TypeKind.SHORT or \ type.kind == TypeKind.LONG or \ type.kind == TypeKind.LONGLONG or \ type.kind == TypeKind.INT128 or \ type.kind == TypeKind.ENUM: inits.append(f'{varname} = atoi({shift_argv});') elif type.kind == TypeKind.UINT or \ type.kind == TypeKind.ULONG or \ type.kind == TypeKind.ULONGLONG or \ type.kind == TypeKind.UINT128: inits.append(f'{varname} = strtoul({shift_argv}, NULL, 10);') elif type.kind == TypeKind.DOUBLE or type.kind == TypeKind.LONGDOUBLE: inits.append(f'{varname} = strtod({shift_argv}, NULL);') elif type.kind == TypeKind.FLOAT: inits.append(f'{varname} = atof({shift_argv});') elif type.kind == TypeKind.CHAR_S: inits.append(f'{varname} = {shift_argv}[0];') elif type.kind == TypeKind.FUNCTIONPROTO: pass else: inits.append(f'// TODO unhandled {varname} = <{type.spelling}>;') yield decls, inits
def parse_args(argv=sys.argv, do_wizard=True): file_dir = Path(__file__).parent default_pinroot = str(file_dir / 'pin-3.16') if '--' in argv: after_dash = argv[argv.index('--') + 1:] argv = argv[:argv.index('--')] else: after_dash = None parser = argparse.ArgumentParser() parser.add_argument( '-l', '--log-level', help='Display logs at a certain level (DEBUG, INFO, ERROR)', default='WARN') parser.add_argument('-v', '--verbose', action='store_true', help='Display verbose logs in -lDEBUG') parser.add_argument('-k', '--keep-logfile', action='store_true', help='Keep the log file after running Pin') parser.add_argument('-s', '--include_static', action='store_true', help='Output static trace') parser.add_argument('--include_code', action='store_true', help='Output code statements') parser.add_argument('--include_column', action='store_true', help='Output column numbers') parser.add_argument( '-p', '--pin-root', type=str, help=f'Use an alternative path to Pin root. Default: {default_pinroot}', default=default_pinroot) parser.add_argument('-o', '--output-file', type=str, help='Output to a file') parser.add_argument( '-I', default=[], dest='clang_include_paths', action='append', help='Include paths to pass to Clang (same as clang\'s -I flag)') parser.add_argument('--clang_library_file', type=str, help='Library file to load for Libclang stuff') arguments = parser.parse_args(argv[1:]) if after_dash is None: raise argparse.ArgumentTypeError( 'A delimiter -- before the command is required') # arguments.target = arguments.target.split() arguments.target = after_dash if arguments.log_level: log.setLevel(logging.getLevelName(arguments.log_level)) if arguments.verbose: global verbose verbose = True log.debug(f'verbose logging enabled') if arguments.pin_root: arguments.pin_root = Path.cwd() / arguments.pin_root if do_wizard: arguments.pin = Pin.do_wizard(arguments, file_dir / 'install.sh') else: arguments.pin = Pin(arguments) if arguments.clang_library_file: log.debug( f'Setting clang library file to {arguments.clang_library_file}') Config.set_library_file(arguments.clang_library_file) log.debug(f'arguments: {arguments}') return arguments
def tick(self, ped_list, time_tick): '''[IN] ped_list: a list of current pedestrians time_tick: how much time to pass [EFFECT] Update ped_list to the time after tick_tick passed. ''' # cal desire force desire_list = [] for ped in ped_list: desire_list.append(self.calDesire(ped)) log.debug("Desire forces: " + str(desire_list)) # cal force comes from wall wall_list = [] for ped in ped_list: ped_vel = np.array(ped.vel) wall_area = self.map.getWallArea() wall_joint = np.array((0, 0)) for wall in wall_area: dist = calDistance(wall, ped.pos)/self.map.scale rad_diff = ped.radius - dist unit_vec = calUnitVector(ped.pos, wall) orth_vec = calOrthogonalVector(unit_vec) # cal social force wall_joint = wall_joint + self.calSocial(unit_vec, rad_diff, ped.A, ped.B) # cal physical force if rad_diff > 0: # touched wall_joint = wall_joint + self.calPhysical(unit_vec, orth_vec, rad_diff, ped_vel) wall_list.append(wall_joint) log.debug("Wall froces: " + str(wall_list)) # cal force comes from other pedestrians others_list = [] for ped_i in ped_list: ped_vel_i = np.array(ped_i.vel) others_joint = np.array((0,0)) for ped_j in ped_list: if ped_i == ped_j: continue ped_vel_j = np.array(ped_j.vel) dist = calDistance(ped_j.pos, ped_i.pos) rad_diff = ped_i.radius + ped_j.radius - dist unit_vec = calUnitVector(ped_i.pos, ped_j.pos) orth_vec = calOrthogonalVector(unit_vec) # cal social force others_joint = others_joint + self.calSocial(unit_vec, rad_diff, ped_i.A, ped_i.B) # cal physical force if rad_diff > 0: others_joint = others_joint + self.calPhysical(unit_vec, orth_vec, rad_diff, ped_vel_j, ped_vel_i) others_list.append(others_joint) log.debug("Others forces: " + str(others_list)) # cal joint force joint_list = [] for desire, wall, others in zip(desire_list, wall_list, others_list): joint = np.array((0, 0)) joint = joint + desire joint = joint + wall joint = joint + others joint_list.append(joint) # cal new position(using old velocity) for ped in ped_list: pos = np.array(ped.pos) vel = np.array(ped.vel) pos = pos + vel* self.map.scale*time_tick ped.pos = (int(pos[0]), int(pos[1])) # cal new velocity for ped, joint in zip(ped_list, joint_list): vel = np.array(ped.vel) vel = vel + joint*time_tick ped.vel = (float(vel[0]), float(vel[1])) # update experiment's time self.time = self.time + time_tick
def get_static_locations(dynamic_locations, clang_include_paths): """ Get locations for certain constructs which are only available statically. - Variable declarations without any executable code "int i;" - Case statements "case foo:" - Default statements "default: " """ static_locations = [] def ancestor_node(n): """ Get the nearest significant ancestor. """ if n.kind == CursorKind.FUNCTION_DECL: return n else: if n.semantic_parent is None: return n else: return ancestor_node(n.semantic_parent) def good(n): """ Node should be added to the trace. """ if n.kind in (CursorKind.VAR_DECL, CursorKind.CASE_STMT, CursorKind.DEFAULT_STMT): return True else: return False filepaths = defaultdict(list) for l in dynamic_locations: filepaths[l.filepath].append(l) for filepath, locations in filepaths.items(): log.debug( f'Parsing source file {filepath} with args {clang_include_paths}') root = nodeutils.parse(filepath, clang_include_paths) ancestors = [] file = File.from_name(root.translation_unit, filepath) for l in locations: source_location = SourceLocation.from_position( root.translation_unit, file, l.lineno, l.column) node = Cursor.from_location(root.translation_unit, source_location) l.node = node if node.kind.is_invalid(): continue ancestor = ancestor_node(node) if ancestor not in ancestors: log.debug( f'node {nodeutils.pp(node)} has ancestor {nodeutils.pp(ancestor)}' ) ancestors.append(ancestor) for a in ancestors: if a.kind.is_translation_unit(): continue # Do not include global constructs else: nodes = nodeutils.find(a, good) locations = [ Location(n.location.file.name, n.location.line, n.location.column, n) for n in nodes ] for l in locations: log.debug(f'static location {l}') static_locations += locations return static_locations