def run(self, args, extra_args): if args.output_file is not None: output_file = os.path.realpath(args.output_file) else: output_file = os.path.realpath(args.input_protocol) additional_files = [] if args.additional_files: for file in args.additional_files: additional_files.append(np.genfromtxt(file)) protocol = mdt.load_protocol(os.path.realpath(args.input_protocol)) context_dict = { name: protocol.get_column(name) for name in protocol.column_names } exec(args.expr, {'np': np, 'files': additional_files}, context_dict) for key in context_dict: if is_scalar(context_dict[key]): context_dict[key] = np.ones( protocol.length) * context_dict[key] protocol = Protocol(context_dict) mdt.write_protocol(protocol, output_file)
def run(self, args): if args.output_file is not None: output_file = os.path.realpath(args.output_file) else: output_file = os.path.realpath(args.input_protocol) protocol = mdt.load_protocol(os.path.realpath(args.input_protocol)) context_dict = { name: protocol.get_column(name) for name in protocol.column_names } def rm(column_name): protocol.remove_column(column_name) del context_dict[column_name] def add(column_name, value): protocol.add_column(column_name, value) context_dict[column_name] = value exec(args.expr, {'np': np, 'rm': rm, 'add': add}, context_dict) for name, value in context_dict.items(): protocol.update_column(name, value) mdt.write_protocol(protocol, output_file)
def run(self, args, extra_args): protocol_base = os.path.join( os.path.dirname(os.path.realpath(args.protocol)), os.path.splitext(os.path.basename(args.protocol))[0]) if args.bvec: bvec = os.path.realpath(args.bvec) else: bvec = protocol_base + '.bvec' if args.bval: bval = os.path.realpath(args.bval) else: bval = protocol_base + '.bval' write_bvec_bval(mdt.load_protocol(os.path.realpath(args.protocol)), bvec, bval)
def create_simulations(protocol_name, model_name): output_pjoin = pjoin.create_extended(protocol_name, model_name) if os.path.exists(output_pjoin()): return else: output_pjoin.make_dirs() model = mdt.get_model(model_name)(volume_selection=False) param_names = model.get_free_param_names() model_config = simulations[model_name] parameters = create_parameter_combinations(10000, [ param_names.index(name) for name in model_config['randomize_parameters'] ], model.get_initial_parameters(), model_config['lower_bounds'], model_config['upper_bounds'], seed=0) if model_config['prepare_params_cube_cb'] is not None: model_config['prepare_params_cube_cb'](parameters) simulated_signals = mdt.simulate_signals( model, mdt.load_protocol(pjoin(protocol_name)), parameters) mdt.write_nifti(parameters[None, :, None, :], output_pjoin('original_parameters.nii')) mdt.write_nifti(simulated_signals[None, :, None, :], output_pjoin('simulated_signals.nii')) for snr in noise_snrs: noisy_signals = mdt.add_rician_noise(simulated_signals, unweighted_signal_height / snr, seed=0) mdt.write_nifti(noisy_signals[None, :, None, :], output_pjoin('noisy_signals_{}.nii'.format(snr))) mdt.create_blank_mask( output_pjoin('noisy_signals_{}.nii'.format(noise_snrs[0])), output_pjoin('mask.nii'))
def run_model(self): model = mdt.get_model(self.modelSelection.currentText()) protocol = mdt.load_protocol(self.selectedProtocol.text()) if not model.is_protocol_sufficient(protocol): msg = ProtocolWarningBox(model.get_protocol_problems(protocol)) msg.exec_() return self._run_model_worker.set_args( model, mdt.load_problem_data(self.selectedDWI.text(), self.selectedProtocol.text(), self.selectedMask.text(), noise_std=self._optim_options.noise_std), self.selectedOutputFolder.text(), recalculate=True, double_precision=self._optim_options.double_precision, only_recalculate_last=not self._optim_options.recalculate_all, optimizer=self._optim_options.get_optimizer(), save_user_script_info=False) self._computations_thread.start() self._run_model_worker.moveToThread(self._computations_thread) self._run_model_worker.starting.connect( self._computations_thread.starting) self._run_model_worker.finished.connect( self._computations_thread.finished) self._run_model_worker.starting.connect( lambda: self.runButton.setEnabled(False)) self._run_model_worker.finished.connect( lambda: self.runButton.setEnabled(True)) self._run_model_worker.finished.connect( lambda: self._shared_state.set_output_folder( self._get_full_model_output_path())) self._run_model_worker.starting.emit()
def run(self, args, extra_args): protocol = mdt.load_protocol(os.path.realpath(args.protocol)) self.print_info(protocol)