def test_attributes(): """Test with different attributes.""" table_data = [ ['Name', 'Color', 'Type'], ['Avocado', 'green', 'nut'], ['Tomato', 'red', 'fruit'], ['Lettuce', 'green', 'vegetable'], ] table = AsciiTable(table_data) assert 31 == max(len(r) for r in table.table.splitlines()) assert 31 == table.table_width table.outer_border = False assert 29 == max(len(r) for r in table.table.splitlines()) assert 29 == table.table_width table.inner_column_border = False assert 27 == max(len(r) for r in table.table.splitlines()) assert 27 == table.table_width table.padding_left = 0 assert 24 == max(len(r) for r in table.table.splitlines()) assert 24 == table.table_width table.padding_right = 0 assert 21 == max(len(r) for r in table.table.splitlines()) assert 21 == table.table_width
def run(self): self.print_banner() self.print_help() while True: command = self.input() if command == 'addcert': count = self.manager.command_addcert() print "Successfully added %s certificates" % count elif command == 'settings': print SETTINGS elif command == 'help': self.print_banner() self.print_help() elif command == 'report': rows, week_start, week_end, total = self.manager.command_report() table = AsciiTable(rows, 'Certificates obtained %s-%s' % (week_start, week_end)) table.outer_border = False print table.table print "\nTotal certificates obtained: %s" % total elif command == 'delete': self.manager.command_delete() elif command == 'exit': return 0 else: pass
def output(buf, dowrap=False): bbuf = [["Bot", "Pack#", "Size", "File"]] + buf t = AsciiTable(bbuf) t.inner_column_border = False t.outer_border = False if dowrap and sys.stdout.isatty(): mw = t.column_max_width(3) for e in bbuf: if len(e[3])>mw: e[3] = "\n".join(wrap(e[3], mw)) print(t.table) sys.stdout.flush()
def info(self, options): """ Display service status information. Usage: info """ from terminaltables import AsciiTable rows = [] for key, value in self.project.info().iteritems(): rows.append([key + ':', value]) table = AsciiTable(rows) table.outer_border = False table.inner_column_border = False table.inner_heading_row_border = False table.title = 'Dork status information' print table.table
def _log_config(keys, context): result = '' for key in keys: c = context[key].config items = list(c.items()) default_config = context[key].default_config() tab = [(key, context[key].name, "", "", "", "", "", "")] for i in range((len(items) + 2) // 3): row_l = _log_row(items[i * 3], default_config) if i * 3 + 1 < len(items): row_m = ("|", *_log_row(items[i * 3 + 1], default_config)) else: row_m = ("", "", "") if i * 3 + 2 < len(items): row_r = ("|", *_log_row(items[i * 3 + 2], default_config)) else: row_r = ("", "", "") tab.append((*row_l, *row_m, *row_r)) table = AsciiTable(tab) table.inner_column_border = False table.outer_border = False result += f'\n{table.table}\n' log.easy().debug(f'Configuration:{RESET}{result}')
def main_help(): commands = ['database', 'sniffing', 'exploit', 'modelling', 'exit'] description = ['Use database mode.', 'Use sniffing mode.', 'Use exploit mode.', 'Use modelling mode.', 'Quit this program'] table_data = [['Commands', 'Description']] for i in range(len(commands) - 1): table_data.append([commands[i], description[i]]) table = AsciiTable(table_data) table.inner_column_border = False table.inner_footing_row_border = False table.inner_heading_row_border = True table.inner_row_border = False table.outer_border = False msg = f""" Core commands ============= {table.table}\n\n""" return msg
def do_info(self, line): print("\n \033[1m\033[94m[*]\033[0m Module Info\033[0m\n") print(''' This module can be used to generate PowerShell based loader (.PS1) and .EXE loader for blocked powershell.exe environments. It support Meterpreter Reverse HTTP, Reverse HTTPS staged payloads. The payload generated by this module has two output. The first output is PowerShell script and it can be used directly when available PowerShell access. The second output is C# code for PowerShell based loader code that will be used when powershell.exe is blocked. You can compile and run it, after that loader runs the PowerShell based loader code using System.Management.Automation.dll. This module also has the ability to process patched stages.''') print("\n \033[1m\033[94m[*]\033[0m Module Options\033[0m") optionsValues = [ ["Parameter", "Required", "Value", "Description"], [ "PROTO", "Yes", mppProto, "Listener protocol. Accepted: http or https" ], [ "LHOST", "Yes", mppLhost, "The local listener hostname or IP address" ], ["LPORT", "Yes", mppLport, "The local listener port."], [ "ARCH", "Yes", mppArch, "Architecture of target system. Accepted: x86 or x64" ], [ "SSIZE", "No", mppSsize, "If you patched Metasploit insert your patch size" ] ] optTable = AsciiTable(optionsValues) optTable.outer_border = False optTable.inner_column_border = False optTable.justify_columns[1] = "center" print("\n" + optTable.table + "\n")
def getNodes(self): """ List the nodes stored in the database Usage: getNodes [-h] Options: -h, --help Print this message. """ nodes = self.dbc.getNodes() table_data = [["id", "dl addresses", "nwk addresses"]] for node in nodes: table_data.append(node) table = AsciiTable(table_data) table.inner_column_border = False table.inner_footing_row_border = False table.inner_heading_row_border = True table.inner_row_border = False table.outer_border = False print(f"{table.table}")
def post_stats(self): data = [ ['Author', 'Count'], ] stats = db.execute_sql(self.author_stats) for row in stats.fetchall(): data.append([row[0], row[1]]) table_instance = AsciiTable(data) table_instance.inner_column_border = False table_instance.outer_border = False table_instance.justify_columns[1] = 'center' content = { 'content': "**WEEKLY AUTHOR STATS:**```{}```".format(table_instance.table) } full_url = self.url + self.hook_id + '/' + self.hook_token + '?wait=true' r = requests.post(full_url, json=content) self.limit = int(r.headers['X-RateLimit-Limit']) self.remaining = int(r.headers['X-RateLimit-Remaining']) self.reset = int(r.headers['X-RateLimit-Reset'])
async def standings(self, ctx, division, driver: str = None): """Show standings for the current season of the specified division.""" division = self.config["division_map"].get(division.lower(), division.lower()) if not get_current_season(division, self): await ctx.send("No seasons found for division") season_id = self.config["division_season"][division.lower()] teams_disabled = self.config["season_info"][season_id]["teams_disabled"] url = f"{self.config['urls']['base_url']}/api/standings/{season_id}" if driver: url += f"?driver={driver.lower()}" r = self.session.get(url) try: standings = json.loads(r.content) data = [["Pos", "Driver", "Team", "Points"]] if teams_disabled: data[0].pop(2) for pos in standings[0:5]: add_row(data, pos, teams_disabled) found = False if driver: try: found = next( iter([d for d in data if driver.lower() in d[1].lower()]) ) except StopIteration: pass if not found: try: info = next( iter( [ {"index": i, "details": d} for i, d in enumerate(standings) if driver.lower() in d["name"].lower() ] ) ) prev_pos = standings[info["index"] - 1] if prev_pos["position"] > 6: data.append(["..."]) if prev_pos["position"] > 5: add_row(data, prev_pos, teams_disabled) add_row(data, info["details"], teams_disabled) try: next_pos = standings[info["index"] + 1] add_row(data, next_pos, teams_disabled) except IndexError: pass except StopIteration: pass table_instance = AsciiTable(data) table_instance.inner_column_border = False table_instance.outer_border = False table_instance.justify_columns[3] = "center" season_info = self.config["season_info"][season_id] season = f"Name: {season_info['name']} ({season_info['start_date']} to {season_info['end_date']})" msg = table_instance.table except json.decoder.JSONDecodeError: season = "Error" msg = "There was an error retrieving the standings" await ctx.send(f"```{season}\n\n{msg}```")
def execute_status(args): status = get_status() # First rows, showing daemon status if status['status'] == 'running': status['status'] = Color('{autogreen}' + '{}'.format(status['status']) + '{/autogreen}') elif status['status'] == 'paused': status['status'] = Color('{autoyellow}' + '{}'.format(status['status']) + '{/autoyellow}') if status['process'] == 'running' or status['process'] == 'paused': status['process'] = Color('{autogreen}' + '{}'.format(status['process']) + '{/autogreen}') print('Daemon: {}\nProcess status: {} \n'.format(status['status'], status['process'])) # Handle queue data data = status['data'] if isinstance(data, str): print(data) elif isinstance(data, dict): # Format incomming data to be compatible with Terminaltables formatted_data = [] formatted_data.append(['Index', 'Status', 'Code', 'Command', 'Path', 'Start', 'End']) for key, entry in sorted(data.items(), key=operator.itemgetter(0)): formatted_data.append( [ '#{}'.format(key), entry['status'], '{}'.format(entry['returncode']), entry['command'], entry['path'], entry['start'], entry['end'] ] ) # Create AsciiTable instance and define style table = AsciiTable(formatted_data) table.outer_border = False table.inner_column_border = False terminal_width = terminal_size() customWidth = table.column_widths # If the text is wider than the actual terminal size, we # compute a new size for the Command and Path column. if (reduce(lambda a, b: a+b, table.column_widths) + 10) > terminal_width[0]: # We have to subtract 14 because of table paddings left_space = math.floor((terminal_width[0] - customWidth[0] - customWidth[1] - customWidth[2] - customWidth[5] - customWidth[6] - 14)/2) if customWidth[3] < left_space: customWidth[4] = 2*left_space - customWidth[3] elif customWidth[4] < left_space: customWidth[3] = 2*left_space - customWidth[4] else: customWidth[3] = left_space customWidth[4] = left_space # Format long strings to match the console width for i, entry in enumerate(table.table_data): for j, string in enumerate(entry): max_width = customWidth[j] wrapped_string = '\n'.join(wrap(string, max_width)) if j == 1: if wrapped_string == 'done' or wrapped_string == 'running' or wrapped_string == 'paused': wrapped_string = Color('{autogreen}' + '{}'.format(wrapped_string) + '{/autogreen}') elif wrapped_string == 'queued': wrapped_string = Color('{autoyellow}' + '{}'.format(wrapped_string) + '{/autoyellow}') elif wrapped_string in ['errored', 'stopping', 'killing']: wrapped_string = Color('{autored}' + '{}'.format(wrapped_string) + '{/autored}') elif j == 2: if wrapped_string == '0' and wrapped_string != 'Code': wrapped_string = Color('{autogreen}' + '{}'.format(wrapped_string) + '{/autogreen}') elif wrapped_string != '0' and wrapped_string != 'Code': wrapped_string = Color('{autored}' + '{}'.format(wrapped_string) + '{/autored}') table.table_data[i][j] = wrapped_string print(table.table) print('')
import matplotlib.pyplot as plt g = [[0.2, 0.6, 0.2, 0], [0.4, 0.4, 0, 0.2], [0.2, 0, 0.5, 0.3], [0.1, 0, 0.5, 0.4]] n = 1000 values = generator(n) tableData = [['γ'] + values] states_list = [st for st in range(len(g))] for i in states_list: states = get_states(g, i, values) tableData.append(['st. (from st. ' + str(i) + ')'] + states) plt.title("Вероятность пребывания в состояниях (начальное состояние=" + str(i) + ")") plt.xlabel("state") plt.ylabel("p") plt.bar(states_list, [states.count(st) / n for st in states_list], 1) plt.xticks(states_list) plt.grid() plt.show() resultTable = AsciiTable(tableData) resultTable.inner_heading_row_border = True resultTable.outer_border = False resultTable.inner_row_border = False print(resultTable.table) print('Стационарное состояние:') print(linalg.matrix_power(g, 100)[0])
def execute_status(args, root_dir=None): """Print the status of the daemon. This function displays the current status of the daemon as well as the whole queue and all available information about every entry in the queue. `terminaltables` is used to format and display the queue contents. `colorclass` is used to color format the various items in the queue. Args: root_dir (string): The path to the root directory the daemon is running in. """ status = command_factory('status')({}, root_dir=root_dir) # First rows, showing daemon status if status['status'] == 'running': status['status'] = Color('{autogreen}' + '{}'.format(status['status']) + '{/autogreen}') elif status['status'] in ['paused']: status['status'] = Color('{autoyellow}' + '{}'.format(status['status']) + '{/autoyellow}') print('Daemon: {}\n'.format(status['status'])) # Handle queue data data = status['data'] if isinstance(data, str): print(data) elif isinstance(data, dict): # Format incomming data to be compatible with Terminaltables formatted_data = [] formatted_data.append( ['Index', 'Status', 'Code', 'Command', 'Path', 'Start', 'End']) for key, entry in sorted(data.items(), key=operator.itemgetter(0)): formatted_data.append([ '#{}'.format(key), entry['status'], '{}'.format(entry['returncode']), entry['command'], entry['path'], entry['start'], entry['end'] ]) # Create AsciiTable instance and define style table = AsciiTable(formatted_data) table.outer_border = False table.inner_column_border = False terminal_width = terminal_size() customWidth = table.column_widths # If the text is wider than the actual terminal size, we # compute a new size for the Command and Path column. if (reduce(lambda a, b: a + b, table.column_widths) + 10) > terminal_width[0]: # We have to subtract 14 because of table paddings left_space = math.floor( (terminal_width[0] - customWidth[0] - customWidth[1] - customWidth[2] - customWidth[5] - customWidth[6] - 14) / 2) if customWidth[3] < left_space: customWidth[4] = 2 * left_space - customWidth[3] elif customWidth[4] < left_space: customWidth[3] = 2 * left_space - customWidth[4] else: customWidth[3] = left_space customWidth[4] = left_space # Format long strings to match the console width for i, entry in enumerate(table.table_data): for j, string in enumerate(entry): max_width = customWidth[j] wrapped_string = '\n'.join(wrap(string, max_width)) if j == 1: if wrapped_string == 'done' or wrapped_string == 'running' or wrapped_string == 'paused': wrapped_string = Color('{autogreen}' + '{}'.format(wrapped_string) + '{/autogreen}') elif wrapped_string in ['queued', 'stashed']: wrapped_string = Color('{autoyellow}' + '{}'.format(wrapped_string) + '{/autoyellow}') elif wrapped_string in ['failed', 'stopping', 'killing']: wrapped_string = Color('{autored}' + '{}'.format(wrapped_string) + '{/autored}') elif j == 2: if wrapped_string == '0' and wrapped_string != 'Code': wrapped_string = Color('{autogreen}' + '{}'.format(wrapped_string) + '{/autogreen}') elif wrapped_string != '0' and wrapped_string != 'Code': wrapped_string = Color('{autored}' + '{}'.format(wrapped_string) + '{/autored}') table.table_data[i][j] = wrapped_string print(table.table) print('')
def run_model(args, currentmodelrun, modelend, numbermodelruns, inputfile, usernamespace): """Runs a model - processes the input file; builds the Yee cells; calculates update coefficients; runs main FDTD loop. Args: args (dict): Namespace with command line arguments currentmodelrun (int): Current model run number. modelend (int): Number of last model to run. numbermodelruns (int): Total number of model runs. inputfile (object): File object for the input file. usernamespace (dict): Namespace that can be accessed by user in any Python code blocks in input file. Returns: tsolve (int): Length of time (seconds) of main FDTD calculations """ # Monitor memory usage p = psutil.Process() # Declare variable to hold FDTDGrid class global G # Used for naming geometry and output files appendmodelnumber = '' if numbermodelruns == 1 and not args.task and not args.restart else '_'+str(currentmodelrun) appendmodelnumberGeometry = '' if numbermodelruns == 1 and not args.task and not args.restart or args.geometry_fixed else '_'+str(currentmodelrun) # Normal model reading/building process; bypassed if geometry information to be reused if 'G' not in globals(): # Initialise an instance of the FDTDGrid class G = FDTDGrid() # Get information about host machine # (need to save this info to FDTDGrid instance after it has been created) G.hostinfo = get_host_info() # Single GPU object if args.gpu: G.gpu = args.gpu G.inputfilename = os.path.split(inputfile.name)[1] G.inputdirectory = os.path.dirname(os.path.abspath(inputfile.name)) inputfilestr = '\n--- Model {}/{}, input file: {}'.format(currentmodelrun, modelend, inputfile.name) if G.messages: print(Fore.GREEN + '{} {}\n'.format(inputfilestr, '-' * (get_terminal_width() - 1 - len(inputfilestr))) + Style.RESET_ALL) # Add the current model run to namespace that can be accessed by # user in any Python code blocks in input file usernamespace['current_model_run'] = currentmodelrun # Read input file and process any Python and include file commands processedlines = process_python_include_code(inputfile, usernamespace) # Print constants/variables in user-accessable namespace uservars = '' for key, value in sorted(usernamespace.items()): if key != '__builtins__': uservars += '{}: {}, '.format(key, value) if G.messages: print('Constants/variables used/available for Python scripting: {{{}}}\n'.format(uservars[:-2])) # Write a file containing the input commands after Python or include file commands have been processed if args.write_processed: write_processed_file(processedlines, appendmodelnumber, G) # Check validity of command names and that essential commands are present singlecmds, multicmds, geometry = check_cmd_names(processedlines) # Create built-in materials m = Material(0, 'pec') m.se = float('inf') m.type = 'builtin' m.averagable = False G.materials.append(m) m = Material(1, 'free_space') m.type = 'builtin' G.materials.append(m) # Process parameters for commands that can only occur once in the model process_singlecmds(singlecmds, G) # Process parameters for commands that can occur multiple times in the model if G.messages: print() process_multicmds(multicmds, G) # Estimate and check memory (RAM) usage G.memory_estimate_basic() #G.memory_check() #if G.messages: # if G.gpu is None: # print('\nMemory (RAM) required: ~{}\n'.format(human_size(G.memoryusage))) # else: # print('\nMemory (RAM) required: ~{} host + ~{} GPU\n'.format(human_size(G.memoryusage), human_size(G.memoryusage))) # Initialise an array for volumetric material IDs (solid), boolean # arrays for specifying materials not to be averaged (rigid), # an array for cell edge IDs (ID) G.initialise_geometry_arrays() # Initialise arrays for the field components if G.gpu is None: G.initialise_field_arrays() # Process geometry commands in the order they were given process_geometrycmds(geometry, G) # Build the PMLs and calculate initial coefficients if G.messages: print() if all(value == 0 for value in G.pmlthickness.values()): if G.messages: print('PML: switched off') pass # If all the PMLs are switched off don't need to build anything else: # Set default CFS parameters for PML if not given if not G.cfs: G.cfs = [CFS()] if G.messages: if all(value == G.pmlthickness['x0'] for value in G.pmlthickness.values()): pmlinfo = str(G.pmlthickness['x0']) else: pmlinfo = '' for key, value in G.pmlthickness.items(): pmlinfo += '{}: {}, '.format(key, value) pmlinfo = pmlinfo[:-2] + ' cells' print('PML: formulation: {}, order: {}, thickness: {}'.format(G.pmlformulation, len(G.cfs), pmlinfo)) pbar = tqdm(total=sum(1 for value in G.pmlthickness.values() if value > 0), desc='Building PML boundaries', ncols=get_terminal_width() - 1, file=sys.stdout, disable=not G.progressbars) build_pmls(G, pbar) pbar.close() # Build the model, i.e. set the material properties (ID) for every edge # of every Yee cell if G.messages: print() pbar = tqdm(total=2, desc='Building main grid', ncols=get_terminal_width() - 1, file=sys.stdout, disable=not G.progressbars) build_electric_components(G.solid, G.rigidE, G.ID, G) pbar.update() build_magnetic_components(G.solid, G.rigidH, G.ID, G) pbar.update() pbar.close() # Add PEC boundaries to invariant direction in 2D modes # N.B. 2D modes are a single cell slice of 3D grid if '2D TMx' in G.mode: # Ey & Ez components G.ID[1, 0, :, :] = 0 G.ID[1, 1, :, :] = 0 G.ID[2, 0, :, :] = 0 G.ID[2, 1, :, :] = 0 elif '2D TMy' in G.mode: # Ex & Ez components G.ID[0, :, 0, :] = 0 G.ID[0, :, 1, :] = 0 G.ID[2, :, 0, :] = 0 G.ID[2, :, 1, :] = 0 elif '2D TMz' in G.mode: # Ex & Ey components G.ID[0, :, :, 0] = 0 G.ID[0, :, :, 1] = 0 G.ID[1, :, :, 0] = 0 G.ID[1, :, :, 1] = 0 # Process any voltage sources (that have resistance) to create a new # material at the source location for voltagesource in G.voltagesources: voltagesource.create_material(G) # Initialise arrays of update coefficients to pass to update functions G.initialise_std_update_coeff_arrays() # Initialise arrays of update coefficients and temporary values if # there are any dispersive materials if Material.maxpoles != 0: # Update estimated memory (RAM) usage G.memoryusage += int(3 * Material.maxpoles * (G.nx + 1) * (G.ny + 1) * (G.nz + 1) * np.dtype(complextype).itemsize) G.memory_check() if G.messages: print('\nMemory (RAM) required - updated (dispersive): ~{}\n'.format(human_size(G.memoryusage))) G.initialise_dispersive_arrays() # Check there is sufficient memory to store any snapshots if G.snapshots: snapsmemsize = 0 for snap in G.snapshots: # 2 x required to account for electric and magnetic fields snapsmemsize += (2 * snap.datasizefield) G.memoryusage += int(snapsmemsize) G.memory_check(snapsmemsize=int(snapsmemsize)) if G.messages: print('\nMemory (RAM) required - updated (snapshots): ~{}\n'.format(human_size(G.memoryusage))) # Process complete list of materials - calculate update coefficients, # store in arrays, and build text list of materials/properties materialsdata = process_materials(G) if G.messages: print('\nMaterials:') materialstable = AsciiTable(materialsdata) materialstable.outer_border = False materialstable.justify_columns[0] = 'right' print(materialstable.table) # Check to see if numerical dispersion might be a problem results = dispersion_analysis(G) if results['error'] and G.messages: print(Fore.RED + "\nWARNING: Numerical dispersion analysis not carried out as {}".format(results['error']) + Style.RESET_ALL) elif results['N'] < G.mingridsampling: raise GeneralError("Non-physical wave propagation: Material '{}' has wavelength sampled by {} cells, less than required minimum for physical wave propagation. Maximum significant frequency estimated as {:g}Hz".format(results['material'].ID, results['N'], results['maxfreq'])) elif results['deltavp'] and np.abs(results['deltavp']) > G.maxnumericaldisp and G.messages: print(Fore.RED + "\nWARNING: Potentially significant numerical dispersion. Estimated largest physical phase-velocity error is {:.2f}% in material '{}' whose wavelength sampled by {} cells. Maximum significant frequency estimated as {:g}Hz".format(results['deltavp'], results['material'].ID, results['N'], results['maxfreq']) + Style.RESET_ALL) elif results['deltavp'] and G.messages: print("\nNumerical dispersion analysis: estimated largest physical phase-velocity error is {:.2f}% in material '{}' whose wavelength sampled by {} cells. Maximum significant frequency estimated as {:g}Hz".format(results['deltavp'], results['material'].ID, results['N'], results['maxfreq'])) # If geometry information to be reused between model runs else: inputfilestr = '\n--- Model {}/{}, input file (not re-processed, i.e. geometry fixed): {}'.format(currentmodelrun, modelend, inputfile.name) if G.messages: print(Fore.GREEN + '{} {}\n'.format(inputfilestr, '-' * (get_terminal_width() - 1 - len(inputfilestr))) + Style.RESET_ALL) if G.gpu is None: # Clear arrays for field components G.initialise_field_arrays() # Clear arrays for fields in PML for pml in G.pmls: pml.initialise_field_arrays() # Adjust position of simple sources and receivers if required if G.srcsteps[0] != 0 or G.srcsteps[1] != 0 or G.srcsteps[2] != 0: for source in itertools.chain(G.hertziandipoles, G.magneticdipoles): if currentmodelrun == 1: if source.xcoord + G.srcsteps[0] * modelend < 0 or source.xcoord + G.srcsteps[0] * modelend > G.nx or source.ycoord + G.srcsteps[1] * modelend < 0 or source.ycoord + G.srcsteps[1] * modelend > G.ny or source.zcoord + G.srcsteps[2] * modelend < 0 or source.zcoord + G.srcsteps[2] * modelend > G.nz: raise GeneralError('Source(s) will be stepped to a position outside the domain.') source.xcoord = source.xcoordorigin + (currentmodelrun - 1) * G.srcsteps[0] source.ycoord = source.ycoordorigin + (currentmodelrun - 1) * G.srcsteps[1] source.zcoord = source.zcoordorigin + (currentmodelrun - 1) * G.srcsteps[2] if G.rxsteps[0] != 0 or G.rxsteps[1] != 0 or G.rxsteps[2] != 0: for receiver in G.rxs: if currentmodelrun == 1: if receiver.xcoord + G.rxsteps[0] * modelend < 0 or receiver.xcoord + G.rxsteps[0] * modelend > G.nx or receiver.ycoord + G.rxsteps[1] * modelend < 0 or receiver.ycoord + G.rxsteps[1] * modelend > G.ny or receiver.zcoord + G.rxsteps[2] * modelend < 0 or receiver.zcoord + G.rxsteps[2] * modelend > G.nz: raise GeneralError('Receiver(s) will be stepped to a position outside the domain.') receiver.xcoord = receiver.xcoordorigin + (currentmodelrun - 1) * G.rxsteps[0] receiver.ycoord = receiver.ycoordorigin + (currentmodelrun - 1) * G.rxsteps[1] receiver.zcoord = receiver.zcoordorigin + (currentmodelrun - 1) * G.rxsteps[2] # Write files for any geometry views and geometry object outputs if not (G.geometryviews or G.geometryobjectswrite) and args.geometry_only and G.messages: print(Fore.RED + '\nWARNING: No geometry views or geometry objects to output found.' + Style.RESET_ALL) if G.geometryviews and (not args.geometry_fixed or currentmodelrun == 1): if G.messages: print() for i, geometryview in enumerate(G.geometryviews): geometryview.set_filename(appendmodelnumberGeometry, G) pbar = tqdm(total=geometryview.datawritesize, unit='byte', unit_scale=True, desc='Writing geometry view file {}/{}, {}'.format(i + 1, len(G.geometryviews), os.path.split(geometryview.filename)[1]), ncols=get_terminal_width() - 1, file=sys.stdout, disable=not G.progressbars) geometryview.write_vtk(G, pbar) pbar.close() if G.geometryobjectswrite: for i, geometryobject in enumerate(G.geometryobjectswrite): pbar = tqdm(total=geometryobject.datawritesize, unit='byte', unit_scale=True, desc='Writing geometry object file {}/{}, {}'.format(i + 1, len(G.geometryobjectswrite), os.path.split(geometryobject.filename)[1]), ncols=get_terminal_width() - 1, file=sys.stdout, disable=not G.progressbars) geometryobject.write_hdf5(G, pbar) pbar.close() # If only writing geometry information if args.geometry_only: tsolve = 0 # Run simulation else: # Output filename inputdirectory, inputfilename = os.path.split(os.path.join(G.inputdirectory, G.inputfilename)) if G.outputdirectory is None: outputdir = inputdirectory else: outputdir = G.outputdirectory # Save current directory curdir = os.getcwd() os.chdir(inputdirectory) outputdir = os.path.abspath(outputdir) if not os.path.isdir(outputdir): os.mkdir(outputdir) if G.messages: print('\nCreated output directory: {}'.format(outputdir)) # Restore current directory os.chdir(curdir) basename, ext = os.path.splitext(inputfilename) outputfile = os.path.join(outputdir, basename + appendmodelnumber + '.out') if G.messages: print('\nOutput file: {}\n'.format(outputfile)) # Main FDTD solving functions for either CPU or GPU if G.gpu is None: tsolve = solve_cpu(currentmodelrun, modelend, G) else: tsolve, memsolve = solve_gpu(currentmodelrun, modelend, G) # Write an output file in HDF5 format write_hdf5_outputfile(outputfile, G) # Write any snapshots to file if G.snapshots: # Create directory and construct filename from user-supplied name and model run number snapshotdir = os.path.join(G.inputdirectory, os.path.splitext(G.inputfilename)[0] + '_snaps' + appendmodelnumber) if not os.path.exists(snapshotdir): os.mkdir(snapshotdir) if G.messages: print() for i, snap in enumerate(G.snapshots): snap.filename = os.path.abspath(os.path.join(snapshotdir, snap.basefilename + '.vti')) pbar = tqdm(total=snap.vtkdatawritesize, leave=True, unit='byte', unit_scale=True, desc='Writing snapshot file {} of {}, {}'.format(i + 1, len(G.snapshots), os.path.split(snap.filename)[1]), ncols=get_terminal_width() - 1, file=sys.stdout, disable=not G.progressbars) snap.write_vtk_imagedata(pbar, G) pbar.close() if G.messages: print() if G.messages: if G.gpu is None: print('Memory (RAM) used: ~{}'.format(human_size(p.memory_info().rss))) else: print('Memory (RAM) used: ~{} host + ~{} GPU'.format(human_size(p.memory_info().rss), human_size(memsolve))) print('Solving time [HH:MM:SS]: {}'.format(datetime.timedelta(seconds=tsolve))) # If geometry information to be reused between model runs then FDTDGrid # class instance must be global so that it persists if not args.geometry_fixed or currentmodelrun is modelend: del G return tsolve
def test_attributes(): table_data = [['Name', 'Color', 'Type'], ['Avocado', 'green', 'nut'], ['Tomato', 'red', 'fruit'], ['Lettuce', 'green', 'vegetable'], ['Watermelon', 'green']] table = AsciiTable(table_data) table.justify_columns[0] = 'right' expected = dedent("""\ +------------+-------+-----------+ | Name | Color | Type | +------------+-------+-----------+ | Avocado | green | nut | | Tomato | red | fruit | | Lettuce | green | vegetable | | Watermelon | green | | +------------+-------+-----------+""") assert expected == table.table table.justify_columns[2] = 'center' expected = dedent("""\ +------------+-------+-----------+ | Name | Color | Type | +------------+-------+-----------+ | Avocado | green | nut | | Tomato | red | fruit | | Lettuce | green | vegetable | | Watermelon | green | | +------------+-------+-----------+""") assert expected == table.table table.inner_heading_row_border = False expected = dedent("""\ +------------+-------+-----------+ | Name | Color | Type | | Avocado | green | nut | | Tomato | red | fruit | | Lettuce | green | vegetable | | Watermelon | green | | +------------+-------+-----------+""") assert expected == table.table table.title = 'Foods' table.inner_column_border = False expected = dedent("""\ +Foods-------------------------+ | Name Color Type | | Avocado green nut | | Tomato red fruit | | Lettuce green vegetable | | Watermelon green | +------------------------------+""") assert expected == table.table table.outer_border = False expected = (' Name Color Type \n' ' Avocado green nut \n' ' Tomato red fruit \n' ' Lettuce green vegetable \n' ' Watermelon green ') assert expected == table.table table.outer_border = True table.inner_row_border = True expected = dedent("""\ +Foods-------------------------+ | Name Color Type | +------------------------------+ | Avocado green nut | +------------------------------+ | Tomato red fruit | +------------------------------+ | Lettuce green vegetable | +------------------------------+ | Watermelon green | +------------------------------+""") assert expected == table.table table.title = False table.inner_column_border = True table.inner_heading_row_border = False # Ignored due to inner_row_border. table.inner_row_border = True expected = dedent("""\ +------------+-------+-----------+ | Name | Color | Type | +------------+-------+-----------+ | Avocado | green | nut | +------------+-------+-----------+ | Tomato | red | fruit | +------------+-------+-----------+ | Lettuce | green | vegetable | +------------+-------+-----------+ | Watermelon | green | | +------------+-------+-----------+""") assert expected == table.table table.outer_border = False expected = (' Name | Color | Type \n' '------------+-------+-----------\n' ' Avocado | green | nut \n' '------------+-------+-----------\n' ' Tomato | red | fruit \n' '------------+-------+-----------\n' ' Lettuce | green | vegetable \n' '------------+-------+-----------\n' ' Watermelon | green | ') assert expected == table.table
def test_attributes(): """Test table attributes.""" table_data = [ ['Name', 'Color', 'Type'], ['Avocado', 'green', 'nut'], ['Tomato', 'red', 'fruit'], ['Lettuce', 'green', 'vegetable'], ['Watermelon', 'green'] ] table = AsciiTable(table_data) table.justify_columns[0] = 'right' expected = dedent("""\ +------------+-------+-----------+ | Name | Color | Type | +------------+-------+-----------+ | Avocado | green | nut | | Tomato | red | fruit | | Lettuce | green | vegetable | | Watermelon | green | | +------------+-------+-----------+""") assert expected == table.table table.justify_columns[2] = 'center' expected = dedent("""\ +------------+-------+-----------+ | Name | Color | Type | +------------+-------+-----------+ | Avocado | green | nut | | Tomato | red | fruit | | Lettuce | green | vegetable | | Watermelon | green | | +------------+-------+-----------+""") assert expected == table.table table.inner_heading_row_border = False expected = dedent("""\ +------------+-------+-----------+ | Name | Color | Type | | Avocado | green | nut | | Tomato | red | fruit | | Lettuce | green | vegetable | | Watermelon | green | | +------------+-------+-----------+""") assert expected == table.table table.title = 'Foods' table.inner_column_border = False expected = dedent("""\ +Foods-------------------------+ | Name Color Type | | Avocado green nut | | Tomato red fruit | | Lettuce green vegetable | | Watermelon green | +------------------------------+""") assert expected == table.table table.outer_border = False expected = ( ' Name Color Type \n' ' Avocado green nut \n' ' Tomato red fruit \n' ' Lettuce green vegetable \n' ' Watermelon green ' ) assert expected == table.table table.outer_border = True table.inner_row_border = True expected = dedent("""\ +Foods-------------------------+ | Name Color Type | +------------------------------+ | Avocado green nut | +------------------------------+ | Tomato red fruit | +------------------------------+ | Lettuce green vegetable | +------------------------------+ | Watermelon green | +------------------------------+""") assert expected == table.table table.title = False table.inner_column_border = True table.inner_heading_row_border = False # Ignored due to inner_row_border. table.inner_row_border = True expected = dedent("""\ +------------+-------+-----------+ | Name | Color | Type | +------------+-------+-----------+ | Avocado | green | nut | +------------+-------+-----------+ | Tomato | red | fruit | +------------+-------+-----------+ | Lettuce | green | vegetable | +------------+-------+-----------+ | Watermelon | green | | +------------+-------+-----------+""") assert expected == table.table table.outer_border = False expected = ( ' Name | Color | Type \n' '------------+-------+-----------\n' ' Avocado | green | nut \n' '------------+-------+-----------\n' ' Tomato | red | fruit \n' '------------+-------+-----------\n' ' Lettuce | green | vegetable \n' '------------+-------+-----------\n' ' Watermelon | green | ' ) assert expected == table.table
def generatePrintTable(PField): resultTable = AsciiTable(PField) resultTable.inner_heading_row_border = True resultTable.outer_border = True resultTable.inner_row_border = True print(resultTable.table)
def print_summary(row_data): table = AsciiTable([row_data]) table.outer_border = False table.padding_left = 10 table.padding_right = 2 print(table.table)
def format_key_values(key_values: KeyValuesType, title: Optional[str] = None, formatter: Callable[[Any], str] = str, delimiter_char: str = '=') -> str: """ Format key value sequence into str. The basic usage, to format a :class:`Config`, a dict or a list of tuples: >>> print(format_key_values(Config(a=123, b=Config(value=456)))) a 123 b.value 456 >>> print(format_key_values({'a': 123, 'b': {'value': 456}})) a 123 b {'value': 456} >>> print(format_key_values([('a', 123), ('b', {'value': 456})])) a 123 b {'value': 456} To add a title and a delimiter: >>> print(format_key_values(Config(a=123, b=Config(value=456)), ... title='short title')) short title ============= a 123 b.value 456 >>> print(format_key_values({'a': 123, 'b': {'value': 456}}, ... title='long long long title')) long long long title ==================== a 123 b {'value': 456} Args: key_values: The sequence of key values, may be a :class:`Config`, a dict, or a list of (key, value) pairs. If it is a :class:`Config`, it will be flatten via :meth:`Config.to_flatten_dict()`. title: If specified, will prepend a title and a horizontal delimiter to the front of returned string. formatter: The function to format values. delimiter_char: The character to use for the delimiter between title and config key values. Returns: The formatted str. """ if len(delimiter_char) != 1: raise ValueError(f'`delimiter_char` must be one character: ' f'got {delimiter_char!r}') if isinstance(key_values, Config): key_values = config_to_dict(key_values, flatten=True) if hasattr(key_values, 'items'): data = [(key, formatter(value)) for key, value in key_values.items()] else: data = [(key, formatter(value)) for key, value in key_values] # use the terminaltables.AsciiTable to format our key values table = AsciiTable(data) table.padding_left = 0 table.padding_right = 3 table.inner_column_border = False table.inner_footing_row_border = False table.inner_heading_row_border = False table.inner_row_border = False table.outer_border = False lines = [line.rstrip() for line in table.table.split('\n')] # prepend a title if title is not None: max_length = max(max(map(len, lines)), len(title)) delim = delimiter_char * max_length lines = [title, delim] + lines return '\n'.join(lines)
def run_model(args, modelrun, numbermodelruns, inputfile, usernamespace): """Runs a model - processes the input file; builds the Yee cells; calculates update coefficients; runs main FDTD loop. Args: args (dict): Namespace with command line arguments modelrun (int): Current model run number. numbermodelruns (int): Total number of model runs. inputfile (str): Name of the input file to open. usernamespace (dict): Namespace that can be accessed by user in any Python code blocks in input file. Returns: tsolve (int): Length of time (seconds) of main FDTD calculations """ # Monitor memory usage p = psutil.Process() # Declare variable to hold FDTDGrid class global G # Normal model reading/building process; bypassed if geometry information to be reused if 'G' not in globals(): inputfilestr = '\n--- Model {} of {}, input file: {}'.format(modelrun, numbermodelruns, inputfile) print(Fore.GREEN + '{} {}\n'.format(inputfilestr, '-' * (get_terminal_width() - 1 - len(inputfilestr))) + Style.RESET_ALL) # Add the current model run to namespace that can be accessed by user in any Python code blocks in input file usernamespace['current_model_run'] = modelrun # Read input file and process any Python or include commands processedlines = process_python_include_code(inputfile, usernamespace) # Print constants/variables in user-accessable namespace uservars = '' for key, value in sorted(usernamespace.items()): if key != '__builtins__': uservars += '{}: {}, '.format(key, value) print('Constants/variables used/available for Python scripting: {{{}}}\n'.format(uservars[:-2])) # Write a file containing the input commands after Python or include commands have been processed if args.write_processed: write_processed_file(inputfile, modelrun, numbermodelruns, processedlines) # Check validity of command names and that essential commands are present singlecmds, multicmds, geometry = check_cmd_names(processedlines) # Initialise an instance of the FDTDGrid class G = FDTDGrid() G.inputfilename = os.path.split(inputfile)[1] G.inputdirectory = os.path.dirname(os.path.abspath(inputfile)) # Create built-in materials m = Material(0, 'pec') m.se = float('inf') m.type = 'builtin' m.averagable = False G.materials.append(m) m = Material(1, 'free_space') m.type = 'builtin' G.materials.append(m) # Process parameters for commands that can only occur once in the model process_singlecmds(singlecmds, G) # Process parameters for commands that can occur multiple times in the model print() process_multicmds(multicmds, G) # Initialise an array for volumetric material IDs (solid), boolean arrays for specifying materials not to be averaged (rigid), # an array for cell edge IDs (ID) G.initialise_geometry_arrays() # Initialise arrays for the field components G.initialise_field_arrays() # Process geometry commands in the order they were given process_geometrycmds(geometry, G) # Build the PMLs and calculate initial coefficients print() if all(value == 0 for value in G.pmlthickness.values()): if G.messages: print('PML boundaries: switched off') pass # If all the PMLs are switched off don't need to build anything else: if G.messages: if all(value == G.pmlthickness['xminus'] for value in G.pmlthickness.values()): pmlinfo = G.pmlthickness['xminus'] else: pmlinfo = '' for key, value in G.pmlthickness.items(): pmlinfo += '{}: {}, '.format(key, value) pmlinfo = pmlinfo[:-2] print('PML boundaries: {} cells'.format(pmlinfo)) pbar = tqdm(total=sum(1 for value in G.pmlthickness.values() if value > 0), desc='Building PML boundaries', ncols=get_terminal_width() - 1, file=sys.stdout, disable=G.tqdmdisable) build_pmls(G, pbar) pbar.close() # Build the model, i.e. set the material properties (ID) for every edge of every Yee cell print() pbar = tqdm(total=2, desc='Building main grid', ncols=get_terminal_width() - 1, file=sys.stdout, disable=G.tqdmdisable) build_electric_components(G.solid, G.rigidE, G.ID, G) pbar.update() build_magnetic_components(G.solid, G.rigidH, G.ID, G) pbar.update() pbar.close() # Process any voltage sources (that have resistance) to create a new material at the source location for voltagesource in G.voltagesources: voltagesource.create_material(G) # Initialise arrays of update coefficients to pass to update functions G.initialise_std_update_coeff_arrays() # Initialise arrays of update coefficients and temporary values if there are any dispersive materials if Material.maxpoles != 0: G.initialise_dispersive_arrays() # Process complete list of materials - calculate update coefficients, store in arrays, and build text list of materials/properties materialsdata = process_materials(G) if G.messages: materialstable = AsciiTable(materialsdata) materialstable.outer_border = False materialstable.justify_columns[0] = 'right' print(materialstable.table) # Check to see if numerical dispersion might be a problem results = dispersion_analysis(G) if results['deltavp'] and np.abs(results['deltavp']) > G.maxnumericaldisp: print(Fore.RED + "\nWARNING: Potentially significant numerical dispersion. Largest physical phase-velocity error is {:.2f}% in material '{}' with wavelength sampled by {} cells (maximum significant frequency {:g}Hz)".format(results['deltavp'], results['material'].ID, round_value(results['N']), results['maxfreq']) + Style.RESET_ALL) elif results['deltavp']: print("\nNumerical dispersion analysis: largest physical phase-velocity error is {:.2f}% in material '{}' with wavelength sampled by {} cells (maximum significant frequency {:g}Hz)".format(results['deltavp'], results['material'].ID, round_value(results['N']), results['maxfreq'])) # If geometry information to be reused between model runs else: inputfilestr = '\n--- Model {} of {}, input file (not re-processed, i.e. geometry fixed): {}'.format(modelrun, numbermodelruns, inputfile) print(Fore.GREEN + '{} {}\n'.format(inputfilestr, '-' * (get_terminal_width() - 1 - len(inputfilestr))) + Style.RESET_ALL) # Clear arrays for field components G.initialise_field_arrays() # Clear arrays for fields in PML for pml in G.pmls: pml.initialise_field_arrays() # Adjust position of simple sources and receivers if required if G.srcsteps[0] > 0 or G.srcsteps[1] > 0 or G.srcsteps[2] > 0: for source in itertools.chain(G.hertziandipoles, G.magneticdipoles): if modelrun == 1: if source.xcoord + G.srcsteps[0] * (numbermodelruns - 1) > G.nx or source.ycoord + G.srcsteps[1] * (numbermodelruns - 1) > G.ny or source.zcoord + G.srcsteps[2] * (numbermodelruns - 1) > G.nz: raise GeneralError('Source(s) will be stepped to a position outside the domain.') source.xcoord = source.xcoordorigin + (modelrun - 1) * G.srcsteps[0] source.ycoord = source.ycoordorigin + (modelrun - 1) * G.srcsteps[1] source.zcoord = source.zcoordorigin + (modelrun - 1) * G.srcsteps[2] if G.rxsteps[0] > 0 or G.rxsteps[1] > 0 or G.rxsteps[2] > 0: for receiver in G.rxs: if modelrun == 1: if receiver.xcoord + G.rxsteps[0] * (numbermodelruns - 1) > G.nx or receiver.ycoord + G.rxsteps[1] * (numbermodelruns - 1) > G.ny or receiver.zcoord + G.rxsteps[2] * (numbermodelruns - 1) > G.nz: raise GeneralError('Receiver(s) will be stepped to a position outside the domain.') receiver.xcoord = receiver.xcoordorigin + (modelrun - 1) * G.rxsteps[0] receiver.ycoord = receiver.ycoordorigin + (modelrun - 1) * G.rxsteps[1] receiver.zcoord = receiver.zcoordorigin + (modelrun - 1) * G.rxsteps[2] # Write files for any geometry views and geometry object outputs if not (G.geometryviews or G.geometryobjectswrite) and args.geometry_only: print(Fore.RED + '\nWARNING: No geometry views or geometry objects to output found.' + Style.RESET_ALL) if G.geometryviews: print() for i, geometryview in enumerate(G.geometryviews): geometryview.set_filename(modelrun, numbermodelruns, G) pbar = tqdm(total=geometryview.datawritesize, unit='byte', unit_scale=True, desc='Writing geometry view file {} of {}, {}'.format(i + 1, len(G.geometryviews), os.path.split(geometryview.filename)[1]), ncols=get_terminal_width() - 1, file=sys.stdout, disable=G.tqdmdisable) geometryview.write_vtk(modelrun, numbermodelruns, G, pbar) pbar.close() if G.geometryobjectswrite: for i, geometryobject in enumerate(G.geometryobjectswrite): pbar = tqdm(total=geometryobject.datawritesize, unit='byte', unit_scale=True, desc='Writing geometry object file {} of {}, {}'.format(i + 1, len(G.geometryobjectswrite), os.path.split(geometryobject.filename)[1]), ncols=get_terminal_width() - 1, file=sys.stdout, disable=G.tqdmdisable) geometryobject.write_hdf5(G, pbar) pbar.close() # Run simulation (if not doing geometry only) if not args.geometry_only: # Prepare any snapshot files for snapshot in G.snapshots: snapshot.prepare_vtk_imagedata(modelrun, numbermodelruns, G) # Output filename inputfileparts = os.path.splitext(inputfile) if numbermodelruns == 1: outputfile = inputfileparts[0] + '.out' else: outputfile = inputfileparts[0] + str(modelrun) + '.out' print('\nOutput file: {}\n'.format(outputfile)) #################################### # Start - Main FDTD calculations # #################################### tsolvestart = perf_counter() # Absolute time abstime = 0 for timestep in tqdm(range(G.iterations), desc='Running simulation, model ' + str(modelrun) + ' of ' + str(numbermodelruns), ncols=get_terminal_width() - 1, file=sys.stdout, disable=G.tqdmdisable): # Store field component values for every receiver and transmission line store_outputs(timestep, G.Ex, G.Ey, G.Ez, G.Hx, G.Hy, G.Hz, G) # Write any snapshots to file for i, snap in enumerate(G.snapshots): if snap.time == timestep + 1: snapiters = 36 * (((snap.xf - snap.xs) / snap.dx) * ((snap.yf - snap.ys) / snap.dy) * ((snap.zf - snap.zs) / snap.dz)) pbar = tqdm(total=snapiters, leave=False, unit='byte', unit_scale=True, desc=' Writing snapshot file {} of {}, {}'.format(i + 1, len(G.snapshots), os.path.split(snap.filename)[1]), ncols=get_terminal_width() - 1, file=sys.stdout, disable=G.tqdmdisable) snap.write_vtk_imagedata(G.Ex, G.Ey, G.Ez, G.Hx, G.Hy, G.Hz, G, pbar) pbar.close() # Update electric field components if Material.maxpoles == 0: # All materials are non-dispersive so do standard update update_electric(G.nx, G.ny, G.nz, G.nthreads, G.updatecoeffsE, G.ID, G.Ex, G.Ey, G.Ez, G.Hx, G.Hy, G.Hz) elif Material.maxpoles == 1: # If there are any dispersive materials do 1st part of dispersive update (it is split into two parts as it requires present and updated electric field values). update_electric_dispersive_1pole_A(G.nx, G.ny, G.nz, G.nthreads, G.updatecoeffsE, G.updatecoeffsdispersive, G.ID, G.Tx, G.Ty, G.Tz, G.Ex, G.Ey, G.Ez, G.Hx, G.Hy, G.Hz) elif Material.maxpoles > 1: update_electric_dispersive_multipole_A(G.nx, G.ny, G.nz, G.nthreads, Material.maxpoles, G.updatecoeffsE, G.updatecoeffsdispersive, G.ID, G.Tx, G.Ty, G.Tz, G.Ex, G.Ey, G.Ez, G.Hx, G.Hy, G.Hz) # Update electric field components with the PML correction for pml in G.pmls: pml.update_electric(G) # Update electric field components from sources (update any Hertzian dipole sources last) for source in G.voltagesources + G.transmissionlines + G.hertziandipoles: source.update_electric(abstime, G.updatecoeffsE, G.ID, G.Ex, G.Ey, G.Ez, G) # If there are any dispersive materials do 2nd part of dispersive update (it is split into two parts as it requires present and updated electric field values). Therefore it can only be completely updated after the electric field has been updated by the PML and source updates. if Material.maxpoles == 1: update_electric_dispersive_1pole_B(G.nx, G.ny, G.nz, G.nthreads, G.updatecoeffsdispersive, G.ID, G.Tx, G.Ty, G.Tz, G.Ex, G.Ey, G.Ez) elif Material.maxpoles > 1: update_electric_dispersive_multipole_B(G.nx, G.ny, G.nz, G.nthreads, Material.maxpoles, G.updatecoeffsdispersive, G.ID, G.Tx, G.Ty, G.Tz, G.Ex, G.Ey, G.Ez) # Increment absolute time value abstime += 0.5 * G.dt # Update magnetic field components update_magnetic(G.nx, G.ny, G.nz, G.nthreads, G.updatecoeffsH, G.ID, G.Ex, G.Ey, G.Ez, G.Hx, G.Hy, G.Hz) # Update magnetic field components with the PML correction for pml in G.pmls: pml.update_magnetic(G) # Update magnetic field components from sources for source in G.transmissionlines + G.magneticdipoles: source.update_magnetic(abstime, G.updatecoeffsH, G.ID, G.Hx, G.Hy, G.Hz, G) # Increment absolute time value abstime += 0.5 * G.dt tsolve = int(perf_counter() - tsolvestart) # Write an output file in HDF5 format write_hdf5_outputfile(outputfile, G.Ex, G.Ey, G.Ez, G.Hx, G.Hy, G.Hz, G) ################################## # End - Main FDTD calculations # ################################## if G.messages: print('Memory (RAM) used: ~{}'.format(human_size(p.memory_info().rss))) # If geometry information to be reused between model runs then FDTDGrid class instance must be global so that it persists if not args.geometry_fixed: del G # Return time to complete solving if in benchmarking mode if args.benchmark: return tsolve
def run_model(args, currentmodelrun, modelend, numbermodelruns, inputfile, usernamespace): """Runs a model - processes the input file; builds the Yee cells; calculates update coefficients; runs main FDTD loop. Args: args (dict): Namespace with command line arguments currentmodelrun (int): Current model run number. modelend (int): Number of last model to run. numbermodelruns (int): Total number of model runs. inputfile (object): File object for the input file. usernamespace (dict): Namespace that can be accessed by user in any Python code blocks in input file. Returns: tsolve (int): Length of time (seconds) of main FDTD calculations """ # Monitor memory usage p = psutil.Process() # Declare variable to hold FDTDGrid class global G # Used for naming geometry and output files appendmodelnumber = '' if numbermodelruns == 1 and not args.task and not args.restart else str(currentmodelrun) # Normal model reading/building process; bypassed if geometry information to be reused if 'G' not in globals(): # Initialise an instance of the FDTDGrid class G = FDTDGrid() G.inputfilename = os.path.split(inputfile.name)[1] G.inputdirectory = os.path.dirname(os.path.abspath(inputfile.name)) inputfilestr = '\n--- Model {}/{}, input file: {}'.format(currentmodelrun, modelend, inputfile.name) print(Fore.GREEN + '{} {}\n'.format(inputfilestr, '-' * (get_terminal_width() - 1 - len(inputfilestr))) + Style.RESET_ALL) # Add the current model run to namespace that can be accessed by user in any Python code blocks in input file usernamespace['current_model_run'] = currentmodelrun # Read input file and process any Python and include file commands processedlines = process_python_include_code(inputfile, usernamespace) # Print constants/variables in user-accessable namespace uservars = '' for key, value in sorted(usernamespace.items()): if key != '__builtins__': uservars += '{}: {}, '.format(key, value) print('Constants/variables used/available for Python scripting: {{{}}}\n'.format(uservars[:-2])) # Write a file containing the input commands after Python or include file commands have been processed if args.write_processed: write_processed_file(processedlines, appendmodelnumber, G) # Check validity of command names and that essential commands are present singlecmds, multicmds, geometry = check_cmd_names(processedlines) # Create built-in materials m = Material(0, 'pec') m.se = float('inf') m.type = 'builtin' m.averagable = False G.materials.append(m) m = Material(1, 'free_space') m.type = 'builtin' G.materials.append(m) # Process parameters for commands that can only occur once in the model process_singlecmds(singlecmds, G) # Process parameters for commands that can occur multiple times in the model print() process_multicmds(multicmds, G) # Initialise an array for volumetric material IDs (solid), boolean arrays for specifying materials not to be averaged (rigid), # an array for cell edge IDs (ID) G.initialise_geometry_arrays() # Initialise arrays for the field components G.initialise_field_arrays() # Process geometry commands in the order they were given process_geometrycmds(geometry, G) # Build the PMLs and calculate initial coefficients print() if all(value == 0 for value in G.pmlthickness.values()): if G.messages: print('PML boundaries: switched off') pass # If all the PMLs are switched off don't need to build anything else: if G.messages: if all(value == G.pmlthickness['x0'] for value in G.pmlthickness.values()): pmlinfo = str(G.pmlthickness['x0']) + ' cells' else: pmlinfo = '' for key, value in G.pmlthickness.items(): pmlinfo += '{}: {} cells, '.format(key, value) pmlinfo = pmlinfo[:-2] print('PML boundaries: {}'.format(pmlinfo)) pbar = tqdm(total=sum(1 for value in G.pmlthickness.values() if value > 0), desc='Building PML boundaries', ncols=get_terminal_width() - 1, file=sys.stdout, disable=G.tqdmdisable) build_pmls(G, pbar) pbar.close() # Build the model, i.e. set the material properties (ID) for every edge of every Yee cell print() pbar = tqdm(total=2, desc='Building main grid', ncols=get_terminal_width() - 1, file=sys.stdout, disable=G.tqdmdisable) build_electric_components(G.solid, G.rigidE, G.ID, G) pbar.update() build_magnetic_components(G.solid, G.rigidH, G.ID, G) pbar.update() pbar.close() # Process any voltage sources (that have resistance) to create a new material at the source location for voltagesource in G.voltagesources: voltagesource.create_material(G) # Initialise arrays of update coefficients to pass to update functions G.initialise_std_update_coeff_arrays() # Initialise arrays of update coefficients and temporary values if there are any dispersive materials if Material.maxpoles != 0: G.initialise_dispersive_arrays() # Process complete list of materials - calculate update coefficients, store in arrays, and build text list of materials/properties materialsdata = process_materials(G) if G.messages: print('\nMaterials:') materialstable = AsciiTable(materialsdata) materialstable.outer_border = False materialstable.justify_columns[0] = 'right' print(materialstable.table) # Check to see if numerical dispersion might be a problem results = dispersion_analysis(G) if not results['waveform']: print(Fore.RED + "\nWARNING: Numerical dispersion analysis not carried out as either no waveform detected or waveform does not fit within specified time window and is therefore being truncated." + Style.RESET_ALL) elif results['N'] < G.mingridsampling: raise GeneralError("Non-physical wave propagation: Material '{}' has wavelength sampled by {} cells, less than required minimum for physical wave propagation. Maximum significant frequency estimated as {:g}Hz".format(results['material'].ID, results['N'], results['maxfreq'])) elif results['deltavp'] and np.abs(results['deltavp']) > G.maxnumericaldisp: print(Fore.RED + "\nWARNING: Potentially significant numerical dispersion. Estimated largest physical phase-velocity error is {:.2f}% in material '{}' whose wavelength sampled by {} cells. Maximum significant frequency estimated as {:g}Hz".format(results['deltavp'], results['material'].ID, results['N'], results['maxfreq']) + Style.RESET_ALL) elif results['deltavp'] and G.messages: print("\nNumerical dispersion analysis: estimated largest physical phase-velocity error is {:.2f}% in material '{}' whose wavelength sampled by {} cells. Maximum significant frequency estimated as {:g}Hz".format(results['deltavp'], results['material'].ID, results['N'], results['maxfreq'])) # If geometry information to be reused between model runs else: inputfilestr = '\n--- Model {}/{}, input file (not re-processed, i.e. geometry fixed): {}'.format(currentmodelrun, modelend, inputfile.name) print(Fore.GREEN + '{} {}\n'.format(inputfilestr, '-' * (get_terminal_width() - 1 - len(inputfilestr))) + Style.RESET_ALL) # Clear arrays for field components G.initialise_field_arrays() # Clear arrays for fields in PML for pml in G.pmls: pml.initialise_field_arrays() # Adjust position of simple sources and receivers if required if G.srcsteps[0] != 0 or G.srcsteps[1] != 0 or G.srcsteps[2] != 0: for source in itertools.chain(G.hertziandipoles, G.magneticdipoles): if currentmodelrun == 1: if source.xcoord + G.srcsteps[0] * modelend < 0 or source.xcoord + G.srcsteps[0] * modelend > G.nx or source.ycoord + G.srcsteps[1] * modelend < 0 or source.ycoord + G.srcsteps[1] * modelend > G.ny or source.zcoord + G.srcsteps[2] * modelend < 0 or source.zcoord + G.srcsteps[2] * modelend > G.nz: raise GeneralError('Source(s) will be stepped to a position outside the domain.') source.xcoord = source.xcoordorigin + (currentmodelrun - 1) * G.srcsteps[0] source.ycoord = source.ycoordorigin + (currentmodelrun - 1) * G.srcsteps[1] source.zcoord = source.zcoordorigin + (currentmodelrun - 1) * G.srcsteps[2] if G.rxsteps[0] != 0 or G.rxsteps[1] != 0 or G.rxsteps[2] != 0: for receiver in G.rxs: if currentmodelrun == 1: if receiver.xcoord + G.rxsteps[0] * modelend < 0 or receiver.xcoord + G.rxsteps[0] * modelend > G.nx or receiver.ycoord + G.rxsteps[1] * modelend < 0 or receiver.ycoord + G.rxsteps[1] * modelend > G.ny or receiver.zcoord + G.rxsteps[2] * modelend < 0 or receiver.zcoord + G.rxsteps[2] * modelend > G.nz: raise GeneralError('Receiver(s) will be stepped to a position outside the domain.') receiver.xcoord = receiver.xcoordorigin + (currentmodelrun - 1) * G.rxsteps[0] receiver.ycoord = receiver.ycoordorigin + (currentmodelrun - 1) * G.rxsteps[1] receiver.zcoord = receiver.zcoordorigin + (currentmodelrun - 1) * G.rxsteps[2] # Write files for any geometry views and geometry object outputs if not (G.geometryviews or G.geometryobjectswrite) and args.geometry_only: print(Fore.RED + '\nWARNING: No geometry views or geometry objects to output found.' + Style.RESET_ALL) if G.geometryviews: print() for i, geometryview in enumerate(G.geometryviews): geometryview.set_filename(appendmodelnumber, G) pbar = tqdm(total=geometryview.datawritesize, unit='byte', unit_scale=True, desc='Writing geometry view file {}/{}, {}'.format(i + 1, len(G.geometryviews), os.path.split(geometryview.filename)[1]), ncols=get_terminal_width() - 1, file=sys.stdout, disable=G.tqdmdisable) geometryview.write_vtk(G, pbar) pbar.close() if G.geometryobjectswrite: for i, geometryobject in enumerate(G.geometryobjectswrite): pbar = tqdm(total=geometryobject.datawritesize, unit='byte', unit_scale=True, desc='Writing geometry object file {}/{}, {}'.format(i + 1, len(G.geometryobjectswrite), os.path.split(geometryobject.filename)[1]), ncols=get_terminal_width() - 1, file=sys.stdout, disable=G.tqdmdisable) geometryobject.write_hdf5(G, pbar) pbar.close() # If only writing geometry information if args.geometry_only: tsolve = 0 # Run simulation else: # Prepare any snapshot files for snapshot in G.snapshots: snapshot.prepare_vtk_imagedata(appendmodelnumber, G) # Output filename inputfileparts = os.path.splitext(os.path.join(G.inputdirectory, G.inputfilename)) outputfile = inputfileparts[0] + appendmodelnumber + '.out' print('\nOutput file: {}\n'.format(outputfile)) # Main FDTD solving functions for either CPU or GPU tsolve = solve_cpu(currentmodelrun, modelend, G) # Write an output file in HDF5 format write_hdf5_outputfile(outputfile, G.Ex, G.Ey, G.Ez, G.Hx, G.Hy, G.Hz, G) if G.messages: print('Memory (RAM) used: ~{}'.format(human_size(p.memory_info().rss))) print('Solving time [HH:MM:SS]: {}'.format(datetime.timedelta(seconds=tsolve))) # If geometry information to be reused between model runs then FDTDGrid class instance must be global so that it persists if not args.geometry_fixed: del G return tsolve
Just prints sample text and exits. """ from __future__ import print_function from terminaltables import AsciiTable, DoubleTable table_data = [ ['Platform', 'Years', 'Notes'], ['Mk5', '2007-2009', '\033[37;41mUnavailable\033[0m'], ['MKVI', '2009-2013', 'Might actually be Mk5.'], ] table = AsciiTable(table_data, 'wangbin') print() print(table.table) table = DoubleTable(table_data, 'Jetta SportWagen') table.inner_row_border = True table.justify_columns[2] = 'right' print() print(table.table) table.outer_border = False table.justify_columns[1] = 'center' print() print(table.table) print()
"""Simple example usage of terminaltables without any other dependencies. Just prints sample text and exits. """ from __future__ import print_function from terminaltables import AsciiTable, DoubleTable table_data = [ ['Platform', 'Years', 'Notes'], ['Mk5', '2007-2009', '\033[37;41mUnavailable\033[0m'], ['MKVI', '2009-2013', 'Might actually be Mk5.'], ] table = AsciiTable(table_data, 'wangbin') print() print(table.table) table = DoubleTable(table_data, 'Jetta SportWagen') table.inner_row_border = True table.justify_columns[2] = 'right' print() print(table.table) table.outer_border = False table.justify_columns[1] = 'center' print() print(table.table) print()
def run_model(args, modelrun, numbermodelruns, inputfile, usernamespace): """Runs a model - processes the input file; builds the Yee cells; calculates update coefficients; runs main FDTD loop. Args: args (dict): Namespace with command line arguments modelrun (int): Current model run number. numbermodelruns (int): Total number of model runs. inputfile (str): Name of the input file to open. usernamespace (dict): Namespace that can be accessed by user in any Python code blocks in input file. Returns: tsolve (int): Length of time (seconds) of main FDTD calculations """ # Monitor memory usage p = psutil.Process() # Declare variable to hold FDTDGrid class global G # Normal model reading/building process; bypassed if geometry information to be reused if 'G' not in globals(): inputfilestr = '\n--- Model {}/{}, input file: {}'.format( modelrun, numbermodelruns, inputfile) print(Fore.GREEN + '{} {}\n'.format( inputfilestr, '-' * (get_terminal_width() - 1 - len(inputfilestr))) + Style.RESET_ALL) # Add the current model run to namespace that can be accessed by user in any Python code blocks in input file usernamespace['current_model_run'] = modelrun # Read input file and process any Python or include commands processedlines = process_python_include_code(inputfile, usernamespace) # Print constants/variables in user-accessable namespace uservars = '' for key, value in sorted(usernamespace.items()): if key != '__builtins__': uservars += '{}: {}, '.format(key, value) print( 'Constants/variables used/available for Python scripting: {{{}}}\n' .format(uservars[:-2])) # Write a file containing the input commands after Python or include commands have been processed if args.write_processed: write_processed_file(inputfile, modelrun, numbermodelruns, processedlines) # Check validity of command names and that essential commands are present singlecmds, multicmds, geometry = check_cmd_names(processedlines) # Initialise an instance of the FDTDGrid class G = FDTDGrid() G.inputfilename = os.path.split(inputfile)[1] G.inputdirectory = os.path.dirname(os.path.abspath(inputfile)) # Create built-in materials m = Material(0, 'pec') m.se = float('inf') m.type = 'builtin' m.averagable = False G.materials.append(m) m = Material(1, 'free_space') m.type = 'builtin' G.materials.append(m) # Process parameters for commands that can only occur once in the model process_singlecmds(singlecmds, G) # Process parameters for commands that can occur multiple times in the model print() process_multicmds(multicmds, G) # Initialise an array for volumetric material IDs (solid), boolean arrays for specifying materials not to be averaged (rigid), # an array for cell edge IDs (ID) G.initialise_geometry_arrays() # Initialise arrays for the field components G.initialise_field_arrays() # Process geometry commands in the order they were given process_geometrycmds(geometry, G) # Build the PMLs and calculate initial coefficients print() if all(value == 0 for value in G.pmlthickness.values()): if G.messages: print('PML boundaries: switched off') pass # If all the PMLs are switched off don't need to build anything else: if G.messages: if all(value == G.pmlthickness['x0'] for value in G.pmlthickness.values()): pmlinfo = str(G.pmlthickness['x0']) + ' cells' else: pmlinfo = '' for key, value in G.pmlthickness.items(): pmlinfo += '{}: {} cells, '.format(key, value) pmlinfo = pmlinfo[:-2] print('PML boundaries: {}'.format(pmlinfo)) pbar = tqdm(total=sum(1 for value in G.pmlthickness.values() if value > 0), desc='Building PML boundaries', ncols=get_terminal_width() - 1, file=sys.stdout, disable=G.tqdmdisable) build_pmls(G, pbar) pbar.close() # Build the model, i.e. set the material properties (ID) for every edge of every Yee cell print() pbar = tqdm(total=2, desc='Building main grid', ncols=get_terminal_width() - 1, file=sys.stdout, disable=G.tqdmdisable) build_electric_components(G.solid, G.rigidE, G.ID, G) pbar.update() build_magnetic_components(G.solid, G.rigidH, G.ID, G) pbar.update() pbar.close() # Process any voltage sources (that have resistance) to create a new material at the source location for voltagesource in G.voltagesources: voltagesource.create_material(G) # Initialise arrays of update coefficients to pass to update functions G.initialise_std_update_coeff_arrays() # Initialise arrays of update coefficients and temporary values if there are any dispersive materials if Material.maxpoles != 0: G.initialise_dispersive_arrays() # Process complete list of materials - calculate update coefficients, store in arrays, and build text list of materials/properties materialsdata = process_materials(G) if G.messages: materialstable = AsciiTable(materialsdata) materialstable.outer_border = False materialstable.justify_columns[0] = 'right' print(materialstable.table) # Check to see if numerical dispersion might be a problem results = dispersion_analysis(G) if all(value == False for value in results.values()): print( '\nNumerical dispersion analysis: No waveform present in model' ) elif results['N'] < G.mingridsampling: raise GeneralError( "Non-physical wave propagation: Material '{}' has a wavelength sampled by {} cells, less than required minimum for physical wave propagation. Maximum significant frequency estimated as {:g}Hz" .format(results['material'].ID, results['N'], results['maxfreq'])) elif results['deltavp'] and np.abs( results['deltavp']) > G.maxnumericaldisp: print( Fore.RED + "\nWARNING: Potentially significant numerical dispersion. Estimated largest physical phase-velocity error is {:.2f}% in material '{}' whose wavelength is sampled by {} cells. Maximum significant frequency estimated as {:g}Hz" .format(results['deltavp'], results['material'].ID, results['N'], results['maxfreq']) + Style.RESET_ALL) elif results['deltavp']: print( "\nNumerical dispersion analysis: estimated largest physical phase-velocity error is {:.2f}% in material '{}' whose wavelength is sampled by {} cells. Maximum significant frequency estimated as {:g}Hz" .format(results['deltavp'], results['material'].ID, results['N'], results['maxfreq'])) # If geometry information to be reused between model runs else: inputfilestr = '\n--- Model {}/{}, input file not re-processed, i.e. geometry fixed: {}'.format( modelrun, numbermodelruns, inputfile) print(Fore.GREEN + '{} {}\n'.format( inputfilestr, '-' * (get_terminal_width() - 1 - len(inputfilestr))) + Style.RESET_ALL) # Clear arrays for field components G.initialise_field_arrays() # Clear arrays for fields in PML for pml in G.pmls: pml.initialise_field_arrays() # Adjust position of simple sources and receivers if required if G.srcsteps[0] != 0 or G.srcsteps[1] != 0 or G.srcsteps[2] != 0: for source in itertools.chain(G.hertziandipoles, G.magneticdipoles): if modelrun == 1: if source.xcoord + G.srcsteps[0] * ( numbermodelruns - 1) < 0 or source.xcoord + G.srcsteps[0] * ( numbermodelruns - 1) > G.nx or source.ycoord + G.srcsteps[1] * ( numbermodelruns - 1) < 0 or source.ycoord + G.srcsteps[1] * ( numbermodelruns - 1 ) > G.ny or source.zcoord + G.srcsteps[2] * ( numbermodelruns - 1) < 0 or source.zcoord + G.srcsteps[2] * ( numbermodelruns - 1) > G.nz: raise GeneralError( 'Source(s) will be stepped to a position outside the domain.' ) source.xcoord = source.xcoordorigin + (modelrun - 1) * G.srcsteps[0] source.ycoord = source.ycoordorigin + (modelrun - 1) * G.srcsteps[1] source.zcoord = source.zcoordorigin + (modelrun - 1) * G.srcsteps[2] if G.rxsteps[0] != 0 or G.rxsteps[1] != 0 or G.rxsteps[2] != 0: for receiver in G.rxs: if modelrun == 1: if receiver.xcoord + G.rxsteps[0] * ( numbermodelruns - 1) < 0 or receiver.xcoord + G.rxsteps[0] * ( numbermodelruns - 1) > G.nx or receiver.ycoord + G.rxsteps[1] * ( numbermodelruns - 1) < 0 or receiver.ycoord + G.rxsteps[1] * ( numbermodelruns - 1 ) > G.ny or receiver.zcoord + G.rxsteps[2] * ( numbermodelruns - 1 ) < 0 or receiver.zcoord + G.rxsteps[2] * ( numbermodelruns - 1) > G.nz: raise GeneralError( 'Receiver(s) will be stepped to a position outside the domain.' ) receiver.xcoord = receiver.xcoordorigin + (modelrun - 1) * G.rxsteps[0] receiver.ycoord = receiver.ycoordorigin + (modelrun - 1) * G.rxsteps[1] receiver.zcoord = receiver.zcoordorigin + (modelrun - 1) * G.rxsteps[2] # Write files for any geometry views and geometry object outputs if not (G.geometryviews or G.geometryobjectswrite) and args.geometry_only: print( Fore.RED + '\nWARNING: No geometry views or geometry objects to output found.' + Style.RESET_ALL) if G.geometryviews: print() for i, geometryview in enumerate(G.geometryviews): geometryview.set_filename(modelrun, numbermodelruns, G) pbar = tqdm(total=geometryview.datawritesize, unit='byte', unit_scale=True, desc='Writing geometry view file {}/{}, {}'.format( i + 1, len(G.geometryviews), os.path.split(geometryview.filename)[1]), ncols=get_terminal_width() - 1, file=sys.stdout, disable=G.tqdmdisable) geometryview.write_vtk(modelrun, numbermodelruns, G, pbar) pbar.close() if G.geometryobjectswrite: for i, geometryobject in enumerate(G.geometryobjectswrite): pbar = tqdm(total=geometryobject.datawritesize, unit='byte', unit_scale=True, desc='Writing geometry object file {}/{}, {}'.format( i + 1, len(G.geometryobjectswrite), os.path.split(geometryobject.filename)[1]), ncols=get_terminal_width() - 1, file=sys.stdout, disable=G.tqdmdisable) geometryobject.write_hdf5(G, pbar) pbar.close() # Run simulation (if not doing geometry only) if not args.geometry_only: # Prepare any snapshot files for snapshot in G.snapshots: snapshot.prepare_vtk_imagedata(modelrun, numbermodelruns, G) # Output filename inputfileparts = os.path.splitext(inputfile) if numbermodelruns == 1: outputfile = inputfileparts[0] + '.out' else: outputfile = inputfileparts[0] + str(modelrun) + '.out' print('\nOutput file: {}\n'.format(outputfile)) #################################### # Start - Main FDTD calculations # #################################### tsolvestart = perf_counter() # Absolute time abstime = 0 for timestep in tqdm(range(G.iterations), desc='Running simulation, model ' + str(modelrun) + '/' + str(numbermodelruns), ncols=get_terminal_width() - 1, file=sys.stdout, disable=G.tqdmdisable): # Store field component values for every receiver and transmission line store_outputs(timestep, G.Ex, G.Ey, G.Ez, G.Hx, G.Hy, G.Hz, G) # Write any snapshots to file for i, snap in enumerate(G.snapshots): if snap.time == timestep + 1: snapiters = 36 * (((snap.xf - snap.xs) / snap.dx) * ((snap.yf - snap.ys) / snap.dy) * ((snap.zf - snap.zs) / snap.dz)) pbar = tqdm( total=snapiters, leave=False, unit='byte', unit_scale=True, desc=' Writing snapshot file {} of {}, {}'.format( i + 1, len(G.snapshots), os.path.split(snap.filename)[1]), ncols=get_terminal_width() - 1, file=sys.stdout, disable=G.tqdmdisable) snap.write_vtk_imagedata(G.Ex, G.Ey, G.Ez, G.Hx, G.Hy, G.Hz, G, pbar) pbar.close() # Update electric field components if Material.maxpoles == 0: # All materials are non-dispersive so do standard update update_electric(G.nx, G.ny, G.nz, G.nthreads, G.updatecoeffsE, G.ID, G.Ex, G.Ey, G.Ez, G.Hx, G.Hy, G.Hz) elif Material.maxpoles == 1: # If there are any dispersive materials do 1st part of dispersive update (it is split into two parts as it requires present and updated electric field values). update_electric_dispersive_1pole_A(G.nx, G.ny, G.nz, G.nthreads, G.updatecoeffsE, G.updatecoeffsdispersive, G.ID, G.Tx, G.Ty, G.Tz, G.Ex, G.Ey, G.Ez, G.Hx, G.Hy, G.Hz) elif Material.maxpoles > 1: update_electric_dispersive_multipole_A( G.nx, G.ny, G.nz, G.nthreads, Material.maxpoles, G.updatecoeffsE, G.updatecoeffsdispersive, G.ID, G.Tx, G.Ty, G.Tz, G.Ex, G.Ey, G.Ez, G.Hx, G.Hy, G.Hz) # Update electric field components with the PML correction for pml in G.pmls: pml.update_electric(G) # Update electric field components from sources (update any Hertzian dipole sources last) for source in G.voltagesources + G.transmissionlines + G.hertziandipoles: source.update_electric(abstime, G.updatecoeffsE, G.ID, G.Ex, G.Ey, G.Ez, G) # If there are any dispersive materials do 2nd part of dispersive update (it is split into two parts as it requires present and updated electric field values). Therefore it can only be completely updated after the electric field has been updated by the PML and source updates. if Material.maxpoles == 1: update_electric_dispersive_1pole_B(G.nx, G.ny, G.nz, G.nthreads, G.updatecoeffsdispersive, G.ID, G.Tx, G.Ty, G.Tz, G.Ex, G.Ey, G.Ez) elif Material.maxpoles > 1: update_electric_dispersive_multipole_B( G.nx, G.ny, G.nz, G.nthreads, Material.maxpoles, G.updatecoeffsdispersive, G.ID, G.Tx, G.Ty, G.Tz, G.Ex, G.Ey, G.Ez) # Increment absolute time value abstime += 0.5 * G.dt # Update magnetic field components update_magnetic(G.nx, G.ny, G.nz, G.nthreads, G.updatecoeffsH, G.ID, G.Ex, G.Ey, G.Ez, G.Hx, G.Hy, G.Hz) # Update magnetic field components with the PML correction for pml in G.pmls: pml.update_magnetic(G) # Update magnetic field components from sources for source in G.transmissionlines + G.magneticdipoles: source.update_magnetic(abstime, G.updatecoeffsH, G.ID, G.Hx, G.Hy, G.Hz, G) # Increment absolute time value abstime += 0.5 * G.dt tsolve = int(perf_counter() - tsolvestart) # Write an output file in HDF5 format write_hdf5_outputfile(outputfile, G.Ex, G.Ey, G.Ez, G.Hx, G.Hy, G.Hz, G) ################################## # End - Main FDTD calculations # ################################## if G.messages: print('Memory (RAM) used: ~{}'.format(human_size(p.memory_info().rss))) # If geometry information to be reused between model runs then FDTDGrid class instance must be global so that it persists if not args.geometry_fixed: del G # Return time to complete solving if in benchmarking mode if args.benchmark: return tsolve
async def result(self, ctx): """Show your points from the most recent race.""" league = self._find_league(ctx) if league: with open(f"{league}-details.json") as infile: details = json.load(infile) player = self._find_player(ctx) if player: totals = {"points": 0, "price": 0, "picked": 0} headers = [ "Name", "Turbo", "Mega", "Points", "Price", "Picked %" ] data = [headers] player_details = details[str(player)] for entry in player_details["drivers"]: data.append([ entry["name"], "Yes" if entry["short_name"] == player_details["turbo"] else "No", "Yes" if entry["short_name"] == player_details["mega"] else "No", format_float(entry["score"]), format_float(entry["price"]), format_float(entry["picked"]) ]) totals["points"] += entry["score"] totals["price"] += entry["price"] totals["picked"] += entry["picked"] data.append([]) team = player_details["team"] data.append([ team["name"], "", "", format_float(team["score"]), format_float(team["price"]), format_float(team["picked"]) ]) totals["points"] += team["score"] totals["price"] += team["price"] totals["picked"] += team["picked"] totals["picked"] = round(totals["picked"] / 6, 1) data.append([]) data.append([ "Total/Average", "", "", format_float(round(totals["points"], 1)), format_float(round(totals["price"], 1)), format_float(round(totals["picked"], 1)) ]) table_instance = AsciiTable(data) table_instance.inner_column_border = False table_instance.outer_border = False table_instance.justify_columns[1] = "center" table_instance.justify_columns[2] = "right" table_instance.justify_columns[3] = "right" table_instance.justify_columns[4] = "right" msg = "```{}```".format(table_instance.table) else: msg = f"Player not found." else: msg = f"League {league} not found." await ctx.send(msg)
def main(): default_in_path = "/usr/include/linux" mode_config = { "capability": ["capability.h", "cap_data.json", "#define (CAP_[A-Z_]+)\s+(\d+)"], "bitflags": ["if.h", "bitflag_data.json", "IFF_([A-Z_]+)\s+=\s1<<(\d+)"], "nw_types": ["if_arp.h", "type_data.json", "#define ARPHRD_([\w]+)\s+(\d+)"] } in_lam = lambda a: "/".join((default_in_path, a)) out_lam = lambda a: os.path.normpath( os.path.join(os.path.dirname(__file__), os.path.pardir, "etc", a)) def addDefaults(): res = [['mode', 'default input', 'default output']] for mode in mode_config: desc = [] val = mode_config[mode] desc.append(mode) desc.append(in_lam(val[0])) desc.append(out_lam(val[1])) res.append(desc) return res description = "{} {}\n{}".format( "Update the available names and", "corresponding bit values from C headers for a", "specified type.") epilog = "Currently available modes are:" table = AsciiTable(addDefaults()) # Do not use any borders at all table.outer_border = False table.inner_column_border = False table.inner_heading_row_border = False epilog = "\n".join((epilog, table.table)) # RawDescriptionHelpFormatter causes new lines and blank spaces in # description to be printed as well. parser = argparse.ArgumentParser( prog=sys.argv[0], description=description, epilog=epilog, formatter_class=argparse.RawDescriptionHelpFormatter) description = "select the type to update." parser.add_argument('mode', metavar="mode", help=description, choices=mode_config.keys(), type=str) description = "The C header used as input file." parser.add_argument("-i", "--input", type=str, help=description) description = "The output file in JSON format." parser.add_argument("-o", "--output", type=str, help=description) args = parser.parse_args() config = mode_config[args.mode] #set default parameters arg_in = in_lam(config[0]) if args.input: arg_in = args.input arg_out = out_lam(config[1]) if args.output: arg_out = args.output try: with open(arg_in, "r") as fi: file_data = fi.read() except EnvironmentError as e: exit("Cannot open file {}: {}".format(arg_in, str(e))) assert file_data # read all system-available capabilities/iface-types/iface-flags from # the input file into the dictionary regex = re.compile(config[2], re.MULTILINE) data = OrderedDict() for m in re.finditer(regex, file_data): val_int = int(m.group(2)) val_name = str(m.group(1)) data[val_name] = val_int if not data: exit("No {} information found in {}".format(args.mode, arg_in)) #write dictionary to output file in JSON encoded format try: with open(arg_out, "w") as fi: json.dump(data, fi, indent=4, sort_keys=True) print("Wrote {} data to {}\n".format(args.mode, arg_out)) except EnvironmentError as e: exit("Cannot write file {}: {}".format(arg_out, str(e)))