def fitting_request_action(request, idNum):
print 'USERNAME: '******'Authenticated: ', request.user.is_authenticated()
print 'Request: ', request.POST
if request.user.is_authenticated() and (request.user.username == str(idNum) or request.user.is_superuser):
try:
actionID = request.POST['actionID']
actionName = request.POST['actionName']
except (KeyError):
return HttpResponse('No POST data')
print 'You are trying to request the following action: ' + actionName + ' [ID: ' + actionID + ']'
if actionID == '1':
xData = simplejson.loads(request.POST['xData'])
yData = simplejson.loads(request.POST['yData'])
functionID = int(request.POST['functionID'])
request.session['xData'] = xData
request.session['yData'] = yData
request.session['functionID'] = functionID
addlParams = { 'xData': xData, 'yData': yData, 'functionID': functionID, 'actionID': 2 }
request.session['addlParams'] = addlParams
fitInstructions = getFitInstructions(functionID)
nextFitInstruction = fitInstructions.popleft()
request.session['fitInstructions'] = fitInstructions
response = fitInstructionResponse(nextFitInstruction, addlParams)
return HttpResponse(response)
elif actionID == '2':
# Data Types
if request.POST['dataType'] == 'askPoint':
request = defPoint(request)
elif request.POST['dataType'] == 'askDrag':
request = defPoint(request)
xData = request.session['xData']
yData = request.session['yData']
functionID = request.session['functionID']
functionParams = getFunctionParams(functionID, request)
dragFit = createFunction(xData, yData, functionID, functionParams)
dragFit.update({ 'dataType': 'doingDrag' })
return HttpResponse(simplejson.dumps(dragFit))
if not request.session['fitInstructions']:
xData = request.session['xData']
yData = request.session['yData']
functionID = request.session['functionID']
functionParams = getFunctionParams(functionID, request)
finishedFunction = createFunction(xData, yData, functionID, functionParams)
return HttpResponse(simplejson.dumps(finishedFunction))
else:
#guess width
#guessWidth = guess_width(xData, yData, peakX, peakY, backgroundY)
#guessWidth2 = guess_width2(xData, yData, peakX, peakY, backgroundY)
nextFitInstruction = request.session['fitInstructions'].popleft()
response = fitInstructionResponse(nextFitInstruction, request.session['addlParams'])
return HttpResponse(response)
elif actionID == '3':
dataData = simplejson.loads(request.POST['dataData'])
xData = dataData['x']
yData = dataData['y']
yErrData = dataData['yerr']
functionData = simplejson.loads(request.POST['functionData'])
functionID = int(request.POST['functionID'])
functionParams = simplejson.loads(request.POST['functionParams'])
params = paramsDictToArray(functionID, functionParams)
functkw = { 'xData': xData, 'yData': yData, 'yErr': yErrData, 'functionID': functionID }
mpfitResult = mpfit(mpfitFunction, params, functkw=functkw)
fitFunctionParams = paramsArrayToDict(functionID, mpfitResult.params)
finishedFit = createFunction(xData, yData, functionID, fitFunctionParams)
chiSquared = sigfig(chisq(xData, yData, yErrData, functionID, fitFunctionParams))
# Map sigfig
fitFunctionParams = paramsArrayToDict(functionID, map(sigfig, mpfitResult.params))
fitFunctionParamsErr = paramsArrayToDict(functionID, map(sigfig, mpfitResult.perror))
fitFunctionParamsArray = paramsJoin(fitFunctionParams, fitFunctionParamsErr)
functionInfo = { 'fitFunctionParams': fitFunctionParams, 'fitFunctionParamsErr': fitFunctionParamsErr, 'chisq': chiSquared,
'fitFunctionParamsArray': fitFunctionParamsArray }
response = finishedFit
response.update({ 'legendIndex': request.POST['legendIndex'], 'functionInfo': functionInfo, 'dataType': 'doFit' })
return HttpResponse(simplejson.dumps(response))
else:
return HttpResponse('actionID not correct; it was ' + actionID)
else:
return HttpResponse('Not authenticated.')
def fitting_request_action(request, idNum):
"""handles all server requests having to do with fitting"""
print 'USERNAME: '******'Authenticated: ', request.user.is_authenticated()
#print 'Request: ', request.POST
if request.user.is_authenticated() and (request.user.username == str(idNum)
or request.user.is_superuser):
try:
actionID = request.POST['actionID']
actionName = request.POST['actionName']
except (KeyError):
return HttpResponse('No POST data')
print 'You are trying to request the following action: ' + actionName + ' [ID: ' + actionID + ']'
if actionID == '1':
"""ID 1: Creating a new function or adding it to a previous function"""
data = simplejson.loads(request.POST['data'])
prevFunctions = simplejson.loads(request.POST['prevFunctions'])
replaceIndices = simplejson.loads(request.POST['replaceIndices'])
xData = simplejson.loads(request.POST['data'])['x']
yData = simplejson.loads(request.POST['data'])['y']
functionID = int(request.POST['functionID'])
function = getFunctionClass(functionID)()
request.session['replaceIndices'] = replaceIndices
request.session['xData'] = xData
request.session['yData'] = yData
request.session['functionID'] = functionID
request.session['function'] = function
"""Populates a new function group with all previous functions"""
functionGroup = FunctionGroup()
functionGroup.data = data
if len(prevFunctions):
for prevFunctionInfo in prevFunctions:
prevFunction = getFunctionClass(
prevFunctionInfo['functionID'])()
prevFunction.setFunctionParamsFromArrayOfDicts(
prevFunctionInfo['functionParams'])
functionGroup.functions.append(prevFunction)
functionGroup.functions.append(function)
request.session['functionGroup'] = functionGroup
print functionGroup.functions
print '^^^^^^^^^^^^^^'
addlParams = {
'functionID': functionID,
'actionID': 2
} # 'xData': xData, 'yData': yData,
request.session['addlParams'] = addlParams
"""Sends the first fitting instruction to the client"""
nextFitInstruction = function.fitInstructions.popleft()
if nextFitInstruction['dataType'] == 'askDrag':
nextFitInstruction.update({'dragMode': 'before'})
response = fitInstructionResponse(nextFitInstruction, addlParams)
response.update({'replaceIndices': replaceIndices})
return HttpResponse(simplejson.dumps(response))
elif actionID == '2':
"""ID 2: Handles responses to fitting instructions after the first one is sent by ID 1"""
xData = request.session['xData']
yData = request.session['yData']
function = request.session['function']
functionGroup = request.session['functionGroup']
# Data Types
if request.POST['dataType'] == 'askPoint':
request = functionGroup.defPoint(request)
elif request.POST['dataType'] == 'askDrag':
"""If you are in the middle of doing a drag send the updated function"""
request = functionGroup.defPoint(request)
dragFit = functionGroup.createFunction(xData, yData)
dragFit.update({
'dataType':
'doingDrag',
'replaceIndices':
request.session['replaceIndices'],
'dragMode':
str(request.POST['dragMode'])
})
return HttpResponse(str(dragFit))
"""If there are no more instructions then you calculate the final function"""
if not request.session['function'].fitInstructions:
#function.setFunctionParamsFromRequest(request)
# Update most recent function (maybe this is wrong)
#functionGroup.functions[-1] = function
finishedFunction = functionGroup.createFunction(xData, yData)
print finishedFunction
print '############'
response = finishedFunction
response.update(
{'replaceIndices': request.session['replaceIndices']})
return HttpResponse(str(response))
else:
"""Otherwise you send the next instruction"""
#guess width
#guessWidth = guess_width(xData, yData, peakX, peakY, bkgdY)
#guessWidth2 = guess_width2(xData, yData, peakX, peakY, bkgdY)
nextFitInstruction = function.fitInstructions.popleft()
if nextFitInstruction['dataType'] == 'askDrag':
nextFitInstruction.update({'dragMode': 'before'})
response = fitInstructionResponse(
nextFitInstruction, request.session['addlParams'])
response.update(
{'replaceIndices': request.session['replaceIndices']})
return HttpResponse(str(response))
elif actionID == '4':
allData = simplejson.loads(request.POST['allData'])
dataData = allData[0]
xData = N.array(dataData['x'])
yData = N.array(dataData['y'])
yErrData = N.array(dataData['yerr'])
"""Find peaks in the data"""
kernel = 21
nmin, nlist, plist = findpeak4.find_npeaks(xData, yData, yErrData,
kernel)
results = findpeak4.findpeak(xData,
yData,
nmin,
order=4,
kernel=kernel)
fwhm = findpeak4.findwidths(xData, yData, nmin, results['xpeaks'],
results['indices'])
"""Generate a composite function with Gaussians for every peak found"""
functionGroup = FunctionGroup()
functionGroup.data = dataData
for resultsIndex in range(len(results['indices'])):
dataIndex = results['indices'][resultsIndex]
function = Gaussian()
functionParams = {
'peakX': xData[dataIndex],
'peakY': yData[dataIndex],
'FWHM': fwhm[resultsIndex]
}
function.setFunctionParamsFromDict(functionParams)
functionGroup.functions.append(function)
"""And a linear background too"""
linearBackground = Linear()
twoPoints = {
'X1': xData[0],
'X2': xData[-1],
'Y1': yData[0],
'Y2': yData[-1]
}
linearBackground.setFunctionParamsFromTwoPoints(twoPoints)
functionGroup.functions.append(linearBackground)
"""Converts the parameters from a set of dictionaries to a flat list"""
(params, slices) = functionGroup.getFunctionsParamsAsArray()
"""Uses mpfit to fit the function using the specified parameter list"""
functkw = {
'xData': xData,
'yData': yData,
'yErr': yErrData,
'functionGroup': functionGroup,
'slices': slices
}
mpfitResult = mpfit(mpfitFunction,
params,
functkw=functkw,
ftol=1e-5)
"""Calculate the new function with the best fitted parameters and chi-squared"""
functionGroup.setFunctionsParamsFromArray(mpfitResult.params,
slices)
finishedFit = functionGroup.createFunction(xData, yData)
chiSquared = sigfig(functionGroup.chisq(xData, yData, yErrData))
"""Formats the parameters and the parameter errors to send to the client"""
fitFunctionInfos = functionGroup.getFitFunctionInfos(mpfitResult)
"""Sends the function and parameters to the client"""
response = finishedFit
response.update({
'functionInfos': fitFunctionInfos,
'fitInfo': {
'chisq': chiSquared
},
'dataType': 'doFit'
})
return HttpResponse(str(response))
elif actionID == '3':
"""This is when the fitting occurs"""
allData = simplejson.loads(request.POST['allData'])
dataData = allData[0]
xData = dataData['x']
yData = dataData['y']
yErrData = dataData['yerr']
#functionData = simplejson.loads(request.POST['functionData']) # Not used at all
"""Gets all the previous functions here and populates the function group"""
allFunctionInfos = simplejson.loads(
request.POST['allFunctionInfos'])
functionGroup = FunctionGroup()
functionGroup.data = dataData
for functionInfos in allFunctionInfos:
for functionInfo in functionInfos:
print functionInfo
functionID = int(functionInfo['functionID'])
functionParams = functionInfo['functionParams']
function = getFunctionClass(functionID)()
function.setFunctionParamsFromArrayOfDicts(functionParams)
functionGroup.functions.append(function)
"""Converts the parameters from a set of dictionaries to a flat list"""
(params, slices) = functionGroup.getFunctionsParamsAsArray()
"""Uses mpfit to fit the function using the specified parameter list"""
functkw = {
'xData': xData,
'yData': yData,
'yErr': yErrData,
'functionGroup': functionGroup,
'slices': slices
}
mpfitResult = mpfit(mpfitFunction,
params,
functkw=functkw,
ftol=1e-5)
"""Calculate the new function with the best fitted parameters and chi-squared"""
functionGroup.setFunctionsParamsFromArray(mpfitResult.params,
slices)
finishedFit = functionGroup.createFunction(xData, yData)
chiSquared = sigfig(functionGroup.chisq(xData, yData, yErrData))
"""Formats the parameters and the parameter errors to send to the client"""
fitFunctionInfos = functionGroup.getFitFunctionInfos(mpfitResult)
"""Sends the function and parameters to the client"""
response = finishedFit
response.update({
'functionInfos':
fitFunctionInfos,
'fitInfo': {
'chisq': chiSquared
},
'replaceIndices':
simplejson.loads(request.POST['replaceIndices']),
'dataType':
'doFit'
})
return HttpResponse(str(response))
else:
return HttpResponse('actionID not correct; it was ' + actionID)
else:
return HttpResponse('Not authenticated.')
def fitting_request_action(request, idNum):
"""handles all server requests having to do with fitting"""
print 'USERNAME: '******'Authenticated: ', request.user.is_authenticated()
#print 'Request: ', request.POST
if request.user.is_authenticated() and (request.user.username == str(idNum) or request.user.is_superuser):
try:
actionID = request.POST['actionID']
actionName = request.POST['actionName']
except (KeyError):
return HttpResponse('No POST data')
print 'You are trying to request the following action: ' + actionName + ' [ID: ' + actionID + ']'
if actionID == '1':
"""ID 1: Creating a new function or adding it to a previous function"""
data = simplejson.loads(request.POST['data'])
prevFunctions = simplejson.loads(request.POST['prevFunctions'])
replaceIndices = simplejson.loads(request.POST['replaceIndices'])
xData = simplejson.loads(request.POST['data'])['x']
yData = simplejson.loads(request.POST['data'])['y']
functionID = int(request.POST['functionID'])
function = getFunctionClass(functionID)()
request.session['replaceIndices'] = replaceIndices
request.session['xData'] = xData
request.session['yData'] = yData
request.session['functionID'] = functionID
request.session['function'] = function
"""Populates a new function group with all previous functions"""
functionGroup = FunctionGroup()
functionGroup.data = data
if len(prevFunctions):
for prevFunctionInfo in prevFunctions:
prevFunction = getFunctionClass(prevFunctionInfo['functionID'])()
prevFunction.setFunctionParamsFromArrayOfDicts(prevFunctionInfo['functionParams'])
functionGroup.functions.append(prevFunction)
functionGroup.functions.append(function)
request.session['functionGroup'] = functionGroup
print functionGroup.functions
print '^^^^^^^^^^^^^^'
addlParams = { 'functionID': functionID, 'actionID': 2 } # 'xData': xData, 'yData': yData,
request.session['addlParams'] = addlParams
"""Sends the first fitting instruction to the client"""
nextFitInstruction = function.fitInstructions.popleft()
if nextFitInstruction['dataType'] == 'askDrag':
nextFitInstruction.update({ 'dragMode': 'before' })
response = fitInstructionResponse(nextFitInstruction, addlParams)
response.update({ 'replaceIndices': replaceIndices })
return HttpResponse(simplejson.dumps(response))
elif actionID == '2':
"""ID 2: Handles responses to fitting instructions after the first one is sent by ID 1"""
xData = request.session['xData']
yData = request.session['yData']
function = request.session['function']
functionGroup = request.session['functionGroup']
# Data Types
if request.POST['dataType'] == 'askPoint':
request = functionGroup.defPoint(request)
elif request.POST['dataType'] == 'askDrag':
"""If you are in the middle of doing a drag send the updated function"""
request = functionGroup.defPoint(request)
dragFit = functionGroup.createFunction(xData, yData)
dragFit.update({ 'dataType': 'doingDrag', 'replaceIndices': request.session['replaceIndices'],
'dragMode': str(request.POST['dragMode']) })
return HttpResponse(str(dragFit))
"""If there are no more instructions then you calculate the final function"""
if not request.session['function'].fitInstructions:
#function.setFunctionParamsFromRequest(request)
# Update most recent function (maybe this is wrong)
#functionGroup.functions[-1] = function
finishedFunction = functionGroup.createFunction(xData, yData)
print finishedFunction
print '############'
response = finishedFunction
response.update({ 'replaceIndices': request.session['replaceIndices'] })
return HttpResponse(str(response))
else:
"""Otherwise you send the next instruction"""
#guess width
#guessWidth = guess_width(xData, yData, peakX, peakY, bkgdY)
#guessWidth2 = guess_width2(xData, yData, peakX, peakY, bkgdY)
nextFitInstruction = function.fitInstructions.popleft()
if nextFitInstruction['dataType'] == 'askDrag':
nextFitInstruction.update({ 'dragMode': 'before' })
response = fitInstructionResponse(nextFitInstruction, request.session['addlParams'])
response.update({ 'replaceIndices': request.session['replaceIndices'] })
return HttpResponse(str(response))
elif actionID == '4':
allData = simplejson.loads(request.POST['allData'])
dataData = allData[0]
xData = N.array(dataData['x'])
yData = N.array(dataData['y'])
yErrData = N.array(dataData['yerr'])
"""Find peaks in the data"""
kernel = 21
nmin, nlist, plist = findpeak4.find_npeaks(xData, yData, yErrData, kernel)
results = findpeak4.findpeak (xData, yData, nmin, order=4, kernel=kernel)
fwhm = findpeak4.findwidths(xData, yData, nmin, results['xpeaks'], results['indices'])
"""Generate a composite function with Gaussians for every peak found"""
functionGroup = FunctionGroup()
functionGroup.data = dataData
for resultsIndex in range(len(results['indices'])):
dataIndex = results['indices'][resultsIndex]
function = Gaussian()
functionParams = { 'peakX': xData[dataIndex], 'peakY': yData[dataIndex], 'FWHM': fwhm[resultsIndex] }
function.setFunctionParamsFromDict(functionParams)
functionGroup.functions.append(function)
"""And a linear background too"""
linearBackground = Linear()
twoPoints = { 'X1': xData[0], 'X2': xData[-1], 'Y1': yData[0], 'Y2': yData[-1] }
linearBackground.setFunctionParamsFromTwoPoints(twoPoints)
functionGroup.functions.append(linearBackground)
"""Converts the parameters from a set of dictionaries to a flat list"""
(params, slices) = functionGroup.getFunctionsParamsAsArray()
"""Uses mpfit to fit the function using the specified parameter list"""
functkw = { 'xData': xData, 'yData': yData, 'yErr': yErrData, 'functionGroup': functionGroup, 'slices': slices }
mpfitResult = mpfit(mpfitFunction, params, functkw=functkw, ftol=1e-5)
"""Calculate the new function with the best fitted parameters and chi-squared"""
functionGroup.setFunctionsParamsFromArray(mpfitResult.params, slices)
finishedFit = functionGroup.createFunction(xData, yData)
chiSquared = sigfig(functionGroup.chisq(xData, yData, yErrData))
"""Formats the parameters and the parameter errors to send to the client"""
fitFunctionInfos = functionGroup.getFitFunctionInfos(mpfitResult)
"""Sends the function and parameters to the client"""
response = finishedFit
response.update({ 'functionInfos': fitFunctionInfos, 'fitInfo': { 'chisq': chiSquared }, 'dataType': 'doFit' })
return HttpResponse(str(response))
elif actionID == '3':
"""This is when the fitting occurs"""
allData = simplejson.loads(request.POST['allData'])
dataData = allData[0]
xData = dataData['x']
yData = dataData['y']
yErrData = dataData['yerr']
#functionData = simplejson.loads(request.POST['functionData']) # Not used at all
"""Gets all the previous functions here and populates the function group"""
allFunctionInfos = simplejson.loads(request.POST['allFunctionInfos'])
functionGroup = FunctionGroup()
functionGroup.data = dataData
for functionInfos in allFunctionInfos:
for functionInfo in functionInfos:
print functionInfo
functionID = int(functionInfo['functionID'])
functionParams = functionInfo['functionParams']
function = getFunctionClass(functionID)()
function.setFunctionParamsFromArrayOfDicts(functionParams)
functionGroup.functions.append(function)
"""Converts the parameters from a set of dictionaries to a flat list"""
(params, slices) = functionGroup.getFunctionsParamsAsArray()
"""Uses mpfit to fit the function using the specified parameter list"""
functkw = { 'xData': xData, 'yData': yData, 'yErr': yErrData, 'functionGroup': functionGroup, 'slices': slices }
mpfitResult = mpfit(mpfitFunction, params, functkw=functkw, ftol=1e-5)
"""Calculate the new function with the best fitted parameters and chi-squared"""
functionGroup.setFunctionsParamsFromArray(mpfitResult.params, slices)
finishedFit = functionGroup.createFunction(xData, yData)
chiSquared = sigfig(functionGroup.chisq(xData, yData, yErrData))
"""Formats the parameters and the parameter errors to send to the client"""
fitFunctionInfos = functionGroup.getFitFunctionInfos(mpfitResult)
"""Sends the function and parameters to the client"""
response = finishedFit
response.update({ 'functionInfos': fitFunctionInfos, 'fitInfo': { 'chisq': chiSquared },
'replaceIndices': simplejson.loads(request.POST['replaceIndices']), 'dataType': 'doFit' })
return HttpResponse(str(response))
else:
return HttpResponse('actionID not correct; it was ' + actionID)
else:
return HttpResponse('Not authenticated.')
def fitting_request_action(request, idNum):
print 'USERNAME: '******'Authenticated: ', request.user.is_authenticated()
print 'Request: ', request.POST
if request.user.is_authenticated() and (request.user.username == str(idNum)
or request.user.is_superuser):
try:
actionID = request.POST['actionID']
actionName = request.POST['actionName']
except (KeyError):
return HttpResponse('No POST data')
print 'You are trying to request the following action: ' + actionName + ' [ID: ' + actionID + ']'
if actionID == '1':
xData = simplejson.loads(request.POST['xData'])
yData = simplejson.loads(request.POST['yData'])
functionID = int(request.POST['functionID'])
request.session['xData'] = xData
request.session['yData'] = yData
request.session['functionID'] = functionID
addlParams = {
'xData': xData,
'yData': yData,
'functionID': functionID,
'actionID': 2
}
request.session['addlParams'] = addlParams
fitInstructions = getFitInstructions(functionID)
nextFitInstruction = fitInstructions.popleft()
request.session['fitInstructions'] = fitInstructions
response = fitInstructionResponse(nextFitInstruction, addlParams)
return HttpResponse(response)
elif actionID == '2':
# Data Types
if request.POST['dataType'] == 'askPoint':
request = defPoint(request)
elif request.POST['dataType'] == 'askDrag':
request = defPoint(request)
xData = request.session['xData']
yData = request.session['yData']
functionID = request.session['functionID']
functionParams = getFunctionParams(functionID, request)
dragFit = createFunction(xData, yData, functionID,
functionParams)
dragFit.update({'dataType': 'doingDrag'})
return HttpResponse(simplejson.dumps(dragFit))
if not request.session['fitInstructions']:
xData = request.session['xData']
yData = request.session['yData']
functionID = request.session['functionID']
functionParams = getFunctionParams(functionID, request)
finishedFunction = createFunction(xData, yData, functionID,
functionParams)
return HttpResponse(simplejson.dumps(finishedFunction))
else:
#guess width
#guessWidth = guess_width(xData, yData, peakX, peakY, backgroundY)
#guessWidth2 = guess_width2(xData, yData, peakX, peakY, backgroundY)
nextFitInstruction = request.session[
'fitInstructions'].popleft()
response = fitInstructionResponse(
nextFitInstruction, request.session['addlParams'])
return HttpResponse(response)
elif actionID == '3':
dataData = simplejson.loads(request.POST['dataData'])
xData = dataData['x']
yData = dataData['y']
yErrData = dataData['yerr']
functionData = simplejson.loads(request.POST['functionData'])
functionID = int(request.POST['functionID'])
functionParams = simplejson.loads(request.POST['functionParams'])
params = paramsDictToArray(functionID, functionParams)
functkw = {
'xData': xData,
'yData': yData,
'yErr': yErrData,
'functionID': functionID
}
mpfitResult = mpfit(mpfitFunction, params, functkw=functkw)
fitFunctionParams = paramsArrayToDict(functionID,
mpfitResult.params)
finishedFit = createFunction(xData, yData, functionID,
fitFunctionParams)
chiSquared = sigfig(
chisq(xData, yData, yErrData, functionID, fitFunctionParams))
# Map sigfig
fitFunctionParams = paramsArrayToDict(
functionID, map(sigfig, mpfitResult.params))
fitFunctionParamsErr = paramsArrayToDict(
functionID, map(sigfig, mpfitResult.perror))
fitFunctionParamsArray = paramsJoin(fitFunctionParams,
fitFunctionParamsErr)
functionInfo = {
'fitFunctionParams': fitFunctionParams,
'fitFunctionParamsErr': fitFunctionParamsErr,
'chisq': chiSquared,
'fitFunctionParamsArray': fitFunctionParamsArray
}
response = finishedFit
response.update({
'legendIndex': request.POST['legendIndex'],
'functionInfo': functionInfo,
'dataType': 'doFit'
})
return HttpResponse(simplejson.dumps(response))
else:
return HttpResponse('actionID not correct; it was ' + actionID)
else:
return HttpResponse('Not authenticated.')
