def estimateTimeSteps(executioner_node): """ Gets the approximate number of steps from the Exectioner section of the input file Inputs: executioner_node[BlockInfo]: /Executioner """ cur_steps = 0 try: if executioner_node: num_steps = executioner_node.getParamInfo("num_steps") if num_steps and num_steps.value: cur_steps = int(num_steps.value) end_time = executioner_node.getParamInfo("end_time") dt = executioner_node.getParamInfo("dt") if end_time and end_time.value and dt and float(dt.value) > 0: steps = float(end_time.value) / float(dt.value) if cur_steps == 0 or steps < cur_steps: cur_steps = steps adaptivity = executioner_node.children.get("Adaptivity") if adaptivity and adaptivity.included: steps = adaptivity.getParamInfo("steps") if steps and steps.value: cur_steps += int(steps.value) return cur_steps + 2 + 1 # The +2 is for setup steps the +1 is so there is always a bit left... except Exception as e: mooseutils.mooseWarning("Problem calculating time steps: %s" % e) return 0
def estimateTimeSteps(executioner_node): """ Gets the approximate number of steps from the Exectioner section of the input file Inputs: executioner_node[BlockInfo]: /Executioner """ cur_steps = 0 try: if executioner_node: num_steps = executioner_node.getParamInfo("num_steps") if num_steps and num_steps.value: cur_steps = int(num_steps.value) end_time = executioner_node.getParamInfo("end_time") dt = executioner_node.getParamInfo("dt") if end_time and end_time.value and dt and float(dt.value) > 0: steps = float(end_time.value) / float(dt.value) if cur_steps == 0 or steps < cur_steps: cur_steps = steps adaptivity = executioner_node.children.get("Adaptivity") if adaptivity and adaptivity.included: steps = adaptivity.getParamInfo("steps") if steps and steps.value: cur_steps += int(steps.value) return cur_steps + 2 + 1 # The +2 is for setup steps the +1 is so there is always a bit left... except Exception as e: mooseutils.mooseWarning("Problem calculating time steps: %s" % e) return 0
def meshChanged(self, tree, reset=False): """ The parameters of the mesh has changed. We need to update the view of the mesh by generating a new mesh file. """ if reset: self._reset() self.meshEnabled.emit(False) if not tree.app_info.valid(): return # if we aren't writing out the mesh node then don't show it mesh_node = tree.getBlockInfo("/Mesh") if not mesh_node or not mesh_node.included: self.onSetFilename(None) self.onWindowRequiresUpdate() self._setLoadingMessage("Mesh block not included") return exe_path = tree.app_info.path self._removeFileNoError(self.current_temp_mesh_file) input_filename = "" if tree.input_filename: input_filename = os.path.basename( os.path.splitext(tree.input_filename)[0]) self.current_temp_mesh_file = os.path.abspath( self.temp_mesh_file.format(input_filename)) input_file = os.path.abspath(self.temp_input_file) self._removeFileNoError(self.current_temp_mesh_file) self._removeFileNoError(input_file) self.needInputFile.emit(input_file) if not os.path.exists(input_file): self.meshEnabled.emit(False) self.onSetFilename(None) self.onWindowRequiresUpdate() self._setLoadingMessage("Error reading temporary input file") return try: args = [ "-i", input_file, "--mesh-only", self.current_temp_mesh_file ] if self._use_test_objects: args.append("--allow-test-objects") ExeLauncher.runExe(exe_path, args, print_errors=False) self.meshEnabled.emit(True) self.onSetFilename(self.current_temp_mesh_file) self.onWindowRequiresUpdate() except Exception as e: self.meshEnabled.emit(False) self.onSetFilename(None) self.onWindowRequiresUpdate() mooseutils.mooseWarning("Error producing mesh: %s" % e) self._setLoadingMessage("Error producing mesh") self._removeFileNoError(self.current_temp_mesh_file) self._removeFileNoError( input_file ) # we need the mesh file since it is in use but not the input file
def _addInputFileNode(self, input_node, included): """ This adds a node from the input file. Input: input_node[hit.Node]: The node from the input file. """ path = "/" + input_node.fullpath() entry = self.path_map.get(path) if not entry: parent_path = os.path.dirname(path) name = os.path.basename(path) entry = self.addUserBlock(parent_path, name) if not entry: mooseutils.mooseWarning("Could not create %s" % path) self.input_has_errors = True return entry.comments = self._getComments(input_node) entry.included = included entry.hard = True in_type = input_node.find("type") param_info = entry.parameters.get("type") if in_type and in_type.raw() and param_info: entry.setBlockType(in_type.raw()) param_info.value = in_type.raw() if "type" not in entry.parameters_list: entry.parameters_list.insert(0, "type") active = self._readParameters(input_node, path) for child_node in input_node.children(node_type=hit.NodeType.Section): self._addInputFileNode(child_node, child_node.path() in active) if child_node.path() not in entry.children_write_first: entry.children_write_first.append(child_node.path())
def _addInputFileNode(self, input_node, included): """ This adds a node from the input file. Input: input_node[hit.Node]: The node from the input file. """ path = "/" + input_node.fullpath() entry = self.path_map.get(path) if not entry: parent_path = os.path.dirname(path) name = os.path.basename(path) entry = self.addUserBlock(parent_path, name) if not entry: mooseutils.mooseWarning("Could not create %s" % path) self.input_has_errors = True return entry.comments = self._getComments(input_node) entry.included = included entry.hard = True in_type = input_node.find("type") param_info = entry.parameters.get("type") if in_type and in_type.raw() and param_info: entry.setBlockType(in_type.raw()) param_info.value = in_type.raw() if "type" not in entry.parameters_list: entry.parameters_list.insert(0, "type") active = self._readParameters(input_node, path) for child_node in input_node.children(node_type=hit.NodeType.Section): self._addInputFileNode(child_node, child_node.path() in active) if child_node.path() not in entry.children_write_first: entry.children_write_first.append(child_node.path())
def meshChanged(self, tree, reset=False): """ The parameters of the mesh has changed. We need to update the view of the mesh by generating a new mesh file. """ if reset: self._reset() self.meshEnabled.emit(False) if not tree.app_info.valid(): return # if we aren't writing out the mesh node then don't show it mesh_node = tree.getBlockInfo("/Mesh") if not mesh_node or not mesh_node.included: self.onSetFilename(None) self.onWindowRequiresUpdate() self._setLoadingMessage("Mesh block not included") return exe_path = tree.app_info.path self._removeFileNoError(self.current_temp_mesh_file) input_filename = "" if tree.input_filename: input_filename = os.path.basename(os.path.splitext(tree.input_filename)[0]) self.current_temp_mesh_file = os.path.abspath(self.temp_mesh_file.format(input_filename)) input_file = os.path.abspath(self.temp_input_file) self._removeFileNoError(self.current_temp_mesh_file) self._removeFileNoError(input_file) self.needInputFile.emit(input_file) if not os.path.exists(input_file): self.meshEnabled.emit(False) self.onSetFilename(None) self.onWindowRequiresUpdate() self._setLoadingMessage("Error reading temporary input file") return try: args = ["-i", input_file, "--mesh-only", self.current_temp_mesh_file] if self._use_test_objects: args.append("--allow-test-objects") ExeLauncher.runExe(exe_path, args, print_errors=False) self.meshEnabled.emit(True) self.onSetFilename(self.current_temp_mesh_file) self.onSetColorbarVisible(False) self.onWindowRequiresUpdate() except Exception as e: self.meshEnabled.emit(False) self.onSetFilename(None) self.onWindowRequiresUpdate() mooseutils.mooseWarning("Error producing mesh: %s" % e) self._setLoadingMessage("Error producing mesh") self._removeFileNoError(self.current_temp_mesh_file) self._removeFileNoError(input_file) # we need the mesh file since it is in use but not the input file
def appChanged(self, app_path): """ Called when the executable changed. Input: app_path: New executable path """ try: raw_data = self._getRawDump(app_path) self.json_data = json.loads(raw_data) self.app_path = app_path except Exception as e: mooseutils.mooseWarning("Failed to load json from '%s': %s" % (app_path, e))
def setInputFile(self, input_filename): """ Set a new input file Input: input_filename[str]: The name of the input file Return: bool: If it was a valid input file """ try: new_input_file = InputFile(input_filename) return self._setInputFile(new_input_file) except Exception as e: mooseutils.mooseWarning("setInputFile exception: %s" % e) return False
def setInputFile(self, input_filename): """ Set a new input file Input: input_filename[str]: The name of the input file Return: bool: If it was a valid input file """ try: new_input_file = InputFile(input_filename) return self._setInputFile(new_input_file) except Exception as e: mooseutils.mooseWarning("setInputFile exception: %s" % e) return False
def writeInputFile(self, filename): """ Write the input tree to a file. Input: filename: Where to write the file. """ if not self.tree.app_info.valid() or not filename: return content = self.tree.getInputFileString() try: with open(filename, "w") as f: f.write(content) except IOError as e: mooseutils.mooseWarning("Failed to write input file %s: %s" % (filename, e))
def __init__(self, *args, **kwargs): # Stored the supplied values # NOTE: The default and value are private to keep them from the type checking being # nullified if the values are just set directly. if len(args) == 2: self.name = args[0] self.__value = None self.doc = args[1] self.__default = None elif len(args) == 3: self.name = args[0] self.__value = args[1] self.doc = args[2] self.__default = self.__value else: raise Exception( "Wrong number of arguments, must supply 2 or 3 input arguments." ) # Extract optional settings self.vtype = kwargs.pop('vtype', type(self.__value)) self.allow = kwargs.pop('allow', []) # Check that allow is correct type if not isinstance(self.allow, list): mooseutils.mooseWarning( 'The allow option must be supplied as a list.') # Check the allowed list contains the correct types else: for i in range(len(self.allow)): try: if not isinstance(self.allow[i], self.vtype) and self.vtype != Option.ANY: self.allow[i] = eval('{}({})'.format( self.vtype.__name__, str(self.allow[i]))) except: #pylint: disable=bare-except msg = 'The type provided, {}, does not match the type of the allowed ' + \ 'values, {} for the {} option.' mooseutils.mooseWarning( msg.format(self.vtype.__name__, type(self.allow[i]).__name__, self.name)) return # Try to set the value using the set method to test the type and if it is allowed if (self.__value != None) and not isinstance(self.__value, Options): self.set(self.__value)
def setInputFileData(self, input_str, filename="String"): """ Set a new input file based on a existing string Input: input_str[str]: The input file data to parse Return: bool: If it was a valid input file """ try: new_input_file = InputFile() new_input_file.readInputData(input_str, filename) return self._setInputFile(new_input_file) except Exception as e: mooseutils.mooseWarning("setInputFileData exception: %s" % e) return False
def setInputFileData(self, input_str, filename="String"): """ Set a new input file based on a existing string Input: input_str[str]: The input file data to parse Return: bool: If it was a valid input file """ try: new_input_file = InputFile() new_input_file.readInputData(input_str, filename) return self._setInputFile(new_input_file) except Exception as e: mooseutils.mooseWarning("setInputFileData exception: %s" % e) return False
def openInputFile(self, filename): """ Opens a file and parses it. Input: filename: file name of the input file Signals: input_file_changed: On success Raises: PeacockException: On invalid input file """ filename = str(filename) self.filename = path.abspath(filename) self.changed = False self.root_node = GPNode("/", None) # Do some basic checks on the filename to make sure # it is probably a real input file since the GetPot # parser doesn't do any checks. if not path.exists(filename): msg = "Input file %s does not exist" % filename mooseutils.mooseError(msg) raise PeacockException(msg) if not path.isfile(filename): msg = "Input file %s is not a file" % filename mooseutils.mooseError(msg) raise PeacockException(msg) if not filename.endswith(".i"): msg = "Input file %s does not have the proper extension" % filename mooseutils.mooseError(msg) raise PeacockException(msg) try: self.root_node = readInputFile(filename) with open(filename, "r") as f: self.original_text = f.read() self.changed = False except ParseException as e: msg = "Failed to parse input file %s:\n%s\n" % (filename, e.msg) mooseutils.mooseWarning(msg) raise e except Exception as e: msg = "Error occurred while parsing input file %s:\n%s\n" % ( filename, e) mooseutils.mooseWarning(msg) raise e
def _addInputFileNode(self, input_node): """ This adds a node from the input file. Input: input_node[GPNode]: The node from the input file. """ path = input_node.fullName(no_root=True) entry = self.path_map.get(path) if not entry: parent_path = os.path.dirname(path) name = os.path.basename(path) entry = self.addUserBlock(parent_path, name) if not entry: mooseutils.mooseWarning("Could not create %s" % path) return entry.comments = "\n".join(input_node.comments) entry.included = True entry.hard = True in_type_name = input_node.params.get("type") param_info = entry.parameters.get("type") if in_type_name and param_info: entry.setBlockType(in_type_name) param_info.value = in_type_name if "type" not in entry.parameters_list: entry.parameters_list.insert(0, "type") for param_name in input_node.params_list: param_value = input_node.params[param_name] param_info = self.getParamInfo(path, param_name) if not param_info: # must be a user added param param_info = self.addUserParam(path, param_name, param_value) else: param_info.value = param_value param_info.set_in_input_file = True if param_info.name not in param_info.parent.parameters_write_first: param_info.parent.parameters_write_first.append( param_info.name) param_info.comments = input_node.param_comments.get(param_name, "") for child_name in input_node.children_list: child_node = input_node.children[child_name] self._addInputFileNode(child_node) if child_name not in entry.children_write_first: entry.children_write_first.append(child_name)
def _addInputFileNode(self, input_node): """ This adds a node from the input file. Input: input_node[GPNode]: The node from the input file. """ path = input_node.fullName(no_root=True) entry = self.path_map.get(path) if not entry: parent_path = os.path.dirname(path) name = os.path.basename(path) entry = self.addUserBlock(parent_path, name) if not entry: mooseutils.mooseWarning("Could not create %s" % path) return entry.comments = "\n".join(input_node.comments) entry.included = True entry.hard = True in_type_name = input_node.params.get("type") param_info = entry.parameters.get("type") if in_type_name and param_info: entry.setBlockType(in_type_name) param_info.value = in_type_name if "type" not in entry.parameters_list: entry.parameters_list.insert(0, "type") for param_name in input_node.params_list: param_value = input_node.params[param_name] param_info = self.getParamInfo(path, param_name) if not param_info: # must be a user added param param_info = self.addUserParam(path, param_name, param_value) else: param_info.value = param_value param_info.set_in_input_file = True if param_info.name not in param_info.parent.parameters_write_first: param_info.parent.parameters_write_first.append(param_info.name) param_info.comments = input_node.param_comments.get(param_name, "") for child_name in input_node.children_list: child_node = input_node.children[child_name] self._addInputFileNode(child_node) if child_name not in entry.children_write_first: entry.children_write_first.append(child_name)
def __setitem__(self, name, value): """ Overload for setting value of an option with []. Inputs: name[str]: The name of the Option to retrieve value: The value to set the option to **kwargs: Key, value pairs are passed to the Option object. """ # Check that the option exists if not self.hasOption(name): mooseutils.mooseWarning('No option with the name:', name) # Set option to the given value, type checking occurs in the Option object else: self.__options[name].set(value)
def __setitem__(self, name, value): """ Overload for setting value of an option with []. Inputs: name[str]: The name of the Option to retrieve value: The value to set the option to **kwargs: Key, value pairs are passed to the Option object. """ # Check that the option exists if not self.hasOption(name): mooseutils.mooseWarning('No option with the name:', name) # Set option to the given value, type checking occurs in the Option object else: self.__options[name].set(value)
def testMooseMessageWarning(self): """ Test the warning dialog message. """ box = mooseutils.mooseWarning("A message", dialog = True, test = True) self.assertIn("A message", box.text()) self.assertIn("WARNING", box.text()) self.assertTrue(box.icon() == QtWidgets.QMessageBox.Warning)
def openInputFile(self, filename): """ Opens a file and parses it. Input: filename: file name of the input file Signals: input_file_changed: On success Raises: PeacockException: On invalid input file """ filename = str(filename) self.filename = path.abspath(filename) self.changed = False self.root_node = GPNode("/", None) # Do some basic checks on the filename to make sure # it is probably a real input file since the GetPot # parser doesn't do any checks. if not path.exists(filename): msg = "Input file %s does not exist" % filename mooseutils.mooseError(msg) raise PeacockException(msg) if not path.isfile(filename): msg = "Input file %s is not a file" % filename mooseutils.mooseError(msg) raise PeacockException(msg) if not filename.endswith(".i"): msg = "Input file %s does not have the proper extension" % filename mooseutils.mooseError(msg) raise PeacockException(msg) try: self.root_node = readInputFile(filename) with open(filename, "r") as f: self.original_text = f.read() self.changed = False except ParseException as e: msg = "Failed to parse input file %s:\n%s\n" % (filename, e.msg) mooseutils.mooseWarning(msg) raise e except Exception as e: msg = "Error occurred while parsing input file %s:\n%s\n" % (filename, e) mooseutils.mooseWarning(msg) raise e
def add(self, *args, **kwargs): """ Add a new option to the warehouse Inputs: name[str]: The name of the option, used to access and set its value value: The value to set the property too (i.e., the default value) doc[str]: The documentation string Optional Key, value Pairs vtype: The type of the value allowed[list]: The allowed values """ if args[0] in self.__options: mooseutils.mooseWarning('A parameter with the name', args[0], 'already exists.') return self.__options[args[0]] = Option(*args, **kwargs)
def add(self, *args, **kwargs): """ Add a new option to the warehouse Inputs: name[str]: The name of the option, used to access and set its value value: The value to set the property too (i.e., the default value) doc[str]: The documentation string Optional Key, value Pairs vtype: The type of the value allowed[list]: The allowed values """ if args[0] in self.__options: mooseutils.mooseWarning('A parameter with the name', args[0], 'already exists.') return self.__options[args[0]] = Option(*args, **kwargs)
def addUserParam(self, param, value): """ Adds a user parameter. Input: param[str]: Name of the parameter to add value[str]: Initial value of the parameter Return: ParameterInfo: The new parameter """ pinfo = self.getParamInfo(param) if pinfo: mooseutils.mooseWarning("Tried to add a user parameter when that name already exists: %s:%s" % (self.path, param)) return pinfo = ParameterInfo(self, param) pinfo.user_added = True pinfo.value = value self.addParameter(pinfo) return pinfo
def readInputData(self, data, filename): try: self.filename = os.path.abspath(filename) root = hit.parse(os.path.abspath(filename), data) hit.explode(root) w = DupWalker(os.path.abspath(filename)) root.walk(w, hit.NodeType.Field) if w.errors: for err in w.errors: mooseutils.mooseWarning(err) raise PeacockException("Parser errors") self.original_text = data self.root_node = root self.changed = False except PeacockException as e: msg = "Failed to parse input file %s:\n%s\n" % (filename, e) mooseutils.mooseWarning(msg) raise e
def __setValue(self, value, set_default=False): """ Set the value of the option with type checking. Inputs: set_default[bool]: (default: False) When true the value passed in is also set to the default. """ # None is always allowed if value is None: self.unset() return # If the Option is storing another Set of options and is passed a dict(), then # loop through the dictionary and update each option in the set of options. if (self.vtype is Options) and isinstance(value, dict): for k, v in value.items(): self.__value[k] = v else: if not isinstance(value, self.vtype): # Check if we can convert (e.g., int->float) try: value = eval(self.vtype.__name__ + '(' + str(value) + ')') except: #pylint: disable=bare-except msg = '{} must be of type {} but {} provided.' mooseutils.mooseWarning( msg.format(self.name, self.vtype.__name__, type(value).__name__)) value = None # Check that the value is allowed if self.allow and (value != None) and (value not in self.allow): msg = 'Attempting to set {} to a value of {} but only the following are allowed: {}' mooseutils.mooseWarning( msg.format(self.name, value, self.allow)) value = None self.__value = value if set_default: self.__default = value
def __init__(self, *args, **kwargs): # Stored the supplied values # NOTE: The default and value are private to keep them from the type checking being # nullified if the values are just set directly. if len(args) == 2: self.name = args[0] self.__value = None self.doc = args[1] self.__default = None elif len(args) == 3: self.name = args[0] self.__value = args[1] self.doc = args[2] self.__default = self.__value else: raise Exception("Wrong number of arguments, must supply 2 or 3 input arguments.") # Extract optional settings self.vtype = kwargs.pop('vtype', type(self.__value)) self.allow = kwargs.pop('allow', []) # Check that allow is correct type if not isinstance(self.allow, list): mooseutils.mooseWarning('The allow option must be supplied as a list.') # Check the allowed list contains the correct types else: for i in range(len(self.allow)): try: if not isinstance(self.allow[i], self.vtype) and self.vtype != Option.ANY: self.allow[i] = eval('{}({})'.format(self.vtype.__name__, str(self.allow[i]))) except: #pylint: disable=bare-except msg = 'The type provided, {}, does not match the type of the allowed ' + \ 'values, {} for the {} option.' mooseutils.mooseWarning(msg.format(self.vtype.__name__, type(self.allow[i]).__name__, self.name)) return # Try to set the value using the set method to test the type and if it is allowed if (self.__value != None) and not isinstance(self.__value, Options): self.set(self.__value)
def update(self, **kwargs): """ Set the options for this cube. (public) """ super(PlaneSourceMeta, self).update(**kwargs) if self.isOptionValid('origin'): self._vtksource.SetOrigin(*self.getOption('origin')) if self.isOptionValid('point1'): self._vtksource.SetPoint1(*self.getOption('point1')) if self.isOptionValid('point2'): self._vtksource.SetPoint2(*self.getOption('point2')) if self.isOptionValid('resolution'): self._vtksource.SetResolution(*self.getOption('resolution')) if self.isOptionValid('cmap'): if self.isOptionValid('color'): mooseutils.mooseWarning( 'The "color" and "cmap" options are both being set, ' 'the "color" will be ignored.') if not self.isOptionValid('data'): mooseutils.mooseError( 'The "cmap" option requires that "data" option also ' 'be supplied.') if self.isOptionValid('data'): self._vtksource.Update() data = self.getOption('data') self._vtksource.GetOutput().GetCellData().SetScalars(data) cmap_options = { key: self.getOption(key) for key in [ 'cmap', 'cmap_reverse', 'cmap_num_colors', 'cmap_range' ] } self._colormap.setOptions(**cmap_options) self._vtkmapper.SetScalarRange(data.GetRange(0)) self._vtkmapper.SetLookupTable(self._colormap())
def start(self, timer=None): """ Begin the interactive VTK session. """ if timer: msg = "The timer argument is deprecated, please use the 'observers' setting." mooseutils.mooseWarning(msg) mooseutils.mooseDebug("{}.start()".format(self.__class__.__name__), color='MAGENTA') if self.needsUpdate(): self.update() if self.__vtkinteractor: self.__vtkinteractor.Initialize() self.__vtkinteractor.Start() if self.getOption('style') == 'test': self.__vtkwindow.Finalize()
def start(self, timer=None): """ Begin the interactive VTK session. """ if timer: msg = "The timer argument is deprecated, please use the 'observers' setting." mooseutils.mooseWarning(msg) mooseutils.mooseDebug("{}.start()".format(self.__class__.__name__), color='MAGENTA') if self.needsUpdate(): self.update() if self.__vtkinteractor: self.__vtkinteractor.Initialize() self.__vtkinteractor.Start() if self.getOption('style') == 'test': self.__vtkwindow.Finalize()
def _addPlotObject(self, line): """ A helper method for inserting a line, handling color automatically, into the graph. Args: line[chigger.graph.Line]: The line object to add to this graph. """ # Initialize the line (this creates the vtk object) if line.needsInitialize(): line.initialize() # Set the line color, if not set by the user if not line.isOptionValid('color'): # Colors if self._vtkcolorseries is None: self._vtkcolorseries = vtk.vtkColorSeries() if self.isOptionValid('color_scheme'): scheme = eval('vtk.vtkColorSeries.' + self.getOption('color_scheme').upper()) self._vtkcolorseries.SetColorScheme(scheme) n_lines = len(self._plots) n_colors = self._vtkcolorseries.GetNumberOfColors() if n_lines >= n_colors: mooseutils.mooseWarning( 'The number of lines exceeds the number of available ' 'line colors.') c = self._vtkcolorseries.GetColorRepeating(n_lines) b = self.getOption('background') # If the color matches the background, flip it if (c[0] == b[0]) and (c[1] == b[1]) and (c[2] == c[2]): c[0] = 1 - c[0] c[1] = 1 - c[1] c[2] = 1 - c[2] line.setOption('color', c) self._plots.append(line)
def __setValue(self, value, set_default=False): """ Set the value of the option with type checking. Inputs: set_default[bool]: (default: False) When true the value passed in is also set to the default. """ # None is always allowed if value is None: self.unset() return # If the Option is storing another Set of options and is passed a dict(), then # loop through the dictionary and update each option in the set of options. if (self.vtype is Options) and isinstance(value, dict): for k, v in value.iteritems(): self.__value[k] = v else: if not isinstance(value, self.vtype): # Check if we can convert (e.g., int->float) try: value = eval(self.vtype.__name__ + '(' + str(value) +')') except: #pylint: disable=bare-except msg = '{} must be of type {} but {} provided.' mooseutils.mooseWarning(msg.format(self.name, self.vtype.__name__, type(value).__name__)) value = None # Check that the value is allowed if self.allow and (value != None) and (value not in self.allow): msg = 'Attempting to set {} to a value of {} but only the following are allowed: {}' mooseutils.mooseWarning(msg.format(self.name, value, self.allow)) value = None self.__value = value if set_default: self.__default = value
def runExe(app_path, args, print_errors=True): """ Convience function to run a executable with arguments and return the output Input: app_path: str: Path to the excutable args: either str or list: Arguments to pass to the executable Return: str: output of running the command Exceptions: FileExistsException: If there was a problem running the executable BadExecutableException: If the executable didn't exit cleanly """ popen_args = [str(app_path)] if isinstance(args, str): popen_args.append(args) else: popen_args.extend(args) proc = None try: proc = subprocess.Popen(popen_args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) except OSError as e: msg = "Problem running '%s'" % ' '.join(popen_args) if print_errors: mooseutils.mooseWarning(msg) msg += "\nError: %s" % e raise FileExistsException(msg) data = proc.communicate() stdout_data = data[0].decode("utf-8") if proc.returncode != 0: msg = "'%s' exited with non zero status %s.\n\n"\ "Please make sure your application is built and able to execute the given arguments.\n"\ "Working dir: %s\n"\ "Output: %s" % (' '.join(popen_args), proc.returncode, os.getcwd(), stdout_data) if print_errors: mooseutils.mooseWarning(msg) raise BadExecutableException(msg) return stdout_data
def renameChildBlock(self, oldname, newname): """ Rename one of the children Input: oldname[str]: Current name of the child newname[str]: New name of the child """ tmp_child = self.children.get(newname) if tmp_child: mooseutils.mooseWarning("Tried to rename %s to %s but %s already exists." % (oldname, newname, newname)) return child = self.children.get(oldname) if child: del self.children[oldname] self.children[newname] = child idx = self.children_list.index(oldname) self.children_list.remove(oldname) self.children_list.insert(idx, newname) child.name = newname child.updatePaths()
def _addPlotObject(self, line): """ A helper method for inserting a line, handling color automatically, into the graph. Args: line[chigger.graph.Line]: The line object to add to this graph. """ # Initialize the line (this creates the vtk object) if line.needsInitialize(): line.initialize() # Set the line color, if not set by the user if not line.isOptionValid('color'): # Colors if self._vtkcolorseries is None: self._vtkcolorseries = vtk.vtkColorSeries() if self.isOptionValid('color_scheme'): scheme = eval('vtk.vtkColorSeries.' + self.getOption('color_scheme').upper()) self._vtkcolorseries.SetColorScheme(scheme) n_lines = len(self._plots) n_colors = self._vtkcolorseries.GetNumberOfColors() if n_lines >= n_colors: mooseutils.mooseWarning('The number of lines exceeds the number of available ' 'line colors.') c = self._vtkcolorseries.GetColorRepeating(n_lines) b = self.getOption('background') # If the color matches the background, flip it if (c[0] == b[0]) and (c[1] == b[1]) and (c[2] == c[2]): c[0] = 1 - c[0] c[1] = 1 - c[1] c[2] = 1 - c[2] line.setOption('color', c) self._plots.append(line)
def runExe(app_path, args, print_errors=True): """ Convience function to run a executable with arguments and return the output Input: app_path: str: Path to the excutable args: either str or list: Arguments to pass to the executable Return: str: output of running the command Exceptions: FileExistsException: If there was a problem running the executable BadExecutableException: If the executable didn't exit cleanly """ popen_args = [str(app_path)] if isinstance(args, str): popen_args.append(args) else: popen_args.extend(args) proc = None try: proc = subprocess.Popen(popen_args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) except OSError as e: msg = "Problem running '%s'" % ' '.join(popen_args) if print_errors: mooseutils.mooseWarning(msg) msg += "\nError: %s" % e raise FileExistsException(msg) data = proc.communicate() stdout_data = data[0].decode("utf-8") if proc.returncode != 0: msg = "'%s' exited with non zero status %s.\n\n"\ "Please make sure your application is built and able to execute the given arguments.\n"\ "Working dir: %s\n"\ "Output: %s" % (' '.join(popen_args), proc.returncode, os.getcwd(), stdout_data) if print_errors: mooseutils.mooseWarning(msg) raise BadExecutableException(msg) return stdout_data
def update(self, **kwargs): """ Computes the contour levels for the vtkContourFilter. """ super(TubeFilter, self).update(**kwargs) if self.isOptionValid('radius'): self._vtkfilter.SetRadius(self.getOption('radius')) if self.isOptionValid('normalized_radius'): if self.isOptionValid('radius'): mooseutils.mooseWarning("The 'radius' and 'normalized_radius' options are both " "set, the 'radius is being used.'") else: self._vtkfilter.SetRadius(utils.compute_distance(self._source) * self.getOption('normalized_radius')) if self.isOptionValid('sides'): self._vtkfilter.SetNumberOfSides(self.getOption('sides')) if self.isOptionValid('caps'): self._vtkfilter.SetCapping(self.getOption('caps'))
def update(self, options=None, **kwargs): """" Update the options given key, value pairs To enable unused warning, include 'warn_unused=True' """ # Unused options changed = False unused = set() warn = kwargs.pop('warn_unused', False) # Update from Options object if isinstance(options, Options): for key in options.keys(): if self.hasOption(key): if options.isOptionValid(key): changed = True self[key] = options[key] else: unused.add(key) # Update from kwargs for k, v in kwargs.iteritems(): if k in self.__options: changed = True self[k] = v else: unused.add(k) # Warning for unused @todo warning if warn and len(unused) > 0: msg = 'The following settings where not recognized:' for key in unused: msg += ' '*4 + key mooseutils.mooseWarning(msg) return changed
def update(self, options=None, **kwargs): """" Update the options given key, value pairs To enable unused warning, include 'warn_unused=True' """ # Unused options changed = False unused = set() warn = kwargs.pop('warn_unused', False) # Update from Options object if isinstance(options, Options): for key in options.keys(): if self.hasOption(key): if options.isOptionValid(key): changed = True self[key] = options[key] else: unused.add(key) # Update from kwargs for k, v in kwargs.items(): if k in self.__options: changed = True self[k] = v else: unused.add(k) # Warning for unused @todo warning if warn and len(unused) > 0: msg = 'The following settings where not recognized:' for key in unused: msg += ' ' * 4 + key mooseutils.mooseWarning(msg) return changed
def incompatibleChanges(self, app_info): """ Tries to detect if there are any incompatible changes in the syntax with the current working input file. Input: app_info[ExecutableInfo]: The executable info to compare against Return: bool: True if errors occurred loading the current input file with the new syntax """ if not self.app_info.json_data: return False if self.app_info.json_data and not app_info.json_data: return True try: old_input = self.getInputFileString() new_tree = InputTree(app_info) read_data = new_tree.setInputFileData(old_input) return not read_data or new_tree.input_has_errors except Exception as e: mooseutils.mooseWarning("Caught exception: %s" % e) return True
def incompatibleChanges(self, app_info): """ Tries to detect if there are any incompatible changes in the syntax with the current working input file. Input: app_info[ExecutableInfo]: The executable info to compare against Return: bool: True if errors occurred loading the current input file with the new syntax """ if not self.app_info.json_data: return False if self.app_info.json_data and not app_info.json_data: return True try: old_input = self.getInputFileString() new_tree = InputTree(app_info) read_data = new_tree.setInputFileData(old_input) return not read_data or new_tree.input_has_errors except Exception as e: mooseutils.mooseWarning("Caught exception: %s" % e) return True
def update(self, **kwargs): """ Set the options for this cube. (public) """ super(PlaneSourceMeta, self).update(**kwargs) if self.isOptionValid('origin'): self._vtksource.SetOrigin(*self.getOption('origin')) if self.isOptionValid('point1'): self._vtksource.SetPoint1(*self.getOption('point1')) if self.isOptionValid('point2'): self._vtksource.SetPoint2(*self.getOption('point2')) if self.isOptionValid('resolution'): self._vtksource.SetResolution(*self.getOption('resolution')) if self.isOptionValid('cmap'): if self.isOptionValid('color'): mooseutils.mooseWarning('The "color" and "cmap" options are both being set, ' 'the "color" will be ignored.') if not self.isOptionValid('data'): mooseutils.mooseError('The "cmap" option requires that "data" option also ' 'be supplied.') if self.isOptionValid('data'): self._vtksource.Update() data = self.getOption('data') self._vtksource.GetOutput().GetCellData().SetScalars(data) cmap_options = {key:self.getOption(key) for key in ['cmap', 'cmap_reverse', 'cmap_num_colors', 'cmap_range']} self._colormap.setOptions(**cmap_options) self._vtkmapper.SetScalarRange(data.GetRange(0)) self._vtkmapper.SetLookupTable(self._colormap())
def update(self, **kwargs): """ Computes the contour levels for the vtkContourFilter. """ super(TubeFilter, self).update(**kwargs) if self.isOptionValid('radius'): self._vtkfilter.SetRadius(self.getOption('radius')) if self.isOptionValid('normalized_radius'): if self.isOptionValid('radius'): mooseutils.mooseWarning( "The 'radius' and 'normalized_radius' options are both " "set, the 'radius is being used.'") else: self._vtkfilter.SetRadius( utils.compute_distance(self._source) * self.getOption('normalized_radius')) if self.isOptionValid('sides'): self._vtkfilter.SetNumberOfSides(self.getOption('sides')) if self.isOptionValid('caps'): self._vtkfilter.SetCapping(self.getOption('caps'))
def __getTimeInformation(self): """ Helper for getting the current TimeData object using the 'time' and 'timestep' options. (private) Returns: TimeData: The current TimeData object. """ # Time/timestep both set, unset 'time' and use 'timestep' if self.isOptionValid('timestep') and self.isOptionValid('time'): time = self.getOption('time') timestep = self.getOption('timestep') self._options.raw('time').unset() msg = "Both 'time' ({}) and 'timestep' ({}) are set, 'timestep' is being used." mooseutils.mooseWarning(msg.format(time, timestep)) # Timestep timestep = -1 n = len(self.__timedata) - 1 if self.isOptionValid('timestep'): timestep = self.getOption('timestep') # Account for out-of-range timesteps if (timestep < 0) and (timestep != -1): mooseutils.mooseWarning("Timestep out of range:", timestep, 'not in', repr([0, n])) self.setOption('timestep', 0) timestep = 0 elif timestep > n: mooseutils.mooseWarning("Timestep out of range:", timestep, 'not in', repr([0, n])) self.setOption('timestep', n) timestep = n # Time elif self.isOptionValid('time'): times = [t.time for t in self.__timedata] idx = bisect.bisect_right(times, self.getOption('time')) - 1 if idx < 0: idx = 0 elif idx > n: idx = -1 timestep = idx else: t = self.getOption('time') ts = self.getOption('timestep') mooseutils.mooseError( 'Invalid time ({}) and timestep({}) options.'.format(t, ts)) return self.__timedata[timestep]
def __getTimeInformation(self): """ Helper for getting the current TimeData object using the 'time' and 'timestep' options. (private) Returns: TimeData: The current TimeData object. """ # Time/timestep both set, unset 'time' and use 'timestep' if self.isOptionValid('timestep') and self.isOptionValid('time'): time = self.getOption('time') timestep = self.getOption('timestep') self._options.raw('time').unset() msg = "Both 'time' ({}) and 'timestep' ({}) are set, 'timestep' is being used." mooseutils.mooseWarning(msg.format(time, timestep)) # Timestep timestep = -1 n = len(self.__timedata)-1 if self.isOptionValid('timestep'): timestep = self.getOption('timestep') # Account for out-of-range timesteps if (timestep < 0) and (timestep != -1): mooseutils.mooseWarning("Timestep out of range:", timestep, 'not in', repr([0, n])) self.setOption('timestep', 0) timestep = 0 elif timestep > n: mooseutils.mooseWarning("Timestep out of range:", timestep, 'not in', repr([0, n])) self.setOption('timestep', n) timestep = n # Time elif self.isOptionValid('time'): times = [t.time for t in self.__timedata] idx = bisect.bisect_right(times, self.getOption('time')) - 1 if idx < 0: idx = 0 elif idx > n: idx = -1 timestep = idx else: t = self.getOption('time') ts = self.getOption('timestep') mooseutils.mooseError('Invalid time ({}) and timestep({}) options.'.format(t, ts)) return self.__timedata[timestep]
def set_options(vtkaxis, opt): """ Set the options for vtkAxis object. """ # Visibility vtkaxis.SetTicksVisible(opt['ticks_visible']) vtkaxis.SetAxisVisible(opt['axis_visible']) vtkaxis.SetLabelsVisible(opt['labels_visible']) # Opacity if opt.isOptionValid('axis_opacity'): opacity = opt['axis_opacity'] vtkaxis.SetOpacity(opacity) vtkaxis.GetTitleProperties().SetOpacity(opacity) vtkaxis.GetLabelProperties().SetOpacity(opacity) # Ticks if opt.isOptionValid('num_ticks'): vtkaxis.SetNumberOfTicks(opt['num_ticks']) # Limits if opt.isOptionValid('lim'): lim = opt['lim'] if abs(lim[1] - lim[0]) < opt['zero_tol']: vtkaxis.SetBehavior(vtk.vtkAxis.CUSTOM) vtkaxis.SetRange(0, 1) pos = vtk.vtkDoubleArray() pos.SetNumberOfTuples(2) pos.SetValue(0, 0) pos.SetValue(1, 1) labels = vtk.vtkStringArray() labels.SetNumberOfTuples(2) labels.SetValue(0, str(lim[0])) labels.SetValue(1, str(lim[1])) vtkaxis.SetCustomTickPositions(pos, labels) else: vtkaxis.SetCustomTickPositions(None, None) vtkaxis.SetBehavior(vtk.vtkAxis.FIXED) scale = opt['axis_scale'] factor = opt['axis_factor'] vtkaxis.SetRange(lim[0] * scale + factor, lim[1] * scale + factor) vtkaxis.RecalculateTickSpacing() else: vtkaxis.SetBehavior(vtk.vtkAxis.AUTO) vtkaxis.SetCustomTickPositions(None, None) # Color if opt.isOptionValid('font_color'): clr = opt['font_color'] vtkaxis.GetTitleProperties().SetColor(*clr) vtkaxis.GetLabelProperties().SetColor(*clr) vtkaxis.GetPen().SetColorF(*clr) # Axis title if opt.isOptionValid('title'): vtkaxis.SetTitle(opt['title']) # Font sizes if opt.isOptionValid('font_size'): vtkaxis.GetTitleProperties().SetFontSize(opt['font_size']) vtkaxis.GetLabelProperties().SetFontSize(opt['font_size']) if opt.isOptionValid('title_font_size'): vtkaxis.GetTitleProperties().SetFontSize(opt['title_font_size']) if opt.isOptionValid('tick_font_size'): vtkaxis.GetLabelProperties().SetFontSize(opt['tick_font_size']) # Precision/notation if opt.isOptionValid('notation'): notation = opt['notation'].upper() vtk_notation = getattr(vtk.vtkAxis, notation + '_NOTATION') vtkaxis.SetNotation(vtk_notation) if opt.isOptionValid('precision'): if vtkaxis.GetNotation() in VTK_NOTATION_ENUM[1:3]: vtkaxis.SetPrecision(opt['precision']) else: mooseutils.mooseWarning("When using 'precision' option, 'notation' option has to be " "set to either 'scientific' or 'fixed'.") # Grid lines vtkaxis.SetGridVisible(opt['grid']) vtkaxis.GetGridPen().SetColorF(opt['grid_color']) # Set the position and points if opt.isOptionValid('axis_position'): pos = {'left':vtk.vtkAxis.LEFT, 'right':vtk.vtkAxis.RIGHT, 'top':vtk.vtkAxis.TOP, 'bottom':vtk.vtkAxis.BOTTOM} vtkaxis.SetPosition(pos[opt['axis_position']]) if opt.isOptionValid('axis_point1'): vtkaxis.SetPoint1(*opt['axis_point1']) if opt.isOptionValid('axis_point2'): vtkaxis.SetPoint2(*opt['axis_point2'])
def set_options(vtkaxis, opt): """ Set the options for vtkAxis object. """ # Visibility vtkaxis.SetTicksVisible(opt['ticks_visible']) vtkaxis.SetAxisVisible(opt['axis_visible']) vtkaxis.SetLabelsVisible(opt['labels_visible']) # Opacity if opt.isOptionValid('axis_opacity'): opacity = opt['axis_opacity'] vtkaxis.SetOpacity(opacity) vtkaxis.GetTitleProperties().SetOpacity(opacity) vtkaxis.GetLabelProperties().SetOpacity(opacity) # Ticks if opt.isOptionValid('num_ticks'): vtkaxis.SetNumberOfTicks(opt['num_ticks']) # Limits if opt.isOptionValid('lim'): lim = opt['lim'] if abs(lim[1] - lim[0]) < opt['zero_tol']: vtkaxis.SetBehavior(vtk.vtkAxis.CUSTOM) vtkaxis.SetRange(0, 1) pos = vtk.vtkDoubleArray() pos.SetNumberOfTuples(2) pos.SetValue(0, 0) pos.SetValue(1, 1) labels = vtk.vtkStringArray() labels.SetNumberOfTuples(2) labels.SetValue(0, str(lim[0])) labels.SetValue(1, str(lim[1])) vtkaxis.SetCustomTickPositions(pos, labels) else: vtkaxis.SetCustomTickPositions(None, None) vtkaxis.SetBehavior(vtk.vtkAxis.FIXED) scale = opt['axis_scale'] factor = opt['axis_factor'] vtkaxis.SetRange(lim[0] * scale + factor, lim[1] * scale + factor) vtkaxis.RecalculateTickSpacing() else: vtkaxis.SetBehavior(vtk.vtkAxis.AUTO) vtkaxis.SetCustomTickPositions(None, None) # Color if opt.isOptionValid('font_color'): clr = opt['font_color'] vtkaxis.GetTitleProperties().SetColor(*clr) vtkaxis.GetLabelProperties().SetColor(*clr) vtkaxis.GetPen().SetColorF(*clr) # Axis title if opt.isOptionValid('title'): vtkaxis.SetTitle(opt['title']) # Font sizes if opt.isOptionValid('font_size'): vtkaxis.GetTitleProperties().SetFontSize(opt['font_size']) vtkaxis.GetLabelProperties().SetFontSize(opt['font_size']) if opt.isOptionValid('title_font_size'): vtkaxis.GetTitleProperties().SetFontSize(opt['title_font_size']) if opt.isOptionValid('tick_font_size'): vtkaxis.GetLabelProperties().SetFontSize(opt['tick_font_size']) # Precision/notation if opt.isOptionValid('notation'): notation = opt['notation'].upper() vtk_notation = getattr(vtk.vtkAxis, notation + '_NOTATION') vtkaxis.SetNotation(vtk_notation) if opt.isOptionValid('precision'): if vtkaxis.GetNotation() in VTK_NOTATION_ENUM[1:2]: vtkaxis.SetPrecision(opt['precision']) else: mooseutils.mooseWarning( "When using 'precision' option, 'notation' option has to be " "set to either 'scientific' or 'fixed'.") # Grid lines vtkaxis.SetGridVisible(opt['grid']) vtkaxis.GetGridPen().SetColorF(opt['grid_color']) # Set the position and points if opt.isOptionValid('axis_position'): pos = { 'left': vtk.vtkAxis.LEFT, 'right': vtk.vtkAxis.RIGHT, 'top': vtk.vtkAxis.TOP, 'bottom': vtk.vtkAxis.BOTTOM } vtkaxis.SetPosition(pos[opt['axis_position']]) if opt.isOptionValid('axis_point1'): vtkaxis.SetPoint1(*opt['axis_point1']) if opt.isOptionValid('axis_point2'): vtkaxis.SetPoint2(*opt['axis_point2'])