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)
