def __init__(self, program): """ Runner to run PROZA simulation(s). """ _Worker.__init__(self, program, java_exec=get_settings().proza.java, jar_path=get_settings().proza.jar)
def __init__(self, program): """ Runner to run NISTMonte simulation(s). """ _Worker.__init__(self, program) self._java_exec = get_settings().nistmonte.java logging.debug('Java executable: %s', self._java_exec) self._jar_path = get_settings().nistmonte.jar logging.debug('pyMonteCarlo jar path: %s', self._jar_path)
def __init__(self, program): """ Runner to run Monaco simulation(s). """ _Worker.__init__(self, program) self._monaco_basedir = get_settings().monaco.basedir try: self._mccli32exe = get_settings().monaco.exe except AttributeError: self._mccli32exe = os.path.join(self._monaco_basedir, 'Mccli32.exe')
def run(argv=None): # Initialise programs get_settings().get_programs() # Initialise console console = Console() console.init() # Create parser usage = "%prog [options] [OPTION_FILE.xml or RESULTS_FILE.zip or RESULTS_FILE.h5 ...]" description = "pyMonteCarlo update tool. This script updates old version " + \ "of options or results file to the newer one." epilog = "For more information, see http://pymontecarlo.bitbucket.org" parser = OptionParser(usage=usage, description=description, epilog=epilog) parser.add_option('-v', '--verbose', dest='verbose', default=False, action='store_true', help='Debug mode') # Parse arguments (values, args) = parser.parse_args(argv) if values.verbose: logging.getLogger().setLevel(logging.DEBUG) if not args: console.print_error('Please specify at least one file') for filepath in args: if not os.path.exists(filepath): console.print_error('File %s does not exists' % filepath) ext = os.path.splitext(filepath)[1] if ext == '.xml': console.print_info("Updating options %s" % filepath) filepath = OptionsUpdater().update(filepath) console.print_success("Successfully updated %s" % filepath) elif ext == '.zip' or ext == '.h5': console.print_info("Updating results %s" % filepath) filepath = ResultsUpdater().update(filepath) console.print_success("Successfully results %s" % filepath) else: console.print_error('Unknown extension %s' % ext) console.close()
def validate(self): settings = get_settings() if 'monaco' not in settings: raise AssertionError("Missing 'monaco' section in settings") if 'basedir' not in settings.monaco: raise AssertionError( "Missing 'basedir' option in 'monaco' section of settings") basedir = settings.monaco.basedir if not os.path.isdir(basedir): raise AssertionError( "Specified Monaco base directory (%s) does not exist" % basedir) try: mccli32_exe = settings.monaco.exe except AttributeError: filename = 'Mccli32' if os.name == 'nt': filename += '.exe' mccli32_exe = os.path.join(settings.monaco.basedir, filename) if not os.path.isfile(mccli32_exe): raise AssertionError( "No Mccli32.exe in Monaco base directory (%s)" % basedir) if not os.access(mccli32_exe, os.X_OK): raise AssertionError( "Specified Monaco executable (%s) is not executable" % mccli32_exe)
def __init__(self): """ Creates a exporter to PENEPMA. """ try: pendbase = get_settings().penepma.pendbase except AttributeError: pendbase = None _Exporter.__init__(self, pendbase) self._beam_exporters[GaussianBeam] = self._export_dummy self._detector_exporters[ BackscatteredElectronEnergyDetector] = self._export_dummy self._detector_exporters[ TransmittedElectronEnergyDetector] = self._export_dummy self._detector_exporters[PhotonSpectrumDetector] = self._export_dummy self._detector_exporters[PhotonIntensityDetector] = self._export_dummy self._detector_exporters[PhotonDepthDetector] = self._export_dummy self._detector_exporters[ElectronFractionDetector] = self._export_dummy self._detector_exporters[TimeDetector] = self._export_dummy self._detector_exporters[ ShowersStatisticsDetector] = self._export_dummy self._limit_exporters[ShowersLimit] = self._export_dummy self._limit_exporters[TimeLimit] = self._export_dummy self._limit_exporters[UncertaintyLimit] = self._export_dummy
def __init__(self, options=None, parent=None): QWizard.__init__(self, parent) if options is None: self.setWindowTitle("Create new options") else: self.setWindowTitle("Modify options") self.setWizardStyle(QWizard.WizardStyle.ClassicStyle) # Variables if options is None: options = Options() options = copy.deepcopy(options) self._options = options settings = get_settings() if not settings.get_programs(): raise RuntimeError('No programs are defined. Run the configuration first.') # Pages self.addPage(NameWizardPage(options)) self.addPage(ProgramWizardPage(options)) self.addPage(BeamWizardPage(options)) self.addPage(GeometryWizardPage(options)) self.addPage(DetectorWizardPage(options)) self.addPage(LimitWizardPage(options)) self.addPage(ModelWizardPage(options)) self.addPage(WarningWizardPage(options))
def validate(self): _PenelopeProgram.validate(self) settings = get_settings() if 'penshower' not in settings: raise AssertionError("Missing 'penshower' section in settings") if 'exe' not in settings.penshower: raise AssertionError( "Missing 'exe' option in 'penshower' section of settings") pendbase = settings.penshower.pendbase if not os.path.isdir(pendbase): raise AssertionError( "Specified PENELOPE pendbase directory (%s) does not exist" % pendbase) exe = settings.penshower.exe if not os.path.isfile(exe): raise AssertionError( "Specified PENSHOWER executable (%s) does not exist" % exe) if not os.access(exe, os.X_OK): raise AssertionError( "Specified PENSHOWER executable (%s) is not executable" % exe)
def autoconfig(self, programs_path): settings = get_settings() # Java try: if os.name == 'posix': java_path = subprocess.check_output(['which', 'java']) else: java_path = subprocess.check_output( 'for %i in (java.exe) do @echo. %~$PATH:i', shell=True) java_path = java_path.decode('ascii').strip() except subprocess.CalledProcessError: return False settings.add_section('pap').java = java_path # jar if sys.platform == 'linux': jar_path = '/usr/share/libpymontecarlo-java/lib/pymontecarlo-dtsa2-pap.jar' if not os.path.exists(jar_path): return False else: jar_path = os.path.join(programs_path, self.alias, 'pymontecarlo-dtsa2-pap.jar') if not os.path.exists(jar_path): return False settings.add_section('pap').jar = jar_path return True
def autoconfig(self, programs_path): settings = get_settings() # Java try: if os.name == 'posix': java_path = subprocess.check_output(['which', 'java']) else: java_path = subprocess.check_output('for %i in (java.exe) do @echo. %~$PATH:i', shell=True) java_path = java_path.decode('ascii').strip() except subprocess.CalledProcessError: return False settings.add_section('xpp').java = java_path # jar if sys.platform == 'linux': jar_path = '/usr/share/libpymontecarlo-java/lib/pymontecarlo-dtsa2-xpp.jar' if not os.path.exists(jar_path): return False else: jar_path = os.path.join(programs_path, self.alias, 'pymontecarlo-dtsa2-xpp.jar') if not os.path.exists(jar_path): return False settings.add_section('xpp').jar = jar_path return True
def autoconfig(self, programs_path): settings = get_settings() # Java try: if os.name == "posix": java_path = subprocess.check_output(["which", "java"]) else: java_path = subprocess.check_output("for %i in (java.exe) do @echo. %~$PATH:i", shell=True) java_path = java_path.decode("ascii").strip() except subprocess.CalledProcessError: return False settings.add_section("pap").java = java_path # jar if sys.platform == "linux": jar_path = "/usr/share/libpymontecarlo-java/lib/pymontecarlo-dtsa2-pap.jar" if not os.path.exists(jar_path): return False else: jar_path = os.path.join(programs_path, self.alias, "pymontecarlo-dtsa2-pap.jar") if not os.path.exists(jar_path): return False settings.add_section("pap").jar = jar_path return True
def _initUI(self): # Variable settings = get_settings() # Widgets self._checkboxes = {} for program in settings.get_programs(): self._checkboxes[program] = QCheckBox(program.name) btn_selectall = QPushButton('Select all') btn_deselectall = QPushButton('Deselect all') # Layouts layout = _OptionsWizardPage._initUI(self) for program in sorted(self._checkboxes.keys() , key=attrgetter('name')): layout.addRow(self._checkboxes[program]) spacer = QSpacerItem(0, 1000, QSizePolicy.Expanding, QSizePolicy.Expanding) layout.addItem(spacer) sublayout = QHBoxLayout() sublayout.addWidget(btn_selectall) sublayout.addWidget(btn_deselectall) layout.addRow(sublayout) # Signals btn_selectall.released.connect(self._onSelectAll) btn_deselectall.released.connect(self._onDeselectAll) return layout
def validate(self): settings = get_settings() if 'pap' not in settings: raise AssertionError("Missing 'pap' section in settings") if 'java' not in settings.pap: raise AssertionError( "Missing 'java' option in 'pap' section of settings") java = settings.pap.java if not os.path.isfile(java): raise AssertionError( "Specified Java executable (%s) does not exist" % java) if not os.access(java, os.X_OK): raise AssertionError( "Specified Java executable (%s) is not executable" % java) if 'jar' not in settings.pap: raise AssertionError( "Missing 'jar' option in 'pap' section of settings") jar = settings.pap.jar if not os.path.isfile(jar): raise AssertionError("Specified jar path (%s) does not exist" % jar) if os.path.splitext(jar)[1] != '.jar': raise AssertionError("Specified jar path (%s) is not a jar" % jar)
def run(self): # Extract choices settings = get_settings() programs = sorted(settings.get_available_programs(), key=attrgetter('name')) attr = self.arguments[0] choices = {} for program in programs: converter = program.converter_class for clasz in getattr(converter, attr, []): modulepath = clasz.__module__ + '.' + clasz.__name__ choices.setdefault(modulepath, set()).add(program) if 'only' in self.options: if self.options['only'] not in choices: raise ValueError("Unknown module in only flag") # Create table table_node = self._build_table(programs, choices) table_node['classes'] += self.options.get('class', []) self.add_name(table_node) return [table_node]
def __init__(self, queue_options, outputdir, workdir=None, overwrite=True): """ Runner to run Casino 3 simulation(s). """ _Worker.__init__(self, queue_options, outputdir, workdir, overwrite) self._executable = get_settings().casino3.exe if not os.path.isfile(self._executable): raise IOError('Casino 3 executable (%s) cannot be found' % self._executable) logging.debug('Casino 3 executable: %s', self._executable)
def __init__(self, program): """ Runner to run PENSHOWER simulation(s). """ _Worker.__init__(self, program) self._executable = get_settings().penshower.exe if not os.path.isfile(self._executable): raise IOError('PENSHOWER executable (%s) cannot be found' % self._executable) logging.debug('PENSHOWER executable: %s', self._executable)
def __init__(self, program): """ Runner to run WinX-Ray simulation(s). """ _Worker.__init__(self, program) self._executable = get_settings().winxray.exe logging.debug('WinX-Ray executable: %s', self._executable) self._executable_dir = os.path.dirname(self._executable) logging.debug('WinX-Ray directory: %s', self._executable_dir)
def add(self, value): if isinstance(value, Program): alias = value.alias program = value else: alias = value try: program = get_settings().get_program(alias, validate=False) except ValueError: program = None self._programs[alias] = program
def __init__(self, program): """ Runner to run Casino2 simulation(s). """ _Worker.__init__(self, program) self._executable = get_settings().casino2.exe logging.debug('Casino2 executable: %s', self._executable) self._executable_dir = os.path.dirname(self._executable) logging.debug('Casino2 directory: %s', self._executable_dir)
def validate(self): settings = get_settings() if 'casino3' not in settings: raise AssertionError("Missing 'casino3' section in settings") if 'exe' not in settings.casino3: raise AssertionError("Missing 'exe' option in 'casino3' section of settings") exe = settings.casino3.exe if not os.path.isfile(exe): raise AssertionError("Specified Casino 3 executable (%s) does not exist" % exe)
def validate(self): settings = get_settings() if 'casino3' not in settings: raise AssertionError("Missing 'casino3' section in settings") if 'exe' not in settings.casino3: raise AssertionError( "Missing 'exe' option in 'casino3' section of settings") exe = settings.casino3.exe if not os.path.isfile(exe): raise AssertionError( "Specified Casino 3 executable (%s) does not exist" % exe)
def autoconfig(self, programs_path): if sys.platform == 'linux': pendbase_path = '/usr/share/penelope-pendbase' if not os.path.exists(pendbase_path): return False else: pendbase_path = os.path.join(programs_path, 'penelope', 'pendbase') if not os.path.exists(pendbase_path): return False settings = get_settings() settings.add_section(self.alias).pendbase = pendbase_path return True
def autoconfig(self, programs_path): if sys.platform == 'linux': exe_path = '/usr/bin/casino2' if not os.path.exists(exe_path): return False else: paths = glob.glob(os.path.join(programs_path, self.alias, '*casino*')) if len(paths) != 1: return False exe_path = paths[0] settings = get_settings() settings.add_section('casino2').exe = exe_path return True
def validate(self): settings = get_settings() if 'winxray' not in settings: raise AssertionError("Missing 'winxray' section in settings") if 'exe' not in settings.winxray: raise AssertionError("Missing 'exe' option in 'winxray' section of settings") exe = settings.winxray.exe if os.path.splitext(exe)[1] != '.app' and not os.path.isfile(exe): raise AssertionError("Specified WinXRay executable (%s) does not exist" % exe) if not os.access(exe, os.X_OK): raise AssertionError("Specified WinXRay executable (%s) is not executable" % exe)
def __init__(self): """ Creates a exporter to PENSHOWER. """ try: pendbase = get_settings().penepma.pendbase except AttributeError: pendbase = None _Exporter.__init__(self, pendbase) self._beam_exporters[GaussianBeam] = self._export_dummy self._detector_exporters[TrajectoryDetector] = self._export_dummy self._limit_exporters[ShowersLimit] = self._export_dummy
def _append_job_properties(self, lines, options, geoinfo, matinfos, phdets_key_index, phdets_index_keys, *args): lines.append(self._COMMENT_JOBPROP()) text = 'dump.dat' line = self._KEYWORD_RESUME(text) lines.append(line) text = 'dump.dat' line = self._KEYWORD_DUMPTO(text) lines.append(line) text = getattr(get_settings().penepma, 'dumpp', 60.0) line = self._KEYWORD_DUMPP(text) lines.append(line) lines.append(self._COMMENT_SKIP()) #NOTE: No random number. PENEPMA will select them. limits = list(options.limits.iterclass(UncertaintyLimit)) if limits: limit = limits[0] transition = limit.transition detector = phdets_key_index[limit.detector_key] + 1 uncertainty = limit.uncertainty code = int(transition.z * 1e6 + \ transition.dest.index * 1e4 + \ transition.src.index * 1e2) text = [code, detector, uncertainty] line = self._KEYWORD_REFLIN(text) lines.append(line) limits = list(options.limits.iterclass(ShowersLimit)) showers = limits[0].showers if limits else 1e38 text = '%e' % showers line = self._KEYWORD_NSIMSH(text) lines.append(line) limits = list(options.limits.iterclass(TimeLimit)) time_s = limits[0].time_s if limits else 1e38 text = '%e' % time_s line = self._KEYWORD_TIME(text) lines.append(line) lines.append(self._COMMENT_SKIP())
def autoconfig(self, programs_path): if not _PenelopeProgram.autoconfig(self, programs_path): return False if sys.platform == 'linux': exe_path = '/usr/bin/penepma' else: paths = glob.glob(os.path.join(programs_path, self.alias, 'bin', 'penepma')) if len(paths) != 1: return False exe_path = paths[0] settings = get_settings() settings.add_section('penepma').exe = exe_path settings.add_section('penepma').dumpp = 30 return True
def autoconfig(self, programs_path): if not _PenelopeProgram.autoconfig(self, programs_path): return False if sys.platform == "linux": exe_path = "/usr/bin/penshower" if not os.path.exists(exe_path): return False else: paths = glob.glob(os.path.join(programs_path, self.alias, "bin", "penshower")) if len(paths) != 1: return False exe_path = paths[0] settings = get_settings() settings.add_section("penshower").exe = exe_path return True
def run(argv=None): # Initialize console = Console() console.init() console.print_message("Configuration of pyMonteCarlo") console.print_line() # Find settings.cfg settings = get_settings() # Programs programs = [] for program_alias in settings.get_available_program_aliases(): default = program_alias in settings.get_program_aliases() answer = \ console.prompt_boolean("Do you want to setup %s?" % program_alias, default) if answer: cli = settings.get_program_cli(program_alias) try: pass except Exception as ex: console.print_exception(ex) return cli.configure(console, settings) programs.append(program_alias) else: if program_alias in settings: delattr(settings, program_alias) console.print_line() settings.pymontecarlo.programs = ','.join(programs) # Save settings.write() console.print_success("Settings saved") # Finalize console.close()
def validate(self): _PenelopeProgram.validate(self) settings = get_settings() if 'penepma' not in settings: raise AssertionError("Missing 'penepma' section in settings") if 'exe' not in settings.penepma: raise AssertionError("Missing 'exe' option in 'penepma' section of settings") pendbase = settings.penepma.pendbase if not os.path.isdir(pendbase): raise AssertionError("Specified PENELOPE pendbase directory (%s) does not exist" % pendbase) exe = settings.penepma.exe if not os.path.isfile(exe): raise AssertionError("Specified PENEPMA executable (%s) does not exist" % exe) if not os.access(exe, os.X_OK): raise AssertionError("Specified PENEPMA executable (%s) is not executable" % exe)
def save(self): settings = get_settings() section = settings.add_section('gui') curdir = getattr(section, 'savedir', os.getcwd()) namefilters = ';;'.join(sorted(self._save_namefilters.keys())) filepath, namefilter = \ QFileDialog.getSaveFileName(self, "Save", curdir, namefilters) if not filepath: return section.savedir = os.path.dirname(filepath) exts = self._save_namefilters[namefilter] if not any(filter(lambda ext: filepath.endswith(ext), exts)): filepath += '.' + exts[0] ext = os.path.splitext(filepath)[1][1:] method = self._save_methods.get(ext) if method is not None: method(filepath)
def autoconfig(self, programs_path): if sys.platform == 'linux': basedir_path = '/usr/share/monaco' if not os.path.exists(basedir_path): return False exe_path = '/usr/bin/mccli32' if not os.path.exists(exe_path): return False else: basedir_path = os.path.join(programs_path, self.alias) if not os.path.exists(basedir_path): return False exe_path = os.path.join(programs_path, self.alias, 'Mccli32.exe') if not os.path.exists(exe_path): return False settings = get_settings() settings.add_section('monaco').basedir = basedir_path settings.add_section('monaco').exe = exe_path return True
def validate(self): settings = get_settings() if 'xpp' not in settings: raise AssertionError("Missing 'xpp' section in settings") if 'java' not in settings.xpp: raise AssertionError("Missing 'java' option in 'xpp' section of settings") java = settings.xpp.java if not os.path.isfile(java): raise AssertionError("Specified Java executable (%s) does not exist" % java) if not os.access(java, os.X_OK): raise AssertionError("Specified Java executable (%s) is not executable" % java) if 'jar' not in settings.xpp: raise AssertionError("Missing 'jar' option in 'xpp' section of settings") jar = settings.xpp.jar if not os.path.isfile(jar): raise AssertionError("Specified jar path (%s) does not exist" % jar) if os.path.splitext(jar)[1] != '.jar': raise AssertionError("Specified jar path (%s) is not a jar" % jar)
def closeEvent(self, event): if self.is_running(): message = 'Runner is running. Do you want to continue?' answer = QMessageBox.question(self, 'Runner', message, QMessageBox.Yes | QMessageBox.No) if answer == QMessageBox.No: event.ignore() return self.cancel() self._dlg_progress.close() settings = get_settings() section = settings.add_section('gui') path = self._txt_outputdir.path() if path: section.outputdir = path section.maxworkers = str(self._spn_workers.value()) section.overwrite = str(self._chk_overwrite.isChecked()) settings.write() event.accept()
def __init__(self): """ Creates a exporter to PENEPMA. """ try: pendbase = get_settings().penepma.pendbase except AttributeError: pendbase = None _Exporter.__init__(self, pendbase) self._beam_exporters[GaussianBeam] = self._export_dummy self._detector_exporters[BackscatteredElectronEnergyDetector] = self._export_dummy self._detector_exporters[TransmittedElectronEnergyDetector] = self._export_dummy self._detector_exporters[PhotonSpectrumDetector] = self._export_dummy self._detector_exporters[PhotonIntensityDetector] = self._export_dummy self._detector_exporters[PhotonDepthDetector] = self._export_dummy self._detector_exporters[ElectronFractionDetector] = self._export_dummy self._detector_exporters[TimeDetector] = self._export_dummy self._detector_exporters[ShowersStatisticsDetector] = self._export_dummy self._limit_exporters[ShowersLimit] = self._export_dummy self._limit_exporters[TimeLimit] = self._export_dummy self._limit_exporters[UncertaintyLimit] = self._export_dummy
def _onOpen(self): settings = get_settings() curdir = getattr(settings.gui, 'opendir', os.getcwd()) filepath, namefilter = \ QFileDialog.getOpenFileName(self, "Open", curdir, 'Options [*.xml] (*.xml)') if not filepath or not namefilter: return settings.gui.opendir = os.path.dirname(filepath) if not filepath.endswith('.xml'): filepath += '.xml' self._options_reader_thread = _OptionsReaderWrapperThread(filepath) self._dlg_progress.canceled.connect(self._onDialogProgressCancel) self._options_reader_thread.resultReady.connect(self._onOpened) self._options_reader_thread.progressUpdated.connect(self._onDialogProgressProgress) self._options_reader_thread.exceptionRaised.connect(self._onDialogProgressException) self._options_reader_thread.start() self._dlg_progress.reset() self._dlg_progress.show()
def validate(self): settings = get_settings() if 'monaco' not in settings: raise AssertionError("Missing 'monaco' section in settings") if 'basedir' not in settings.monaco: raise AssertionError("Missing 'basedir' option in 'monaco' section of settings") basedir = settings.monaco.basedir if not os.path.isdir(basedir): raise AssertionError("Specified Monaco base directory (%s) does not exist" % basedir) try: mccli32_exe = settings.monaco.exe except AttributeError: filename = 'Mccli32' if os.name == 'nt': filename += '.exe' mccli32_exe = os.path.join(settings.monaco.basedir, filename) if not os.path.isfile(mccli32_exe): raise AssertionError("No Mccli32.exe in Monaco base directory (%s)" % basedir) if not os.access(mccli32_exe, os.X_OK): raise AssertionError("Specified Monaco executable (%s) is not executable" % mccli32_exe)
def setUp(self): TestCase.setUp(self) self.tmpdir = tempfile.mkdtemp() self.e = Exporter(get_settings().penepma.pendbase) self.c = Converter()
def run(argv=None): # Initialize console = Console() console.init() programs = get_settings().get_programs() parser = create_parser(programs) # Parse arguments (values, args) = parser.parse_args(argv) # Check inputs outputdir = values.outputdir if not os.path.exists(outputdir): console.print_error("The specified output directory (%s) does not exist" % outputdir) workdir = values.workdir if workdir is not None and not os.path.exists(workdir): console.print_error("The specified work directory (%s) does not exist" % workdir) if values.verbose: logging.getLogger().setLevel(logging.DEBUG) quiet = values.quiet nbprocesses = values.nbprocesses if nbprocesses <= 0: parser.error("Number of processes must be greater than 0.") overwrite = not values.skip max_iterations = values.max_iterations if max_iterations < 0: raise ValueError, 'Maximum number of iterations must be greater or equal to 0' convergence_limit = values.convergence_limit if convergence_limit <= 0.0: raise ValueError, 'Convergence limit must be greater than 0.0' if values.linear: iterator_class = SimpleIterator elif values.pouchou1991: iterator_class = Pouchou1991Iterator elif values.wegstein1958: iterator_class = Wegstein1958Iterator else: iterator_class = Heinrich1972Iterator if values.kratio: convergor_class = KRatioConvergor else: convergor_class = CompositionConvergor if values.fluorescence: calculator_class = FluorescenceCalculator else: calculator_class = SimpleCalculator aliases = map(attrgetter('alias'), programs) selected_programs = [alias for alias in aliases if getattr(values, alias)] if not selected_programs: console.print_error("Please select one Monte Carlo program") if len(selected_programs) > 1: console.print_error("Please select only one Monte Carlo program") selected_program = selected_programs[0] workers = dict(zip(aliases, map(attrgetter('worker'), programs))) worker_class = workers[selected_program] measurements = [] try: load_measurements(args, measurements) except Exception as ex: console.print_error(str(ex)) if not measurements: console.print_error("Please specify a measurement file") # Setup runner = Runner(worker_class, iterator_class, convergor_class, calculator_class, outputdir, workdir, overwrite, max_iterations, nbprocesses, limit=convergence_limit) progressbar = ProgressBar(console, len(measurements)) if not quiet: progressbar.start() runner.start() for measurement in measurements: runner.put(measurement) try: while runner.is_alive(): counter, progress, status = runner.report() if not quiet: progressbar.update(counter, progress, status) time.sleep(1) except Exception as ex: console.print_error('%s - %s' % (ex.__class__.__name__, str(ex))) runner.stop() if not quiet: progressbar.close() # Clean up console.close()
def run(argv=None): # Initialize console = Console() console.init() programs = get_settings().get_programs() parser = _create_parser(programs) # Parse arguments (values, args) = parser.parse_args(argv) # Check inputs outputdir = values.outputdir if not os.path.exists(outputdir): console.print_error( "The specified output directory (%s) does not exist" % outputdir) workdir = values.workdir if workdir is not None and not os.path.exists(workdir): console.print_error( "The specified work directory (%s) does not exist" % workdir) if values.verbose: logging.getLogger().setLevel(logging.DEBUG) quiet = values.quiet nbprocesses = values.nbprocesses if nbprocesses <= 0: parser.error("Number of processes must be greater than 0.") overwrite = not values.skip aliases = dict(zip(map(attrgetter('alias'), programs), programs)) selected_aliases = [alias for alias in aliases if getattr(values, alias)] if not selected_aliases: console.print_error("Please select one Monte Carlo program") selected_programs = list(map(aliases.get, selected_aliases)) list_options = [] try: _load(args, list_options) except Exception as ex: console.print_error(str(ex)) if not list_options: console.print_error("Please specify at least one options file") # Setup runner = LocalRunner(outputdir, workdir, overwrite, nbprocesses) progressbar = ProgressBar(console) if not quiet: progressbar.start() # Start simulation with runner: for options in list_options: options.programs.update(selected_programs) runner.put(options) try: while runner.is_alive() and not runner.is_finished(): if not quiet: progressbar.update(runner.progress, runner.status) time.sleep(1) except Exception as ex: console.print_exception(ex) runner.close() if not quiet: progressbar.close() # Clean up console.close()
def __init__(self, parent=None): QDialog.__init__(self, parent) self.setWindowTitle('Runner') self.setMinimumWidth(750) # Runner self._runner = None self._running_timer = QTimer() self._running_timer.setInterval(500) # Widgets self._dlg_progress = QProgressDialog() self._dlg_progress.setRange(0, 100) self._dlg_progress.setModal(True) self._dlg_progress.hide() lbl_outputdir = QLabel("Output directory") self._txt_outputdir = DirBrowseWidget() max_workers = cpu_count() #@UndefinedVariable lbl_workers = QLabel('Number of workers') self._spn_workers = QSpinBox() self._spn_workers.setRange(1, max_workers) self._spn_workers.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) lbl_max_workers = QLabel('(max: %i)' % max_workers) self._chk_overwrite = QCheckBox("Overwrite existing results in output directory") self._chk_overwrite.setChecked(True) self._lbl_available = QLabel('Available') self._lst_available = QListView() self._lst_available.setModel(_AvailableOptionsListModel()) self._lst_available.setSelectionMode(QListView.SelectionMode.MultiSelection) tlb_available = QToolBar() spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) tlb_available.addWidget(spacer) act_open = tlb_available.addAction(getIcon("document-open"), "Open") act_open.setShortcut(QKeySequence.Open) tlb_available.addSeparator() act_remove = tlb_available.addAction(getIcon("list-remove"), "Remove") act_clear = tlb_available.addAction(getIcon("edit-clear"), "Clear") self._btn_addtoqueue = QPushButton(getIcon("go-next"), "") self._btn_addtoqueue.setToolTip("Add to queue") self._btn_addtoqueue.setEnabled(False) self._btn_addalltoqueue = QPushButton(getIcon("go-last"), "") self._btn_addalltoqueue.setToolTip("Add all to queue") self._btn_addalltoqueue.setEnabled(False) self._lbl_options = QLabel('Queued/Running/Completed') self._tbl_options = QTableView() self._tbl_options.setModel(_StateOptionsTableModel()) self._tbl_options.setItemDelegate(_StateOptionsItemDelegate()) self._tbl_options.setSelectionMode(QListView.SelectionMode.NoSelection) self._tbl_options.setColumnWidth(1, 60) self._tbl_options.setColumnWidth(2, 80) header = self._tbl_options.horizontalHeader() header.setResizeMode(0, QHeaderView.Interactive) header.setResizeMode(1, QHeaderView.Fixed) header.setResizeMode(2, QHeaderView.Fixed) header.setResizeMode(3, QHeaderView.Stretch) self._btn_start = QPushButton(getIcon("media-playback-start"), "Start") self._btn_cancel = QPushButton("Cancel") self._btn_cancel.setEnabled(False) self._btn_close = QPushButton("Close") self._btn_import = QPushButton("Import") self._btn_import.setEnabled(False) # Layouts layout = QVBoxLayout() sublayout = QGridLayout() sublayout.addWidget(lbl_outputdir, 0, 0) sublayout.addWidget(self._txt_outputdir, 0, 1) sublayout.addWidget(lbl_workers, 1, 0) subsublayout = QHBoxLayout() subsublayout.addWidget(self._spn_workers) subsublayout.addWidget(lbl_max_workers) sublayout.addLayout(subsublayout, 1, 1) layout.addLayout(sublayout) sublayout.addWidget(self._chk_overwrite, 2, 0, 1, 3) sublayout = QGridLayout() sublayout.setColumnStretch(0, 1) sublayout.setColumnStretch(2, 3) sublayout.addWidget(self._lbl_available, 0, 0) sublayout.addWidget(self._lst_available, 1, 0) sublayout.addWidget(tlb_available, 2, 0) subsublayout = QVBoxLayout() subsublayout.addStretch() subsublayout.addWidget(self._btn_addtoqueue) subsublayout.addWidget(self._btn_addalltoqueue) subsublayout.addStretch() sublayout.addLayout(subsublayout, 1, 1) sublayout.addWidget(self._lbl_options, 0, 2) sublayout.addWidget(self._tbl_options, 1, 2) layout.addLayout(sublayout) sublayout = QHBoxLayout() sublayout.addStretch() sublayout.addWidget(self._btn_import) sublayout.addWidget(self._btn_start) sublayout.addWidget(self._btn_cancel) sublayout.addWidget(self._btn_close) layout.addLayout(sublayout) self.setLayout(layout) # Signal self._running_timer.timeout.connect(self._onRunningTimer) act_open.triggered.connect(self._onOpen) act_remove.triggered.connect(self._onRemove) act_clear.triggered.connect(self._onClear) self._btn_addtoqueue.released.connect(self._onAddToQueue) self._btn_addalltoqueue.released.connect(self._onAddAllToQueue) self._btn_start.released.connect(self._onStart) self._btn_cancel.released.connect(self._onCancel) self._btn_close.released.connect(self._onClose) self._btn_import.released.connect(self._onImport) self.options_added.connect(self._onOptionsAdded) self.options_running.connect(self._onOptionsRunning) self.options_simulated.connect(self._onOptionsSimulated) self.options_error.connect(self._onOptionsError) self.results_error.connect(self._onResultsError) # Defaults settings = get_settings() section = settings.add_section('gui') if hasattr(section, 'outputdir'): self._txt_outputdir.setPath(section.outputdir) if hasattr(section, 'maxworkers'): self._spn_workers.setValue(int(section.maxworkers)) if hasattr(section, 'overwrite'): state = True if section.overwrite.lower() == 'true' else False self._chk_overwrite.setChecked(state)