From de48ad722f64c10dcef5c0f66ec9c82335f3cb90 Mon Sep 17 00:00:00 2001 From: ym1906 Date: Thu, 9 May 2024 11:25:06 +0100 Subject: [PATCH 1/5] Removed ndscan_funcs as it is no longer used in the codebase --- process/io/ndscan_funcs.py | 127 ------------------------------------- 1 file changed, 127 deletions(-) delete mode 100644 process/io/ndscan_funcs.py diff --git a/process/io/ndscan_funcs.py b/process/io/ndscan_funcs.py deleted file mode 100644 index d567ef4a94..0000000000 --- a/process/io/ndscan_funcs.py +++ /dev/null @@ -1,127 +0,0 @@ -""" -A selection of functions for using the PROCESS code - -Author: Steven Torrisi (storrisi@u.rochester.edu) - -Date: August 2014 - initial released version - -Notes: -22/08/2014 HL moved functions from process_config.py to this file -24/11/2021 Global dictionary variables moved within the functions - to avoid cyclic dependencies. This is because the dicts - generation script imports, and inspects, process. - -Compatible with PROCESS version 319 -""" - -from process.io.in_dat import InDat -import collections as col -import subprocess -from process.io.python_fortran_dicts import get_dicts - - -def get_var_name_or_number(variable): - """ - Returns the iteration variable ixc number from a variable name, - or the iteration variable ixc number from a variable name. - This is useful to have as some PROCESS python library functionality - uses the variable number instead of the name. - - Arguments: - variable-->Can be an integer or a string. - - Returns: - if variable is string and string a key in DICT_IXC_SIMPLE: - Returns the integer ixc representation - if variable is integer: - Returns the string name of the variable. - if the integer or string does not represent a variable: - Returns FALSE - Dependencies: - process_dicts: DICT_IXC_SIMPLE - """ - # Load dicts from dicts JSON file - dicts = get_dicts() - - if isinstance(variable, str): - for key in dicts["DICT_IXC_SIMPLE"]: - if dicts["DICT_IXC_SIMPLE"][key] == variable.lower(): - return int(key) - - return False - elif isinstance(variable, int): - try: - return dicts["DICT_IXC_SIMPLE"][str(variable)] - except KeyError: - return False - - return None - - -def get_iter_vars(inputfile="IN.DAT", makeboundarydict=False): - - """ - Opens IN.DAT file at inputfile, and returns the value of ixc, - the array of iteration variables. - Used by the iteration variable smoothing option. - Gets the numbers of the iteration variables and sets them in - self.iterationvariables. - - Arguments: - inputfile--------> What IN.DAT file to read - makeboundarydict-> Returns a special dictionary for the boundary - diagnostics option. - - Returns: - An ordered dictionary; - if makeboundarydict is false: - The keys will be the ixc numbers, and the values will be - string names of the variables - if makeboudnarydict is true: - The keys will be the variable names, the values will be - a list with two numbers that start at 0. - - Dependencies: - in_dat.py - collections module - """ - - # Stored as a dictionary, where the KEY is the number and the - # VALUE is the name. - indat = InDat(inputfile) - output = col.OrderedDict({}) - if not makeboundarydict: - for iternumber in indat.data["ixc"].get_value: - output[iternumber] = get_var_name_or_number(iternumber) - else: - for iternumber in indat.data["ixc"].get_value: - output[get_var_name_or_number(iternumber)] = [0, 0] - return output - - -def backup_in_file(setting, destination="IN.DATBACKUP"): - - """ - Writes and reads the IN.DAT file before and after the scan - respectively to a backup. - - If setting is "w", will back up the input file by attempting - to copy IN.DAT to destination. - If setting is "r", will attempt to copy destination to "IN.DAT". - - Arguments: - setting-----> "r" or "w": Determines what direction the backup - is going to go. - destination-> What to call the backup. - - Modifies: - IN.DAT in the current directory. - - Dependencies: - subprocess - - """ - if setting == "w": - subprocess.call(["cp", "IN.DAT", destination]) - if setting == "r": - subprocess.call(["cp", destination, "IN.DAT"]) From 195ff17c16c56f31cea7e6397fe6221a8014d407 Mon Sep 17 00:00:00 2001 From: ym1906 Date: Thu, 9 May 2024 13:21:06 +0100 Subject: [PATCH 2/5] Remove ndscan content from process_config --- process/io/process_config.py | 500 ----------------------------------- 1 file changed, 500 deletions(-) diff --git a/process/io/process_config.py b/process/io/process_config.py index bf5b70c0af..d36eaea538 100755 --- a/process/io/process_config.py +++ b/process/io/process_config.py @@ -33,11 +33,6 @@ set_variable_in_indat, check_in_dat, ) -from process.io.ndscan_funcs import ( - get_var_name_or_number, - get_iter_vars, - backup_in_file, -) from process.io.in_dat import InDat from process.io.mfile import MFile from process.io.configuration import Config @@ -48,7 +43,6 @@ class ProcessConfig(object): - """ Configuration parameters for PROCESS runs @@ -328,7 +322,6 @@ def run_process(self, input_path, solver="vmcon"): class TestProcessConfig(ProcessConfig): - """ Configuration parameter of the test_process.py program @@ -413,7 +406,6 @@ def modify_in_dat(self): class RunProcessConfig(ProcessConfig): - """ Configuration parameters of the run_process.py program @@ -682,7 +674,6 @@ def modify_icc(self): class UncertaintiesConfig(ProcessConfig, Config): - """ Configuration parameters for evaluate_uncertainties.py program """ @@ -1208,494 +1199,3 @@ def write_error_summary(self, sample_index): err_summary.write(output) err_summary.close() - - -################################################################################ -# class NdScanConfig(RunProcessConfig) -################################################################################ - - -class NdScanConfig(Config, RunProcessConfig): - - """ - # Author: Steven Torrisi (storrisi@u.rochester.edu) - # University of Rochester, IPP Greifswald - # July 2014 - """ - - scanaxes = { - "ndim": 0, - "varnames": [], - "lbs": [], - "ubs": [], - "steps": [], - # A list of lists enumerating the values at which the scan - # variables will be evaluated. - "coords": [], - } - # A n-dimensional 'coordinate vector' which uses - # step's numbers from 0 to the [# of steps-1] of coordinates - # to keep track of where the scan is. - currentstep = [] - totalfails = 0 - mfiledir = "MFILES" - failcoords = ndarray((1), int) - errorlist = col.OrderedDict({}) - - # A dictionary of lists; each sublist has 2 elements, - # one for number at lower and one for number at upper - iterationvariablesatbounds = col.OrderedDict({}) - optionals = { - "remove_scanvars_from_ixc": True, - # Removes all scanning variables from the iteration variables - # of the IN.DAT file. - "smooth_itervars": False, - # Activates data smoothing, which increases run time but reduces errors - } - - def __init__(self, configfilename="ndscan.json"): - """ - Contains the code which parses ndscan.conf files, manipulates IN.DAT - files, sorts and stores MFILES, - and runs PROCESS during the scan. - - Init makes all of the self variables, then calls - establish_default_optionals, parse_config_file, generate_coords, and - get_iter_vars. - - Arguments: - configfilename--> The name of the configuration file to read. - - """ - - super().__init__(configfilename) - self.filename = configfilename - - # ------------------------- - # set general config params - self.wdir = os.path.abspath( - self.get("config", "working_directory", default=self.wdir) - ) - self.or_in_dat = os.path.abspath( - self.get("config", "IN.DAT_path", default=self.or_in_dat) - ) - self.process = self.get("config", "process_bin", default=self.process) - self.niter = self.get("config", "no_iter", default=self.niter) - self.u_seed = self.get("config", "pseudorandom_seed", default=self.u_seed) - self.factor = self.get("config", "factor", default=self.factor) - self.comment = self.get("config", "runtitle", default=self.comment) - - # -------------------------------- - # set ndscan specific config params - for option, value in self.get("optionals", default=self.optionals).items(): - self.optionals[option] = value - - axes = self.get("axes", default=[]) - self.scanaxes["ndim"] = len(axes) - - for axis in axes: - self.scanaxes["varnames"].append(axis["varname"]) - - if isinstance(axis["steps"], list): - self.scanaxes["steps"].append(axis["steps"]) - else: - self.scanaxes["lbs"].append(axis["lowerbound"]) - self.scanaxes["ubs"].append(axis["upperbound"]) - self.scanaxes["steps"].append(axis["steps"]) - - self.setup() - - currentdirectory = os.getcwd() - try: - os.stat(currentdirectory + "/" + self.mfiledir) - except FileNotFoundError: - os.mkdir(currentdirectory + "/" + self.mfiledir) - - self.generate_coords() - - if self.optionals["smooth_itervars"]: - self.wasjustsmoothed = False - - def echo(self): - """echos the values of the current class""" - - print("") - super().echo() - - print("Remove Scanvars from IXC ", self.optionals["remove_scanvars_from_ixc"]) - print("Smooth Itervars ", self.optionals["smooth_itervars"]) - if self.scanaxes["varnames"] != []: - print("axes:") - for i in range(self.scanaxes["ndim"]): - print(" ", self.scanaxes["varnames"][i]) - print(" steps", self.scanaxes["steps"][i]) - if not isinstance(self.scanaxes["steps"][i], list): - print(" lbs ", self.scanaxes["lbs"][i]) - print(" ubs ", self.scanaxes["ubs"][i]) - print(" -------") - print("") - sleep(1) - - def generate_coords(self): - """ - From the bounds and number of evaluations specified, generates the - N-dimensional coordinates to scan. - - This generates the coodinates for the variables so that - the process scanner later can iterate through them. The coordinates are - linearly interpolated by the upper bound, lower bound, and number of - steps specified. - - Additionally, containers for output coordinates and failure coordinates - are created The failure coordinates - store a value from ifail, which can later be interpreted to figure out - what went wrong with PROCESS in a given run. - - """ - - totalsteps = [] - # If Manual Steps are specified, will construct the coordinates - # from what is given. - # otherwise, - # Constructs a linear interpolation of the x and y variables - # by calculating the difference of the upper and lower bound, - # divided by the step length, - # then producing a list of those steps in the range. - for i in range(self.scanaxes["ndim"]): - self.currentstep.append(0) - - if isinstance(self.scanaxes["steps"][i], list): - self.scanaxes["coords"] = self.scanaxes["steps"][i] - totalsteps.append(len(self.scanaxes["coords"][i])) - - else: - lbnd = self.scanaxes["lbs"][i] - ubnd = self.scanaxes["ubs"][i] - steps = int(self.scanaxes["steps"][i]) - self.scanaxes["coords"].append( - [lbnd + j * (ubnd - lbnd) / (steps - 1) for j in range(steps)] - ) - totalsteps.append(steps) - - # The program will later scan the resultant MFILEs in the PROCESS - # code to extract the failure states of the runs and - # a z variable of our choosing which can be plotted against 2 x and - # y dimensions. - # The failure coordinates and output coordinates store these - # values respectively. - - self.failcoords = ndarray(tuple(totalsteps), int) - - def adjust_variable(self, varname, newvalue): - """ - Given a variable of varname and newvalue, modifies an already - existing variable - in the ProcessRunConfig's internal IN.dat memory. - - Arguments: - varname--->Name of the variable to modify. string - newvalue-->Value to assign to varname. - - Dependencies: - RunProcessConfig.modify_vars() - - Modifies: - self.dictvar (temporarily, from parent class) - """ - - varname = str(varname) - varname = varname.lower() - - self.dictvar[varname] = newvalue - - RunProcessConfig.modify_vars(self) - self.dictvar = {} - - def catalog_output(self, currentstep): - """ - Copies the MFILE.DAT in the current directory to subdirectory MFILES - with a name determined by currentstep. - - Because PROCESS outputs an MFILE for each run, and many runs will be - made in a given Nd scan, this stores away the files produced to be - analyzed later. - - Files are tagged with the steps of the variables from the run. - For example, currentstep = [0,12,5,1] produces M.0.12.5.1.DAT. - - Arguments: - currentstep--> The list describes the current step the scanner - is on. - """ - - stepstring = "" - - for dims in range(self.scanaxes["ndim"]): - stepstring += str(currentstep[dims]) + "." - - destination = self.mfiledir + "/M." + stepstring + "DAT" - subprocess.call(["cp", "MFILE.DAT", destination]) - - def before_run_do(self): - """ - A helper function: executes commands that need to be done before a run, - including incrementing a counter or modifying IN.DAT. - - Also a place for developers to add functionality. - - Modifies: - self.counter - - Dependencies: - self.smooth_iter_variables (sometimes) - - """ - - self.counter += 1 - - # We can't smooth the variables if we are on the first run - # so it waits until counter is greater than 1. - if self.counter > 1 and self.optionals["smooth_itervars"] is True: - lastrun = MFile() - # Establishing a new self variable outside of __init__; is that ok? - backup_in_file("w", "IN.DATSMOOTHERBACKUP") - if self.smooth_iter_variables(lastrun): - self.wasjustsmoothed = True - else: - self.wasjustsmoothed = False - subprocess.call(["rm", "IN.DATSMOOTHERBACKUP"]) - - def after_run_do(self): - """ - Executes commands that need to be done just after a run, such as - recording the ifail value. - """ - - check_input_error() - - currentrun = MFile() - if process_stopped(): - currentfail = 0 - else: - # Check the Mfile that was just produced to see if there was a failure - # or not- - # Re reun with new iteration variable values if this was specified. - currentfail = int(currentrun.data["ifail"].get_scan(-1)) - - if self.niter != 0 and currentfail != 1: - for x in range(self.niter): - print( - "Ifail = ", int(currentfail), " Rerunning ", x + 1, "of", self.niter - ) - - if currentfail != 1: - # Does not work, if bounds in input.f90 are tighter - # than boundu/boundl - neqns, itervars = get_neqns_itervars() - lbs, ubs = get_variable_range(itervars, self.factor) - vary_iteration_variables(itervars, lbs, ubs) - self.run_process() - check_input_error() - - currentrun = MFile() - if process_stopped(): - currentfail = 0 - else: - currentfail = int(currentrun.data["ifail"].get_scan(-1)) - else: - break - - if self.optionals["smooth_itervars"] and self.wasjustsmoothed: - backup_in_file("r", "IN.DATSMOOTHERBACKUP") - subprocess.call(["rm", "IN.DATSMOOTHERBACKUP"]) - self.wasjustsmoothed = False - - # Records the ifail value of the last run - self.failcoords[tuple(self.currentstep)] = int(currentfail) - - # Checks the error status - if currentrun.data["error_status"].get_scan(-1) > 0: - self.errorlist[tuple(self.currentstep)] = ( - currentrun.data["error_status"].get_scan(-1), - currentrun.data["error_id"].get_scan(-1), - ) - - if self.failcoords[tuple(self.currentstep)] != 1: - self.totalfails += 1 - print("Run failed! With ifail = ", self.failcoords[tuple(self.currentstep)]) - - else: - print("Run successful.") - - # Stores the MFILE away with the convention used of - # M.currentstep[0].currentstep[1]......currentstep[N].DAT - # So currentstep=[1,2,4,0] => M.1.2.4.0.DAT - self.catalog_output(self.currentstep) - - def dimension_scan(self, currentdim): - """ - A recursive function which conducts the N dimensional scan when called. - currentdim keeps track of what dimension level the scan is on. - - When currentdim=0, the scan ticks along the first variable. - - Works through the coordinates determined by the step #, upper bound, - and lower bound - for a given dimension. - - Should only be called once from start_scan with the number of - dimensions being scanned-1. - - Arugments: - currentdim---> Integer which keeps track of 'how deep' the scanner - is while iterating over the axes. - - - Dependencies: - self.adjust_variable (calls) - self.dimension_scan (calls) - self.before_run_do (calls) - self.after_run_do (calls) - """ - - for coord in self.scanaxes["coords"][currentdim]: - # Updates the current step according to steps along the coordinates. - self.currentstep[currentdim] = self.scanaxes["coords"][currentdim].index( - coord - ) - - # Adjusts the scanned variable to the new coordinate. - self.adjust_variable(self.scanaxes["varnames"][currentdim], coord) - - if currentdim > 0: - # Activates the recursion - self.dimension_scan(currentdim - 1) - else: - # Before and after are different methods for ease of access, - # modification, and cleaner code. - - self.before_run_do() - - print("Current step coordinate:", self.currentstep) - self.run_process() - - self.after_run_do() - - def smooth_iter_variables(self, mfile): - """ - Sets the values of the iteration variables in IN.DAT equal to the - values from the last run, - if it was not a failure. Work in progress. - - Returns: - True----> If iteration variables were attempted to be modfied - because it was an appropriate scan point - False---> If the conditions were not right for modifcation of - iteration variables (due to a previous failure, - or due to it being at a new starting point. - - Arguments: - mfile---> An MFile object from mfile.py - - Dependencies: - self.currentstep - self.modify_vars (from super class) - self. adjust_variable - """ - - # If the first dimension has a step value of 0, - # we can infer that a most likely nontrivial 'jump' just happened - # across the parameter space which - # can seriously break the smoothness, and maybe the solver. - # Re-smoothing from here might cause an error. So, - # we don't smooth it from the previous run. - - if self.currentstep[0] == 0: - return False - - elif process_stopped(): - return False - - # As long as we aren't in that smoothness breaking case, - # checks to see if the previous run was succesful. - # If it was, then re-adjust the current iter variables accordingly. - - elif mfile.data["ifail"].get_scan(-1) == 1: - nvar = int(mfile.data["nvar"].get_scan(-1)) - for i in range(1, nvar + 1): - itervarstring = "itvar%03i" % i - - value = mfile.data[itervarstring].get_scan(-1) - itervarname = mfile.data[itervarstring].var_description - if value != 0: - self.adjust_variable(itervarname, value) - return True - return False - - def after_scan(self): - """#FINISH THIS DOCSTRING - A helper method which runs at the conclusion of the ND scan and - carries out actions like printing output. - - - """ - - if len(self.errorlist) > 0: - if len(self.errorlist.keys()) > 0: - print( - len(self.errorlist), - "runs had some sort of error associated with them.", - ) - - print("Now printing failure coordinates below:") - print(self.failcoords) - print( - "Scan complete.", - self.totalfails, - " of ", - self.totalruns, - " runs ended in failure.", - ) - - return (self.totalfails, self.totalruns) - - def start_scan(self): - """ - Commences the N-dimensional scan, and calls all of the necessary - methods. - dimension_scan is the function which carries out 'motion' along - the axes, which is a recursive function which - calls itself however many times it needs to. - """ - if self.optionals["remove_scanvars_from_ixc"]: - iterationvariables = get_iter_vars() - - for varname in self.scanaxes["varnames"]: - if varname in iterationvariables.values(): - print( - "Warning! Removing scan variable", - varname, - " from the iteration variable list.", - ) - self.del_ixc.append(get_var_name_or_number(varname)) - print( - "Please either reconsider your iteration variables\ - in the IN.DAT file in the future, or if this was intended, set the\ - RemoveIterVars optional to False in your config file." - ) - self.modify_ixc() - - if self.optionals["smooth_itervars"]: - get_iter_vars() - - self.totalruns = 1 - for i in range(self.scanaxes["ndim"]): - self.totalruns *= self.scanaxes["steps"][i] - - self.counter = 0 - - backup_in_file("w") - self.dimension_scan(self.scanaxes["ndim"] - 1) - backup_in_file("r") - - self.after_scan() From 620560060a1d764959ac1e44d68bd70859141c3e Mon Sep 17 00:00:00 2001 From: ym1906 Date: Thu, 9 May 2024 14:01:09 +0100 Subject: [PATCH 3/5] Removed last reference to ndscan.py --- process/io/process_config.py | 1 - 1 file changed, 1 deletion(-) diff --git a/process/io/process_config.py b/process/io/process_config.py index d36eaea538..bce6591a5b 100755 --- a/process/io/process_config.py +++ b/process/io/process_config.py @@ -4,7 +4,6 @@ Interfaces for Configuration values for programs - run_process.py - test_process.py -- ndscan.py - evaluate_uncertainties.py Compatible with PROCESS version 382 From 1cb6b6eff6d26aac5aad926868ef67f65db1bc95 Mon Sep 17 00:00:00 2001 From: ym1906 Date: Thu, 9 May 2024 14:11:21 +0100 Subject: [PATCH 4/5] black fixes --- examples/csv_output.ipynb | 10 +++++----- examples/examples.ipynb | 22 ++++++++++------------ examples/scan.ipynb | 2 +- 3 files changed, 16 insertions(+), 18 deletions(-) diff --git a/examples/csv_output.ipynb b/examples/csv_output.ipynb index f3cecf75d0..e9a5a13a43 100644 --- a/examples/csv_output.ipynb +++ b/examples/csv_output.ipynb @@ -53,17 +53,17 @@ "proj_dir = Path.cwd().parent\n", "\n", "# Replace this path/to/MFILE.DAT with your target file:\n", - "mfilename = proj_dir / 'examples/csv_output_large_tokamak_MFILE.DAT'\n", + "mfilename = proj_dir / \"examples/csv_output_large_tokamak_MFILE.DAT\"\n", "\n", - "# Either replace this with your own path/to/file.json target, \n", + "# Either replace this with your own path/to/file.json target,\n", "# or add your required variables into the identified file:\n", - "varfilename = proj_dir / 'process/io/mfile_to_csv_vars.json'\n", - "# This routine attempts to find every variable in the given list and \n", + "varfilename = proj_dir / \"process/io/mfile_to_csv_vars.json\"\n", + "# This routine attempts to find every variable in the given list and\n", "# writes the variable name, description and value to the output csv.\n", "# Any listed variable that isn't in that MFILE will be skipped.\n", "\n", "# call to function:\n", - "mfile_to_csv.main(args=[\"-f\", str(mfilename), \"-v\", str(varfilename)])\n" + "mfile_to_csv.main(args=[\"-f\", str(mfilename), \"-v\", str(varfilename)])" ] }, { diff --git a/examples/examples.ipynb b/examples/examples.ipynb index 8e01b7be95..77884d347b 100644 --- a/examples/examples.ipynb +++ b/examples/examples.ipynb @@ -60,7 +60,7 @@ " copy(input_abs_path, temp_dir_path)\n", " temp_input_path = temp_dir_path / input_abs_path.name\n", "\n", - " return temp_dir, temp_input_path\n" + " return temp_dir, temp_input_path" ] }, { @@ -190,7 +190,7 @@ "pages = convert_from_path(summary_pdf)\n", "for page_no, page_image in enumerate(pages):\n", " png_path = PROJ_DIR / f\"examples/plot_proc_{page_no + 1}.png\"\n", - " page_image.save(png_path, \"PNG\")\n" + " page_image.save(png_path, \"PNG\")" ] }, { @@ -232,9 +232,9 @@ "from PIL import Image\n", "from IPython.display import display\n", "\n", - "img1 = Image.open('plot_proc_1.png')\n", + "img1 = Image.open(\"plot_proc_1.png\")\n", "display(img1)\n", - "img2 = Image.open('plot_proc_2.png')\n", + "img2 = Image.open(\"plot_proc_2.png\")\n", "display(img2)" ] }, @@ -245,7 +245,7 @@ "outputs": [], "source": [ "# Delete temp dir\n", - "temp_dir.cleanup()\n" + "temp_dir.cleanup()" ] }, { @@ -344,10 +344,8 @@ ], "source": [ "# Print some values on the CostModel instance\n", - "print(\n", - " f\"Heat transport system: {single_run.models.costs.c226:.3e} M$\"\n", - ")\n", - "print(f\"Electrical plant equipment: {single_run.models.costs.c24:.3e} M$\")\n" + "print(f\"Heat transport system: {single_run.models.costs.c226:.3e} M$\")\n", + "print(f\"Electrical plant equipment: {single_run.models.costs.c24:.3e} M$\")" ] }, { @@ -357,7 +355,7 @@ "outputs": [], "source": [ "# Clean up\n", - "temp_dir.cleanup()\n" + "temp_dir.cleanup()" ] }, { @@ -466,7 +464,7 @@ "vary_run = VaryRun(str(temp_input_path))\n", "os.chdir(cwd)\n", "\n", - "temp_dir.cleanup()\n" + "temp_dir.cleanup()" ] }, { @@ -528,7 +526,7 @@ " ]\n", ")\n", "\n", - "temp_dir.cleanup()\n" + "temp_dir.cleanup()" ] } ], diff --git a/examples/scan.ipynb b/examples/scan.ipynb index b632b4ca36..3a7439673f 100644 --- a/examples/scan.ipynb +++ b/examples/scan.ipynb @@ -296,7 +296,7 @@ " \"--outputdir\",\n", " str(output_dir),\n", " ]\n", - ")\n" + ")" ] } ], From 11bc9b6775114c9f4f60216069cc888783267b65 Mon Sep 17 00:00:00 2001 From: ym1906 Date: Thu, 9 May 2024 14:18:04 +0100 Subject: [PATCH 5/5] Remove unused imports to fix flake8 flags --- process/io/process_config.py | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/process/io/process_config.py b/process/io/process_config.py index bce6591a5b..cdf7407cd0 100755 --- a/process/io/process_config.py +++ b/process/io/process_config.py @@ -18,16 +18,10 @@ import sys from sys import stderr from time import sleep -import collections as col from numpy.random import seed, uniform, normal -from numpy import argsort, ndarray, argwhere, logical_or +from numpy import argsort, argwhere, logical_or from pathlib import Path from process.io.process_funcs import ( - get_neqns_itervars, - get_variable_range, - vary_iteration_variables, - check_input_error, - process_stopped, get_from_indat_or_default, set_variable_in_indat, check_in_dat,