def post(self, request, instrument, data_id, *args, **kwargs):
""" Add a data set to this fit problem """
_, fit_problem = view_util.get_fit_problem(request, instrument, data_id)
# If we haven't performed a fit for this particular data set, create a FitProblem
# as a placeholder so we can continue.
if fit_problem is None:
data_path = "%s/%s" % (instrument, data_id)
ref_model = ReflectivityModel(data_path=data_path)
ref_model.save()
fit_problem = FitProblem(user=request.user, reflectivity_model=ref_model)
fit_problem.save()
simultaneous_form = SimultaneousModelForm(request.POST)
if fit_problem is not None and simultaneous_form.is_valid():
# First, check if we have access to that data
instrument_, data_id_ = view_util.parse_data_path(simultaneous_form.cleaned_data['dependent_data'])
is_allowed, _ = view_util.check_permissions(request, data_id_, instrument_)
if is_allowed is False:
return redirect(reverse('fitting:private'))
SimultaneousModel.objects.create(fit_problem=fit_problem,
dependent_data=simultaneous_form.cleaned_data['dependent_data'])
# When changing the list of data sets, remove the existing SimultaneousFit object to avoid confusion
for item in SimultaneousFit.objects.filter(fit_problem=fit_problem, user=request.user):
item.delete()
return redirect(reverse('fitting:fit', args=(instrument, data_id)))
def post(self, request, instrument, data_id, *args, **kwargs):
""" Process POST request """
error_list = []
is_allowed, run_info = view_util.check_permissions(
request, data_id, instrument)
if not is_allowed:
raise Http404
try:
output = view_util.evaluate_simultaneous_fit(request,
instrument,
data_id,
run_info=run_info)
if 'error_list' in output:
error_list = output['error_list']
if 'job_id' in output:
request.session['job_id'] = output['job_id']
except:
error_list = [
"There was a problem performing your fit:<br>refresh your page.",
str(sys.exc_value)
]
if len(error_list) > 0:
breadcrumbs = "<a href='/'>home</a> › simultaneous › %s › %s" % (
instrument, data_id)
template_values = dict(breadcrumbs=breadcrumbs,
instrument=instrument,
data_id=data_id,
user_alert=error_list)
template_values = users.view_util.fill_template_values(
request, **template_values)
return render(request, 'fitting/simultaneous_view.html',
template_values)
return redirect(
reverse('fitting:simultaneous', args=(instrument, data_id)))
def get(self, request, instrument, data_id, *args, **kwargs):
"""
Process GET
:param request: request object
:param instrument: instrument name
:param data_id: data set identifier
"""
is_allowed, run_info = view_util.check_permissions(request, data_id, instrument)
if is_allowed is False:
return redirect(reverse('fitting:private'))
template_values = self._fill_template_values(request, instrument, data_id)
# Check whether we need an extra layer
default_extra = 0
try:
extra = int(request.GET.get('extra', default_extra))
except:
extra = default_extra
error_message = []
data_path, fit_problem = view_util.get_fit_problem(request, instrument, data_id)
chi2, _, errors, can_update = view_util.get_results(request, fit_problem)
error_message.extend(errors)
if fit_problem is not None:
data_form = ReflectivityFittingForm(instance=fit_problem.reflectivity_model)
else:
extra = 1
data_form = ReflectivityFittingForm(initial={'data_path': data_path})
LayerFormSet = layer_modelformset(extra=extra)
layers_form = LayerFormSet(queryset=fit_problem.layers.all().order_by('layer_number') if fit_problem is not None else ReflectivityLayer.objects.none())
job_id = request.session.get('job_id', None)
html_data, _chi2 = view_util.assemble_plots(request, instrument, data_id, fit_problem, rq4=template_values['rq4'])
template_values.update({'data_form': data_form,
'html_data': html_data,
'user_alert': error_message,
'chi2': chi2 if chi2 is not None else _chi2,
'extra': extra,
'simultaneous_form': SimultaneousModelForm(),
'simultaneous_data': SimultaneousModel.objects.filter(fit_problem=fit_problem),
'number_of_constraints': Constraint.objects.filter(fit_problem=fit_problem).count(),
'job_id': job_id if can_update else None,
'layers_form': layers_form})
template_values['run_title'] = run_info.get('title', '')
template_values['extra_tags'] = run_info.get('tags', '')
template_values = users.view_util.fill_template_values(request, **template_values)
return render(request, 'fitting/modeling.html', template_values)
def post(self, request, instrument, data_id, *args, **kwargs):
"""
Process POST
:param request: request object
:param instrument: instrument name
:param data_id: data set identifier
"""
error_message = []
# Check whether we need to redirect because the user changes the data path
data_path = request.POST.get('data_path', '')
instrument_, data_id_ = view_util.parse_data_path(data_path)
if instrument_ is not None:
instrument = instrument_
if data_id_ is not None:
data_id = data_id_
is_allowed, run_info = view_util.check_permissions(request, data_id, instrument)
if is_allowed is False:
return redirect(reverse('fitting:private'))
template_values = self._fill_template_values(request, instrument, data_id)
request.session['latest_data_path'] = data_path
html_data = data_handler.get_plot_data_from_server(instrument, data_id)
if html_data is None:
return redirect(reverse('fitting:fit', args=(instrument, data_id)))
try:
# See if we have a fit problem already
fit_problem_list = FitProblem.objects.filter(user=request.user,
reflectivity_model__data_path=data_path)
if len(fit_problem_list) > 0:
reflectivity_model = fit_problem_list.latest('timestamp').reflectivity_model
else:
reflectivity_model = None
data_form = ReflectivityFittingForm(request.POST, instance=reflectivity_model)
LayerFormSet = layer_modelformset(extra=0)
layers_form = LayerFormSet(request.POST)
# Check for invalid form
if data_form.is_valid() and layers_form.is_valid():
task = request.POST.get('button_choice', 'fit')
# Check for form submission option
output = {}
if task == "fit":
if view_util.is_fittable(data_form, layers_form):
output = view_util.evaluate_model(data_form, layers_form, html_data, fit=task == "fit", user=request.user, run_info=run_info)
if 'job_id' in output:
job_id = output['job_id']
request.session['job_id'] = job_id
else:
error_message.append("Your model needs at least one free parameter.")
else:
view_util.save_fit_problem(data_form, layers_form, None, request.user)
if 'error' in output:
error_message.append(output['error'])
if len(error_message) == 0:
return redirect(reverse('fitting:fit', args=(instrument, data_id)))
else:
error_message.append("Invalid parameters were found!")
except:
logging.error("Could not fit data: %s", sys.exc_value)
error_message.append("Could not fit data")
# If we have errors, compose the response here so that we can display the errors.
# If everything is good, just redirect to the corresponding fit page showing the current status.
if error_message:
template_values.update({'data_form': data_form,
'html_data': view_util.assemble_plots(request, instrument, data_id, None, rq4=template_values['rq4']),
'user_alert': error_message,
'instrument': instrument,
'data_id': data_id,
'layers_form': layers_form})
template_values['run_title'] = run_info.get('title', '')
template_values = users.view_util.fill_template_values(request, **template_values)
return render(request, 'fitting/modeling.html', template_values)
else:
return redirect(reverse('fitting:fit', args=(instrument, data_id)))